From f9897479d2a8a865c4033bc44ec9a85fb5000795 Mon Sep 17 00:00:00 2001
From: cAttte <26514199+cAttte@users.noreply.github.com>
Date: Thu, 12 Jun 2025 11:09:37 -0300
Subject: [PATCH 001/101] Unify `EvalMode` and `LexMode` into `SyntaxMode`
 (#6432)

---
 crates/typst-cli/src/query.rs                 |  6 +--
 crates/typst-eval/src/lib.rs                  | 17 ++++----
 crates/typst-library/src/foundations/cast.rs  | 17 +++++++-
 crates/typst-library/src/foundations/mod.rs   |  6 +--
 .../typst-library/src/model/bibliography.rs   |  6 +--
 crates/typst-library/src/routines.rs          | 15 +------
 crates/typst-syntax/src/lexer.rs              | 37 ++++++----------
 crates/typst-syntax/src/lib.rs                | 13 +++++-
 crates/typst-syntax/src/parser.rs             | 43 ++++++++++---------
 9 files changed, 82 insertions(+), 78 deletions(-)

diff --git a/crates/typst-cli/src/query.rs b/crates/typst-cli/src/query.rs
index 7806e456f..b1a446203 100644
--- a/crates/typst-cli/src/query.rs
+++ b/crates/typst-cli/src/query.rs
@@ -5,9 +5,9 @@ use typst::diag::{bail, HintedStrResult, StrResult, Warned};
 use typst::engine::Sink;
 use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
 use typst::layout::PagedDocument;
-use typst::syntax::Span;
+use typst::syntax::{Span, SyntaxMode};
 use typst::World;
-use typst_eval::{eval_string, EvalMode};
+use typst_eval::eval_string;
 
 use crate::args::{QueryCommand, SerializationFormat};
 use crate::compile::print_diagnostics;
@@ -63,7 +63,7 @@ fn retrieve(
         Sink::new().track_mut(),
         &command.selector,
         Span::detached(),
-        EvalMode::Code,
+        SyntaxMode::Code,
         Scope::default(),
     )
     .map_err(|errors| {
diff --git a/crates/typst-eval/src/lib.rs b/crates/typst-eval/src/lib.rs
index 586da26be..e4bbe4f0f 100644
--- a/crates/typst-eval/src/lib.rs
+++ b/crates/typst-eval/src/lib.rs
@@ -18,7 +18,6 @@ pub use self::call::{eval_closure, CapturesVisitor};
 pub use self::flow::FlowEvent;
 pub use self::import::import;
 pub use self::vm::Vm;
-pub use typst_library::routines::EvalMode;
 
 use self::access::*;
 use self::binding::*;
@@ -32,7 +31,7 @@ use typst_library::introspection::Introspector;
 use typst_library::math::EquationElem;
 use typst_library::routines::Routines;
 use typst_library::World;
-use typst_syntax::{ast, parse, parse_code, parse_math, Source, Span};
+use typst_syntax::{ast, parse, parse_code, parse_math, Source, Span, SyntaxMode};
 
 /// Evaluate a source file and return the resulting module.
 #[comemo::memoize]
@@ -104,13 +103,13 @@ pub fn eval_string(
     sink: TrackedMut<Sink>,
     string: &str,
     span: Span,
-    mode: EvalMode,
+    mode: SyntaxMode,
     scope: Scope,
 ) -> SourceResult<Value> {
     let mut root = match mode {
-        EvalMode::Code => parse_code(string),
-        EvalMode::Markup => parse(string),
-        EvalMode::Math => parse_math(string),
+        SyntaxMode::Code => parse_code(string),
+        SyntaxMode::Markup => parse(string),
+        SyntaxMode::Math => parse_math(string),
     };
 
     root.synthesize(span);
@@ -141,11 +140,11 @@ pub fn eval_string(
 
     // Evaluate the code.
     let output = match mode {
-        EvalMode::Code => root.cast::<ast::Code>().unwrap().eval(&mut vm)?,
-        EvalMode::Markup => {
+        SyntaxMode::Code => root.cast::<ast::Code>().unwrap().eval(&mut vm)?,
+        SyntaxMode::Markup => {
             Value::Content(root.cast::<ast::Markup>().unwrap().eval(&mut vm)?)
         }
-        EvalMode::Math => Value::Content(
+        SyntaxMode::Math => Value::Content(
             EquationElem::new(root.cast::<ast::Math>().unwrap().eval(&mut vm)?)
                 .with_block(false)
                 .pack()
diff --git a/crates/typst-library/src/foundations/cast.rs b/crates/typst-library/src/foundations/cast.rs
index 73645491f..5e0ba688e 100644
--- a/crates/typst-library/src/foundations/cast.rs
+++ b/crates/typst-library/src/foundations/cast.rs
@@ -9,7 +9,7 @@ use std::ops::Add;
 
 use ecow::eco_format;
 use smallvec::SmallVec;
-use typst_syntax::{Span, Spanned};
+use typst_syntax::{Span, Spanned, SyntaxMode};
 use unicode_math_class::MathClass;
 
 use crate::diag::{At, HintedStrResult, HintedString, SourceResult, StrResult};
@@ -459,6 +459,21 @@ impl FromValue for Never {
     }
 }
 
+cast! {
+    SyntaxMode,
+    self => IntoValue::into_value(match self {
+        SyntaxMode::Markup => "markup",
+        SyntaxMode::Math => "math",
+        SyntaxMode::Code => "code",
+    }),
+    /// Evaluate as markup, as in a Typst file.
+    "markup" => SyntaxMode::Markup,
+    /// Evaluate as math, as in an equation.
+    "math" => SyntaxMode::Math,
+    /// Evaluate as code, as after a hash.
+    "code" => SyntaxMode::Code,
+}
+
 cast! {
     MathClass,
     self => IntoValue::into_value(match self {
diff --git a/crates/typst-library/src/foundations/mod.rs b/crates/typst-library/src/foundations/mod.rs
index d42be15b1..6840f855d 100644
--- a/crates/typst-library/src/foundations/mod.rs
+++ b/crates/typst-library/src/foundations/mod.rs
@@ -69,6 +69,7 @@ pub use self::ty::*;
 pub use self::value::*;
 pub use self::version::*;
 pub use typst_macros::{scope, ty};
+use typst_syntax::SyntaxMode;
 
 #[rustfmt::skip]
 #[doc(hidden)]
@@ -83,7 +84,6 @@ use typst_syntax::Spanned;
 
 use crate::diag::{bail, SourceResult, StrResult};
 use crate::engine::Engine;
-use crate::routines::EvalMode;
 use crate::{Feature, Features};
 
 /// Hook up all `foundations` definitions.
@@ -273,8 +273,8 @@ pub fn eval(
     /// #eval("1_2^3", mode: "math")
     /// ```
     #[named]
-    #[default(EvalMode::Code)]
-    mode: EvalMode,
+    #[default(SyntaxMode::Code)]
+    mode: SyntaxMode,
     /// A scope of definitions that are made available.
     ///
     /// ```example
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index a85efc810..7bfacfc66 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -16,7 +16,7 @@ use hayagriva::{
 };
 use indexmap::IndexMap;
 use smallvec::{smallvec, SmallVec};
-use typst_syntax::{Span, Spanned};
+use typst_syntax::{Span, Spanned, SyntaxMode};
 use typst_utils::{Get, ManuallyHash, NonZeroExt, PicoStr};
 
 use crate::diag::{
@@ -39,7 +39,7 @@ use crate::model::{
     CitationForm, CiteGroup, Destination, FootnoteElem, HeadingElem, LinkElem, ParElem,
     Url,
 };
-use crate::routines::{EvalMode, Routines};
+use crate::routines::Routines;
 use crate::text::{
     FontStyle, Lang, LocalName, Region, Smallcaps, SubElem, SuperElem, TextElem,
     WeightDelta,
@@ -1024,7 +1024,7 @@ impl ElemRenderer<'_> {
             Sink::new().track_mut(),
             math,
             self.span,
-            EvalMode::Math,
+            SyntaxMode::Math,
             Scope::new(),
         )
         .map(Value::display)
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs
index 6f0cb32b1..59ce83282 100644
--- a/crates/typst-library/src/routines.rs
+++ b/crates/typst-library/src/routines.rs
@@ -4,7 +4,7 @@ use std::hash::{Hash, Hasher};
 use std::num::NonZeroUsize;
 
 use comemo::{Tracked, TrackedMut};
-use typst_syntax::Span;
+use typst_syntax::{Span, SyntaxMode};
 use typst_utils::LazyHash;
 
 use crate::diag::SourceResult;
@@ -58,7 +58,7 @@ routines! {
         sink: TrackedMut<Sink>,
         string: &str,
         span: Span,
-        mode: EvalMode,
+        mode: SyntaxMode,
         scope: Scope,
     ) -> SourceResult<Value>
 
@@ -312,17 +312,6 @@ routines! {
     ) -> SourceResult<Fragment>
 }
 
-/// In which mode to evaluate a string.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
-pub enum EvalMode {
-    /// Evaluate as code, as after a hash.
-    Code,
-    /// Evaluate as markup, like in a Typst file.
-    Markup,
-    /// Evaluate as math, as in an equation.
-    Math,
-}
-
 /// Defines what kind of realization we are performing.
 pub enum RealizationKind<'a> {
     /// This the root realization for layout. Requires a mutable reference
diff --git a/crates/typst-syntax/src/lexer.rs b/crates/typst-syntax/src/lexer.rs
index 7d363d7b5..74f14cfeb 100644
--- a/crates/typst-syntax/src/lexer.rs
+++ b/crates/typst-syntax/src/lexer.rs
@@ -4,7 +4,7 @@ use unicode_script::{Script, UnicodeScript};
 use unicode_segmentation::UnicodeSegmentation;
 use unscanny::Scanner;
 
-use crate::{SyntaxError, SyntaxKind, SyntaxNode};
+use crate::{SyntaxError, SyntaxKind, SyntaxMode, SyntaxNode};
 
 /// An iterator over a source code string which returns tokens.
 #[derive(Clone)]
@@ -13,28 +13,17 @@ pub(super) struct Lexer<'s> {
     s: Scanner<'s>,
     /// The mode the lexer is in. This determines which kinds of tokens it
     /// produces.
-    mode: LexMode,
+    mode: SyntaxMode,
     /// Whether the last token contained a newline.
     newline: bool,
     /// An error for the last token.
     error: Option<SyntaxError>,
 }
 
-/// What kind of tokens to emit.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub(super) enum LexMode {
-    /// Text and markup.
-    Markup,
-    /// Math atoms, operators, etc.
-    Math,
-    /// Keywords, literals and operators.
-    Code,
-}
-
 impl<'s> Lexer<'s> {
     /// Create a new lexer with the given mode and a prefix to offset column
     /// calculations.
-    pub fn new(text: &'s str, mode: LexMode) -> Self {
+    pub fn new(text: &'s str, mode: SyntaxMode) -> Self {
         Self {
             s: Scanner::new(text),
             mode,
@@ -44,12 +33,12 @@ impl<'s> Lexer<'s> {
     }
 
     /// Get the current lexing mode.
-    pub fn mode(&self) -> LexMode {
+    pub fn mode(&self) -> SyntaxMode {
         self.mode
     }
 
     /// Change the lexing mode.
-    pub fn set_mode(&mut self, mode: LexMode) {
+    pub fn set_mode(&mut self, mode: SyntaxMode) {
         self.mode = mode;
     }
 
@@ -92,7 +81,7 @@ impl Lexer<'_> {
     }
 }
 
-/// Shared methods with all [`LexMode`].
+/// Shared methods with all [`SyntaxMode`].
 impl Lexer<'_> {
     /// Return the next token in our text. Returns both the [`SyntaxNode`]
     /// and the raw [`SyntaxKind`] to make it more ergonomic to check the kind
@@ -114,14 +103,14 @@ impl Lexer<'_> {
                 );
                 kind
             }
-            Some('`') if self.mode != LexMode::Math => return self.raw(),
+            Some('`') if self.mode != SyntaxMode::Math => return self.raw(),
             Some(c) => match self.mode {
-                LexMode::Markup => self.markup(start, c),
-                LexMode::Math => match self.math(start, c) {
+                SyntaxMode::Markup => self.markup(start, c),
+                SyntaxMode::Math => match self.math(start, c) {
                     (kind, None) => kind,
                     (kind, Some(node)) => return (kind, node),
                 },
-                LexMode::Code => self.code(start, c),
+                SyntaxMode::Code => self.code(start, c),
             },
 
             None => SyntaxKind::End,
@@ -145,7 +134,7 @@ impl Lexer<'_> {
         };
 
         self.newline = newlines > 0;
-        if self.mode == LexMode::Markup && newlines >= 2 {
+        if self.mode == SyntaxMode::Markup && newlines >= 2 {
             SyntaxKind::Parbreak
         } else {
             SyntaxKind::Space
@@ -965,9 +954,9 @@ impl ScannerExt for Scanner<'_> {
 
 /// Whether a character will become a [`SyntaxKind::Space`] token.
 #[inline]
-fn is_space(character: char, mode: LexMode) -> bool {
+fn is_space(character: char, mode: SyntaxMode) -> bool {
     match mode {
-        LexMode::Markup => matches!(character, ' ' | '\t') || is_newline(character),
+        SyntaxMode::Markup => matches!(character, ' ' | '\t') || is_newline(character),
         _ => character.is_whitespace(),
     }
 }
diff --git a/crates/typst-syntax/src/lib.rs b/crates/typst-syntax/src/lib.rs
index 1249f88e9..4741506c5 100644
--- a/crates/typst-syntax/src/lib.rs
+++ b/crates/typst-syntax/src/lib.rs
@@ -30,5 +30,16 @@ pub use self::path::VirtualPath;
 pub use self::source::Source;
 pub use self::span::{Span, Spanned};
 
-use self::lexer::{LexMode, Lexer};
+use self::lexer::Lexer;
 use self::parser::{reparse_block, reparse_markup};
+
+/// The syntax mode of a portion of Typst code.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum SyntaxMode {
+    /// Text and markup, as in the top level.
+    Markup,
+    /// Math atoms, operators, etc., as in equations.
+    Math,
+    /// Keywords, literals and operators, as after hashes.
+    Code,
+}
diff --git a/crates/typst-syntax/src/parser.rs b/crates/typst-syntax/src/parser.rs
index a68815806..b452c2c09 100644
--- a/crates/typst-syntax/src/parser.rs
+++ b/crates/typst-syntax/src/parser.rs
@@ -7,12 +7,12 @@ use typst_utils::default_math_class;
 use unicode_math_class::MathClass;
 
 use crate::set::{syntax_set, SyntaxSet};
-use crate::{ast, set, LexMode, Lexer, SyntaxError, SyntaxKind, SyntaxNode};
+use crate::{ast, set, Lexer, SyntaxError, SyntaxKind, SyntaxMode, SyntaxNode};
 
 /// Parses a source file as top-level markup.
 pub fn parse(text: &str) -> SyntaxNode {
     let _scope = typst_timing::TimingScope::new("parse");
-    let mut p = Parser::new(text, 0, LexMode::Markup);
+    let mut p = Parser::new(text, 0, SyntaxMode::Markup);
     markup_exprs(&mut p, true, syntax_set!(End));
     p.finish_into(SyntaxKind::Markup)
 }
@@ -20,7 +20,7 @@ pub fn parse(text: &str) -> SyntaxNode {
 /// Parses top-level code.
 pub fn parse_code(text: &str) -> SyntaxNode {
     let _scope = typst_timing::TimingScope::new("parse code");
-    let mut p = Parser::new(text, 0, LexMode::Code);
+    let mut p = Parser::new(text, 0, SyntaxMode::Code);
     code_exprs(&mut p, syntax_set!(End));
     p.finish_into(SyntaxKind::Code)
 }
@@ -28,7 +28,7 @@ pub fn parse_code(text: &str) -> SyntaxNode {
 /// Parses top-level math.
 pub fn parse_math(text: &str) -> SyntaxNode {
     let _scope = typst_timing::TimingScope::new("parse math");
-    let mut p = Parser::new(text, 0, LexMode::Math);
+    let mut p = Parser::new(text, 0, SyntaxMode::Math);
     math_exprs(&mut p, syntax_set!(End));
     p.finish_into(SyntaxKind::Math)
 }
@@ -63,7 +63,7 @@ pub(super) fn reparse_markup(
     nesting: &mut usize,
     top_level: bool,
 ) -> Option<Vec<SyntaxNode>> {
-    let mut p = Parser::new(text, range.start, LexMode::Markup);
+    let mut p = Parser::new(text, range.start, SyntaxMode::Markup);
     *at_start |= p.had_newline();
     while !p.end() && p.current_start() < range.end {
         // If not top-level and at a new RightBracket, stop the reparse.
@@ -205,7 +205,7 @@ fn reference(p: &mut Parser) {
 /// Parses a mathematical equation: `$x$`, `$ x^2 $`.
 fn equation(p: &mut Parser) {
     let m = p.marker();
-    p.enter_modes(LexMode::Math, AtNewline::Continue, |p| {
+    p.enter_modes(SyntaxMode::Math, AtNewline::Continue, |p| {
         p.assert(SyntaxKind::Dollar);
         math(p, syntax_set!(Dollar, End));
         p.expect_closing_delimiter(m, SyntaxKind::Dollar);
@@ -615,7 +615,7 @@ fn code_exprs(p: &mut Parser, stop_set: SyntaxSet) {
 
 /// Parses an atomic code expression embedded in markup or math.
 fn embedded_code_expr(p: &mut Parser) {
-    p.enter_modes(LexMode::Code, AtNewline::Stop, |p| {
+    p.enter_modes(SyntaxMode::Code, AtNewline::Stop, |p| {
         p.assert(SyntaxKind::Hash);
         if p.had_trivia() || p.end() {
             p.expected("expression");
@@ -777,7 +777,7 @@ fn code_primary(p: &mut Parser, atomic: bool) {
 
 /// Reparses a full content or code block.
 pub(super) fn reparse_block(text: &str, range: Range<usize>) -> Option<SyntaxNode> {
-    let mut p = Parser::new(text, range.start, LexMode::Code);
+    let mut p = Parser::new(text, range.start, SyntaxMode::Code);
     assert!(p.at(SyntaxKind::LeftBracket) || p.at(SyntaxKind::LeftBrace));
     block(&mut p);
     (p.balanced && p.prev_end() == range.end)
@@ -796,7 +796,7 @@ fn block(p: &mut Parser) {
 /// Parses a code block: `{ let x = 1; x + 2 }`.
 fn code_block(p: &mut Parser) {
     let m = p.marker();
-    p.enter_modes(LexMode::Code, AtNewline::Continue, |p| {
+    p.enter_modes(SyntaxMode::Code, AtNewline::Continue, |p| {
         p.assert(SyntaxKind::LeftBrace);
         code(p, syntax_set!(RightBrace, RightBracket, RightParen, End));
         p.expect_closing_delimiter(m, SyntaxKind::RightBrace);
@@ -807,7 +807,7 @@ fn code_block(p: &mut Parser) {
 /// Parses a content block: `[*Hi* there!]`.
 fn content_block(p: &mut Parser) {
     let m = p.marker();
-    p.enter_modes(LexMode::Markup, AtNewline::Continue, |p| {
+    p.enter_modes(SyntaxMode::Markup, AtNewline::Continue, |p| {
         p.assert(SyntaxKind::LeftBracket);
         markup(p, true, true, syntax_set!(RightBracket, End));
         p.expect_closing_delimiter(m, SyntaxKind::RightBracket);
@@ -1516,10 +1516,10 @@ fn pattern_leaf<'s>(
 /// ### Modes
 ///
 /// The parser manages the transitions between the three modes of Typst through
-/// [lexer modes](`LexMode`) and [newline modes](`AtNewline`).
+/// [syntax modes](`SyntaxMode`) and [newline modes](`AtNewline`).
 ///
-/// The lexer modes map to the three Typst modes and are stored in the lexer,
-/// changing which`SyntaxKind`s it will generate.
+/// The syntax modes map to the three Typst modes and are stored in the lexer,
+/// changing which `SyntaxKind`s it will generate.
 ///
 /// The newline mode is used to determine whether a newline should end the
 /// current expression. If so, the parser temporarily changes `token`'s kind to
@@ -1529,7 +1529,7 @@ struct Parser<'s> {
     /// The source text shared with the lexer.
     text: &'s str,
     /// A lexer over the source text with multiple modes. Defines the boundaries
-    /// of tokens and determines their [`SyntaxKind`]. Contains the [`LexMode`]
+    /// of tokens and determines their [`SyntaxKind`]. Contains the [`SyntaxMode`]
     /// defining our current Typst mode.
     lexer: Lexer<'s>,
     /// The newline mode: whether to insert a temporary end at newlines.
@@ -1612,7 +1612,7 @@ impl AtNewline {
             AtNewline::RequireColumn(min_col) => {
                 // When the column is `None`, the newline doesn't start a
                 // column, and we continue parsing. This may happen on the
-                // boundary of lexer modes, since we only report a column in
+                // boundary of syntax modes, since we only report a column in
                 // Markup.
                 column.is_some_and(|column| column <= min_col)
             }
@@ -1643,8 +1643,8 @@ impl IndexMut<Marker> for Parser<'_> {
 
 /// Creating/Consuming the parser and getting info about the current token.
 impl<'s> Parser<'s> {
-    /// Create a new parser starting from the given text offset and lexer mode.
-    fn new(text: &'s str, offset: usize, mode: LexMode) -> Self {
+    /// Create a new parser starting from the given text offset and syntax mode.
+    fn new(text: &'s str, offset: usize, mode: SyntaxMode) -> Self {
         let mut lexer = Lexer::new(text, mode);
         lexer.jump(offset);
         let nl_mode = AtNewline::Continue;
@@ -1825,13 +1825,13 @@ impl<'s> Parser<'s> {
         self.nodes.insert(from, SyntaxNode::inner(kind, children));
     }
 
-    /// Parse within the [`LexMode`] for subsequent tokens (does not change the
+    /// Parse within the [`SyntaxMode`] for subsequent tokens (does not change the
     /// current token). This may re-lex the final token on exit.
     ///
     /// This function effectively repurposes the call stack as a stack of modes.
     fn enter_modes(
         &mut self,
-        mode: LexMode,
+        mode: SyntaxMode,
         stop: AtNewline,
         func: impl FnOnce(&mut Parser<'s>),
     ) {
@@ -1891,7 +1891,8 @@ impl<'s> Parser<'s> {
         }
 
         let newline = if had_newline {
-            let column = (lexer.mode() == LexMode::Markup).then(|| lexer.column(start));
+            let column =
+                (lexer.mode() == SyntaxMode::Markup).then(|| lexer.column(start));
             let newline = Newline { column, parbreak };
             if nl_mode.stop_at(newline, kind) {
                 // Insert a temporary `SyntaxKind::End` to halt the parser.
@@ -1938,7 +1939,7 @@ struct Checkpoint {
 #[derive(Clone)]
 struct PartialState {
     cursor: usize,
-    lex_mode: LexMode,
+    lex_mode: SyntaxMode,
     token: Token,
 }
 

From 4a638f41cde37312390359a5345073bed5835ae6 Mon Sep 17 00:00:00 2001
From: cAttte <26514199+cAttte@users.noreply.github.com>
Date: Thu, 12 Jun 2025 11:10:04 -0300
Subject: [PATCH 002/101] Consume `data` argument in `pdf.embed()` (#6435)

---
 crates/typst-library/src/pdf/embed.rs | 2 +-
 tests/suite/pdf/embed.typ             | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/typst-library/src/pdf/embed.rs b/crates/typst-library/src/pdf/embed.rs
index f902e7f14..4c01cd651 100644
--- a/crates/typst-library/src/pdf/embed.rs
+++ b/crates/typst-library/src/pdf/embed.rs
@@ -59,7 +59,7 @@ pub struct EmbedElem {
     // We can't distinguish between the two at the moment.
     #[required]
     #[parse(
-        match args.find::<Bytes>()? {
+        match args.eat::<Bytes>()? {
             Some(data) => data,
             None => engine.world.file(id).at(span)?,
         }
diff --git a/tests/suite/pdf/embed.typ b/tests/suite/pdf/embed.typ
index 83f006d63..4546532b7 100644
--- a/tests/suite/pdf/embed.typ
+++ b/tests/suite/pdf/embed.typ
@@ -28,3 +28,7 @@
   mime-type: "text/plain",
   description: "A test file",
 )
+
+--- pdf-embed-invalid-data ---
+// Error: 38-45 expected bytes, found string
+#pdf.embed("/assets/text/hello.txt", "hello")

From 64d0a564bf92b6540955d820149e62e7fab394c5 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 12 Jun 2025 16:11:18 +0200
Subject: [PATCH 003/101] Better error message for compile time string
 interning failure (#6439)

---
 crates/typst-utils/src/pico.rs | 45 +++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/crates/typst-utils/src/pico.rs b/crates/typst-utils/src/pico.rs
index ce43667e9..3aa4570f2 100644
--- a/crates/typst-utils/src/pico.rs
+++ b/crates/typst-utils/src/pico.rs
@@ -72,7 +72,7 @@ impl PicoStr {
     pub const fn constant(string: &'static str) -> PicoStr {
         match PicoStr::try_constant(string) {
             Ok(value) => value,
-            Err(err) => panic!("{}", err.message()),
+            Err(err) => failed_to_compile_time_intern(err, string),
         }
     }
 
@@ -190,15 +190,9 @@ mod bitcode {
     impl EncodingError {
         pub const fn message(&self) -> &'static str {
             match self {
-                Self::TooLong => {
-                    "the maximum auto-internible string length is 12. \
-                     you can add an exception to typst-utils/src/pico.rs \
-                     to intern longer strings."
-                }
+                Self::TooLong => "the maximum auto-internible string length is 12",
                 Self::BadChar => {
-                    "can only auto-intern the chars 'a'-'z', '1'-'4', and '-'. \
-                     you can add an exception to typst-utils/src/pico.rs \
-                     to intern other strings."
+                    "can only auto-intern the chars 'a'-'z', '1'-'4', and '-'"
                 }
             }
         }
@@ -356,6 +350,39 @@ impl Hash for ResolvedPicoStr {
     }
 }
 
+/// The error when a string could not be interned at compile time. Because the
+/// normal formatting machinery is not available at compile time, just producing
+/// the message is a bit involved ...
+#[track_caller]
+const fn failed_to_compile_time_intern(
+    error: bitcode::EncodingError,
+    string: &'static str,
+) -> ! {
+    const CAPACITY: usize = 512;
+    const fn push((buf, i): &mut ([u8; CAPACITY], usize), s: &str) {
+        let mut k = 0;
+        while k < s.len() && *i < buf.len() {
+            buf[*i] = s.as_bytes()[k];
+            k += 1;
+            *i += 1;
+        }
+    }
+
+    let mut dest = ([0; CAPACITY], 0);
+    push(&mut dest, "failed to compile-time intern string \"");
+    push(&mut dest, string);
+    push(&mut dest, "\". ");
+    push(&mut dest, error.message());
+    push(&mut dest, ". you can add an exception to ");
+    push(&mut dest, file!());
+    push(&mut dest, " to intern longer strings.");
+
+    let (slice, _) = dest.0.split_at(dest.1);
+    let Ok(message) = std::str::from_utf8(slice) else { panic!() };
+
+    panic!("{}", message);
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

From f32cd5b3e1e9b5c81f8fe72042212a7c7d3a43a7 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 09:29:35 +0200
Subject: [PATCH 004/101] Ensure that label repr is syntactically valid (#6456)

---
 crates/typst-library/src/foundations/label.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/crates/typst-library/src/foundations/label.rs b/crates/typst-library/src/foundations/label.rs
index 2f5520b1c..3b9b010c5 100644
--- a/crates/typst-library/src/foundations/label.rs
+++ b/crates/typst-library/src/foundations/label.rs
@@ -79,7 +79,12 @@ impl Label {
 
 impl Repr for Label {
     fn repr(&self) -> EcoString {
-        eco_format!("<{}>", self.resolve())
+        let resolved = self.resolve();
+        if typst_syntax::is_valid_label_literal_id(&resolved) {
+            eco_format!("<{resolved}>")
+        } else {
+            eco_format!("label({})", resolved.repr())
+        }
     }
 }
 

From 0bc68df2a9a87ca7e36e34dab56b07c666d64760 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 09:29:38 +0200
Subject: [PATCH 005/101] Hint for label in both document and bibliography
 (#6457)

---
 crates/typst-library/src/model/reference.rs | 13 ++++++++++---
 tests/suite/model/ref.typ                   |  3 ++-
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index 7d44cccc0..f22d70b32 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -5,7 +5,7 @@ use crate::diag::{bail, At, Hint, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Cast, Content, Context, Func, IntoValue, Label, NativeElement, Packed,
-    Show, Smart, StyleChain, Synthesize,
+    Repr, Show, Smart, StyleChain, Synthesize,
 };
 use crate::introspection::{Counter, CounterKey, Locatable};
 use crate::math::EquationElem;
@@ -229,8 +229,15 @@ impl Show for Packed<RefElem> {
         // RefForm::Normal
 
         if BibliographyElem::has(engine, self.target) {
-            if elem.is_ok() {
-                bail!(span, "label occurs in the document and its bibliography");
+            if let Ok(elem) = elem {
+                bail!(
+                    span,
+                    "label `{}` occurs both in the document and its bibliography",
+                    self.target.repr();
+                    hint: "change either the {}'s label or the \
+                           bibliography key to resolve the ambiguity",
+                    elem.func().name(),
+                );
             }
 
             return Ok(to_citation(self, engine, styles)?.pack().spanned(span));
diff --git a/tests/suite/model/ref.typ b/tests/suite/model/ref.typ
index 2f8e2fa25..87b1c409a 100644
--- a/tests/suite/model/ref.typ
+++ b/tests/suite/model/ref.typ
@@ -51,7 +51,8 @@ $ A = 1 $ <eq2>
 // Test ambiguous reference.
 = Introduction <arrgh>
 
-// Error: 1-7 label occurs in the document and its bibliography
+// Error: 1-7 label `<arrgh>` occurs both in the document and its bibliography
+// Hint: 1-7 change either the heading's label or the bibliography key to resolve the ambiguity
 @arrgh
 #bibliography("/assets/bib/works.bib")
 

From 4588595792cec196298446c47c99c35e323b663e Mon Sep 17 00:00:00 2001
From: Andrew Voynov <37143421+Andrew15-5@users.noreply.github.com>
Date: Thu, 19 Jun 2025 22:20:15 +0300
Subject: [PATCH 006/101] Prefer `.yaml` over `.yml` in the docs (#6436)

---
 crates/typst-library/src/model/bibliography.rs | 4 ++--
 docs/changelog/0.9.0.md                        | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index 7bfacfc66..8056d4ab3 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -90,7 +90,7 @@ use crate::World;
 /// ```
 #[elem(Locatable, Synthesize, Show, ShowSet, LocalName)]
 pub struct BibliographyElem {
-    /// One or multiple paths to or raw bytes for Hayagriva `.yml` and/or
+    /// One or multiple paths to or raw bytes for Hayagriva `.yaml` and/or
     /// BibLaTeX `.bib` files.
     ///
     /// This can be a:
@@ -385,7 +385,7 @@ fn decode_library(loaded: &Loaded) -> SourceResult<Library> {
                 .within(loaded),
             _ => bail!(
                 loaded.source.span,
-                "unknown bibliography format (must be .yml/.yaml or .bib)"
+                "unknown bibliography format (must be .yaml/.yml or .bib)"
             ),
         }
     } else {
diff --git a/docs/changelog/0.9.0.md b/docs/changelog/0.9.0.md
index 0cf3c1bd8..0a4ac8268 100644
--- a/docs/changelog/0.9.0.md
+++ b/docs/changelog/0.9.0.md
@@ -21,7 +21,7 @@ description: Changes in Typst 0.9.0
 - Added [`full`]($bibliography.full) argument to bibliography function to print
   the full bibliography even if not all works were cited
 - Bibliography entries can now contain Typst equations (wrapped in `[$..$]` just
-  like in markup), this works both for `.yml` and `.bib` bibliographies
+  like in markup), this works both for `.yaml` and `.bib` bibliographies
 - The hayagriva YAML format was improved. See its
   [changelog](https://github.com/typst/hayagriva/blob/main/CHANGELOG.md) for
   more details. **(Breaking change)**

From f1c761e88ba50c5560360062c03d7d04f3925c49 Mon Sep 17 00:00:00 2001
From: Noam Zaks <63877260+noamzaks@users.noreply.github.com>
Date: Fri, 20 Jun 2025 00:24:02 +0300
Subject: [PATCH 007/101] Fix align link in layout documentation (#6451)

---
 crates/typst-library/src/layout/align.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-library/src/layout/align.rs b/crates/typst-library/src/layout/align.rs
index 5604d6831..0a978dbae 100644
--- a/crates/typst-library/src/layout/align.rs
+++ b/crates/typst-library/src/layout/align.rs
@@ -104,7 +104,7 @@ impl Show for Packed<AlignElem> {
     }
 }
 
-/// Where to [align] something along an axis.
+/// Where to align something along an axis.
 ///
 /// Possible values are:
 /// - `start`: Aligns at the [start]($direction.start) of the [text

From f364b3c3239261e98da4c28c53463b751addfee7 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Fri, 20 Jun 2025 14:32:04 +0200
Subject: [PATCH 008/101] Fix param autocompletion false positive (#6475)

---
 crates/typst-ide/src/complete.rs | 15 ++++++++++-----
 crates/typst-ide/src/tests.rs    |  3 ++-
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index c98320679..47727743f 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -701,7 +701,10 @@ fn complete_params(ctx: &mut CompletionContext) -> bool {
     let mut deciding = ctx.leaf.clone();
     while !matches!(
         deciding.kind(),
-        SyntaxKind::LeftParen | SyntaxKind::Comma | SyntaxKind::Colon
+        SyntaxKind::LeftParen
+            | SyntaxKind::RightParen
+            | SyntaxKind::Comma
+            | SyntaxKind::Colon
     ) {
         let Some(prev) = deciding.prev_leaf() else { break };
         deciding = prev;
@@ -1734,6 +1737,8 @@ mod tests {
         test("#numbering(\"foo\", 1, )", -2)
             .must_include(["integer"])
             .must_exclude(["string"]);
+        // After argument list no completions.
+        test("#numbering()", -1).must_exclude(["string"]);
     }
 
     /// Test that autocompletion for values of known type picks up nested
@@ -1829,17 +1834,17 @@ mod tests {
 
     #[test]
     fn test_autocomplete_fonts() {
-        test("#text(font:)", -1)
+        test("#text(font:)", -2)
             .must_include(["\"Libertinus Serif\"", "\"New Computer Modern Math\""]);
 
-        test("#show link: set text(font: )", -1)
+        test("#show link: set text(font: )", -2)
             .must_include(["\"Libertinus Serif\"", "\"New Computer Modern Math\""]);
 
-        test("#show math.equation: set text(font: )", -1)
+        test("#show math.equation: set text(font: )", -2)
             .must_include(["\"New Computer Modern Math\""])
             .must_exclude(["\"Libertinus Serif\""]);
 
-        test("#show math.equation: it => { set text(font: )\nit }", -6)
+        test("#show math.equation: it => { set text(font: )\nit }", -7)
             .must_include(["\"New Computer Modern Math\""])
             .must_exclude(["\"Libertinus Serif\""]);
     }
diff --git a/crates/typst-ide/src/tests.rs b/crates/typst-ide/src/tests.rs
index 1176e4601..5edc05f17 100644
--- a/crates/typst-ide/src/tests.rs
+++ b/crates/typst-ide/src/tests.rs
@@ -202,7 +202,8 @@ impl WorldLike for &str {
     }
 }
 
-/// Specifies a position in a file for a test.
+/// Specifies a position in a file for a test. Negative numbers index from the
+/// back. `-1` is at the very back.
 pub trait FilePos {
     fn resolve(self, world: &TestWorld) -> (Source, usize);
 }

From fee6844045e6a898bc65491a8e18cd520b24d08b Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 17:11:13 +0200
Subject: [PATCH 009/101] Encode empty attributes with shorthand syntax

---
 crates/typst-html/src/encode.rs | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 612f923fc..c6a6a7bce 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -69,16 +69,21 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     for (attr, value) in &element.attrs.0 {
         w.buf.push(' ');
         w.buf.push_str(&attr.resolve());
-        w.buf.push('=');
-        w.buf.push('"');
-        for c in value.chars() {
-            if charsets::is_valid_in_attribute_value(c) {
-                w.buf.push(c);
-            } else {
-                write_escape(w, c).at(element.span)?;
+
+        // If the string is empty, we can use shorthand syntax.
+        // `<elem attr="">..</div` is equivalent to `<elem attr>..</div>`
+        if !value.is_empty() {
+            w.buf.push('=');
+            w.buf.push('"');
+            for c in value.chars() {
+                if charsets::is_valid_in_attribute_value(c) {
+                    w.buf.push(c);
+                } else {
+                    write_escape(w, c).at(element.span)?;
+                }
             }
+            w.buf.push('"');
         }
-        w.buf.push('"');
     }
 
     w.buf.push('>');

From 3b35f0cecf37c00d33334be6a596a105167875dd Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 17:11:26 +0200
Subject: [PATCH 010/101] Add `Duration::decompose`

---
 .../typst-library/src/foundations/duration.rs | 26 ++++++++++++-------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/crates/typst-library/src/foundations/duration.rs b/crates/typst-library/src/foundations/duration.rs
index 94d44fb2a..90685fa34 100644
--- a/crates/typst-library/src/foundations/duration.rs
+++ b/crates/typst-library/src/foundations/duration.rs
@@ -16,6 +16,21 @@ impl Duration {
     pub fn is_zero(&self) -> bool {
         self.0.is_zero()
     }
+
+    /// Decomposes the time into whole weeks, days, hours, minutes, and seconds.
+    pub fn decompose(&self) -> [i64; 5] {
+        let mut tmp = self.0;
+        let weeks = tmp.whole_weeks();
+        tmp -= weeks.weeks();
+        let days = tmp.whole_days();
+        tmp -= days.days();
+        let hours = tmp.whole_hours();
+        tmp -= hours.hours();
+        let minutes = tmp.whole_minutes();
+        tmp -= minutes.minutes();
+        let seconds = tmp.whole_seconds();
+        [weeks, days, hours, minutes, seconds]
+    }
 }
 
 #[scope]
@@ -118,34 +133,25 @@ impl Debug for Duration {
 
 impl Repr for Duration {
     fn repr(&self) -> EcoString {
-        let mut tmp = self.0;
+        let [weeks, days, hours, minutes, seconds] = self.decompose();
         let mut vec = Vec::with_capacity(5);
 
-        let weeks = tmp.whole_seconds() / 604_800.0 as i64;
         if weeks != 0 {
             vec.push(eco_format!("weeks: {}", weeks.repr()));
         }
-        tmp -= weeks.weeks();
 
-        let days = tmp.whole_days();
         if days != 0 {
             vec.push(eco_format!("days: {}", days.repr()));
         }
-        tmp -= days.days();
 
-        let hours = tmp.whole_hours();
         if hours != 0 {
             vec.push(eco_format!("hours: {}", hours.repr()));
         }
-        tmp -= hours.hours();
 
-        let minutes = tmp.whole_minutes();
         if minutes != 0 {
             vec.push(eco_format!("minutes: {}", minutes.repr()));
         }
-        tmp -= minutes.minutes();
 
-        let seconds = tmp.whole_seconds();
         if seconds != 0 {
             vec.push(eco_format!("seconds: {}", seconds.repr()));
         }

From d821633f50f7f4c9edc49b6ac5e88d43802cb206 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 17:20:17 +0200
Subject: [PATCH 011/101] Generic casting for `Axes<T>`

---
 crates/typst-library/src/layout/axes.rs | 62 +++++++++++++------------
 tests/suite/visualize/line.typ          |  3 +-
 tests/suite/visualize/path.typ          |  3 +-
 tests/suite/visualize/polygon.typ       |  3 +-
 4 files changed, 38 insertions(+), 33 deletions(-)

diff --git a/crates/typst-library/src/layout/axes.rs b/crates/typst-library/src/layout/axes.rs
index 7a73ba796..e4303f98b 100644
--- a/crates/typst-library/src/layout/axes.rs
+++ b/crates/typst-library/src/layout/axes.rs
@@ -4,9 +4,12 @@ use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Deref, Not};
 
 use typst_utils::Get;
 
-use crate::diag::bail;
-use crate::foundations::{array, cast, Array, Resolve, Smart, StyleChain};
-use crate::layout::{Abs, Dir, Length, Ratio, Rel, Size};
+use crate::diag::{bail, HintedStrResult};
+use crate::foundations::{
+    array, cast, Array, CastInfo, FromValue, IntoValue, Reflect, Resolve, Smart,
+    StyleChain, Value,
+};
+use crate::layout::{Abs, Dir, Rel, Size};
 
 /// A container with a horizontal and vertical component.
 #[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
@@ -275,40 +278,39 @@ impl BitAndAssign for Axes<bool> {
     }
 }
 
-cast! {
-    Axes<Rel<Length>>,
-    self => array![self.x, self.y].into_value(),
-    array: Array => {
-        let mut iter = array.into_iter();
-        match (iter.next(), iter.next(), iter.next()) {
-            (Some(a), Some(b), None) => Axes::new(a.cast()?, b.cast()?),
-            _ => bail!("point array must contain exactly two entries"),
-        }
-    },
+impl<T: Reflect> Reflect for Axes<T> {
+    fn input() -> CastInfo {
+        Array::input()
+    }
+
+    fn output() -> CastInfo {
+        Array::output()
+    }
+
+    fn castable(value: &Value) -> bool {
+        Array::castable(value)
+    }
 }
 
-cast! {
-    Axes<Ratio>,
-    self => array![self.x, self.y].into_value(),
-    array: Array => {
+impl<T: FromValue> FromValue for Axes<T> {
+    fn from_value(value: Value) -> HintedStrResult<Self> {
+        let array = value.cast::<Array>()?;
         let mut iter = array.into_iter();
         match (iter.next(), iter.next(), iter.next()) {
-            (Some(a), Some(b), None) => Axes::new(a.cast()?, b.cast()?),
-            _ => bail!("ratio array must contain exactly two entries"),
+            (Some(a), Some(b), None) => Ok(Axes::new(a.cast()?, b.cast()?)),
+            _ => bail!(
+                "array must contain exactly two items";
+                hint: "the first item determines the value for the X axis \
+                       and the second item the value for the Y axis"
+            ),
         }
-    },
+    }
 }
 
-cast! {
-    Axes<Length>,
-    self => array![self.x, self.y].into_value(),
-    array: Array => {
-        let mut iter = array.into_iter();
-        match (iter.next(), iter.next(), iter.next()) {
-            (Some(a), Some(b), None) => Axes::new(a.cast()?, b.cast()?),
-            _ => bail!("length array must contain exactly two entries"),
-        }
-    },
+impl<T: IntoValue> IntoValue for Axes<T> {
+    fn into_value(self) -> Value {
+        array![self.x.into_value(), self.y.into_value()].into_value()
+    }
 }
 
 impl<T: Resolve> Resolve for Axes<T> {
diff --git a/tests/suite/visualize/line.typ b/tests/suite/visualize/line.typ
index 6cbbbb493..4c763030f 100644
--- a/tests/suite/visualize/line.typ
+++ b/tests/suite/visualize/line.typ
@@ -84,7 +84,8 @@
 --- line-bad-point-array ---
 // Test errors.
 
-// Error: 12-19 point array must contain exactly two entries
+// Error: 12-19 array must contain exactly two items
+// Hint: 12-19 the first item determines the value for the X axis and the second item the value for the Y axis
 #line(end: (50pt,))
 
 --- line-bad-point-component-type ---
diff --git a/tests/suite/visualize/path.typ b/tests/suite/visualize/path.typ
index e44b2270e..795fde981 100644
--- a/tests/suite/visualize/path.typ
+++ b/tests/suite/visualize/path.typ
@@ -76,7 +76,8 @@
 #path(((0%, 0%), (0%, 0%), (0%, 0%), (0%, 0%)))
 
 --- path-bad-point-array ---
-// Error: 7-31 point array must contain exactly two entries
+// Error: 7-31 array must contain exactly two items
+// Hint: 7-31 the first item determines the value for the X axis and the second item the value for the Y axis
 // Warning: 2-6 the `path` function is deprecated, use `curve` instead
 #path(((0%, 0%), (0%, 0%, 0%)))
 
diff --git a/tests/suite/visualize/polygon.typ b/tests/suite/visualize/polygon.typ
index ec27194df..6cc243d2b 100644
--- a/tests/suite/visualize/polygon.typ
+++ b/tests/suite/visualize/polygon.typ
@@ -49,7 +49,8 @@
 )
 
 --- polygon-bad-point-array ---
-// Error: 10-17 point array must contain exactly two entries
+// Error: 10-17 array must contain exactly two items
+// Hint: 10-17 the first item determines the value for the X axis and the second item the value for the Y axis
 #polygon((50pt,))
 
 --- polygon-infinite-size ---

From 4580daf307cb1ba66458fb46d9442b1183731ec2 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 17:20:45 +0200
Subject: [PATCH 012/101] More type-safe color conversions

---
 crates/typst-library/src/text/raw.rs        |   2 +-
 crates/typst-library/src/visualize/color.rs | 144 ++++++++++----------
 crates/typst-render/src/paint.rs            |   4 +-
 3 files changed, 73 insertions(+), 77 deletions(-)

diff --git a/crates/typst-library/src/text/raw.rs b/crates/typst-library/src/text/raw.rs
index f2485e16b..e1f4cf13d 100644
--- a/crates/typst-library/src/text/raw.rs
+++ b/crates/typst-library/src/text/raw.rs
@@ -836,7 +836,7 @@ fn to_typst(synt::Color { r, g, b, a }: synt::Color) -> Color {
 }
 
 fn to_syn(color: Color) -> synt::Color {
-    let [r, g, b, a] = color.to_rgb().to_vec4_u8();
+    let (r, g, b, a) = color.to_rgb().into_format::<u8, u8>().into_components();
     synt::Color { r, g, b, a }
 }
 
diff --git a/crates/typst-library/src/visualize/color.rs b/crates/typst-library/src/visualize/color.rs
index 24d8305cd..5c657b4e2 100644
--- a/crates/typst-library/src/visualize/color.rs
+++ b/crates/typst-library/src/visualize/color.rs
@@ -262,7 +262,7 @@ impl Color {
         color: Color,
     ) -> SourceResult<Color> {
         Ok(if let Some(color) = args.find::<Color>()? {
-            color.to_luma()
+            Color::Luma(color.to_luma())
         } else {
             let Component(gray) =
                 args.expect("gray component").unwrap_or(Component(Ratio::one()));
@@ -318,7 +318,7 @@ impl Color {
         color: Color,
     ) -> SourceResult<Color> {
         Ok(if let Some(color) = args.find::<Color>()? {
-            color.to_oklab()
+            Color::Oklab(color.to_oklab())
         } else {
             let RatioComponent(l) = args.expect("lightness component")?;
             let ChromaComponent(a) = args.expect("A component")?;
@@ -374,7 +374,7 @@ impl Color {
         color: Color,
     ) -> SourceResult<Color> {
         Ok(if let Some(color) = args.find::<Color>()? {
-            color.to_oklch()
+            Color::Oklch(color.to_oklch())
         } else {
             let RatioComponent(l) = args.expect("lightness component")?;
             let ChromaComponent(c) = args.expect("chroma component")?;
@@ -434,7 +434,7 @@ impl Color {
         color: Color,
     ) -> SourceResult<Color> {
         Ok(if let Some(color) = args.find::<Color>()? {
-            color.to_linear_rgb()
+            Color::LinearRgb(color.to_linear_rgb())
         } else {
             let Component(r) = args.expect("red component")?;
             let Component(g) = args.expect("green component")?;
@@ -505,7 +505,7 @@ impl Color {
         Ok(if let Some(string) = args.find::<Spanned<Str>>()? {
             Self::from_str(&string.v).at(string.span)?
         } else if let Some(color) = args.find::<Color>()? {
-            color.to_rgb()
+            Color::Rgb(color.to_rgb())
         } else {
             let Component(r) = args.expect("red component")?;
             let Component(g) = args.expect("green component")?;
@@ -565,7 +565,7 @@ impl Color {
         color: Color,
     ) -> SourceResult<Color> {
         Ok(if let Some(color) = args.find::<Color>()? {
-            color.to_cmyk()
+            Color::Cmyk(color.to_cmyk())
         } else {
             let RatioComponent(c) = args.expect("cyan component")?;
             let RatioComponent(m) = args.expect("magenta component")?;
@@ -622,7 +622,7 @@ impl Color {
         color: Color,
     ) -> SourceResult<Color> {
         Ok(if let Some(color) = args.find::<Color>()? {
-            color.to_hsl()
+            Color::Hsl(color.to_hsl())
         } else {
             let h: Angle = args.expect("hue component")?;
             let Component(s) = args.expect("saturation component")?;
@@ -679,7 +679,7 @@ impl Color {
         color: Color,
     ) -> SourceResult<Color> {
         Ok(if let Some(color) = args.find::<Color>()? {
-            color.to_hsv()
+            Color::Hsv(color.to_hsv())
         } else {
             let h: Angle = args.expect("hue component")?;
             let Component(s) = args.expect("saturation component")?;
@@ -830,7 +830,7 @@ impl Color {
     /// omitted if it is equal to `ff` (255 / 100%).
     #[func]
     pub fn to_hex(self) -> EcoString {
-        let [r, g, b, a] = self.to_rgb().to_vec4_u8();
+        let (r, g, b, a) = self.to_rgb().into_format::<u8, u8>().into_components();
         if a != 255 {
             eco_format!("#{:02x}{:02x}{:02x}{:02x}", r, g, b, a)
         } else {
@@ -886,20 +886,21 @@ impl Color {
         /// The factor to saturate the color by.
         factor: Ratio,
     ) -> SourceResult<Color> {
+        let f = factor.get() as f32;
         Ok(match self {
-            Self::Luma(_) => {
-                bail!(
-                    span, "cannot saturate grayscale color";
-                    hint: "try converting your color to RGB first"
-                );
+            Self::Luma(_) => bail!(
+                span, "cannot saturate grayscale color";
+                hint: "try converting your color to RGB first"
+            ),
+            Self::Hsl(c) => Self::Hsl(c.saturate(f)),
+            Self::Hsv(c) => Self::Hsv(c.saturate(f)),
+            Self::Oklab(_)
+            | Self::Oklch(_)
+            | Self::LinearRgb(_)
+            | Self::Rgb(_)
+            | Self::Cmyk(_) => {
+                Color::Hsv(self.to_hsv().saturate(f)).to_space(self.space())
             }
-            Self::Oklab(_) => self.to_hsv().saturate(span, factor)?.to_oklab(),
-            Self::Oklch(_) => self.to_hsv().saturate(span, factor)?.to_oklch(),
-            Self::LinearRgb(_) => self.to_hsv().saturate(span, factor)?.to_linear_rgb(),
-            Self::Rgb(_) => self.to_hsv().saturate(span, factor)?.to_rgb(),
-            Self::Cmyk(_) => self.to_hsv().saturate(span, factor)?.to_cmyk(),
-            Self::Hsl(c) => Self::Hsl(c.saturate(factor.get() as f32)),
-            Self::Hsv(c) => Self::Hsv(c.saturate(factor.get() as f32)),
         })
     }
 
@@ -911,20 +912,21 @@ impl Color {
         /// The factor to desaturate the color by.
         factor: Ratio,
     ) -> SourceResult<Color> {
+        let f = factor.get() as f32;
         Ok(match self {
-            Self::Luma(_) => {
-                bail!(
-                    span, "cannot desaturate grayscale color";
-                    hint: "try converting your color to RGB first"
-                );
+            Self::Luma(_) => bail!(
+                span, "cannot desaturate grayscale color";
+                hint: "try converting your color to RGB first"
+            ),
+            Self::Hsl(c) => Self::Hsl(c.desaturate(f)),
+            Self::Hsv(c) => Self::Hsv(c.desaturate(f)),
+            Self::Oklab(_)
+            | Self::Oklch(_)
+            | Self::LinearRgb(_)
+            | Self::Rgb(_)
+            | Self::Cmyk(_) => {
+                Color::Hsv(self.to_hsv().desaturate(f)).to_space(self.space())
             }
-            Self::Oklab(_) => self.to_hsv().desaturate(span, factor)?.to_oklab(),
-            Self::Oklch(_) => self.to_hsv().desaturate(span, factor)?.to_oklch(),
-            Self::LinearRgb(_) => self.to_hsv().desaturate(span, factor)?.to_linear_rgb(),
-            Self::Rgb(_) => self.to_hsv().desaturate(span, factor)?.to_rgb(),
-            Self::Cmyk(_) => self.to_hsv().desaturate(span, factor)?.to_cmyk(),
-            Self::Hsl(c) => Self::Hsl(c.desaturate(factor.get() as f32)),
-            Self::Hsv(c) => Self::Hsv(c.desaturate(factor.get() as f32)),
         })
     }
 
@@ -994,23 +996,17 @@ impl Color {
     ) -> SourceResult<Color> {
         Ok(match space {
             ColorSpace::Oklch => {
-                let Self::Oklch(oklch) = self.to_oklch() else {
-                    unreachable!();
-                };
+                let oklch = self.to_oklch();
                 let rotated = oklch.shift_hue(angle.to_deg() as f32);
                 Self::Oklch(rotated).to_space(self.space())
             }
             ColorSpace::Hsl => {
-                let Self::Hsl(hsl) = self.to_hsl() else {
-                    unreachable!();
-                };
+                let hsl = self.to_hsl();
                 let rotated = hsl.shift_hue(angle.to_deg() as f32);
                 Self::Hsl(rotated).to_space(self.space())
             }
             ColorSpace::Hsv => {
-                let Self::Hsv(hsv) = self.to_hsv() else {
-                    unreachable!();
-                };
+                let hsv = self.to_hsv();
                 let rotated = hsv.shift_hue(angle.to_deg() as f32);
                 Self::Hsv(rotated).to_space(self.space())
             }
@@ -1281,19 +1277,19 @@ impl Color {
 
     pub fn to_space(self, space: ColorSpace) -> Self {
         match space {
-            ColorSpace::Oklab => self.to_oklab(),
-            ColorSpace::Oklch => self.to_oklch(),
-            ColorSpace::Srgb => self.to_rgb(),
-            ColorSpace::LinearRgb => self.to_linear_rgb(),
-            ColorSpace::Hsl => self.to_hsl(),
-            ColorSpace::Hsv => self.to_hsv(),
-            ColorSpace::Cmyk => self.to_cmyk(),
-            ColorSpace::D65Gray => self.to_luma(),
+            ColorSpace::D65Gray => Self::Luma(self.to_luma()),
+            ColorSpace::Oklab => Self::Oklab(self.to_oklab()),
+            ColorSpace::Oklch => Self::Oklch(self.to_oklch()),
+            ColorSpace::Srgb => Self::Rgb(self.to_rgb()),
+            ColorSpace::LinearRgb => Self::LinearRgb(self.to_linear_rgb()),
+            ColorSpace::Cmyk => Self::Cmyk(self.to_cmyk()),
+            ColorSpace::Hsl => Self::Hsl(self.to_hsl()),
+            ColorSpace::Hsv => Self::Hsv(self.to_hsv()),
         }
     }
 
-    pub fn to_luma(self) -> Self {
-        Self::Luma(match self {
+    pub fn to_luma(self) -> Luma {
+        match self {
             Self::Luma(c) => c,
             Self::Oklab(c) => Luma::from_color(c),
             Self::Oklch(c) => Luma::from_color(c),
@@ -1302,11 +1298,11 @@ impl Color {
             Self::Cmyk(c) => Luma::from_color(c.to_rgba()),
             Self::Hsl(c) => Luma::from_color(c),
             Self::Hsv(c) => Luma::from_color(c),
-        })
+        }
     }
 
-    pub fn to_oklab(self) -> Self {
-        Self::Oklab(match self {
+    pub fn to_oklab(self) -> Oklab {
+        match self {
             Self::Luma(c) => Oklab::from_color(c),
             Self::Oklab(c) => c,
             Self::Oklch(c) => Oklab::from_color(c),
@@ -1315,11 +1311,11 @@ impl Color {
             Self::Cmyk(c) => Oklab::from_color(c.to_rgba()),
             Self::Hsl(c) => Oklab::from_color(c),
             Self::Hsv(c) => Oklab::from_color(c),
-        })
+        }
     }
 
-    pub fn to_oklch(self) -> Self {
-        Self::Oklch(match self {
+    pub fn to_oklch(self) -> Oklch {
+        match self {
             Self::Luma(c) => Oklch::from_color(c),
             Self::Oklab(c) => Oklch::from_color(c),
             Self::Oklch(c) => c,
@@ -1328,11 +1324,11 @@ impl Color {
             Self::Cmyk(c) => Oklch::from_color(c.to_rgba()),
             Self::Hsl(c) => Oklch::from_color(c),
             Self::Hsv(c) => Oklch::from_color(c),
-        })
+        }
     }
 
-    pub fn to_rgb(self) -> Self {
-        Self::Rgb(match self {
+    pub fn to_rgb(self) -> Rgb {
+        match self {
             Self::Luma(c) => Rgb::from_color(c),
             Self::Oklab(c) => Rgb::from_color(c),
             Self::Oklch(c) => Rgb::from_color(c),
@@ -1341,11 +1337,11 @@ impl Color {
             Self::Cmyk(c) => Rgb::from_color(c.to_rgba()),
             Self::Hsl(c) => Rgb::from_color(c),
             Self::Hsv(c) => Rgb::from_color(c),
-        })
+        }
     }
 
-    pub fn to_linear_rgb(self) -> Self {
-        Self::LinearRgb(match self {
+    pub fn to_linear_rgb(self) -> LinearRgb {
+        match self {
             Self::Luma(c) => LinearRgb::from_color(c),
             Self::Oklab(c) => LinearRgb::from_color(c),
             Self::Oklch(c) => LinearRgb::from_color(c),
@@ -1354,11 +1350,11 @@ impl Color {
             Self::Cmyk(c) => LinearRgb::from_color(c.to_rgba()),
             Self::Hsl(c) => Rgb::from_color(c).into_linear(),
             Self::Hsv(c) => Rgb::from_color(c).into_linear(),
-        })
+        }
     }
 
-    pub fn to_cmyk(self) -> Self {
-        Self::Cmyk(match self {
+    pub fn to_cmyk(self) -> Cmyk {
+        match self {
             Self::Luma(c) => Cmyk::from_luma(c),
             Self::Oklab(c) => Cmyk::from_rgba(Rgb::from_color(c)),
             Self::Oklch(c) => Cmyk::from_rgba(Rgb::from_color(c)),
@@ -1367,11 +1363,11 @@ impl Color {
             Self::Cmyk(c) => c,
             Self::Hsl(c) => Cmyk::from_rgba(Rgb::from_color(c)),
             Self::Hsv(c) => Cmyk::from_rgba(Rgb::from_color(c)),
-        })
+        }
     }
 
-    pub fn to_hsl(self) -> Self {
-        Self::Hsl(match self {
+    pub fn to_hsl(self) -> Hsl {
+        match self {
             Self::Luma(c) => Hsl::from_color(c),
             Self::Oklab(c) => Hsl::from_color(c),
             Self::Oklch(c) => Hsl::from_color(c),
@@ -1380,11 +1376,11 @@ impl Color {
             Self::Cmyk(c) => Hsl::from_color(c.to_rgba()),
             Self::Hsl(c) => c,
             Self::Hsv(c) => Hsl::from_color(c),
-        })
+        }
     }
 
-    pub fn to_hsv(self) -> Self {
-        Self::Hsv(match self {
+    pub fn to_hsv(self) -> Hsv {
+        match self {
             Self::Luma(c) => Hsv::from_color(c),
             Self::Oklab(c) => Hsv::from_color(c),
             Self::Oklch(c) => Hsv::from_color(c),
@@ -1393,7 +1389,7 @@ impl Color {
             Self::Cmyk(c) => Hsv::from_color(c.to_rgba()),
             Self::Hsl(c) => Hsv::from_color(c),
             Self::Hsv(c) => c,
-        })
+        }
     }
 }
 
diff --git a/crates/typst-render/src/paint.rs b/crates/typst-render/src/paint.rs
index ce92fd6a3..6eb9c5826 100644
--- a/crates/typst-render/src/paint.rs
+++ b/crates/typst-render/src/paint.rs
@@ -255,13 +255,13 @@ pub fn to_sk_paint<'a>(
 }
 
 pub fn to_sk_color(color: Color) -> sk::Color {
-    let [r, g, b, a] = color.to_rgb().to_vec4();
+    let (r, g, b, a) = color.to_rgb().into_components();
     sk::Color::from_rgba(r, g, b, a)
         .expect("components must always be in the range [0..=1]")
 }
 
 pub fn to_sk_color_u8(color: Color) -> sk::ColorU8 {
-    let [r, g, b, a] = color.to_rgb().to_vec4_u8();
+    let (r, g, b, a) = color.to_rgb().into_format::<u8, u8>().into_components();
     sk::ColorU8::from_rgba(r, g, b, a)
 }
 

From 15302dbe7a6bd04125c4a56fee24bbbacfb4cc2f Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 17:21:00 +0200
Subject: [PATCH 013/101] Add  `typst_utils::display`

---
 crates/typst-utils/src/lib.rs | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/crates/typst-utils/src/lib.rs b/crates/typst-utils/src/lib.rs
index abe6423df..4cfe0c046 100644
--- a/crates/typst-utils/src/lib.rs
+++ b/crates/typst-utils/src/lib.rs
@@ -23,7 +23,7 @@ pub use self::scalar::Scalar;
 #[doc(hidden)]
 pub use once_cell;
 
-use std::fmt::{Debug, Formatter};
+use std::fmt::{Debug, Display, Formatter};
 use std::hash::Hash;
 use std::iter::{Chain, Flatten, Rev};
 use std::num::{NonZeroU32, NonZeroUsize};
@@ -52,6 +52,25 @@ where
     Wrapper(f)
 }
 
+/// Turn a closure into a struct implementing [`Display`].
+pub fn display<F>(f: F) -> impl Display
+where
+    F: Fn(&mut Formatter) -> std::fmt::Result,
+{
+    struct Wrapper<F>(F);
+
+    impl<F> Display for Wrapper<F>
+    where
+        F: Fn(&mut Formatter) -> std::fmt::Result,
+    {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            self.0(f)
+        }
+    }
+
+    Wrapper(f)
+}
+
 /// Calculate a 128-bit siphash of a value.
 pub fn hash128<T: Hash + ?Sized>(value: &T) -> u128 {
     let mut state = SipHasher13::new();

From 3602d06a155a0567fe2b2e75a4d5970578d0f14f Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 19 Jun 2025 17:45:00 +0200
Subject: [PATCH 014/101] Support for generating native functions at runtime

---
 crates/typst-library/src/foundations/func.rs | 34 ++++++++++++++++----
 crates/typst-macros/src/func.rs              |  8 ++---
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/crates/typst-library/src/foundations/func.rs b/crates/typst-library/src/foundations/func.rs
index 27eb34eac..9ef812890 100644
--- a/crates/typst-library/src/foundations/func.rs
+++ b/crates/typst-library/src/foundations/func.rs
@@ -307,7 +307,7 @@ impl Func {
     ) -> SourceResult<Value> {
         match &self.repr {
             Repr::Native(native) => {
-                let value = (native.function)(engine, context, &mut args)?;
+                let value = (native.function.0)(engine, context, &mut args)?;
                 args.finish()?;
                 Ok(value)
             }
@@ -491,8 +491,8 @@ pub trait NativeFunc {
 /// Defines a native function.
 #[derive(Debug)]
 pub struct NativeFuncData {
-    /// Invokes the function from Typst.
-    pub function: fn(&mut Engine, Tracked<Context>, &mut Args) -> SourceResult<Value>,
+    /// The implementation of the function.
+    pub function: NativeFuncPtr,
     /// The function's normal name (e.g. `align`), as exposed to Typst.
     pub name: &'static str,
     /// The function's title case name (e.g. `Align`).
@@ -504,11 +504,11 @@ pub struct NativeFuncData {
     /// Whether this function makes use of context.
     pub contextual: bool,
     /// Definitions in the scope of the function.
-    pub scope: LazyLock<Scope>,
+    pub scope: DynLazyLock<Scope>,
     /// A list of parameter information for each parameter.
-    pub params: LazyLock<Vec<ParamInfo>>,
+    pub params: DynLazyLock<Vec<ParamInfo>>,
     /// Information about the return value of this function.
-    pub returns: LazyLock<CastInfo>,
+    pub returns: DynLazyLock<CastInfo>,
 }
 
 cast! {
@@ -516,6 +516,28 @@ cast! {
     self => Func::from(self).into_value(),
 }
 
+/// A pointer to a native function's implementation.
+pub struct NativeFuncPtr(pub &'static NativeFuncSignature);
+
+/// The signature of a native function's implementation.
+type NativeFuncSignature =
+    dyn Fn(&mut Engine, Tracked<Context>, &mut Args) -> SourceResult<Value> + Send + Sync;
+
+impl Debug for NativeFuncPtr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        f.pad("NativeFuncPtr(..)")
+    }
+}
+
+/// A `LazyLock` that uses a static closure for initialization instead of only
+/// working with function pointers.
+///
+/// Can be created from a normal function or closure by prepending with a `&`,
+/// e.g. `LazyLock::new(&|| "hello")`. Can be created from a dynamic closure
+/// by allocating and then leaking it. This is equivalent to having it
+/// statically allocated, but allows for it to be generated at runtime.
+type DynLazyLock<T> = LazyLock<T, &'static (dyn Fn() -> T + Send + Sync)>;
+
 /// Describes a function parameter.
 #[derive(Debug, Clone)]
 pub struct ParamInfo {
diff --git a/crates/typst-macros/src/func.rs b/crates/typst-macros/src/func.rs
index b8ab7a364..e953dc374 100644
--- a/crates/typst-macros/src/func.rs
+++ b/crates/typst-macros/src/func.rs
@@ -315,15 +315,15 @@ fn create_func_data(func: &Func) -> TokenStream {
 
     quote! {
         #foundations::NativeFuncData {
-            function: #closure,
+            function: #foundations::NativeFuncPtr(&#closure),
             name: #name,
             title: #title,
             docs: #docs,
             keywords: &[#(#keywords),*],
             contextual: #contextual,
-            scope: ::std::sync::LazyLock::new(|| #scope),
-            params: ::std::sync::LazyLock::new(|| ::std::vec![#(#params),*]),
-            returns:  ::std::sync::LazyLock::new(|| <#returns as #foundations::Reflect>::output()),
+            scope: ::std::sync::LazyLock::new(&|| #scope),
+            params: ::std::sync::LazyLock::new(&|| ::std::vec![#(#params),*]),
+            returns:  ::std::sync::LazyLock::new(&|| <#returns as #foundations::Reflect>::output()),
         }
     }
 }

From e9dc4bb20404037cf192c19f00a010ff3bb1a10b Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 23 Jun 2025 11:12:58 +0200
Subject: [PATCH 015/101] Typed HTML API (#6476)

---
 Cargo.lock                                    |   2 +-
 Cargo.toml                                    |   2 +-
 crates/typst-ide/src/complete.rs              |   9 +
 crates/typst-ide/src/tests.rs                 |   6 +-
 crates/typst-library/src/foundations/float.rs |  22 +
 crates/typst-library/src/html/dom.rs          | 460 ++++++----
 crates/typst-library/src/html/mod.rs          |   2 +
 crates/typst-library/src/html/typed.rs        | 868 ++++++++++++++++++
 crates/typst-utils/src/pico.rs                |  52 ++
 tests/ref/html/html-typed.html                |  63 ++
 tests/suite/html/typed.typ                    | 187 ++++
 11 files changed, 1513 insertions(+), 160 deletions(-)
 create mode 100644 crates/typst-library/src/html/typed.rs
 create mode 100644 tests/ref/html/html-typed.html
 create mode 100644 tests/suite/html/typed.typ

diff --git a/Cargo.lock b/Cargo.lock
index 218fa2e4d..58cac3c58 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2863,7 +2863,7 @@ dependencies = [
 [[package]]
 name = "typst-assets"
 version = "0.13.1"
-source = "git+https://github.com/typst/typst-assets?rev=c74e539#c74e539b090070a0c66fd007c550f5b6d3b724bd"
+source = "git+https://github.com/typst/typst-assets?rev=c1089b4#c1089b46c461bdde579c55caa941a3cc7dec3e8a"
 
 [[package]]
 name = "typst-cli"
diff --git a/Cargo.toml b/Cargo.toml
index 03141cbbf..72ab9094d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ typst-svg = { path = "crates/typst-svg", version = "0.13.1" }
 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 = "c74e539" }
+typst-assets = { git = "https://github.com/typst/typst-assets", rev = "c1089b4" }
 typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "fddbf8b" }
 arrayvec = "0.7.4"
 az = "1.2"
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index 47727743f..536423318 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -1848,4 +1848,13 @@ mod tests {
             .must_include(["\"New Computer Modern Math\""])
             .must_exclude(["\"Libertinus Serif\""]);
     }
+
+    #[test]
+    fn test_autocomplete_typed_html() {
+        test("#html.div(translate: )", -2)
+            .must_include(["true", "false"])
+            .must_exclude(["\"yes\"", "\"no\""]);
+        test("#html.input(value: )", -2).must_include(["float", "string", "red", "blue"]);
+        test("#html.div(role: )", -2).must_include(["\"alertdialog\""]);
+    }
 }
diff --git a/crates/typst-ide/src/tests.rs b/crates/typst-ide/src/tests.rs
index 5edc05f17..dd5c230ad 100644
--- a/crates/typst-ide/src/tests.rs
+++ b/crates/typst-ide/src/tests.rs
@@ -10,7 +10,7 @@ use typst::syntax::package::{PackageSpec, PackageVersion};
 use typst::syntax::{FileId, Source, VirtualPath};
 use typst::text::{Font, FontBook, TextElem, TextSize};
 use typst::utils::{singleton, LazyHash};
-use typst::{Library, World};
+use typst::{Feature, Library, World};
 
 use crate::IdeWorld;
 
@@ -168,7 +168,9 @@ fn library() -> Library {
     // Set page width to 120pt with 10pt margins, so that the inner page is
     // exactly 100pt wide. Page height is unbounded and font size is 10pt so
     // that it multiplies to nice round numbers.
-    let mut lib = typst::Library::default();
+    let mut lib = typst::Library::builder()
+        .with_features([Feature::Html].into_iter().collect())
+        .build();
     lib.styles
         .set(PageElem::set_width(Smart::Custom(Abs::pt(120.0).into())));
     lib.styles.set(PageElem::set_height(Smart::Auto));
diff --git a/crates/typst-library/src/foundations/float.rs b/crates/typst-library/src/foundations/float.rs
index 21d0a8d81..353e498d3 100644
--- a/crates/typst-library/src/foundations/float.rs
+++ b/crates/typst-library/src/foundations/float.rs
@@ -210,3 +210,25 @@ cast! {
 fn parse_float(s: EcoString) -> Result<f64, ParseFloatError> {
     s.replace(repr::MINUS_SIGN, "-").parse()
 }
+
+/// A floating-point number that must be positive (strictly larger than zero).
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
+pub struct PositiveF64(f64);
+
+impl PositiveF64 {
+    /// Wrap a float if it is positive.
+    pub fn new(value: f64) -> Option<Self> {
+        (value > 0.0).then_some(Self(value))
+    }
+
+    /// Get the underlying value.
+    pub fn get(self) -> f64 {
+        self.0
+    }
+}
+
+cast! {
+    PositiveF64,
+    self => self.get().into_value(),
+    v: f64 => Self::new(v).ok_or("number must be positive")?,
+}
diff --git a/crates/typst-library/src/html/dom.rs b/crates/typst-library/src/html/dom.rs
index 1b725d543..35d513c10 100644
--- a/crates/typst-library/src/html/dom.rs
+++ b/crates/typst-library/src/html/dom.rs
@@ -188,7 +188,7 @@ cast! {
         .collect::<HintedStrResult<_>>()?),
 }
 
-/// An attribute of an HTML.
+/// An attribute of an HTML element.
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct HtmlAttr(PicoStr);
 
@@ -347,135 +347,124 @@ pub mod charsets {
 }
 
 /// Predefined constants for HTML tags.
+#[allow(non_upper_case_globals)]
 pub mod tag {
     use super::HtmlTag;
 
-    macro_rules! tags {
-        ($($tag:ident)*) => {
-            $(#[allow(non_upper_case_globals)]
-            pub const $tag: HtmlTag = HtmlTag::constant(
-                stringify!($tag)
-            );)*
-        }
-    }
+    pub const a: HtmlTag = HtmlTag::constant("a");
+    pub const abbr: HtmlTag = HtmlTag::constant("abbr");
+    pub const address: HtmlTag = HtmlTag::constant("address");
+    pub const area: HtmlTag = HtmlTag::constant("area");
+    pub const article: HtmlTag = HtmlTag::constant("article");
+    pub const aside: HtmlTag = HtmlTag::constant("aside");
+    pub const audio: HtmlTag = HtmlTag::constant("audio");
+    pub const b: HtmlTag = HtmlTag::constant("b");
+    pub const base: HtmlTag = HtmlTag::constant("base");
+    pub const bdi: HtmlTag = HtmlTag::constant("bdi");
+    pub const bdo: HtmlTag = HtmlTag::constant("bdo");
+    pub const blockquote: HtmlTag = HtmlTag::constant("blockquote");
+    pub const body: HtmlTag = HtmlTag::constant("body");
+    pub const br: HtmlTag = HtmlTag::constant("br");
+    pub const button: HtmlTag = HtmlTag::constant("button");
+    pub const canvas: HtmlTag = HtmlTag::constant("canvas");
+    pub const caption: HtmlTag = HtmlTag::constant("caption");
+    pub const cite: HtmlTag = HtmlTag::constant("cite");
+    pub const code: HtmlTag = HtmlTag::constant("code");
+    pub const col: HtmlTag = HtmlTag::constant("col");
+    pub const colgroup: HtmlTag = HtmlTag::constant("colgroup");
+    pub const data: HtmlTag = HtmlTag::constant("data");
+    pub const datalist: HtmlTag = HtmlTag::constant("datalist");
+    pub const dd: HtmlTag = HtmlTag::constant("dd");
+    pub const del: HtmlTag = HtmlTag::constant("del");
+    pub const details: HtmlTag = HtmlTag::constant("details");
+    pub const dfn: HtmlTag = HtmlTag::constant("dfn");
+    pub const dialog: HtmlTag = HtmlTag::constant("dialog");
+    pub const div: HtmlTag = HtmlTag::constant("div");
+    pub const dl: HtmlTag = HtmlTag::constant("dl");
+    pub const dt: HtmlTag = HtmlTag::constant("dt");
+    pub const em: HtmlTag = HtmlTag::constant("em");
+    pub const embed: HtmlTag = HtmlTag::constant("embed");
+    pub const fieldset: HtmlTag = HtmlTag::constant("fieldset");
+    pub const figcaption: HtmlTag = HtmlTag::constant("figcaption");
+    pub const figure: HtmlTag = HtmlTag::constant("figure");
+    pub const footer: HtmlTag = HtmlTag::constant("footer");
+    pub const form: HtmlTag = HtmlTag::constant("form");
+    pub const h1: HtmlTag = HtmlTag::constant("h1");
+    pub const h2: HtmlTag = HtmlTag::constant("h2");
+    pub const h3: HtmlTag = HtmlTag::constant("h3");
+    pub const h4: HtmlTag = HtmlTag::constant("h4");
+    pub const h5: HtmlTag = HtmlTag::constant("h5");
+    pub const h6: HtmlTag = HtmlTag::constant("h6");
+    pub const head: HtmlTag = HtmlTag::constant("head");
+    pub const header: HtmlTag = HtmlTag::constant("header");
+    pub const hgroup: HtmlTag = HtmlTag::constant("hgroup");
+    pub const hr: HtmlTag = HtmlTag::constant("hr");
+    pub const html: HtmlTag = HtmlTag::constant("html");
+    pub const i: HtmlTag = HtmlTag::constant("i");
+    pub const iframe: HtmlTag = HtmlTag::constant("iframe");
+    pub const img: HtmlTag = HtmlTag::constant("img");
+    pub const input: HtmlTag = HtmlTag::constant("input");
+    pub const ins: HtmlTag = HtmlTag::constant("ins");
+    pub const kbd: HtmlTag = HtmlTag::constant("kbd");
+    pub const label: HtmlTag = HtmlTag::constant("label");
+    pub const legend: HtmlTag = HtmlTag::constant("legend");
+    pub const li: HtmlTag = HtmlTag::constant("li");
+    pub const link: HtmlTag = HtmlTag::constant("link");
+    pub const main: HtmlTag = HtmlTag::constant("main");
+    pub const map: HtmlTag = HtmlTag::constant("map");
+    pub const mark: HtmlTag = HtmlTag::constant("mark");
+    pub const menu: HtmlTag = HtmlTag::constant("menu");
+    pub const meta: HtmlTag = HtmlTag::constant("meta");
+    pub const meter: HtmlTag = HtmlTag::constant("meter");
+    pub const nav: HtmlTag = HtmlTag::constant("nav");
+    pub const noscript: HtmlTag = HtmlTag::constant("noscript");
+    pub const object: HtmlTag = HtmlTag::constant("object");
+    pub const ol: HtmlTag = HtmlTag::constant("ol");
+    pub const optgroup: HtmlTag = HtmlTag::constant("optgroup");
+    pub const option: HtmlTag = HtmlTag::constant("option");
+    pub const output: HtmlTag = HtmlTag::constant("output");
+    pub const p: HtmlTag = HtmlTag::constant("p");
+    pub const picture: HtmlTag = HtmlTag::constant("picture");
+    pub const pre: HtmlTag = HtmlTag::constant("pre");
+    pub const progress: HtmlTag = HtmlTag::constant("progress");
+    pub const q: HtmlTag = HtmlTag::constant("q");
+    pub const rp: HtmlTag = HtmlTag::constant("rp");
+    pub const rt: HtmlTag = HtmlTag::constant("rt");
+    pub const ruby: HtmlTag = HtmlTag::constant("ruby");
+    pub const s: HtmlTag = HtmlTag::constant("s");
+    pub const samp: HtmlTag = HtmlTag::constant("samp");
+    pub const script: HtmlTag = HtmlTag::constant("script");
+    pub const search: HtmlTag = HtmlTag::constant("search");
+    pub const section: HtmlTag = HtmlTag::constant("section");
+    pub const select: HtmlTag = HtmlTag::constant("select");
+    pub const slot: HtmlTag = HtmlTag::constant("slot");
+    pub const small: HtmlTag = HtmlTag::constant("small");
+    pub const source: HtmlTag = HtmlTag::constant("source");
+    pub const span: HtmlTag = HtmlTag::constant("span");
+    pub const strong: HtmlTag = HtmlTag::constant("strong");
+    pub const style: HtmlTag = HtmlTag::constant("style");
+    pub const sub: HtmlTag = HtmlTag::constant("sub");
+    pub const summary: HtmlTag = HtmlTag::constant("summary");
+    pub const sup: HtmlTag = HtmlTag::constant("sup");
+    pub const table: HtmlTag = HtmlTag::constant("table");
+    pub const tbody: HtmlTag = HtmlTag::constant("tbody");
+    pub const td: HtmlTag = HtmlTag::constant("td");
+    pub const template: HtmlTag = HtmlTag::constant("template");
+    pub const textarea: HtmlTag = HtmlTag::constant("textarea");
+    pub const tfoot: HtmlTag = HtmlTag::constant("tfoot");
+    pub const th: HtmlTag = HtmlTag::constant("th");
+    pub const thead: HtmlTag = HtmlTag::constant("thead");
+    pub const time: HtmlTag = HtmlTag::constant("time");
+    pub const title: HtmlTag = HtmlTag::constant("title");
+    pub const tr: HtmlTag = HtmlTag::constant("tr");
+    pub const track: HtmlTag = HtmlTag::constant("track");
+    pub const u: HtmlTag = HtmlTag::constant("u");
+    pub const ul: HtmlTag = HtmlTag::constant("ul");
+    pub const var: HtmlTag = HtmlTag::constant("var");
+    pub const video: HtmlTag = HtmlTag::constant("video");
+    pub const wbr: HtmlTag = HtmlTag::constant("wbr");
 
-    tags! {
-        a
-        abbr
-        address
-        area
-        article
-        aside
-        audio
-        b
-        base
-        bdi
-        bdo
-        blockquote
-        body
-        br
-        button
-        canvas
-        caption
-        cite
-        code
-        col
-        colgroup
-        data
-        datalist
-        dd
-        del
-        details
-        dfn
-        dialog
-        div
-        dl
-        dt
-        em
-        embed
-        fieldset
-        figcaption
-        figure
-        footer
-        form
-        h1
-        h2
-        h3
-        h4
-        h5
-        h6
-        head
-        header
-        hgroup
-        hr
-        html
-        i
-        iframe
-        img
-        input
-        ins
-        kbd
-        label
-        legend
-        li
-        link
-        main
-        map
-        mark
-        menu
-        meta
-        meter
-        nav
-        noscript
-        object
-        ol
-        optgroup
-        option
-        output
-        p
-        param
-        picture
-        pre
-        progress
-        q
-        rp
-        rt
-        ruby
-        s
-        samp
-        script
-        search
-        section
-        select
-        slot
-        small
-        source
-        span
-        strong
-        style
-        sub
-        summary
-        sup
-        table
-        tbody
-        td
-        template
-        textarea
-        tfoot
-        th
-        thead
-        time
-        title
-        tr
-        track
-        u
-        ul
-        var
-        video
-        wbr
-    }
-
-    /// Whether this is a void tag whose associated element may not have a
+    /// Whether this is a void tag whose associated element may not have
     /// children.
     pub fn is_void(tag: HtmlTag) -> bool {
         matches!(
@@ -490,7 +479,6 @@ pub mod tag {
                 | self::input
                 | self::link
                 | self::meta
-                | self::param
                 | self::source
                 | self::track
                 | self::wbr
@@ -629,36 +617,196 @@ pub mod tag {
     }
 }
 
-/// Predefined constants for HTML attributes.
-///
-/// Note: These are very incomplete.
 #[allow(non_upper_case_globals)]
+#[rustfmt::skip]
 pub mod attr {
-    use super::HtmlAttr;
-
-    macro_rules! attrs {
-        ($($attr:ident)*) => {
-            $(#[allow(non_upper_case_globals)]
-            pub const $attr: HtmlAttr = HtmlAttr::constant(
-                stringify!($attr)
-            );)*
-        }
-    }
-
-    attrs! {
-        charset
-        cite
-        colspan
-        content
-        href
-        name
-        reversed
-        role
-        rowspan
-        start
-        style
-        value
-    }
-
+    use crate::html::HtmlAttr;
+    pub const abbr: HtmlAttr = HtmlAttr::constant("abbr");
+    pub const accept: HtmlAttr = HtmlAttr::constant("accept");
+    pub const accept_charset: HtmlAttr = HtmlAttr::constant("accept-charset");
+    pub const accesskey: HtmlAttr = HtmlAttr::constant("accesskey");
+    pub const action: HtmlAttr = HtmlAttr::constant("action");
+    pub const allow: HtmlAttr = HtmlAttr::constant("allow");
+    pub const allowfullscreen: HtmlAttr = HtmlAttr::constant("allowfullscreen");
+    pub const alpha: HtmlAttr = HtmlAttr::constant("alpha");
+    pub const alt: HtmlAttr = HtmlAttr::constant("alt");
+    pub const aria_activedescendant: HtmlAttr = HtmlAttr::constant("aria-activedescendant");
+    pub const aria_atomic: HtmlAttr = HtmlAttr::constant("aria-atomic");
+    pub const aria_autocomplete: HtmlAttr = HtmlAttr::constant("aria-autocomplete");
+    pub const aria_busy: HtmlAttr = HtmlAttr::constant("aria-busy");
+    pub const aria_checked: HtmlAttr = HtmlAttr::constant("aria-checked");
+    pub const aria_colcount: HtmlAttr = HtmlAttr::constant("aria-colcount");
+    pub const aria_colindex: HtmlAttr = HtmlAttr::constant("aria-colindex");
+    pub const aria_colspan: HtmlAttr = HtmlAttr::constant("aria-colspan");
+    pub const aria_controls: HtmlAttr = HtmlAttr::constant("aria-controls");
+    pub const aria_current: HtmlAttr = HtmlAttr::constant("aria-current");
+    pub const aria_describedby: HtmlAttr = HtmlAttr::constant("aria-describedby");
+    pub const aria_details: HtmlAttr = HtmlAttr::constant("aria-details");
+    pub const aria_disabled: HtmlAttr = HtmlAttr::constant("aria-disabled");
+    pub const aria_errormessage: HtmlAttr = HtmlAttr::constant("aria-errormessage");
+    pub const aria_expanded: HtmlAttr = HtmlAttr::constant("aria-expanded");
+    pub const aria_flowto: HtmlAttr = HtmlAttr::constant("aria-flowto");
+    pub const aria_haspopup: HtmlAttr = HtmlAttr::constant("aria-haspopup");
+    pub const aria_hidden: HtmlAttr = HtmlAttr::constant("aria-hidden");
+    pub const aria_invalid: HtmlAttr = HtmlAttr::constant("aria-invalid");
+    pub const aria_keyshortcuts: HtmlAttr = HtmlAttr::constant("aria-keyshortcuts");
+    pub const aria_label: HtmlAttr = HtmlAttr::constant("aria-label");
+    pub const aria_labelledby: HtmlAttr = HtmlAttr::constant("aria-labelledby");
     pub const aria_level: HtmlAttr = HtmlAttr::constant("aria-level");
+    pub const aria_live: HtmlAttr = HtmlAttr::constant("aria-live");
+    pub const aria_modal: HtmlAttr = HtmlAttr::constant("aria-modal");
+    pub const aria_multiline: HtmlAttr = HtmlAttr::constant("aria-multiline");
+    pub const aria_multiselectable: HtmlAttr = HtmlAttr::constant("aria-multiselectable");
+    pub const aria_orientation: HtmlAttr = HtmlAttr::constant("aria-orientation");
+    pub const aria_owns: HtmlAttr = HtmlAttr::constant("aria-owns");
+    pub const aria_placeholder: HtmlAttr = HtmlAttr::constant("aria-placeholder");
+    pub const aria_posinset: HtmlAttr = HtmlAttr::constant("aria-posinset");
+    pub const aria_pressed: HtmlAttr = HtmlAttr::constant("aria-pressed");
+    pub const aria_readonly: HtmlAttr = HtmlAttr::constant("aria-readonly");
+    pub const aria_relevant: HtmlAttr = HtmlAttr::constant("aria-relevant");
+    pub const aria_required: HtmlAttr = HtmlAttr::constant("aria-required");
+    pub const aria_roledescription: HtmlAttr = HtmlAttr::constant("aria-roledescription");
+    pub const aria_rowcount: HtmlAttr = HtmlAttr::constant("aria-rowcount");
+    pub const aria_rowindex: HtmlAttr = HtmlAttr::constant("aria-rowindex");
+    pub const aria_rowspan: HtmlAttr = HtmlAttr::constant("aria-rowspan");
+    pub const aria_selected: HtmlAttr = HtmlAttr::constant("aria-selected");
+    pub const aria_setsize: HtmlAttr = HtmlAttr::constant("aria-setsize");
+    pub const aria_sort: HtmlAttr = HtmlAttr::constant("aria-sort");
+    pub const aria_valuemax: HtmlAttr = HtmlAttr::constant("aria-valuemax");
+    pub const aria_valuemin: HtmlAttr = HtmlAttr::constant("aria-valuemin");
+    pub const aria_valuenow: HtmlAttr = HtmlAttr::constant("aria-valuenow");
+    pub const aria_valuetext: HtmlAttr = HtmlAttr::constant("aria-valuetext");
+    pub const r#as: HtmlAttr = HtmlAttr::constant("as");
+    pub const r#async: HtmlAttr = HtmlAttr::constant("async");
+    pub const autocapitalize: HtmlAttr = HtmlAttr::constant("autocapitalize");
+    pub const autocomplete: HtmlAttr = HtmlAttr::constant("autocomplete");
+    pub const autocorrect: HtmlAttr = HtmlAttr::constant("autocorrect");
+    pub const autofocus: HtmlAttr = HtmlAttr::constant("autofocus");
+    pub const autoplay: HtmlAttr = HtmlAttr::constant("autoplay");
+    pub const blocking: HtmlAttr = HtmlAttr::constant("blocking");
+    pub const charset: HtmlAttr = HtmlAttr::constant("charset");
+    pub const checked: HtmlAttr = HtmlAttr::constant("checked");
+    pub const cite: HtmlAttr = HtmlAttr::constant("cite");
+    pub const class: HtmlAttr = HtmlAttr::constant("class");
+    pub const closedby: HtmlAttr = HtmlAttr::constant("closedby");
+    pub const color: HtmlAttr = HtmlAttr::constant("color");
+    pub const colorspace: HtmlAttr = HtmlAttr::constant("colorspace");
+    pub const cols: HtmlAttr = HtmlAttr::constant("cols");
+    pub const colspan: HtmlAttr = HtmlAttr::constant("colspan");
+    pub const command: HtmlAttr = HtmlAttr::constant("command");
+    pub const commandfor: HtmlAttr = HtmlAttr::constant("commandfor");
+    pub const content: HtmlAttr = HtmlAttr::constant("content");
+    pub const contenteditable: HtmlAttr = HtmlAttr::constant("contenteditable");
+    pub const controls: HtmlAttr = HtmlAttr::constant("controls");
+    pub const coords: HtmlAttr = HtmlAttr::constant("coords");
+    pub const crossorigin: HtmlAttr = HtmlAttr::constant("crossorigin");
+    pub const data: HtmlAttr = HtmlAttr::constant("data");
+    pub const datetime: HtmlAttr = HtmlAttr::constant("datetime");
+    pub const decoding: HtmlAttr = HtmlAttr::constant("decoding");
+    pub const default: HtmlAttr = HtmlAttr::constant("default");
+    pub const defer: HtmlAttr = HtmlAttr::constant("defer");
+    pub const dir: HtmlAttr = HtmlAttr::constant("dir");
+    pub const dirname: HtmlAttr = HtmlAttr::constant("dirname");
+    pub const disabled: HtmlAttr = HtmlAttr::constant("disabled");
+    pub const download: HtmlAttr = HtmlAttr::constant("download");
+    pub const draggable: HtmlAttr = HtmlAttr::constant("draggable");
+    pub const enctype: HtmlAttr = HtmlAttr::constant("enctype");
+    pub const enterkeyhint: HtmlAttr = HtmlAttr::constant("enterkeyhint");
+    pub const fetchpriority: HtmlAttr = HtmlAttr::constant("fetchpriority");
+    pub const r#for: HtmlAttr = HtmlAttr::constant("for");
+    pub const form: HtmlAttr = HtmlAttr::constant("form");
+    pub const formaction: HtmlAttr = HtmlAttr::constant("formaction");
+    pub const formenctype: HtmlAttr = HtmlAttr::constant("formenctype");
+    pub const formmethod: HtmlAttr = HtmlAttr::constant("formmethod");
+    pub const formnovalidate: HtmlAttr = HtmlAttr::constant("formnovalidate");
+    pub const formtarget: HtmlAttr = HtmlAttr::constant("formtarget");
+    pub const headers: HtmlAttr = HtmlAttr::constant("headers");
+    pub const height: HtmlAttr = HtmlAttr::constant("height");
+    pub const hidden: HtmlAttr = HtmlAttr::constant("hidden");
+    pub const high: HtmlAttr = HtmlAttr::constant("high");
+    pub const href: HtmlAttr = HtmlAttr::constant("href");
+    pub const hreflang: HtmlAttr = HtmlAttr::constant("hreflang");
+    pub const http_equiv: HtmlAttr = HtmlAttr::constant("http-equiv");
+    pub const id: HtmlAttr = HtmlAttr::constant("id");
+    pub const imagesizes: HtmlAttr = HtmlAttr::constant("imagesizes");
+    pub const imagesrcset: HtmlAttr = HtmlAttr::constant("imagesrcset");
+    pub const inert: HtmlAttr = HtmlAttr::constant("inert");
+    pub const inputmode: HtmlAttr = HtmlAttr::constant("inputmode");
+    pub const integrity: HtmlAttr = HtmlAttr::constant("integrity");
+    pub const is: HtmlAttr = HtmlAttr::constant("is");
+    pub const ismap: HtmlAttr = HtmlAttr::constant("ismap");
+    pub const itemid: HtmlAttr = HtmlAttr::constant("itemid");
+    pub const itemprop: HtmlAttr = HtmlAttr::constant("itemprop");
+    pub const itemref: HtmlAttr = HtmlAttr::constant("itemref");
+    pub const itemscope: HtmlAttr = HtmlAttr::constant("itemscope");
+    pub const itemtype: HtmlAttr = HtmlAttr::constant("itemtype");
+    pub const kind: HtmlAttr = HtmlAttr::constant("kind");
+    pub const label: HtmlAttr = HtmlAttr::constant("label");
+    pub const lang: HtmlAttr = HtmlAttr::constant("lang");
+    pub const list: HtmlAttr = HtmlAttr::constant("list");
+    pub const loading: HtmlAttr = HtmlAttr::constant("loading");
+    pub const r#loop: HtmlAttr = HtmlAttr::constant("loop");
+    pub const low: HtmlAttr = HtmlAttr::constant("low");
+    pub const max: HtmlAttr = HtmlAttr::constant("max");
+    pub const maxlength: HtmlAttr = HtmlAttr::constant("maxlength");
+    pub const media: HtmlAttr = HtmlAttr::constant("media");
+    pub const method: HtmlAttr = HtmlAttr::constant("method");
+    pub const min: HtmlAttr = HtmlAttr::constant("min");
+    pub const minlength: HtmlAttr = HtmlAttr::constant("minlength");
+    pub const multiple: HtmlAttr = HtmlAttr::constant("multiple");
+    pub const muted: HtmlAttr = HtmlAttr::constant("muted");
+    pub const name: HtmlAttr = HtmlAttr::constant("name");
+    pub const nomodule: HtmlAttr = HtmlAttr::constant("nomodule");
+    pub const nonce: HtmlAttr = HtmlAttr::constant("nonce");
+    pub const novalidate: HtmlAttr = HtmlAttr::constant("novalidate");
+    pub const open: HtmlAttr = HtmlAttr::constant("open");
+    pub const optimum: HtmlAttr = HtmlAttr::constant("optimum");
+    pub const pattern: HtmlAttr = HtmlAttr::constant("pattern");
+    pub const ping: HtmlAttr = HtmlAttr::constant("ping");
+    pub const placeholder: HtmlAttr = HtmlAttr::constant("placeholder");
+    pub const playsinline: HtmlAttr = HtmlAttr::constant("playsinline");
+    pub const popover: HtmlAttr = HtmlAttr::constant("popover");
+    pub const popovertarget: HtmlAttr = HtmlAttr::constant("popovertarget");
+    pub const popovertargetaction: HtmlAttr = HtmlAttr::constant("popovertargetaction");
+    pub const poster: HtmlAttr = HtmlAttr::constant("poster");
+    pub const preload: HtmlAttr = HtmlAttr::constant("preload");
+    pub const readonly: HtmlAttr = HtmlAttr::constant("readonly");
+    pub const referrerpolicy: HtmlAttr = HtmlAttr::constant("referrerpolicy");
+    pub const rel: HtmlAttr = HtmlAttr::constant("rel");
+    pub const required: HtmlAttr = HtmlAttr::constant("required");
+    pub const reversed: HtmlAttr = HtmlAttr::constant("reversed");
+    pub const role: HtmlAttr = HtmlAttr::constant("role");
+    pub const rows: HtmlAttr = HtmlAttr::constant("rows");
+    pub const rowspan: HtmlAttr = HtmlAttr::constant("rowspan");
+    pub const sandbox: HtmlAttr = HtmlAttr::constant("sandbox");
+    pub const scope: HtmlAttr = HtmlAttr::constant("scope");
+    pub const selected: HtmlAttr = HtmlAttr::constant("selected");
+    pub const shadowrootclonable: HtmlAttr = HtmlAttr::constant("shadowrootclonable");
+    pub const shadowrootcustomelementregistry: HtmlAttr = HtmlAttr::constant("shadowrootcustomelementregistry");
+    pub const shadowrootdelegatesfocus: HtmlAttr = HtmlAttr::constant("shadowrootdelegatesfocus");
+    pub const shadowrootmode: HtmlAttr = HtmlAttr::constant("shadowrootmode");
+    pub const shadowrootserializable: HtmlAttr = HtmlAttr::constant("shadowrootserializable");
+    pub const shape: HtmlAttr = HtmlAttr::constant("shape");
+    pub const size: HtmlAttr = HtmlAttr::constant("size");
+    pub const sizes: HtmlAttr = HtmlAttr::constant("sizes");
+    pub const slot: HtmlAttr = HtmlAttr::constant("slot");
+    pub const span: HtmlAttr = HtmlAttr::constant("span");
+    pub const spellcheck: HtmlAttr = HtmlAttr::constant("spellcheck");
+    pub const src: HtmlAttr = HtmlAttr::constant("src");
+    pub const srcdoc: HtmlAttr = HtmlAttr::constant("srcdoc");
+    pub const srclang: HtmlAttr = HtmlAttr::constant("srclang");
+    pub const srcset: HtmlAttr = HtmlAttr::constant("srcset");
+    pub const start: HtmlAttr = HtmlAttr::constant("start");
+    pub const step: HtmlAttr = HtmlAttr::constant("step");
+    pub const style: HtmlAttr = HtmlAttr::constant("style");
+    pub const tabindex: HtmlAttr = HtmlAttr::constant("tabindex");
+    pub const target: HtmlAttr = HtmlAttr::constant("target");
+    pub const title: HtmlAttr = HtmlAttr::constant("title");
+    pub const translate: HtmlAttr = HtmlAttr::constant("translate");
+    pub const r#type: HtmlAttr = HtmlAttr::constant("type");
+    pub const usemap: HtmlAttr = HtmlAttr::constant("usemap");
+    pub const value: HtmlAttr = HtmlAttr::constant("value");
+    pub const width: HtmlAttr = HtmlAttr::constant("width");
+    pub const wrap: HtmlAttr = HtmlAttr::constant("wrap");
+    pub const writingsuggestions: HtmlAttr = HtmlAttr::constant("writingsuggestions");
 }
diff --git a/crates/typst-library/src/html/mod.rs b/crates/typst-library/src/html/mod.rs
index 1d88781c1..7fc8adecd 100644
--- a/crates/typst-library/src/html/mod.rs
+++ b/crates/typst-library/src/html/mod.rs
@@ -1,6 +1,7 @@
 //! HTML output.
 
 mod dom;
+mod typed;
 
 pub use self::dom::*;
 
@@ -14,6 +15,7 @@ pub fn module() -> Module {
     html.start_category(crate::Category::Html);
     html.define_elem::<HtmlElem>();
     html.define_elem::<FrameElem>();
+    self::typed::define(&mut html);
     Module::new("html", html)
 }
 
diff --git a/crates/typst-library/src/html/typed.rs b/crates/typst-library/src/html/typed.rs
new file mode 100644
index 000000000..1e7c1ad6f
--- /dev/null
+++ b/crates/typst-library/src/html/typed.rs
@@ -0,0 +1,868 @@
+//! The typed HTML element API (e.g. `html.div`).
+//!
+//! The typed API is backed by generated data derived from the HTML
+//! specification. See [generated] and `tools/codegen`.
+
+use std::fmt::Write;
+use std::num::{NonZeroI64, NonZeroU64};
+use std::sync::LazyLock;
+
+use bumpalo::Bump;
+use comemo::Tracked;
+use ecow::{eco_format, eco_vec, EcoString};
+use typst_assets::html as data;
+use typst_macros::cast;
+
+use crate::diag::{bail, At, Hint, HintedStrResult, SourceResult};
+use crate::engine::Engine;
+use crate::foundations::{
+    Args, Array, AutoValue, CastInfo, Content, Context, Datetime, Dict, Duration,
+    FromValue, IntoValue, NativeFuncData, NativeFuncPtr, NoneValue, ParamInfo,
+    PositiveF64, Reflect, Scope, Str, Type, Value,
+};
+use crate::html::tag;
+use crate::html::{HtmlAttr, HtmlAttrs, HtmlElem, HtmlTag};
+use crate::layout::{Axes, Axis, Dir, Length};
+use crate::visualize::Color;
+
+/// Hook up all typed HTML definitions.
+pub(super) fn define(html: &mut Scope) {
+    for data in FUNCS.iter() {
+        html.define_func_with_data(data);
+    }
+}
+
+/// Lazily created functions for all typed HTML constructors.
+static FUNCS: LazyLock<Vec<NativeFuncData>> = LazyLock::new(|| {
+    // Leaking is okay here. It's not meaningfully different from having
+    // memory-managed values as `FUNCS` is a static.
+    let bump = Box::leak(Box::new(Bump::new()));
+    data::ELEMS.iter().map(|info| create_func_data(info, bump)).collect()
+});
+
+/// Creates metadata for a native HTML element constructor function.
+fn create_func_data(
+    element: &'static data::ElemInfo,
+    bump: &'static Bump,
+) -> NativeFuncData {
+    NativeFuncData {
+        function: NativeFuncPtr(bump.alloc(
+            move |_: &mut Engine, _: Tracked<Context>, args: &mut Args| {
+                construct(element, args)
+            },
+        )),
+        name: element.name,
+        title: {
+            let title = bump.alloc_str(element.name);
+            title[0..1].make_ascii_uppercase();
+            title
+        },
+        docs: element.docs,
+        keywords: &[],
+        contextual: false,
+        scope: LazyLock::new(&|| Scope::new()),
+        params: LazyLock::new(bump.alloc(move || create_param_info(element))),
+        returns: LazyLock::new(&|| CastInfo::Type(Type::of::<Content>())),
+    }
+}
+
+/// Creates parameter signature metadata for an element.
+fn create_param_info(element: &'static data::ElemInfo) -> Vec<ParamInfo> {
+    let mut params = vec![];
+    for attr in element.attributes() {
+        params.push(ParamInfo {
+            name: attr.name,
+            docs: attr.docs,
+            input: AttrType::convert(attr.ty).input(),
+            default: None,
+            positional: false,
+            named: true,
+            variadic: false,
+            required: false,
+            settable: false,
+        });
+    }
+    let tag = HtmlTag::constant(element.name);
+    if !tag::is_void(tag) {
+        params.push(ParamInfo {
+            name: "body",
+            docs: "The contents of the HTML element.",
+            input: CastInfo::Type(Type::of::<Content>()),
+            default: None,
+            positional: true,
+            named: false,
+            variadic: false,
+            required: false,
+            settable: false,
+        });
+    }
+    params
+}
+
+/// The native constructor function shared by all HTML elements.
+fn construct(element: &'static data::ElemInfo, args: &mut Args) -> SourceResult<Value> {
+    let mut attrs = HtmlAttrs::default();
+    let mut errors = eco_vec![];
+
+    args.items.retain(|item| {
+        let Some(name) = &item.name else { return true };
+        let Some(attr) = element.get_attr(name) else { return true };
+
+        let span = item.value.span;
+        let value = std::mem::take(&mut item.value.v);
+        let ty = AttrType::convert(attr.ty);
+        match ty.cast(value).at(span) {
+            Ok(Some(string)) => attrs.push(HtmlAttr::constant(attr.name), string),
+            Ok(None) => {}
+            Err(diags) => errors.extend(diags),
+        }
+
+        false
+    });
+
+    if !errors.is_empty() {
+        return Err(errors);
+    }
+
+    let tag = HtmlTag::constant(element.name);
+    let mut elem = HtmlElem::new(tag);
+    if !attrs.0.is_empty() {
+        elem.push_attrs(attrs);
+    }
+
+    if !tag::is_void(tag) {
+        let body = args.eat::<Content>()?;
+        elem.push_body(body);
+    }
+
+    Ok(elem.into_value())
+}
+
+/// A dynamic representation of an attribute's type.
+///
+/// See the documentation of [`data::Type`] for more details on variants.
+enum AttrType {
+    Presence,
+    Native(NativeType),
+    Strings(StringsType),
+    Union(UnionType),
+    List(ListType),
+}
+
+impl AttrType {
+    /// Converts the type definition into a representation suitable for casting
+    /// and reflection.
+    const fn convert(ty: data::Type) -> AttrType {
+        use data::Type;
+        match ty {
+            Type::Presence => Self::Presence,
+            Type::None => Self::of::<NoneValue>(),
+            Type::NoneEmpty => Self::of::<NoneEmpty>(),
+            Type::NoneUndefined => Self::of::<NoneUndefined>(),
+            Type::Auto => Self::of::<AutoValue>(),
+            Type::TrueFalse => Self::of::<TrueFalseBool>(),
+            Type::YesNo => Self::of::<YesNoBool>(),
+            Type::OnOff => Self::of::<OnOffBool>(),
+            Type::Int => Self::of::<i64>(),
+            Type::NonNegativeInt => Self::of::<u64>(),
+            Type::PositiveInt => Self::of::<NonZeroU64>(),
+            Type::Float => Self::of::<f64>(),
+            Type::PositiveFloat => Self::of::<PositiveF64>(),
+            Type::Str => Self::of::<Str>(),
+            Type::Char => Self::of::<char>(),
+            Type::Datetime => Self::of::<Datetime>(),
+            Type::Duration => Self::of::<Duration>(),
+            Type::Color => Self::of::<Color>(),
+            Type::HorizontalDir => Self::of::<HorizontalDir>(),
+            Type::IconSize => Self::of::<IconSize>(),
+            Type::ImageCandidate => Self::of::<ImageCandidate>(),
+            Type::SourceSize => Self::of::<SourceSize>(),
+            Type::Strings(start, end) => Self::Strings(StringsType { start, end }),
+            Type::Union(variants) => Self::Union(UnionType(variants)),
+            Type::List(inner, separator, shorthand) => {
+                Self::List(ListType { inner, separator, shorthand })
+            }
+        }
+    }
+
+    /// Produces the dynamic representation of an attribute type backed by a
+    /// native Rust type.
+    const fn of<T: IntoAttr>() -> Self {
+        Self::Native(NativeType::of::<T>())
+    }
+
+    /// See [`Reflect::input`].
+    fn input(&self) -> CastInfo {
+        match self {
+            Self::Presence => bool::input(),
+            Self::Native(ty) => (ty.input)(),
+            Self::Union(ty) => ty.input(),
+            Self::Strings(ty) => ty.input(),
+            Self::List(ty) => ty.input(),
+        }
+    }
+
+    /// See [`Reflect::castable`].
+    fn castable(&self, value: &Value) -> bool {
+        match self {
+            Self::Presence => bool::castable(value),
+            Self::Native(ty) => (ty.castable)(value),
+            Self::Union(ty) => ty.castable(value),
+            Self::Strings(ty) => ty.castable(value),
+            Self::List(ty) => ty.castable(value),
+        }
+    }
+
+    /// Tries to cast the value into this attribute's type and serialize it into
+    /// an HTML attribute string.
+    fn cast(&self, value: Value) -> HintedStrResult<Option<EcoString>> {
+        match self {
+            Self::Presence => value.cast::<bool>().map(|b| b.then(EcoString::new)),
+            Self::Native(ty) => (ty.cast)(value),
+            Self::Union(ty) => ty.cast(value),
+            Self::Strings(ty) => ty.cast(value),
+            Self::List(ty) => ty.cast(value),
+        }
+    }
+}
+
+/// An enumeration with generated string variants.
+///
+/// `start` and `end` are used to index into `data::ATTR_STRINGS`.
+struct StringsType {
+    start: usize,
+    end: usize,
+}
+
+impl StringsType {
+    fn input(&self) -> CastInfo {
+        CastInfo::Union(
+            self.strings()
+                .iter()
+                .map(|(val, desc)| CastInfo::Value(val.into_value(), desc))
+                .collect(),
+        )
+    }
+
+    fn castable(&self, value: &Value) -> bool {
+        match value {
+            Value::Str(s) => self.strings().iter().any(|&(v, _)| v == s.as_str()),
+            _ => false,
+        }
+    }
+
+    fn cast(&self, value: Value) -> HintedStrResult<Option<EcoString>> {
+        if self.castable(&value) {
+            value.cast().map(Some)
+        } else {
+            Err(self.input().error(&value))
+        }
+    }
+
+    fn strings(&self) -> &'static [(&'static str, &'static str)] {
+        &data::ATTR_STRINGS[self.start..self.end]
+    }
+}
+
+/// A type that accepts any of the contained types.
+struct UnionType(&'static [data::Type]);
+
+impl UnionType {
+    fn input(&self) -> CastInfo {
+        CastInfo::Union(self.iter().map(|ty| ty.input()).collect())
+    }
+
+    fn castable(&self, value: &Value) -> bool {
+        self.iter().any(|ty| ty.castable(value))
+    }
+
+    fn cast(&self, value: Value) -> HintedStrResult<Option<EcoString>> {
+        for item in self.iter() {
+            if item.castable(&value) {
+                return item.cast(value);
+            }
+        }
+        Err(self.input().error(&value))
+    }
+
+    fn iter(&self) -> impl Iterator<Item = AttrType> {
+        self.0.iter().map(|&ty| AttrType::convert(ty))
+    }
+}
+
+/// A list of items separated by a specific separator char.
+///
+/// - <https://html.spec.whatwg.org/#space-separated-tokens>
+/// - <https://html.spec.whatwg.org/#comma-separated-tokens>
+struct ListType {
+    inner: &'static data::Type,
+    separator: char,
+    shorthand: bool,
+}
+
+impl ListType {
+    fn input(&self) -> CastInfo {
+        if self.shorthand {
+            Array::input() + self.inner().input()
+        } else {
+            Array::input()
+        }
+    }
+
+    fn castable(&self, value: &Value) -> bool {
+        Array::castable(value) || (self.shorthand && self.inner().castable(value))
+    }
+
+    fn cast(&self, value: Value) -> HintedStrResult<Option<EcoString>> {
+        let ty = self.inner();
+        if Array::castable(&value) {
+            let array = value.cast::<Array>()?;
+            let mut out = EcoString::new();
+            for (i, item) in array.into_iter().enumerate() {
+                let item = ty.cast(item)?.unwrap();
+                if item.as_str().contains(self.separator) {
+                    let buf;
+                    let name = match self.separator {
+                        ' ' => "space",
+                        ',' => "comma",
+                        _ => {
+                            buf = eco_format!("'{}'", self.separator);
+                            buf.as_str()
+                        }
+                    };
+                    bail!(
+                        "array item may not contain a {name}";
+                        hint: "the array attribute will be encoded as a \
+                               {name}-separated string"
+                    );
+                }
+                if i > 0 {
+                    out.push(self.separator);
+                    if self.separator == ',' {
+                        out.push(' ');
+                    }
+                }
+                out.push_str(&item);
+            }
+            Ok(Some(out))
+        } else if self.shorthand && ty.castable(&value) {
+            let item = ty.cast(value)?.unwrap();
+            Ok(Some(item))
+        } else {
+            Err(self.input().error(&value))
+        }
+    }
+
+    fn inner(&self) -> AttrType {
+        AttrType::convert(*self.inner)
+    }
+}
+
+/// A dynamic representation of attribute backed by a native type implementing
+/// - the standard `Reflect` and `FromValue` traits for casting from a value,
+/// - the special `IntoAttr` trait for conversion into an attribute string.
+#[derive(Copy, Clone)]
+struct NativeType {
+    input: fn() -> CastInfo,
+    cast: fn(Value) -> HintedStrResult<Option<EcoString>>,
+    castable: fn(&Value) -> bool,
+}
+
+impl NativeType {
+    /// Creates a dynamic native type from a native Rust type.
+    const fn of<T: IntoAttr>() -> Self {
+        Self {
+            cast: |value| {
+                let this = value.cast::<T>()?;
+                Ok(Some(this.into_attr()))
+            },
+            input: T::input,
+            castable: T::castable,
+        }
+    }
+}
+
+/// Casts a native type into an HTML attribute.
+pub trait IntoAttr: FromValue {
+    /// Turn the value into an attribute string.
+    fn into_attr(self) -> EcoString;
+}
+
+impl IntoAttr for Str {
+    fn into_attr(self) -> EcoString {
+        self.into()
+    }
+}
+
+/// A boolean that is encoded as a string:
+/// - `false` is encoded as `"false"`
+/// - `true` is encoded as `"true"`
+pub struct TrueFalseBool(pub bool);
+
+cast! {
+    TrueFalseBool,
+    v: bool => Self(v),
+}
+
+impl IntoAttr for TrueFalseBool {
+    fn into_attr(self) -> EcoString {
+        if self.0 { "true" } else { "false" }.into()
+    }
+}
+
+/// A boolean that is encoded as a string:
+/// - `false` is encoded as `"no"`
+/// - `true` is encoded as `"yes"`
+pub struct YesNoBool(pub bool);
+
+cast! {
+    YesNoBool,
+    v: bool => Self(v),
+}
+
+impl IntoAttr for YesNoBool {
+    fn into_attr(self) -> EcoString {
+        if self.0 { "yes" } else { "no" }.into()
+    }
+}
+
+/// A boolean that is encoded as a string:
+/// - `false` is encoded as `"off"`
+/// - `true` is encoded as `"on"`
+pub struct OnOffBool(pub bool);
+
+cast! {
+    OnOffBool,
+    v: bool => Self(v),
+}
+
+impl IntoAttr for OnOffBool {
+    fn into_attr(self) -> EcoString {
+        if self.0 { "on" } else { "off" }.into()
+    }
+}
+
+impl IntoAttr for AutoValue {
+    fn into_attr(self) -> EcoString {
+        "auto".into()
+    }
+}
+
+impl IntoAttr for NoneValue {
+    fn into_attr(self) -> EcoString {
+        "none".into()
+    }
+}
+
+/// A `none` value that turns into an empty string attribute.
+struct NoneEmpty;
+
+cast! {
+    NoneEmpty,
+    _: NoneValue => NoneEmpty,
+}
+
+impl IntoAttr for NoneEmpty {
+    fn into_attr(self) -> EcoString {
+        "".into()
+    }
+}
+
+/// A `none` value that turns into the string `"undefined"`.
+struct NoneUndefined;
+
+cast! {
+    NoneUndefined,
+    _: NoneValue => NoneUndefined,
+}
+
+impl IntoAttr for NoneUndefined {
+    fn into_attr(self) -> EcoString {
+        "undefined".into()
+    }
+}
+
+impl IntoAttr for char {
+    fn into_attr(self) -> EcoString {
+        eco_format!("{self}")
+    }
+}
+
+impl IntoAttr for i64 {
+    fn into_attr(self) -> EcoString {
+        eco_format!("{self}")
+    }
+}
+
+impl IntoAttr for u64 {
+    fn into_attr(self) -> EcoString {
+        eco_format!("{self}")
+    }
+}
+
+impl IntoAttr for NonZeroI64 {
+    fn into_attr(self) -> EcoString {
+        eco_format!("{self}")
+    }
+}
+
+impl IntoAttr for NonZeroU64 {
+    fn into_attr(self) -> EcoString {
+        eco_format!("{self}")
+    }
+}
+
+impl IntoAttr for f64 {
+    fn into_attr(self) -> EcoString {
+        // HTML float literal allows all the things that Rust's float `Display`
+        // impl produces.
+        eco_format!("{self}")
+    }
+}
+
+impl IntoAttr for PositiveF64 {
+    fn into_attr(self) -> EcoString {
+        self.get().into_attr()
+    }
+}
+
+impl IntoAttr for Color {
+    fn into_attr(self) -> EcoString {
+        eco_format!("{}", css::color(self))
+    }
+}
+
+impl IntoAttr for Duration {
+    fn into_attr(self) -> EcoString {
+        // https://html.spec.whatwg.org/#valid-duration-string
+        let mut out = EcoString::new();
+        macro_rules! part {
+            ($s:literal) => {
+                if !out.is_empty() {
+                    out.push(' ');
+                }
+                write!(out, $s).unwrap();
+            };
+        }
+
+        let [weeks, days, hours, minutes, seconds] = self.decompose();
+        if weeks > 0 {
+            part!("{weeks}w");
+        }
+        if days > 0 {
+            part!("{days}d");
+        }
+        if hours > 0 {
+            part!("{hours}h");
+        }
+        if minutes > 0 {
+            part!("{minutes}m");
+        }
+        if seconds > 0 || out.is_empty() {
+            part!("{seconds}s");
+        }
+
+        out
+    }
+}
+
+impl IntoAttr for Datetime {
+    fn into_attr(self) -> EcoString {
+        let fmt = typst_utils::display(|f| match self {
+            Self::Date(date) => datetime::date(f, date),
+            Self::Time(time) => datetime::time(f, time),
+            Self::Datetime(datetime) => datetime::datetime(f, datetime),
+        });
+        eco_format!("{fmt}")
+    }
+}
+
+mod datetime {
+    use std::fmt::{self, Formatter, Write};
+
+    pub fn datetime(f: &mut Formatter, datetime: time::PrimitiveDateTime) -> fmt::Result {
+        // https://html.spec.whatwg.org/#valid-global-date-and-time-string
+        date(f, datetime.date())?;
+        f.write_char('T')?;
+        time(f, datetime.time())
+    }
+
+    pub fn date(f: &mut Formatter, date: time::Date) -> fmt::Result {
+        // https://html.spec.whatwg.org/#valid-date-string
+        write!(f, "{:04}-{:02}-{:02}", date.year(), date.month() as u8, date.day())
+    }
+
+    pub fn time(f: &mut Formatter, time: time::Time) -> fmt::Result {
+        // https://html.spec.whatwg.org/#valid-time-string
+        write!(f, "{:02}:{:02}", time.hour(), time.minute())?;
+        if time.second() > 0 {
+            write!(f, ":{:02}", time.second())?;
+        }
+        Ok(())
+    }
+}
+
+/// A direction on the X axis: `ltr` or `rtl`.
+pub struct HorizontalDir(Dir);
+
+cast! {
+    HorizontalDir,
+    v: Dir => {
+        if v.axis() == Axis::Y {
+            bail!("direction must be horizontal");
+        }
+        Self(v)
+    },
+}
+
+impl IntoAttr for HorizontalDir {
+    fn into_attr(self) -> EcoString {
+        self.0.into_attr()
+    }
+}
+
+impl IntoAttr for Dir {
+    fn into_attr(self) -> EcoString {
+        match self {
+            Self::LTR => "ltr".into(),
+            Self::RTL => "rtl".into(),
+            Self::TTB => "ttb".into(),
+            Self::BTT => "btt".into(),
+        }
+    }
+}
+
+/// A width/height pair for `<link rel="icon" sizes="..." />`.
+pub struct IconSize(Axes<u64>);
+
+cast! {
+    IconSize,
+    v: Axes<u64> => Self(v),
+}
+
+impl IntoAttr for IconSize {
+    fn into_attr(self) -> EcoString {
+        eco_format!("{}x{}", self.0.x, self.0.y)
+    }
+}
+
+/// <https://html.spec.whatwg.org/#image-candidate-string>
+pub struct ImageCandidate(EcoString);
+
+cast! {
+    ImageCandidate,
+    mut v: Dict => {
+        let src = v.take("src")?.cast::<EcoString>()?;
+        let width: Option<NonZeroU64> =
+            v.take("width").ok().map(Value::cast).transpose()?;
+        let density: Option<PositiveF64> =
+            v.take("density").ok().map(Value::cast).transpose()?;
+        v.finish(&["src", "width", "density"])?;
+
+        if src.is_empty() {
+            bail!("`src` must not be empty");
+        } else if src.starts_with(',') || src.ends_with(',') {
+            bail!("`src` must not start or end with a comma");
+        }
+
+        let mut out = src;
+        match (width, density) {
+            (None, None) => {}
+            (Some(width), None) => write!(out, " {width}w").unwrap(),
+            (None, Some(density)) => write!(out, " {}d", density.get()).unwrap(),
+            (Some(_), Some(_)) => bail!("cannot specify both `width` and `density`"),
+        }
+
+        Self(out)
+    },
+}
+
+impl IntoAttr for ImageCandidate {
+    fn into_attr(self) -> EcoString {
+        self.0
+    }
+}
+
+/// <https://html.spec.whatwg.org/multipage/images.html#valid-source-size-list>
+pub struct SourceSize(EcoString);
+
+cast! {
+    SourceSize,
+    mut v: Dict => {
+        let condition = v.take("condition")?.cast::<EcoString>()?;
+        let size = v
+            .take("size")?
+            .cast::<Length>()
+            .hint("CSS lengths that are not expressible as Typst lengths are not yet supported")
+            .hint("you can use `html.elem` to create a raw attribute")?;
+        Self(eco_format!("({condition}) {}", css::length(size)))
+    },
+}
+
+impl IntoAttr for SourceSize {
+    fn into_attr(self) -> EcoString {
+        self.0
+    }
+}
+
+/// Conversion from Typst data types into CSS data types.
+///
+/// This can be moved elsewhere once we start supporting more CSS stuff.
+mod css {
+    use std::fmt::{self, Display};
+
+    use typst_utils::Numeric;
+
+    use crate::layout::Length;
+    use crate::visualize::{Color, Hsl, LinearRgb, Oklab, Oklch, Rgb};
+
+    pub fn length(length: Length) -> impl Display {
+        typst_utils::display(move |f| match (length.abs.is_zero(), length.em.is_zero()) {
+            (false, false) => {
+                write!(f, "calc({}pt + {}em)", length.abs.to_pt(), length.em.get())
+            }
+            (true, false) => write!(f, "{}em", length.em.get()),
+            (_, true) => write!(f, "{}pt", length.abs.to_pt()),
+        })
+    }
+
+    pub fn color(color: Color) -> impl Display {
+        typst_utils::display(move |f| match color {
+            Color::Rgb(_) | Color::Cmyk(_) | Color::Luma(_) => rgb(f, color.to_rgb()),
+            Color::Oklab(v) => oklab(f, v),
+            Color::Oklch(v) => oklch(f, v),
+            Color::LinearRgb(v) => linear_rgb(f, v),
+            Color::Hsl(_) | Color::Hsv(_) => hsl(f, color.to_hsl()),
+        })
+    }
+
+    fn oklab(f: &mut fmt::Formatter<'_>, v: Oklab) -> fmt::Result {
+        write!(
+            f,
+            "oklab({} {} {}{})",
+            percent(v.l),
+            number(v.a),
+            number(v.b),
+            alpha(v.alpha)
+        )
+    }
+
+    fn oklch(f: &mut fmt::Formatter<'_>, v: Oklch) -> fmt::Result {
+        write!(
+            f,
+            "oklch({} {} {}deg{})",
+            percent(v.l),
+            number(v.chroma),
+            number(v.hue.into_degrees()),
+            alpha(v.alpha)
+        )
+    }
+
+    fn rgb(f: &mut fmt::Formatter<'_>, v: Rgb) -> fmt::Result {
+        if let Some(v) = rgb_to_8_bit_lossless(v) {
+            let (r, g, b, a) = v.into_components();
+            write!(f, "#{r:02x}{g:02x}{b:02x}")?;
+            if a != u8::MAX {
+                write!(f, "{a:02x}")?;
+            }
+            Ok(())
+        } else {
+            write!(
+                f,
+                "rgb({} {} {}{})",
+                percent(v.red),
+                percent(v.green),
+                percent(v.blue),
+                alpha(v.alpha)
+            )
+        }
+    }
+
+    /// Converts an f32 RGBA color to its 8-bit representation if the result is
+    /// [very close](is_very_close) to the original.
+    fn rgb_to_8_bit_lossless(
+        v: Rgb,
+    ) -> Option<palette::rgb::Rgba<palette::encoding::Srgb, u8>> {
+        let l = v.into_format::<u8, u8>();
+        let h = l.into_format::<f32, f32>();
+        (is_very_close(v.red, h.red)
+            && is_very_close(v.blue, h.blue)
+            && is_very_close(v.green, h.green)
+            && is_very_close(v.alpha, h.alpha))
+        .then_some(l)
+    }
+
+    fn linear_rgb(f: &mut fmt::Formatter<'_>, v: LinearRgb) -> fmt::Result {
+        write!(
+            f,
+            "color(srgb-linear {} {} {}{})",
+            percent(v.red),
+            percent(v.green),
+            percent(v.blue),
+            alpha(v.alpha),
+        )
+    }
+
+    fn hsl(f: &mut fmt::Formatter<'_>, v: Hsl) -> fmt::Result {
+        write!(
+            f,
+            "hsl({}deg {} {}{})",
+            number(v.hue.into_degrees()),
+            percent(v.saturation),
+            percent(v.lightness),
+            alpha(v.alpha),
+        )
+    }
+
+    /// Displays an alpha component if it not 1.
+    fn alpha(value: f32) -> impl Display {
+        typst_utils::display(move |f| {
+            if !is_very_close(value, 1.0) {
+                write!(f, " / {}", percent(value))?;
+            }
+            Ok(())
+        })
+    }
+
+    /// Displays a rounded percentage.
+    ///
+    /// For a percentage, two significant digits after the comma gives us a
+    /// precision of 1/10_000, which is more than 12 bits (see `is_very_close`).
+    fn percent(ratio: f32) -> impl Display {
+        typst_utils::display(move |f| {
+            write!(f, "{}%", typst_utils::round_with_precision(ratio as f64 * 100.0, 2))
+        })
+    }
+
+    /// Rounds a number for display.
+    ///
+    /// For a number between 0 and 1, four significant digits give us a
+    /// precision of 1/10_000, which is more than 12 bits (see `is_very_close`).
+    fn number(value: f32) -> impl Display {
+        typst_utils::round_with_precision(value as f64, 4)
+    }
+
+    /// Whether two component values are close enough that there is no
+    /// difference when encoding them with 12-bit. 12 bit is the highest
+    /// reasonable color bit depth found in the industry.
+    fn is_very_close(a: f32, b: f32) -> bool {
+        const MAX_BIT_DEPTH: u32 = 12;
+        const EPS: f32 = 0.5 / 2_i32.pow(MAX_BIT_DEPTH) as f32;
+        (a - b).abs() < EPS
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tags_and_attr_const_internible() {
+        for elem in data::ELEMS {
+            let _ = HtmlTag::constant(elem.name);
+        }
+        for attr in data::ATTRS {
+            let _ = HtmlAttr::constant(attr.name);
+        }
+    }
+}
diff --git a/crates/typst-utils/src/pico.rs b/crates/typst-utils/src/pico.rs
index 3aa4570f2..9f4a2fde7 100644
--- a/crates/typst-utils/src/pico.rs
+++ b/crates/typst-utils/src/pico.rs
@@ -204,18 +204,70 @@ mod exceptions {
     use std::cmp::Ordering;
 
     /// A global list of non-bitcode-encodable compile-time internible strings.
+    ///
+    /// Must be sorted.
     pub const LIST: &[&str] = &[
+        "accept-charset",
+        "allowfullscreen",
+        "aria-activedescendant",
+        "aria-autocomplete",
+        "aria-colcount",
+        "aria-colindex",
+        "aria-controls",
+        "aria-describedby",
+        "aria-disabled",
+        "aria-dropeffect",
+        "aria-errormessage",
+        "aria-expanded",
+        "aria-haspopup",
+        "aria-keyshortcuts",
+        "aria-labelledby",
+        "aria-multiline",
+        "aria-multiselectable",
+        "aria-orientation",
+        "aria-placeholder",
+        "aria-posinset",
+        "aria-readonly",
+        "aria-relevant",
+        "aria-required",
+        "aria-roledescription",
+        "aria-rowcount",
+        "aria-rowindex",
+        "aria-selected",
+        "aria-valuemax",
+        "aria-valuemin",
+        "aria-valuenow",
+        "aria-valuetext",
+        "autocapitalize",
         "cjk-latin-spacing",
+        "contenteditable",
         "discretionary-ligatures",
+        "fetchpriority",
+        "formnovalidate",
         "h5",
         "h6",
         "historical-ligatures",
         "number-clearance",
         "number-margin",
         "numbering-scope",
+        "onbeforeprint",
+        "onbeforeunload",
+        "onlanguagechange",
+        "onmessageerror",
+        "onrejectionhandled",
+        "onunhandledrejection",
         "page-numbering",
         "par-line-marker",
+        "popovertarget",
+        "popovertargetaction",
+        "referrerpolicy",
+        "shadowrootclonable",
+        "shadowrootcustomelementregistry",
+        "shadowrootdelegatesfocus",
+        "shadowrootmode",
+        "shadowrootserializable",
         "transparentize",
+        "writingsuggestions",
     ];
 
     /// Try to find the index of an exception if it exists.
diff --git a/tests/ref/html/html-typed.html b/tests/ref/html/html-typed.html
new file mode 100644
index 000000000..ef62538fe
--- /dev/null
+++ b/tests/ref/html/html-typed.html
@@ -0,0 +1,63 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <div id="hi"></div>
+    <div aria-autocomplete="none"></div>
+    <div aria-expanded="undefined"></div>
+    <link referrerpolicy>
+    <div></div>
+    <div autofocus></div>
+    <div></div>
+    <div hidden></div>
+    <div aria-atomic="false"></div>
+    <div aria-atomic="true"></div>
+    <div translate="no"></div>
+    <div translate="yes"></div>
+    <form autocomplete="off"></form>
+    <form autocomplete="on"></form>
+    <div accesskey="K"></div>
+    <div aria-colcount="2"></div>
+    <object width="120" height="10"></object>
+    <td rowspan="2"></td>
+    <meter low="3.4" high="7.9"></meter>
+    <div class="alpha"></div>
+    <div class="alpha beta"></div>
+    <div class="alpha beta"></div>
+    <div><input accept="image/jpeg"></div>
+    <div><input accept="image/jpeg, image/png"></div>
+    <div><input accept="image/jpeg, image/png"></div>
+    <area coords="2.3, 4, 5.6">
+    <link color="#ff4136">
+    <link color="rgb(100% 32.94% 29.06%)">
+    <link color="rgb(50% 50% 50%)">
+    <link color="#958677">
+    <link color="oklab(27% 0.08 -0.012 / 50%)">
+    <link color="color(srgb-linear 20% 30% 40% / 50%)">
+    <link color="hsl(20deg 10% 20%)">
+    <link color="hsl(30deg 11.11% 27%)">
+    <div><time datetime="3w 4s"></time></div>
+    <div><time datetime="1d 4m"></time></div>
+    <div><time datetime="0s"></time></div>
+    <div><time datetime="2005-07-10"></time></div>
+    <div><time datetime="0000-02-01"></time></div>
+    <div><time datetime="06:30"></time></div>
+    <div><time datetime="0000-02-01T11:11"></time></div>
+    <div><time datetime="0000-02-01T06:00:09"></time></div>
+    <div dir="ltr">RTL</div>
+    <img src="image.png" alt="My wonderful image" srcset="/image-120px.png 120w, /image-60px.png 60w" sizes="(min-width: 800px) 400pt, (min-width: 400px) 250pt">
+    <form enctype="text/plain"></form>
+    <form role="complementary"></form>
+    <div hidden="until-found"></div>
+    <div aria-checked="false"></div>
+    <div aria-checked="true"></div>
+    <div aria-checked="mixed"></div>
+    <div><input value="5.6"></div>
+    <div><input value="#ff4136"></div>
+    <div><input min="3" max="9"></div>
+    <link rel="icon" sizes="32x24 64x48">
+  </body>
+</html>
diff --git a/tests/suite/html/typed.typ b/tests/suite/html/typed.typ
new file mode 100644
index 000000000..e8fa9f6e7
--- /dev/null
+++ b/tests/suite/html/typed.typ
@@ -0,0 +1,187 @@
+--- html-typed html ---
+// String
+#html.div(id: "hi")
+
+// Different kinds of options.
+#html.div(aria-autocomplete: none) // "none"
+#html.div(aria-expanded: none) // "undefined"
+#html.link(referrerpolicy: none) // present
+
+// Different kinds of bools.
+#html.div(autofocus: false) // absent
+#html.div(autofocus: true) // present
+#html.div(hidden: false) // absent
+#html.div(hidden: true) // present
+#html.div(aria-atomic: false) // "false"
+#html.div(aria-atomic: true) // "true"
+#html.div(translate: false) // "no"
+#html.div(translate: true) // "yes"
+#html.form(autocomplete: false) // "on"
+#html.form(autocomplete: true) // "off"
+
+// Char
+#html.div(accesskey: "K")
+
+// Int
+#html.div(aria-colcount: 2)
+#html.object(width: 120, height: 10)
+#html.td(rowspan: 2)
+
+// Float
+#html.meter(low: 3.4, high: 7.9)
+
+// Space-separated strings.
+#html.div(class: "alpha")
+#html.div(class: "alpha beta")
+#html.div(class: ("alpha", "beta"))
+
+// Comma-separated strings.
+#html.div(html.input(accept: "image/jpeg"))
+#html.div(html.input(accept: "image/jpeg, image/png"))
+#html.div(html.input(accept: ("image/jpeg", "image/png")))
+
+// Comma-separated floats.
+#html.area(coords: (2.3, 4, 5.6))
+
+// Colors.
+#for c in (
+  red,
+  red.lighten(10%),
+  luma(50%),
+  cmyk(10%, 20%, 30%, 40%),
+  oklab(27%, 20%, -3%, 50%),
+  color.linear-rgb(20%, 30%, 40%, 50%),
+  color.hsl(20deg, 10%, 20%),
+  color.hsv(30deg, 20%, 30%),
+) {
+  html.link(color: c)
+}
+
+// Durations & datetimes.
+#for d in (
+  duration(weeks: 3, seconds: 4),
+  duration(days: 1, minutes: 4),
+  duration(),
+  datetime(day: 10, month: 7, year: 2005),
+  datetime(day: 1, month: 2, year: 0),
+  datetime(hour: 6, minute: 30, second: 0),
+  datetime(day: 1, month: 2, year: 0, hour: 11, minute: 11, second: 0),
+  datetime(day: 1, month: 2, year: 0, hour: 6, minute: 0, second: 9),
+) {
+  html.div(html.time(datetime: d))
+}
+
+// Direction
+#html.div(dir: ltr)[RTL]
+
+// Image candidate and source size.
+#html.img(
+  src: "image.png",
+  alt: "My wonderful image",
+  srcset: (
+    (src: "/image-120px.png", width: 120),
+    (src: "/image-60px.png", width: 60),
+  ),
+  sizes: (
+    (condition: "min-width: 800px", size: 400pt),
+    (condition: "min-width: 400px", size: 250pt),
+  )
+)
+
+// String enum.
+#html.form(enctype: "text/plain")
+#html.form(role: "complementary")
+#html.div(hidden: "until-found")
+
+// Or.
+#html.div(aria-checked: false)
+#html.div(aria-checked: true)
+#html.div(aria-checked: "mixed")
+
+// Input value.
+#html.div(html.input(value: 5.6))
+#html.div(html.input(value: red))
+#html.div(html.input(min: 3, max: 9))
+
+// Icon size.
+#html.link(rel: "icon", sizes: ((32, 24), (64, 48)))
+
+--- html-typed-dir-str html ---
+// Error: 16-21 expected direction or auto, found string
+#html.div(dir: "ltr")
+
+--- html-typed-char-too-long html ---
+// Error: 22-35 expected exactly one character
+#html.div(accesskey: ("Ctrl", "K"))
+
+--- html-typed-int-negative html ---
+// Error: 18-21 number must be at least zero
+#html.img(width: -10)
+
+--- html-typed-int-zero html ---
+// Error: 22-23 number must be positive
+#html.textarea(rows: 0)
+
+--- html-typed-float-negative html ---
+// Error: 19-23 number must be positive
+#html.input(step: -3.4)
+
+--- html-typed-string-array-with-space html ---
+// Error: 18-41 array item may not contain a space
+// Hint: 18-41 the array attribute will be encoded as a space-separated string
+#html.div(class: ("alpha beta", "gamma"))
+
+--- html-typed-float-array-invalid-shorthand html ---
+// Error: 20-23 expected array, found float
+#html.area(coords: 4.5)
+
+--- html-typed-dir-vertical html ---
+// Error: 16-19 direction must be horizontal
+#html.div(dir: ttb)
+
+--- html-typed-string-enum-invalid html ---
+// Error: 21-28 expected "application/x-www-form-urlencoded", "multipart/form-data", or "text/plain"
+#html.form(enctype: "utf-8")
+
+--- html-typed-or-invalid ---
+// Error: 25-31 expected boolean or "mixed"
+#html.div(aria-checked: "nope")
+
+--- html-typed-string-enum-or-array-invalid ---
+// Error: 27-33 expected array, "additions", "additions text", "all", "removals", or "text"
+// Error: 49-54 expected boolean or "mixed"
+#html.link(aria-relevant: "nope", aria-checked: "yes")
+
+--- html-typed-srcset-both-width-and-density html ---
+// Error: 19-64 cannot specify both `width` and `density`
+#html.img(srcset: ((src: "img.png", width: 120, density: 0.5),))
+
+--- html-typed-srcset-src-comma html ---
+// Error: 19-50 `src` must not start or end with a comma
+#html.img(srcset: ((src: "img.png,", width: 50),))
+
+--- html-typed-sizes-string-size html ---
+// Error: 18-66 expected length, found string
+// Hint: 18-66 CSS lengths that are not expressible as Typst lengths are not yet supported
+// Hint: 18-66 you can use `html.elem` to create a raw attribute
+#html.img(sizes: ((condition: "min-width: 100px", size: "10px"),))
+
+--- html-typed-input-value-invalid html ---
+// Error: 20-25 expected string, float, datetime, color, or array, found boolean
+#html.input(value: false)
+
+--- html-typed-input-bound-invalid html ---
+// Error: 18-21 expected string, float, or datetime, found color
+#html.input(min: red)
+
+--- html-typed-icon-size-invalid html ---
+// Error: 32-45 expected array, found string
+#html.link(rel: "icon", sizes: "10x20 20x30")
+
+--- html-typed-hidden-none html ---
+// Error: 19-23 expected boolean or "until-found", found none
+#html.div(hidden: none)
+
+--- html-typed-invalid-body html ---
+// Error: 10-14 unexpected argument
+#html.img[hi]

From fbb02f40d96e0a9d41d19a575fca4d8e9c344119 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 23 Jun 2025 14:18:41 +0200
Subject: [PATCH 016/101] Consistent codepoint formatting in HTML and PDF error
 messages

---
 crates/typst-html/src/encode.rs |  2 +-
 crates/typst-pdf/src/convert.rs | 17 ++++++++++-------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index c6a6a7bce..eb25ab1ec 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -165,7 +165,7 @@ fn write_escape(w: &mut Writer, c: char) -> StrResult<()> {
         c if charsets::is_w3c_text_char(c) && c != '\r' => {
             write!(w.buf, "&#x{:x};", c as u32).unwrap()
         }
-        _ => bail!("the character {} cannot be encoded in HTML", c.repr()),
+        _ => bail!("the character `{}` cannot be encoded in HTML", c.repr()),
     }
     Ok(())
 }
diff --git a/crates/typst-pdf/src/convert.rs b/crates/typst-pdf/src/convert.rs
index f5ca31730..645d56f11 100644
--- a/crates/typst-pdf/src/convert.rs
+++ b/crates/typst-pdf/src/convert.rs
@@ -13,7 +13,7 @@ use krilla::surface::Surface;
 use krilla::{Document, SerializeSettings};
 use krilla_svg::render_svg_glyph;
 use typst_library::diag::{bail, error, SourceDiagnostic, SourceResult};
-use typst_library::foundations::NativeElement;
+use typst_library::foundations::{NativeElement, Repr};
 use typst_library::introspection::Location;
 use typst_library::layout::{
     Abs, Frame, FrameItem, GroupItem, PagedDocument, Size, Transform,
@@ -429,14 +429,18 @@ fn convert_error(
             display_font(gc.fonts_backward.get(f).unwrap());
             hint: "try using a different font"
         ),
-        ValidationError::InvalidCodepointMapping(_, _, cp, loc) => {
-            if let Some(c) = cp.map(|c| eco_format!("{:#06x}", c as u32)) {
+        ValidationError::InvalidCodepointMapping(_, _, c, loc) => {
+            if let Some(c) = c {
                 let msg = if loc.is_some() {
                     "the PDF contains text with"
                 } else {
                     "the text contains"
                 };
-                error!(to_span(*loc), "{prefix} {msg} the disallowed codepoint {c}")
+                error!(
+                    to_span(*loc),
+                    "{prefix} {msg} the disallowed codepoint `{}`",
+                    c.repr()
+                )
             } else {
                 // I think this code path is in theory unreachable,
                 // but just to be safe.
@@ -454,13 +458,12 @@ fn convert_error(
             }
         }
         ValidationError::UnicodePrivateArea(_, _, c, loc) => {
-            let code_point = eco_format!("{:#06x}", *c as u32);
             let msg = if loc.is_some() { "the PDF" } else { "the text" };
             error!(
                 to_span(*loc),
-                "{prefix} {msg} contains the codepoint {code_point}";
+                "{prefix} {msg} contains the codepoint `{}`", c.repr();
                 hint: "codepoints from the Unicode private area are \
-                       forbidden in this export mode"
+                       forbidden in this export mode",
             )
         }
         ValidationError::Transparency(loc) => {

From c1b2aee1a941f49d5eb8c04c9b19841dbeb1b27d Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 23 Jun 2025 14:21:35 +0200
Subject: [PATCH 017/101] Test runner support for HTML export errors

---
 tests/src/run.rs            | 45 +++++++++++++++++++++++--------------
 tests/suite/html/syntax.typ |  3 +++
 2 files changed, 31 insertions(+), 17 deletions(-)
 create mode 100644 tests/suite/html/syntax.typ

diff --git a/tests/src/run.rs b/tests/src/run.rs
index 76ce1299f..1d93ba392 100644
--- a/tests/src/run.rs
+++ b/tests/src/run.rs
@@ -4,7 +4,7 @@ use std::path::PathBuf;
 
 use ecow::eco_vec;
 use tiny_skia as sk;
-use typst::diag::{SourceDiagnostic, Warned};
+use typst::diag::{SourceDiagnostic, SourceResult, Warned};
 use typst::html::HtmlDocument;
 use typst::layout::{Abs, Frame, FrameItem, PagedDocument, Transform};
 use typst::visualize::Color;
@@ -82,17 +82,26 @@ impl<'a> Runner<'a> {
     /// Run test specific to document format.
     fn run_test<D: OutputType>(&mut self) {
         let Warned { output, warnings } = typst::compile(&self.world);
-        let (doc, errors) = match output {
+        let (doc, mut errors) = match output {
             Ok(doc) => (Some(doc), eco_vec![]),
             Err(errors) => (None, errors),
         };
 
-        if doc.is_none() && errors.is_empty() {
+        D::check_custom(self, doc.as_ref());
+
+        let output = doc.and_then(|doc: D| match doc.make_live() {
+            Ok(live) => Some((doc, live)),
+            Err(list) => {
+                errors.extend(list);
+                None
+            }
+        });
+
+        if output.is_none() && errors.is_empty() {
             log!(self, "no document, but also no errors");
         }
 
-        D::check_custom(self, doc.as_ref());
-        self.check_output(doc.as_ref());
+        self.check_output(output);
 
         for error in &errors {
             self.check_diagnostic(NoteKind::Error, error);
@@ -128,12 +137,12 @@ impl<'a> Runner<'a> {
     }
 
     /// Check that the document output is correct.
-    fn check_output<D: OutputType>(&mut self, document: Option<&D>) {
+    fn check_output<D: OutputType>(&mut self, output: Option<(D, D::Live)>) {
         let live_path = D::live_path(&self.test.name);
         let ref_path = D::ref_path(&self.test.name);
         let ref_data = std::fs::read(&ref_path);
 
-        let Some(document) = document else {
+        let Some((document, live)) = output else {
             if ref_data.is_ok() {
                 log!(self, "missing document");
                 log!(self, "  ref       | {}", ref_path.display());
@@ -141,7 +150,7 @@ impl<'a> Runner<'a> {
             return;
         };
 
-        let skippable = match D::is_skippable(document) {
+        let skippable = match D::is_skippable(&document) {
             Ok(skippable) => skippable,
             Err(()) => {
                 log!(self, "document has zero pages");
@@ -157,7 +166,6 @@ impl<'a> Runner<'a> {
         }
 
         // Render and save live version.
-        let live = document.make_live();
         document.save_live(&self.test.name, &live);
 
         // Compare against reference output if available.
@@ -214,9 +222,13 @@ impl<'a> Runner<'a> {
             return;
         }
 
-        let message = diag.message.replace("\\", "/");
+        let message = if diag.message.contains("\\u{") {
+            &diag.message
+        } else {
+            &diag.message.replace("\\", "/")
+        };
         let range = self.world.range(diag.span);
-        self.validate_note(kind, diag.span.id(), range.clone(), &message);
+        self.validate_note(kind, diag.span.id(), range.clone(), message);
 
         // Check hints.
         for hint in &diag.hints {
@@ -359,7 +371,7 @@ trait OutputType: Document {
     }
 
     /// Produces the live output.
-    fn make_live(&self) -> Self::Live;
+    fn make_live(&self) -> SourceResult<Self::Live>;
 
     /// Saves the live output.
     fn save_live(&self, name: &str, live: &Self::Live);
@@ -406,8 +418,8 @@ impl OutputType for PagedDocument {
         }
     }
 
-    fn make_live(&self) -> Self::Live {
-        render(self, 1.0)
+    fn make_live(&self) -> SourceResult<Self::Live> {
+        Ok(render(self, 1.0))
     }
 
     fn save_live(&self, name: &str, live: &Self::Live) {
@@ -471,9 +483,8 @@ impl OutputType for HtmlDocument {
         format!("{}/html/{}.html", crate::REF_PATH, name).into()
     }
 
-    fn make_live(&self) -> Self::Live {
-        // TODO: Do this earlier to be able to process export errors.
-        typst_html::html(self).unwrap()
+    fn make_live(&self) -> SourceResult<Self::Live> {
+        typst_html::html(self)
     }
 
     fn save_live(&self, name: &str, live: &Self::Live) {
diff --git a/tests/suite/html/syntax.typ b/tests/suite/html/syntax.typ
new file mode 100644
index 000000000..af671ef58
--- /dev/null
+++ b/tests/suite/html/syntax.typ
@@ -0,0 +1,3 @@
+--- html-non-char html ---
+// Error: 1-9 the character `"\u{fdd0}"` cannot be encoded in HTML
+\u{fdd0}

From 9050ee1639a20463e3cafce58964c9ef0fa38205 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 23 Jun 2025 14:22:09 +0200
Subject: [PATCH 018/101] Turn non-empty void element into export error

---
 crates/typst-html/src/encode.rs | 3 +++
 crates/typst-html/src/lib.rs    | 3 ---
 tests/suite/html/syntax.typ     | 4 ++++
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index eb25ab1ec..2bfa78a72 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -89,6 +89,9 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     w.buf.push('>');
 
     if tag::is_void(element.tag) {
+        if !element.children.is_empty() {
+            bail!(element.span, "HTML void elements must not have children");
+        }
         return Ok(());
     }
 
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index 7d78a5da4..703948f66 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -180,9 +180,6 @@ fn handle(
         if let Some(body) = elem.body(styles) {
             children = html_fragment(engine, body, locator.next(&elem.span()), styles)?;
         }
-        if tag::is_void(elem.tag) && !children.is_empty() {
-            bail!(elem.span(), "HTML void elements may not have children");
-        }
         let element = HtmlElement {
             tag: elem.tag,
             attrs: elem.attrs(styles).clone(),
diff --git a/tests/suite/html/syntax.typ b/tests/suite/html/syntax.typ
index af671ef58..c95fa06ed 100644
--- a/tests/suite/html/syntax.typ
+++ b/tests/suite/html/syntax.typ
@@ -1,3 +1,7 @@
 --- html-non-char html ---
 // Error: 1-9 the character `"\u{fdd0}"` cannot be encoded in HTML
 \u{fdd0}
+
+--- html-void-element-with-children html ---
+// Error: 2-27 HTML void elements must not have children
+#html.elem("img", [Hello])

From f8dc1ad3bdbe20ec25379427e6afba36c75ec08c Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 23 Jun 2025 14:30:22 +0200
Subject: [PATCH 019/101] Handle pre elements that start with a newline

---
 crates/typst-html/src/encode.rs                 | 17 +++++++++++++++++
 .../html/html-pre-starting-with-newline.html    | 17 +++++++++++++++++
 tests/suite/html/syntax.typ                     |  5 +++++
 3 files changed, 39 insertions(+)
 create mode 100644 tests/ref/html/html-pre-starting-with-newline.html

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 2bfa78a72..82a5df47c 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -97,6 +97,11 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
 
     let pretty = w.pretty;
     if !element.children.is_empty() {
+        // See HTML spec § 13.1.2.5.
+        if element.tag == tag::pre && starts_with_newline(element) {
+            w.buf.push('\n');
+        }
+
         let pretty_inside = allows_pretty_inside(element.tag)
             && element.children.iter().any(|node| match node {
                 HtmlNode::Element(child) => wants_pretty_around(child.tag),
@@ -133,6 +138,18 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     Ok(())
 }
 
+/// Whether the first character in the element is a newline.
+fn starts_with_newline(element: &HtmlElement) -> bool {
+    for child in &element.children {
+        match child {
+            HtmlNode::Tag(_) => {}
+            HtmlNode::Text(text, _) => return text.starts_with(['\n', '\r']),
+            _ => return false,
+        }
+    }
+    false
+}
+
 /// Whether we are allowed to add an extra newline at the start and end of the
 /// element's contents.
 ///
diff --git a/tests/ref/html/html-pre-starting-with-newline.html b/tests/ref/html/html-pre-starting-with-newline.html
new file mode 100644
index 000000000..676d1a803
--- /dev/null
+++ b/tests/ref/html/html-pre-starting-with-newline.html
@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <pre>hello</pre>
+    <pre>
+
+hello</pre>
+    <pre>
+
+
+hello</pre>
+  </body>
+</html>
diff --git a/tests/suite/html/syntax.typ b/tests/suite/html/syntax.typ
index c95fa06ed..fb5caf3bd 100644
--- a/tests/suite/html/syntax.typ
+++ b/tests/suite/html/syntax.typ
@@ -5,3 +5,8 @@
 --- html-void-element-with-children html ---
 // Error: 2-27 HTML void elements must not have children
 #html.elem("img", [Hello])
+
+--- html-pre-starting-with-newline html ---
+#html.pre("hello")
+#html.pre("\nhello")
+#html.pre("\n\nhello")

From c2e2fd99f69665e2361a1129dd04121a5b2c61a2 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 23 Jun 2025 14:35:52 +0200
Subject: [PATCH 020/101] Extract `write_children` function

---
 crates/typst-html/src/encode.rs | 81 ++++++++++++++++++---------------
 1 file changed, 44 insertions(+), 37 deletions(-)

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 82a5df47c..758bf0b91 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -28,7 +28,7 @@ struct Writer {
     pretty: bool,
 }
 
-/// Write a newline and indent, if pretty printing is enabled.
+/// Writes a newline and indent, if pretty printing is enabled.
 fn write_indent(w: &mut Writer) {
     if w.pretty {
         w.buf.push('\n');
@@ -38,7 +38,7 @@ fn write_indent(w: &mut Writer) {
     }
 }
 
-/// Encode an HTML node into the writer.
+/// Encodes an HTML node into the writer.
 fn write_node(w: &mut Writer, node: &HtmlNode) -> SourceResult<()> {
     match node {
         HtmlNode::Tag(_) => {}
@@ -49,7 +49,7 @@ fn write_node(w: &mut Writer, node: &HtmlNode) -> SourceResult<()> {
     Ok(())
 }
 
-/// Encode plain text into the writer.
+/// Encodes plain text into the writer.
 fn write_text(w: &mut Writer, text: &str, span: Span) -> SourceResult<()> {
     for c in text.chars() {
         if charsets::is_valid_in_normal_element_text(c) {
@@ -61,7 +61,7 @@ fn write_text(w: &mut Writer, text: &str, span: Span) -> SourceResult<()> {
     Ok(())
 }
 
-/// Encode one element into the write.
+/// Encodes one element into the writer.
 fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     w.buf.push('<');
     w.buf.push_str(&element.tag.resolve());
@@ -95,41 +95,9 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
         return Ok(());
     }
 
-    let pretty = w.pretty;
     if !element.children.is_empty() {
-        // See HTML spec § 13.1.2.5.
-        if element.tag == tag::pre && starts_with_newline(element) {
-            w.buf.push('\n');
-        }
-
-        let pretty_inside = allows_pretty_inside(element.tag)
-            && element.children.iter().any(|node| match node {
-                HtmlNode::Element(child) => wants_pretty_around(child.tag),
-                _ => false,
-            });
-
-        w.pretty &= pretty_inside;
-        let mut indent = w.pretty;
-
-        w.level += 1;
-        for c in &element.children {
-            let pretty_around = match c {
-                HtmlNode::Tag(_) => continue,
-                HtmlNode::Element(child) => w.pretty && wants_pretty_around(child.tag),
-                HtmlNode::Text(..) | HtmlNode::Frame(_) => false,
-            };
-
-            if core::mem::take(&mut indent) || pretty_around {
-                write_indent(w);
-            }
-            write_node(w, c)?;
-            indent = pretty_around;
-        }
-        w.level -= 1;
-
-        write_indent(w);
+        write_children(w, element)?;
     }
-    w.pretty = pretty;
 
     w.buf.push_str("</");
     w.buf.push_str(&element.tag.resolve());
@@ -138,6 +106,45 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     Ok(())
 }
 
+/// Encodes the children of an element.
+fn write_children(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
+    // See HTML spec § 13.1.2.5.
+    if element.tag == tag::pre && starts_with_newline(element) {
+        w.buf.push('\n');
+    }
+
+    let pretty = w.pretty;
+    let pretty_inside = allows_pretty_inside(element.tag)
+        && element.children.iter().any(|node| match node {
+            HtmlNode::Element(child) => wants_pretty_around(child.tag),
+            _ => false,
+        });
+
+    w.pretty &= pretty_inside;
+    let mut indent = w.pretty;
+
+    w.level += 1;
+    for c in &element.children {
+        let pretty_around = match c {
+            HtmlNode::Tag(_) => continue,
+            HtmlNode::Element(child) => w.pretty && wants_pretty_around(child.tag),
+            HtmlNode::Text(..) | HtmlNode::Frame(_) => false,
+        };
+
+        if core::mem::take(&mut indent) || pretty_around {
+            write_indent(w);
+        }
+        write_node(w, c)?;
+        indent = pretty_around;
+    }
+    w.level -= 1;
+
+    write_indent(w);
+    w.pretty = pretty;
+
+    Ok(())
+}
+
 /// Whether the first character in the element is a newline.
 fn starts_with_newline(element: &HtmlElement) -> bool {
     for child in &element.children {

From bf8ef2a4a5ffa9c30fce9fc254ffcf982634e4c6 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 23 Jun 2025 15:54:52 +0200
Subject: [PATCH 021/101] Properly handle raw text elements

---
 crates/typst-html/src/encode.rs               | 110 +++++++++++++++++-
 ...capable-raw-text-contains-closing-tag.html |   8 ++
 tests/ref/html/html-script.html               |  21 ++++
 tests/ref/html/html-style.html                |  14 +++
 tests/suite/html/syntax.typ                   |  51 ++++++++
 5 files changed, 202 insertions(+), 2 deletions(-)
 create mode 100644 tests/ref/html/html-escapable-raw-text-contains-closing-tag.html
 create mode 100644 tests/ref/html/html-script.html
 create mode 100644 tests/ref/html/html-style.html

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 758bf0b91..adcb6e032 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -2,7 +2,9 @@ use std::fmt::Write;
 
 use typst_library::diag::{bail, At, SourceResult, StrResult};
 use typst_library::foundations::Repr;
-use typst_library::html::{charsets, tag, HtmlDocument, HtmlElement, HtmlNode, HtmlTag};
+use typst_library::html::{
+    attr, charsets, tag, HtmlDocument, HtmlElement, HtmlNode, HtmlTag,
+};
 use typst_library::layout::Frame;
 use typst_syntax::Span;
 
@@ -95,7 +97,9 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
         return Ok(());
     }
 
-    if !element.children.is_empty() {
+    if tag::is_raw(element.tag) {
+        write_raw(w, element)?;
+    } else if !element.children.is_empty() {
         write_children(w, element)?;
     }
 
@@ -157,6 +161,108 @@ fn starts_with_newline(element: &HtmlElement) -> bool {
     false
 }
 
+/// Encodes the contents of a raw text element.
+fn write_raw(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
+    let text = collect_raw_text(element)?;
+
+    if let Some(closing) = find_closing_tag(&text, element.tag) {
+        bail!(
+            element.span,
+            "HTML raw text element cannot contain its own closing tag";
+            hint: "the sequence `{closing}` appears in the raw text",
+        )
+    }
+
+    let mode = if w.pretty { RawMode::of(element, &text) } else { RawMode::Keep };
+    match mode {
+        RawMode::Keep => {
+            w.buf.push_str(&text);
+        }
+        RawMode::Wrap => {
+            w.buf.push('\n');
+            w.buf.push_str(&text);
+            write_indent(w);
+        }
+        RawMode::Indent => {
+            w.level += 1;
+            for line in text.lines() {
+                write_indent(w);
+                w.buf.push_str(line);
+            }
+            w.level -= 1;
+            write_indent(w);
+        }
+    }
+
+    Ok(())
+}
+
+/// Collects the textual contents of a raw text element.
+fn collect_raw_text(element: &HtmlElement) -> SourceResult<String> {
+    let mut output = String::new();
+    for c in &element.children {
+        match c {
+            HtmlNode::Tag(_) => continue,
+            HtmlNode::Text(text, _) => output.push_str(text),
+            HtmlNode::Element(_) | HtmlNode::Frame(_) => {
+                let span = match c {
+                    HtmlNode::Element(child) => child.span,
+                    _ => element.span,
+                };
+                bail!(span, "HTML raw text element cannot have non-text children")
+            }
+        };
+    }
+    Ok(output)
+}
+
+/// Finds a closing sequence for the given tag in the text, if it exists.
+///
+/// See HTML spec § 13.1.2.6.
+fn find_closing_tag(text: &str, tag: HtmlTag) -> Option<&str> {
+    let s = tag.resolve();
+    let len = s.len();
+    text.match_indices("</").find_map(|(i, _)| {
+        let rest = &text[i + 2..];
+        let disallowed = rest.len() >= len
+            && rest[..len].eq_ignore_ascii_case(&s)
+            && rest[len..].starts_with(['\t', '\n', '\u{c}', '\r', ' ', '>', '/']);
+        disallowed.then(|| &text[i..i + 2 + len])
+    })
+}
+
+/// How to format the contents of a raw text element.
+enum RawMode {
+    /// Just don't touch it.
+    Keep,
+    /// Newline after the opening and newline + indent before the closing tag.
+    Wrap,
+    /// Newlines after opening and before closing tag and each line indented.
+    Indent,
+}
+
+impl RawMode {
+    fn of(element: &HtmlElement, text: &str) -> Self {
+        match element.tag {
+            tag::script
+                if !element.attrs.0.iter().any(|(attr, value)| {
+                    *attr == attr::r#type && value != "text/javascript"
+                }) =>
+            {
+                // Template literals can be multi-line, so indent may change
+                // the semantics of the JavaScript.
+                if text.contains('`') {
+                    Self::Wrap
+                } else {
+                    Self::Indent
+                }
+            }
+            tag::style => Self::Indent,
+            _ => Self::Keep,
+        }
+    }
+}
+
 /// Whether we are allowed to add an extra newline at the start and end of the
 /// element's contents.
 ///
diff --git a/tests/ref/html/html-escapable-raw-text-contains-closing-tag.html b/tests/ref/html/html-escapable-raw-text-contains-closing-tag.html
new file mode 100644
index 000000000..9e0b96433
--- /dev/null
+++ b/tests/ref/html/html-escapable-raw-text-contains-closing-tag.html
@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body><textarea>hello &lt;/textarea></textarea></body>
+</html>
diff --git a/tests/ref/html/html-script.html b/tests/ref/html/html-script.html
new file mode 100644
index 000000000..81b74765a
--- /dev/null
+++ b/tests/ref/html/html-script.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <script>
+      const x = 1
+      const y = 2
+      console.log(x < y, Math.max(1, 2))
+    </script>
+    <script>
+console.log(`Hello
+World`)
+    </script>
+    <script type="text/python">x = 1
+y = 2
+print(x < y, max(x, y))</script>
+  </body>
+</html>
diff --git a/tests/ref/html/html-style.html b/tests/ref/html/html-style.html
new file mode 100644
index 000000000..c8d558bce
--- /dev/null
+++ b/tests/ref/html/html-style.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <style>
+      body {
+        text: red;
+      }
+    </style>
+  </body>
+</html>
diff --git a/tests/suite/html/syntax.typ b/tests/suite/html/syntax.typ
index fb5caf3bd..eb1c86994 100644
--- a/tests/suite/html/syntax.typ
+++ b/tests/suite/html/syntax.typ
@@ -10,3 +10,54 @@
 #html.pre("hello")
 #html.pre("\nhello")
 #html.pre("\n\nhello")
+
+--- html-script html ---
+// This should be pretty and indented.
+#html.script(
+  ```js
+  const x = 1
+  const y = 2
+  console.log(x < y, Math.max(1, 2))
+  ```.text,
+)
+
+// This should have extra newlines, but no indent because of the multiline
+// string literal.
+#html.script("console.log(`Hello\nWorld`)")
+
+// This should be untouched.
+#html.script(
+  type: "text/python",
+  ```py
+  x = 1
+  y = 2
+  print(x < y, max(x, y))
+  ```.text,
+)
+
+--- html-style html ---
+// This should be pretty and indented.
+#html.style(
+  ```css
+  body {
+    text: red;
+  }
+  ```.text,
+)
+
+--- html-raw-text-contains-elem html ---
+// Error: 14-32 HTML raw text element cannot have non-text children
+#html.script(html.strong[Hello])
+
+--- html-raw-text-contains-frame html ---
+// Error: 2-29 HTML raw text element cannot have non-text children
+#html.script(html.frame[Ok])
+
+--- html-raw-text-contains-closing-tag html ---
+// Error: 2-32 HTML raw text element cannot contain its own closing tag
+// Hint: 2-32 the sequence `</SCRiPT` appears in the raw text
+#html.script("hello </SCRiPT ")
+
+--- html-escapable-raw-text-contains-closing-tag html ---
+// This is okay because we escape it.
+#html.textarea("hello </textarea>")

From 38dd6da237b8d1ea86f82069338d9ceae479d180 Mon Sep 17 00:00:00 2001
From: Wannes Malfait <46323945+WannesMalfait@users.noreply.github.com>
Date: Mon, 23 Jun 2025 16:58:04 +0200
Subject: [PATCH 022/101] Fix stroke cap of shapes with partial stroke (#5688)

---
 crates/typst-layout/src/shapes.rs | 113 +++++++++++++++++++++++++++---
 tests/ref/rect-stroke-caps.png    | Bin 0 -> 252 bytes
 tests/suite/visualize/rect.typ    |  16 +++++
 3 files changed, 121 insertions(+), 8 deletions(-)
 create mode 100644 tests/ref/rect-stroke-caps.png

diff --git a/crates/typst-layout/src/shapes.rs b/crates/typst-layout/src/shapes.rs
index 7ab41e9d4..0616b4ce4 100644
--- a/crates/typst-layout/src/shapes.rs
+++ b/crates/typst-layout/src/shapes.rs
@@ -11,8 +11,8 @@ use typst_library::layout::{
 };
 use typst_library::visualize::{
     CircleElem, CloseMode, Curve, CurveComponent, CurveElem, EllipseElem, FillRule,
-    FixedStroke, Geometry, LineElem, Paint, PathElem, PathVertex, PolygonElem, RectElem,
-    Shape, SquareElem, Stroke,
+    FixedStroke, Geometry, LineCap, LineElem, Paint, PathElem, PathVertex, PolygonElem,
+    RectElem, Shape, SquareElem, Stroke,
 };
 use typst_syntax::Span;
 use typst_utils::{Get, Numeric};
@@ -889,7 +889,13 @@ fn segmented_rect(
             let end = current;
             last = current;
             let Some(stroke) = strokes.get_ref(start.side_cw()) else { continue };
-            let (shape, ontop) = segment(start, end, &corners, stroke);
+            let start_cap = stroke.cap;
+            let end_cap = match strokes.get_ref(end.side_ccw()) {
+                Some(stroke) => stroke.cap,
+                None => start_cap,
+            };
+            let (shape, ontop) =
+                segment(start, end, start_cap, end_cap, &corners, stroke);
             if ontop {
                 res.push(shape);
             } else {
@@ -899,7 +905,14 @@ fn segmented_rect(
         }
     } else if let Some(stroke) = &strokes.top {
         // single segment
-        let (shape, _) = segment(Corner::TopLeft, Corner::TopLeft, &corners, stroke);
+        let (shape, _) = segment(
+            Corner::TopLeft,
+            Corner::TopLeft,
+            stroke.cap,
+            stroke.cap,
+            &corners,
+            stroke,
+        );
         res.push(shape);
     }
     res
@@ -946,6 +959,8 @@ fn curve_segment(
 fn segment(
     start: Corner,
     end: Corner,
+    start_cap: LineCap,
+    end_cap: LineCap,
     corners: &Corners<ControlPoints>,
     stroke: &FixedStroke,
 ) -> (Shape, bool) {
@@ -979,7 +994,7 @@ fn segment(
 
     let use_fill = solid && fill_corners(start, end, corners);
     let shape = if use_fill {
-        fill_segment(start, end, corners, stroke)
+        fill_segment(start, end, start_cap, end_cap, corners, stroke)
     } else {
         stroke_segment(start, end, corners, stroke.clone())
     };
@@ -1010,6 +1025,8 @@ fn stroke_segment(
 fn fill_segment(
     start: Corner,
     end: Corner,
+    start_cap: LineCap,
+    end_cap: LineCap,
     corners: &Corners<ControlPoints>,
     stroke: &FixedStroke,
 ) -> Shape {
@@ -1035,8 +1052,7 @@ fn fill_segment(
         if c.arc_outer() {
             curve.arc_line(c.mid_outer(), c.center_outer(), c.end_outer());
         } else {
-            curve.line(c.outer());
-            curve.line(c.end_outer());
+            c.start_cap(&mut curve, start_cap);
         }
     }
 
@@ -1079,7 +1095,7 @@ fn fill_segment(
         if c.arc_inner() {
             curve.arc_line(c.mid_inner(), c.center_inner(), c.start_inner());
         } else {
-            curve.line(c.center_inner());
+            c.end_cap(&mut curve, end_cap);
         }
     }
 
@@ -1134,6 +1150,16 @@ struct ControlPoints {
 }
 
 impl ControlPoints {
+    /// Rotate point around the origin, relative to the top-left.
+    fn rotate_centered(&self, point: Point) -> Point {
+        match self.corner {
+            Corner::TopLeft => point,
+            Corner::TopRight => Point { x: -point.y, y: point.x },
+            Corner::BottomRight => Point { x: -point.x, y: -point.y },
+            Corner::BottomLeft => Point { x: point.y, y: -point.x },
+        }
+    }
+
     /// Move and rotate the point from top-left to the required corner.
     fn rotate(&self, point: Point) -> Point {
         match self.corner {
@@ -1280,6 +1306,77 @@ impl ControlPoints {
             y: self.stroke_after,
         })
     }
+
+    /// Draw the cap at the beginning of the segment.
+    ///
+    /// If this corner has a stroke before it,
+    /// a default "butt" cap is used.
+    ///
+    /// NOTE: doesn't support the case where the corner has a radius.
+    pub fn start_cap(&self, curve: &mut Curve, cap_type: LineCap) {
+        if self.stroke_before != Abs::zero()
+            || self.radius != Abs::zero()
+            || cap_type == LineCap::Butt
+        {
+            // Just the default cap.
+            curve.line(self.outer());
+        } else if cap_type == LineCap::Square {
+            // Extend by the stroke width.
+            let offset =
+                self.rotate_centered(Point { x: -self.stroke_after, y: Abs::zero() });
+            curve.line(self.end_inner() + offset);
+            curve.line(self.outer() + offset);
+        } else if cap_type == LineCap::Round {
+            // We push the center by a little bit to ensure the correct
+            // half of the circle gets drawn. If it is perfectly centered
+            // the `arc` function just degenerates into a line, which we
+            // do not want in this case.
+            curve.arc(
+                self.end_inner(),
+                (self.end_inner()
+                    + self.rotate_centered(Point { x: Abs::raw(1.0), y: Abs::zero() })
+                    + self.outer())
+                    / 2.,
+                self.outer(),
+            );
+        }
+        curve.line(self.end_outer());
+    }
+
+    /// Draw the cap at the end of the segment.
+    ///
+    /// If this corner has a stroke before it,
+    /// a default "butt" cap is used.
+    ///
+    /// NOTE: doesn't support the case where the corner has a radius.
+    pub fn end_cap(&self, curve: &mut Curve, cap_type: LineCap) {
+        if self.stroke_after != Abs::zero()
+            || self.radius != Abs::zero()
+            || cap_type == LineCap::Butt
+        {
+            // Just the default cap.
+            curve.line(self.center_inner());
+        } else if cap_type == LineCap::Square {
+            // Extend by the stroke width.
+            let offset =
+                self.rotate_centered(Point { x: Abs::zero(), y: -self.stroke_before });
+            curve.line(self.outer() + offset);
+            curve.line(self.center_inner() + offset);
+        } else if cap_type == LineCap::Round {
+            // We push the center by a little bit to ensure the correct
+            // half of the circle gets drawn. If it is perfectly centered
+            // the `arc` function just degenerates into a line, which we
+            // do not want in this case.
+            curve.arc(
+                self.outer(),
+                (self.outer()
+                    + self.rotate_centered(Point { x: Abs::zero(), y: Abs::raw(1.0) })
+                    + self.center_inner())
+                    / 2.,
+                self.center_inner(),
+            );
+        }
+    }
 }
 
 /// Helper to draw arcs with Bézier curves.
diff --git a/tests/ref/rect-stroke-caps.png b/tests/ref/rect-stroke-caps.png
new file mode 100644
index 0000000000000000000000000000000000000000..13a34ad9aaf255c1a8f758c93842dd88cdb850ff
GIT binary patch
literal 252
zcmeAS@N?(olHy`uVBq!ia0vp^6+oQ90VEjYZ)Q&gQinZV978H@y}j-zc*sG(<zm?c
zi!N3fUl|p?1B^m!>>iSw3$>=}Dp&?udk6iOuDG73+bd*Hz<lGl>3W{yHpf3r%RKw)
z&_(ZBlLmFqUC$1=8YV!&gW$fsFP7*@9q{%E{<Pr!+1#_0-3Rs`w0rloH1TpA8&6G2
z#fDy+N{%TFjbPxt^Z$-1fBL;S|IfJ0R%7(Tu&%6|=f|S=ztU@etXtdmYeS~-gB*+h
o@|ztX8h#%Clk6vL@WK9|zE@&|-lE%G{2*_6y85}Sb4q9e07B|&EdT%j

literal 0
HcmV?d00001

diff --git a/tests/suite/visualize/rect.typ b/tests/suite/visualize/rect.typ
index a659287e7..ba5792b78 100644
--- a/tests/suite/visualize/rect.typ
+++ b/tests/suite/visualize/rect.typ
@@ -54,6 +54,22 @@
 #v(3pt)
 #rect(width: 20pt, height: 20pt, stroke: (thickness: 5pt, join: "round"))
 
+--- rect-stroke-caps ---
+// Separated segments
+#rect(width: 20pt, height: 20pt, stroke: (
+  left: (cap: "round", thickness: 5pt),
+  right: (cap: "square", thickness: 7pt),
+))
+// Joined segment with different caps.
+#rect(width: 20pt, height: 20pt, stroke: (
+  left: (cap: "round", thickness: 5pt),
+  top: (cap: "square", thickness: 7pt),
+))
+// No caps when there is a radius for that corner.
+#rect(width: 20pt, height: 20pt, radius: (top: 3pt), stroke: (
+  left: (cap: "round", thickness: 5pt),
+  top: (cap: "square", thickness: 7pt),
+))
 --- red-stroke-bad-type ---
 // Error: 15-21 expected length, color, gradient, tiling, dictionary, stroke, none, or auto, found array
 #rect(stroke: (1, 2))

From 87cb8f5094b9ea45893344143ca069a521f9ba47 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ivica=20Naki=C4=87?= <ssemigr@gmail.com>
Date: Mon, 23 Jun 2025 17:09:03 +0200
Subject: [PATCH 023/101] Adding Croatian translations entries (#6413)

---
 crates/typst-library/src/text/lang.rs    | 1 +
 crates/typst-library/translations/hr.txt | 8 ++++++++
 2 files changed, 9 insertions(+)
 create mode 100644 crates/typst-library/translations/hr.txt

diff --git a/crates/typst-library/src/text/lang.rs b/crates/typst-library/src/text/lang.rs
index e06156c43..a170714b5 100644
--- a/crates/typst-library/src/text/lang.rs
+++ b/crates/typst-library/src/text/lang.rs
@@ -30,6 +30,7 @@ const TRANSLATIONS: &[(&str, &str)] = &[
     translation!("fr"),
     translation!("gl"),
     translation!("he"),
+    translation!("hr"),
     translation!("hu"),
     translation!("id"),
     translation!("is"),
diff --git a/crates/typst-library/translations/hr.txt b/crates/typst-library/translations/hr.txt
new file mode 100644
index 000000000..ea0754592
--- /dev/null
+++ b/crates/typst-library/translations/hr.txt
@@ -0,0 +1,8 @@
+figure = Slika
+table = Tablica
+equation = Jednadžba
+bibliography = Literatura
+heading = Odjeljak
+outline = Sadržaj
+raw = Kôd
+page = str.

From 24293a6c121a4b4e02c32901fec44e0093aa5d8c Mon Sep 17 00:00:00 2001
From: Andrew Voynov <37143421+Andrew15-5@users.noreply.github.com>
Date: Tue, 24 Jun 2025 12:56:58 +0300
Subject: [PATCH 024/101] Rewrite `outline.indent` example (#6383)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-library/src/model/outline.rs | 35 +++++++++++------------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/crates/typst-library/src/model/outline.rs b/crates/typst-library/src/model/outline.rs
index 489c375e6..16a116146 100644
--- a/crates/typst-library/src/model/outline.rs
+++ b/crates/typst-library/src/model/outline.rs
@@ -225,25 +225,21 @@ pub struct OutlineElem {
     ///   to just specifying `{2em}`.
     ///
     /// ```example
-    /// #set heading(numbering: "1.a.")
+    /// >>> #show heading: none
+    /// #set heading(numbering: "I-I.")
+    /// #set outline(title: none)
     ///
-    /// #outline(
-    ///   title: [Contents (Automatic)],
-    ///   indent: auto,
-    /// )
+    /// #outline()
+    /// #line(length: 100%)
+    /// #outline(indent: 3em)
     ///
-    /// #outline(
-    ///   title: [Contents (Length)],
-    ///   indent: 2em,
-    /// )
-    ///
-    /// = About ACME Corp.
-    /// == History
-    /// === Origins
-    /// #lorem(10)
-    ///
-    /// == Products
-    /// #lorem(10)
+    /// = Software engineering technologies
+    /// == Requirements
+    /// == Tools and technologies
+    /// === Code editors
+    /// == Analyzing alternatives
+    /// = Designing software components
+    /// = Testing and integration
     /// ```
     pub indent: Smart<OutlineIndent>,
 }
@@ -450,8 +446,9 @@ impl OutlineEntry {
     /// at the same level are aligned.
     ///
     /// If the outline's indent is a fixed value or a function, the prefixes are
-    /// indented, but the inner contents are simply inset from the prefix by the
-    /// specified `gap`, rather than aligning outline-wide.
+    /// indented, but the inner contents are simply offset from the prefix by
+    /// the specified `gap`, rather than aligning outline-wide. For a visual
+    /// explanation, see [`outline.indent`]($outline.indent).
     #[func(contextual)]
     pub fn indented(
         &self,

From 899de6d5d501c6aed04897d425dd3615e745743e Mon Sep 17 00:00:00 2001
From: Max <max@mkor.je>
Date: Tue, 24 Jun 2025 10:03:10 +0000
Subject: [PATCH 025/101] Use ICU data to check if accent is bottom (#6393)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-library/src/math/accent.rs | 30 +++++++++++++++++--------
 1 file changed, 21 insertions(+), 9 deletions(-)

diff --git a/crates/typst-library/src/math/accent.rs b/crates/typst-library/src/math/accent.rs
index f2c9168c2..c8569ea23 100644
--- a/crates/typst-library/src/math/accent.rs
+++ b/crates/typst-library/src/math/accent.rs
@@ -1,3 +1,10 @@
+use std::sync::LazyLock;
+
+use icu_properties::maps::CodePointMapData;
+use icu_properties::CanonicalCombiningClass;
+use icu_provider::AsDeserializingBufferProvider;
+use icu_provider_blob::BlobDataProvider;
+
 use crate::diag::bail;
 use crate::foundations::{cast, elem, func, Content, NativeElement, SymbolElem};
 use crate::layout::{Length, Rel};
@@ -81,17 +88,22 @@ impl Accent {
         Self(Self::combine(c).unwrap_or(c))
     }
 
-    /// List of bottom accents. Currently just a list of ones included in the
-    /// Unicode math class document.
-    const BOTTOM: &[char] = &[
-        '\u{0323}', '\u{032C}', '\u{032D}', '\u{032E}', '\u{032F}', '\u{0330}',
-        '\u{0331}', '\u{0332}', '\u{0333}', '\u{033A}', '\u{20E8}', '\u{20EC}',
-        '\u{20ED}', '\u{20EE}', '\u{20EF}',
-    ];
-
     /// Whether this accent is a bottom accent or not.
     pub fn is_bottom(&self) -> bool {
-        Self::BOTTOM.contains(&self.0)
+        static COMBINING_CLASS_DATA: LazyLock<CodePointMapData<CanonicalCombiningClass>> =
+            LazyLock::new(|| {
+                icu_properties::maps::load_canonical_combining_class(
+                    &BlobDataProvider::try_new_from_static_blob(typst_assets::icu::ICU)
+                        .unwrap()
+                        .as_deserializing(),
+                )
+                .unwrap()
+            });
+
+        matches!(
+            COMBINING_CLASS_DATA.as_borrowed().get(self.0),
+            CanonicalCombiningClass::Below
+        )
     }
 }
 

From 87c56865606e027f552a4dbc800c6851b0d0b821 Mon Sep 17 00:00:00 2001
From: Andrew Voynov <37143421+Andrew15-5@users.noreply.github.com>
Date: Tue, 24 Jun 2025 13:22:55 +0300
Subject: [PATCH 026/101] Add docs for `std` module (#6407)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-library/src/lib.rs |  2 +-
 docs/reference/groups.yml       | 53 +++++++++++++++++++++++++++++++++
 docs/src/lib.rs                 |  2 +-
 3 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/crates/typst-library/src/lib.rs b/crates/typst-library/src/lib.rs
index c39024f71..fa7977888 100644
--- a/crates/typst-library/src/lib.rs
+++ b/crates/typst-library/src/lib.rs
@@ -148,7 +148,7 @@ pub struct Library {
     /// The default style properties (for page size, font selection, and
     /// everything else configurable via set and show rules).
     pub styles: Styles,
-    /// The standard library as a value. Used to provide the `std` variable.
+    /// The standard library as a value. Used to provide the `std` module.
     pub std: Binding,
     /// In-development features that were enabled.
     pub features: Features,
diff --git a/docs/reference/groups.yml b/docs/reference/groups.yml
index e5aa7e999..c7e3d9964 100644
--- a/docs/reference/groups.yml
+++ b/docs/reference/groups.yml
@@ -137,6 +137,59 @@
     In addition to the functions listed below, the `calc` module also defines
     the constants `pi`, `tau`, `e`, and `inf`.
 
+- name: std
+  title: Standard library
+  category: foundations
+  path: ["std"]
+  details: |
+    A module that contains all globally accessible items.
+
+    # Using "shadowed" definitions
+    The `std` module is useful whenever you overrode a name from the global
+    scope (this is called _shadowing_). For instance, you might have used the
+    name `text` for a parameter. To still access the `text` element, write
+    `std.text`.
+
+    ```example
+    >>> #set page(margin: (left: 3em))
+    #let par = [My special paragraph.]
+    #let special(text) = {
+      set std.text(style: "italic")
+      set std.par.line(numbering: "1")
+      text
+    }
+
+    #special(par)
+
+    #lorem(10)
+    ```
+
+    # Conditional access
+    You can also use this in combination with the [dictionary
+    constructor]($dictionary) to conditionally access global definitions. This
+    can, for instance, be useful to use new or experimental functionality when
+    it is available, while falling back to an alternative implementation if
+    used on an older Typst version. In particular, this allows us to create
+    [polyfills](https://en.wikipedia.org/wiki/Polyfill_(programming)).
+
+    This can be as simple as creating an alias to prevent warning messages, for
+    example, conditionally using `pattern` in Typst version 0.12, but using
+    [`tiling`] in newer versions. Since the parameters accepted by the `tiling`
+    function match those of the older `pattern` function, using the `tiling`
+    function when available and falling back to `pattern` otherwise will unify
+    the usage across all versions. Note that, when creating a polyfill,
+    [`sys.version`]($category/foundations/sys) can also be very useful.
+
+    ```typ
+    #let tiling = if "tiling" in dictionary(std) {
+      tiling
+    } else {
+      pattern
+    }
+
+    ...
+    ```
+
 - name: sys
   title: System
   category: foundations
diff --git a/docs/src/lib.rs b/docs/src/lib.rs
index b81f0dc66..9bd21c2e8 100644
--- a/docs/src/lib.rs
+++ b/docs/src/lib.rs
@@ -37,7 +37,7 @@ static GROUPS: LazyLock<Vec<GroupData>> = LazyLock::new(|| {
     let mut groups: Vec<GroupData> =
         yaml::from_str(load!("reference/groups.yml")).unwrap();
     for group in &mut groups {
-        if group.filter.is_empty() {
+        if group.filter.is_empty() && group.name != "std" {
             group.filter = group
                 .module()
                 .scope()

From f162c371017f0d503cfae8738cbbf505b9f11173 Mon Sep 17 00:00:00 2001
From: Andrew Voynov <37143421+Andrew15-5@users.noreply.github.com>
Date: Tue, 24 Jun 2025 15:49:28 +0300
Subject: [PATCH 027/101] Improve equation reference example (#6481)

---
 crates/typst-library/src/model/reference.rs | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index f22d70b32..6fddc56ca 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -91,16 +91,13 @@ use crate::text::TextElem;
 /// #show ref: it => {
 ///   let eq = math.equation
 ///   let el = it.element
-///   if el != none and el.func() == eq {
-///     // Override equation references.
-///     link(el.location(),numbering(
-///       el.numbering,
-///       ..counter(eq).at(el.location())
-///     ))
-///   } else {
-///     // Other references as usual.
-///     it
-///   }
+///   // Skip all other references.
+///   if el == none or el.func() != eq { return it }
+///   // Override equation references.
+///   link(el.location(), numbering(
+///     el.numbering,
+///     ..counter(eq).at(el.location())
+///   ))
 /// }
 ///
 /// = Beginnings <beginning>

From d4be7c4ca54ce1907ce5f7af8a603cf3f4c5a42f Mon Sep 17 00:00:00 2001
From: Andrew Voynov <37143421+Andrew15-5@users.noreply.github.com>
Date: Tue, 24 Jun 2025 16:00:51 +0300
Subject: [PATCH 028/101] Add page reference customization example (#6480)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-library/src/model/reference.rs | 30 +++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index 6fddc56ca..17f93b7c4 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -79,6 +79,36 @@ use crate::text::TextElem;
 /// reference: `[@intro[Chapter]]`.
 ///
 /// # Customization
+/// When you only ever need to reference pages of a figure/table/heading/etc. in
+/// a document, the default `form` field value can be changed to `{"page"}` with
+/// a set rule. If you prefer a short "p." supplement over "page", the
+/// [`page.supplement`]($page.supplement) field can be used for changing this:
+///
+/// ```example
+/// #set page(
+///   numbering: "1",
+///   supplement: "p.",
+/// >>> margin: (bottom: 3em),
+/// >>> footer-descent: 1.25em,
+/// )
+/// #set ref(form: "page")
+///
+/// #figure(
+///   stack(
+///     dir: ltr,
+///     spacing: 1em,
+///     circle(),
+///     square(),
+///   ),
+///   caption: [Shapes],
+/// ) <shapes>
+///
+/// #pagebreak()
+///
+/// See @shapes for examples
+/// of different shapes.
+/// ```
+///
 /// If you write a show rule for references, you can access the referenced
 /// element through the `element` field of the reference. The `element` may
 /// be `{none}` even if it exists if Typst hasn't discovered it yet, so you

From 70399a94fd58cc5e3e953c10670c396de8f7f6f7 Mon Sep 17 00:00:00 2001
From: Tobias Schmitz <tobiasschmitz2001@gmail.com>
Date: Tue, 24 Jun 2025 15:23:37 +0200
Subject: [PATCH 029/101] Bump `krilla` to current Git version (#6488)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 Cargo.lock                    | 18 ++++++++----------
 Cargo.toml                    |  4 ++--
 crates/typst-pdf/src/embed.rs |  3 +--
 3 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 58cac3c58..3ea423f5f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -786,9 +786,9 @@ checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
 
 [[package]]
 name = "font-types"
-version = "0.8.4"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fa6a5e5a77b5f3f7f9e32879f484aa5b3632ddfbe568a16266c904a6f32cdaf"
+checksum = "02a596f5713680923a2080d86de50fe472fb290693cf0f701187a1c8b36996b7"
 dependencies = [
  "bytemuck",
 ]
@@ -1367,8 +1367,7 @@ dependencies = [
 [[package]]
 name = "krilla"
 version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69ee6128ebf52d7ce684613b6431ead2959f2be9ff8cf776eeaaad0427c953e9"
+source = "git+https://github.com/LaurenzV/krilla?rev=20c14fe#20c14fefee5002566b3d6668b338bbe2168784e7"
 dependencies = [
  "base64",
  "bumpalo",
@@ -1396,8 +1395,7 @@ dependencies = [
 [[package]]
 name = "krilla-svg"
 version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3462989578155cf620ef8035f8921533cc95c28e2a0c75de172f7219e6aba84e"
+source = "git+https://github.com/LaurenzV/krilla?rev=20c14fe#20c14fefee5002566b3d6668b338bbe2168784e7"
 dependencies = [
  "flate2",
  "fontdb",
@@ -2106,9 +2104,9 @@ dependencies = [
 
 [[package]]
 name = "read-fonts"
-version = "0.28.0"
+version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "600e807b48ac55bad68a8cb75cc3c7739f139b9248f7e003e01e080f589b5288"
+checksum = "192735ef611aac958468e670cb98432c925426f3cb71521fda202130f7388d91"
 dependencies = [
  "bytemuck",
  "font-types",
@@ -2434,9 +2432,9 @@ checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
 name = "skrifa"
-version = "0.30.0"
+version = "0.32.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fa1e5622e4f7b98877e8a19890efddcac1230cec6198bd9de91ec0e00010dc8"
+checksum = "e6d632b5a73f566303dbeabd344dc3e716fd4ddc9a70d6fc8ea8e6f06617da97"
 dependencies = [
  "bytemuck",
  "read-fonts",
diff --git a/Cargo.toml b/Cargo.toml
index 72ab9094d..3cfb72008 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -73,8 +73,8 @@ image = { version = "0.25.5", default-features = false, features = ["png", "jpeg
 indexmap = { version = "2", features = ["serde"] }
 infer = { version = "0.19.0", default-features = false }
 kamadak-exif = "0.6"
-krilla = { version = "0.4.0", default-features = false, features = ["raster-images", "comemo", "rayon"] }
-krilla-svg = "0.1.0"
+krilla = { git = "https://github.com/LaurenzV/krilla", rev = "20c14fe", default-features = false, features = ["raster-images", "comemo", "rayon"] }
+krilla-svg = { git = "https://github.com/LaurenzV/krilla", rev = "20c14fe" }
 kurbo = "0.11"
 libfuzzer-sys = "0.4"
 lipsum = "0.9"
diff --git a/crates/typst-pdf/src/embed.rs b/crates/typst-pdf/src/embed.rs
index f0cd9060a..36330c445 100644
--- a/crates/typst-pdf/src/embed.rs
+++ b/crates/typst-pdf/src/embed.rs
@@ -34,8 +34,7 @@ pub(crate) fn embed_files(
             },
         };
         let data: Arc<dyn AsRef<[u8]> + Send + Sync> = Arc::new(embed.data.clone());
-        // TODO: update when new krilla version lands (https://github.com/LaurenzV/krilla/pull/203)
-        let compress = should_compress(&embed.data).unwrap_or(true);
+        let compress = should_compress(&embed.data);
 
         let file = EmbeddedFile {
             path,

From 9e3c1199edddc0422d34a266681d2efe1babd0c1 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 24 Jun 2025 17:05:02 +0200
Subject: [PATCH 030/101] Check that git tree is clean after build (#6495)

---
 .github/workflows/ci.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c5c81537b..2354de582 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -81,6 +81,7 @@ jobs:
       - run: cargo clippy --workspace --all-targets --no-default-features
       - run: cargo fmt --check --all
       - run: cargo doc --workspace --no-deps
+      - run: git diff --exit-code
 
   min-version:
     name: Check minimum Rust version

From f2f527c451b1b05b393af99b89c528aadb203ce6 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 24 Jun 2025 17:52:15 +0200
Subject: [PATCH 031/101] Also fix encoding of `<textarea>` (#6497)

---
 crates/typst-html/src/encode.rs                        |  2 +-
 .../ref/html/html-textarea-starting-with-newline.html  | 10 ++++++++++
 tests/suite/html/syntax.typ                            |  3 +++
 3 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 tests/ref/html/html-textarea-starting-with-newline.html

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index adcb6e032..9c7938360 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -113,7 +113,7 @@ fn write_element(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
 /// Encodes the children of an element.
 fn write_children(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     // See HTML spec § 13.1.2.5.
-    if element.tag == tag::pre && starts_with_newline(element) {
+    if matches!(element.tag, tag::pre | tag::textarea) && starts_with_newline(element) {
         w.buf.push('\n');
     }
 
diff --git a/tests/ref/html/html-textarea-starting-with-newline.html b/tests/ref/html/html-textarea-starting-with-newline.html
new file mode 100644
index 000000000..9c234037d
--- /dev/null
+++ b/tests/ref/html/html-textarea-starting-with-newline.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body><textarea>
+
+enter</textarea></body>
+</html>
diff --git a/tests/suite/html/syntax.typ b/tests/suite/html/syntax.typ
index eb1c86994..4bda0c686 100644
--- a/tests/suite/html/syntax.typ
+++ b/tests/suite/html/syntax.typ
@@ -11,6 +11,9 @@
 #html.pre("\nhello")
 #html.pre("\n\nhello")
 
+--- html-textarea-starting-with-newline html ---
+#html.textarea("\nenter")
+
 --- html-script html ---
 // This should be pretty and indented.
 #html.script(

From d54544297beba0a762bee9bc731baab96e4d7250 Mon Sep 17 00:00:00 2001
From: +merlan #flirora <flirora@flirora.xyz>
Date: Wed, 25 Jun 2025 12:58:40 -0400
Subject: [PATCH 032/101] Minor fixes to doc comments (#6500)

---
 crates/typst-layout/src/inline/line.rs         | 6 +++++-
 crates/typst-library/src/model/bibliography.rs | 4 ++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/crates/typst-layout/src/inline/line.rs b/crates/typst-layout/src/inline/line.rs
index 659d33f4a..f05189275 100644
--- a/crates/typst-layout/src/inline/line.rs
+++ b/crates/typst-layout/src/inline/line.rs
@@ -640,7 +640,7 @@ impl<'a> Items<'a> {
         self.0.push(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)
     }
@@ -698,6 +698,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>>),
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index 8056d4ab3..e1a073594 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -592,7 +592,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 +609,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,

From d3caedd813b1ca4379a71eb1b4aa636096d53a04 Mon Sep 17 00:00:00 2001
From: Connor K <sigstackfault@gmail.com>
Date: Wed, 25 Jun 2025 12:59:19 -0400
Subject: [PATCH 033/101] Fix typos in page-setup.md (#6499)

---
 docs/guides/page-setup.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/docs/guides/page-setup.md b/docs/guides/page-setup.md
index 36ed0fa23..1682c1220 100644
--- a/docs/guides/page-setup.md
+++ b/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()

From 35809387f88483bfa3d0978cfc3303eba0de632b Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 26 Jun 2025 10:06:22 +0200
Subject: [PATCH 034/101] Support `in` operator on strings and modules (#6498)

---
 .../typst-library/src/foundations/module.rs   | 19 +++++++++++++++----
 crates/typst-library/src/foundations/ops.rs   |  1 +
 docs/reference/groups.yml                     |  6 +-----
 tests/suite/scripting/ops.typ                 |  2 ++
 4 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/crates/typst-library/src/foundations/module.rs b/crates/typst-library/src/foundations/module.rs
index 55d8bab63..14eefca39 100644
--- a/crates/typst-library/src/foundations/module.rs
+++ b/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
-/// convert a module to a dictionary, and therefore access its contents
-/// dynamically, using the [dictionary constructor]($dictionary/#constructor).
+/// include syntaxes]($scripting/#modules).
 ///
-/// # 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)]
diff --git a/crates/typst-library/src/foundations/ops.rs b/crates/typst-library/src/foundations/ops.rs
index 6c2408446..3c6a5e6cf 100644
--- a/crates/typst-library/src/foundations/ops.rs
+++ b/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,
diff --git a/docs/reference/groups.yml b/docs/reference/groups.yml
index c7e3d9964..e01d99dc4 100644
--- a/docs/reference/groups.yml
+++ b/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) {
-      tiling
-    } else {
-      pattern
-    }
+    #let tiling = if "tiling" in std { tiling } else { pattern }
 
     ...
     ```
diff --git a/tests/suite/scripting/ops.typ b/tests/suite/scripting/ops.typ
index d17c0117f..561682f05 100644
--- a/tests/suite/scripting/ops.typ
+++ b/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`

From 6a1d6c08e2d6e4c184c6d177e67796b23ccbe4c7 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 26 Jun 2025 10:07:41 +0200
Subject: [PATCH 035/101] Consistent sizing for `html.frame` (#6505)

---
 crates/typst-html/src/encode.rs                 | 15 ++++++++++-----
 crates/typst-html/src/lib.rs                    |  7 +++++--
 crates/typst-library/src/html/dom.rs            | 17 ++++++++++++++---
 .../src/introspection/introspector.rs           |  2 +-
 4 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 9c7938360..84860dbe9 100644
--- a/crates/typst-html/src/encode.rs
+++ b/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)
-        .replace("<svg class", "<svg style=\"overflow: visible;\" class");
+    let svg = typst_svg::svg_frame(&frame.inner).replace(
+        "<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);
 }
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index 703948f66..495187166 100644
--- a/crates/typst-html/src/lib.rs
+++ b/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(),
diff --git a/crates/typst-library/src/html/dom.rs b/crates/typst-library/src/html/dom.rs
index 35d513c10..47bcf9954 100644
--- a/crates/typst-library/src/html/dom.rs
+++ b/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.
-    Frame(Frame),
+    /// Layouted content that will be embedded into HTML as an SVG.
+    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.
diff --git a/crates/typst-library/src/introspection/introspector.rs b/crates/typst-library/src/introspection/introspector.rs
index 9751dfcb8..d2ad0525b 100644
--- a/crates/typst-library/src/introspection/introspector.rs
+++ b/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(),
                 ),

From 04fd0acacab8cf2e82268da9c18ef4bcf37507dc Mon Sep 17 00:00:00 2001
From: Malo <57839069+MDLC01@users.noreply.github.com>
Date: Thu, 26 Jun 2025 09:24:21 +0100
Subject: [PATCH 036/101] Allow deprecating symbol variants (#6441)

---
 Cargo.lock                                    |  2 +-
 Cargo.toml                                    |  2 +-
 crates/typst-ide/src/complete.rs              |  2 +-
 .../typst-library/src/foundations/symbol.rs   | 59 ++++++++++++-------
 crates/typst-library/src/foundations/value.rs |  4 +-
 docs/src/lib.rs                               | 14 ++---
 tests/suite/math/attach.typ                   |  6 +-
 7 files changed, 51 insertions(+), 38 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3ea423f5f..91ff48432 100644
--- a/Cargo.lock
+++ b/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"
diff --git a/Cargo.toml b/Cargo.toml
index 3cfb72008..76d83995f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -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"
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index 536423318..bc5b3e10e 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/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(),
diff --git a/crates/typst-library/src/foundations/symbol.rs b/crates/typst-library/src/foundations/symbol.rs
index 0f503edd0..f57bb0c2a 100644
--- a/crates/typst-library/src/foundations/symbol.rs
+++ b/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)]),
-    Runtime(Box<[(ModifierSet<EcoString>, char)]>),
+    Static(&'static [Variant<&'static str>]),
+    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)>),
-    Runtime(std::slice::Iter<'a, (ModifierSet<EcoString>, char)>),
+    Static(std::slice::Iter<'static, Variant<&'static str>>),
+    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()))
+            }
         }
     }
 }
diff --git a/crates/typst-library/src/foundations/value.rs b/crates/typst-library/src/foundations/value.rs
index 854c2486e..4bcf2d4e3 100644
--- a/crates/typst-library/src/foundations/value.rs
+++ b/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),
diff --git a/docs/src/lib.rs b/docs/src/lib.rs
index 9bd21c2e8..dc6b62c72 100644
--- a/docs/src/lib.rs
+++ b/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)
-                    .map(|(other, _)| complete(other))
+                    .filter(|(other, _, _)| other != &variant)
+                    .map(|(other, _, _)| complete(other))
                     .collect(),
-                deprecation,
+                deprecation: deprecation.or_else(|| binding.deprecation()),
             });
         }
     }
diff --git a/tests/suite/math/attach.typ b/tests/suite/math/attach.typ
index cedc3a4ab..979018478 100644
--- a/tests/suite/math/attach.typ
+++ b/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.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.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$
 }

From 5dd5771df03a666fe17930b0b071b06266e5937f Mon Sep 17 00:00:00 2001
From: "Said A." <47973576+Daaiid@users.noreply.github.com>
Date: Thu, 26 Jun 2025 11:18:51 +0200
Subject: [PATCH 037/101] Disallow empty labels and references (#5776) (#6332)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-eval/src/markup.rs               |   7 ++++--
 crates/typst-ide/src/definition.rs            |   3 ++-
 crates/typst-library/src/foundations/label.rs |  23 ++++++++++++------
 .../typst-library/src/model/bibliography.rs   |   6 ++++-
 crates/typst-syntax/src/ast.rs                |   2 ++
 crates/typst-syntax/src/lexer.rs              |   2 +-
 tests/ref/ref-to-empty-label-not-possible.png | Bin 0 -> 182 bytes
 tests/suite/foundations/label.typ             |   4 +++
 tests/suite/model/bibliography.typ            |   8 ++++++
 tests/suite/model/ref.typ                     |  11 +++++++++
 10 files changed, 54 insertions(+), 12 deletions(-)
 create mode 100644 tests/ref/ref-to-empty-label-not-possible.png

diff --git a/crates/typst-eval/src/markup.rs b/crates/typst-eval/src/markup.rs
index 5beefa912..9118ded56 100644
--- a/crates/typst-eval/src/markup.rs
+++ b/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(
diff --git a/crates/typst-ide/src/definition.rs b/crates/typst-ide/src/definition.rs
index 69d702b3b..ae1ba287b 100644
--- a/crates/typst-ide/src/definition.rs
+++ b/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()));
diff --git a/crates/typst-library/src/foundations/label.rs b/crates/typst-library/src/foundations/label.rs
index 3b9b010c5..b1ac58bf2 100644
--- a/crates/typst-library/src/foundations/label.rs
+++ b/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 {
-        Self(PicoStr::intern(name.as_str()))
+    ) -> StrResult<Label> {
+        if name.is_empty() {
+            bail!("label name must not be empty");
+        }
+
+        Ok(Self(PicoStr::intern(name.as_str())))
     }
 }
 
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index e1a073594..f56f5813e 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/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);
                     }
diff --git a/crates/typst-syntax/src/ast.rs b/crates/typst-syntax/src/ast.rs
index 7b211bfc1..547d53cd8 100644
--- a/crates/typst-syntax/src/ast.rs
+++ b/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()
diff --git a/crates/typst-syntax/src/lexer.rs b/crates/typst-syntax/src/lexer.rs
index 74f14cfeb..82f65cd36 100644
--- a/crates/typst-syntax/src/lexer.rs
+++ b/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,
diff --git a/tests/ref/ref-to-empty-label-not-possible.png b/tests/ref/ref-to-empty-label-not-possible.png
new file mode 100644
index 0000000000000000000000000000000000000000..774b79589cc3637bf29516c525d23d33d0c53bac
GIT binary patch
literal 182
zcmeAS@N?(olHy`uVBq!ia0vp^6+kS_0VEhE<%|3RQnj8gjv*Ddl7HAcG$dYm6xi*q
zE4Ouqme~K@J91C2X58>2^!xY!`?<_6-+wg0zJ8m$#lqiH?}^<%^)LQ&)w`}!Yrkx(
zDE<F=)ql_aY`#mkA1#mkewaVv?(9GP?+RtgpWN)0p3klj`hR8ijlJKG91u}B|F1`E
i=3=q_D4Q(9jSLLhFS-|6L@c=ja*(I1pUXO@geCy>;Zq6#

literal 0
HcmV?d00001

diff --git a/tests/suite/foundations/label.typ b/tests/suite/foundations/label.typ
index 3b84c2d70..6eb2a9fdd 100644
--- a/tests/suite/foundations/label.typ
+++ b/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("")
diff --git a/tests/suite/model/bibliography.typ b/tests/suite/model/bibliography.typ
index 23576c156..6a0c3e3c5 100644
--- a/tests/suite/model/bibliography.typ
+++ b/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
diff --git a/tests/suite/model/ref.typ b/tests/suite/model/ref.typ
index 87b1c409a..d48072edb 100644
--- a/tests/suite/model/ref.typ
+++ b/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(<>)

From 7420ec972ffd6e4893fa24d12992b375da6b11fa Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 26 Jun 2025 15:20:22 +0200
Subject: [PATCH 038/101] Fix nested HTML frames (#6509)

---
 crates/typst-realize/src/lib.rs    |  18 ++++++++++++------
 tests/ref/html-frame-in-layout.png | Bin 0 -> 146 bytes
 tests/suite/html/frame.typ         |   8 ++++++++
 3 files changed, 20 insertions(+), 6 deletions(-)
 create mode 100644 tests/ref/html-frame-in-layout.png
 create mode 100644 tests/suite/html/frame.typ

diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index 7d2460a89..526f4631a 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/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
-// math.
-fn visit_math_rules<'a>(
+// Handles transformations based on the realization kind.
+fn visit_kind_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)
 }
 
diff --git a/tests/ref/html-frame-in-layout.png b/tests/ref/html-frame-in-layout.png
new file mode 100644
index 0000000000000000000000000000000000000000..c3382e432a4ed17ac94d3243f428e193872d3759
GIT binary patch
literal 146
zcmeAS@N?(olHy`uVBq!ia0vp^6+kS_0VEhE<%|3RQjwl6jv*Ddl7HAcG$dYm6xi*q
zE4Ouqm00y2DT!|XbU!(X?rQs6yd6i^8}rS&E5*@W-5)zQ%$z~2UiZiU|Lynke?{9Y
pefIUg@J?<w?g<d>6<3mE7#P;qO`Pg`;!-TgGEY}Omvv4FO#lj>Gv@#R

literal 0
HcmV?d00001

diff --git a/tests/suite/html/frame.typ b/tests/suite/html/frame.typ
new file mode 100644
index 000000000..711933d76
--- /dev/null
+++ b/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]

From 9311f6f08eca583b6214834148c94685f0161c21 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 26 Jun 2025 15:44:45 +0200
Subject: [PATCH 039/101] Basic support for text decoration functions in HTML
 (#6510)

---
 crates/typst-library/src/text/deco.rs | 32 ++++++++++++++++++++++++++-
 tests/ref/html/html-deco.html         | 11 +++++++++
 tests/suite/text/deco.typ             |  8 +++++++
 3 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 tests/ref/html/html-deco.html

diff --git a/crates/typst-library/src/text/deco.rs b/crates/typst-library/src/text/deco.rs
index 7aa06e815..d745a48fd 100644
--- a/crates/typst-library/src/text/deco.rs
+++ b/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::layout::{Abs, Corners, Length, Rel, Sides};
 use crate::text::{BottomEdge, BottomEdgeMetric, TextElem, TopEdge, TopEdgeMetric};
 use crate::visualize::{Color, FixedStroke, Paint, Stroke};
@@ -81,6 +84,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(),
@@ -173,6 +186,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(),
@@ -250,6 +270,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 {
@@ -345,6 +369,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),
diff --git a/tests/ref/html/html-deco.html b/tests/ref/html/html-deco.html
new file mode 100644
index 000000000..87f2ab4c8
--- /dev/null
+++ b/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>
diff --git a/tests/suite/text/deco.typ b/tests/suite/text/deco.typ
index 07fdb6c19..a1d287d9d 100644
--- a/tests/suite/text/deco.typ
+++ b/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))

From e8ce894ee7317654a0de1c822d14b3e169dde4d9 Mon Sep 17 00:00:00 2001
From: Florian Bohlken <flibbo@gmail.com>
Date: Thu, 26 Jun 2025 17:24:55 +0200
Subject: [PATCH 040/101] Improve sentence in guide for LaTeX users (#6511)

---
 docs/guides/guide-for-latex-users.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/guides/guide-for-latex-users.md b/docs/guides/guide-for-latex-users.md
index fffa6c521..93fa296fc 100644
--- a/docs/guides/guide-for-latex-users.md
+++ b/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
-immediately obvious based on whether it is used in a call or a
+current block, or the end of the document, if there is none. The effects of a
+function are immediately obvious based on whether it is used in a call or a
 [set rule.]($styling/#set-rules)
 
 ```example

From b9f3a95e03bd792bca4926959eab5f9f6edd1a9d Mon Sep 17 00:00:00 2001
From: +merlan #flirora <flirora@flirora.xyz>
Date: Fri, 27 Jun 2025 04:36:46 -0400
Subject: [PATCH 041/101] Sort line items by logical order when constructing
 frame (#5887)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-layout/src/inline/line.rs  |  58 ++++++++++++++----------
 tests/ref/issue-5775-cite-order-rtl.png | Bin 0 -> 14786 bytes
 tests/suite/model/cite.typ              |  12 +++++
 3 files changed, 46 insertions(+), 24 deletions(-)
 create mode 100644 tests/ref/issue-5775-cite-order-rtl.png

diff --git a/crates/typst-layout/src/inline/line.rs b/crates/typst-layout/src/inline/line.rs
index f05189275..7bf4d4c73 100644
--- a/crates/typst-layout/src/inline/line.rs
+++ b/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() {
-        let mut push = |offset: &mut Abs, frame: Frame| {
+    for &(idx, ref item) in line.items.indexed_iter() {
+        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>>) {
-        self.0.push(entry.into());
+    pub fn push(&mut self, entry: impl Into<ItemEntry<'a>>, idx: usize) {
+        self.0.push((idx, entry.into()));
     }
 
     /// 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
diff --git a/tests/ref/issue-5775-cite-order-rtl.png b/tests/ref/issue-5775-cite-order-rtl.png
new file mode 100644
index 0000000000000000000000000000000000000000..982ceef3928f9a275611bcd3cc2969131056c623
GIT binary patch
literal 14786
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
OA}y{URxe@{^8Wy!zYvQ6

literal 0
HcmV?d00001

diff --git a/tests/suite/model/cite.typ b/tests/suite/model/cite.typ
index b328dda49..1a79b690d 100644
--- a/tests/suite/model/cite.typ
+++ b/tests/suite/model/cite.typ
@@ -147,3 +147,15 @@ 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)
+@netwok
+aaa
+این است
+@tolkien54
+و این یکی هست
+@arrgh
+
+#bibliography("/assets/bib/works.bib")

From 584dd5fec69ad80feedf4018e02b427f2c812716 Mon Sep 17 00:00:00 2001
From: +merlan #flirora <flirora@flirora.xyz>
Date: Fri, 27 Jun 2025 05:26:15 -0400
Subject: [PATCH 042/101] Fix panic when sampling across two coincident
 gradient stops (#6166)

---
 .../typst-library/src/visualize/gradient.rs   |  21 +++++---------
 ...2-coincident-gradient-stops-export-png.png | Bin 0 -> 522 bytes
 tests/suite/visualize/gradient.typ            |  26 ++++++++++++++++++
 3 files changed, 33 insertions(+), 14 deletions(-)
 create mode 100644 tests/ref/issue-6162-coincident-gradient-stops-export-png.png

diff --git a/crates/typst-library/src/visualize/gradient.rs b/crates/typst-library/src/visualize/gradient.rs
index 5d7859a37..4917da68d 100644
--- a/crates/typst-library/src/visualize/gradient.rs
+++ b/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 high = stops.len();
+    let mut j = stops.partition_point(|(_, ratio)| ratio.get() < t);
 
-    while low < high {
-        let mid = (low + high) / 2;
-        if stops[mid].1.get() < t {
-            low = mid + 1;
-        } else {
-            high = mid;
+    if j == 0 {
+        while stops.get(j + 1).is_some_and(|(_, r)| r.is_zero()) {
+            j += 1;
         }
+        return stops[j].0;
     }
 
-    if low == 0 {
-        low = 1;
-    }
-
-    let (col_0, pos_0) = stops[low - 1];
-    let (col_1, pos_1) = stops[low];
+    let (col_0, pos_0) = stops[j - 1];
+    let (col_1, pos_1) = stops[j];
     let t = (t - pos_0.get()) / (pos_1.get() - pos_0.get());
 
     Color::mix_iter(
diff --git a/tests/ref/issue-6162-coincident-gradient-stops-export-png.png b/tests/ref/issue-6162-coincident-gradient-stops-export-png.png
new file mode 100644
index 0000000000000000000000000000000000000000..d269342c7c6678e525f62b7d85b080e2fcfd812d
GIT binary patch
literal 522
zcmV+l0`>igP)<h;3K|Lk000e1NJLTq004LZ004#v0{{R3AtJts0003~P)t-s|Ns90
zdDH-W(g1$Y0D;W_gUbMg$N-4O0E)x_jKKhozW|WD0F$`@mA3$wv;dj10GqD>ovZ+#
zsQ{s;0HdS;q@e(&o&czu0IHY(td#(+k^rxc0I`bzvxoq-gaNjJ2Dp6-x_J=1brijE
z7r$*A!Dt@BWFf>~BgR@L$5biFPAkesF3dnb%0NuWKv%{;VZ=Xa!as4pKX|=9e!D(|
zxju@wK996Ml(IdUusxowJ)^5Vr>H%vraZ5tJhP!Zx1Kz^oIAdmJHnSc#gseAkvq(e
zI?szb(ug|Mg*w=RIop3Z-h4UXcsb;CIp%RV>1{adX*lj>IPqaO^IbRgSU31nH~LLB
z{YN(cK{fz)*Z)X7|5Qf*UQqvNS^sik|9flygmnLmegBk(|DBHirI-J#pZ~O||GcsP
z#JT^=!vE9D|Ju|4;@tn~<^S;Q|M>PEWWQwq0044HL_t(|+U?k}4S+BVMZvHS3uOzY
zVjd*+!IU&9Nax7+DtA|ZH%VHq?K}7QUq8WMFc=I5gTY`h7@QckcO|LRXRpUZHy8{C
zgTY`h7z_r36T|kdB$fK?wIfDd&!_-{!C){L3<iV2U~ppC-j!6Z7q(WHJPu}VG5`Po
M07*qoM6N<$f<RjGIRF3v

literal 0
HcmV?d00001

diff --git a/tests/suite/visualize/gradient.typ b/tests/suite/visualize/gradient.typ
index 811b8b605..8446ca030 100644
--- a/tests/suite/visualize/gradient.typ
+++ b/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%),
+  )
+)

From 74b1b109865f5a8c141bbc711de6960844b8949d Mon Sep 17 00:00:00 2001
From: Max <max@mkor.je>
Date: Fri, 27 Jun 2025 10:35:05 +0000
Subject: [PATCH 043/101] Bump `typst-dev-assets` (#6514)

---
 Cargo.lock                            | 2 +-
 Cargo.toml                            | 2 +-
 tests/suite/layout/align.typ          | 2 +-
 tests/suite/layout/inline/bidi.typ    | 3 ++-
 tests/suite/layout/inline/shaping.typ | 1 +
 tests/suite/layout/inline/text.typ    | 2 +-
 tests/suite/layout/repeat.typ         | 4 ++--
 tests/suite/model/cite.typ            | 1 +
 tests/suite/model/par.typ             | 2 +-
 tests/suite/model/quote.typ           | 2 ++
 tests/suite/syntax/numbers.typ        | 1 +
 11 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 91ff48432..550c4141a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2911,7 +2911,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"
diff --git a/Cargo.toml b/Cargo.toml
index 76d83995f..6cc59ee89 100644
--- a/Cargo.toml
+++ b/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"
diff --git a/tests/suite/layout/align.typ b/tests/suite/layout/align.typ
index c4ed9ab95..1c1a08683 100644
--- a/tests/suite/layout/align.typ
+++ b/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)[نهاية]
 
diff --git a/tests/suite/layout/inline/bidi.typ b/tests/suite/layout/inline/bidi.typ
index 5f8712d56..d7601fa1d 100644
--- a/tests/suite/layout/inline/bidi.typ
+++ b/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")[سلام]
   ],
 )
diff --git a/tests/suite/layout/inline/shaping.typ b/tests/suite/layout/inline/shaping.typ
index dc73100b5..4dfc6eb11 100644
--- a/tests/suite/layout/inline/shaping.typ
+++ b/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
 
diff --git a/tests/suite/layout/inline/text.typ b/tests/suite/layout/inline/text.typ
index 369aba7fd..a211ffd30 100644
--- a/tests/suite/layout/inline/text.typ
+++ 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 ---
diff --git a/tests/suite/layout/repeat.typ b/tests/suite/layout/repeat.typ
index a46bf6d28..8ba5d2661 100644
--- a/tests/suite/layout/repeat.typ
+++ b/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 ---
diff --git a/tests/suite/model/cite.typ b/tests/suite/model/cite.typ
index 1a79b690d..363b58489 100644
--- a/tests/suite/model/cite.typ
+++ b/tests/suite/model/cite.typ
@@ -151,6 +151,7 @@ B #cite(<netwok>) #cite(<arrgh>).
 --- 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
 این است
diff --git a/tests/suite/model/par.typ b/tests/suite/model/par.typ
index d2c3416e0..fae0e1f56 100644
--- a/tests/suite/model/par.typ
+++ b/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"))
 لآن وقد أظلم الليل وبدأت النجوم
 تنضخ وجه الطبيعة التي أعْيَتْ من طول ما انبعثت في النهار
 
diff --git a/tests/suite/model/quote.typ b/tests/suite/model/quote.typ
index 4137262a7..1c5954427 100644
--- a/tests/suite/model/quote.typ
+++ b/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]
 
diff --git a/tests/suite/syntax/numbers.typ b/tests/suite/syntax/numbers.typ
index 1f15ac720..d7e6da4d1 100644
--- a/tests/suite/syntax/numbers.typ
+++ b/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 \

From e8f9877fc5b56a329726d293fe686d0fd1bf1e3a Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 30 Jun 2025 10:23:15 +0200
Subject: [PATCH 044/101] Acknowledgements (#6528)

---
 README.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/README.md b/README.md
index 9526f3df4..9dee102b6 100644
--- a/README.md
+++ b/README.md
@@ -240,6 +240,26 @@ instant preview. To achieve these goals, we follow three core design principles:
   Luckily we have [`comemo`], a system for incremental compilation which does
   most of the hard work in the background.
 
+## Acknowledgements
+
+We'd like to thank everyone who is supporting Typst's development, be it via
+[GitHub sponsors] or elsewhere. In particular, special thanks[^1] go to:
+
+- [Posit](https://posit.co/blog/posit-and-typst/) for financing a full-time
+  compiler engineer
+- [NLnet](https://nlnet.nl/) for supporting work on Typst via multiple grants
+  through the [NGI Zero Core](https://nlnet.nl/core) fund:
+  - Work on [HTML export](https://nlnet.nl/project/Typst-HTML/)
+  - Work on [PDF accessibility](https://nlnet.nl/project/Typst-Accessibility/)
+- [Science & Startups](https://www.science-startups.berlin/) for having financed
+  Typst development from January through June 2023 via the Berlin Startup
+  Scholarship
+- [Zerodha](https://zerodha.tech/blog/1-5-million-pdfs-in-25-minutes/) for their
+  generous one-time sponsorship
+
+[^1]: This list only includes contributions for our open-source work that exceed
+    or are expected to exceed €10K.
+
 [docs]: https://typst.app/docs/
 [app]: https://typst.app/
 [discord]: https://discord.gg/2uDybryKPe
@@ -259,3 +279,4 @@ instant preview. To achieve these goals, we follow three core design principles:
 [packages]: https://github.com/typst/packages/
 [`comemo`]: https://github.com/typst/comemo/
 [snap]: https://snapcraft.io/typst
+[GitHub sponsors]: https://github.com/sponsors/typst/

From c4bcfb18c13c8b6fff26667def1c855162eeb02d Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 30 Jun 2025 10:27:02 +0200
Subject: [PATCH 045/101] Support HTML tests in test-helper extension (#6504)

---
 tools/test-helper/package.json     |  11 +-
 tools/test-helper/src/extension.ts | 313 +++++++++++++++++++++--------
 tools/test-helper/tsconfig.json    |   5 +-
 3 files changed, 239 insertions(+), 90 deletions(-)

diff --git a/tools/test-helper/package.json b/tools/test-helper/package.json
index 08a60fa31..42c77390d 100644
--- a/tools/test-helper/package.json
+++ b/tools/test-helper/package.json
@@ -94,9 +94,12 @@
 		"watch": "tsc -watch -p ./"
 	},
 	"devDependencies": {
-		"@types/node": "18.x",
-		"@types/vscode": "^1.88.0",
-		"typescript": "^5.3.3"
+		"@types/node": "^24.0.4",
+		"@types/vscode": "^1.101.0",
+		"typescript": "^5.8.3"
+	},
+	"dependencies": {
+		"shiki": "^3.7.0"
 	},
 	"engines": {
 		"vscode": "^1.88.0"
@@ -104,4 +107,4 @@
 	"__metadata": {
 		"size": 35098973
 	}
-}
\ No newline at end of file
+}
diff --git a/tools/test-helper/src/extension.ts b/tools/test-helper/src/extension.ts
index b98b4bad4..f86527b5a 100644
--- a/tools/test-helper/src/extension.ts
+++ b/tools/test-helper/src/extension.ts
@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 import * as cp from "child_process";
 import { clearInterval } from "timers";
+const shiki = import("shiki"); // Normal import causes TypeScript problems.
 
 // Called when an activation event is triggered. Our activation event is the
 // presence of "tests/suite/playground.typ".
@@ -17,6 +18,8 @@ class TestHelper {
   opened?: {
     // The tests's name.
     name: string;
+    // The test's attributes.
+    attrs: string[];
     // The WebView panel that displays the test images and output.
     panel: vscode.WebviewPanel;
   };
@@ -44,18 +47,18 @@ class TestHelper {
     );
 
     // Triggered when clicking "View" in the lens.
-    this.registerCommand("typst-test-helper.viewFromLens", (name) =>
-      this.viewFromLens(name)
+    this.registerCommand("typst-test-helper.viewFromLens", (name, attrs) =>
+      this.viewFromLens(name, attrs)
     );
 
     // Triggered when clicking "Run" in the lens.
-    this.registerCommand("typst-test-helper.runFromLens", (name) =>
-      this.runFromLens(name)
+    this.registerCommand("typst-test-helper.runFromLens", (name, attrs) =>
+      this.runFromLens(name, attrs)
     );
 
     // Triggered when clicking "Save" in the lens.
-    this.registerCommand("typst-test-helper.saveFromLens", (name) =>
-      this.saveFromLens(name)
+    this.registerCommand("typst-test-helper.saveFromLens", (name, attrs) =>
+      this.saveFromLens(name, attrs)
     );
 
     // Triggered when clicking "Terminal" in the lens.
@@ -121,31 +124,32 @@ class TestHelper {
     const lenses = [];
     for (let nr = 0; nr < document.lineCount; nr++) {
       const line = document.lineAt(nr);
-      const re = /^--- ([\d\w-]+)( [\d\w-]+)* ---$/;
+      const re = /^--- ([\d\w-]+)(( [\d\w-]+)*) ---$/;
       const m = line.text.match(re);
       if (!m) {
         continue;
       }
 
       const name = m[1];
+      const attrs = m[2].trim().split(" ");
       lenses.push(
         new vscode.CodeLens(line.range, {
           title: "View",
           tooltip: "View the test output and reference in a new tab",
           command: "typst-test-helper.viewFromLens",
-          arguments: [name],
+          arguments: [name, attrs],
         }),
         new vscode.CodeLens(line.range, {
           title: "Run",
           tooltip: "Run the test and view the results in a new tab",
           command: "typst-test-helper.runFromLens",
-          arguments: [name],
+          arguments: [name, attrs],
         }),
         new vscode.CodeLens(line.range, {
           title: "Save",
           tooltip: "Run and view the test and save the reference output",
           command: "typst-test-helper.saveFromLens",
-          arguments: [name],
+          arguments: [name, attrs],
         }),
         new vscode.CodeLens(line.range, {
           title: "Terminal",
@@ -159,40 +163,49 @@ class TestHelper {
   }
 
   // Triggered when clicking "View" in the lens.
-  private viewFromLens(name: string) {
-    if (this.opened?.name == name) {
+  private viewFromLens(name: string, attrs: string[]) {
+    if (
+      this.opened?.name == name &&
+      this.opened.attrs.join(" ") == attrs.join(" ")
+    ) {
       this.opened.panel.reveal();
       return;
     }
 
     if (this.opened) {
       this.opened.name = name;
+      this.opened.attrs = attrs;
       this.opened.panel.title = name;
     } else {
       const panel = vscode.window.createWebviewPanel(
         "typst-test-helper.preview",
         name,
         vscode.ViewColumn.Beside,
-        { enableFindWidget: true }
+        { enableFindWidget: true, enableScripts: true }
       );
 
       panel.onDidDispose(() => (this.opened = undefined));
+      panel.webview.onDidReceiveMessage((message) => {
+        if (message.command === "openFile") {
+          vscode.env.openExternal(vscode.Uri.parse(message.uri));
+        }
+      });
 
-      this.opened = { name, panel };
+      this.opened = { name, attrs, panel };
     }
 
     this.refreshWebView();
   }
 
   // Triggered when clicking "Run" in the lens.
-  private runFromLens(name: string) {
-    this.viewFromLens(name);
+  private runFromLens(name: string, attrs: string[]) {
+    this.viewFromLens(name, attrs);
     this.runFromPreview();
   }
 
   // Triggered when clicking "Run" in the lens.
-  private saveFromLens(name: string) {
-    this.viewFromLens(name);
+  private saveFromLens(name: string, attrs: string[]) {
+    this.viewFromLens(name, attrs);
     this.saveFromPreview();
   }
 
@@ -288,41 +301,37 @@ class TestHelper {
   private copyImageFilePathFromPreviewContext(webviewSection: string) {
     if (!this.opened) return;
     const { name } = this.opened;
-    const { png, ref } = getImageUris(name);
-    switch (webviewSection) {
-      case "png":
-        vscode.env.clipboard.writeText(png.fsPath);
-        break;
-      case "ref":
-        vscode.env.clipboard.writeText(ref.fsPath);
-        break;
-      default:
-        break;
-    }
+    const [bucket, format] = webviewSection.split("/");
+    vscode.env.clipboard.writeText(
+      getUri(name, bucket as Bucket, format as Format).fsPath
+    );
   }
 
   // Reloads the web view.
   private refreshWebView(output?: { stdout: string; stderr: string }) {
     if (!this.opened) return;
 
-    const { name, panel } = this.opened;
-    const { png, ref } = getImageUris(name);
+    const { name, attrs, panel } = this.opened;
 
     if (panel) {
       console.log(
-        `Refreshing WebView for ${name}` + (panel.visible ? " in background" : ""));
-      const webViewSrcs = {
-        png: panel.webview.asWebviewUri(png),
-        ref: panel.webview.asWebviewUri(ref),
-      };
+        `Refreshing WebView for ${name}` +
+          (panel.visible ? " in background" : "")
+      );
+
       panel.webview.html = "";
 
       // Make refresh notable.
-      setTimeout(() => {
+      setTimeout(async () => {
         if (!panel) {
           throw new Error("panel to refresh is falsy after waiting");
         }
-        panel.webview.html = getWebviewContent(webViewSrcs, output);
+        panel.webview.html = await getWebviewContent(
+          panel,
+          name,
+          attrs,
+          output
+        );
       }, 50);
     }
   }
@@ -386,30 +395,43 @@ function getWorkspaceRoot() {
   return vscode.workspace.workspaceFolders![0].uri;
 }
 
-// Returns the URIs for a test's images.
-function getImageUris(name: string) {
-  const root = getWorkspaceRoot();
-  const png = vscode.Uri.joinPath(root, `tests/store/render/${name}.png`);
-  const ref = vscode.Uri.joinPath(root, `tests/ref/${name}.png`);
-  return { png, ref };
+const EXTENSION = { html: "html", render: "png" };
+
+type Bucket = "store" | "ref";
+type Format = "html" | "render";
+
+function getUri(name: string, bucket: Bucket, format: Format) {
+  let path;
+  if (bucket === "ref" && format === "render") {
+    path = `tests/ref/${name}.png`;
+  } else {
+    path = `tests/${bucket}/${format}/${name}.${EXTENSION[format]}`;
+  }
+  return vscode.Uri.joinPath(getWorkspaceRoot(), path);
 }
 
 // Produces the content of the WebView.
-function getWebviewContent(
-  webViewSrcs: { png: vscode.Uri; ref: vscode.Uri },
+async function getWebviewContent(
+  panel: vscode.WebviewPanel,
+  name: string,
+  attrs: string[],
   output?: {
     stdout: string;
     stderr: string;
   }
-): string {
-  const escape = (text: string) =>
-    text.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+): Promise<string> {
+  const showHtml = attrs.includes("html");
+  const showRender = !showHtml || attrs.includes("render");
 
-  const stdoutHtml = output?.stdout
-    ? `<h1>Standard output</h1><pre>${escape(output.stdout)}</pre>`
+  const stdout = output?.stdout
+    ? `<h2>Standard output</h2><pre class="output">${escape(
+        output.stdout
+      )}</pre>`
     : "";
-  const stderrHtml = output?.stderr
-    ? `<h1>Standard error</h1><pre>${escape(output.stderr)}</pre>`
+  const stderr = output?.stderr
+    ? `<h2>Standard error</h2><pre class="output">${escape(
+        output.stderr
+      )}</pre>`
     : "";
 
   return `
@@ -449,46 +471,169 @@ function getWebviewContent(
           color: #bebebe;
           content: "Not present";
         }
-        pre {
-          display: inline-block;
-          font-family: var(--vscode-editor-font-family);
-          text-align: left;
-          width: 80%;
+        h2 {
+          margin-bottom: 12px;
+        }
+        h2 a {
+          color: var(--vscode-editor-foreground);
+          text-decoration: underline;
+        }
+        h2 a:hover {
+          cursor: pointer;
         }
         .flex {
           display: flex;
           flex-wrap: wrap;
           justify-content: center;
         }
+        .vertical {
+          flex-direction: column;
+        }
+        .top-bottom {
+          display: flex;
+          flex-direction: column;
+          padding-inline: 32px;
+          width: calc(100vw - 64px);
+        }
+        pre {
+          font-family: var(--vscode-editor-font-family);
+          text-align: left;
+          white-space: pre-wrap;
+        }
+        pre.output {
+          display: inline-block;
+          width: 80%;
+          margin-block-start: 0;
+        }
+        pre.shiki {
+          background-color: transparent !important;
+          padding: 12px;
+          margin-block-start: 0;
+        }
+        pre.shiki code {
+          --vscode-textPreformat-background: transparent;
+        }
+        iframe, pre.shiki {
+          border: 1px solid rgb(189, 191, 204);
+          border-radius: 6px;
+        }
+        iframe {
+          background: white;
+        }
+        .vscode-dark iframe {
+          filter: invert(1) hue-rotate(180deg);
+        }
       </style>
+      <script>
+        const api = acquireVsCodeApi()
+        function openFile(uri) {
+          api.postMessage({ command: 'openFile', uri });
+        }
+        function sizeIframe(obj){
+          obj.style.height = 0;
+          obj.style.height = obj.contentWindow.document.body.scrollHeight + 'px';
+        }
+      </script>
     </head>
     <body>
-      <div
-        class="flex"
-        data-vscode-context='{"preventDefaultContextMenuItems": true}'
-      >
-        <div>
-          <h1>Output</h1>
-          <img
-            class="output"
-            data-vscode-context='{"webviewSection":"png"}'
-            src="${webViewSrcs.png}"
-            alt="Placeholder"
-          >
-        </div>
-
-        <div>
-          <h1>Reference</h1>
-          <img
-            class="ref"
-            data-vscode-context='{"webviewSection":"ref"}'
-            src="${webViewSrcs.ref}"
-            alt="Placeholder"
-          >
-        </div>
-      </div>
-      ${stdoutHtml}
-      ${stderrHtml}
+      ${showRender ? renderSection(panel, name) : ""}
+      ${showHtml ? await htmlSection(name) : ""}
+      ${stdout}
+      ${stderr}
     </body>
   </html>`;
 }
+
+function renderSection(panel: vscode.WebviewPanel, name: string) {
+  const outputUri = getUri(name, "store", "render");
+  const refUri = getUri(name, "ref", "render");
+  return `<div
+    class="flex"
+    data-vscode-context='{"preventDefaultContextMenuItems": true}'
+  >
+    <div>
+      ${linkedTitle("Output", outputUri)}
+      <img
+        class="output"
+        data-vscode-context='{"bucket":"store", format: "render"}'
+        src="${panel.webview.asWebviewUri(outputUri)}"
+        alt="Placeholder"
+      >
+    </div>
+
+    <div>
+      ${linkedTitle("Reference", refUri)}
+      <img
+        class="ref"
+        data-vscode-context='{"bucket":"ref", format: "render"}'
+        src="${panel.webview.asWebviewUri(refUri)}"
+        alt="Placeholder"
+      >
+    </div>
+  </div>`;
+}
+
+async function htmlSection(name: string) {
+  const storeHtml = await htmlSnippet(
+    "HTML Output",
+    getUri(name, "store", "html")
+  );
+  const refHtml = await htmlSnippet(
+    "HTML Reference",
+    getUri(name, "ref", "html")
+  );
+  return `<div
+    class="flex vertical"
+    data-vscode-context='{"preventDefaultContextMenuItems": true}'
+  >
+    ${storeHtml}
+    ${refHtml}
+  </div>`;
+}
+
+async function htmlSnippet(title: string, uri: vscode.Uri): Promise<string> {
+  try {
+    const data = await vscode.workspace.fs.readFile(uri);
+    const code = new TextDecoder("utf-8").decode(data);
+    return `<div>
+      ${linkedTitle(title, uri)}
+      <div class="top-bottom">
+        ${await highlight(code)}
+        <iframe srcdoc="${escape(code)}"></iframe>
+      </div>
+    </div>`;
+  } catch {
+    return `<div><h2>${title}</h2>Not present</div>`;
+  }
+}
+
+function linkedTitle(title: string, uri: vscode.Uri) {
+  return `<h2><a onclick="openFile('${uri.toString()}')">${title}</a></h2>`;
+}
+
+async function highlight(code: string): Promise<string> {
+  return (await shiki).codeToHtml(code, {
+    lang: "html",
+    theme: selectTheme(),
+  });
+}
+
+function selectTheme() {
+  switch (vscode.window.activeColorTheme.kind) {
+    case vscode.ColorThemeKind.Light:
+    case vscode.ColorThemeKind.HighContrastLight:
+      return "github-light";
+    case vscode.ColorThemeKind.Dark:
+    case vscode.ColorThemeKind.HighContrast:
+      return "github-dark";
+  }
+}
+
+function escape(text: string) {
+  return text
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
diff --git a/tools/test-helper/tsconfig.json b/tools/test-helper/tsconfig.json
index 45e374553..952c40426 100644
--- a/tools/test-helper/tsconfig.json
+++ b/tools/test-helper/tsconfig.json
@@ -1,9 +1,10 @@
 {
   "compilerOptions": {
-    "module": "Node16",
+    "module": "nodenext",
+    "lib": ["ES2022", "DOM"],
     "target": "ES2022",
+    "moduleResolution": "nodenext",
     "outDir": "dist",
-    "lib": ["ES2022"],
     "sourceMap": true,
     "rootDir": "src",
     "strict": true

From a6cf0247b211974240ac2245c92a328245d16b5d Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Mon, 30 Jun 2025 10:27:22 +0200
Subject: [PATCH 046/101] Fix typo in Advanced Styling docs tutorial (#6517)

---
 docs/tutorial/3-advanced.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/tutorial/3-advanced.md b/docs/tutorial/3-advanced.md
index b7f338db5..41e60ecef 100644
--- a/docs/tutorial/3-advanced.md
+++ b/docs/tutorial/3-advanced.md
@@ -79,7 +79,7 @@ the right.
 
 Last but not least is the `numbering` argument. Here, we can provide a
 [numbering pattern]($numbering) that defines how to number the pages. By
-setting into to `{"1"}`, Typst only displays the bare page number. Setting it to
+setting it to `{"1"}`, Typst only displays the bare page number. Setting it to
 `{"(1/1)"}` would have displayed the current page and total number of pages
 surrounded by parentheses. And we could even have provided a completely custom
 function here to format things to our liking.

From 880f56c90db69a892f0beb3e3fa251c9f3e986d0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Delgado?=
 <11708972+adriandelgado@users.noreply.github.com>
Date: Mon, 30 Jun 2025 03:27:42 -0500
Subject: [PATCH 047/101] Fix typo in PDF standard CLI help (#6518)

---
 crates/typst-pdf/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-pdf/src/lib.rs b/crates/typst-pdf/src/lib.rs
index 4e0b74308..88c6ee552 100644
--- a/crates/typst-pdf/src/lib.rs
+++ b/crates/typst-pdf/src/lib.rs
@@ -172,7 +172,7 @@ pub enum PdfStandard {
     /// PDF/A-2u.
     #[serde(rename = "a-2u")]
     A_2u,
-    /// PDF/A-3u.
+    /// PDF/A-3b.
     #[serde(rename = "a-3b")]
     A_3b,
     /// PDF/A-3u.

From c99f3ffc7d885bf32d1a028a3ab22e840226c0c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Adri=C3=A1n=20Delgado?=
 <11708972+adriandelgado@users.noreply.github.com>
Date: Mon, 30 Jun 2025 11:51:36 -0500
Subject: [PATCH 048/101] Fix typo in PDF standard CLI help part 2 (#6531)

---
 crates/typst-cli/src/args.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-cli/src/args.rs b/crates/typst-cli/src/args.rs
index fd0eb5f05..c3fd541ad 100644
--- a/crates/typst-cli/src/args.rs
+++ b/crates/typst-cli/src/args.rs
@@ -491,7 +491,7 @@ pub enum PdfStandard {
     /// PDF/A-2u.
     #[value(name = "a-2u")]
     A_2u,
-    /// PDF/A-3u.
+    /// PDF/A-3b.
     #[value(name = "a-3b")]
     A_3b,
     /// PDF/A-3u.

From d978f8c33a869b52d2b38b20127bfbda635e1b42 Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Tue, 1 Jul 2025 13:04:11 +0200
Subject: [PATCH 049/101] Fix minor typo in `array.product` docs (#6532)

---
 crates/typst-library/src/foundations/array.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-library/src/foundations/array.rs b/crates/typst-library/src/foundations/array.rs
index c1fcb6b49..11c2220d7 100644
--- a/crates/typst-library/src/foundations/array.rs
+++ b/crates/typst-library/src/foundations/array.rs
@@ -604,7 +604,7 @@ impl Array {
         Ok(acc)
     }
 
-    /// Calculates the product all items (works for all types that can be
+    /// Calculates the product of all items (works for all types that can be
     /// multiplied).
     #[func]
     pub fn product(

From 30ddc4a7ca38ea41d9184cec6eee732307c80b33 Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Tue, 1 Jul 2025 13:04:31 +0200
Subject: [PATCH 050/101] Fix typos in calc module docs (#6535)

---
 crates/typst-library/src/foundations/calc.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/typst-library/src/foundations/calc.rs b/crates/typst-library/src/foundations/calc.rs
index 7f481a23b..1fe1ff1fc 100644
--- a/crates/typst-library/src/foundations/calc.rs
+++ b/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 arcsine to calculate. Must be between -1 and 1.
+    /// The number whose arccosine 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 an hyperbolic angle.
+/// Calculates the hyperbolic tangent of a hyperbolic angle.
 ///
 /// ```example
 /// #calc.tanh(0) \

From 09c831d3b32935fe162f198e3512e1e7cd6647db Mon Sep 17 00:00:00 2001
From: Malo <57839069+MDLC01@users.noreply.github.com>
Date: Wed, 2 Jul 2025 09:00:45 +0100
Subject: [PATCH 051/101] Use "subs" and "sups" font features for typographic
 scripts (#5777)

---
 crates/typst-layout/src/inline/collect.rs     |   4 +-
 crates/typst-layout/src/inline/line.rs        |  43 ++-
 crates/typst-layout/src/inline/linebreak.rs   |   6 +-
 crates/typst-layout/src/inline/mod.rs         |   2 +-
 crates/typst-layout/src/inline/prepare.rs     |   4 +-
 crates/typst-layout/src/inline/shaping.rs     | 143 +++++++--
 crates/typst-layout/src/math/fragment.rs      |   6 +-
 crates/typst-library/src/layout/em.rs         |  17 +-
 crates/typst-library/src/text/font/mod.rs     |  39 +++
 crates/typst-library/src/text/mod.rs          |   6 +
 crates/typst-library/src/text/shift.rs        | 298 ++++++++++--------
 .../ref/issue-4454-footnote-ref-numbering.png | Bin 841 -> 903 bytes
 tests/ref/long-scripts.png                    | Bin 0 -> 956 bytes
 tests/ref/script-metrics-bundeled-fonts.png   | Bin 0 -> 3110 bytes
 tests/ref/sub-super-italic-compensation.png   | Bin 0 -> 1281 bytes
 tests/ref/sub-super-non-typographic.png       | Bin 311 -> 318 bytes
 tests/ref/sub-super-typographic.png           | Bin 0 -> 1337 bytes
 tests/ref/sub-super.png                       | Bin 1114 -> 1189 bytes
 tests/ref/super-highlight.png                 | Bin 0 -> 1353 bytes
 tests/ref/super-underline.png                 | Bin 1833 -> 835 bytes
 tests/suite/text/shift.typ                    |  79 ++++-
 21 files changed, 450 insertions(+), 197 deletions(-)
 create mode 100644 tests/ref/long-scripts.png
 create mode 100644 tests/ref/script-metrics-bundeled-fonts.png
 create mode 100644 tests/ref/sub-super-italic-compensation.png
 create mode 100644 tests/ref/sub-super-typographic.png
 create mode 100644 tests/ref/super-highlight.png

diff --git a/crates/typst-layout/src/inline/collect.rs b/crates/typst-layout/src/inline/collect.rs
index 5a1b7b4fc..829f64b66 100644
--- a/crates/typst-layout/src/inline/collect.rs
+++ b/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_baseline_shift(&mut frame, styles);
+                        apply_shift(&engine.world, &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_baseline_shift(&mut frame, styles);
+                apply_shift(&engine.world, &mut frame, styles);
                 collector.push_item(Item::Frame(frame));
             }
         } else if let Some(elem) = child.to_packed::<TagElem>() {
diff --git a/crates/typst-layout/src/inline/line.rs b/crates/typst-layout/src/inline/line.rs
index 7bf4d4c73..b850e50ee 100644
--- a/crates/typst-layout/src/inline/line.rs
+++ b/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::{Lang, TextElem};
+use typst_library::text::{variant, 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(shaped.size);
+        shaped.width -= shrink.at(glyph.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(shaped.size);
+        shaped.width -= shrink.at(glyph.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(shaped.size);
+        shaped.width -= shrink.at(punct.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(shaped.size);
+        shaped.width -= shrink.at(glyph.size);
     }
 }
 
@@ -412,9 +412,30 @@ fn should_repeat_hyphen(pred_line: &Line, text: &str) -> bool {
     }
 }
 
-/// Apply the current baseline shift to a frame.
-pub fn apply_baseline_shift(frame: &mut Frame, styles: StyleChain) {
-    frame.translate(Point::with_y(TextElem::baseline_in(styles)));
+/// Apply the current baseline shift and italic compensation to a frame.
+pub fn apply_shift<'a>(
+    world: &Tracked<'a, dyn World + 'a>,
+    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.
@@ -444,7 +465,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(text.size);
+                let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
                 offset -= amount;
                 remaining += amount;
             }
@@ -458,7 +479,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(text.size);
+                let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
                 remaining += amount;
             }
         }
@@ -519,7 +540,7 @@ pub fn commit(
                     let mut frame = layout_and_modify(*styles, |styles| {
                         layout_box(elem, engine, loc.relayout(), styles, region)
                     })?;
-                    apply_baseline_shift(&mut frame, *styles);
+                    apply_shift(&engine.world, &mut frame, *styles);
                     push(&mut offset, frame, idx);
                 } else {
                     offset += amount;
diff --git a/crates/typst-layout/src/inline/linebreak.rs b/crates/typst-layout/src/inline/linebreak.rs
index ada048c7d..709745edc 100644
--- a/crates/typst-layout/src/inline/linebreak.rs
+++ b/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(shaped.size));
-                    stretchability.push(byte_len, stretch.at(shaped.size));
-                    shrinkability.push(byte_len, shrink.at(shaped.size));
+                    widths.push(byte_len, g.x_advance.at(g.size));
+                    stretchability.push(byte_len, stretch.at(g.size));
+                    shrinkability.push(byte_len, shrink.at(g.size));
                     justifiables.push(byte_len, g.is_justifiable() as usize);
                 }
             } else {
diff --git a/crates/typst-layout/src/inline/mod.rs b/crates/typst-layout/src/inline/mod.rs
index 6cafb9b00..506fa5eac 100644
--- a/crates/typst-layout/src/inline/mod.rs
+++ b/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_baseline_shift, commit, line, Line};
+use self::line::{apply_shift, commit, line, Line};
 use self::linebreak::{linebreak, Breakpoint};
 use self::prepare::{prepare, Preparation};
 use self::shaping::{
diff --git a/crates/typst-layout/src/inline/prepare.rs b/crates/typst-layout/src/inline/prepare.rs
index 5d7fcd7cb..ab39bdb14 100644
--- a/crates/typst-layout/src/inline/prepare.rs
+++ b/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(text.size);
+                text.width += Em::new(0.25).at(glyph.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(text.size);
+                text.width += Em::new(0.25).at(glyph.size);
             }
 
             prev = Some(glyph);
diff --git a/crates/typst-layout/src/inline/shaping.rs b/crates/typst-layout/src/inline/shaping.rs
index 935a86b38..48747cd50 100644
--- a/crates/typst-layout/src/inline/shaping.rs
+++ b/crates/typst-layout/src/inline/shaping.rs
@@ -3,14 +3,15 @@ use std::fmt::{self, Debug, Formatter};
 use std::sync::Arc;
 
 use az::SaturatingAs;
-use rustybuzz::{BufferFlags, ShapePlan, UnicodeBuffer};
+use rustybuzz::{BufferFlags, Feature, 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, TextEdgeBounds, TextElem, TextItem,
+    FontVariant, Glyph, Lang, Region, ShiftSettings, TextEdgeBounds, TextElem, TextItem,
 };
 use typst_library::World;
 use typst_utils::SliceExt;
@@ -41,8 +42,6 @@ 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.
@@ -62,6 +61,8 @@ 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
@@ -222,14 +223,17 @@ 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), group) in
-            self.glyphs.as_ref().group_by_key(|g| (g.font.clone(), g.y_offset))
+        for ((font, y_offset, glyph_size), group) in self
+            .glyphs
+            .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 {
@@ -237,7 +241,7 @@ impl<'a> ShapedText<'a> {
                 range.end = range.end.max(glyph.range.end);
             }
 
-            let pos = Point::new(offset, top + shift - y_offset.at(self.size));
+            let pos = Point::new(offset, top + shift - y_offset.at(size));
             let glyphs: Vec<Glyph> = group
                 .iter()
                 .map(|shaped: &ShapedGlyph| {
@@ -257,11 +261,11 @@ impl<'a> ShapedText<'a> {
                         adjustability_right * justification_ratio;
                     if shaped.is_justifiable() {
                         justification_right +=
-                            Em::from_length(extra_justification, self.size)
+                            Em::from_abs(extra_justification, glyph_size)
                     }
 
-                    frame.size_mut().x += justification_left.at(self.size)
-                        + justification_right.at(self.size);
+                    frame.size_mut().x += justification_left.at(glyph_size)
+                        + justification_right.at(glyph_size);
 
                     // We may not be able to reach the offset completely if
                     // it exceeds u16, but better to have a roughly correct
@@ -304,7 +308,7 @@ impl<'a> ShapedText<'a> {
 
             let item = TextItem {
                 font,
-                size: self.size,
+                size: glyph_size,
                 lang: self.lang,
                 region: self.region,
                 fill: fill.clone(),
@@ -336,12 +340,13 @@ 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, self.size, bounds);
+            let (t, b) = font.edges(top_edge, bottom_edge, size, bounds);
             top.set_max(t);
             bottom.set_max(b);
         };
@@ -388,18 +393,16 @@ impl<'a> ShapedText<'a> {
     pub fn stretchability(&self) -> Abs {
         self.glyphs
             .iter()
-            .map(|g| g.stretchability().0 + g.stretchability().1)
-            .sum::<Em>()
-            .at(self.size)
+            .map(|g| (g.stretchability().0 + g.stretchability().1).at(g.size))
+            .sum()
     }
 
     /// The shrinkability of the text
     pub fn shrinkability(&self) -> Abs {
         self.glyphs
             .iter()
-            .map(|g| g.shrinkability().0 + g.shrinkability().1)
-            .sum::<Em>()
-            .at(self.size)
+            .map(|g| (g.shrinkability().0 + g.shrinkability().1).at(g.size))
+            .sum()
     }
 
     /// Reshape a range of the shaped text, reusing information from this
@@ -418,9 +421,8 @@ impl<'a> ShapedText<'a> {
                 lang: self.lang,
                 region: self.region,
                 styles: self.styles,
-                size: self.size,
                 variant: self.variant,
-                width: glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(self.size),
+                width: glyphs_width(glyphs),
                 glyphs: Cow::Borrowed(glyphs),
             }
         } else {
@@ -484,13 +486,15 @@ 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);
-            self.width += x_advance.at(self.size);
+            let size = TextElem::size_in(self.styles);
+            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,
@@ -666,6 +670,7 @@ 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,
@@ -676,6 +681,7 @@ fn shape<'a>(
         features: features(styles),
         fallback: TextElem::fallback_in(styles),
         dir,
+        shift_settings,
     };
 
     if !text.is_empty() {
@@ -698,12 +704,17 @@ fn shape<'a>(
         region,
         styles,
         variant: ctx.variant,
-        size,
-        width: ctx.glyphs.iter().map(|g| g.x_advance).sum::<Em>().at(size),
+        width: glyphs_width(&ctx.glyphs),
         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>,
@@ -715,6 +726,7 @@ 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.
@@ -789,6 +801,18 @@ 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(
@@ -799,6 +823,10 @@ 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();
@@ -869,8 +897,9 @@ 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),
-                y_offset: font.to_em(pos[i].y_offset),
+                x_offset: font.to_em(pos[i].x_offset) + script_compensation,
+                y_offset: font.to_em(pos[i].y_offset) + script_shift,
+                size: scale.at(ctx.size),
                 adjustability: Adjustability::default(),
                 range: start..end,
                 safe_to_break: !info.unsafe_to_break(),
@@ -932,6 +961,64 @@ 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(
@@ -963,6 +1050,7 @@ 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,
@@ -985,9 +1073,8 @@ 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_length(TextElem::tracking_in(ctx.styles), ctx.size);
-    let spacing =
-        TextElem::spacing_in(ctx.styles).map(|abs| Em::from_length(abs, ctx.size));
+    let tracking = Em::from_abs(TextElem::tracking_in(ctx.styles), ctx.size);
+    let spacing = TextElem::spacing_in(ctx.styles).map(|abs| Em::from_abs(abs, ctx.size));
 
     let mut glyphs = ctx.glyphs.iter_mut().peekable();
     while let Some(glyph) = glyphs.next() {
diff --git a/crates/typst-layout/src/math/fragment.rs b/crates/typst-layout/src/math/fragment.rs
index eb85eeb5d..c5891f7d5 100644
--- a/crates/typst-layout/src/math/fragment.rs
+++ b/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_length(height, glyph.item.size),
+                    Em::from_abs(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_length(advance, base.item.size), Em::zero()),
-            Axis::Y => (Em::zero(), Em::from_length(advance, base.item.size)),
+            Axis::X => (Em::from_abs(advance, base.item.size), Em::zero()),
+            Axis::Y => (Em::zero(), Em::from_abs(advance, base.item.size)),
         };
         glyphs.push(Glyph {
             id: part.glyph_id.0,
diff --git a/crates/typst-library/src/layout/em.rs b/crates/typst-library/src/layout/em.rs
index e2d8b120f..746e17692 100644
--- a/crates/typst-library/src/layout/em.rs
+++ b/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;
+use crate::layout::{Abs, Length};
 use crate::text::TextElem;
 
 /// A length that is relative to the font size.
@@ -26,18 +26,18 @@ impl Em {
         Self(Scalar::ONE)
     }
 
-    /// Create a font-relative length.
+    /// Creates a font-relative length.
     pub const fn new(em: f64) -> Self {
         Self(Scalar::new(em))
     }
 
-    /// Create an em length from font units at the given units per em.
+    /// Creates 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))
     }
 
-    /// Create an em length from a length at the given font size.
-    pub fn from_length(length: Abs, font_size: Abs) -> Self {
+    /// Creates an em length from an absolute length at the given font size.
+    pub fn from_abs(length: Abs, font_size: Abs) -> Self {
         let result = length / font_size;
         if result.is_finite() {
             Self(Scalar::new(result))
@@ -46,6 +46,11 @@ 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()
@@ -56,7 +61,7 @@ impl Em {
         Self::new(self.get().abs())
     }
 
-    /// Convert to an absolute length at the given font size.
+    /// Converts 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() {
diff --git a/crates/typst-library/src/text/font/mod.rs b/crates/typst-library/src/text/font/mod.rs
index 0383bfe15..3f5e71204 100644
--- a/crates/typst-library/src/text/font/mod.rs
+++ b/crates/typst-library/src/text/font/mod.rs
@@ -228,6 +228,10 @@ 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 {
@@ -240,6 +244,7 @@ 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();
 
@@ -262,6 +267,20 @@ 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,
@@ -271,6 +290,8 @@ impl FontMetrics {
             strikethrough,
             underline,
             overline,
+            superscript,
+            subscript,
         }
     }
 
@@ -296,6 +317,24 @@ 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 {
diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index 563adbbd4..b1e381cb2 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -755,6 +755,12 @@ 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 {
diff --git a/crates/typst-library/src/text/shift.rs b/crates/typst-library/src/text/shift.rs
index 7b35dfd38..b7f3ed926 100644
--- a/crates/typst-library/src/text/shift.rs
+++ b/crates/typst-library/src/text/shift.rs
@@ -1,14 +1,13 @@
-use ecow::EcoString;
-
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, SequenceElem, Show, StyleChain, TargetElem,
+    elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
 };
 use crate::html::{tag, HtmlElem};
 use crate::layout::{Em, Length};
-use crate::text::{variant, SpaceElem, TextElem, TextSize};
-use crate::World;
+use crate::text::{FontMetrics, TextElem, TextSize};
+use ttf_parser::Tag;
+use typst_library::text::ScriptMetrics;
 
 /// Renders text in subscript.
 ///
@@ -20,11 +19,16 @@ use crate::World;
 /// ```
 #[elem(title = "Subscript", Show)]
 pub struct SubElem {
-    /// Whether to prefer the dedicated subscript characters of the font.
+    /// Whether to create artificial subscripts by lowering and scaling down
+    /// regular glyphs.
     ///
-    /// If this is enabled, Typst first tries to transform the text to subscript
-    /// codepoints. If that fails, it falls back to rendering lowered and shrunk
-    /// normal letters.
+    /// Ideally, subscripts glyphs are provided by the font (using the `subs`
+    /// OpenType feature). Otherwise, Typst is able to synthesize subscripts.
+    ///
+    /// 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]
@@ -33,17 +37,27 @@ pub struct SubElem {
     #[default(true)]
     pub typographic: bool,
 
-    /// The baseline shift for synthetic subscripts. Does not apply if
-    /// `typographic` is true and the font has subscript codepoints for the
-    /// given `body`.
-    #[default(Em::new(0.2).into())]
-    pub baseline: Length,
+    /// The downward baseline shift for synthesized subscripts.
+    ///
+    /// This only applies to synthesized subscripts. In other words, this has no
+    /// effect if `typographic` is `{true}` and the font provides the necessary
+    /// subscript glyphs.
+    ///
+    /// 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 synthetic subscripts. Does not apply if
-    /// `typographic` is true and the font has subscript codepoints for the
-    /// given `body`.
-    #[default(TextSize(Em::new(0.6).into()))]
-    pub size: TextSize,
+    /// The font size for synthesized subscripts.
+    ///
+    /// This only applies to synthesized subscripts. In other words, this has no
+    /// effect if `typographic` is `{true}` and the font provides the necessary
+    /// subscript glyphs.
+    ///
+    /// 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]
@@ -52,7 +66,7 @@ pub struct SubElem {
 
 impl Show for Packed<SubElem> {
     #[typst_macros::time(name = "sub", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
 
         if TargetElem::target_in(styles).is_html() {
@@ -62,17 +76,14 @@ impl Show for Packed<SubElem> {
                 .spanned(self.span()));
         }
 
-        if self.typographic(styles) {
-            if let Some(text) = convert_script(&body, true) {
-                if is_shapable(engine, &text, styles) {
-                    return Ok(TextElem::packed(text));
-                }
-            }
-        };
-
-        Ok(body
-            .styled(TextElem::set_baseline(self.baseline(styles)))
-            .styled(TextElem::set_size(self.size(styles))))
+        show_script(
+            styles,
+            body,
+            self.typographic(styles),
+            self.baseline(styles),
+            self.size(styles),
+            ScriptKind::Sub,
+        )
     }
 }
 
@@ -86,11 +97,16 @@ impl Show for Packed<SubElem> {
 /// ```
 #[elem(title = "Superscript", Show)]
 pub struct SuperElem {
-    /// Whether to prefer the dedicated superscript characters of the font.
+    /// Whether to create artificial superscripts by raising and scaling down
+    /// regular glyphs.
     ///
-    /// If this is enabled, Typst first tries to transform the text to
-    /// superscript codepoints. If that fails, it falls back to rendering
-    /// raised and shrunk normal letters.
+    /// Ideally, superscripts glyphs are provided by the font (using the `sups`
+    /// OpenType feature). Otherwise, Typst is able to synthesize superscripts.
+    ///
+    /// 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]
@@ -99,17 +115,31 @@ pub struct SuperElem {
     #[default(true)]
     pub typographic: bool,
 
-    /// The baseline shift for synthetic superscripts. Does not apply if
-    /// `typographic` is true and the font has superscript codepoints for the
-    /// given `body`.
-    #[default(Em::new(-0.5).into())]
-    pub baseline: Length,
+    /// The downward baseline shift for synthesized superscripts.
+    ///
+    /// This only applies to synthesized superscripts. In other words, this has
+    /// no effect if `typographic` is `{true}` and the font provides the
+    /// necessary superscript glyphs.
+    ///
+    /// 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 synthetic superscripts. Does not apply if
-    /// `typographic` is true and the font has superscript codepoints for the
-    /// given `body`.
-    #[default(TextSize(Em::new(0.6).into()))]
-    pub size: TextSize,
+    /// The font size for synthesized superscripts.
+    ///
+    /// This only applies to synthesized superscripts. In other words, this has
+    /// no effect if `typographic` is `{true}` and the font provides the
+    /// necessary superscript glyphs.
+    ///
+    /// 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]
@@ -118,7 +148,7 @@ pub struct SuperElem {
 
 impl Show for Packed<SuperElem> {
     #[typst_macros::time(name = "super", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
 
         if TargetElem::target_in(styles).is_html() {
@@ -128,104 +158,102 @@ impl Show for Packed<SuperElem> {
                 .spanned(self.span()));
         }
 
-        if self.typographic(styles) {
-            if let Some(text) = convert_script(&body, false) {
-                if is_shapable(engine, &text, styles) {
-                    return Ok(TextElem::packed(text));
-                }
-            }
-        };
-
-        Ok(body
-            .styled(TextElem::set_baseline(self.baseline(styles)))
-            .styled(TextElem::set_size(self.size(styles))))
+        show_script(
+            styles,
+            body,
+            self.typographic(styles),
+            self.baseline(styles),
+            self.size(styles),
+            ScriptKind::Super,
+        )
     }
 }
 
-/// Find and transform the text contained in `content` to the given script kind
-/// if and only if it only consists of `Text`, `Space`, and `Empty` leaves.
-fn convert_script(content: &Content, sub: bool) -> Option<EcoString> {
-    if content.is::<SpaceElem>() {
-        Some(' '.into())
-    } else if let Some(elem) = content.to_packed::<TextElem>() {
-        if sub {
-            elem.text.chars().map(to_subscript_codepoint).collect()
-        } else {
-            elem.text.chars().map(to_superscript_codepoint).collect()
-        }
-    } else if let Some(sequence) = content.to_packed::<SequenceElem>() {
-        sequence
-            .children
-            .iter()
-            .map(|item| convert_script(item, sub))
-            .collect()
-    } else {
-        None
-    }
+fn show_script(
+    styles: StyleChain,
+    body: Content,
+    typographic: bool,
+    baseline: Smart<Length>,
+    size: Smart<TextSize>,
+    kind: ScriptKind,
+) -> SourceResult<Content> {
+    let font_size = TextElem::size_in(styles);
+    Ok(body.styled(TextElem::set_shift_settings(Some(ShiftSettings {
+        typographic,
+        shift: baseline.map(|l| -Em::from_length(l, font_size)),
+        size: size.map(|t| Em::from_length(t.0, font_size)),
+        kind,
+    }))))
 }
 
-/// Checks whether the first retrievable family contains all code points of the
-/// given string.
-fn is_shapable(engine: &Engine, text: &str, styles: StyleChain) -> bool {
-    let world = engine.world;
-    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()
-            });
+/// 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,
         }
     }
 
-    false
-}
+    /// 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())
+    }
 
-/// 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,
+    /// 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"),
+        }
     }
 }
+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),
+};
 
-/// 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,
-    }
-}
+static DEFAULT_SUPERSCRIPT_METRICS: ScriptMetrics = ScriptMetrics {
+    width: Em::new(0.6),
+    height: Em::new(0.6),
+    horizontal_offset: Em::zero(),
+    vertical_offset: Em::new(0.5),
+};
diff --git a/tests/ref/issue-4454-footnote-ref-numbering.png b/tests/ref/issue-4454-footnote-ref-numbering.png
index bf23221aeeeb719e4e276cb3f92e15fbce353363..bc19d46c531ca73d46feb7e883c46af7fce88d44 100644
GIT binary patch
delta 880
zcmV-$1CRX428RcbB!8z+OjJex|Nr&%_4oJr-QVZ#@AKy8?fLoo+}`H%^Y-lR@#Ey^
z+uPesO-=s({z^(pG&D4QeSM3Ii#RwqEG#VX@$t>g&6k&#+}zxBbacqd(zdp?larHa
zX=!h7Z}9N&>FMdq%gddeoui|pb8~YmD=UG4fvc^xm6xBeuz#?LiHXF-#Psy^NJvQP
z>gqEyGv?;z>g(@<gpAG4*NBLS*VotB*w}J%a>d2PK0ZD+Ha6PY+T!BkS65f5sj1M=
z&_qN;(bCv{fQZ`L;l9AgxVpmN;pf%X+<$?Igocj1zQ)PR)5pottgNg-K|y+Ydf(sQ
zg@uKDe0-FYlz(SuXJTSv^78VcqN3K;)@*ES>FVy{;^f}m;NITehlhu|ySrs&WzWyg
zYHDiJ)6?qe>@F@Y`}_N#prBq}UaG39>+JC3<K?TXt?ljY@9*)zz`(MyviJA*{QUgJ
z#>Qx9XtT4knwpwqWMqttjDCK8!NI|(sHoM|)s~i)LVrR+`1ts6aB$Mn(qLd<jg5`v
z<>lSo-ED1c!^6YAzP|na{m973>+9?L`}~TEik)xbcmMzan@L1LRCwC$)zwY|K>&r}
z!_00A6n7}@?(XjH?(VL|N`<yOG#kinH>C7x$OPE$?p*zuOfmzF<{u#B6$%}3!Si}0
z1Z+`Cpnnjl0MCn1$~vr9hxGzHFQR81&dgGUJG=bh*4#4V4tMu}o%{kIHuf{TxL~?8
zcC-tSID$h$ujkR)_Oa~gA?9b&*9&Hn<BiH4-z@=1kZ(1}fc=3Xc?BoJ&h(DW5!FiA
zdI%s;P6Zf%{y}+#B{`y5hMi|OHMMd$C=wENxPP%p38$n*vJ9I~?@ZTnI40_AxM5fc
zM*s)x!ak3{!}<oLYfk_yg$5iSNvWzp0Qcp{tACM}4U%vtY<rZxSir>Sh!YO$CZ)5_
zkQ7CkZcn6CWd-1PEK5zPgS57sfZcj^Vcn(Fb`F*(ox4%LRku*Boo(hX7yl<y6m?Me
ziD|y@ymX?deW)7Eciz0h&++jJe;5%6xDZMOaN%E4oSmKfz~RJHNX<#Q=Ms)HCXVq5
z$7hUB@HsKACV7NISC*%zc!Zx;EdY-&xNs4d_G4-^zsWn*4NQnYmfMK{0000<MNUMn
GLSTZ?P56lb

delta 818
zcmV-21I_%02gwGIB!7}nOjJex|Nn}LitFp^$jHdPzP`i5!)<MC`uh6S)z#bE+f7YP
zN=izWmX`SV_^7C;{QUga*VjTqLNqiqeSLk+&CQpWmvnS=+}zwND=RoSIPvlE!NI{S
zEG+Qw@agI4ot>R?b92PR#Imxo_xJa|zrmrQqi1Jl&Cb%Kq<^IL_V$N|hr7GGWo2c+
zz`!#zGv?;zfq{WyVq)Ij;PmwMhK7jb<mL4A^y1>=>gw!XUS6uIs_X3V;^N|0S6A}#
z@}i=m*4Eaksi}p9g+xR|(9qDVtgL!^dO<-!-{0T2x4EgQtKi_^?(XhvY;5iA?LIy}
zHa0fT&(CUVYJczV@vEz?<KyMt-rm~U+Su6Ga&mIT#l>i7XvW6I+S=QVjgR>F`IMBD
ze0+TB>gq^HNQsGwu&}VRv$M;~%bJ>+h=_=zqobgppl@$)WMpJ%X=#&_leV_DjEsyf
zE-rq4ev6BX`}_NFaBz){jbLD4($dn?)6@O^{r>*`<$vYn-QC^$`~36s_U7m9_xJhT
z-{<b{^Y!)h!jao@0004UNkl<Zc-rmMMNdOP7=__OjTVZ#ySux)ySqEZ3stz^^nWv5
z+~$UmhQ-hlGS6zx>dj=5fh0+iIMY*_5g8w+U1rU2L_(aSLttXk3BRgJ>y53Yxe1&;
zG3n`X6@NRsd*BS|N%mJ~Nil>uyR`vC3OI8$fa?!p@Qb!!c5GZ-i8(MRL=eWFITr|<
zY5=&@RFnl68C6$Cu0Bm<Shtlmzov$xlfh}j!$W~^UVgI3uzlNXeN@A#DPO|_gMn}+
zup}<*djVn|o{8Gu0C;LGC@SQsO&5TKc(nGo`F}Ek%htiTOyu@Ji2VZ{^rkDKwpVa<
zDc0CHp4wOk^e-2edEMZvLkAd4_vfY+BI7AUB5KTnil<_sSzVp#Ss{X0jCm38&J=vV
zyo|}uR+9dlh@kL$d_l>F`A;g!pHEH-Vi0mlnR0oYn}CpG#O`c4rQr$R);IKq=f=42
w3oA$XX>nnuKOEsVhX<jjFh%|;k|h1WC-o_FqZCBtEC2ui07*qoM6N<$f*wHCf&c&j

diff --git a/tests/ref/long-scripts.png b/tests/ref/long-scripts.png
new file mode 100644
index 0000000000000000000000000000000000000000..84758d087cc3b979e8ae9fb48c52e5ee95c89fc6
GIT binary patch
literal 956
zcmV;t14I0YP)<h;3K|Lk000e1NJLTq004LZ002)2000001#n&)000AnNkl<Zc-rmP
z%}*0~9LI70noahyhs|z0?B4dW*?3soM>QA;M#cC*NQj~Z2~vunIJG`dC`_@17AjyN
zq7;iT^3Z^#j994R3<wHsX-kXrk+vU$ItLJpiT$CHd7r+?9A1}i=J)&Uz!z$V2#c@?
zZztG0&ztaRMV_Y;9_=0Z86QiEcP+qEpIR6@@v#zk+eA7E*j;?%9tx@p_l3}S^Nb2t
zDI;p=%d@*%PcnO=$CT&FR%(7R5P<)GiC?Fh)8nW5r!(<;aB6p$HOX)bX~r;qM0qhz
z8XX5f0RBFLqb6esN{matJvs=;f3ium0REi;c7oDDca8uY{s9>V{NZjaKtbbc`6OU+
z_UGS9TXA5Q1NaV<3MU38{|lxXHlDDCE3OYhD)CEXiNCWlv}5He4{GuTpXMmgb*!J-
zFTagsc1x<^HD9Xk1E;aJiuYh@Vf)~kFBAK<npv!A>96zvR`a!p|LSiN4tSJ{_@HqB
z7y?HS9__7i_cR2gOxtq%l>mK*YwJ@qadc;$=1Hc9A_`Z}N`}-$kUCTq(c^vj@ZVT~
z)YeqKSPrsq!J~W~`zN1f&F!)4i|RG(Av3>gxKNwS^pl0-2_yla{RI_@0&%Ry=vODQ
zurP%lI02y%3josa#))vMVV1$>Da3#Ec7TI{G8fkMJPg2tIe_R^t6g(!q^~339$<L}
zBQs{!^2+isc6gd14Zo_qZ_eQ~R~cKW+29_}bLqJ3Sw$&G!&Us*0jtEVsAVvk-Ow|A
z7FtIk-*G-b8n(Ugb0KENW@w@xPhw>Gq5CnPGXXwK8WyHzc3v3$vKRp3@P>)-_JNZL
zY*tJ>BvJ}TL)g4U@y;c}p9NFiji0Ge3t_m*-9azpF?w%vvG028SX)<F19$DtHDy=s
zYqD_l%o!_P3@Jyc;<?=tL@T{08NGdRq8?=7qTvfV#~yC4RnlO;S<za{9`EM<87^%0
z<%G6oxms9d2ts#jNiSC{B20;AF+hlW3IGA|kVqk%SixpR#H-JCf!mj`uHe?dwa)do
zJ7*MthB&NtHL53%D9whtyOlbJ>E7W^Ih&<pvZhJH^wcH0QMRa5w|IN=<UYvI#Fxet
zGLVMr*fx`|#7@(i?pDJbJtlSOhmLmo^z&P_)tAOC!nm9fC%#;vC1Fa&A(RLLfKz-)
eh_DEM#qb;KI1Q4L>#BVK0000<MNUMnLSTZQ%f^TR

literal 0
HcmV?d00001

diff --git a/tests/ref/script-metrics-bundeled-fonts.png b/tests/ref/script-metrics-bundeled-fonts.png
new file mode 100644
index 0000000000000000000000000000000000000000..fb99b1bd67fc6dd2b88878c65200b181f172ae3a
GIT binary patch
literal 3110
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
AtN;K2

literal 0
HcmV?d00001

diff --git a/tests/ref/sub-super-italic-compensation.png b/tests/ref/sub-super-italic-compensation.png
new file mode 100644
index 0000000000000000000000000000000000000000..b6c8ad06aeb0c3857bae3e8136b498246943f63a
GIT binary patch
literal 1281
zcmV+c1^)VpP)<h;3K|Lk000e1NJLTq004LZ0027(00000mBSIt000EYNkl<Zc-rmP
zYfMvD0KjouGNNWej2a)zxac%Q+(Z$Vg+vkA6cnPyZRkKpt)d1|6nq2`P@r?ZP(i01
z447IbZaS%mnz5+_9Wrqs7*<em2*{u+&jM}#+iv<{7F*g6ZduY_?zx{%^3P4~J@=e`
z{73rP!nUw2{K~`69s^LOcmzO&qW)hAH%AXH2T00moYW1Zf7d(<W32}x0OiqO1zb&$
zCSy$f*-j9gNm-_}C=5<IfMhL`G(ZW(YcSHY@||d?@F9OVErI&9IT(4mYWyJt*Md0h
zVp;f+2MClg0DS4+LoYsOfi9xLfz$3a^x|Gn6fBkQ(9q4Q1k1wThatGN8NqMM_t48I
zp_Lu3f$mI~<rvex-a2EWT<&@WQnza@3&*4ba489cAJ=27VJM)NDYTUUhh|{xt~1_O
z_-piRztHi(Ot>X><`dZIehmD}Xs;)K7pjuhCukw^CIZ#UrJ$C$6+z~7AmmhA=v8j;
zbbJAV(xA0a_sO(M*zaoyFS`6JsN8h8ZL*g*fyn5PG)?kYnLhh{X3qAR)|I}1HHXu3
z5fn_GBD&GOaPLPY>|V1fjb^DtvW}h|(Yq=U<V>9?R;lOjTU@1&T^(}T&rd3KJtL7w
zwqZJqo_Adp@fg%)BB)WkFr|6G#*hL`(sSP~G2ku+4RX0W$Aa(psMuSJ!LJ}F<wYMl
zL}Hew<8G@Lka}@EeK{$<fmul+mDS-bqo>jb-5iGq%+Yw-Tm8g^D~^j*n3wo<z?+z}
zG1uG8s&IGKWuKM?ySTh6OsdN|6^uf3{g{@Qdyp*;=dk$R5i7z~1IJcDz@SZ-mSHzn
zL+6-L3QX8%_py%VVPh^@5vI#<H>VRotLtMzw`~Vv3){lBuq|v0+rt05@Z*pPHT0}@
zl407-`JPbgGx8@)_`!P-RC+nxu{_-NUZ6M%>5;gzm~_p{Ta>T%Ke?gO)M;<7hq$!X
z?^IZ=<zZl!bIK9SYZ<h5NhxO3y|&%|Az)QFT{I7XUjpv|6eY{H0NmNXM+OGV`X^$R
zZ~x<18?F<_0Q{cipaYl#qqRVizTO`UPKd4|$ZZ6Q<+p)~^rC;BB+3EMooxd_p}f40
zaES9n0BSq{&{MV)fX2-aFwl4n2?fZ0+r9%9ewEo@jU?{Gz%C4)dk%;NNS!cPUtC;#
z8=cp;2OYI$!xuMYipv1bg&}AQY64)}^g9?tDnA{m2bz>_pgqQ|!D{M>hy(*^;XD_B
zri{6%<J{cFXSZf@@ePgXaQpuB`CV%Jhzu3PWB|~(;SUg`MggEYurHi*qVow_*cA%U
zIqw@_g`*5X>A|>o<l=&OAS`yP4E`R^XXRl!T;t@?0PCGT2mHza>ep#nn-J_h55Sor
z5*<C$CSC!2PXG@MZ}@Qs1oENb(CX~^GvI#75UyBKW#P(IHLRM9L}o{&EN=PY06U-N
zN9r*0#IXnp7qrwQ(FF<q7^}9wzcsYDI9Qe!pt+lBQMl!NPA;|E^f^l9b*kg2%u-=2
z-9`KXnsL4>M^xjzWnG{eBZuA+Eh(Mk<~F5d_@Wgfnk)$mbjoJ{bYE!YW%Qs!-_g<0
r3DkDbi%z&en541&oor!S_|^FnI3g<Fve^4s00000NkvXXu0mjfmQ!m?

literal 0
HcmV?d00001

diff --git a/tests/ref/sub-super-non-typographic.png b/tests/ref/sub-super-non-typographic.png
index b905e7d321ba8339d69b0f4b11ce486e95dbd73f..68e748c54b654123bb3f6840cd18274cc2a26e21 100644
GIT binary patch
delta 292
zcmV+<0o(q!0=@!}BYyz}Nkl<Zc-mw5KR|$C)Z$T#M=c(P7JnzKY1xzi2ewn&;&~GY
zYg*~?^TrWsTl{PyVNDwk<lH|^J&V^@O^&|^v-ok)u52uR|C+Y8H243;AG6A-Xz@qY
zcY7NC@5qMmf;RuR!J@vQ^}o-DwzL0JsA%yw$N#5u|G$3?;eUlc{BQpM>hh0h>RUJe
zkG%Kh)BnGJsb}#!%m0T{K#bErfP~-8|C;|UZ`*d`4UlvE&#x2z?>+^xYF7Ubyh`Ql
zw5H(hoU)fd#+0r9|KBZMc`0|#lNm4e_5elN-@oblzxnY0{~xORo|P=5RROZ)GmJH5
q?%p%EM~lo+iycQT9<_LoSquPnI&V511!zqG0000<MNUMnLSTXrzn^#j

delta 285
zcmV+&0pk9?0=EK?BYyz?Nkl<Zc-mw5KR|$C)Z$T#M=c(;m}(Y(y-iqC*Wv%0mQdT`
z#S;i?+UW80?n&xdyuNC3{KfyzCW1MSgLY+Oal+TMwWYcLH{K7vahiG-e^h<9rvYa1
z|DetPZLp|sX#MZ=VdIZuK2)^$o8$k}x&PM|{sZ&EAO1K0e}8rPM>O@VoBv1NYdiRV
z_EqXx{Lb?K;S><#^ba86ck{pIzsuXU-FO4!9RKs{#Q(cbfvlR<{{yd5IaRMIxI3rp
zC6F;?>;M0Ei&tLC-ScF|i@iNSk@oj*y8drI{Qv)l>b_?s3u%>)w|s`Nrp(=Y=JsgG
jHEQvw#iJGvG8T&g%vEnNuDA|p00000NkvXXu0mjfgY2Q~

diff --git a/tests/ref/sub-super-typographic.png b/tests/ref/sub-super-typographic.png
new file mode 100644
index 0000000000000000000000000000000000000000..a0c53d5002b540dadc26f36160e9aaf511a90d3b
GIT binary patch
literal 1337
zcmV-91;+Y`P)<h;3K|Lk000e1NJLTq004LZ0027(00000mBSIt000F5Nkl<Zc-rmQ
zX;74P9Ki87Oh&DA@`^1rHLt0h5iJeVEDbqiutky3@hVMiN<oB#8jlnuM-Z<-N1aRu
zxfU^%n{kG41eE&{L_}agSngw8cK4glEIJ14y8EJ<X7)4l%=6}%-}l8c^M9WCy~Kay
zC1cnaHirM{umS|_Eg+EB|2yH-g^36bOO}NI%B@kZA@q@P7RcZIqZG;x?J1{^2M5uR
z26*1qC)}O3C<Wlr*W8{0$PRPamEPP$VkmmQ+1Hwu5Awa7>CJDl2m~roMa*mMdW2zl
z3L4im^KOVs>Eomr6lq*|4`{QGp^q#Ps?gBTa8kHuAu}l4=_mzI9(VAhj}S3{+~z8<
zdy+kU<cauYmW#{G5cqB%hJ@wcJVZnGYJLCV4sn_SKsqS7zp%F-!nOUBTBS9ddgNGu
zl;g(&>p+}@;M)g8fS_%p0zq`p(ZkBtfMWq_@SF`SOlDoP>LK?BR3NzZWJ)E$M+2)N
za!{ux?7N@fIIZEkD@>NP^V9Hi9o%?hV<T2~vff;`dNFIywmW5bo&mwlk4=71D_o{Z
zz<b&|zLZQ@<v5Q=b{oVIAShpL>e#}8VW-<TYc<iq%QZA~>AvY=*YUdEvDmUv`FR0Q
zT3FCVTx?5WaZx3;{xqbu(4&3&Y*oWN8QQHJQLDDUgGTjI7nkKS1UkYp%N0HndMGcd
zK@ii(^KvZqy5^xn>o~`~7YsZ=u9}K@AwQGd=#*?`i-F;sk%NnQk&DCMZb6q~ON$)C
z!p#fntgO1xt;DW+lp8v<FOXWlD>o!8w~eR7Vlz6`%`7Lz<Rn@tmPS)Cc#Q$!KV}WQ
zMy{oaV>a6TI^Hsecysf0we&A;j=6-Qai+HEdWWkD@@tUg7UnggU0GpX6V-Wzxt;W{
zrXatHrYBPxjDH};urX{58^gx1G5kLY-;Ga<Z6+Zxt_AHf6B4hhx?+=J(V{FqDON^u
zVqBx%;Xh}aEUIUdg_jKN!Y7)nRdv{m*pC+Jb4}+<@p##zPVX?CbEe60jzg#Fx18vj
zSBzGV7fk42<z>)6O!+IGApr=gDiL%=o|Xf&MIUdaM}q13?-S6WYS`xA_hC?&V6!Cv
z-TtGK5$<1h2CV^_Kj{qF!c$uY?m(yWrVBAJTs3f19RlYRfTrKbn+!Zo=cp%7#hK6S
z29SDw1uFlo^RGbQS{n&ZJsSLa6+ma8H5y@C7a!0S?p~Zd&i?PKh@f2nsx32Q&&Gb1
zIoKP(-9Zfb3pqcI)?NH8riW_D?Ma`ifxrzS9@siLIZDT<OU-I@gg2fe)$Gvo;jB$+
z1oeSdXvi0(bJ9Ha*+xJ?fIV=1N(Mc)ogj0-9)MgCUaKS$XFmluM=Q04GnNm`pmMC)
zj{DETB_8U>AW#jh1|cwaYz0~7L;Rb2!sOdj0g3B}wj#)0X`V{;B-3rB&#xky>~5kp
zoEZ_GP5Gs$uyU}u0$J)V2PHm~v{OatR1hRZhE;GUEb>w#1b-ofoLUPz0L75&ns7vT
zCY6^W!|p<kWly+aNl8P6K1b%MS#A|rN8Ot7(TD5t*wNv7#J7yzYHi2Vpb%x3S$Ef+
zB3jf&FRfmt=>apGoMxP{J6G$LuJ>6TQw)N8k@PEYr_TxQySuv|grJRktLZIjr;oQv
vB9X)>w?BDGu5VabghsCMvuF$(!+QA(zLpk~LW$FI00000NkvXXu0mjf&n|^o

literal 0
HcmV?d00001

diff --git a/tests/ref/sub-super.png b/tests/ref/sub-super.png
index 10fe77b07b5a1d65ec87de08f54bc8d13db6ee8d..fafdf5594dfb65df0e515779572353f0c380d42f 100644
GIT binary patch
delta 1169
zcmV;C1aAA<2&D;-B!6s4L_t(|+U?nCOcZAv$8i(-qNPcbCZsRgas+D`D86b_r6JVN
zn2JOR4X06#7$xN>Vz~rmLC(~284Bg9C{Vyc$cl)S!*IAO6o?YL8=}Aha%-SmdoVk{
z4vi7m%s#WbeNj{An|=3xvY%vUp2@SBUHFgMCBOnK!2csSFMlYRTyP+HemFLnub?~*
zIOu?goU03YZV@Kp>p&m}oGb#lv_uf2<lu=l1lR<4?e;UpZB6?)FFe&`2<(~ef9Rqc
z0j}Gf9}^3<71u$TqsIS+4%}CsmV|9BVA9qQxE+<}ahCvNH_(R7LLOir(r)U&zU%CG
zE2Rst-w+t6Nq@nJSBo;V^>|f6Db!izS9Zd7s^+Dcy12;~aLmQ)JK)S?PoeM;Yr^h*
zUwJ-&>9DI{oN7-s7zX1)6^amAjiW=C#Q0Xc1GcRRo^PMMmHGm1fb-&Z7?ln`A-xPm
zD2-rF$<<#1_G7Du41{M~I-el&J~AqfNl~7;1Ev5d@_%zeU;fkqL)&2umMzuKoTM^T
z{EX=CO?V&sF#s-!25>wQh-_zk6$SB#>V7=C1vBqyfuP}z(+H4i?U5>0d7x_x)<ytd
z11Cd(qCAARZtP#j$I$FWpNa>bOp1F1RNZ0W=pVX)tCt(mDBXg83%?HZWZjDCjV)-2
z=xxf&oqs?A{Srp@kJl#HRX3nXNm)FXkECCE!v1Lc?qTi>0p6+<K!n8f2S^!X+5;q^
z6PR+1)S3z>w+hc{0({Wig529Y3*LCwf-m!f9B^XH0=a}J@_dhEfv?yE;Tr40{k9Zk
zCnLj&b`<5kst>OJh@!q2Hxiyc7k^eRKb@%;u759{1FYKQa?3F;n5oHxPqtisq{c{C
z6BW;*@%rKBisb>=u&50u3?>_XEb3<jJT*d(E+9fbJUy~8HV^6V;D)s$Q){D2vBGG$
z-a#EWJe`sCAw^k>xnQx~`bk+^vuXhDdnoF&c^!BoBwT)GL6ifLHAQ_QF&xHKpQivA
zxqn<f3@#XT-ze};OYE9y=)iza1~yZ((@_`!_qh&`x6|NPQsQ<hbkmr!o$klZI><<H
z|JmpEL;B&3yqiVAOD4dhV=CDM3091%W#a@`_IytEm+%+n)r3R6YRUO}lII`f)biyO
z$^rX0`jXr0K%T#I*q1LyZ{ZpX@M{EL5q~K&djQZht>uI(FRWg=i_I8z4WkPy<Etl=
z=D_t0WO&*AVHtpCGc&U{ySU)hBM*wPGPVx*vui$I)Pd3O-8u;6DstJW<&fbp9$RSv
z3E|8&{=NnccUGY9%$0ryOk<MKM<0|FWkBIcfXmC0&{Z%qpa)(n^nV1p&}jJAtbawf
z7R1G;({vmsT%Wq^-b70}l(2b1)4DL$qI#Q7D6WmeubQTPYm7ZtA1!9D&|CNP-qoF5
zj0`8(HBL)hceUzr2@2S$)t|yXex+a!D`#@nmgKqlr_Ov?d2qne`fhR!JPXR(y7_95
j2ybBoSbzoi-}g7*gjC-_@u{-_015yANkvXXu0mjfa+f$M

delta 1093
zcmV-L1iJgB3EBvdB!3}EL_t(|+U?nIOcQq;$8nP_S;7*NWn>TBbctp|h(6jDF(J6H
zEQ)R#9HYZIgc&8{Z`t^xs4Y+^WKIF+?1Xm0Kq%VAlp>G;8Y!cIKw8F*m`W)W5JZGk
zptR6_RuW^uw7)x=g>B~EY5L@Q$t%74^_RQcI{ZtmV__C%;eQthE{Mz^7j=X@-<z62
z)9ztcaO8)4azTOQxpyp|ruCF7ID-#z*{48kYaeKO%gDl>z_ay_4E5HgL0Wi3$pj9`
z3Ez_yOn|Gl6sDxY(UYKVYMV8@`Z>5mlFh@iCScsm1a3mvY1}5j*a9?Ssb~#$AiL%{
zm^0@XJ2M9Y{(nqhpfVHvp>^h%hQsCQ#jxZ_uB?Q8=5J0vs7f<Fg;TPwt$=e64Z{$o
zu*UxWUD@df`z@am`%dXGIWrh%${|9`RqXFMtH3vk74YWDsE18swSuRx9060yVU+p(
zgd8zMD2}%u>$B_vd<SOsFoYij-noy&HV8`&sUgW-0e^1=U?@Bv^Xybd^el(1Fm1Fv
z+Nq{c@-vcEOYjcIhXGua4B&7gkl1AB7%rYbl1ew`gzazGfXI8djw3>C^Myb$e*n!+
z*cK1$298Dpq5{M<EcnmiU0Ao%!$w|OFHruQ15W;41(aU6fg5Tkd_C?O(2`f1(w=&;
zF1}q^kbggf^u=c|&i(M~5OBR3*38VQlZD{@(h_^OF+od&ofQL!Z}ofw5!*f6K+^93
zBSDEaPvMLPcCRMDAA5O|dzI#ZmtXUy>7`Cr@Trsua_LFr`8%x>G;J7MgHvsiE>*ks
z*El+m<LLdHYYu-=>HKC4kDjD~sfzoP^W*MeN`LJcY)ztpo28={Dw5s8c8y@w@JRon
zegg6C;nDtufrl9Tv05u|1>5>ZX7%Qw`c=a+Kg*GOqryMk!U~_cqm))TUDYPmxqug<
z<NCPMY2^q_kUHAM7)EK>FnMuR9W)RZSC|lseL8e~#&LAq#2D@f>LSD4AE}A(rC_Tk
zdw+FX>X;uzf;+#R^zCsEFBH^>qNY87^#k+N5D7NuEz}?ZrY6U!zt~5Z|0Wz0DkaAW
zA<y4DFQw^qohvwO8;9I>Kk|J2UJgxOf3Vk>h5yg+KmylMmX#@dg>TMnA;D#5X3pMr
z51UV1HS)#*9E`|!<X_1YHto}jL4s#K)qh+j{o>Bg8@fHZ+0$*Z0j=&~3~sREu}tp{
zMh+KfmaQHx5(!}lA;1zb4>cY3%ko^8@a(1VUb``8)o?}LRB#>A+`}?~X`j-3x2UE^
z=n9@qYFB<`=+b(4U%kJVysEWQ&AB?R&fTguf6d32pKu+0AYb#p)8qW5O4*&u1wMRW
zQvkWQH<IUG?*-8GipCYJmZ`|eX%3Jys%R>D!oG!JVHRfLf1tks?=69MA@eAY00000
LNkvXXu0mjf+=n3e

diff --git a/tests/ref/super-highlight.png b/tests/ref/super-highlight.png
new file mode 100644
index 0000000000000000000000000000000000000000..c0cf612b95278ebef939f33cd1ed42c079079a3b
GIT binary patch
literal 1353
zcmV-P1-AN$P)<h;3K|Lk000e1NJLTq004LZ003MF0{{R3l81r70007xP)t-s|NsC0
z{%Py$>+9-Zm6er~laq*ui1_zrkB^Vq*;)MiXUNA=VPRoTPEOj|+K`ZtNl8ij`e*Iz
zVc_3f_Vs1S$;qdur=Xugp`oFKgoJNzZ%s{2^YimcN=igTM1_Tg;NakGZEZO@In~wG
zTwGjnadF$*+veq7+1OdZ!NGlfeZjy_z`sw4h&XC$EAH)Lf`Wp8fPkv1s;Q}|czAex
ze0*SFC#|eUp`b#Pl$4m4KK}h^yt_@s#8I%XNR^a5i;6jOb1zs}B&DQ8ZEY<sE)!^I
zXpfFNARr(+J3HUs--w4e!og2wW-7S2xVpN!o}Qk}%T&+KRngE^a&j+jZY|;9T(7UM
z-P~J!eKUoGHh6e3ettCL;$325C~Ryj($dmjUtdK<Mc3EY>F8flQd02mVxpl!%gf7|
znVB*&GVSf{OG`_amzQN_Wy8b6laf4XX)E#YV?I6^l94>#-CIIJ8{*+zPEH`Hs6{|P
z8q3O4HZ~TPl|9weSH{IrWo0R7Xe;dNVOd#ODJdyKLqqKB?2e9(e0(!-a4wCEIz2rZ
zH#ZhoSXjTmzxDKF_x5G8v$IG@9b#f)t*xz_nm@F&N`{7pGcz-Ca&lv1V^B~~l9H0;
z<>l(?>MkxW?(XhqXJ_c>=$4k2T3T8+H#d!qjhUD~baZq~OiWi-S8#A}l#@NMu&{xF
zfn8l)dU|??hBtzNHPFvh6ciLdKtSs0VBX%|;o;#`RaHGbJxEAMnwpw(b91q=v5Sj~
zb#-;DtgL>1ex042TU%R<jEvCG(43r{LPA0`G&KAB`z0kM@9*#W`ud}zqtnyV*x1<g
z^z{Dz{_ybd{r&xsk&&gPrJI|Z=H}+e$jE_<i97%R0(MD6K~#9!?buaQl~EMN@&Do+
zIUpWTv0H2rI{~}98@s!^Td}*l6$=!lySvZ%HqO8quDtSMF$4Se1)h2LyY_l!Hilu;
zCQ_}2f~Pgo555&CVwr9OXV%w>GQHp<yLO7apVu8|>&^3Awcya*dqiyW7XbFAJGP@l
zET{aBdWtk|0@zz@+ggYY2|aQAScq$??cOY$fR5{zL~P?-Bb}Mftd{5qyJ!)wam@j6
zes*s*Q~4gFPO6v{uBOILTjtb9UFTd_zuX4ScI`9DQB&|H7B++|0~&gB_61rloIeL^
zSNH;U?=@%8QWDq6uLI)Q7_j^FUDp96_2PT9zfW~Z4CsiCye?4mpqNUlSJHnVIy_pr
z;Y>{dz`3e#v;M_qsTsAUBs}Y*u2maoGT4T;uB}_ZkbpjD^LZKr-FthYtSI?ev;*<#
zhO*d{q{MgVPj%@-D0z#%v`20@8&;T2X4JyxCJE9H4!<EHqk_Sa_&xuQUhskaheYm8
z91A4)a63sYc<;W0B9Y-g0Bb#77NSFJQ-cm$M0|Y#YlGyN0(8jGfWVVsA|h2^{5uOB
zGFs&HWmj;S2iZC32pD4#uPb*&1RSZK%B_WUV1bwyC+!ojL&3xHKt}cgN57W&*HH7y
z?+f$_909m{aP=lyUU!OuMT=b}(J>t**=a<VAQ2IjCDF6p6qF1YWc`*wbx9OVM#%?o
zWV(W%lu<kh9qu39aOPB0mBi!L<z-FH0x`@#{(t4AAkBxPZOi5vFnee)+BR+M40D$*
zL0M@6enp7CKg#0ctWo*s4;P8>CkFjs_g`)}e^!WySs;dC82|DYYgCpWSt%gC00000
LNkvXXu0mjf(1NCl

literal 0
HcmV?d00001

diff --git a/tests/ref/super-underline.png b/tests/ref/super-underline.png
index 4608d1a8308c5729a6b0b10905ebe2683019e2fc..cef0d2a108341211983a8db7815725d82d202448 100644
GIT binary patch
delta 825
zcmV-91IGNR4#NhJ7k^v`00000fHE#F0009DNkl<Zc-rmN*-KPm7{~Fh`U|4#2!tZ&
zqN0$R2rIC~HjoxusAz*M%Y+J*nlh(la+}H0vUHeY#9YWABybBoB9bJQO=P3dsB>IK
z)H=*~=9@DJUUnmoVCM(##e4PPxp;oh0_G?S4A_7Tcs{}nL4SET)(7fo4U{!E3v=Y)
z)^mCA<nmWwyPK6GVz6~|BWM?TfL$$(r;vixv-NA;F!VbN7w7Njl7g*GosZJBd-q&n
z*iFS*A$TGQw3UI02@Qy8r|7m2Y)e&95?=tIBw1e7AOyEW(k5RZZzHKOy81tWKTgWS
zheyDFLIY(>#(z_%9NclJ07}w-0^8gy9~Ofj4sM2l^PWg$emRH~>`(5D_JDgR3}>77
zd8FXHs``vOn$1=fnHX215FEG!<EwR5^#fZ!QF>Jf&bp|gBs>E^Ic9!U8Zw&8faekX
zSsK1L20&9L1k#Q=^87;Zx42?}-Uf46KS)WE5S;xh7Jp#;!?_T&C4@4oW#I92pUDf*
z*9^36u*ErK;DTpmDONx!D(VkUjJ{$>0@g2se;qK~)1yIiJVXyjzz<HUDBB7FfWY;=
zFP^s=&1Jyz1P;l==0Cvw_ux&r?szQ+_r|!OI?EZ>vpG>F2IqF~0-re(u;+26OA6L3
zp-n1yJb!@wczSGy6kL4w@hKYsk%_z4NWsZ4XaWFovIs^A!FLa+DC-IV@Fwhc+Pj3{
zzDW9~p70*$M^Z5Lbfc>cc-CQC0I=7A_r`5UtsLART?uuMD*;Ou2i}Omk2>Swd)oAo
zNNksagAXwIp}jqFB+|D0kb+&Q_9IVcjzq_LDS!A1cw+#7+#EtngkZ}~6(wr=NbHGo
z=Cp|JacFdObWRFHvs$gjkuc!dhn+eAgV%s^OHt*75InT%9RL-nz~o|DO+xUK*29F!
z(iktW4Bu`USiev7IDoI*2P`cy70bX?$@X~1%y$|3_C^sn1$ts<zEO~oF9BONsVIvI
znKF)RVeZSDW1@Sk2ZQ>Y6iCgjTeU`I8n6Ky@IUhx_1Q)K?Nxld00000NkvXXu0mjf
Dy!wGc

delta 1831
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
V(s2!Gj#mHx002ovPDHLkV1hH_nRfsH

diff --git a/tests/suite/text/shift.typ b/tests/suite/text/shift.typ
index 2667ca2f4..2ab6f8dc4 100644
--- a/tests/suite/text/shift.typ
+++ b/tests/suite/text/shift.typ
@@ -1,22 +1,89 @@
 // Test sub- and superscript shifts.
 
 --- sub-super ---
+#let sq = box(square(size: 4pt))
 #table(
   columns: 3,
-  [Typo.], [Fallb.], [Synth],
-  [x#super[1]], [x#super[5n]], [x#super[2 #box(square(size: 6pt))]],
-  [x#sub[1]], [x#sub[5n]], [x#sub[2 #box(square(size: 6pt))]],
+  [Typo.], [Fallb.], [Synth.],
+  [x#super[1#sq]], [x#super[5: #sq]], [x#super(typographic: false)[2 #sq]],
+  [x#sub[1#sq]], [x#sub[5: #sq]], [x#sub(typographic: false)[2 #sq]],
 )
 
+--- 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)
-#underline[The claim#super[\[4\]]] has been disputed. \
-The claim#super[#underline[\[4\]]] has been disputed. \
-It really has been#super(box(text(baseline: 0pt, underline[\[4\]]))) \
+#set super(typographic: false)
+#underline[A#super[4]] B \
+A#super[#underline[4]] B \
+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].

From 22a57fcf5c52cc0e961368a6d6fb7e9a82312b48 Mon Sep 17 00:00:00 2001
From: Max <max@mkor.je>
Date: Wed, 2 Jul 2025 08:01:44 +0000
Subject: [PATCH 052/101] Use punctuation math class for Arabic comma (#6537)

---
 crates/typst-utils/src/lib.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/crates/typst-utils/src/lib.rs b/crates/typst-utils/src/lib.rs
index 4cfe0c046..8d0cdc15a 100644
--- a/crates/typst-utils/src/lib.rs
+++ b/crates/typst-utils/src/lib.rs
@@ -395,6 +395,10 @@ 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),
     }
 }

From cc3a68ecb1a1fc55a771d6c29d0282ba98857333 Mon Sep 17 00:00:00 2001
From: Tobias Schmitz <tobiasschmitz2001@gmail.com>
Date: Fri, 4 Jul 2025 19:00:45 +0200
Subject: [PATCH 053/101] Remove duplicate language computation (#6557)

---
 crates/typst-pdf/src/metadata.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/crates/typst-pdf/src/metadata.rs b/crates/typst-pdf/src/metadata.rs
index 589c5e2fb..7c546b237 100644
--- a/crates/typst-pdf/src/metadata.rs
+++ b/crates/typst-pdf/src/metadata.rs
@@ -22,8 +22,6 @@ 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());
     }

From 88e451b3dc5c23f52d4fe69d1c6abb4ca9463b1a Mon Sep 17 00:00:00 2001
From: Andrew Voynov <37143421+Andrew15-5@users.noreply.github.com>
Date: Fri, 4 Jul 2025 20:02:02 +0300
Subject: [PATCH 054/101] Fix typo in PackageStorage (#6556)

---
 crates/typst-kit/src/package.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-kit/src/package.rs b/crates/typst-kit/src/package.rs
index 584ec83c0..e62e843cd 100644
--- a/crates/typst-kit/src/package.rs
+++ b/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 interferring, we download
+        // To prevent multiple Typst instances from interfering, we download
         // into a temporary directory first and then move this directory to
         // its final destination.
         //

From d1deb80bb8b4d5fad348c23a3e079e4854aa57e4 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Sat, 5 Jul 2025 14:23:48 +0200
Subject: [PATCH 055/101] Fix nightly warnings (#6558)

---
 crates/typst-library/src/foundations/array.rs |  2 +-
 crates/typst-library/src/foundations/dict.rs  |  2 +-
 crates/typst-library/src/layout/container.rs  | 16 +++++++++++++++-
 crates/typst-library/src/layout/fragment.rs   |  4 ++--
 crates/typst-library/src/text/mod.rs          |  2 +-
 5 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/crates/typst-library/src/foundations/array.rs b/crates/typst-library/src/foundations/array.rs
index 11c2220d7..87a301049 100644
--- a/crates/typst-library/src/foundations/array.rs
+++ b/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()
     }
 
diff --git a/crates/typst-library/src/foundations/dict.rs b/crates/typst-library/src/foundations/dict.rs
index c93670c1d..ba161f44c 100644
--- a/crates/typst-library/src/foundations/dict.rs
+++ b/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()
     }
 
diff --git a/crates/typst-library/src/layout/container.rs b/crates/typst-library/src/layout/container.rs
index 725f177b7..fc27644e2 100644
--- a/crates/typst-library/src/layout/container.rs
+++ b/crates/typst-library/src/layout/container.rs
@@ -497,7 +497,8 @@ mod callbacks {
 
     macro_rules! callback {
         ($name:ident = ($($param:ident: $param_ty:ty),* $(,)?) -> $ret:ty) => {
-            #[derive(Debug, Clone, PartialEq, Hash)]
+            #[derive(Debug, Clone, Hash)]
+            #[allow(clippy::derived_hash_with_manual_eq)]
             pub struct $name {
                 captured: Content,
                 f: fn(&Content, $($param_ty),*) -> $ret,
@@ -535,6 +536,19 @@ 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)
+                }
+            }
         };
     }
 
diff --git a/crates/typst-library/src/layout/fragment.rs b/crates/typst-library/src/layout/fragment.rs
index c26661154..dd28191c5 100644
--- a/crates/typst-library/src/layout/fragment.rs
+++ b/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()
     }
 }
diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index b1e381cb2..230f8e501 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -936,7 +936,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",

From 51ab5b815c0553c866e3a5e9f1c2331902d9e6aa Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Mon, 7 Jul 2025 16:15:10 +0200
Subject: [PATCH 056/101] Fix minor typo in function docs (#6542)

---
 crates/typst-library/src/foundations/func.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-library/src/foundations/func.rs b/crates/typst-library/src/foundations/func.rs
index 9ef812890..dd999ddc3 100644
--- a/crates/typst-library/src/foundations/func.rs
+++ b/crates/typst-library/src/foundations/func.rs
@@ -20,7 +20,7 @@ use crate::foundations::{
 ///
 /// You can call a function by writing a comma-separated list of function
 /// _arguments_ enclosed in parentheses directly after the function name.
-/// Additionally, you can pass any number of trailing content blocks arguments
+/// Additionally, you can pass any number of trailing content block arguments
 /// to a function _after_ the normal argument list. If the normal argument list
 /// would become empty, it can be omitted. Typst supports positional and named
 /// arguments. The former are identified by position and type, while the latter

From 36ecbb2c8dccc1a31c43fee1466f1425844d8607 Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Mon, 7 Jul 2025 16:15:32 +0200
Subject: [PATCH 057/101] Refer to json function instead of deprecated
 json.decode in groups docs (#6552)

---
 docs/reference/groups.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/reference/groups.yml b/docs/reference/groups.yml
index e01d99dc4..1aaa8f229 100644
--- a/docs/reference/groups.yml
+++ b/docs/reference/groups.yml
@@ -205,7 +205,7 @@
       single or double quotes.
 
       The value is always of type [string]($str). More complex data
-      may be parsed manually using functions like [`json.decode`]($json.decode).
+      may be parsed manually using functions like [`json`]($json).
 
 - name: sym
   title: General

From 0a3c6939dd274f40672484695d909c2cc0d0d755 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 8 Jul 2025 10:52:43 +0200
Subject: [PATCH 058/101] Rewrite foundations of native elements (#6547)

---
 .github/workflows/ci.yml                      |  12 +
 crates/typst-eval/src/markup.rs               |   9 +-
 crates/typst-eval/src/math.rs                 |   6 +-
 crates/typst-eval/src/rules.rs                |   5 +-
 crates/typst-html/src/lib.rs                  |  14 +-
 crates/typst-ide/src/definition.rs            |   2 +-
 crates/typst-ide/src/tests.rs                 |  10 +-
 crates/typst-layout/src/flow/block.rs         |  38 +-
 crates/typst-layout/src/flow/collect.rs       |  42 +-
 crates/typst-layout/src/flow/compose.rs       |   4 +-
 crates/typst-layout/src/flow/mod.rs           |  20 +-
 crates/typst-layout/src/grid/layouter.rs      |   2 +-
 crates/typst-layout/src/image.rs              |   8 +-
 crates/typst-layout/src/inline/box.rs         |  21 +-
 crates/typst-layout/src/inline/collect.rs     |  26 +-
 crates/typst-layout/src/inline/line.rs        |  12 +-
 crates/typst-layout/src/inline/linebreak.rs   |   6 +-
 crates/typst-layout/src/inline/mod.rs         |  50 +-
 crates/typst-layout/src/inline/shaping.rs     |  41 +-
 crates/typst-layout/src/lists.rs              |  50 +-
 crates/typst-layout/src/math/accent.rs        |   4 +-
 crates/typst-layout/src/math/attach.rs        |  19 +-
 crates/typst-layout/src/math/cancel.rs        |  16 +-
 crates/typst-layout/src/math/frac.rs          |   2 +-
 crates/typst-layout/src/math/fragment.rs      |  25 +-
 crates/typst-layout/src/math/lr.rs            |   4 +-
 crates/typst-layout/src/math/mat.rs           |  27 +-
 crates/typst-layout/src/math/mod.rs           |  35 +-
 crates/typst-layout/src/math/root.rs          |   6 +-
 crates/typst-layout/src/math/run.rs           |   6 +-
 crates/typst-layout/src/math/shared.rs        |  53 +-
 crates/typst-layout/src/math/stretch.rs       |   9 +-
 crates/typst-layout/src/math/text.rs          |  12 +-
 crates/typst-layout/src/math/underover.rs     |  18 +-
 crates/typst-layout/src/modifiers.rs          |   8 +-
 crates/typst-layout/src/pad.rs                |  10 +-
 crates/typst-layout/src/pages/collect.rs      |   8 +-
 crates/typst-layout/src/pages/run.rs          |  42 +-
 crates/typst-layout/src/repeat.rs             |   6 +-
 crates/typst-layout/src/shapes.rs             |  96 +-
 crates/typst-layout/src/stack.rs              |  10 +-
 crates/typst-layout/src/transforms.rs         |  24 +-
 .../src/foundations/{ => content}/element.rs  | 220 ++---
 .../src/foundations/content/field.rs          | 564 ++++++++++++
 .../{content.rs => content/mod.rs}            | 434 ++-------
 .../src/foundations/content/packed.rs         | 147 ++++
 .../src/foundations/content/raw.rs            | 426 +++++++++
 .../src/foundations/content/vtable.rs         | 383 ++++++++
 crates/typst-library/src/foundations/mod.rs   |   2 -
 crates/typst-library/src/foundations/scope.rs |  11 +-
 .../typst-library/src/foundations/selector.rs |   4 +-
 .../typst-library/src/foundations/styles.rs   | 238 +++--
 .../typst-library/src/foundations/target.rs   |   2 +-
 crates/typst-library/src/html/mod.rs          |   7 +-
 crates/typst-library/src/html/typed.rs        |   4 +-
 .../src/introspection/counter.rs              |  26 +-
 .../typst-library/src/introspection/state.rs  |   4 +-
 crates/typst-library/src/layout/align.rs      |  10 +-
 crates/typst-library/src/layout/columns.rs    |   1 -
 crates/typst-library/src/layout/container.rs  |  11 -
 crates/typst-library/src/layout/em.rs         |   2 +-
 crates/typst-library/src/layout/grid/mod.rs   |  12 +-
 .../typst-library/src/layout/grid/resolve.rs  | 176 ++--
 crates/typst-library/src/layout/hide.rs       |   2 +-
 crates/typst-library/src/layout/page.rs       |  10 -
 crates/typst-library/src/layout/place.rs      |   1 -
 crates/typst-library/src/math/accent.rs       |   1 -
 crates/typst-library/src/math/attach.rs       |   5 +-
 crates/typst-library/src/math/cancel.rs       |   2 -
 crates/typst-library/src/math/equation.rs     |  40 +-
 crates/typst-library/src/math/lr.rs           |   3 +-
 crates/typst-library/src/math/matrix.rs       |   7 -
 crates/typst-library/src/math/style.rs        |  34 +-
 .../typst-library/src/model/bibliography.rs   |  53 +-
 crates/typst-library/src/model/cite.rs        |   5 +-
 crates/typst-library/src/model/document.rs    |  31 +-
 crates/typst-library/src/model/emph.rs        |   4 +-
 crates/typst-library/src/model/enum.rs        |  18 +-
 crates/typst-library/src/model/figure.rs      |  94 +-
 crates/typst-library/src/model/footnote.rs    |  17 +-
 crates/typst-library/src/model/heading.rs     |  50 +-
 crates/typst-library/src/model/link.rs        |   4 +-
 crates/typst-library/src/model/list.rs        |  12 +-
 crates/typst-library/src/model/outline.rs     |  36 +-
 crates/typst-library/src/model/par.rs         |   3 -
 crates/typst-library/src/model/quote.rs       |  33 +-
 crates/typst-library/src/model/reference.rs   |  15 +-
 crates/typst-library/src/model/strong.rs      |   4 +-
 crates/typst-library/src/model/table.rs       |  18 +-
 crates/typst-library/src/model/terms.rs       |  27 +-
 crates/typst-library/src/pdf/embed.rs         |   5 +-
 crates/typst-library/src/text/case.rs         |   4 +-
 crates/typst-library/src/text/deco.rs         | 113 +--
 crates/typst-library/src/text/lang.rs         |   2 +-
 crates/typst-library/src/text/mod.rs          |  59 +-
 crates/typst-library/src/text/raw.rs          |  44 +-
 crates/typst-library/src/text/shift.rs        |  33 +-
 crates/typst-library/src/text/smallcaps.rs    |   5 +-
 crates/typst-library/src/text/smartquote.rs   |   3 +-
 crates/typst-library/src/visualize/curve.rs   |   1 -
 .../typst-library/src/visualize/image/mod.rs  |  17 +-
 crates/typst-library/src/visualize/line.rs    |   4 -
 crates/typst-library/src/visualize/path.rs    |   1 -
 crates/typst-library/src/visualize/polygon.rs |   5 +-
 crates/typst-library/src/visualize/shape.rs   |  34 +-
 crates/typst-macros/src/elem.rs               | 821 +++++-------------
 crates/typst-pdf/src/convert.rs               |   2 +-
 crates/typst-pdf/src/embed.rs                 |  18 +-
 crates/typst-pdf/src/outline.rs               |   7 +-
 crates/typst-realize/src/lib.rs               |  50 +-
 crates/typst-utils/src/hash.rs                |  99 ++-
 crates/typst-utils/src/lib.rs                 |   2 +-
 crates/typst/src/lib.rs                       |   2 +-
 docs/src/lib.rs                               |   8 +-
 tests/src/world.rs                            |  10 +-
 115 files changed, 3103 insertions(+), 2277 deletions(-)
 rename crates/typst-library/src/foundations/{ => content}/element.rs (53%)
 create mode 100644 crates/typst-library/src/foundations/content/field.rs
 rename crates/typst-library/src/foundations/{content.rs => content/mod.rs} (64%)
 create mode 100644 crates/typst-library/src/foundations/content/packed.rs
 create mode 100644 crates/typst-library/src/foundations/content/raw.rs
 create mode 100644 crates/typst-library/src/foundations/content/vtable.rs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2354de582..70518860e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -103,3 +103,15 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - run: cargo install --locked cargo-fuzz@0.12.0
       - run: cd tests/fuzz && cargo fuzz build --dev
+
+  miri:
+    name: Check unsafe code
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          components: miri
+          toolchain: nightly-2024-10-29
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo miri test -p typst-library test_miri
diff --git a/crates/typst-eval/src/markup.rs b/crates/typst-eval/src/markup.rs
index 9118ded56..cc9606269 100644
--- a/crates/typst-eval/src/markup.rs
+++ b/crates/typst-eval/src/markup.rs
@@ -186,7 +186,7 @@ impl Eval for ast::Raw<'_> {
         let lines = self.lines().map(|line| (line.get().clone(), line.span())).collect();
         let mut elem = RawElem::new(RawContent::Lines(lines)).with_block(self.block());
         if let Some(lang) = self.lang() {
-            elem.push_lang(Some(lang.get().clone()));
+            elem.lang.set(Some(lang.get().clone()));
         }
         Ok(elem.pack())
     }
@@ -219,9 +219,8 @@ impl Eval for ast::Ref<'_> {
             .expect("unexpected empty reference");
         let mut elem = RefElem::new(target);
         if let Some(supplement) = self.supplement() {
-            elem.push_supplement(Smart::Custom(Some(Supplement::Content(
-                supplement.eval(vm)?,
-            ))));
+            elem.supplement
+                .set(Smart::Custom(Some(Supplement::Content(supplement.eval(vm)?))));
         }
         Ok(elem.pack())
     }
@@ -252,7 +251,7 @@ impl Eval for ast::EnumItem<'_> {
         let body = self.body().eval(vm)?;
         let mut elem = EnumItem::new(body);
         if let Some(number) = self.number() {
-            elem.push_number(Some(number));
+            elem.number.set(Some(number));
         }
         Ok(elem.pack())
     }
diff --git a/crates/typst-eval/src/math.rs b/crates/typst-eval/src/math.rs
index 0e271a089..c2325a8c5 100644
--- a/crates/typst-eval/src/math.rs
+++ b/crates/typst-eval/src/math.rs
@@ -80,17 +80,17 @@ impl Eval for ast::MathAttach<'_> {
         let mut elem = AttachElem::new(base);
 
         if let Some(expr) = self.top() {
-            elem.push_t(Some(expr.eval_display(vm)?));
+            elem.t.set(Some(expr.eval_display(vm)?));
         }
 
         // Always attach primes in scripts style (not limits style),
         // i.e. at the top-right corner.
         if let Some(primes) = self.primes() {
-            elem.push_tr(Some(primes.eval(vm)?));
+            elem.tr.set(Some(primes.eval(vm)?));
         }
 
         if let Some(expr) = self.bottom() {
-            elem.push_b(Some(expr.eval_display(vm)?));
+            elem.b.set(Some(expr.eval_display(vm)?));
         }
 
         Ok(elem.pack())
diff --git a/crates/typst-eval/src/rules.rs b/crates/typst-eval/src/rules.rs
index f4c1563f3..eb6a1e6da 100644
--- a/crates/typst-eval/src/rules.rs
+++ b/crates/typst-eval/src/rules.rs
@@ -1,6 +1,6 @@
 use typst_library::diag::{warning, At, SourceResult};
 use typst_library::foundations::{
-    Element, Fields, Func, Recipe, Selector, ShowableSelector, Styles, Transformation,
+    Element, Func, Recipe, Selector, ShowableSelector, Styles, Transformation,
 };
 use typst_library::layout::BlockElem;
 use typst_library::model::ParElem;
@@ -62,8 +62,7 @@ fn check_show_par_set_block(vm: &mut Vm, recipe: &Recipe) {
         if let Some(Selector::Elem(elem, _)) = recipe.selector();
         if *elem == Element::of::<ParElem>();
         if let Transformation::Style(styles) = recipe.transform();
-        if styles.has::<BlockElem>(<BlockElem as Fields>::Enum::Above as _) ||
-           styles.has::<BlockElem>(<BlockElem as Fields>::Enum::Below as _);
+        if styles.has(BlockElem::above) || styles.has(BlockElem::below);
         then {
             vm.engine.sink.warn(warning!(
                 recipe.span(),
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index 495187166..60ffa78ee 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -177,12 +177,12 @@ fn handle(
         output.push(HtmlNode::Tag(elem.tag.clone()));
     } else if let Some(elem) = child.to_packed::<HtmlElem>() {
         let mut children = vec![];
-        if let Some(body) = elem.body(styles) {
+        if let Some(body) = elem.body.get_ref(styles) {
             children = html_fragment(engine, body, locator.next(&elem.span()), styles)?;
         }
         let element = HtmlElement {
             tag: elem.tag,
-            attrs: elem.attrs(styles).clone(),
+            attrs: elem.attrs.get_cloned(styles),
             children,
             span: elem.span(),
         };
@@ -198,7 +198,7 @@ fn handle(
         );
     } else if let Some(elem) = child.to_packed::<BoxElem>() {
         // TODO: This is rather incomplete.
-        if let Some(body) = elem.body(styles) {
+        if let Some(body) = elem.body.get_ref(styles) {
             let children =
                 html_fragment(engine, body, locator.next(&elem.span()), styles)?;
             output.push(
@@ -212,7 +212,7 @@ fn handle(
     } else if let Some((elem, body)) =
         child
             .to_packed::<BlockElem>()
-            .and_then(|elem| match elem.body(styles) {
+            .and_then(|elem| match elem.body.get_ref(styles) {
                 Some(BlockBody::Content(body)) => Some((elem, body)),
                 _ => None,
             })
@@ -233,12 +233,12 @@ fn handle(
         output.push(HtmlElement::new(tag::br).spanned(elem.span()).into());
     } else if let Some(elem) = child.to_packed::<SmartQuoteElem>() {
         output.push(HtmlNode::text(
-            if elem.double(styles) { '"' } else { '\'' },
+            if elem.double.get(styles) { '"' } else { '\'' },
             child.span(),
         ));
     } else if let Some(elem) = child.to_packed::<FrameElem>() {
         let locator = locator.next(&elem.span());
-        let style = TargetElem::set_target(Target::Paged).wrap();
+        let style = TargetElem::target.set(Target::Paged).wrap();
         let frame = (engine.routines.layout_frame)(
             engine,
             &elem.body,
@@ -248,7 +248,7 @@ fn handle(
         )?;
         output.push(HtmlNode::Frame(HtmlFrame {
             inner: frame,
-            text_size: TextElem::size_in(styles),
+            text_size: styles.resolve(TextElem::size),
         }));
     } else {
         engine.sink.warn(warning!(
diff --git a/crates/typst-ide/src/definition.rs b/crates/typst-ide/src/definition.rs
index ae1ba287b..4c2b80cd4 100644
--- a/crates/typst-ide/src/definition.rs
+++ b/crates/typst-ide/src/definition.rs
@@ -187,6 +187,6 @@ mod tests {
 
     #[test]
     fn test_definition_std() {
-        test("#table", 1, Side::After).must_be_value(typst::model::TableElem::elem());
+        test("#table", 1, Side::After).must_be_value(typst::model::TableElem::ELEM);
     }
 }
diff --git a/crates/typst-ide/src/tests.rs b/crates/typst-ide/src/tests.rs
index dd5c230ad..b3f368f2e 100644
--- a/crates/typst-ide/src/tests.rs
+++ b/crates/typst-ide/src/tests.rs
@@ -171,13 +171,11 @@ fn library() -> Library {
     let mut lib = typst::Library::builder()
         .with_features([Feature::Html].into_iter().collect())
         .build();
+    lib.styles.set(PageElem::width, Smart::Custom(Abs::pt(120.0).into()));
+    lib.styles.set(PageElem::height, Smart::Auto);
     lib.styles
-        .set(PageElem::set_width(Smart::Custom(Abs::pt(120.0).into())));
-    lib.styles.set(PageElem::set_height(Smart::Auto));
-    lib.styles.set(PageElem::set_margin(Margin::splat(Some(Smart::Custom(
-        Abs::pt(10.0).into(),
-    )))));
-    lib.styles.set(TextElem::set_size(TextSize(Abs::pt(10.0).into())));
+        .set(PageElem::margin, Margin::splat(Some(Smart::Custom(Abs::pt(10.0).into()))));
+    lib.styles.set(TextElem::size, TextSize(Abs::pt(10.0).into()));
     lib
 }
 
diff --git a/crates/typst-layout/src/flow/block.rs b/crates/typst-layout/src/flow/block.rs
index 6c2c3923d..d6cfe3a9e 100644
--- a/crates/typst-layout/src/flow/block.rs
+++ b/crates/typst-layout/src/flow/block.rs
@@ -24,15 +24,15 @@ pub fn layout_single_block(
     region: Region,
 ) -> SourceResult<Frame> {
     // Fetch sizing properties.
-    let width = elem.width(styles);
-    let height = elem.height(styles);
-    let inset = elem.inset(styles).unwrap_or_default();
+    let width = elem.width.get(styles);
+    let height = elem.height.get(styles);
+    let inset = elem.inset.resolve(styles).unwrap_or_default();
 
     // Build the pod regions.
     let pod = unbreakable_pod(&width.into(), &height, &inset, styles, region.size);
 
     // Layout the body.
-    let body = elem.body(styles);
+    let body = elem.body.get_ref(styles);
     let mut frame = match body {
         // If we have no body, just create one frame. Its size will be
         // adjusted below.
@@ -73,18 +73,19 @@ pub fn layout_single_block(
     }
 
     // Prepare fill and stroke.
-    let fill = elem.fill(styles);
+    let fill = elem.fill.get_cloned(styles);
     let stroke = elem
-        .stroke(styles)
+        .stroke
+        .resolve(styles)
         .unwrap_or_default()
         .map(|s| s.map(Stroke::unwrap_or_default));
 
     // Only fetch these if necessary (for clipping or filling/stroking).
-    let outset = LazyCell::new(|| elem.outset(styles).unwrap_or_default());
-    let radius = LazyCell::new(|| elem.radius(styles).unwrap_or_default());
+    let outset = LazyCell::new(|| elem.outset.resolve(styles).unwrap_or_default());
+    let radius = LazyCell::new(|| elem.radius.resolve(styles).unwrap_or_default());
 
     // Clip the contents, if requested.
-    if elem.clip(styles) {
+    if elem.clip.get(styles) {
         frame.clip(clip_rect(frame.size(), &radius, &stroke, &outset));
     }
 
@@ -111,9 +112,9 @@ pub fn layout_multi_block(
     regions: Regions,
 ) -> SourceResult<Fragment> {
     // Fetch sizing properties.
-    let width = elem.width(styles);
-    let height = elem.height(styles);
-    let inset = elem.inset(styles).unwrap_or_default();
+    let width = elem.width.get(styles);
+    let height = elem.height.get(styles);
+    let inset = elem.inset.resolve(styles).unwrap_or_default();
 
     // Allocate a small vector for backlogs.
     let mut buf = SmallVec::<[Abs; 2]>::new();
@@ -122,7 +123,7 @@ pub fn layout_multi_block(
     let pod = breakable_pod(&width.into(), &height, &inset, styles, regions, &mut buf);
 
     // Layout the body.
-    let body = elem.body(styles);
+    let body = elem.body.get_ref(styles);
     let mut fragment = match body {
         // If we have no body, just create one frame plus one per backlog
         // region. We create them zero-sized; if necessary, their size will
@@ -188,18 +189,19 @@ pub fn layout_multi_block(
     };
 
     // Prepare fill and stroke.
-    let fill = elem.fill(styles);
+    let fill = elem.fill.get_ref(styles);
     let stroke = elem
-        .stroke(styles)
+        .stroke
+        .resolve(styles)
         .unwrap_or_default()
         .map(|s| s.map(Stroke::unwrap_or_default));
 
     // Only fetch these if necessary (for clipping or filling/stroking).
-    let outset = LazyCell::new(|| elem.outset(styles).unwrap_or_default());
-    let radius = LazyCell::new(|| elem.radius(styles).unwrap_or_default());
+    let outset = LazyCell::new(|| elem.outset.resolve(styles).unwrap_or_default());
+    let radius = LazyCell::new(|| elem.radius.resolve(styles).unwrap_or_default());
 
     // Fetch/compute these outside of the loop.
-    let clip = elem.clip(styles);
+    let clip = elem.clip.get(styles);
     let has_fill_or_stroke = fill.is_some() || stroke.iter().any(Option::is_some);
     let has_inset = !inset.is_zero();
     let is_explicit = matches!(body, None | Some(BlockBody::Content(_)));
diff --git a/crates/typst-layout/src/flow/collect.rs b/crates/typst-layout/src/flow/collect.rs
index 2c14f7a37..76268b590 100644
--- a/crates/typst-layout/src/flow/collect.rs
+++ b/crates/typst-layout/src/flow/collect.rs
@@ -89,7 +89,7 @@ impl<'a> Collector<'a, '_, '_> {
             } else if child.is::<FlushElem>() {
                 self.output.push(Child::Flush);
             } else if let Some(elem) = child.to_packed::<ColbreakElem>() {
-                self.output.push(Child::Break(elem.weak(styles)));
+                self.output.push(Child::Break(elem.weak.get(styles)));
             } else if child.is::<PagebreakElem>() {
                 bail!(
                     child.span(), "pagebreaks are not allowed inside of containers";
@@ -132,7 +132,7 @@ impl<'a> Collector<'a, '_, '_> {
             self.output.push(Child::Tag(&elem.tag));
         }
 
-        let leading = ParElem::leading_in(styles);
+        let leading = styles.resolve(ParElem::leading);
         self.lines(lines, leading, styles);
 
         for (c, _) in &self.children[end..] {
@@ -146,7 +146,9 @@ impl<'a> Collector<'a, '_, '_> {
     /// Collect vertical spacing into a relative or fractional child.
     fn v(&mut self, elem: &'a Packed<VElem>, styles: StyleChain<'a>) {
         self.output.push(match elem.amount {
-            Spacing::Rel(rel) => Child::Rel(rel.resolve(styles), elem.weak(styles) as u8),
+            Spacing::Rel(rel) => {
+                Child::Rel(rel.resolve(styles), elem.weak.get(styles) as u8)
+            }
             Spacing::Fr(fr) => Child::Fr(fr),
         });
     }
@@ -169,8 +171,8 @@ impl<'a> Collector<'a, '_, '_> {
         )?
         .into_frames();
 
-        let spacing = elem.spacing(styles);
-        let leading = elem.leading(styles);
+        let spacing = elem.spacing.resolve(styles);
+        let leading = elem.leading.resolve(styles);
 
         self.output.push(Child::Rel(spacing.into(), 4));
 
@@ -184,8 +186,8 @@ impl<'a> Collector<'a, '_, '_> {
 
     /// Collect laid-out lines.
     fn lines(&mut self, lines: Vec<Frame>, leading: Abs, styles: StyleChain<'a>) {
-        let align = AlignElem::alignment_in(styles).resolve(styles);
-        let costs = TextElem::costs_in(styles);
+        let align = styles.resolve(AlignElem::alignment);
+        let costs = styles.get(TextElem::costs);
 
         // Determine whether to prevent widow and orphans.
         let len = lines.len();
@@ -231,23 +233,23 @@ impl<'a> Collector<'a, '_, '_> {
     /// whether it is breakable.
     fn block(&mut self, elem: &'a Packed<BlockElem>, styles: StyleChain<'a>) {
         let locator = self.locator.next(&elem.span());
-        let align = AlignElem::alignment_in(styles).resolve(styles);
+        let align = styles.resolve(AlignElem::alignment);
         let alone = self.children.len() == 1;
-        let sticky = elem.sticky(styles);
-        let breakable = elem.breakable(styles);
-        let fr = match elem.height(styles) {
+        let sticky = elem.sticky.get(styles);
+        let breakable = elem.breakable.get(styles);
+        let fr = match elem.height.get(styles) {
             Sizing::Fr(fr) => Some(fr),
             _ => None,
         };
 
-        let fallback = LazyCell::new(|| ParElem::spacing_in(styles));
+        let fallback = LazyCell::new(|| styles.resolve(ParElem::spacing));
         let spacing = |amount| match amount {
             Smart::Auto => Child::Rel((*fallback).into(), 4),
             Smart::Custom(Spacing::Rel(rel)) => Child::Rel(rel.resolve(styles), 3),
             Smart::Custom(Spacing::Fr(fr)) => Child::Fr(fr),
         };
 
-        self.output.push(spacing(elem.above(styles)));
+        self.output.push(spacing(elem.above.get(styles)));
 
         if !breakable || fr.is_some() {
             self.output.push(Child::Single(self.boxed(SingleChild {
@@ -272,7 +274,7 @@ impl<'a> Collector<'a, '_, '_> {
             })));
         };
 
-        self.output.push(spacing(elem.below(styles)));
+        self.output.push(spacing(elem.below.get(styles)));
         self.par_situation = ParSituation::Other;
     }
 
@@ -282,13 +284,13 @@ impl<'a> Collector<'a, '_, '_> {
         elem: &'a Packed<PlaceElem>,
         styles: StyleChain<'a>,
     ) -> SourceResult<()> {
-        let alignment = elem.alignment(styles);
+        let alignment = elem.alignment.get(styles);
         let align_x = alignment.map_or(FixedAlignment::Center, |align| {
             align.x().unwrap_or_default().resolve(styles)
         });
         let align_y = alignment.map(|align| align.y().map(|y| y.resolve(styles)));
-        let scope = elem.scope(styles);
-        let float = elem.float(styles);
+        let scope = elem.scope.get(styles);
+        let float = elem.float.get(styles);
 
         match (float, align_y) {
             (true, Smart::Custom(None | Some(FixedAlignment::Center))) => bail!(
@@ -312,8 +314,8 @@ impl<'a> Collector<'a, '_, '_> {
         }
 
         let locator = self.locator.next(&elem.span());
-        let clearance = elem.clearance(styles);
-        let delta = Axes::new(elem.dx(styles), elem.dy(styles)).resolve(styles);
+        let clearance = elem.clearance.resolve(styles);
+        let delta = Axes::new(elem.dx.get(styles), elem.dy.get(styles)).resolve(styles);
         self.output.push(Child::Placed(self.boxed(PlacedChild {
             align_x,
             align_y,
@@ -631,7 +633,7 @@ impl PlacedChild<'_> {
     pub fn layout(&self, engine: &mut Engine, base: Size) -> SourceResult<Frame> {
         self.cell.get_or_init(base, |base| {
             let align = self.alignment.unwrap_or_else(|| Alignment::CENTER);
-            let aligned = AlignElem::set_alignment(align).wrap();
+            let aligned = AlignElem::alignment.set(align).wrap();
             let styles = self.styles.chain(&aligned);
 
             let mut frame = layout_and_modify(styles, |styles| {
diff --git a/crates/typst-layout/src/flow/compose.rs b/crates/typst-layout/src/flow/compose.rs
index 54dc487a3..ed514a248 100644
--- a/crates/typst-layout/src/flow/compose.rs
+++ b/crates/typst-layout/src/flow/compose.rs
@@ -851,7 +851,7 @@ fn layout_line_number_reset(
     config: &Config,
     locator: &mut SplitLocator,
 ) -> SourceResult<Frame> {
-    let counter = Counter::of(ParLineMarker::elem());
+    let counter = Counter::of(ParLineMarker::ELEM);
     let update = CounterUpdate::Set(CounterState::init(false));
     let content = counter.update(Span::detached(), update);
     crate::layout_frame(
@@ -879,7 +879,7 @@ fn layout_line_number(
     locator: &mut SplitLocator,
     numbering: &Numbering,
 ) -> SourceResult<Frame> {
-    let counter = Counter::of(ParLineMarker::elem());
+    let counter = Counter::of(ParLineMarker::ELEM);
     let update = CounterUpdate::Step(NonZeroUsize::ONE);
     let numbering = Smart::Custom(numbering.clone());
 
diff --git a/crates/typst-layout/src/flow/mod.rs b/crates/typst-layout/src/flow/mod.rs
index cba228bcd..f4f1c0915 100644
--- a/crates/typst-layout/src/flow/mod.rs
+++ b/crates/typst-layout/src/flow/mod.rs
@@ -98,8 +98,8 @@ pub fn layout_columns(
         locator.track(),
         styles,
         regions,
-        elem.count(styles),
-        elem.gutter(styles),
+        elem.count.get(styles),
+        elem.gutter.resolve(styles),
     )
 }
 
@@ -251,22 +251,22 @@ fn configuration<'x>(
 
             let gutter = column_gutter.relative_to(regions.base().x);
             let width = (regions.size.x - gutter * (count - 1) as f64) / count as f64;
-            let dir = TextElem::dir_in(shared);
+            let dir = shared.resolve(TextElem::dir);
             ColumnConfig { count, width, gutter, dir }
         },
         footnote: FootnoteConfig {
-            separator: FootnoteEntry::separator_in(shared),
-            clearance: FootnoteEntry::clearance_in(shared),
-            gap: FootnoteEntry::gap_in(shared),
+            separator: shared.get_cloned(FootnoteEntry::separator),
+            clearance: shared.resolve(FootnoteEntry::clearance),
+            gap: shared.resolve(FootnoteEntry::gap),
             expand: regions.expand.x,
         },
         line_numbers: (mode == FlowMode::Root).then(|| LineNumberConfig {
-            scope: ParLine::numbering_scope_in(shared),
+            scope: shared.get(ParLine::numbering_scope),
             default_clearance: {
-                let width = if PageElem::flipped_in(shared) {
-                    PageElem::height_in(shared)
+                let width = if shared.get(PageElem::flipped) {
+                    shared.resolve(PageElem::height)
                 } else {
-                    PageElem::width_in(shared)
+                    shared.resolve(PageElem::width)
                 };
 
                 // Clamp below is safe (min <= max): if the font size is
diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index 42fe38dbe..d4f11f470 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -249,7 +249,7 @@ impl<'a> GridLayouter<'a> {
             rowspans: vec![],
             finished: vec![],
             finished_header_rows: vec![],
-            is_rtl: TextElem::dir_in(styles) == Dir::RTL,
+            is_rtl: styles.resolve(TextElem::dir) == Dir::RTL,
             repeating_headers: vec![],
             upcoming_headers: &grid.headers,
             pending_headers: Default::default(),
diff --git a/crates/typst-layout/src/image.rs b/crates/typst-layout/src/image.rs
index a8f4a0c81..261a58fa3 100644
--- a/crates/typst-layout/src/image.rs
+++ b/crates/typst-layout/src/image.rs
@@ -28,7 +28,7 @@ pub fn layout_image(
     // Take the format that was explicitly defined, or parse the extension,
     // or try to detect the format.
     let Derived { source, derived: loaded } = &elem.source;
-    let format = match elem.format(styles) {
+    let format = match elem.format.get(styles) {
         Smart::Custom(v) => v,
         Smart::Auto => determine_format(source, &loaded.data).at(span)?,
     };
@@ -55,7 +55,7 @@ pub fn layout_image(
             RasterImage::new(
                 loaded.data.clone(),
                 format,
-                elem.icc(styles).as_ref().map(|icc| icc.derived.clone()),
+                elem.icc.get_ref(styles).as_ref().map(|icc| icc.derived.clone()),
             )
             .at(span)?,
         ),
@@ -69,7 +69,7 @@ pub fn layout_image(
         ),
     };
 
-    let image = Image::new(kind, elem.alt(styles), elem.scaling(styles));
+    let image = Image::new(kind, elem.alt.get_cloned(styles), elem.scaling.get(styles));
 
     // Determine the image's pixel aspect ratio.
     let pxw = image.width();
@@ -106,7 +106,7 @@ pub fn layout_image(
     };
 
     // Compute the actual size of the fitted image.
-    let fit = elem.fit(styles);
+    let fit = elem.fit.get(styles);
     let fitted = match fit {
         ImageFit::Cover | ImageFit::Contain => {
             if wide == (fit == ImageFit::Contain) {
diff --git a/crates/typst-layout/src/inline/box.rs b/crates/typst-layout/src/inline/box.rs
index e21928d3c..65b025334 100644
--- a/crates/typst-layout/src/inline/box.rs
+++ b/crates/typst-layout/src/inline/box.rs
@@ -21,15 +21,15 @@ pub fn layout_box(
     region: Size,
 ) -> SourceResult<Frame> {
     // Fetch sizing properties.
-    let width = elem.width(styles);
-    let height = elem.height(styles);
-    let inset = elem.inset(styles).unwrap_or_default();
+    let width = elem.width.get(styles);
+    let height = elem.height.get(styles);
+    let inset = elem.inset.resolve(styles).unwrap_or_default();
 
     // Build the pod region.
     let pod = unbreakable_pod(&width, &height.into(), &inset, styles, region);
 
     // Layout the body.
-    let mut frame = match elem.body(styles) {
+    let mut frame = match elem.body.get_ref(styles) {
         // If we have no body, just create an empty frame. If necessary,
         // its size will be adjusted below.
         None => Frame::hard(Size::zero()),
@@ -50,18 +50,19 @@ pub fn layout_box(
     }
 
     // Prepare fill and stroke.
-    let fill = elem.fill(styles);
+    let fill = elem.fill.get_cloned(styles);
     let stroke = elem
-        .stroke(styles)
+        .stroke
+        .resolve(styles)
         .unwrap_or_default()
         .map(|s| s.map(Stroke::unwrap_or_default));
 
     // Only fetch these if necessary (for clipping or filling/stroking).
-    let outset = LazyCell::new(|| elem.outset(styles).unwrap_or_default());
-    let radius = LazyCell::new(|| elem.radius(styles).unwrap_or_default());
+    let outset = LazyCell::new(|| elem.outset.resolve(styles).unwrap_or_default());
+    let radius = LazyCell::new(|| elem.radius.resolve(styles).unwrap_or_default());
 
     // Clip the contents, if requested.
-    if elem.clip(styles) {
+    if elem.clip.get(styles) {
         frame.clip(clip_rect(frame.size(), &radius, &stroke, &outset));
     }
 
@@ -78,7 +79,7 @@ pub fn layout_box(
     // Apply baseline shift. Do this after setting the size and applying the
     // inset, so that a relative shift is resolved relative to the final
     // height.
-    let shift = elem.baseline(styles).relative_to(frame.height());
+    let shift = elem.baseline.resolve(styles).relative_to(frame.height());
     if !shift.is_zero() {
         frame.set_baseline(frame.baseline() - shift);
     }
diff --git a/crates/typst-layout/src/inline/collect.rs b/crates/typst-layout/src/inline/collect.rs
index 829f64b66..2744b31e0 100644
--- a/crates/typst-layout/src/inline/collect.rs
+++ b/crates/typst-layout/src/inline/collect.rs
@@ -144,7 +144,7 @@ pub fn collect<'a>(
             collector.push_text(" ", styles);
         } else if let Some(elem) = child.to_packed::<TextElem>() {
             collector.build_text(styles, |full| {
-                let dir = TextElem::dir_in(styles);
+                let dir = styles.resolve(TextElem::dir);
                 if dir != config.dir {
                     // Insert "Explicit Directional Embedding".
                     match dir {
@@ -154,7 +154,7 @@ pub fn collect<'a>(
                     }
                 }
 
-                if let Some(case) = TextElem::case_in(styles) {
+                if let Some(case) = styles.get(TextElem::case) {
                     full.push_str(&case.apply(&elem.text));
                 } else {
                     full.push_str(&elem.text);
@@ -174,20 +174,22 @@ pub fn collect<'a>(
                 Spacing::Fr(fr) => Item::Fractional(fr, None),
                 Spacing::Rel(rel) => Item::Absolute(
                     rel.resolve(styles).relative_to(region.x),
-                    elem.weak(styles),
+                    elem.weak.get(styles),
                 ),
             });
         } else if let Some(elem) = child.to_packed::<LinebreakElem>() {
-            collector
-                .push_text(if elem.justify(styles) { "\u{2028}" } else { "\n" }, styles);
+            collector.push_text(
+                if elem.justify.get(styles) { "\u{2028}" } else { "\n" },
+                styles,
+            );
         } else if let Some(elem) = child.to_packed::<SmartQuoteElem>() {
-            let double = elem.double(styles);
-            if elem.enabled(styles) {
+            let double = elem.double.get(styles);
+            if elem.enabled.get(styles) {
                 let quotes = SmartQuotes::get(
-                    elem.quotes(styles),
-                    TextElem::lang_in(styles),
-                    TextElem::region_in(styles),
-                    elem.alternative(styles),
+                    elem.quotes.get_ref(styles),
+                    styles.get(TextElem::lang),
+                    styles.get(TextElem::region),
+                    elem.alternative.get(styles),
                 );
                 let before =
                     collector.full.chars().rev().find(|&c| !is_default_ignorable(c));
@@ -215,7 +217,7 @@ pub fn collect<'a>(
             collector.push_item(Item::Skip(POP_ISOLATE));
         } else if let Some(elem) = child.to_packed::<BoxElem>() {
             let loc = locator.next(&elem.span());
-            if let Sizing::Fr(v) = elem.width(styles) {
+            if let Sizing::Fr(v) = elem.width.get(styles) {
                 collector.push_item(Item::Fractional(v, Some((elem, loc, styles))));
             } else {
                 let mut frame = layout_and_modify(styles, |styles| {
diff --git a/crates/typst-layout/src/inline/line.rs b/crates/typst-layout/src/inline/line.rs
index b850e50ee..58162d12b 100644
--- a/crates/typst-layout/src/inline/line.rs
+++ b/crates/typst-layout/src/inline/line.rs
@@ -2,6 +2,7 @@ use std::fmt::{self, Debug, Formatter};
 use std::ops::{Deref, DerefMut};
 
 use typst_library::engine::Engine;
+use typst_library::foundations::Resolve;
 use typst_library::introspection::{SplitLocator, Tag};
 use typst_library::layout::{Abs, Dir, Em, Fr, Frame, FrameItem, Point};
 use typst_library::model::ParLineMarker;
@@ -418,10 +419,11 @@ pub fn apply_shift<'a>(
     frame: &mut Frame,
     styles: StyleChain,
 ) {
-    let mut baseline = TextElem::baseline_in(styles);
+    let mut baseline = styles.resolve(TextElem::baseline);
     let mut compensation = Abs::zero();
-    if let Some(scripts) = TextElem::shift_settings_in(styles) {
-        let font_metrics = TextElem::font_in(styles)
+    if let Some(scripts) = styles.get_ref(TextElem::shift_settings) {
+        let font_metrics = styles
+            .get_ref(TextElem::font)
             .into_iter()
             .find_map(|family| {
                 world
@@ -462,7 +464,7 @@ pub fn commit(
     if let Some(Item::Text(text)) = line.items.first() {
         if let Some(glyph) = text.glyphs.first() {
             if !text.dir.is_positive()
-                && TextElem::overhang_in(text.styles)
+                && text.styles.get(TextElem::overhang)
                 && (line.items.len() > 1 || text.glyphs.len() > 1)
             {
                 let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
@@ -476,7 +478,7 @@ pub fn commit(
     if let Some(Item::Text(text)) = line.items.last() {
         if let Some(glyph) = text.glyphs.last() {
             if text.dir.is_positive()
-                && TextElem::overhang_in(text.styles)
+                && text.styles.get(TextElem::overhang)
                 && (line.items.len() > 1 || text.glyphs.len() > 1)
             {
                 let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
diff --git a/crates/typst-layout/src/inline/linebreak.rs b/crates/typst-layout/src/inline/linebreak.rs
index 709745edc..955360df1 100644
--- a/crates/typst-layout/src/inline/linebreak.rs
+++ b/crates/typst-layout/src/inline/linebreak.rs
@@ -846,7 +846,9 @@ fn hyphenate_at(p: &Preparation, offset: usize) -> bool {
     p.config.hyphenate.unwrap_or_else(|| {
         let (_, item) = p.get(offset);
         match item.text() {
-            Some(text) => TextElem::hyphenate_in(text.styles).unwrap_or(p.config.justify),
+            Some(text) => {
+                text.styles.get(TextElem::hyphenate).unwrap_or(p.config.justify)
+            }
             None => false,
         }
     })
@@ -857,7 +859,7 @@ fn lang_at(p: &Preparation, offset: usize) -> Option<hypher::Lang> {
     let lang = p.config.lang.or_else(|| {
         let (_, item) = p.get(offset);
         let styles = item.text()?.styles;
-        Some(TextElem::lang_in(styles))
+        Some(styles.get(TextElem::lang))
     })?;
 
     let bytes = lang.as_str().as_bytes().try_into().ok()?;
diff --git a/crates/typst-layout/src/inline/mod.rs b/crates/typst-layout/src/inline/mod.rs
index 506fa5eac..06223cebf 100644
--- a/crates/typst-layout/src/inline/mod.rs
+++ b/crates/typst-layout/src/inline/mod.rs
@@ -14,7 +14,7 @@ pub use self::shaping::create_shape_plan;
 use comemo::{Track, Tracked, TrackedMut};
 use typst_library::diag::SourceResult;
 use typst_library::engine::{Engine, Route, Sink, Traced};
-use typst_library::foundations::{Packed, Resolve, Smart, StyleChain};
+use typst_library::foundations::{Packed, Smart, StyleChain};
 use typst_library::introspection::{Introspector, Locator, LocatorLink, SplitLocator};
 use typst_library::layout::{Abs, AlignElem, Dir, FixedAlignment, Fragment, Size};
 use typst_library::model::{
@@ -113,10 +113,10 @@ fn layout_par_impl(
         expand,
         Some(situation),
         &ConfigBase {
-            justify: elem.justify(styles),
-            linebreaks: elem.linebreaks(styles),
-            first_line_indent: elem.first_line_indent(styles),
-            hanging_indent: elem.hanging_indent(styles),
+            justify: elem.justify.get(styles),
+            linebreaks: elem.linebreaks.get(styles),
+            first_line_indent: elem.first_line_indent.get(styles),
+            hanging_indent: elem.hanging_indent.resolve(styles),
         },
     )
 }
@@ -139,10 +139,10 @@ pub fn layout_inline<'a>(
         expand,
         None,
         &ConfigBase {
-            justify: ParElem::justify_in(shared),
-            linebreaks: ParElem::linebreaks_in(shared),
-            first_line_indent: ParElem::first_line_indent_in(shared),
-            hanging_indent: ParElem::hanging_indent_in(shared),
+            justify: shared.get(ParElem::justify),
+            linebreaks: shared.get(ParElem::linebreaks),
+            first_line_indent: shared.get(ParElem::first_line_indent),
+            hanging_indent: shared.resolve(ParElem::hanging_indent),
         },
     )
 }
@@ -184,8 +184,8 @@ fn configuration(
     situation: Option<ParSituation>,
 ) -> Config {
     let justify = base.justify;
-    let font_size = TextElem::size_in(shared);
-    let dir = TextElem::dir_in(shared);
+    let font_size = shared.resolve(TextElem::size);
+    let dir = shared.resolve(TextElem::dir);
 
     Config {
         justify,
@@ -207,7 +207,7 @@ fn configuration(
                     Some(ParSituation::Other) => all,
                     None => false,
                 }
-                && AlignElem::alignment_in(shared).resolve(shared).x == dir.start().into()
+                && shared.resolve(AlignElem::alignment).x == dir.start().into()
             {
                 amount.at(font_size)
             } else {
@@ -219,26 +219,26 @@ fn configuration(
         } else {
             Abs::zero()
         },
-        numbering_marker: ParLine::numbering_in(shared).map(|numbering| {
+        numbering_marker: shared.get_cloned(ParLine::numbering).map(|numbering| {
             Packed::new(ParLineMarker::new(
                 numbering,
-                ParLine::number_align_in(shared),
-                ParLine::number_margin_in(shared),
+                shared.get(ParLine::number_align),
+                shared.get(ParLine::number_margin),
                 // Delay resolving the number clearance until line numbers are
                 // laid out to avoid inconsistent spacing depending on varying
                 // font size.
-                ParLine::number_clearance_in(shared),
+                shared.get(ParLine::number_clearance),
             ))
         }),
-        align: AlignElem::alignment_in(shared).fix(dir).x,
+        align: shared.get(AlignElem::alignment).fix(dir).x,
         font_size,
         dir,
-        hyphenate: shared_get(children, shared, TextElem::hyphenate_in)
+        hyphenate: shared_get(children, shared, |s| s.get(TextElem::hyphenate))
             .map(|uniform| uniform.unwrap_or(justify)),
-        lang: shared_get(children, shared, TextElem::lang_in),
-        fallback: TextElem::fallback_in(shared),
-        cjk_latin_spacing: TextElem::cjk_latin_spacing_in(shared).is_auto(),
-        costs: TextElem::costs_in(shared),
+        lang: shared_get(children, shared, |s| s.get(TextElem::lang)),
+        fallback: shared.get(TextElem::fallback),
+        cjk_latin_spacing: shared.get(TextElem::cjk_latin_spacing).is_auto(),
+        costs: shared.get(TextElem::costs),
     }
 }
 
@@ -314,7 +314,7 @@ fn shared_get<T: PartialEq>(
 /// When we support some kind of more general ancestry mechanism, this can
 /// become more elegant.
 fn in_list(styles: StyleChain) -> bool {
-    ListElem::depth_in(styles).0 > 0
-        || !EnumElem::parents_in(styles).is_empty()
-        || TermsElem::within_in(styles)
+    styles.get(ListElem::depth).0 > 0
+        || !styles.get_cloned(EnumElem::parents).is_empty()
+        || styles.get(TermsElem::within)
 }
diff --git a/crates/typst-layout/src/inline/shaping.rs b/crates/typst-layout/src/inline/shaping.rs
index 48747cd50..d1e748da8 100644
--- a/crates/typst-layout/src/inline/shaping.rs
+++ b/crates/typst-layout/src/inline/shaping.rs
@@ -223,12 +223,12 @@ 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);
+        let size = self.styles.resolve(TextElem::size);
+        let shift = self.styles.resolve(TextElem::baseline);
+        let decos = self.styles.get_cloned(TextElem::deco);
+        let fill = self.styles.get_ref(TextElem::fill);
+        let stroke = self.styles.resolve(TextElem::stroke);
+        let span_offset = self.styles.get(TextElem::span_offset);
 
         for ((font, y_offset, glyph_size), group) in self
             .glyphs
@@ -340,9 +340,9 @@ 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);
+        let size = self.styles.resolve(TextElem::size);
+        let top_edge = self.styles.get(TextElem::top_edge);
+        let bottom_edge = self.styles.get(TextElem::bottom_edge);
 
         // Expand top and bottom by reading the font's vertical metrics.
         let mut expand = |font: &Font, bounds: TextEdgeBounds| {
@@ -486,7 +486,7 @@ 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);
+            let size = self.styles.resolve(TextElem::size);
             self.width += x_advance.at(size);
             let glyph = ShapedGlyph {
                 font,
@@ -603,9 +603,9 @@ pub fn shape_range<'a>(
     range: Range,
     styles: StyleChain<'a>,
 ) {
-    let script = TextElem::script_in(styles);
-    let lang = TextElem::lang_in(styles);
-    let region = TextElem::region_in(styles);
+    let script = styles.get(TextElem::script);
+    let lang = styles.get(TextElem::lang);
+    let region = styles.get(TextElem::region);
     let mut process = |range: Range, level: BidiLevel| {
         let dir = if level.is_ltr() { Dir::LTR } else { Dir::RTL };
         let shaped =
@@ -669,8 +669,8 @@ fn shape<'a>(
     lang: Lang,
     region: Option<Region>,
 ) -> ShapedText<'a> {
-    let size = TextElem::size_in(styles);
-    let shift_settings = TextElem::shift_settings_in(styles);
+    let size = styles.resolve(TextElem::size);
+    let shift_settings = styles.get(TextElem::shift_settings);
     let mut ctx = ShapingContext {
         engine,
         size,
@@ -679,7 +679,7 @@ fn shape<'a>(
         styles,
         variant: variant(styles),
         features: features(styles),
-        fallback: TextElem::fallback_in(styles),
+        fallback: styles.get(TextElem::fallback),
         dir,
         shift_settings,
     };
@@ -783,7 +783,7 @@ fn shape_segment<'a>(
     let mut buffer = UnicodeBuffer::new();
     buffer.push_str(text);
     buffer.set_language(language(ctx.styles));
-    if let Some(script) = TextElem::script_in(ctx.styles).custom().and_then(|script| {
+    if let Some(script) = ctx.styles.get(TextElem::script).custom().and_then(|script| {
         rustybuzz::Script::from_iso15924_tag(Tag::from_bytes(script.as_bytes()))
     }) {
         buffer.set_script(script)
@@ -1073,8 +1073,11 @@ 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 spacing = TextElem::spacing_in(ctx.styles).map(|abs| Em::from_abs(abs, ctx.size));
+    let tracking = Em::from_abs(ctx.styles.resolve(TextElem::tracking), ctx.size);
+    let spacing = ctx
+        .styles
+        .resolve(TextElem::spacing)
+        .map(|abs| Em::from_abs(abs, ctx.size));
 
     let mut glyphs = ctx.glyphs.iter_mut().peekable();
     while let Some(glyph) = glyphs.next() {
diff --git a/crates/typst-layout/src/lists.rs b/crates/typst-layout/src/lists.rs
index 974788a70..adb793fb9 100644
--- a/crates/typst-layout/src/lists.rs
+++ b/crates/typst-layout/src/lists.rs
@@ -20,20 +20,21 @@ pub fn layout_list(
     styles: StyleChain,
     regions: Regions,
 ) -> SourceResult<Fragment> {
-    let indent = elem.indent(styles);
-    let body_indent = elem.body_indent(styles);
-    let tight = elem.tight(styles);
-    let gutter = elem.spacing(styles).unwrap_or_else(|| {
+    let indent = elem.indent.get(styles);
+    let body_indent = elem.body_indent.get(styles);
+    let tight = elem.tight.get(styles);
+    let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
         if tight {
-            ParElem::leading_in(styles).into()
+            styles.get(ParElem::leading)
         } else {
-            ParElem::spacing_in(styles).into()
+            styles.get(ParElem::spacing)
         }
     });
 
-    let Depth(depth) = ListElem::depth_in(styles);
+    let Depth(depth) = styles.get(ListElem::depth);
     let marker = elem
-        .marker(styles)
+        .marker
+        .get_ref(styles)
         .resolve(engine, styles, depth)?
         // avoid '#set align' interference with the list
         .aligned(HAlignment::Start + VAlignment::Top);
@@ -52,7 +53,7 @@ pub fn layout_list(
         cells.push(Cell::new(marker.clone(), locator.next(&marker.span())));
         cells.push(Cell::new(Content::empty(), locator.next(&())));
         cells.push(Cell::new(
-            body.styled(ListElem::set_depth(Depth(1))),
+            body.set(ListElem::depth, Depth(1)),
             locator.next(&item.body.span()),
         ));
     }
@@ -81,40 +82,40 @@ pub fn layout_enum(
     styles: StyleChain,
     regions: Regions,
 ) -> SourceResult<Fragment> {
-    let numbering = elem.numbering(styles);
-    let reversed = elem.reversed(styles);
-    let indent = elem.indent(styles);
-    let body_indent = elem.body_indent(styles);
-    let tight = elem.tight(styles);
-    let gutter = elem.spacing(styles).unwrap_or_else(|| {
+    let numbering = elem.numbering.get_ref(styles);
+    let reversed = elem.reversed.get(styles);
+    let indent = elem.indent.get(styles);
+    let body_indent = elem.body_indent.get(styles);
+    let tight = elem.tight.get(styles);
+    let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
         if tight {
-            ParElem::leading_in(styles).into()
+            styles.get(ParElem::leading)
         } else {
-            ParElem::spacing_in(styles).into()
+            styles.get(ParElem::spacing)
         }
     });
 
     let mut cells = vec![];
     let mut locator = locator.split();
-    let mut number = elem.start(styles).unwrap_or_else(|| {
+    let mut number = elem.start.get(styles).unwrap_or_else(|| {
         if reversed {
             elem.children.len() as u64
         } else {
             1
         }
     });
-    let mut parents = EnumElem::parents_in(styles);
+    let mut parents = styles.get_cloned(EnumElem::parents);
 
-    let full = elem.full(styles);
+    let full = elem.full.get(styles);
 
     // Horizontally align based on the given respective parameter.
     // Vertically align to the top to avoid inheriting `horizon` or `bottom`
     // alignment from the context and having the number be displaced in
     // relation to the item it refers to.
-    let number_align = elem.number_align(styles);
+    let number_align = elem.number_align.get(styles);
 
     for item in &elem.children {
-        number = item.number(styles).unwrap_or(number);
+        number = item.number.get(styles).unwrap_or(number);
 
         let context = Context::new(None, Some(styles));
         let resolved = if full {
@@ -133,8 +134,7 @@ pub fn layout_enum(
 
         // Disable overhang as a workaround to end-aligned dots glitching
         // and decreasing spacing between numbers and items.
-        let resolved =
-            resolved.aligned(number_align).styled(TextElem::set_overhang(false));
+        let resolved = resolved.aligned(number_align).set(TextElem::overhang, false);
 
         // Text in wide enums shall always turn into paragraphs.
         let mut body = item.body.clone();
@@ -146,7 +146,7 @@ pub fn layout_enum(
         cells.push(Cell::new(resolved, locator.next(&())));
         cells.push(Cell::new(Content::empty(), locator.next(&())));
         cells.push(Cell::new(
-            body.styled(EnumElem::set_parents(smallvec![number])),
+            body.set(EnumElem::parents, smallvec![number]),
             locator.next(&item.body.span()),
         ));
         number =
diff --git a/crates/typst-layout/src/math/accent.rs b/crates/typst-layout/src/math/accent.rs
index 159703b8e..e7f051ace 100644
--- a/crates/typst-layout/src/math/accent.rs
+++ b/crates/typst-layout/src/math/accent.rs
@@ -24,7 +24,7 @@ pub fn layout_accent(
     // Try to replace the base glyph with its dotless variant.
     let dtls = style_dtls();
     let base_styles =
-        if top_accent && elem.dotless(styles) { styles.chain(&dtls) } else { styles };
+        if top_accent && elem.dotless.get(styles) { styles.chain(&dtls) } else { styles };
 
     let cramped = style_cramped();
     let base = ctx.layout_into_fragment(&elem.base, base_styles.chain(&cramped))?;
@@ -47,7 +47,7 @@ pub fn layout_accent(
 
     // Forcing the accent to be at least as large as the base makes it too wide
     // in many cases.
-    let width = elem.size(styles).relative_to(base.width());
+    let width = elem.size.resolve(styles).relative_to(base.width());
     let short_fall = ACCENT_SHORT_FALL.at(glyph.item.size);
     glyph.stretch_horizontal(ctx, width - short_fall);
     let accent_attach = glyph.accent_attach.0;
diff --git a/crates/typst-layout/src/math/attach.rs b/crates/typst-layout/src/math/attach.rs
index a7f3cad5f..78b6f5515 100644
--- a/crates/typst-layout/src/math/attach.rs
+++ b/crates/typst-layout/src/math/attach.rs
@@ -31,16 +31,16 @@ pub fn layout_attach(
     let mut base = ctx.layout_into_fragment(&elem.base, styles)?;
     let sup_style = style_for_superscript(styles);
     let sup_style_chain = styles.chain(&sup_style);
-    let tl = elem.tl(sup_style_chain);
-    let tr = elem.tr(sup_style_chain);
+    let tl = elem.tl.get_cloned(sup_style_chain);
+    let tr = elem.tr.get_cloned(sup_style_chain);
     let primed = tr.as_ref().is_some_and(|content| content.is::<PrimesElem>());
-    let t = elem.t(sup_style_chain);
+    let t = elem.t.get_cloned(sup_style_chain);
 
     let sub_style = style_for_subscript(styles);
     let sub_style_chain = styles.chain(&sub_style);
-    let bl = elem.bl(sub_style_chain);
-    let br = elem.br(sub_style_chain);
-    let b = elem.b(sub_style_chain);
+    let bl = elem.bl.get_cloned(sub_style_chain);
+    let br = elem.br.get_cloned(sub_style_chain);
+    let b = elem.b.get_cloned(sub_style_chain);
 
     let limits = base.limits().active(styles);
     let (t, tr) = match (t, tr) {
@@ -146,7 +146,7 @@ pub fn layout_limits(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<()> {
-    let limits = if elem.inline(styles) { Limits::Always } else { Limits::Display };
+    let limits = if elem.inline.get(styles) { Limits::Always } else { Limits::Display };
     let mut fragment = ctx.layout_into_fragment(&elem.body, styles)?;
     fragment.set_limits(limits);
     ctx.push(fragment);
@@ -161,7 +161,8 @@ fn stretch_size(styles: StyleChain, elem: &Packed<AttachElem>) -> Option<Rel<Abs
         base = &equation.body;
     }
 
-    base.to_packed::<StretchElem>().map(|stretch| stretch.size(styles))
+    base.to_packed::<StretchElem>()
+        .map(|stretch| stretch.size.resolve(styles))
 }
 
 /// Lay out the attachments.
@@ -397,7 +398,7 @@ fn compute_script_shifts(
     base: &MathFragment,
     [tl, tr, bl, br]: [&Option<MathFragment>; 4],
 ) -> (Abs, Abs) {
-    let sup_shift_up = if EquationElem::cramped_in(styles) {
+    let sup_shift_up = if styles.get(EquationElem::cramped) {
         scaled!(ctx, styles, superscript_shift_up_cramped)
     } else {
         scaled!(ctx, styles, superscript_shift_up)
diff --git a/crates/typst-layout/src/math/cancel.rs b/crates/typst-layout/src/math/cancel.rs
index 9826397fa..57a32ca2a 100644
--- a/crates/typst-layout/src/math/cancel.rs
+++ b/crates/typst-layout/src/math/cancel.rs
@@ -27,16 +27,16 @@ pub fn layout_cancel(
     let mut body = body.into_frame();
     let body_size = body.size();
     let span = elem.span();
-    let length = elem.length(styles);
+    let length = elem.length.resolve(styles);
 
-    let stroke = elem.stroke(styles).unwrap_or(FixedStroke {
-        paint: TextElem::fill_in(styles).as_decoration(),
+    let stroke = elem.stroke.resolve(styles).unwrap_or(FixedStroke {
+        paint: styles.get_ref(TextElem::fill).as_decoration(),
         ..Default::default()
     });
 
-    let invert = elem.inverted(styles);
-    let cross = elem.cross(styles);
-    let angle = elem.angle(styles);
+    let invert = elem.inverted.get(styles);
+    let cross = elem.cross.get(styles);
+    let angle = elem.angle.get_ref(styles);
 
     let invert_first_line = !cross && invert;
     let first_line = draw_cancel_line(
@@ -44,7 +44,7 @@ pub fn layout_cancel(
         length,
         stroke.clone(),
         invert_first_line,
-        &angle,
+        angle,
         body_size,
         styles,
         span,
@@ -57,7 +57,7 @@ pub fn layout_cancel(
     if cross {
         // Draw the second line.
         let second_line =
-            draw_cancel_line(ctx, length, stroke, true, &angle, body_size, styles, span)?;
+            draw_cancel_line(ctx, length, stroke, true, angle, body_size, styles, span)?;
 
         body.push_frame(center, second_line);
     }
diff --git a/crates/typst-layout/src/math/frac.rs b/crates/typst-layout/src/math/frac.rs
index 091f328f6..12a2c6fd1 100644
--- a/crates/typst-layout/src/math/frac.rs
+++ b/crates/typst-layout/src/math/frac.rs
@@ -124,7 +124,7 @@ fn layout_frac_like(
             FrameItem::Shape(
                 Geometry::Line(Point::with_x(line_width)).stroked(
                     FixedStroke::from_pair(
-                        TextElem::fill_in(styles).as_decoration(),
+                        styles.get_ref(TextElem::fill).as_decoration(),
                         thickness,
                     ),
                 ),
diff --git a/crates/typst-layout/src/math/fragment.rs b/crates/typst-layout/src/math/fragment.rs
index c5891f7d5..758dd401f 100644
--- a/crates/typst-layout/src/math/fragment.rs
+++ b/crates/typst-layout/src/math/fragment.rs
@@ -315,7 +315,8 @@ impl GlyphFragment {
         let cluster = info.cluster as usize;
         let c = text[cluster..].chars().next().unwrap();
         let limits = Limits::for_char(c);
-        let class = EquationElem::class_in(styles)
+        let class = styles
+            .get(EquationElem::class)
             .or_else(|| default_math_class(c))
             .unwrap_or(MathClass::Normal);
 
@@ -331,11 +332,11 @@ impl GlyphFragment {
 
         let item = TextItem {
             font: font.clone(),
-            size: TextElem::size_in(styles),
-            fill: TextElem::fill_in(styles).as_decoration(),
-            stroke: TextElem::stroke_in(styles).map(|s| s.unwrap_or_default()),
-            lang: TextElem::lang_in(styles),
-            region: TextElem::region_in(styles),
+            size: styles.resolve(TextElem::size),
+            fill: styles.get_ref(TextElem::fill).as_decoration(),
+            stroke: styles.resolve(TextElem::stroke).map(|s| s.unwrap_or_default()),
+            lang: styles.get(TextElem::lang),
+            region: styles.get(TextElem::region),
             text: text.into(),
             glyphs: vec![glyph.clone()],
         };
@@ -344,7 +345,7 @@ impl GlyphFragment {
             item,
             base_glyph: glyph,
             // Math
-            math_size: EquationElem::size_in(styles),
+            math_size: styles.get(EquationElem::size),
             class,
             limits,
             mid_stretched: None,
@@ -356,7 +357,7 @@ impl GlyphFragment {
             baseline: None,
             // Misc
             align: Abs::zero(),
-            shift: TextElem::baseline_in(styles),
+            shift: styles.resolve(TextElem::baseline),
             modifiers: FrameModifiers::get_in(styles),
         };
         fragment.update_glyph();
@@ -541,9 +542,9 @@ impl FrameFragment {
         let accent_attach = frame.width() / 2.0;
         Self {
             frame: frame.modified(&FrameModifiers::get_in(styles)),
-            font_size: TextElem::size_in(styles),
-            class: EquationElem::class_in(styles).unwrap_or(MathClass::Normal),
-            math_size: EquationElem::size_in(styles),
+            font_size: styles.resolve(TextElem::size),
+            class: styles.get(EquationElem::class).unwrap_or(MathClass::Normal),
+            math_size: styles.get(EquationElem::size),
             limits: Limits::Never,
             spaced: false,
             base_ascent,
@@ -864,7 +865,7 @@ impl Limits {
     pub fn active(&self, styles: StyleChain) -> bool {
         match self {
             Self::Always => true,
-            Self::Display => EquationElem::size_in(styles) == MathSize::Display,
+            Self::Display => styles.get(EquationElem::size) == MathSize::Display,
             Self::Never => false,
         }
     }
diff --git a/crates/typst-layout/src/math/lr.rs b/crates/typst-layout/src/math/lr.rs
index a3b5cb05c..2348025e8 100644
--- a/crates/typst-layout/src/math/lr.rs
+++ b/crates/typst-layout/src/math/lr.rs
@@ -22,7 +22,7 @@ pub fn layout_lr(
 
     // Extract implicit LrElem.
     if let Some(lr) = body.to_packed::<LrElem>() {
-        if lr.size(styles).is_one() {
+        if lr.size.get(styles).is_one() {
             body = &lr.body;
         }
     }
@@ -41,7 +41,7 @@ pub fn layout_lr(
         .unwrap_or_default();
 
     let relative_to = 2.0 * max_extent;
-    let height = elem.size(styles);
+    let height = elem.size.resolve(styles);
 
     // Scale up fragments at both ends.
     match inner_fragments {
diff --git a/crates/typst-layout/src/math/mat.rs b/crates/typst-layout/src/math/mat.rs
index 278b1343e..4a897a03e 100644
--- a/crates/typst-layout/src/math/mat.rs
+++ b/crates/typst-layout/src/math/mat.rs
@@ -30,15 +30,15 @@ pub fn layout_vec(
         ctx,
         styles,
         &[column],
-        elem.align(styles),
+        elem.align.resolve(styles),
         LeftRightAlternator::Right,
         None,
-        Axes::with_y(elem.gap(styles)),
+        Axes::with_y(elem.gap.resolve(styles)),
         span,
         "elements",
     )?;
 
-    let delim = elem.delim(styles);
+    let delim = elem.delim.get(styles);
     layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span)
 }
 
@@ -59,14 +59,17 @@ pub fn layout_cases(
         FixedAlignment::Start,
         LeftRightAlternator::None,
         None,
-        Axes::with_y(elem.gap(styles)),
+        Axes::with_y(elem.gap.resolve(styles)),
         span,
         "branches",
     )?;
 
-    let delim = elem.delim(styles);
-    let (open, close) =
-        if elem.reverse(styles) { (None, delim.close()) } else { (delim.open(), None) };
+    let delim = elem.delim.get(styles);
+    let (open, close) = if elem.reverse.get(styles) {
+        (None, delim.close())
+    } else {
+        (delim.open(), None)
+    };
     layout_delimiters(ctx, styles, frame, open, close, span)
 }
 
@@ -81,7 +84,7 @@ pub fn layout_mat(
     let rows = &elem.rows;
     let ncols = rows.first().map_or(0, |row| row.len());
 
-    let augment = elem.augment(styles);
+    let augment = elem.augment.resolve(styles);
     if let Some(aug) = &augment {
         for &offset in &aug.hline.0 {
             if offset == 0 || offset.unsigned_abs() >= rows.len() {
@@ -116,15 +119,15 @@ pub fn layout_mat(
         ctx,
         styles,
         &columns,
-        elem.align(styles),
+        elem.align.resolve(styles),
         LeftRightAlternator::Right,
         augment,
-        Axes::new(elem.column_gap(styles), elem.row_gap(styles)),
+        Axes::new(elem.column_gap.resolve(styles), elem.row_gap.resolve(styles)),
         span,
         "cells",
     )?;
 
-    let delim = elem.delim(styles);
+    let delim = elem.delim.get(styles);
     layout_delimiters(ctx, styles, frame, delim.open(), delim.close(), span)
 }
 
@@ -157,7 +160,7 @@ fn layout_body(
     let default_stroke_thickness = DEFAULT_STROKE_THICKNESS.resolve(styles);
     let default_stroke = FixedStroke {
         thickness: default_stroke_thickness,
-        paint: TextElem::fill_in(styles).as_decoration(),
+        paint: styles.get_ref(TextElem::fill).as_decoration(),
         cap: LineCap::Square,
         ..Default::default()
     };
diff --git a/crates/typst-layout/src/math/mod.rs b/crates/typst-layout/src/math/mod.rs
index 5fd22e578..390835067 100644
--- a/crates/typst-layout/src/math/mod.rs
+++ b/crates/typst-layout/src/math/mod.rs
@@ -51,7 +51,7 @@ pub fn layout_equation_inline(
     styles: StyleChain,
     region: Size,
 ) -> SourceResult<Vec<InlineItem>> {
-    assert!(!elem.block(styles));
+    assert!(!elem.block.get(styles));
 
     let font = find_math_font(engine, styles, elem.span())?;
 
@@ -78,12 +78,12 @@ pub fn layout_equation_inline(
     for item in &mut items {
         let InlineItem::Frame(frame) = item else { continue };
 
-        let slack = ParElem::leading_in(styles) * 0.7;
+        let slack = styles.resolve(ParElem::leading) * 0.7;
 
         let (t, b) = font.edges(
-            TextElem::top_edge_in(styles),
-            TextElem::bottom_edge_in(styles),
-            TextElem::size_in(styles),
+            styles.get(TextElem::top_edge),
+            styles.get(TextElem::bottom_edge),
+            styles.resolve(TextElem::size),
             TextEdgeBounds::Frame(frame),
         );
 
@@ -105,7 +105,7 @@ pub fn layout_equation_block(
     styles: StyleChain,
     regions: Regions,
 ) -> SourceResult<Fragment> {
-    assert!(elem.block(styles));
+    assert!(elem.block.get(styles));
 
     let span = elem.span();
     let font = find_math_font(engine, styles, span)?;
@@ -121,7 +121,7 @@ pub fn layout_equation_block(
         .multiline_frame_builder(styles);
     let width = full_equation_builder.size.x;
 
-    let equation_builders = if BlockElem::breakable_in(styles) {
+    let equation_builders = if styles.get(BlockElem::breakable) {
         let mut rows = full_equation_builder.frames.into_iter().peekable();
         let mut equation_builders = vec![];
         let mut last_first_pos = Point::zero();
@@ -188,7 +188,7 @@ pub fn layout_equation_block(
         vec![full_equation_builder]
     };
 
-    let Some(numbering) = (**elem).numbering(styles) else {
+    let Some(numbering) = elem.numbering.get_ref(styles) else {
         let frames = equation_builders
             .into_iter()
             .map(MathRunFrameBuilder::build)
@@ -197,7 +197,7 @@ pub fn layout_equation_block(
     };
 
     let pod = Region::new(regions.base(), Axes::splat(false));
-    let counter = Counter::of(EquationElem::elem())
+    let counter = Counter::of(EquationElem::ELEM)
         .display_at_loc(engine, elem.location().unwrap(), styles, numbering)?
         .spanned(span);
     let number = crate::layout_frame(engine, &counter, locator.next(&()), styles, pod)?;
@@ -205,7 +205,7 @@ pub fn layout_equation_block(
     static NUMBER_GUTTER: Em = Em::new(0.5);
     let full_number_width = number.width() + NUMBER_GUTTER.resolve(styles);
 
-    let number_align = match elem.number_align(styles) {
+    let number_align = match elem.number_align.get(styles) {
         SpecificAlignment::H(h) => SpecificAlignment::Both(h, VAlignment::Horizon),
         SpecificAlignment::V(v) => SpecificAlignment::Both(OuterHAlignment::End, v),
         SpecificAlignment::Both(h, v) => SpecificAlignment::Both(h, v),
@@ -224,7 +224,7 @@ pub fn layout_equation_block(
                 builder,
                 number.clone(),
                 number_align.resolve(styles),
-                AlignElem::alignment_in(styles).resolve(styles).x,
+                styles.get(AlignElem::alignment).resolve(styles).x,
                 regions.size.x,
                 full_number_width,
             )
@@ -472,7 +472,9 @@ impl<'a, 'v, 'e> MathContext<'a, 'v, 'e> {
         let outer = styles;
         for (elem, styles) in pairs {
             // Hack because the font is fixed in math.
-            if styles != outer && TextElem::font_in(styles) != TextElem::font_in(outer) {
+            if styles != outer
+                && styles.get_ref(TextElem::font) != outer.get_ref(TextElem::font)
+            {
                 let frame = layout_external(elem, self, styles)?;
                 self.push(FrameFragment::new(styles, frame).with_spaced(true));
                 continue;
@@ -603,7 +605,10 @@ fn layout_h(
 ) -> SourceResult<()> {
     if let Spacing::Rel(rel) = elem.amount {
         if rel.rel.is_zero() {
-            ctx.push(MathFragment::Spacing(rel.abs.resolve(styles), elem.weak(styles)));
+            ctx.push(MathFragment::Spacing(
+                rel.abs.resolve(styles),
+                elem.weak.get(styles),
+            ));
         }
     }
     Ok(())
@@ -616,7 +621,7 @@ fn layout_class(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<()> {
-    let style = EquationElem::set_class(Some(elem.class)).wrap();
+    let style = EquationElem::class.set(Some(elem.class)).wrap();
     let mut fragment = ctx.layout_into_fragment(&elem.body, styles.chain(&style))?;
     fragment.set_class(elem.class);
     fragment.set_limits(Limits::for_class(elem.class));
@@ -642,7 +647,7 @@ fn layout_op(
             .with_italics_correction(italics)
             .with_accent_attach(accent_attach)
             .with_text_like(text_like)
-            .with_limits(if elem.limits(styles) {
+            .with_limits(if elem.limits.get(styles) {
                 Limits::Display
             } else {
                 Limits::Never
diff --git a/crates/typst-layout/src/math/root.rs b/crates/typst-layout/src/math/root.rs
index 91b9b16af..30948e08e 100644
--- a/crates/typst-layout/src/math/root.rs
+++ b/crates/typst-layout/src/math/root.rs
@@ -17,7 +17,7 @@ pub fn layout_root(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<()> {
-    let index = elem.index(styles);
+    let index = elem.index.get_ref(styles);
     let span = elem.span();
 
     let gap = scaled!(
@@ -54,7 +54,7 @@ pub fn layout_root(
     let sqrt = sqrt.into_frame();
 
     // Layout the index.
-    let sscript = EquationElem::set_size(MathSize::ScriptScript).wrap();
+    let sscript = EquationElem::size.set(MathSize::ScriptScript).wrap();
     let index = index
         .as_ref()
         .map(|elem| ctx.layout_into_frame(elem, styles.chain(&sscript)))
@@ -112,7 +112,7 @@ pub fn layout_root(
         FrameItem::Shape(
             Geometry::Line(Point::with_x(radicand.width())).stroked(
                 FixedStroke::from_pair(
-                    TextElem::fill_in(styles).as_decoration(),
+                    styles.get_ref(TextElem::fill).as_decoration(),
                     thickness,
                 ),
             ),
diff --git a/crates/typst-layout/src/math/run.rs b/crates/typst-layout/src/math/run.rs
index 4ec76c253..161fa1062 100644
--- a/crates/typst-layout/src/math/run.rs
+++ b/crates/typst-layout/src/math/run.rs
@@ -194,13 +194,13 @@ impl MathRun {
         let row_count = rows.len();
         let alignments = alignments(&rows);
 
-        let leading = if EquationElem::size_in(styles) >= MathSize::Text {
-            ParElem::leading_in(styles)
+        let leading = if styles.get(EquationElem::size) >= MathSize::Text {
+            styles.resolve(ParElem::leading)
         } else {
             TIGHT_LEADING.resolve(styles)
         };
 
-        let align = AlignElem::alignment_in(styles).resolve(styles).x;
+        let align = styles.resolve(AlignElem::alignment).x;
         let mut frames: Vec<(Frame, Point)> = vec![];
         let mut size = Size::zero();
         for (i, row) in rows.into_iter().enumerate() {
diff --git a/crates/typst-layout/src/math/shared.rs b/crates/typst-layout/src/math/shared.rs
index 1f88d2dd7..c9d20aa68 100644
--- a/crates/typst-layout/src/math/shared.rs
+++ b/crates/typst-layout/src/math/shared.rs
@@ -10,7 +10,7 @@ use super::{LeftRightAlternator, MathContext, MathFragment, MathRun};
 
 macro_rules! scaled {
     ($ctx:expr, $styles:expr, text: $text:ident, display: $display:ident $(,)?) => {
-        match typst_library::math::EquationElem::size_in($styles) {
+        match $styles.get(typst_library::math::EquationElem::size) {
             typst_library::math::MathSize::Display => scaled!($ctx, $styles, $display),
             _ => scaled!($ctx, $styles, $text),
         }
@@ -19,7 +19,7 @@ macro_rules! scaled {
         $crate::math::Scaled::scaled(
             $ctx.constants.$name(),
             $ctx,
-            typst_library::text::TextElem::size_in($styles),
+            $styles.resolve(typst_library::text::TextElem::size),
         )
     };
 }
@@ -58,55 +58,62 @@ impl Scaled for MathValue<'_> {
 
 /// Styles something as cramped.
 pub fn style_cramped() -> LazyHash<Style> {
-    EquationElem::set_cramped(true).wrap()
+    EquationElem::cramped.set(true).wrap()
 }
 
 /// Sets flac OpenType feature.
 pub fn style_flac() -> LazyHash<Style> {
-    TextElem::set_features(FontFeatures(vec![(Tag::from_bytes(b"flac"), 1)])).wrap()
+    TextElem::features
+        .set(FontFeatures(vec![(Tag::from_bytes(b"flac"), 1)]))
+        .wrap()
 }
 
 /// Sets dtls OpenType feature.
 pub fn style_dtls() -> LazyHash<Style> {
-    TextElem::set_features(FontFeatures(vec![(Tag::from_bytes(b"dtls"), 1)])).wrap()
+    TextElem::features
+        .set(FontFeatures(vec![(Tag::from_bytes(b"dtls"), 1)]))
+        .wrap()
 }
 
 /// The style for subscripts in the current style.
 pub fn style_for_subscript(styles: StyleChain) -> [LazyHash<Style>; 2] {
-    [style_for_superscript(styles), EquationElem::set_cramped(true).wrap()]
+    [style_for_superscript(styles), EquationElem::cramped.set(true).wrap()]
 }
 
 /// The style for superscripts in the current style.
 pub fn style_for_superscript(styles: StyleChain) -> LazyHash<Style> {
-    EquationElem::set_size(match EquationElem::size_in(styles) {
-        MathSize::Display | MathSize::Text => MathSize::Script,
-        MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
-    })
-    .wrap()
+    EquationElem::size
+        .set(match styles.get(EquationElem::size) {
+            MathSize::Display | MathSize::Text => MathSize::Script,
+            MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
+        })
+        .wrap()
 }
 
 /// The style for numerators in the current style.
 pub fn style_for_numerator(styles: StyleChain) -> LazyHash<Style> {
-    EquationElem::set_size(match EquationElem::size_in(styles) {
-        MathSize::Display => MathSize::Text,
-        MathSize::Text => MathSize::Script,
-        MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
-    })
-    .wrap()
+    EquationElem::size
+        .set(match styles.get(EquationElem::size) {
+            MathSize::Display => MathSize::Text,
+            MathSize::Text => MathSize::Script,
+            MathSize::Script | MathSize::ScriptScript => MathSize::ScriptScript,
+        })
+        .wrap()
 }
 
 /// The style for denominators in the current style.
 pub fn style_for_denominator(styles: StyleChain) -> [LazyHash<Style>; 2] {
-    [style_for_numerator(styles), EquationElem::set_cramped(true).wrap()]
+    [style_for_numerator(styles), EquationElem::cramped.set(true).wrap()]
 }
 
 /// Styles to add font constants to the style chain.
 pub fn style_for_script_scale(ctx: &MathContext) -> LazyHash<Style> {
-    EquationElem::set_script_scale((
-        ctx.constants.script_percent_scale_down(),
-        ctx.constants.script_script_percent_scale_down(),
-    ))
-    .wrap()
+    EquationElem::script_scale
+        .set((
+            ctx.constants.script_percent_scale_down(),
+            ctx.constants.script_script_percent_scale_down(),
+        ))
+        .wrap()
 }
 
 /// Stack rows on top of each other.
diff --git a/crates/typst-layout/src/math/stretch.rs b/crates/typst-layout/src/math/stretch.rs
index d4370e7b9..f1a22a814 100644
--- a/crates/typst-layout/src/math/stretch.rs
+++ b/crates/typst-layout/src/math/stretch.rs
@@ -14,7 +14,14 @@ pub fn layout_stretch(
     styles: StyleChain,
 ) -> SourceResult<()> {
     let mut fragment = ctx.layout_into_fragment(&elem.body, styles)?;
-    stretch_fragment(ctx, &mut fragment, None, None, elem.size(styles), Abs::zero());
+    stretch_fragment(
+        ctx,
+        &mut fragment,
+        None,
+        None,
+        elem.size.resolve(styles),
+        Abs::zero(),
+    );
     ctx.push(fragment);
     Ok(())
 }
diff --git a/crates/typst-layout/src/math/text.rs b/crates/typst-layout/src/math/text.rs
index 67dc0a2c8..53f88f2b6 100644
--- a/crates/typst-layout/src/math/text.rs
+++ b/crates/typst-layout/src/math/text.rs
@@ -77,8 +77,8 @@ fn layout_inline_text(
         Ok(FrameFragment::new(styles, frame).with_text_like(true))
     } else {
         let local = [
-            TextElem::set_top_edge(TopEdge::Metric(TopEdgeMetric::Bounds)),
-            TextElem::set_bottom_edge(BottomEdge::Metric(BottomEdgeMetric::Bounds)),
+            TextElem::top_edge.set(TopEdge::Metric(TopEdgeMetric::Bounds)),
+            TextElem::bottom_edge.set(BottomEdge::Metric(BottomEdgeMetric::Bounds)),
         ]
         .map(|p| p.wrap());
 
@@ -150,7 +150,7 @@ fn adjust_glyph_layout(
     styles: StyleChain,
 ) {
     if glyph.class == MathClass::Large {
-        if EquationElem::size_in(styles) == MathSize::Display {
+        if styles.get(EquationElem::size) == MathSize::Display {
             let height = scaled!(ctx, styles, display_operator_min_height)
                 .max(SQRT_2 * glyph.size.y);
             glyph.stretch_vertical(ctx, height);
@@ -169,9 +169,9 @@ fn adjust_glyph_layout(
 fn styled_char(styles: StyleChain, c: char, auto_italic: bool) -> char {
     use MathVariant::*;
 
-    let variant = EquationElem::variant_in(styles);
-    let bold = EquationElem::bold_in(styles);
-    let italic = EquationElem::italic_in(styles).unwrap_or(
+    let variant = styles.get(EquationElem::variant);
+    let bold = styles.get(EquationElem::bold);
+    let italic = styles.get(EquationElem::italic).unwrap_or(
         auto_italic
             && matches!(
                 c,
diff --git a/crates/typst-layout/src/math/underover.rs b/crates/typst-layout/src/math/underover.rs
index c29d99478..1e1aeb41d 100644
--- a/crates/typst-layout/src/math/underover.rs
+++ b/crates/typst-layout/src/math/underover.rs
@@ -56,7 +56,7 @@ pub fn layout_underbrace(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⏟',
         BRACE_GAP,
         Position::Under,
@@ -75,7 +75,7 @@ pub fn layout_overbrace(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⏞',
         BRACE_GAP,
         Position::Over,
@@ -94,7 +94,7 @@ pub fn layout_underbracket(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⎵',
         BRACKET_GAP,
         Position::Under,
@@ -113,7 +113,7 @@ pub fn layout_overbracket(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⎴',
         BRACKET_GAP,
         Position::Over,
@@ -132,7 +132,7 @@ pub fn layout_underparen(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⏝',
         PAREN_GAP,
         Position::Under,
@@ -151,7 +151,7 @@ pub fn layout_overparen(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⏜',
         PAREN_GAP,
         Position::Over,
@@ -170,7 +170,7 @@ pub fn layout_undershell(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⏡',
         SHELL_GAP,
         Position::Under,
@@ -189,7 +189,7 @@ pub fn layout_overshell(
         ctx,
         styles,
         &elem.body,
-        &elem.annotation(styles),
+        elem.annotation.get_ref(styles),
         '⏠',
         SHELL_GAP,
         Position::Over,
@@ -251,7 +251,7 @@ fn layout_underoverline(
         line_pos,
         FrameItem::Shape(
             Geometry::Line(Point::with_x(line_width)).stroked(FixedStroke {
-                paint: TextElem::fill_in(styles).as_decoration(),
+                paint: styles.get_ref(TextElem::fill).as_decoration(),
                 thickness: bar_height,
                 ..FixedStroke::default()
             }),
diff --git a/crates/typst-layout/src/modifiers.rs b/crates/typst-layout/src/modifiers.rs
index b0371d63e..57d70302e 100644
--- a/crates/typst-layout/src/modifiers.rs
+++ b/crates/typst-layout/src/modifiers.rs
@@ -29,8 +29,8 @@ impl FrameModifiers {
     /// Retrieve all modifications that should be applied per-frame.
     pub fn get_in(styles: StyleChain) -> Self {
         Self {
-            dest: LinkElem::current_in(styles),
-            hidden: HideElem::hidden_in(styles),
+            dest: styles.get_cloned(LinkElem::current),
+            hidden: styles.get(HideElem::hidden),
         }
     }
 }
@@ -83,7 +83,7 @@ pub trait FrameModifyText {
 impl FrameModifyText for Frame {
     fn modify_text(&mut self, styles: StyleChain) {
         let modifiers = FrameModifiers::get_in(styles);
-        let expand_y = 0.5 * ParElem::leading_in(styles);
+        let expand_y = 0.5 * styles.resolve(ParElem::leading);
         let outset = Sides::new(Abs::zero(), expand_y, Abs::zero(), expand_y);
         modify_frame(self, &modifiers, Some(outset));
     }
@@ -130,7 +130,7 @@ where
     let outer = styles;
     let mut styles = styles;
     if modifiers.dest.is_some() {
-        reset = LinkElem::set_current(None).wrap();
+        reset = LinkElem::current.set(None).wrap();
         styles = outer.chain(&reset);
     }
 
diff --git a/crates/typst-layout/src/pad.rs b/crates/typst-layout/src/pad.rs
index 00badcdb8..b69e0de43 100644
--- a/crates/typst-layout/src/pad.rs
+++ b/crates/typst-layout/src/pad.rs
@@ -1,6 +1,6 @@
 use typst_library::diag::SourceResult;
 use typst_library::engine::Engine;
-use typst_library::foundations::{Packed, Resolve, StyleChain};
+use typst_library::foundations::{Packed, StyleChain};
 use typst_library::introspection::Locator;
 use typst_library::layout::{
     Abs, Fragment, Frame, PadElem, Point, Regions, Rel, Sides, Size,
@@ -16,10 +16,10 @@ pub fn layout_pad(
     regions: Regions,
 ) -> SourceResult<Fragment> {
     let padding = Sides::new(
-        elem.left(styles).resolve(styles),
-        elem.top(styles).resolve(styles),
-        elem.right(styles).resolve(styles),
-        elem.bottom(styles).resolve(styles),
+        elem.left.resolve(styles),
+        elem.top.resolve(styles),
+        elem.right.resolve(styles),
+        elem.bottom.resolve(styles),
     );
 
     let mut backlog = vec![];
diff --git a/crates/typst-layout/src/pages/collect.rs b/crates/typst-layout/src/pages/collect.rs
index 8eab18a62..64167d080 100644
--- a/crates/typst-layout/src/pages/collect.rs
+++ b/crates/typst-layout/src/pages/collect.rs
@@ -39,14 +39,14 @@ pub fn collect<'a>(
         if let Some(pagebreak) = elem.to_packed::<PagebreakElem>() {
             // Add a blank page if we encounter a strong pagebreak and there was
             // a staged empty page.
-            let strong = !pagebreak.weak(styles);
+            let strong = !pagebreak.weak.get(styles);
             if strong && staged_empty_page {
                 let locator = locator.next(&elem.span());
                 items.push(Item::Run(&[], initial, locator));
             }
 
             // Add an instruction to adjust the page parity if requested.
-            if let Some(parity) = pagebreak.to(styles) {
+            if let Some(parity) = pagebreak.to.get(styles) {
                 let locator = locator.next(&elem.span());
                 items.push(Item::Parity(parity, styles, locator));
             }
@@ -56,7 +56,7 @@ pub fn collect<'a>(
             // the scope of a page set rule to ensure a page boundary. Its
             // styles correspond to the styles _before_ the page set rule, so we
             // don't want to apply it to a potential empty page.
-            if !pagebreak.boundary(styles) {
+            if !pagebreak.boundary.get(styles) {
                 initial = styles;
             }
 
@@ -94,7 +94,7 @@ pub fn collect<'a>(
             if group.iter().all(|(c, _)| c.is::<TagElem>())
                 && !(staged_empty_page
                     && children.iter().all(|&(c, s)| {
-                        c.to_packed::<PagebreakElem>().is_some_and(|c| c.boundary(s))
+                        c.to_packed::<PagebreakElem>().is_some_and(|c| c.boundary.get(s))
                     }))
             {
                 items.push(Item::Tags(group));
diff --git a/crates/typst-layout/src/pages/run.rs b/crates/typst-layout/src/pages/run.rs
index 6d2d29da5..8c1a34ed5 100644
--- a/crates/typst-layout/src/pages/run.rs
+++ b/crates/typst-layout/src/pages/run.rs
@@ -101,10 +101,10 @@ fn layout_page_run_impl(
 
     // When one of the lengths is infinite the page fits its content along
     // that axis.
-    let width = PageElem::width_in(styles).unwrap_or(Abs::inf());
-    let height = PageElem::height_in(styles).unwrap_or(Abs::inf());
+    let width = styles.resolve(PageElem::width).unwrap_or(Abs::inf());
+    let height = styles.resolve(PageElem::height).unwrap_or(Abs::inf());
     let mut size = Size::new(width, height);
-    if PageElem::flipped_in(styles) {
+    if styles.get(PageElem::flipped) {
         std::mem::swap(&mut size.x, &mut size.y);
     }
 
@@ -115,7 +115,7 @@ fn layout_page_run_impl(
 
     // Determine the margins.
     let default = Rel::<Length>::from((2.5 / 21.0) * min);
-    let margin = PageElem::margin_in(styles);
+    let margin = styles.get(PageElem::margin);
     let two_sided = margin.two_sided.unwrap_or(false);
     let margin = margin
         .sides
@@ -123,22 +123,24 @@ fn layout_page_run_impl(
         .resolve(styles)
         .relative_to(size);
 
-    let fill = PageElem::fill_in(styles);
-    let foreground = PageElem::foreground_in(styles);
-    let background = PageElem::background_in(styles);
-    let header_ascent = PageElem::header_ascent_in(styles).relative_to(margin.top);
-    let footer_descent = PageElem::footer_descent_in(styles).relative_to(margin.bottom);
-    let numbering = PageElem::numbering_in(styles);
-    let supplement = match PageElem::supplement_in(styles) {
+    let fill = styles.get_cloned(PageElem::fill);
+    let foreground = styles.get_ref(PageElem::foreground);
+    let background = styles.get_ref(PageElem::background);
+    let header_ascent = styles.resolve(PageElem::header_ascent).relative_to(margin.top);
+    let footer_descent =
+        styles.resolve(PageElem::footer_descent).relative_to(margin.bottom);
+    let numbering = styles.get_ref(PageElem::numbering);
+    let supplement = match styles.get_cloned(PageElem::supplement) {
         Smart::Auto => TextElem::packed(PageElem::local_name_in(styles)),
         Smart::Custom(content) => content.unwrap_or_default(),
     };
-    let number_align = PageElem::number_align_in(styles);
-    let binding =
-        PageElem::binding_in(styles).unwrap_or_else(|| match TextElem::dir_in(styles) {
+    let number_align = styles.get(PageElem::number_align);
+    let binding = styles.get(PageElem::binding).unwrap_or_else(|| {
+        match styles.resolve(TextElem::dir) {
             Dir::LTR => Binding::Left,
             _ => Binding::Right,
-        });
+        }
+    });
 
     // Construct the numbering (for header or footer).
     let numbering_marginal = numbering.as_ref().map(|numbering| {
@@ -163,8 +165,8 @@ fn layout_page_run_impl(
         counter
     });
 
-    let header = PageElem::header_in(styles);
-    let footer = PageElem::footer_in(styles);
+    let header = styles.get_ref(PageElem::header);
+    let footer = styles.get_ref(PageElem::footer);
     let (header, footer) = if matches!(number_align.y(), Some(OuterVAlignment::Top)) {
         (header.as_ref().unwrap_or(&numbering_marginal), footer.as_ref().unwrap_or(&None))
     } else {
@@ -179,15 +181,15 @@ fn layout_page_run_impl(
         &mut locator,
         styles,
         Regions::repeat(area, area.map(Abs::is_finite)),
-        PageElem::columns_in(styles),
-        ColumnsElem::gutter_in(styles),
+        styles.get(PageElem::columns),
+        styles.get(ColumnsElem::gutter).resolve(styles),
         FlowMode::Root,
     )?;
 
     // Layouts a single marginal.
     let mut layout_marginal = |content: &Option<Content>, area, align| {
         let Some(content) = content else { return Ok(None) };
-        let aligned = content.clone().styled(AlignElem::set_alignment(align));
+        let aligned = content.clone().set(AlignElem::alignment, align);
         crate::layout_frame(
             &mut engine,
             &aligned,
diff --git a/crates/typst-layout/src/repeat.rs b/crates/typst-layout/src/repeat.rs
index bfc7b32ce..40179c349 100644
--- a/crates/typst-layout/src/repeat.rs
+++ b/crates/typst-layout/src/repeat.rs
@@ -29,7 +29,7 @@ pub fn layout_repeat(
         frame.set_baseline(piece.baseline());
     }
 
-    let mut gap = elem.gap(styles).resolve(styles);
+    let mut gap = elem.gap.resolve(styles);
     let fill = region.size.x;
     let width = piece.width();
 
@@ -47,12 +47,12 @@ pub fn layout_repeat(
     let count = ((fill + gap) / (width + gap)).floor();
     let remaining = (fill + gap) % (width + gap);
 
-    let justify = elem.justify(styles);
+    let justify = elem.justify.get(styles);
     if justify {
         gap += remaining / (count - 1.0);
     }
 
-    let align = AlignElem::alignment_in(styles).resolve(styles);
+    let align = styles.get(AlignElem::alignment).resolve(styles);
     let mut offset = Abs::zero();
     if count == 1.0 || !justify {
         offset += align.x.position(remaining);
diff --git a/crates/typst-layout/src/shapes.rs b/crates/typst-layout/src/shapes.rs
index 0616b4ce4..1a9b38f25 100644
--- a/crates/typst-layout/src/shapes.rs
+++ b/crates/typst-layout/src/shapes.rs
@@ -27,16 +27,20 @@ pub fn layout_line(
     region: Region,
 ) -> SourceResult<Frame> {
     let resolve = |axes: Axes<Rel<Abs>>| axes.zip_map(region.size, Rel::relative_to);
-    let start = resolve(elem.start(styles));
-    let delta = elem.end(styles).map(|end| resolve(end) - start).unwrap_or_else(|| {
-        let length = elem.length(styles);
-        let angle = elem.angle(styles);
-        let x = angle.cos() * length;
-        let y = angle.sin() * length;
-        resolve(Axes::new(x, y))
-    });
+    let start = resolve(elem.start.resolve(styles));
+    let delta = elem
+        .end
+        .resolve(styles)
+        .map(|end| resolve(end) - start)
+        .unwrap_or_else(|| {
+            let length = elem.length.resolve(styles);
+            let angle = elem.angle.get(styles);
+            let x = angle.cos() * length;
+            let y = angle.sin() * length;
+            resolve(Axes::new(x, y))
+        });
 
-    let stroke = elem.stroke(styles).unwrap_or_default();
+    let stroke = elem.stroke.resolve(styles).unwrap_or_default();
     let size = start.max(start + delta).max(Size::zero());
 
     if !size.is_finite() {
@@ -105,7 +109,7 @@ pub fn layout_path(
         add_cubic(from_point, to_point, from, to);
     }
 
-    if elem.closed(styles) {
+    if elem.closed.get(styles) {
         let from = *vertices.last().unwrap(); // We checked that we have at least one element.
         let to = vertices[0];
         let from_point = *points.last().unwrap();
@@ -120,9 +124,9 @@ pub fn layout_path(
     }
 
     // Prepare fill and stroke.
-    let fill = elem.fill(styles);
-    let fill_rule = elem.fill_rule(styles);
-    let stroke = match elem.stroke(styles) {
+    let fill = elem.fill.get_cloned(styles);
+    let fill_rule = elem.fill_rule.get(styles);
+    let stroke = match elem.stroke.resolve(styles) {
         Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
         Smart::Auto => None,
         Smart::Custom(stroke) => stroke.map(Stroke::unwrap_or_default),
@@ -153,19 +157,19 @@ pub fn layout_curve(
     for item in &elem.components {
         match item {
             CurveComponent::Move(element) => {
-                let relative = element.relative(styles);
+                let relative = element.relative.get(styles);
                 let point = builder.resolve_point(element.start, relative);
                 builder.move_(point);
             }
 
             CurveComponent::Line(element) => {
-                let relative = element.relative(styles);
+                let relative = element.relative.get(styles);
                 let point = builder.resolve_point(element.end, relative);
                 builder.line(point);
             }
 
             CurveComponent::Quad(element) => {
-                let relative = element.relative(styles);
+                let relative = element.relative.get(styles);
                 let end = builder.resolve_point(element.end, relative);
                 let control = match element.control {
                     Smart::Auto => {
@@ -178,7 +182,7 @@ pub fn layout_curve(
             }
 
             CurveComponent::Cubic(element) => {
-                let relative = element.relative(styles);
+                let relative = element.relative.get(styles);
                 let end = builder.resolve_point(element.end, relative);
                 let c1 = match element.control_start {
                     Some(Smart::Custom(p)) => builder.resolve_point(p, relative),
@@ -193,7 +197,7 @@ pub fn layout_curve(
             }
 
             CurveComponent::Close(element) => {
-                builder.close(element.mode(styles));
+                builder.close(element.mode.get(styles));
             }
         }
     }
@@ -208,9 +212,9 @@ pub fn layout_curve(
     }
 
     // Prepare fill and stroke.
-    let fill = elem.fill(styles);
-    let fill_rule = elem.fill_rule(styles);
-    let stroke = match elem.stroke(styles) {
+    let fill = elem.fill.get_cloned(styles);
+    let fill_rule = elem.fill_rule.get(styles);
+    let stroke = match elem.stroke.resolve(styles) {
         Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
         Smart::Auto => None,
         Smart::Custom(stroke) => stroke.map(Stroke::unwrap_or_default),
@@ -418,9 +422,9 @@ pub fn layout_polygon(
     }
 
     // Prepare fill and stroke.
-    let fill = elem.fill(styles);
-    let fill_rule = elem.fill_rule(styles);
-    let stroke = match elem.stroke(styles) {
+    let fill = elem.fill.get_cloned(styles);
+    let fill_rule = elem.fill_rule.get(styles);
+    let stroke = match elem.stroke.resolve(styles) {
         Smart::Auto if fill.is_none() => Some(FixedStroke::default()),
         Smart::Auto => None,
         Smart::Custom(stroke) => stroke.map(Stroke::unwrap_or_default),
@@ -459,12 +463,12 @@ pub fn layout_rect(
         styles,
         region,
         ShapeKind::Rect,
-        elem.body(styles),
-        elem.fill(styles),
-        elem.stroke(styles),
-        elem.inset(styles),
-        elem.outset(styles),
-        elem.radius(styles),
+        elem.body.get_ref(styles),
+        elem.fill.get_cloned(styles),
+        elem.stroke.resolve(styles),
+        elem.inset.resolve(styles),
+        elem.outset.resolve(styles),
+        elem.radius.resolve(styles),
         elem.span(),
     )
 }
@@ -484,12 +488,12 @@ pub fn layout_square(
         styles,
         region,
         ShapeKind::Square,
-        elem.body(styles),
-        elem.fill(styles),
-        elem.stroke(styles),
-        elem.inset(styles),
-        elem.outset(styles),
-        elem.radius(styles),
+        elem.body.get_ref(styles),
+        elem.fill.get_cloned(styles),
+        elem.stroke.resolve(styles),
+        elem.inset.resolve(styles),
+        elem.outset.resolve(styles),
+        elem.radius.resolve(styles),
         elem.span(),
     )
 }
@@ -509,11 +513,11 @@ pub fn layout_ellipse(
         styles,
         region,
         ShapeKind::Ellipse,
-        elem.body(styles),
-        elem.fill(styles),
-        elem.stroke(styles).map(|s| Sides::splat(Some(s))),
-        elem.inset(styles),
-        elem.outset(styles),
+        elem.body.get_ref(styles),
+        elem.fill.get_cloned(styles),
+        elem.stroke.resolve(styles).map(|s| Sides::splat(Some(s))),
+        elem.inset.resolve(styles),
+        elem.outset.resolve(styles),
         Corners::splat(None),
         elem.span(),
     )
@@ -534,11 +538,11 @@ pub fn layout_circle(
         styles,
         region,
         ShapeKind::Circle,
-        elem.body(styles),
-        elem.fill(styles),
-        elem.stroke(styles).map(|s| Sides::splat(Some(s))),
-        elem.inset(styles),
-        elem.outset(styles),
+        elem.body.get_ref(styles),
+        elem.fill.get_cloned(styles),
+        elem.stroke.resolve(styles).map(|s| Sides::splat(Some(s))),
+        elem.inset.resolve(styles),
+        elem.outset.resolve(styles),
         Corners::splat(None),
         elem.span(),
     )
diff --git a/crates/typst-layout/src/stack.rs b/crates/typst-layout/src/stack.rs
index c468945eb..5df626fdf 100644
--- a/crates/typst-layout/src/stack.rs
+++ b/crates/typst-layout/src/stack.rs
@@ -19,12 +19,12 @@ pub fn layout_stack(
     regions: Regions,
 ) -> SourceResult<Fragment> {
     let mut layouter =
-        StackLayouter::new(elem.span(), elem.dir(styles), locator, styles, regions);
+        StackLayouter::new(elem.span(), elem.dir.get(styles), locator, styles, regions);
 
     let axis = layouter.dir.axis();
 
     // Spacing to insert before the next block.
-    let spacing = elem.spacing(styles);
+    let spacing = elem.spacing.get(styles);
     let mut deferred = None;
 
     for child in &elem.children {
@@ -167,11 +167,11 @@ impl<'a> StackLayouter<'a> {
 
         // Block-axis alignment of the `AlignElem` is respected by stacks.
         let align = if let Some(align) = block.to_packed::<AlignElem>() {
-            align.alignment(styles)
+            align.alignment.get(styles)
         } else if let Some(styled) = block.to_packed::<StyledElem>() {
-            AlignElem::alignment_in(styles.chain(&styled.styles))
+            styles.chain(&styled.styles).get(AlignElem::alignment)
         } else {
-            AlignElem::alignment_in(styles)
+            styles.get(AlignElem::alignment)
         }
         .resolve(styles);
 
diff --git a/crates/typst-layout/src/transforms.rs b/crates/typst-layout/src/transforms.rs
index f4526dd09..e545dd512 100644
--- a/crates/typst-layout/src/transforms.rs
+++ b/crates/typst-layout/src/transforms.rs
@@ -20,7 +20,7 @@ pub fn layout_move(
     region: Region,
 ) -> SourceResult<Frame> {
     let mut frame = crate::layout_frame(engine, &elem.body, locator, styles, region)?;
-    let delta = Axes::new(elem.dx(styles), elem.dy(styles)).resolve(styles);
+    let delta = Axes::new(elem.dx.resolve(styles), elem.dy.resolve(styles));
     let delta = delta.zip_map(region.size, Rel::relative_to);
     frame.translate(delta.to_point());
     Ok(frame)
@@ -35,8 +35,8 @@ pub fn layout_rotate(
     styles: StyleChain,
     region: Region,
 ) -> SourceResult<Frame> {
-    let angle = elem.angle(styles);
-    let align = elem.origin(styles).resolve(styles);
+    let angle = elem.angle.get(styles);
+    let align = elem.origin.resolve(styles);
 
     // Compute the new region's approximate size.
     let is_finite = region.size.is_finite();
@@ -55,7 +55,7 @@ pub fn layout_rotate(
         &elem.body,
         Transform::rotate(angle),
         align,
-        elem.reflow(styles),
+        elem.reflow.get(styles),
     )
 }
 
@@ -83,8 +83,8 @@ pub fn layout_scale(
         styles,
         &elem.body,
         Transform::scale(scale.x, scale.y),
-        elem.origin(styles).resolve(styles),
-        elem.reflow(styles),
+        elem.origin.resolve(styles),
+        elem.reflow.get(styles),
     )
 }
 
@@ -121,13 +121,13 @@ fn resolve_scale(
     });
 
     let x = resolve_axis(
-        elem.x(styles),
+        elem.x.get(styles),
         || size.as_ref().map(|size| size.x).map_err(Clone::clone),
         styles,
     )?;
 
     let y = resolve_axis(
-        elem.y(styles),
+        elem.y.get(styles),
         || size.as_ref().map(|size| size.y).map_err(Clone::clone),
         styles,
     )?;
@@ -152,9 +152,9 @@ pub fn layout_skew(
     styles: StyleChain,
     region: Region,
 ) -> SourceResult<Frame> {
-    let ax = elem.ax(styles);
-    let ay = elem.ay(styles);
-    let align = elem.origin(styles).resolve(styles);
+    let ax = elem.ax.get(styles);
+    let ay = elem.ay.get(styles);
+    let align = elem.origin.resolve(styles);
 
     // Compute the new region's approximate size.
     let size = if region.size.is_finite() {
@@ -172,7 +172,7 @@ pub fn layout_skew(
         &elem.body,
         Transform::skew(ax, ay),
         align,
-        elem.reflow(styles),
+        elem.reflow.get(styles),
     )
 }
 
diff --git a/crates/typst-library/src/foundations/element.rs b/crates/typst-library/src/foundations/content/element.rs
similarity index 53%
rename from crates/typst-library/src/foundations/element.rs
rename to crates/typst-library/src/foundations/content/element.rs
index 7ff00b9df..49b0b0f9b 100644
--- a/crates/typst-library/src/foundations/element.rs
+++ b/crates/typst-library/src/foundations/content/element.rs
@@ -2,52 +2,54 @@ use std::any::TypeId;
 use std::cmp::Ordering;
 use std::fmt::{self, Debug};
 use std::hash::Hash;
-use std::ptr::NonNull;
-use std::sync::LazyLock;
+use std::sync::OnceLock;
 
 use ecow::EcoString;
 use smallvec::SmallVec;
-#[doc(inline)]
-pub use typst_macros::elem;
 use typst_utils::Static;
 
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, Args, Content, Dict, FieldAccessError, Func, ParamInfo, Repr, Scope, Selector,
-    StyleChain, Styles, Value,
+    cast, Args, Content, ContentVtable, FieldAccessError, Func, ParamInfo, Repr, Scope,
+    Selector, StyleChain, Styles, Value,
 };
 use crate::text::{Lang, Region};
 
 /// A document element.
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
-pub struct Element(Static<NativeElementData>);
+pub struct Element(Static<ContentVtable>);
 
 impl Element {
     /// Get the element for `T`.
-    pub fn of<T: NativeElement>() -> Self {
-        T::elem()
+    pub const fn of<T: NativeElement>() -> Self {
+        T::ELEM
+    }
+
+    /// Get the element for `T`.
+    pub const fn from_vtable(vtable: &'static ContentVtable) -> Self {
+        Self(Static(vtable))
     }
 
     /// The element's normal name (e.g. `enum`).
     pub fn name(self) -> &'static str {
-        self.0.name
+        self.vtable().name
     }
 
     /// The element's title case name, for use in documentation
     /// (e.g. `Numbered List`).
     pub fn title(&self) -> &'static str {
-        self.0.title
+        self.vtable().title
     }
 
     /// Documentation for the element (as Markdown).
     pub fn docs(&self) -> &'static str {
-        self.0.docs
+        self.vtable().docs
     }
 
     /// Search keywords for the element.
     pub fn keywords(&self) -> &'static [&'static str] {
-        self.0.keywords
+        self.vtable().keywords
     }
 
     /// Construct an instance of this element.
@@ -56,12 +58,12 @@ impl Element {
         engine: &mut Engine,
         args: &mut Args,
     ) -> SourceResult<Content> {
-        (self.0.construct)(engine, args)
+        (self.vtable().construct)(engine, args)
     }
 
     /// Execute the set rule for the element and return the resulting style map.
     pub fn set(self, engine: &mut Engine, mut args: Args) -> SourceResult<Styles> {
-        let styles = (self.0.set)(engine, &mut args)?;
+        let styles = (self.vtable().set)(engine, &mut args)?;
         args.finish()?;
         Ok(styles)
     }
@@ -77,12 +79,7 @@ impl Element {
     /// Whether the element has the given capability where the capability is
     /// given by a `TypeId`.
     pub fn can_type_id(self, type_id: TypeId) -> bool {
-        (self.0.vtable)(type_id).is_some()
-    }
-
-    /// The VTable for capabilities dispatch.
-    pub fn vtable(self) -> fn(of: TypeId) -> Option<NonNull<()>> {
-        self.0.vtable
+        (self.vtable().capability)(type_id).is_some()
     }
 
     /// Create a selector for this element.
@@ -98,12 +95,29 @@ impl Element {
 
     /// The element's associated scope of sub-definition.
     pub fn scope(&self) -> &'static Scope {
-        &(self.0).0.scope
+        (self.vtable().store)().scope.get_or_init(|| (self.vtable().scope)())
     }
 
     /// Details about the element's fields.
     pub fn params(&self) -> &'static [ParamInfo] {
-        &(self.0).0.params
+        (self.vtable().store)().params.get_or_init(|| {
+            self.vtable()
+                .fields
+                .iter()
+                .filter(|field| !field.synthesized)
+                .map(|field| ParamInfo {
+                    name: field.name,
+                    docs: field.docs,
+                    input: (field.input)(),
+                    default: field.default,
+                    positional: field.positional,
+                    named: !field.positional,
+                    variadic: field.variadic,
+                    required: field.required,
+                    settable: field.settable,
+                })
+                .collect()
+        })
     }
 
     /// Extract the field ID for the given field name.
@@ -111,7 +125,7 @@ impl Element {
         if name == "label" {
             return Some(255);
         }
-        (self.0.field_id)(name)
+        (self.vtable().field_id)(name)
     }
 
     /// Extract the field name for the given field ID.
@@ -119,7 +133,7 @@ impl Element {
         if id == 255 {
             return Some("label");
         }
-        (self.0.field_name)(id)
+        self.vtable().field(id).map(|data| data.name)
     }
 
     /// Extract the value of the field for the given field ID and style chain.
@@ -128,12 +142,20 @@ impl Element {
         id: u8,
         styles: StyleChain,
     ) -> Result<Value, FieldAccessError> {
-        (self.0.field_from_styles)(id, styles)
+        self.vtable()
+            .field(id)
+            .and_then(|field| (field.get_from_styles)(styles))
+            .ok_or(FieldAccessError::Unknown)
     }
 
     /// The element's local name, if any.
     pub fn local_name(&self, lang: Lang, region: Option<Region>) -> Option<&'static str> {
-        (self.0).0.local_name.map(|f| f(lang, region))
+        self.vtable().local_name.map(|f| f(lang, region))
+    }
+
+    /// Retrieves the element's vtable for dynamic dispatch.
+    pub(super) fn vtable(&self) -> &'static ContentVtable {
+        (self.0).0
     }
 }
 
@@ -167,84 +189,34 @@ cast! {
     v: Func => v.element().ok_or("expected element")?,
 }
 
-/// A Typst element that is defined by a native Rust type.
-pub trait NativeElement:
-    Debug
-    + Clone
-    + PartialEq
-    + Hash
-    + Construct
-    + Set
-    + Capable
-    + Fields
-    + Repr
-    + Send
-    + Sync
-    + 'static
-{
-    /// Get the element for the native Rust element.
-    fn elem() -> Element
-    where
-        Self: Sized,
-    {
-        Element::from(Self::data())
-    }
-
-    /// Pack the element into type-erased content.
-    fn pack(self) -> Content
-    where
-        Self: Sized,
-    {
-        Content::new(self)
-    }
-
-    /// Get the element data for the native Rust element.
-    fn data() -> &'static NativeElementData
-    where
-        Self: Sized;
+/// Lazily initialized data for an element.
+#[derive(Default)]
+pub struct LazyElementStore {
+    pub scope: OnceLock<Scope>,
+    pub params: OnceLock<Vec<ParamInfo>>,
 }
 
-/// Used to cast an element to a trait object for a trait it implements.
+impl LazyElementStore {
+    /// Create an empty store.
+    pub const fn new() -> Self {
+        Self { scope: OnceLock::new(), params: OnceLock::new() }
+    }
+}
+
+/// A Typst element that is defined by a native Rust type.
 ///
 /// # Safety
-/// If the `vtable` function returns `Some(p)`, then `p` must be a valid pointer
-/// to a vtable of `Packed<Self>` w.r.t to the trait `C` where `capability` is
-/// `TypeId::of::<dyn C>()`.
-pub unsafe trait Capable {
-    /// Get the pointer to the vtable for the given capability / trait.
-    fn vtable(capability: TypeId) -> Option<NonNull<()>>;
-}
+/// `ELEM` must hold the correct `Element` for `Self`.
+pub unsafe trait NativeElement:
+    Debug + Clone + Hash + Construct + Set + Send + Sync + 'static
+{
+    /// The associated element.
+    const ELEM: Element;
 
-/// Defines how fields of an element are accessed.
-pub trait Fields {
-    /// An enum with the fields of the element.
-    type Enum
-    where
-        Self: Sized;
-
-    /// Whether the element has the given field set.
-    fn has(&self, id: u8) -> bool;
-
-    /// Get the field with the given field ID.
-    fn field(&self, id: u8) -> Result<Value, FieldAccessError>;
-
-    /// Get the field with the given ID in the presence of styles.
-    fn field_with_styles(
-        &self,
-        id: u8,
-        styles: StyleChain,
-    ) -> Result<Value, FieldAccessError>;
-
-    /// Get the field with the given ID from the styles.
-    fn field_from_styles(id: u8, styles: StyleChain) -> Result<Value, FieldAccessError>
-    where
-        Self: Sized;
-
-    /// Resolve all fields with the styles and save them in-place.
-    fn materialize(&mut self, styles: StyleChain);
-
-    /// Get the fields of the element.
-    fn fields(&self) -> Dict;
+    /// Pack the element into type-erased content.
+    fn pack(self) -> Content {
+        Content::new(self)
+    }
 }
 
 /// An element's constructor function.
@@ -266,48 +238,6 @@ pub trait Set {
         Self: Sized;
 }
 
-/// Defines a native element.
-#[derive(Debug)]
-pub struct NativeElementData {
-    /// The element's normal name (e.g. `align`), as exposed to Typst.
-    pub name: &'static str,
-    /// The element's title case name (e.g. `Align`).
-    pub title: &'static str,
-    /// The documentation for this element as a string.
-    pub docs: &'static str,
-    /// A list of alternate search terms for this element.
-    pub keywords: &'static [&'static str],
-    /// The constructor for this element (see [`Construct`]).
-    pub construct: fn(&mut Engine, &mut Args) -> SourceResult<Content>,
-    /// Executes this element's set rule (see [`Set`]).
-    pub set: fn(&mut Engine, &mut Args) -> SourceResult<Styles>,
-    /// Gets the vtable for one of this element's capabilities
-    /// (see [`Capable`]).
-    pub vtable: fn(capability: TypeId) -> Option<NonNull<()>>,
-    /// Gets the numeric index of this field by its name.
-    pub field_id: fn(name: &str) -> Option<u8>,
-    /// Gets the name of a field by its numeric index.
-    pub field_name: fn(u8) -> Option<&'static str>,
-    /// Get the field with the given ID in the presence of styles (see [`Fields`]).
-    pub field_from_styles: fn(u8, StyleChain) -> Result<Value, FieldAccessError>,
-    /// Gets the localized name for this element (see [`LocalName`][crate::text::LocalName]).
-    pub local_name: Option<fn(Lang, Option<Region>) -> &'static str>,
-    pub scope: LazyLock<Scope>,
-    /// A list of parameter information for each field.
-    pub params: LazyLock<Vec<ParamInfo>>,
-}
-
-impl From<&'static NativeElementData> for Element {
-    fn from(data: &'static NativeElementData) -> Self {
-        Self(Static(data))
-    }
-}
-
-cast! {
-    &'static NativeElementData,
-    self => Element::from(self).into_value(),
-}
-
 /// Synthesize fields on an element. This happens before execution of any show
 /// rule.
 pub trait Synthesize {
@@ -331,3 +261,9 @@ pub trait ShowSet {
     /// that should work even in the face of a user-defined show rule.
     fn show_set(&self, styles: StyleChain) -> Styles;
 }
+
+/// Tries to extract the plain-text representation of the element.
+pub trait PlainText {
+    /// Write this element's plain text into the given buffer.
+    fn plain_text(&self, text: &mut EcoString);
+}
diff --git a/crates/typst-library/src/foundations/content/field.rs b/crates/typst-library/src/foundations/content/field.rs
new file mode 100644
index 000000000..8d0fe529c
--- /dev/null
+++ b/crates/typst-library/src/foundations/content/field.rs
@@ -0,0 +1,564 @@
+use std::fmt::{self, Debug};
+use std::hash::Hash;
+use std::marker::PhantomData;
+use std::sync::OnceLock;
+
+use ecow::{eco_format, EcoString};
+
+use crate::foundations::{
+    Container, Content, FieldVtable, Fold, FoldFn, IntoValue, NativeElement, Packed,
+    Property, Reflect, Repr, Resolve, StyleChain,
+};
+
+/// An accessor for the `I`-th field of the element `E`. Values of this type are
+/// generated for each field of an element can be used to interact with this
+/// field programmatically, for example to access the style chain, as in
+/// `styles.get(TextElem::size)`.
+#[derive(Copy, Clone)]
+pub struct Field<E: NativeElement, const I: u8>(pub PhantomData<E>);
+
+impl<E: NativeElement, const I: u8> Field<E, I> {
+    /// Creates a new zero-sized accessor.
+    pub const fn new() -> Self {
+        Self(PhantomData)
+    }
+
+    /// The index of the projected field.
+    pub const fn index(self) -> u8 {
+        I
+    }
+
+    /// Creates a dynamic property instance for this field.
+    ///
+    /// Prefer [`Content::set`] or
+    /// [`Styles::set`](crate::foundations::Styles::set) when working with
+    /// existing content or style value.
+    pub fn set(self, value: E::Type) -> Property
+    where
+        E: SettableProperty<I>,
+        E::Type: Debug + Clone + Hash + Send + Sync + 'static,
+    {
+        Property::new(self, value)
+    }
+}
+
+impl<E: NativeElement, const I: u8> Default for Field<E, I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// A field that is present on every instance of the element.
+pub trait RequiredField<const I: u8>: NativeElement {
+    type Type: Clone;
+
+    const FIELD: RequiredFieldData<Self, I>;
+}
+
+/// Metadata and routines for a [`RequiredField`].
+pub struct RequiredFieldData<E: RequiredField<I>, const I: u8> {
+    name: &'static str,
+    docs: &'static str,
+    get: fn(&E) -> &E::Type,
+}
+
+impl<E: RequiredField<I>, const I: u8> RequiredFieldData<E, I> {
+    /// Creates the data from its parts. This is called in the `#[elem]` macro.
+    pub const fn new(
+        name: &'static str,
+        docs: &'static str,
+        get: fn(&E) -> &E::Type,
+    ) -> Self {
+        Self { name, docs, get }
+    }
+
+    /// Creates the vtable for a `#[required]` field.
+    pub const fn vtable() -> FieldVtable<Packed<E>>
+    where
+        E: RequiredField<I>,
+        E::Type: Reflect + IntoValue + PartialEq,
+    {
+        FieldVtable {
+            name: E::FIELD.name,
+            docs: E::FIELD.docs,
+            positional: true,
+            required: true,
+            variadic: false,
+            settable: false,
+            synthesized: false,
+            input: || <E::Type as Reflect>::input(),
+            default: None,
+            has: |_| true,
+            get: |elem| Some((E::FIELD.get)(elem).clone().into_value()),
+            get_with_styles: |elem, _| Some((E::FIELD.get)(elem).clone().into_value()),
+            get_from_styles: |_| None,
+            materialize: |_, _| {},
+            eq: |a, b| (E::FIELD.get)(a) == (E::FIELD.get)(b),
+        }
+    }
+
+    /// Creates the vtable for a `#[variadic]` field.
+    pub const fn vtable_variadic() -> FieldVtable<Packed<E>>
+    where
+        E: RequiredField<I>,
+        E::Type: Container + IntoValue + PartialEq,
+        <E::Type as Container>::Inner: Reflect,
+    {
+        FieldVtable {
+            name: E::FIELD.name,
+            docs: E::FIELD.docs,
+            positional: true,
+            required: true,
+            variadic: true,
+            settable: false,
+            synthesized: false,
+            input: || <<E::Type as Container>::Inner as Reflect>::input(),
+            default: None,
+            has: |_| true,
+            get: |elem| Some((E::FIELD.get)(elem).clone().into_value()),
+            get_with_styles: |elem, _| Some((E::FIELD.get)(elem).clone().into_value()),
+            get_from_styles: |_| None,
+            materialize: |_, _| {},
+            eq: |a, b| (E::FIELD.get)(a) == (E::FIELD.get)(b),
+        }
+    }
+}
+
+/// A field that is initially unset, but may be set through a
+/// [`Synthesize`](crate::foundations::Synthesize) implementation.
+pub trait SynthesizedField<const I: u8>: NativeElement {
+    type Type: Clone;
+
+    const FIELD: SynthesizedFieldData<Self, I>;
+}
+
+/// Metadata and routines for a [`SynthesizedField`].
+pub struct SynthesizedFieldData<E: SynthesizedField<I>, const I: u8> {
+    name: &'static str,
+    docs: &'static str,
+    get: fn(&E) -> &Option<E::Type>,
+}
+
+impl<E: SynthesizedField<I>, const I: u8> SynthesizedFieldData<E, I> {
+    /// Creates the data from its parts. This is called in the `#[elem]` macro.
+    pub const fn new(
+        name: &'static str,
+        docs: &'static str,
+        get: fn(&E) -> &Option<E::Type>,
+    ) -> Self {
+        Self { name, docs, get }
+    }
+
+    /// Creates type-erased metadata and routines for a `#[synthesized]` field.
+    pub const fn vtable() -> FieldVtable<Packed<E>>
+    where
+        E: SynthesizedField<I>,
+        E::Type: Reflect + IntoValue + PartialEq,
+    {
+        FieldVtable {
+            name: E::FIELD.name,
+            docs: E::FIELD.docs,
+            positional: false,
+            required: false,
+            variadic: false,
+            settable: false,
+            synthesized: true,
+            input: || <E::Type as Reflect>::input(),
+            default: None,
+            has: |elem| (E::FIELD.get)(elem).is_some(),
+            get: |elem| (E::FIELD.get)(elem).clone().map(|v| v.into_value()),
+            get_with_styles: |elem, _| {
+                (E::FIELD.get)(elem).clone().map(|v| v.into_value())
+            },
+            get_from_styles: |_| None,
+            materialize: |_, _| {},
+            // Synthesized fields don't affect equality.
+            eq: |_, _| true,
+        }
+    }
+}
+
+/// A field that is not actually there. It's only visible in the docs.
+pub trait ExternalField<const I: u8>: NativeElement {
+    type Type;
+
+    const FIELD: ExternalFieldData<Self, I>;
+}
+
+/// Metadata for an [`ExternalField`].
+pub struct ExternalFieldData<E: ExternalField<I>, const I: u8> {
+    name: &'static str,
+    docs: &'static str,
+    default: fn() -> E::Type,
+}
+
+impl<E: ExternalField<I>, const I: u8> ExternalFieldData<E, I> {
+    /// Creates the data from its parts. This is called in the `#[elem]` macro.
+    pub const fn new(
+        name: &'static str,
+        docs: &'static str,
+        default: fn() -> E::Type,
+    ) -> Self {
+        Self { name, docs, default }
+    }
+
+    /// Creates type-erased metadata and routines for an `#[external]` field.
+    pub const fn vtable() -> FieldVtable<Packed<E>>
+    where
+        E: ExternalField<I>,
+        E::Type: Reflect + IntoValue,
+    {
+        FieldVtable {
+            name: E::FIELD.name,
+            docs: E::FIELD.docs,
+            positional: false,
+            required: false,
+            variadic: false,
+            settable: false,
+            synthesized: false,
+            input: || <E::Type as Reflect>::input(),
+            default: Some(|| (E::FIELD.default)().into_value()),
+            has: |_| false,
+            get: |_| None,
+            get_with_styles: |_, _| None,
+            get_from_styles: |_| None,
+            materialize: |_, _| {},
+            eq: |_, _| true,
+        }
+    }
+}
+
+/// A field that has a default value and can be configured via a set rule, but
+/// can also present on elements and be present in the constructor.
+pub trait SettableField<const I: u8>: NativeElement {
+    type Type: Clone;
+
+    const FIELD: SettableFieldData<Self, I>;
+}
+
+/// Metadata and routines for a [`SettableField`].
+pub struct SettableFieldData<E: SettableField<I>, const I: u8> {
+    get: fn(&E) -> &Settable<E, I>,
+    get_mut: fn(&mut E) -> &mut Settable<E, I>,
+    property: SettablePropertyData<E, I>,
+}
+
+impl<E: SettableField<I>, const I: u8> SettableFieldData<E, I> {
+    /// Creates the data from its parts. This is called in the `#[elem]` macro.
+    pub const fn new(
+        name: &'static str,
+        docs: &'static str,
+        positional: bool,
+        get: fn(&E) -> &Settable<E, I>,
+        get_mut: fn(&mut E) -> &mut Settable<E, I>,
+        default: fn() -> E::Type,
+        slot: fn() -> &'static OnceLock<E::Type>,
+    ) -> Self {
+        Self {
+            get,
+            get_mut,
+            property: SettablePropertyData::new(name, docs, positional, default, slot),
+        }
+    }
+
+    /// Ensures that the property is folded on every access. See the
+    /// documentation of the [`Fold`] trait for more details.
+    pub const fn with_fold(mut self) -> Self
+    where
+        E::Type: Fold,
+    {
+        self.property.fold = Some(E::Type::fold);
+        self
+    }
+
+    /// Creates type-erased metadata and routines for a normal settable field.
+    pub const fn vtable() -> FieldVtable<Packed<E>>
+    where
+        E: SettableField<I>,
+        E::Type: Reflect + IntoValue + PartialEq,
+    {
+        FieldVtable {
+            name: E::FIELD.property.name,
+            docs: E::FIELD.property.docs,
+            positional: E::FIELD.property.positional,
+            required: false,
+            variadic: false,
+            settable: true,
+            synthesized: false,
+            input: || <E::Type as Reflect>::input(),
+            default: Some(|| E::default().into_value()),
+            has: |elem| (E::FIELD.get)(elem).is_set(),
+            get: |elem| (E::FIELD.get)(elem).as_option().clone().map(|v| v.into_value()),
+            get_with_styles: |elem, styles| {
+                Some((E::FIELD.get)(elem).get_cloned(styles).into_value())
+            },
+            get_from_styles: |styles| {
+                Some(styles.get_cloned::<E, I>(Field::new()).into_value())
+            },
+            materialize: |elem, styles| {
+                if !(E::FIELD.get)(elem).is_set() {
+                    (E::FIELD.get_mut)(elem).set(styles.get_cloned::<E, I>(Field::new()));
+                }
+            },
+            eq: |a, b| (E::FIELD.get)(a).as_option() == (E::FIELD.get)(b).as_option(),
+        }
+    }
+}
+
+/// A field that has a default value and can be configured via a set rule, but
+/// is never present on elements.
+///
+/// This is provided for all `SettableField` impls through a blanket impl. In
+/// the case of `#[ghost]` fields, which only live in the style chain and not in
+/// elements, it is also implemented manually.
+pub trait SettableProperty<const I: u8>: NativeElement {
+    type Type: Clone;
+
+    const FIELD: SettablePropertyData<Self, I>;
+    const FOLD: Option<FoldFn<Self::Type>> = Self::FIELD.fold;
+
+    /// Produces an instance of the property's default value.
+    fn default() -> Self::Type {
+        // Avoid recreating an expensive instance over and over, but also
+        // avoid unnecessary lazy initialization for cheap types.
+        if std::mem::needs_drop::<Self::Type>() {
+            Self::default_ref().clone()
+        } else {
+            (Self::FIELD.default)()
+        }
+    }
+
+    /// Produces a static reference to this property's default value.
+    fn default_ref() -> &'static Self::Type {
+        (Self::FIELD.slot)().get_or_init(Self::FIELD.default)
+    }
+}
+
+impl<T, const I: u8> SettableProperty<I> for T
+where
+    T: SettableField<I>,
+{
+    type Type = <Self as SettableField<I>>::Type;
+
+    const FIELD: SettablePropertyData<Self, I> =
+        <Self as SettableField<I>>::FIELD.property;
+}
+
+/// Metadata and routines for a [`SettableProperty`].
+pub struct SettablePropertyData<E: SettableProperty<I>, const I: u8> {
+    name: &'static str,
+    docs: &'static str,
+    positional: bool,
+    default: fn() -> E::Type,
+    slot: fn() -> &'static OnceLock<E::Type>,
+    fold: Option<FoldFn<E::Type>>,
+}
+
+impl<E: SettableProperty<I>, const I: u8> SettablePropertyData<E, I> {
+    /// Creates the data from its parts. This is called in the `#[elem]` macro.
+    pub const fn new(
+        name: &'static str,
+        docs: &'static str,
+        positional: bool,
+        default: fn() -> E::Type,
+        slot: fn() -> &'static OnceLock<E::Type>,
+    ) -> Self {
+        Self { name, docs, positional, default, slot, fold: None }
+    }
+
+    /// Ensures that the property is folded on every access. See the
+    /// documentation of the [`Fold`] trait for more details.
+    pub const fn with_fold(self) -> Self
+    where
+        E::Type: Fold,
+    {
+        Self { fold: Some(E::Type::fold), ..self }
+    }
+
+    /// Creates type-erased metadata and routines for a `#[ghost]` field.
+    pub const fn vtable() -> FieldVtable<Packed<E>>
+    where
+        E: SettableProperty<I>,
+        E::Type: Reflect + IntoValue + PartialEq,
+    {
+        FieldVtable {
+            name: E::FIELD.name,
+            docs: E::FIELD.docs,
+            positional: E::FIELD.positional,
+            required: false,
+            variadic: false,
+            settable: true,
+            synthesized: false,
+            input: || <E::Type as Reflect>::input(),
+            default: Some(|| E::default().into_value()),
+            has: |_| false,
+            get: |_| None,
+            get_with_styles: |_, styles| {
+                Some(styles.get_cloned::<E, I>(Field::new()).into_value())
+            },
+            get_from_styles: |styles| {
+                Some(styles.get_cloned::<E, I>(Field::new()).into_value())
+            },
+            materialize: |_, _| {},
+            eq: |_, _| true,
+        }
+    }
+}
+
+/// A settable property that can be accessed by reference (because it is not
+/// folded).
+pub trait RefableProperty<const I: u8>: SettableProperty<I> {}
+
+/// A settable field of an element.
+///
+/// The field can be in two states: Unset or present.
+///
+/// See [`StyleChain`] for more details about the available accessor methods.
+#[derive(Copy, Clone, Hash)]
+pub struct Settable<E: NativeElement, const I: u8>(Option<E::Type>)
+where
+    E: SettableProperty<I>;
+
+impl<E: NativeElement, const I: u8> Settable<E, I>
+where
+    E: SettableProperty<I>,
+{
+    /// Creates a new unset instance.
+    pub fn new() -> Self {
+        Self(None)
+    }
+
+    /// Sets the instance to a value.
+    pub fn set(&mut self, value: E::Type) {
+        self.0 = Some(value);
+    }
+
+    /// Clears the value from the instance.
+    pub fn unset(&mut self) {
+        self.0 = None;
+    }
+
+    /// Views the type as an [`Option`] which is `Some` if the type is set
+    /// and `None` if it is unset.
+    pub fn as_option(&self) -> &Option<E::Type> {
+        &self.0
+    }
+
+    /// Views the type as a mutable [`Option`].
+    pub fn as_option_mut(&mut self) -> &mut Option<E::Type> {
+        &mut self.0
+    }
+
+    /// Whether the field is set.
+    pub fn is_set(&self) -> bool {
+        self.0.is_some()
+    }
+
+    /// Retrieves the value given styles. The styles are used if the value is
+    /// unset.
+    pub fn get<'a>(&'a self, styles: StyleChain<'a>) -> E::Type
+    where
+        E::Type: Copy,
+    {
+        self.get_cloned(styles)
+    }
+
+    /// Retrieves and clones the value given styles. The styles are used if the
+    /// value is unset or if it needs folding.
+    pub fn get_cloned<'a>(&'a self, styles: StyleChain<'a>) -> E::Type {
+        if let Some(fold) = E::FOLD {
+            let mut res = styles.get_cloned::<E, I>(Field::new());
+            if let Some(value) = &self.0 {
+                res = fold(value.clone(), res);
+            }
+            res
+        } else if let Some(value) = &self.0 {
+            value.clone()
+        } else {
+            styles.get_cloned::<E, I>(Field::new())
+        }
+    }
+
+    /// Retrieves a reference to the value given styles. The styles are used if
+    /// the value is unset.
+    pub fn get_ref<'a>(&'a self, styles: StyleChain<'a>) -> &'a E::Type
+    where
+        E: RefableProperty<I>,
+    {
+        if let Some(value) = &self.0 {
+            value
+        } else {
+            styles.get_ref::<E, I>(Field::new())
+        }
+    }
+
+    /// Retrieves the value and then immediately [resolves](Resolve) it.
+    pub fn resolve<'a>(&'a self, styles: StyleChain<'a>) -> <E::Type as Resolve>::Output
+    where
+        E::Type: Resolve,
+    {
+        self.get_cloned(styles).resolve(styles)
+    }
+}
+
+impl<E: NativeElement, const I: u8> Debug for Settable<E, I>
+where
+    E: SettableProperty<I>,
+    E::Type: Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<E: NativeElement, const I: u8> Default for Settable<E, I>
+where
+    E: SettableProperty<I>,
+{
+    fn default() -> Self {
+        Self(None)
+    }
+}
+
+impl<E: NativeElement, const I: u8> From<Option<E::Type>> for Settable<E, I>
+where
+    E: SettableProperty<I>,
+{
+    fn from(value: Option<E::Type>) -> Self {
+        Self(value)
+    }
+}
+
+/// An error arising when trying to access a field of content.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum FieldAccessError {
+    Unknown,
+    Unset,
+}
+
+impl FieldAccessError {
+    /// Formats the error message given the content and the field name.
+    #[cold]
+    pub fn message(self, content: &Content, field: &str) -> EcoString {
+        let elem_name = content.elem().name();
+        match self {
+            FieldAccessError::Unknown => {
+                eco_format!("{elem_name} does not have field {}", field.repr())
+            }
+            FieldAccessError::Unset => {
+                eco_format!(
+                    "field {} in {elem_name} is not known at this point",
+                    field.repr()
+                )
+            }
+        }
+    }
+
+    /// Formats the error message for an `at` calls without a default value.
+    #[cold]
+    pub fn message_no_default(self, content: &Content, field: &str) -> EcoString {
+        let mut msg = self.message(content, field);
+        msg.push_str(" and no default was specified");
+        msg
+    }
+}
diff --git a/crates/typst-library/src/foundations/content.rs b/crates/typst-library/src/foundations/content/mod.rs
similarity index 64%
rename from crates/typst-library/src/foundations/content.rs
rename to crates/typst-library/src/foundations/content/mod.rs
index 1855bb70b..7ba790d88 100644
--- a/crates/typst-library/src/foundations/content.rs
+++ b/crates/typst-library/src/foundations/content/mod.rs
@@ -1,23 +1,33 @@
-use std::any::TypeId;
+mod element;
+mod field;
+mod packed;
+mod raw;
+mod vtable;
+
+pub use self::element::*;
+pub use self::field::*;
+pub use self::packed::Packed;
+pub use self::vtable::{ContentVtable, FieldVtable};
+#[doc(inline)]
+pub use typst_macros::elem;
+
 use std::fmt::{self, Debug, Formatter};
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::iter::{self, Sum};
-use std::marker::PhantomData;
-use std::ops::{Add, AddAssign, ControlFlow, Deref, DerefMut};
-use std::sync::Arc;
+use std::ops::{Add, AddAssign, ControlFlow};
 
 use comemo::Tracked;
 use ecow::{eco_format, EcoString};
 use serde::{Serialize, Serializer};
+
 use typst_syntax::Span;
-use typst_utils::{fat, singleton, LazyHash, SmallBitSet};
+use typst_utils::singleton;
 
 use crate::diag::{SourceResult, StrResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, func, scope, ty, Context, Dict, Element, Fields, IntoValue, Label,
-    NativeElement, Recipe, RecipeIndex, Repr, Selector, Str, Style, StyleChain, Styles,
-    Value,
+    func, repr, scope, ty, Context, Dict, IntoValue, Label, Property, Recipe,
+    RecipeIndex, Repr, Selector, Str, Style, StyleChain, Styles, Value,
 };
 use crate::introspection::Location;
 use crate::layout::{AlignElem, Alignment, Axes, Length, MoveElem, PadElem, Rel, Sides};
@@ -68,43 +78,14 @@ use crate::text::UnderlineElem;
 /// elements the content is composed of and what fields they have.
 /// Alternatively, you can inspect the output of the [`repr`] function.
 #[ty(scope, cast)]
-#[derive(Clone, Hash)]
-#[allow(clippy::derived_hash_with_manual_eq)]
-pub struct Content {
-    /// The partially element-dependent inner data.
-    inner: Arc<Inner<dyn Bounds>>,
-    /// The element's source code location.
-    span: Span,
-}
-
-/// The inner representation behind the `Arc`.
-#[derive(Hash)]
-struct Inner<T: ?Sized + 'static> {
-    /// An optional label attached to the element.
-    label: Option<Label>,
-    /// The element's location which identifies it in the layouted output.
-    location: Option<Location>,
-    /// Manages the element during realization.
-    /// - If bit 0 is set, the element is prepared.
-    /// - If bit n is set, the element is guarded against the n-th show rule
-    ///   recipe from the top of the style chain (counting from 1).
-    lifecycle: SmallBitSet,
-    /// The element's raw data.
-    elem: LazyHash<T>,
-}
+#[derive(Clone, PartialEq, Hash)]
+#[repr(transparent)]
+pub struct Content(raw::RawContent);
 
 impl Content {
     /// Creates a new content from an element.
     pub fn new<T: NativeElement>(elem: T) -> Self {
-        Self {
-            inner: Arc::new(Inner {
-                label: None,
-                location: None,
-                lifecycle: SmallBitSet::new(),
-                elem: elem.into(),
-            }),
-            span: Span::detached(),
-        }
+        Self(raw::RawContent::new(elem))
     }
 
     /// Creates a empty sequence content.
@@ -114,25 +95,25 @@ impl Content {
 
     /// Get the element of this content.
     pub fn elem(&self) -> Element {
-        self.inner.elem.dyn_elem()
+        self.0.elem()
     }
 
     /// Get the span of the content.
     pub fn span(&self) -> Span {
-        self.span
+        self.0.span()
     }
 
     /// Set the span of the content.
     pub fn spanned(mut self, span: Span) -> Self {
-        if self.span.is_detached() {
-            self.span = span;
+        if self.0.span().is_detached() {
+            *self.0.span_mut() = span;
         }
         self
     }
 
     /// Get the label of the content.
     pub fn label(&self) -> Option<Label> {
-        self.inner.label
+        self.0.meta().label
     }
 
     /// Attach a label to the content.
@@ -143,7 +124,7 @@ impl Content {
 
     /// Set the label of the content.
     pub fn set_label(&mut self, label: Label) {
-        self.make_mut().label = Some(label);
+        self.0.meta_mut().label = Some(label);
     }
 
     /// Assigns a location to the content.
@@ -159,28 +140,28 @@ impl Content {
 
     /// Set the location of the content.
     pub fn set_location(&mut self, location: Location) {
-        self.make_mut().location = Some(location);
+        self.0.meta_mut().location = Some(location);
     }
 
     /// Check whether a show rule recipe is disabled.
     pub fn is_guarded(&self, index: RecipeIndex) -> bool {
-        self.inner.lifecycle.contains(index.0)
+        self.0.meta().lifecycle.contains(index.0)
     }
 
     /// Disable a show rule recipe.
     pub fn guarded(mut self, index: RecipeIndex) -> Self {
-        self.make_mut().lifecycle.insert(index.0);
+        self.0.meta_mut().lifecycle.insert(index.0);
         self
     }
 
     /// Whether this content has already been prepared.
     pub fn is_prepared(&self) -> bool {
-        self.inner.lifecycle.contains(0)
+        self.0.meta().lifecycle.contains(0)
     }
 
     /// Mark this content as prepared.
     pub fn mark_prepared(&mut self) {
-        self.make_mut().lifecycle.insert(0);
+        self.0.meta_mut().lifecycle.insert(0);
     }
 
     /// Get a field by ID.
@@ -198,9 +179,14 @@ impl Content {
                 return Ok(label.into_value());
             }
         }
-        match styles {
-            Some(styles) => self.inner.elem.field_with_styles(id, styles),
-            None => self.inner.elem.field(id),
+
+        match self.0.handle().field(id) {
+            Some(handle) => match styles {
+                Some(styles) => handle.get_with_styles(styles),
+                None => handle.get(),
+            }
+            .ok_or(FieldAccessError::Unset),
+            None => Err(FieldAccessError::Unknown),
         }
     }
 
@@ -215,8 +201,11 @@ impl Content {
                 .map(|label| label.into_value())
                 .ok_or(FieldAccessError::Unknown);
         }
-        let id = self.elem().field_id(name).ok_or(FieldAccessError::Unknown)?;
-        self.get(id, None)
+
+        match self.elem().field_id(name).and_then(|id| self.0.handle().field(id)) {
+            Some(handle) => handle.get().ok_or(FieldAccessError::Unset),
+            None => Err(FieldAccessError::Unknown),
+        }
     }
 
     /// Get a field by ID, returning a missing field error if it does not exist.
@@ -240,7 +229,9 @@ impl Content {
 
     /// Resolve all fields with the styles and save them in-place.
     pub fn materialize(&mut self, styles: StyleChain) {
-        self.make_mut().elem.materialize(styles);
+        for id in 0..self.elem().vtable().fields.len() as u8 {
+            self.0.handle_mut().field(id).unwrap().materialize(styles);
+        }
     }
 
     /// Create a new sequence element from multiples elements.
@@ -257,7 +248,7 @@ impl Content {
 
     /// Whether the contained element is of type `T`.
     pub fn is<T: NativeElement>(&self) -> bool {
-        self.inner.elem.dyn_type_id() == TypeId::of::<T>()
+        self.0.is::<T>()
     }
 
     /// Downcasts the element to a packed value.
@@ -280,16 +271,6 @@ impl Content {
         self.into_packed::<T>().map(Packed::unpack)
     }
 
-    /// Makes sure the content is not shared and returns a mutable reference to
-    /// the inner data.
-    fn make_mut(&mut self) -> &mut Inner<dyn Bounds> {
-        let arc = &mut self.inner;
-        if Arc::strong_count(arc) > 1 || Arc::weak_count(arc) > 0 {
-            *self = arc.elem.dyn_clone(arc, self.span);
-        }
-        Arc::get_mut(&mut self.inner).unwrap()
-    }
-
     /// Whether the contained element has the given capability.
     pub fn can<C>(&self) -> bool
     where
@@ -304,13 +285,7 @@ impl Content {
     where
         C: ?Sized + 'static,
     {
-        // Safety: The vtable comes from the `Capable` implementation which
-        // guarantees to return a matching vtable for `Packed<T>` and `C`.
-        // Since any `Packed<T>` is a repr(transparent) `Content`, we can also
-        // use a `*const Content` pointer.
-        let vtable = self.elem().vtable()(TypeId::of::<C>())?;
-        let data = self as *const Content as *const ();
-        Some(unsafe { &*fat::from_raw_parts(data, vtable.as_ptr()) })
+        self.0.with::<C>()
     }
 
     /// Cast to a mutable trait object if the contained element has the given
@@ -319,18 +294,7 @@ impl Content {
     where
         C: ?Sized + 'static,
     {
-        // Safety: The vtable comes from the `Capable` implementation which
-        // guarantees to return a matching vtable for `Packed<T>` and `C`.
-        // Since any `Packed<T>` is a repr(transparent) `Content`, we can also
-        // use a `*const Content` pointer.
-        //
-        // The resulting trait object contains an `&mut Packed<T>`. We do _not_
-        // need to ensure that we hold the only reference to the `Arc` here
-        // because `Packed<T>`'s DerefMut impl will take care of that if
-        // mutable access is required.
-        let vtable = self.elem().vtable()(TypeId::of::<C>())?;
-        let data = self as *mut Content as *mut ();
-        Some(unsafe { &mut *fat::from_raw_parts_mut(data, vtable.as_ptr()) })
+        self.0.with_mut::<C>()
     }
 
     /// Whether the content is an empty sequence.
@@ -372,6 +336,15 @@ impl Content {
         Self::sequence(std::iter::repeat_with(|| self.clone()).take(count))
     }
 
+    /// Sets a style property on the content.
+    pub fn set<E, const I: u8>(self, field: Field<E, I>, value: E::Type) -> Self
+    where
+        E: SettableProperty<I>,
+        E::Type: Debug + Clone + Hash + Send + Sync + 'static,
+    {
+        self.styled(Property::new(field, value))
+    }
+
     /// Style this content with a style entry.
     pub fn styled(mut self, style: impl Into<Style>) -> Self {
         if let Some(style_elem) = self.to_packed_mut::<StyledElem>() {
@@ -476,7 +449,7 @@ impl Content {
 
         // Call f on the element itself before recursively iterating its fields.
         f(self.clone())?;
-        for (_, value) in self.inner.elem.fields() {
+        for (_, value) in self.fields() {
             walk_value(value, f)?;
         }
         ControlFlow::Continue(())
@@ -504,12 +477,12 @@ impl Content {
 
     /// Link the content somewhere.
     pub fn linked(self, dest: Destination) -> Self {
-        self.styled(LinkElem::set_current(Some(dest)))
+        self.set(LinkElem::current, Some(dest))
     }
 
     /// Set alignments for this content.
     pub fn aligned(self, align: Alignment) -> Self {
-        self.styled(AlignElem::set_alignment(align))
+        self.set(AlignElem::alignment, align)
     }
 
     /// Pad this content at the sides.
@@ -562,7 +535,10 @@ impl Content {
             return false;
         };
 
-        self.inner.elem.has(id)
+        match self.0.handle().field(id) {
+            Some(field) => field.has(),
+            None => false,
+        }
     }
 
     /// Access the specified field on the content. Returns the default value if
@@ -592,7 +568,12 @@ impl Content {
     /// ```
     #[func]
     pub fn fields(&self) -> Dict {
-        let mut dict = self.inner.elem.fields();
+        let mut dict = Dict::new();
+        for field in self.0.handle().fields() {
+            if let Some(value) = field.get() {
+                dict.insert(field.name.into(), value);
+            }
+        }
         if let Some(label) = self.label() {
             dict.insert("label".into(), label.into_value());
         }
@@ -605,7 +586,7 @@ impl Content {
     /// used with [counters]($counter), [state] and [queries]($query).
     #[func]
     pub fn location(&self) -> Option<Location> {
-        self.inner.location
+        self.0.meta().location
     }
 }
 
@@ -617,7 +598,7 @@ impl Default for Content {
 
 impl Debug for Content {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.inner.elem.fmt(f)
+        self.0.fmt(f)
     }
 }
 
@@ -627,16 +608,22 @@ impl<T: NativeElement> From<T> for Content {
     }
 }
 
-impl PartialEq for Content {
-    fn eq(&self, other: &Self) -> bool {
-        // Additional short circuit for different elements.
-        self.elem() == other.elem() && self.inner.elem.dyn_eq(other)
-    }
-}
-
 impl Repr for Content {
     fn repr(&self) -> EcoString {
-        self.inner.elem.repr()
+        self.0.handle().repr().unwrap_or_else(|| {
+            let fields = self
+                .0
+                .handle()
+                .fields()
+                .filter_map(|field| field.get().map(|v| (field.name, v.repr())))
+                .map(|(name, value)| eco_format!("{name}: {value}"))
+                .collect::<Vec<_>>();
+            eco_format!(
+                "{}{}",
+                self.elem().name(),
+                repr::pretty_array_like(&fields, false),
+            )
+        })
     }
 }
 
@@ -717,190 +704,8 @@ impl Serialize for Content {
     }
 }
 
-/// The trait that combines all the other traits into a trait object.
-trait Bounds: Debug + Repr + Fields + Send + Sync + 'static {
-    fn dyn_type_id(&self) -> TypeId;
-    fn dyn_elem(&self) -> Element;
-    fn dyn_clone(&self, inner: &Inner<dyn Bounds>, span: Span) -> Content;
-    fn dyn_hash(&self, hasher: &mut dyn Hasher);
-    fn dyn_eq(&self, other: &Content) -> bool;
-}
-
-impl<T: NativeElement> Bounds for T {
-    fn dyn_type_id(&self) -> TypeId {
-        TypeId::of::<Self>()
-    }
-
-    fn dyn_elem(&self) -> Element {
-        Self::elem()
-    }
-
-    fn dyn_clone(&self, inner: &Inner<dyn Bounds>, span: Span) -> Content {
-        Content {
-            inner: Arc::new(Inner {
-                label: inner.label,
-                location: inner.location,
-                lifecycle: inner.lifecycle.clone(),
-                elem: LazyHash::reuse(self.clone(), &inner.elem),
-            }),
-            span,
-        }
-    }
-
-    fn dyn_hash(&self, mut state: &mut dyn Hasher) {
-        TypeId::of::<Self>().hash(&mut state);
-        self.hash(&mut state);
-    }
-
-    fn dyn_eq(&self, other: &Content) -> bool {
-        let Some(other) = other.to_packed::<Self>() else {
-            return false;
-        };
-        *self == **other
-    }
-}
-
-impl Hash for dyn Bounds {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.dyn_hash(state);
-    }
-}
-
-/// A packed element of a static type.
-#[derive(Clone, PartialEq, Hash)]
-#[repr(transparent)]
-pub struct Packed<T: NativeElement>(
-    /// Invariant: Must be of type `T`.
-    Content,
-    PhantomData<T>,
-);
-
-impl<T: NativeElement> Packed<T> {
-    /// Pack element while retaining its static type.
-    pub fn new(element: T) -> Self {
-        // Safety: The element is known to be of type `T`.
-        Packed(element.pack(), PhantomData)
-    }
-
-    /// Try to cast type-erased content into a statically known packed element.
-    pub fn from_ref(content: &Content) -> Option<&Self> {
-        if content.is::<T>() {
-            // Safety:
-            // - We have checked the type.
-            // - Packed<T> is repr(transparent).
-            return Some(unsafe { std::mem::transmute::<&Content, &Packed<T>>(content) });
-        }
-        None
-    }
-
-    /// Try to cast type-erased content into a statically known packed element.
-    pub fn from_mut(content: &mut Content) -> Option<&mut Self> {
-        if content.is::<T>() {
-            // Safety:
-            // - We have checked the type.
-            // - Packed<T> is repr(transparent).
-            return Some(unsafe {
-                std::mem::transmute::<&mut Content, &mut Packed<T>>(content)
-            });
-        }
-        None
-    }
-
-    /// Try to cast type-erased content into a statically known packed element.
-    pub fn from_owned(content: Content) -> Result<Self, Content> {
-        if content.is::<T>() {
-            // Safety:
-            // - We have checked the type.
-            // - Packed<T> is repr(transparent).
-            return Ok(unsafe { std::mem::transmute::<Content, Packed<T>>(content) });
-        }
-        Err(content)
-    }
-
-    /// Pack back into content.
-    pub fn pack(self) -> Content {
-        self.0
-    }
-
-    /// Extract the raw underlying element.
-    pub fn unpack(self) -> T {
-        // This function doesn't yet need owned self, but might in the future.
-        (*self).clone()
-    }
-
-    /// The element's span.
-    pub fn span(&self) -> Span {
-        self.0.span()
-    }
-
-    /// Set the span of the element.
-    pub fn spanned(self, span: Span) -> Self {
-        Self(self.0.spanned(span), PhantomData)
-    }
-
-    /// Accesses the label of the element.
-    pub fn label(&self) -> Option<Label> {
-        self.0.label()
-    }
-
-    /// Accesses the location of the element.
-    pub fn location(&self) -> Option<Location> {
-        self.0.location()
-    }
-
-    /// Sets the location of the element.
-    pub fn set_location(&mut self, location: Location) {
-        self.0.set_location(location);
-    }
-}
-
-impl<T: NativeElement> AsRef<T> for Packed<T> {
-    fn as_ref(&self) -> &T {
-        self
-    }
-}
-
-impl<T: NativeElement> AsMut<T> for Packed<T> {
-    fn as_mut(&mut self) -> &mut T {
-        self
-    }
-}
-
-impl<T: NativeElement> Deref for Packed<T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        // Safety:
-        // - Packed<T> guarantees that the content trait object wraps
-        //   an element of type `T`.
-        // - This downcast works the same way as dyn Any's does. We can't reuse
-        //   that one because we don't want to pay the cost for every deref.
-        let elem = &*self.0.inner.elem;
-        unsafe { &*(elem as *const dyn Bounds as *const T) }
-    }
-}
-
-impl<T: NativeElement> DerefMut for Packed<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        // Safety:
-        // - Packed<T> guarantees that the content trait object wraps
-        //   an element of type `T`.
-        // - We have guaranteed unique access thanks to `make_mut`.
-        // - This downcast works the same way as dyn Any's does. We can't reuse
-        //   that one because we don't want to pay the cost for every deref.
-        let elem = &mut *self.0.make_mut().elem;
-        unsafe { &mut *(elem as *mut dyn Bounds as *mut T) }
-    }
-}
-
-impl<T: NativeElement + Debug> Debug for Packed<T> {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
 /// A sequence of content.
-#[elem(Debug, Repr, PartialEq)]
+#[elem(Debug, Repr)]
 pub struct SequenceElem {
     /// The elements.
     #[required]
@@ -922,19 +727,13 @@ impl Default for SequenceElem {
     }
 }
 
-impl PartialEq for SequenceElem {
-    fn eq(&self, other: &Self) -> bool {
-        self.children.iter().eq(other.children.iter())
-    }
-}
-
 impl Repr for SequenceElem {
     fn repr(&self) -> EcoString {
         if self.children.is_empty() {
             "[]".into()
         } else {
             let elements = crate::foundations::repr::pretty_array_like(
-                &self.children.iter().map(|c| c.inner.elem.repr()).collect::<Vec<_>>(),
+                &self.children.iter().map(|c| c.repr()).collect::<Vec<_>>(),
                 false,
             );
             eco_format!("sequence{}", elements)
@@ -974,49 +773,8 @@ impl Repr for StyledElem {
     }
 }
 
-/// Tries to extract the plain-text representation of the element.
-pub trait PlainText {
-    /// Write this element's plain text into the given buffer.
-    fn plain_text(&self, text: &mut EcoString);
-}
-
-/// An error arising when trying to access a field of content.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum FieldAccessError {
-    Unknown,
-    Unset,
-    Internal,
-}
-
-impl FieldAccessError {
-    /// Formats the error message given the content and the field name.
-    #[cold]
-    pub fn message(self, content: &Content, field: &str) -> EcoString {
-        let elem_name = content.elem().name();
-        match self {
-            FieldAccessError::Unknown => {
-                eco_format!("{elem_name} does not have field {}", field.repr())
-            }
-            FieldAccessError::Unset => {
-                eco_format!(
-                    "field {} in {elem_name} is not known at this point",
-                    field.repr()
-                )
-            }
-            FieldAccessError::Internal => {
-                eco_format!(
-                    "internal error when accessing field {} in {elem_name} – this is a bug",
-                    field.repr()
-                )
-            }
-        }
-    }
-
-    /// Formats the error message for an `at` calls without a default value.
-    #[cold]
-    pub fn message_no_default(self, content: &Content, field: &str) -> EcoString {
-        let mut msg = self.message(content, field);
-        msg.push_str(" and no default was specified");
-        msg
+impl<T: NativeElement> IntoValue for T {
+    fn into_value(self) -> Value {
+        Value::Content(self.pack())
     }
 }
diff --git a/crates/typst-library/src/foundations/content/packed.rs b/crates/typst-library/src/foundations/content/packed.rs
new file mode 100644
index 000000000..71bb66a94
--- /dev/null
+++ b/crates/typst-library/src/foundations/content/packed.rs
@@ -0,0 +1,147 @@
+use std::fmt::{self, Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+
+use typst_syntax::Span;
+
+use crate::foundations::{Content, Label, NativeElement};
+use crate::introspection::Location;
+
+/// A packed element of a static type.
+#[derive(Clone)]
+#[repr(transparent)]
+pub struct Packed<T: NativeElement>(
+    /// Invariant: Must be of type `T`.
+    Content,
+    PhantomData<T>,
+);
+
+impl<T: NativeElement> Packed<T> {
+    /// Pack element while retaining its static type.
+    pub fn new(element: T) -> Self {
+        // Safety: The element is known to be of type `T`.
+        Packed(element.pack(), PhantomData)
+    }
+
+    /// Try to cast type-erased content into a statically known packed element.
+    pub fn from_ref(content: &Content) -> Option<&Self> {
+        if content.is::<T>() {
+            // Safety:
+            // - We have checked the type.
+            // - Packed<T> is repr(transparent).
+            return Some(unsafe { std::mem::transmute::<&Content, &Packed<T>>(content) });
+        }
+        None
+    }
+
+    /// Try to cast type-erased content into a statically known packed element.
+    pub fn from_mut(content: &mut Content) -> Option<&mut Self> {
+        if content.is::<T>() {
+            // Safety:
+            // - We have checked the type.
+            // - Packed<T> is repr(transparent).
+            return Some(unsafe {
+                std::mem::transmute::<&mut Content, &mut Packed<T>>(content)
+            });
+        }
+        None
+    }
+
+    /// Try to cast type-erased content into a statically known packed element.
+    pub fn from_owned(content: Content) -> Result<Self, Content> {
+        if content.is::<T>() {
+            // Safety:
+            // - We have checked the type.
+            // - Packed<T> is repr(transparent).
+            return Ok(unsafe { std::mem::transmute::<Content, Packed<T>>(content) });
+        }
+        Err(content)
+    }
+
+    /// Pack back into content.
+    pub fn pack(self) -> Content {
+        self.0
+    }
+
+    /// Extract the raw underlying element.
+    pub fn unpack(self) -> T {
+        // This function doesn't yet need owned self, but might in the future.
+        (*self).clone()
+    }
+
+    /// The element's span.
+    pub fn span(&self) -> Span {
+        self.0.span()
+    }
+
+    /// Set the span of the element.
+    pub fn spanned(self, span: Span) -> Self {
+        Self(self.0.spanned(span), PhantomData)
+    }
+
+    /// Accesses the label of the element.
+    pub fn label(&self) -> Option<Label> {
+        self.0.label()
+    }
+
+    /// Accesses the location of the element.
+    pub fn location(&self) -> Option<Location> {
+        self.0.location()
+    }
+
+    /// Sets the location of the element.
+    pub fn set_location(&mut self, location: Location) {
+        self.0.set_location(location);
+    }
+
+    pub fn as_content(&self) -> &Content {
+        &self.0
+    }
+}
+
+impl<T: NativeElement> AsRef<T> for Packed<T> {
+    fn as_ref(&self) -> &T {
+        self
+    }
+}
+
+impl<T: NativeElement> AsMut<T> for Packed<T> {
+    fn as_mut(&mut self) -> &mut T {
+        self
+    }
+}
+
+impl<T: NativeElement> Deref for Packed<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        // Safety: Packed<T> guarantees that the content is of element type `T`.
+        unsafe { (self.0).0.data::<T>() }
+    }
+}
+
+impl<T: NativeElement> DerefMut for Packed<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        // Safety: Packed<T> guarantees that the content is of element type `T`.
+        unsafe { (self.0).0.data_mut::<T>() }
+    }
+}
+
+impl<T: NativeElement + Debug> Debug for Packed<T> {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<T: NativeElement> PartialEq for Packed<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl<T: NativeElement> Hash for Packed<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.hash(state);
+    }
+}
diff --git a/crates/typst-library/src/foundations/content/raw.rs b/crates/typst-library/src/foundations/content/raw.rs
new file mode 100644
index 000000000..f5dfffd73
--- /dev/null
+++ b/crates/typst-library/src/foundations/content/raw.rs
@@ -0,0 +1,426 @@
+use std::any::TypeId;
+use std::fmt::{self, Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::ptr::NonNull;
+use std::sync::atomic::{self, AtomicUsize, Ordering};
+
+use typst_syntax::Span;
+use typst_utils::{fat, HashLock, SmallBitSet};
+
+use super::vtable;
+use crate::foundations::{Element, Label, NativeElement, Packed};
+use crate::introspection::Location;
+
+/// The raw, low-level implementation of content.
+///
+/// The `ptr` + `elem` fields implement a fat pointer setup similar to an
+/// `Arc<Inner<dyn Trait>>`, but in a manual way, allowing us to have a custom
+/// [vtable].
+pub struct RawContent {
+    /// A type-erased pointer to an allocation containing two things:
+    /// - A header that is the same for all elements
+    /// - Element-specific `data` that holds the specific element
+    ///
+    /// This pointer is valid for both a `Header` and an `Inner<E>` where
+    /// `E::ELEM == self.elem` and can be freely cast between both. This is
+    /// possible because
+    /// - `Inner<E>` is `repr(C)`
+    /// - The first field of `Inner<E>` is `Header`
+    /// - ISO/IEC 9899:TC2 C standard § 6.7.2.1 - 13 states that a pointer to a
+    ///   structure "points to its initial member" with no padding at the start
+    ptr: NonNull<Header>,
+    /// Describes which kind of element this content holds. This is used for
+    ///
+    /// - Direct comparisons, e.g. `is::<HeadingElem>()`
+    /// - Behavior: An `Element` is just a pointer to a `ContentVtable`
+    ///   containing not just data, but also function pointers for various
+    ///   element-specific operations that can be performed
+    ///
+    /// It is absolutely crucial that `elem == <E as NativeElement>::ELEM` for
+    /// `Inner<E>` pointed to by `ptr`. Otherwise, things will go very wrong
+    /// since we'd be using the wrong vtable.
+    elem: Element,
+    /// The content's span.
+    span: Span,
+}
+
+/// The allocated part of an element's representation.
+///
+/// This is `repr(C)` to ensure that a pointer to the whole structure may be
+/// cast to a pointer to its first field.
+#[repr(C)]
+struct Inner<E> {
+    /// It is crucial that this is the first field because we cast between
+    /// pointers to `Inner<E>` and pointers to `Header`. See the documentation
+    /// of `RawContent::ptr` for more details.
+    header: Header,
+    /// The element struct. E.g. `E = HeadingElem`.
+    data: E,
+}
+
+/// The header that is shared by all elements.
+struct Header {
+    /// The element's reference count. This works just like for `Arc`.
+    /// Unfortunately, we have to reimplement reference counting because we
+    /// have a custom fat pointer and `Arc` wouldn't know how to drop its
+    /// contents. Something with `ManuallyDrop<Arc<_>>` might also work, but at
+    /// that point we're not gaining much and with the way it's implemented now
+    /// we can also skip the unnecessary weak reference count.
+    refs: AtomicUsize,
+    /// Metadata for the element.
+    meta: Meta,
+    /// A cell for memoizing the hash of just the `data` part of the content.
+    hash: HashLock,
+}
+
+/// Metadata that elements can hold.
+#[derive(Clone, Hash)]
+pub(super) struct Meta {
+    /// An optional label attached to the element.
+    pub label: Option<Label>,
+    /// The element's location which identifies it in the laid-out output.
+    pub location: Option<Location>,
+    /// Manages the element during realization.
+    /// - If bit 0 is set, the element is prepared.
+    /// - If bit n is set, the element is guarded against the n-th show rule
+    ///   recipe from the top of the style chain (counting from 1).
+    pub lifecycle: SmallBitSet,
+}
+
+impl RawContent {
+    /// Creates raw content wrapping an element, with all metadata set to
+    /// default (including a detached span).
+    pub(super) fn new<E: NativeElement>(data: E) -> Self {
+        Self::create(
+            data,
+            Meta {
+                label: None,
+                location: None,
+                lifecycle: SmallBitSet::new(),
+            },
+            HashLock::new(),
+            Span::detached(),
+        )
+    }
+
+    /// Creates and allocates raw content.
+    fn create<E: NativeElement>(data: E, meta: Meta, hash: HashLock, span: Span) -> Self {
+        let raw = Box::into_raw(Box::<Inner<E>>::new(Inner {
+            header: Header { refs: AtomicUsize::new(1), meta, hash },
+            data,
+        }));
+
+        // Safety: `Box` always holds a non-null pointer. See also
+        // `Box::into_non_null` (which is unstable).
+        let non_null = unsafe { NonNull::new_unchecked(raw) };
+
+        // Safety: See `RawContent::ptr`.
+        let ptr = non_null.cast::<Header>();
+
+        Self { ptr, elem: E::ELEM, span }
+    }
+
+    /// Destroys raw content and deallocates.
+    ///
+    /// # Safety
+    /// - The reference count must be zero.
+    /// - The raw content must be be of type `E`.
+    pub(super) unsafe fn drop_impl<E: NativeElement>(&mut self) {
+        debug_assert_eq!(self.header().refs.load(Ordering::Relaxed), 0);
+
+        // Safety:
+        // - The caller guarantees that the content is of type `E`.
+        // - Thus, `ptr` must have been created from `Box<Inner<E>>` (see
+        //   `RawContent::ptr`).
+        // - And to clean it up, we can just reproduce our box.
+        unsafe {
+            let ptr = self.ptr.cast::<Inner<E>>();
+            drop(Box::<Inner<E>>::from_raw(ptr.as_ptr()));
+        }
+    }
+
+    /// Clones a packed element into new raw content.
+    pub(super) fn clone_impl<E: NativeElement>(elem: &Packed<E>) -> Self {
+        let raw = &elem.as_content().0;
+        let header = raw.header();
+        RawContent::create(
+            elem.as_ref().clone(),
+            header.meta.clone(),
+            header.hash.clone(),
+            raw.span,
+        )
+    }
+
+    /// Accesses the header part of the raw content.
+    fn header(&self) -> &Header {
+        // Safety: `self.ptr` is a valid pointer to a header structure.
+        unsafe { self.ptr.as_ref() }
+    }
+
+    /// Mutably accesses the header part of the raw content.
+    fn header_mut(&mut self) -> &mut Header {
+        self.make_unique();
+
+        // Safety:
+        // - `self.ptr` is a valid pointer to a header structure.
+        // - We have unique access to the backing allocation (just ensured).
+        unsafe { self.ptr.as_mut() }
+    }
+
+    /// Retrieves the contained element **without checking that the content is
+    /// of the correct type.**
+    ///
+    /// # Safety
+    /// This must be preceded by a check to [`is`]. The safe API for this is
+    /// [`Content::to_packed`] and the [`Packed`] struct.
+    pub(super) unsafe fn data<E: NativeElement>(&self) -> &E {
+        debug_assert!(self.is::<E>());
+
+        // Safety:
+        // - The caller guarantees that the content is of type `E`.
+        // - `self.ptr` is a valid pointer to an `Inner<E>` (see
+        //   `RawContent::ptr`).
+        unsafe { &self.ptr.cast::<Inner<E>>().as_ref().data }
+    }
+
+    /// Retrieves the contained element mutably **without checking that the
+    /// content is of the correct type.**
+    ///
+    /// Ensures that the element's allocation is unique.
+    ///
+    /// # Safety
+    /// This must be preceded by a check to [`is`]. The safe API for this is
+    /// [`Content::to_packed_mut`] and the [`Packed`] struct.
+    pub(super) unsafe fn data_mut<E: NativeElement>(&mut self) -> &mut E {
+        debug_assert!(self.is::<E>());
+
+        // Ensure that the memoized hash is reset because we may mutate the
+        // element.
+        self.header_mut().hash.reset();
+
+        // Safety:
+        // - The caller guarantees that the content is of type `E`.
+        // - `self.ptr` is a valid pointer to an `Inner<E>` (see
+        //   `RawContent::ptr`).
+        // - We have unique access to the backing allocation (due to header_mut).
+        unsafe { &mut self.ptr.cast::<Inner<E>>().as_mut().data }
+    }
+
+    /// Ensures that we have unique access to the backing allocation by cloning
+    /// if the reference count exceeds 1. This is used before performing
+    /// mutable operations, implementing a clone-on-write scheme.
+    fn make_unique(&mut self) {
+        if self.header().refs.load(Ordering::Relaxed) > 1 {
+            *self = self.handle().clone();
+        }
+    }
+
+    /// Retrieves the element this content is for.
+    pub(super) fn elem(&self) -> Element {
+        self.elem
+    }
+
+    /// Whether this content holds an element of type `E`.
+    pub(super) fn is<E: NativeElement>(&self) -> bool {
+        self.elem == E::ELEM
+    }
+
+    /// Retrieves the content's span.
+    pub(super) fn span(&self) -> Span {
+        self.span
+    }
+
+    /// Retrieves the content's span mutably.
+    pub(super) fn span_mut(&mut self) -> &mut Span {
+        &mut self.span
+    }
+
+    /// Retrieves the content's metadata.
+    pub(super) fn meta(&self) -> &Meta {
+        &self.header().meta
+    }
+
+    /// Retrieves the content's metadata mutably.
+    pub(super) fn meta_mut(&mut self) -> &mut Meta {
+        &mut self.header_mut().meta
+    }
+
+    /// Casts into a trait object for a given trait if the packed element
+    /// implements said trait.
+    pub(super) fn with<C>(&self) -> Option<&C>
+    where
+        C: ?Sized + 'static,
+    {
+        // Safety: The vtable comes from the `Capable` implementation which
+        // guarantees to return a matching vtable for `Packed<T>` and `C`. Since
+        // any `Packed<T>` is repr(transparent) with `Content` and `RawContent`,
+        // we can also use a `*const RawContent` pointer.
+        let vtable = (self.elem.vtable().capability)(TypeId::of::<C>())?;
+        let data = self as *const Self as *const ();
+        Some(unsafe { &*fat::from_raw_parts(data, vtable.as_ptr()) })
+    }
+
+    /// Casts into a mutable trait object for a given trait if the packed
+    /// element implements said trait.
+    pub(super) fn with_mut<C>(&mut self) -> Option<&mut C>
+    where
+        C: ?Sized + 'static,
+    {
+        // Safety: The vtable comes from the `Capable` implementation which
+        // guarantees to return a matching vtable for `Packed<T>` and `C`. Since
+        // any `Packed<T>` is repr(transparent) with `Content` and `RawContent`,
+        // we can also use a `*const Content` pointer.
+        //
+        // The resulting trait object contains an `&mut Packed<T>`. We do _not_
+        // need to ensure that we hold the only reference to the `Arc` here
+        // because `Packed<T>`'s DerefMut impl will take care of that if mutable
+        // access is required.
+        let vtable = (self.elem.vtable().capability)(TypeId::of::<C>())?;
+        let data = self as *mut Self as *mut ();
+        Some(unsafe { &mut *fat::from_raw_parts_mut(data, vtable.as_ptr()) })
+    }
+}
+
+impl RawContent {
+    /// Retrieves the element's vtable.
+    pub(super) fn handle(&self) -> vtable::ContentHandle<&RawContent> {
+        // Safety `self.elem.vtable()` is a matching vtable for `self`.
+        unsafe { vtable::Handle::new(self, self.elem.vtable()) }
+    }
+
+    /// Retrieves the element's vtable.
+    pub(super) fn handle_mut(&mut self) -> vtable::ContentHandle<&mut RawContent> {
+        // Safety `self.elem.vtable()` is a matching vtable for `self`.
+        unsafe { vtable::Handle::new(self, self.elem.vtable()) }
+    }
+
+    /// Retrieves the element's vtable.
+    pub(super) fn handle_pair<'a, 'b>(
+        &'a self,
+        other: &'b RawContent,
+    ) -> Option<vtable::ContentHandle<(&'a RawContent, &'b RawContent)>> {
+        (self.elem == other.elem).then(|| {
+            // Safety:
+            // - `self.elem.vtable()` is a matching vtable for `self`.
+            // - It's also matching for `other` because `self.elem == other.elem`.
+            unsafe { vtable::Handle::new((self, other), self.elem.vtable()) }
+        })
+    }
+}
+
+impl Debug for RawContent {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        self.handle().debug(f)
+    }
+}
+
+impl Clone for RawContent {
+    fn clone(&self) -> Self {
+        // See Arc's clone impl for details about memory ordering.
+        let prev = self.header().refs.fetch_add(1, Ordering::Relaxed);
+
+        // See Arc's clone impl details about guarding against incredibly
+        // degenerate programs.
+        if prev > isize::MAX as usize {
+            ref_count_overflow(self.ptr, self.elem, self.span);
+        }
+
+        Self { ptr: self.ptr, elem: self.elem, span: self.span }
+    }
+}
+
+impl Drop for RawContent {
+    fn drop(&mut self) {
+        // Drop our ref-count. If there was more than one content before
+        // (including this one), we shouldn't deallocate. See Arc's drop impl
+        // for details about memory ordering.
+        if self.header().refs.fetch_sub(1, Ordering::Release) != 1 {
+            return;
+        }
+
+        // See Arc's drop impl for details.
+        atomic::fence(Ordering::Acquire);
+
+        // Safety:
+        // No other content references the backing allocation (just checked)
+        unsafe {
+            self.handle_mut().drop();
+        }
+    }
+}
+
+impl PartialEq for RawContent {
+    fn eq(&self, other: &Self) -> bool {
+        let Some(handle) = self.handle_pair(other) else { return false };
+        handle
+            .eq()
+            .unwrap_or_else(|| handle.fields().all(|handle| handle.eq()))
+    }
+}
+
+impl Hash for RawContent {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.elem.hash(state);
+        let header = self.header();
+        header.meta.hash(state);
+        header.hash.get_or_insert_with(|| self.handle().hash()).hash(state);
+        self.span.hash(state);
+    }
+}
+
+// Safety:
+// - Works like `Arc`.
+// - `NativeElement` implies `Send` and `Sync`, see below.
+unsafe impl Sync for RawContent {}
+unsafe impl Send for RawContent {}
+
+fn _ensure_send_sync<T: NativeElement>() {
+    fn needs_send_sync<T: Send + Sync>() {}
+    needs_send_sync::<T>();
+}
+
+#[cold]
+fn ref_count_overflow(ptr: NonNull<Header>, elem: Element, span: Span) -> ! {
+    // Drop to decrement the ref count to counter the increment in `clone()`
+    drop(RawContent { ptr, elem, span });
+    panic!("reference count overflow");
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::foundations::{NativeElement, Repr, StyleChain, Value};
+    use crate::introspection::Location;
+    use crate::model::HeadingElem;
+    use crate::text::TextElem;
+
+    #[test]
+    fn test_miri() {
+        let styles = StyleChain::default();
+
+        let mut first = HeadingElem::new(TextElem::packed("Hi!")).with_offset(2).pack();
+        let hash1 = typst_utils::hash128(&first);
+        first.set_location(Location::new(10));
+        let _ = format!("{first:?}");
+        let _ = first.repr();
+
+        assert!(first.is::<HeadingElem>());
+        assert!(!first.is::<TextElem>());
+        assert_eq!(first.to_packed::<TextElem>(), None);
+        assert_eq!(first.location(), Some(Location::new(10)));
+        assert_eq!(first.field_by_name("offset"), Ok(Value::Int(2)));
+        assert!(!first.has("depth".into()));
+
+        let second = first.clone();
+        first.materialize(styles);
+
+        let first_packed = first.to_packed::<HeadingElem>().unwrap();
+        let second_packed = second.to_packed::<HeadingElem>().unwrap();
+
+        assert!(first.has("depth".into()));
+        assert!(!second.has("depth".into()));
+        assert!(first_packed.depth.is_set());
+        assert!(!second_packed.depth.is_set());
+        assert_ne!(first, second);
+        assert_ne!(hash1, typst_utils::hash128(&first));
+    }
+}
diff --git a/crates/typst-library/src/foundations/content/vtable.rs b/crates/typst-library/src/foundations/content/vtable.rs
new file mode 100644
index 000000000..fdc9d4237
--- /dev/null
+++ b/crates/typst-library/src/foundations/content/vtable.rs
@@ -0,0 +1,383 @@
+//! A custom [vtable] implementation for content.
+//!
+//! This is similar to what is generated by the Rust compiler under the hood
+//! when using trait objects. However, ours has two key advantages:
+//!
+//! - It can store a _slice_ of sub-vtables for field-specific operations.
+//! - It can store not only methods, but also plain data, allowing us to access
+//!   that data without going through dynamic dispatch.
+//!
+//! Because our vtable pointers are backed by `static` variables, we can also
+//! perform checks for element types by comparing raw vtable pointers giving us
+//! `RawContent::is` without dynamic dispatch.
+//!
+//! Overall, the custom vtable gives us just a little more flexibility and
+//! optimizability than using built-in trait objects.
+//!
+//! Note that all vtable methods receive elements of type `Packed<E>`, but some
+//! only perform actions on the `E` itself, with the shared part kept outside of
+//! the vtable (e.g. `hash`), while some perform the full action (e.g. `clone`
+//! as it needs to return new, fully populated raw content). Which one it is, is
+//! documented for each.
+//!
+//! # Safety
+//! This module contains a lot of `unsafe` keywords, but almost all of it is the
+//! same and quite straightfoward. All function pointers that operate on a
+//! specific element type are marked as unsafe. In combination with `repr(C)`,
+//! this grants us the ability to safely transmute a `ContentVtable<Packed<E>>`
+//! into a `ContentVtable<RawContent>` (or just short `ContentVtable`). Callers
+//! of functions marked as unsafe have to guarantee that the `ContentVtable` was
+//! transmuted from the same `E` as the RawContent was constructed from. The
+//! `Handle` struct provides a safe access layer, moving the guarantee that the
+//! vtable is matching into a single spot.
+//!
+//! [vtable]: https://en.wikipedia.org/wiki/Virtual_method_table
+
+use std::any::TypeId;
+use std::fmt::{self, Debug, Formatter};
+use std::ops::Deref;
+use std::ptr::NonNull;
+
+use ecow::EcoString;
+
+use super::raw::RawContent;
+use crate::diag::SourceResult;
+use crate::engine::Engine;
+use crate::foundations::{
+    Args, CastInfo, Construct, Content, LazyElementStore, NativeElement, NativeScope,
+    Packed, Repr, Scope, Set, StyleChain, Styles, Value,
+};
+use crate::text::{Lang, LocalName, Region};
+
+/// Encapsulates content and a vtable, granting safe access to vtable operations.
+pub(super) struct Handle<T, V: 'static>(T, &'static V);
+
+impl<T, V> Handle<T, V> {
+    /// Produces a new handle from content and a vtable.
+    ///
+    /// # Safety
+    /// The content and vtable must be matching, i.e. `vtable` must be derived
+    /// from the content's vtable.
+    pub(super) unsafe fn new(content: T, vtable: &'static V) -> Self {
+        Self(content, vtable)
+    }
+}
+
+impl<T, V> Deref for Handle<T, V> {
+    type Target = V;
+
+    fn deref(&self) -> &Self::Target {
+        self.1
+    }
+}
+
+pub(super) type ContentHandle<T> = Handle<T, ContentVtable>;
+pub(super) type FieldHandle<T> = Handle<T, FieldVtable>;
+
+/// A vtable for performing element-specific actions on type-erased content.
+/// Also contains general metadata for the specific element.
+#[repr(C)]
+pub struct ContentVtable<T: 'static = RawContent> {
+    /// The element's normal name, as in code.
+    pub(super) name: &'static str,
+    /// The element's title-cased name.
+    pub(super) title: &'static str,
+    /// The element's documentation (as Markdown).
+    pub(super) docs: &'static str,
+    /// Search keywords for the documentation.
+    pub(super) keywords: &'static [&'static str],
+
+    /// Subvtables for all fields of the element.
+    pub(super) fields: &'static [FieldVtable<T>],
+    /// Determines the ID for a field name. This is a separate function instead
+    /// of searching through `fields` so that Rust can generate optimized code
+    /// for the string matching.
+    pub(super) field_id: fn(name: &str) -> Option<u8>,
+
+    /// The constructor of the element.
+    pub(super) construct: fn(&mut Engine, &mut Args) -> SourceResult<Content>,
+    /// The set rule of the element.
+    pub(super) set: fn(&mut Engine, &mut Args) -> SourceResult<Styles>,
+    /// The element's local name in a specific lang-region pairing.
+    pub(super) local_name: Option<fn(Lang, Option<Region>) -> &'static str>,
+    /// Produces the associated [`Scope`] of the element.
+    pub(super) scope: fn() -> Scope,
+    /// If the `capability` function returns `Some(p)`, then `p` must be a valid
+    /// pointer to a native Rust vtable of `Packed<Self>` w.r.t to the trait `C`
+    /// where `capability` is `TypeId::of::<dyn C>()`.
+    pub(super) capability: fn(capability: TypeId) -> Option<NonNull<()>>,
+
+    /// The `Drop` impl (for the whole raw content). The content must have a
+    /// reference count of zero and may not be used anymore after `drop` was
+    /// called.
+    pub(super) drop: unsafe fn(&mut RawContent),
+    /// The `Clone` impl (for the whole raw content).
+    pub(super) clone: unsafe fn(&T) -> RawContent,
+    /// The `Hash` impl (for just the element).
+    pub(super) hash: unsafe fn(&T) -> u128,
+    /// The `Debug` impl (for just the element).
+    pub(super) debug: unsafe fn(&T, &mut Formatter) -> fmt::Result,
+    /// The `PartialEq` impl (for just the element). If this is `None`,
+    /// field-wise equality checks (via `FieldVtable`) should be performed.
+    pub(super) eq: Option<unsafe fn(&T, &T) -> bool>,
+    /// The `Repr` impl (for just the element). If this is `None`, a generic
+    /// name + fields representation should be produced.
+    pub(super) repr: Option<unsafe fn(&T) -> EcoString>,
+
+    /// Produces a reference to a `static` variable holding a `LazyElementStore`
+    /// that is unique for this element and can be populated with data that is
+    /// somewhat costly to initialize at runtime and shouldn't be initialized
+    /// over and over again. Must be a function rather than a direct reference
+    /// so that we can store the vtable in a `const` without Rust complaining
+    /// about the presence of interior mutability.
+    pub(super) store: fn() -> &'static LazyElementStore,
+}
+
+impl ContentVtable {
+    /// Creates the vtable for an element.
+    pub const fn new<E: NativeElement>(
+        name: &'static str,
+        title: &'static str,
+        docs: &'static str,
+        fields: &'static [FieldVtable<Packed<E>>],
+        field_id: fn(name: &str) -> Option<u8>,
+        capability: fn(TypeId) -> Option<NonNull<()>>,
+        store: fn() -> &'static LazyElementStore,
+    ) -> ContentVtable<Packed<E>> {
+        ContentVtable {
+            name,
+            title,
+            docs,
+            keywords: &[],
+            fields,
+            field_id,
+            construct: <E as Construct>::construct,
+            set: <E as Set>::set,
+            local_name: None,
+            scope: || Scope::new(),
+            capability,
+            drop: RawContent::drop_impl::<E>,
+            clone: RawContent::clone_impl::<E>,
+            hash: |elem| typst_utils::hash128(elem.as_ref()),
+            debug: |elem, f| Debug::fmt(elem.as_ref(), f),
+            eq: None,
+            repr: None,
+            store,
+        }
+    }
+
+    /// Retrieves the vtable of the element with the given ID.
+    pub fn field(&self, id: u8) -> Option<&'static FieldVtable> {
+        self.fields.get(usize::from(id))
+    }
+}
+
+impl<E: NativeElement> ContentVtable<Packed<E>> {
+    /// Attaches search keywords for the documentation.
+    pub const fn with_keywords(mut self, keywords: &'static [&'static str]) -> Self {
+        self.keywords = keywords;
+        self
+    }
+
+    /// Takes a [`Repr`] impl into account.
+    pub const fn with_repr(mut self) -> Self
+    where
+        E: Repr,
+    {
+        self.repr = Some(|e| E::repr(&**e));
+        self
+    }
+
+    /// Takes a [`PartialEq`] impl into account.
+    pub const fn with_partial_eq(mut self) -> Self
+    where
+        E: PartialEq,
+    {
+        self.eq = Some(|a, b| E::eq(&**a, &**b));
+        self
+    }
+
+    /// Takes a [`LocalName`] impl into account.
+    pub const fn with_local_name(mut self) -> Self
+    where
+        Packed<E>: LocalName,
+    {
+        self.local_name = Some(<Packed<E> as LocalName>::local_name);
+        self
+    }
+
+    /// Takes a [`NativeScope`] impl into account.
+    pub const fn with_scope(mut self) -> Self
+    where
+        E: NativeScope,
+    {
+        self.scope = || E::scope();
+        self
+    }
+
+    /// Type-erases the data.
+    pub const fn erase(self) -> ContentVtable {
+        // Safety:
+        // - `ContentVtable` is `repr(C)`.
+        // - `ContentVtable` does not hold any `E`-specific data except for
+        //   function pointers.
+        // - All functions pointers have the same memory layout.
+        // - All functions containing `E` are marked as unsafe and callers need
+        //   to uphold the guarantee that they only call them with raw content
+        //   that is of type `E`.
+        // - `Packed<E>` and `RawContent` have the exact same memory layout
+        //   because of `repr(transparent)`.
+        unsafe {
+            std::mem::transmute::<ContentVtable<Packed<E>>, ContentVtable<RawContent>>(
+                self,
+            )
+        }
+    }
+}
+
+impl<T> ContentHandle<T> {
+    /// Provides safe access to operations for the field with the given `id`.
+    pub(super) fn field(self, id: u8) -> Option<FieldHandle<T>> {
+        self.fields.get(usize::from(id)).map(|vtable| {
+            // Safety: Field vtables are of same type as the content vtable.
+            unsafe { Handle::new(self.0, vtable) }
+        })
+    }
+
+    /// Provides safe access to all field operations.
+    pub(super) fn fields(self) -> impl Iterator<Item = FieldHandle<T>>
+    where
+        T: Copy,
+    {
+        self.fields.iter().map(move |vtable| {
+            // Safety: Field vtables are of same type as the content vtable.
+            unsafe { Handle::new(self.0, vtable) }
+        })
+    }
+}
+
+impl ContentHandle<&RawContent> {
+    /// See [`ContentVtable::debug`].
+    pub fn debug(&self, f: &mut Formatter) -> fmt::Result {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { (self.1.debug)(self.0, f) }
+    }
+
+    /// See [`ContentVtable::repr`].
+    pub fn repr(&self) -> Option<EcoString> {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { self.1.repr.map(|f| f(self.0)) }
+    }
+
+    /// See [`ContentVtable::clone`].
+    pub fn clone(&self) -> RawContent {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { (self.1.clone)(self.0) }
+    }
+
+    /// See [`ContentVtable::hash`].
+    pub fn hash(&self) -> u128 {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { (self.1.hash)(self.0) }
+    }
+}
+
+impl ContentHandle<&mut RawContent> {
+    /// See [`ContentVtable::drop`].
+    pub unsafe fn drop(&mut self) {
+        // Safety:
+        // - `Handle` has the invariant that the vtable is matching.
+        // - The caller satifies the requirements of `drop`
+        unsafe { (self.1.drop)(self.0) }
+    }
+}
+
+impl ContentHandle<(&RawContent, &RawContent)> {
+    /// See [`ContentVtable::eq`].
+    pub fn eq(&self) -> Option<bool> {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        let (a, b) = self.0;
+        unsafe { self.1.eq.map(|f| f(a, b)) }
+    }
+}
+
+/// A vtable for performing field-specific actions on type-erased
+/// content. Also contains general metadata for the specific field.
+#[repr(C)]
+pub struct FieldVtable<T: 'static = RawContent> {
+    /// The field's name, as in code.
+    pub(super) name: &'static str,
+    /// The fields's documentation (as Markdown).
+    pub(super) docs: &'static str,
+
+    /// Whether the field's parameter is positional.
+    pub(super) positional: bool,
+    /// Whether the field's parameter is variadic.
+    pub(super) variadic: bool,
+    /// Whether the field's parameter is required.
+    pub(super) required: bool,
+    /// Whether the field can be set via a set rule.
+    pub(super) settable: bool,
+    /// Whether the field is synthesized (i.e. initially not present).
+    pub(super) synthesized: bool,
+    /// Reflects what types the field's parameter accepts.
+    pub(super) input: fn() -> CastInfo,
+    /// Produces the default value of the field, if any. This would e.g. be
+    /// `None` for a required parameter.
+    pub(super) default: Option<fn() -> Value>,
+
+    /// Whether the field is set on the given element. Always true for required
+    /// fields, but can be false for settable or synthesized fields.
+    pub(super) has: unsafe fn(elem: &T) -> bool,
+    /// Retrieves the field and [turns it into a
+    /// value](crate::foundations::IntoValue).
+    pub(super) get: unsafe fn(elem: &T) -> Option<Value>,
+    /// Retrieves the field given styles. The resulting value may come from the
+    /// element, the style chain, or a mix (if it's a
+    /// [`Fold`](crate::foundations::Fold) field).
+    pub(super) get_with_styles: unsafe fn(elem: &T, StyleChain) -> Option<Value>,
+    /// Retrieves the field just from the styles.
+    pub(super) get_from_styles: fn(StyleChain) -> Option<Value>,
+    /// Sets the field from the styles if it is currently unset. (Or merges
+    /// with the style data in case of a `Fold` field).
+    pub(super) materialize: unsafe fn(elem: &mut T, styles: StyleChain),
+    /// Compares the field for equality.
+    pub(super) eq: unsafe fn(a: &T, b: &T) -> bool,
+}
+
+impl FieldHandle<&RawContent> {
+    /// See [`FieldVtable::has`].
+    pub fn has(&self) -> bool {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { (self.1.has)(self.0) }
+    }
+
+    /// See [`FieldVtable::get`].
+    pub fn get(&self) -> Option<Value> {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { (self.1.get)(self.0) }
+    }
+
+    /// See [`FieldVtable::get_with_styles`].
+    pub fn get_with_styles(&self, styles: StyleChain) -> Option<Value> {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { (self.1.get_with_styles)(self.0, styles) }
+    }
+}
+
+impl FieldHandle<&mut RawContent> {
+    /// See [`FieldVtable::materialize`].
+    pub fn materialize(&mut self, styles: StyleChain) {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        unsafe { (self.1.materialize)(self.0, styles) }
+    }
+}
+
+impl FieldHandle<(&RawContent, &RawContent)> {
+    /// See [`FieldVtable::eq`].
+    pub fn eq(&self) -> bool {
+        // Safety: `Handle` has the invariant that the vtable is matching.
+        let (a, b) = self.0;
+        unsafe { (self.1.eq)(a, b) }
+    }
+}
diff --git a/crates/typst-library/src/foundations/mod.rs b/crates/typst-library/src/foundations/mod.rs
index 6840f855d..382beb2cd 100644
--- a/crates/typst-library/src/foundations/mod.rs
+++ b/crates/typst-library/src/foundations/mod.rs
@@ -17,7 +17,6 @@ mod datetime;
 mod decimal;
 mod dict;
 mod duration;
-mod element;
 mod fields;
 mod float;
 mod func;
@@ -49,7 +48,6 @@ pub use self::datetime::*;
 pub use self::decimal::*;
 pub use self::dict::*;
 pub use self::duration::*;
-pub use self::element::*;
 pub use self::fields::*;
 pub use self::float::*;
 pub use self::func::*;
diff --git a/crates/typst-library/src/foundations/scope.rs b/crates/typst-library/src/foundations/scope.rs
index e1ce61b8a..838584ccd 100644
--- a/crates/typst-library/src/foundations/scope.rs
+++ b/crates/typst-library/src/foundations/scope.rs
@@ -8,8 +8,7 @@ use typst_syntax::Span;
 
 use crate::diag::{bail, DeprecationSink, HintedStrResult, HintedString, StrResult};
 use crate::foundations::{
-    Element, Func, IntoValue, NativeElement, NativeFunc, NativeFuncData, NativeType,
-    Type, Value,
+    Func, IntoValue, NativeElement, NativeFunc, NativeFuncData, NativeType, Value,
 };
 use crate::{Category, Library};
 
@@ -149,15 +148,15 @@ impl Scope {
     /// Define a native type.
     #[track_caller]
     pub fn define_type<T: NativeType>(&mut self) -> &mut Binding {
-        let data = T::data();
-        self.define(data.name, Type::from(data))
+        let ty = T::ty();
+        self.define(ty.short_name(), ty)
     }
 
     /// Define a native element.
     #[track_caller]
     pub fn define_elem<T: NativeElement>(&mut self) -> &mut Binding {
-        let data = T::data();
-        self.define(data.name, Element::from(data))
+        let elem = T::ELEM;
+        self.define(elem.name(), elem)
     }
 
     /// Define a built-in with compile-time known name and returns a mutable
diff --git a/crates/typst-library/src/foundations/selector.rs b/crates/typst-library/src/foundations/selector.rs
index bf5449d94..8f264a813 100644
--- a/crates/typst-library/src/foundations/selector.rs
+++ b/crates/typst-library/src/foundations/selector.rs
@@ -21,12 +21,12 @@ macro_rules! __select_where {
         let mut fields = ::smallvec::SmallVec::new();
         $(
             fields.push((
-                <$ty as $crate::foundations::Fields>::Enum::$field as u8,
+                <$ty>::$field.index(),
                 $crate::foundations::IntoValue::into_value($value),
             ));
         )*
         $crate::foundations::Selector::Elem(
-            <$ty as $crate::foundations::NativeElement>::elem(),
+            <$ty as $crate::foundations::NativeElement>::ELEM,
             Some(fields),
         )
     }};
diff --git a/crates/typst-library/src/foundations/styles.rs b/crates/typst-library/src/foundations/styles.rs
index d124f2c87..978b47d5f 100644
--- a/crates/typst-library/src/foundations/styles.rs
+++ b/crates/typst-library/src/foundations/styles.rs
@@ -12,8 +12,8 @@ use typst_utils::LazyHash;
 use crate::diag::{SourceResult, Trace, Tracepoint};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, ty, Content, Context, Element, Func, NativeElement, OneOrMultiple, Repr,
-    Selector,
+    cast, ty, Content, Context, Element, Field, Func, NativeElement, OneOrMultiple,
+    RefableProperty, Repr, Selector, SettableProperty,
 };
 use crate::text::{FontFamily, FontList, TextElem};
 
@@ -48,7 +48,16 @@ impl Styles {
     /// If the property needs folding and the value is already contained in the
     /// style map, `self` contributes the outer values and `value` is the inner
     /// one.
-    pub fn set(&mut self, style: impl Into<Style>) {
+    pub fn set<E, const I: u8>(&mut self, field: Field<E, I>, value: E::Type)
+    where
+        E: SettableProperty<I>,
+        E::Type: Debug + Clone + Hash + Send + Sync + 'static,
+    {
+        self.push(Property::new(field, value));
+    }
+
+    /// Add a new style to the list.
+    pub fn push(&mut self, style: impl Into<Style>) {
         self.0.push(LazyHash::new(style.into()));
     }
 
@@ -101,22 +110,25 @@ impl Styles {
     }
 
     /// Whether there is a style for the given field of the given element.
-    pub fn has<T: NativeElement>(&self, field: u8) -> bool {
-        let elem = T::elem();
+    pub fn has<E: NativeElement, const I: u8>(&self, _: Field<E, I>) -> bool {
+        let elem = E::ELEM;
         self.0
             .iter()
             .filter_map(|style| style.property())
-            .any(|property| property.is_of(elem) && property.id == field)
+            .any(|property| property.is_of(elem) && property.id == I)
     }
 
     /// Set a font family composed of a preferred family and existing families
     /// from a style chain.
     pub fn set_family(&mut self, preferred: FontFamily, existing: StyleChain) {
-        self.set(TextElem::set_font(FontList(
-            std::iter::once(preferred)
-                .chain(TextElem::font_in(existing).into_iter().cloned())
-                .collect(),
-        )));
+        self.set(
+            TextElem::font,
+            FontList(
+                std::iter::once(preferred)
+                    .chain(existing.get_ref(TextElem::font).into_iter().cloned())
+                    .collect(),
+            ),
+        );
     }
 }
 
@@ -281,14 +293,14 @@ pub struct Property {
 
 impl Property {
     /// Create a new property from a key-value pair.
-    pub fn new<E, T>(id: u8, value: T) -> Self
+    pub fn new<E, const I: u8>(_: Field<E, I>, value: E::Type) -> Self
     where
-        E: NativeElement,
-        T: Debug + Clone + Hash + Send + Sync + 'static,
+        E: SettableProperty<I>,
+        E::Type: Debug + Clone + Hash + Send + Sync + 'static,
     {
         Self {
-            elem: E::elem(),
-            id,
+            elem: E::ELEM,
+            id: I,
             value: Block::new(value),
             span: Span::detached(),
             liftable: false,
@@ -340,8 +352,11 @@ impl Block {
     }
 
     /// Downcasts the block to the specified type.
-    fn downcast<T: 'static>(&self) -> Option<&T> {
-        self.0.as_any().downcast_ref()
+    fn downcast<T: 'static>(&self, func: Element, id: u8) -> &T {
+        self.0
+            .as_any()
+            .downcast_ref()
+            .unwrap_or_else(|| block_wrong_type(func, id, self))
     }
 }
 
@@ -528,6 +543,103 @@ impl<'a> StyleChain<'a> {
         Self { head: &root.0, tail: None }
     }
 
+    /// Retrieves the value of the given field from the style chain.
+    ///
+    /// A `Field` value is a zero-sized value that specifies which field of an
+    /// element you want to retrieve on the type-system level. It also ensures
+    /// that Rust can infer the correct return type.
+    ///
+    /// Should be preferred over [`get_cloned`](Self::get_cloned) or
+    /// [`get_ref`](Self::get_ref), but is only available for [`Copy`] types.
+    /// For other types an explicit decision needs to be made whether cloning is
+    /// necessary.
+    pub fn get<E, const I: u8>(self, field: Field<E, I>) -> E::Type
+    where
+        E: SettableProperty<I>,
+        E::Type: Copy,
+    {
+        self.get_cloned(field)
+    }
+
+    /// Retrieves and clones the value from the style chain.
+    ///
+    /// Prefer [`get`](Self::get) if the type is `Copy` and
+    /// [`get_ref`](Self::get_ref) if a reference suffices.
+    pub fn get_cloned<E, const I: u8>(self, _: Field<E, I>) -> E::Type
+    where
+        E: SettableProperty<I>,
+    {
+        if let Some(fold) = E::FOLD {
+            self.get_folded::<E::Type>(E::ELEM, I, fold, E::default())
+        } else {
+            self.get_unfolded::<E::Type>(E::ELEM, I)
+                .cloned()
+                .unwrap_or_else(E::default)
+        }
+    }
+
+    /// Retrieves a reference to the value of the given field from the style
+    /// chain.
+    ///
+    /// Not possible if the value needs folding.
+    pub fn get_ref<E, const I: u8>(self, _: Field<E, I>) -> &'a E::Type
+    where
+        E: RefableProperty<I>,
+    {
+        self.get_unfolded(E::ELEM, I).unwrap_or_else(|| E::default_ref())
+    }
+
+    /// Retrieves the value and then immediately [resolves](Resolve) it.
+    pub fn resolve<E, const I: u8>(
+        self,
+        field: Field<E, I>,
+    ) -> <E::Type as Resolve>::Output
+    where
+        E: SettableProperty<I>,
+        E::Type: Resolve,
+    {
+        self.get_cloned(field).resolve(self)
+    }
+
+    /// Retrieves a reference to a field, also taking into account the
+    /// instance's value if any.
+    fn get_unfolded<T: 'static>(self, func: Element, id: u8) -> Option<&'a T> {
+        self.find(func, id).map(|block| block.downcast(func, id))
+    }
+
+    /// Retrieves a reference to a field, also taking into account the
+    /// instance's value if any.
+    fn get_folded<T: 'static + Clone>(
+        self,
+        func: Element,
+        id: u8,
+        fold: fn(T, T) -> T,
+        default: T,
+    ) -> T {
+        let iter = self
+            .properties(func, id)
+            .map(|block| block.downcast::<T>(func, id).clone());
+
+        if let Some(folded) = iter.reduce(fold) {
+            fold(folded, default)
+        } else {
+            default
+        }
+    }
+
+    /// Iterate over all values for the given property in the chain.
+    fn find(self, func: Element, id: u8) -> Option<&'a Block> {
+        self.properties(func, id).next()
+    }
+
+    /// Iterate over all values for the given property in the chain.
+    fn properties(self, func: Element, id: u8) -> impl Iterator<Item = &'a Block> {
+        self.entries()
+            .filter_map(|style| style.property())
+            .filter(move |property| property.is(func, id))
+            .map(|property| &property.value)
+    }
+
     /// Make the given chainable the first link of this chain.
     ///
     /// The resulting style chain contains styles from `local` as well as
@@ -540,80 +652,6 @@ impl<'a> StyleChain<'a> {
         Chainable::chain(local, self)
     }
 
-    /// Cast the first value for the given property in the chain.
-    pub fn get<T: Clone + 'static>(
-        self,
-        func: Element,
-        id: u8,
-        inherent: Option<&T>,
-        default: impl Fn() -> T,
-    ) -> T {
-        self.properties::<T>(func, id, inherent)
-            .next()
-            .cloned()
-            .unwrap_or_else(default)
-    }
-
-    /// Cast the first value for the given property in the chain,
-    /// returning a borrowed value.
-    pub fn get_ref<T: 'static>(
-        self,
-        func: Element,
-        id: u8,
-        inherent: Option<&'a T>,
-        default: impl Fn() -> &'a T,
-    ) -> &'a T {
-        self.properties::<T>(func, id, inherent)
-            .next()
-            .unwrap_or_else(default)
-    }
-
-    /// Cast the first value for the given property in the chain, taking
-    /// `Fold` implementations into account.
-    pub fn get_folded<T: Fold + Clone + 'static>(
-        self,
-        func: Element,
-        id: u8,
-        inherent: Option<&T>,
-        default: impl Fn() -> T,
-    ) -> T {
-        fn next<T: Fold>(
-            mut values: impl Iterator<Item = T>,
-            default: &impl Fn() -> T,
-        ) -> T {
-            values
-                .next()
-                .map(|value| value.fold(next(values, default)))
-                .unwrap_or_else(default)
-        }
-        next(self.properties::<T>(func, id, inherent).cloned(), &default)
-    }
-
-    /// Iterate over all values for the given property in the chain.
-    fn properties<T: 'static>(
-        self,
-        func: Element,
-        id: u8,
-        inherent: Option<&'a T>,
-    ) -> impl Iterator<Item = &'a T> {
-        inherent.into_iter().chain(
-            self.entries()
-                .filter_map(|style| style.property())
-                .filter(move |property| property.is(func, id))
-                .map(|property| &property.value)
-                .map(move |value| {
-                    value.downcast().unwrap_or_else(|| {
-                        panic!(
-                            "attempted to read a value of a different type than was written {}.{}: {:?}",
-                            func.name(),
-                            func.field_name(id).unwrap(),
-                            value
-                        )
-                    })
-                }),
-        )
-    }
-
     /// Iterate over the entries of the chain.
     pub fn entries(self) -> Entries<'a> {
         Entries { inner: [].as_slice().iter(), links: self.links() }
@@ -804,6 +842,9 @@ impl<T: Resolve> Resolve for Option<T> {
 /// #set rect(stroke: 4pt)
 /// #rect()
 /// ```
+///
+/// Note: Folding must be associative, i.e. any implementation must satisfy
+/// `fold(fold(a, b), c) == fold(a, fold(b, c))`.
 pub trait Fold {
     /// Fold this inner value with an outer folded value.
     fn fold(self, outer: Self) -> Self;
@@ -847,6 +888,9 @@ impl<T> Fold for OneOrMultiple<T> {
     }
 }
 
+/// A [folding](Fold) function.
+pub type FoldFn<T> = fn(T, T) -> T;
+
 /// A variant of fold for foldable optional (`Option<T>`) values where an inner
 /// `None` value isn't respected (contrary to `Option`'s usual `Fold`
 /// implementation, with which folding with an inner `None` always returns
@@ -884,3 +928,13 @@ impl Fold for Depth {
         Self(outer.0 + self.0)
     }
 }
+
+#[cold]
+fn block_wrong_type(func: Element, id: u8, value: &Block) -> ! {
+    panic!(
+        "attempted to read a value of a different type than was written {}.{}: {:?}",
+        func.name(),
+        func.field_name(id).unwrap(),
+        value
+    )
+}
diff --git a/crates/typst-library/src/foundations/target.rs b/crates/typst-library/src/foundations/target.rs
index 2a21fd42b..71e7554e0 100644
--- a/crates/typst-library/src/foundations/target.rs
+++ b/crates/typst-library/src/foundations/target.rs
@@ -73,5 +73,5 @@ pub struct TargetElem {
 /// ```
 #[func(contextual)]
 pub fn target(context: Tracked<Context>) -> HintedStrResult<Target> {
-    Ok(TargetElem::target_in(context.styles()?))
+    Ok(context.styles()?.get(TargetElem::target))
 }
diff --git a/crates/typst-library/src/html/mod.rs b/crates/typst-library/src/html/mod.rs
index 7fc8adecd..f98352061 100644
--- a/crates/typst-library/src/html/mod.rs
+++ b/crates/typst-library/src/html/mod.rs
@@ -47,21 +47,22 @@ pub struct HtmlElem {
     pub tag: HtmlTag,
 
     /// The element's HTML attributes.
-    #[borrowed]
     pub attrs: HtmlAttrs,
 
     /// The contents of the HTML element.
     ///
     /// The body can be arbitrary Typst content.
     #[positional]
-    #[borrowed]
     pub body: Option<Content>,
 }
 
 impl HtmlElem {
     /// Add an attribute to the element.
     pub fn with_attr(mut self, attr: HtmlAttr, value: impl Into<EcoString>) -> Self {
-        self.attrs.get_or_insert_with(Default::default).push(attr, value);
+        self.attrs
+            .as_option_mut()
+            .get_or_insert_with(Default::default)
+            .push(attr, value);
         self
     }
 }
diff --git a/crates/typst-library/src/html/typed.rs b/crates/typst-library/src/html/typed.rs
index 1e7c1ad6f..8240b2963 100644
--- a/crates/typst-library/src/html/typed.rs
+++ b/crates/typst-library/src/html/typed.rs
@@ -127,12 +127,12 @@ fn construct(element: &'static data::ElemInfo, args: &mut Args) -> SourceResult<
     let tag = HtmlTag::constant(element.name);
     let mut elem = HtmlElem::new(tag);
     if !attrs.0.is_empty() {
-        elem.push_attrs(attrs);
+        elem.attrs.set(attrs);
     }
 
     if !tag::is_void(tag) {
         let body = args.eat::<Content>()?;
-        elem.push_body(body);
+        elem.body.set(body);
     }
 
     Ok(elem.into_value())
diff --git a/crates/typst-library/src/introspection/counter.rs b/crates/typst-library/src/introspection/counter.rs
index 772bea963..a7925e13a 100644
--- a/crates/typst-library/src/introspection/counter.rs
+++ b/crates/typst-library/src/introspection/counter.rs
@@ -338,7 +338,7 @@ impl Counter {
 
     /// The selector relevant for this counter's updates.
     fn selector(&self) -> Selector {
-        let mut selector = select_where!(CounterUpdateElem, Key => self.0.clone());
+        let mut selector = select_where!(CounterUpdateElem, key => self.0.clone());
 
         if let CounterKey::Selector(key) = &self.0 {
             selector = Selector::Or(eco_vec![selector, key.clone()]);
@@ -367,16 +367,16 @@ impl Counter {
             .or_else(|| {
                 let styles = styles?;
                 match self.0 {
-                    CounterKey::Page => PageElem::numbering_in(styles).clone(),
+                    CounterKey::Page => styles.get_cloned(PageElem::numbering),
                     CounterKey::Selector(Selector::Elem(func, _)) => {
-                        if func == HeadingElem::elem() {
-                            HeadingElem::numbering_in(styles).clone()
-                        } else if func == FigureElem::elem() {
-                            FigureElem::numbering_in(styles).clone()
-                        } else if func == EquationElem::elem() {
-                            EquationElem::numbering_in(styles).clone()
-                        } else if func == FootnoteElem::elem() {
-                            Some(FootnoteElem::numbering_in(styles).clone())
+                        if func == HeadingElem::ELEM {
+                            styles.get_cloned(HeadingElem::numbering)
+                        } else if func == FigureElem::ELEM {
+                            styles.get_cloned(FigureElem::numbering)
+                        } else if func == EquationElem::ELEM {
+                            styles.get_cloned(EquationElem::numbering)
+                        } else if func == FootnoteElem::ELEM {
+                            Some(styles.get_cloned(FootnoteElem::numbering))
                         } else {
                             None
                         }
@@ -398,7 +398,7 @@ impl Counter {
 
     /// Selects all state updates.
     pub fn select_any() -> Selector {
-        CounterUpdateElem::elem().select()
+        CounterUpdateElem::ELEM.select()
     }
 }
 
@@ -565,14 +565,14 @@ pub enum CounterKey {
 cast! {
     CounterKey,
     self => match self {
-        Self::Page => PageElem::elem().into_value(),
+        Self::Page => PageElem::ELEM.into_value(),
         Self::Selector(v) => v.into_value(),
         Self::Str(v) => v.into_value(),
     },
     v: Str => Self::Str(v),
     v: Label => Self::Selector(Selector::Label(v)),
     v: Element => {
-        if v == PageElem::elem() {
+        if v == PageElem::ELEM {
             Self::Page
         } else {
             Self::Selector(LocatableSelector::from_value(v.into_value())?.0)
diff --git a/crates/typst-library/src/introspection/state.rs b/crates/typst-library/src/introspection/state.rs
index cc3f566b5..784f2acb2 100644
--- a/crates/typst-library/src/introspection/state.rs
+++ b/crates/typst-library/src/introspection/state.rs
@@ -259,12 +259,12 @@ impl State {
 
     /// The selector for this state's updates.
     fn selector(&self) -> Selector {
-        select_where!(StateUpdateElem, Key => self.key.clone())
+        select_where!(StateUpdateElem, key => self.key.clone())
     }
 
     /// Selects all state updates.
     pub fn select_any() -> Selector {
-        StateUpdateElem::elem().select()
+        StateUpdateElem::ELEM.select()
     }
 }
 
diff --git a/crates/typst-library/src/layout/align.rs b/crates/typst-library/src/layout/align.rs
index 0a978dbae..e5ceddf65 100644
--- a/crates/typst-library/src/layout/align.rs
+++ b/crates/typst-library/src/layout/align.rs
@@ -100,7 +100,7 @@ pub struct AlignElem {
 impl Show for Packed<AlignElem> {
     #[typst_macros::time(name = "align", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(self.body.clone().aligned(self.alignment(styles)))
+        Ok(self.body.clone().aligned(self.alignment.get(styles)))
     }
 }
 
@@ -277,7 +277,7 @@ impl Resolve for Alignment {
     type Output = Axes<FixedAlignment>;
 
     fn resolve(self, styles: StyleChain) -> Self::Output {
-        self.fix(TextElem::dir_in(styles))
+        self.fix(styles.resolve(TextElem::dir))
     }
 }
 
@@ -378,7 +378,7 @@ impl Resolve for HAlignment {
     type Output = FixedAlignment;
 
     fn resolve(self, styles: StyleChain) -> Self::Output {
-        self.fix(TextElem::dir_in(styles))
+        self.fix(styles.resolve(TextElem::dir))
     }
 }
 
@@ -414,7 +414,7 @@ impl Resolve for OuterHAlignment {
     type Output = FixedAlignment;
 
     fn resolve(self, styles: StyleChain) -> Self::Output {
-        self.fix(TextElem::dir_in(styles))
+        self.fix(styles.resolve(TextElem::dir))
     }
 }
 
@@ -636,7 +636,7 @@ where
     type Output = Axes<FixedAlignment>;
 
     fn resolve(self, styles: StyleChain) -> Self::Output {
-        self.fix(TextElem::dir_in(styles))
+        self.fix(styles.resolve(TextElem::dir))
     }
 }
 
diff --git a/crates/typst-library/src/layout/columns.rs b/crates/typst-library/src/layout/columns.rs
index f2f364417..1cea52759 100644
--- a/crates/typst-library/src/layout/columns.rs
+++ b/crates/typst-library/src/layout/columns.rs
@@ -49,7 +49,6 @@ pub struct ColumnsElem {
     pub count: NonZeroUsize,
 
     /// The size of the gutter space between each column.
-    #[resolve]
     #[default(Ratio::new(0.04).into())]
     pub gutter: Rel<Length>,
 
diff --git a/crates/typst-library/src/layout/container.rs b/crates/typst-library/src/layout/container.rs
index fc27644e2..cff66fe38 100644
--- a/crates/typst-library/src/layout/container.rs
+++ b/crates/typst-library/src/layout/container.rs
@@ -51,7 +51,6 @@ pub struct BoxElem {
     /// ```example
     /// Image: #box(baseline: 40%, image("tiger.jpg", width: 2cm)).
     /// ```
-    #[resolve]
     pub baseline: Rel<Length>,
 
     /// The box's background color. See the
@@ -60,13 +59,11 @@ pub struct BoxElem {
 
     /// The box's border color. See the
     /// [rectangle's documentation]($rect.stroke) for more details.
-    #[resolve]
     #[fold]
     pub stroke: Sides<Option<Option<Stroke>>>,
 
     /// How much to round the box's corners. See the
     /// [rectangle's documentation]($rect.radius) for more details.
-    #[resolve]
     #[fold]
     pub radius: Corners<Option<Rel<Length>>>,
 
@@ -78,7 +75,6 @@ pub struct BoxElem {
     /// ```example
     /// #rect(inset: 0pt)[Tight]
     /// ```
-    #[resolve]
     #[fold]
     pub inset: Sides<Option<Rel<Length>>>,
 
@@ -97,7 +93,6 @@ pub struct BoxElem {
     ///   radius: 2pt,
     /// )[rectangle].
     /// ```
-    #[resolve]
     #[fold]
     pub outset: Sides<Option<Rel<Length>>>,
 
@@ -119,7 +114,6 @@ pub struct BoxElem {
 
     /// The contents of the box.
     #[positional]
-    #[borrowed]
     pub body: Option<Content>,
 }
 
@@ -262,25 +256,21 @@ pub struct BlockElem {
 
     /// The block's border color. See the
     /// [rectangle's documentation]($rect.stroke) for more details.
-    #[resolve]
     #[fold]
     pub stroke: Sides<Option<Option<Stroke>>>,
 
     /// How much to round the block's corners. See the
     /// [rectangle's documentation]($rect.radius) for more details.
-    #[resolve]
     #[fold]
     pub radius: Corners<Option<Rel<Length>>>,
 
     /// How much to pad the block's content. See the
     /// [box's documentation]($box.inset) for more details.
-    #[resolve]
     #[fold]
     pub inset: Sides<Option<Rel<Length>>>,
 
     /// How much to expand the block's size without affecting the layout. See
     /// the [box's documentation]($box.outset) for more details.
-    #[resolve]
     #[fold]
     pub outset: Sides<Option<Rel<Length>>>,
 
@@ -358,7 +348,6 @@ pub struct BlockElem {
 
     /// The contents of the block.
     #[positional]
-    #[borrowed]
     pub body: Option<BlockBody>,
 }
 
diff --git a/crates/typst-library/src/layout/em.rs b/crates/typst-library/src/layout/em.rs
index 746e17692..460bf5fa7 100644
--- a/crates/typst-library/src/layout/em.rs
+++ b/crates/typst-library/src/layout/em.rs
@@ -167,7 +167,7 @@ impl Resolve for Em {
         if self.is_zero() {
             Abs::zero()
         } else {
-            self.at(TextElem::size_in(styles))
+            self.at(styles.resolve(TextElem::size))
         }
     }
 }
diff --git a/crates/typst-library/src/layout/grid/mod.rs b/crates/typst-library/src/layout/grid/mod.rs
index 52621c647..64e7464be 100644
--- a/crates/typst-library/src/layout/grid/mod.rs
+++ b/crates/typst-library/src/layout/grid/mod.rs
@@ -144,14 +144,12 @@ pub struct GridElem {
     /// with that many `{auto}`-sized columns. Note that opposed to rows and
     /// gutters, providing a single track size will only ever create a single
     /// column.
-    #[borrowed]
     pub columns: TrackSizings,
 
     /// The row sizes.
     ///
     /// If there are more cells than fit the defined rows, the last row is
     /// repeated until there are no more cells.
-    #[borrowed]
     pub rows: TrackSizings,
 
     /// The gaps between rows and columns.
@@ -169,12 +167,10 @@ pub struct GridElem {
         let gutter = args.named("gutter")?;
         args.named("column-gutter")?.or_else(|| gutter.clone())
     )]
-    #[borrowed]
     pub column_gutter: TrackSizings,
 
     /// The gaps between rows.
     #[parse(args.named("row-gutter")?.or_else(|| gutter.clone()))]
-    #[borrowed]
     pub row_gutter: TrackSizings,
 
     /// How to fill the cells.
@@ -197,7 +193,6 @@ pub struct GridElem {
     ///   [O], [X], [O], [X],
     /// )
     /// ```
-    #[borrowed]
     pub fill: Celled<Option<Paint>>,
 
     /// How to align the cells' content.
@@ -209,7 +204,6 @@ pub struct GridElem {
     ///
     /// You can find an example for this argument at the
     /// [`table.align`]($table.align) parameter.
-    #[borrowed]
     pub align: Celled<Smart<Alignment>>,
 
     /// How to [stroke]($stroke) the cells.
@@ -289,7 +283,6 @@ pub struct GridElem {
     ///   ),
     /// )
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Celled<Sides<Option<Option<Arc<Stroke>>>>>,
 
@@ -541,7 +534,6 @@ pub struct GridHLine {
     ///
     /// Specifying `{none}` removes any lines previously placed across this
     /// line's range, including hlines or per-cell stroke below it.
-    #[resolve]
     #[fold]
     #[default(Some(Arc::new(Stroke::default())))]
     pub stroke: Option<Arc<Stroke>>,
@@ -596,7 +588,6 @@ pub struct GridVLine {
     ///
     /// Specifying `{none}` removes any lines previously placed across this
     /// line's range, including vlines or per-cell stroke below it.
-    #[resolve]
     #[fold]
     #[default(Some(Arc::new(Stroke::default())))]
     pub stroke: Option<Arc<Stroke>>,
@@ -742,7 +733,6 @@ pub struct GridCell {
     pub inset: Smart<Sides<Option<Rel<Length>>>>,
 
     /// The cell's [stroke]($grid.stroke) override.
-    #[resolve]
     #[fold]
     pub stroke: Sides<Option<Option<Arc<Stroke>>>>,
 
@@ -760,7 +750,7 @@ cast! {
 
 impl Show for Packed<GridCell> {
     fn show(&self, _engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        show_grid_cell(self.body.clone(), self.inset(styles), self.align(styles))
+        show_grid_cell(self.body.clone(), self.inset.get(styles), self.align.get(styles))
     }
 }
 
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index baf6b7383..f3004088e 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -31,14 +31,14 @@ pub fn grid_to_cellgrid<'a>(
     locator: Locator<'a>,
     styles: StyleChain,
 ) -> SourceResult<CellGrid<'a>> {
-    let inset = elem.inset(styles);
-    let align = elem.align(styles);
-    let columns = elem.columns(styles);
-    let rows = elem.rows(styles);
-    let column_gutter = elem.column_gutter(styles);
-    let row_gutter = elem.row_gutter(styles);
-    let fill = elem.fill(styles);
-    let stroke = elem.stroke(styles);
+    let inset = elem.inset.get_cloned(styles);
+    let align = elem.align.get_ref(styles);
+    let columns = elem.columns.get_ref(styles);
+    let rows = elem.rows.get_ref(styles);
+    let column_gutter = elem.column_gutter.get_ref(styles);
+    let row_gutter = elem.row_gutter.get_ref(styles);
+    let fill = elem.fill.get_ref(styles);
+    let stroke = elem.stroke.resolve(styles);
 
     let tracks = Axes::new(columns.0.as_slice(), rows.0.as_slice());
     let gutter = Axes::new(column_gutter.0.as_slice(), row_gutter.0.as_slice());
@@ -47,13 +47,13 @@ pub fn grid_to_cellgrid<'a>(
     let resolve_item = |item: &GridItem| grid_item_to_resolvable(item, styles);
     let children = elem.children.iter().map(|child| match child {
         GridChild::Header(header) => ResolvableGridChild::Header {
-            repeat: header.repeat(styles),
-            level: header.level(styles),
+            repeat: header.repeat.get(styles),
+            level: header.level.get(styles),
             span: header.span(),
             items: header.children.iter().map(resolve_item),
         },
         GridChild::Footer(footer) => ResolvableGridChild::Footer {
-            repeat: footer.repeat(styles),
+            repeat: footer.repeat.get(styles),
             span: footer.span(),
             items: footer.children.iter().map(resolve_item),
         },
@@ -85,14 +85,14 @@ pub fn table_to_cellgrid<'a>(
     locator: Locator<'a>,
     styles: StyleChain,
 ) -> SourceResult<CellGrid<'a>> {
-    let inset = elem.inset(styles);
-    let align = elem.align(styles);
-    let columns = elem.columns(styles);
-    let rows = elem.rows(styles);
-    let column_gutter = elem.column_gutter(styles);
-    let row_gutter = elem.row_gutter(styles);
-    let fill = elem.fill(styles);
-    let stroke = elem.stroke(styles);
+    let inset = elem.inset.get_cloned(styles);
+    let align = elem.align.get_ref(styles);
+    let columns = elem.columns.get_ref(styles);
+    let rows = elem.rows.get_ref(styles);
+    let column_gutter = elem.column_gutter.get_ref(styles);
+    let row_gutter = elem.row_gutter.get_ref(styles);
+    let fill = elem.fill.get_ref(styles);
+    let stroke = elem.stroke.resolve(styles);
 
     let tracks = Axes::new(columns.0.as_slice(), rows.0.as_slice());
     let gutter = Axes::new(column_gutter.0.as_slice(), row_gutter.0.as_slice());
@@ -101,13 +101,13 @@ pub fn table_to_cellgrid<'a>(
     let resolve_item = |item: &TableItem| table_item_to_resolvable(item, styles);
     let children = elem.children.iter().map(|child| match child {
         TableChild::Header(header) => ResolvableGridChild::Header {
-            repeat: header.repeat(styles),
-            level: header.level(styles),
+            repeat: header.repeat.get(styles),
+            level: header.level.get(styles),
             span: header.span(),
             items: header.children.iter().map(resolve_item),
         },
         TableChild::Footer(footer) => ResolvableGridChild::Footer {
-            repeat: footer.repeat(styles),
+            repeat: footer.repeat.get(styles),
             span: footer.span(),
             items: footer.children.iter().map(resolve_item),
         },
@@ -137,27 +137,27 @@ fn grid_item_to_resolvable(
 ) -> ResolvableGridItem<Packed<GridCell>> {
     match item {
         GridItem::HLine(hline) => ResolvableGridItem::HLine {
-            y: hline.y(styles),
-            start: hline.start(styles),
-            end: hline.end(styles),
-            stroke: hline.stroke(styles),
+            y: hline.y.get(styles),
+            start: hline.start.get(styles),
+            end: hline.end.get(styles),
+            stroke: hline.stroke.resolve(styles),
             span: hline.span(),
-            position: match hline.position(styles) {
+            position: match hline.position.get(styles) {
                 OuterVAlignment::Top => LinePosition::Before,
                 OuterVAlignment::Bottom => LinePosition::After,
             },
         },
         GridItem::VLine(vline) => ResolvableGridItem::VLine {
-            x: vline.x(styles),
-            start: vline.start(styles),
-            end: vline.end(styles),
-            stroke: vline.stroke(styles),
+            x: vline.x.get(styles),
+            start: vline.start.get(styles),
+            end: vline.end.get(styles),
+            stroke: vline.stroke.resolve(styles),
             span: vline.span(),
-            position: match vline.position(styles) {
-                OuterHAlignment::Left if TextElem::dir_in(styles) == Dir::RTL => {
+            position: match vline.position.get(styles) {
+                OuterHAlignment::Left if styles.resolve(TextElem::dir) == Dir::RTL => {
                     LinePosition::After
                 }
-                OuterHAlignment::Right if TextElem::dir_in(styles) == Dir::RTL => {
+                OuterHAlignment::Right if styles.resolve(TextElem::dir) == Dir::RTL => {
                     LinePosition::Before
                 }
                 OuterHAlignment::Start | OuterHAlignment::Left => LinePosition::Before,
@@ -174,27 +174,27 @@ fn table_item_to_resolvable(
 ) -> ResolvableGridItem<Packed<TableCell>> {
     match item {
         TableItem::HLine(hline) => ResolvableGridItem::HLine {
-            y: hline.y(styles),
-            start: hline.start(styles),
-            end: hline.end(styles),
-            stroke: hline.stroke(styles),
+            y: hline.y.get(styles),
+            start: hline.start.get(styles),
+            end: hline.end.get(styles),
+            stroke: hline.stroke.resolve(styles),
             span: hline.span(),
-            position: match hline.position(styles) {
+            position: match hline.position.get(styles) {
                 OuterVAlignment::Top => LinePosition::Before,
                 OuterVAlignment::Bottom => LinePosition::After,
             },
         },
         TableItem::VLine(vline) => ResolvableGridItem::VLine {
-            x: vline.x(styles),
-            start: vline.start(styles),
-            end: vline.end(styles),
-            stroke: vline.stroke(styles),
+            x: vline.x.get(styles),
+            start: vline.start.get(styles),
+            end: vline.end.get(styles),
+            stroke: vline.stroke.resolve(styles),
             span: vline.span(),
-            position: match vline.position(styles) {
-                OuterHAlignment::Left if TextElem::dir_in(styles) == Dir::RTL => {
+            position: match vline.position.get(styles) {
+                OuterHAlignment::Left if styles.resolve(TextElem::dir) == Dir::RTL => {
                     LinePosition::After
                 }
-                OuterHAlignment::Right if TextElem::dir_in(styles) == Dir::RTL => {
+                OuterHAlignment::Right if styles.resolve(TextElem::dir) == Dir::RTL => {
                     LinePosition::Before
                 }
                 OuterHAlignment::Start | OuterHAlignment::Left => LinePosition::Before,
@@ -219,12 +219,12 @@ impl ResolvableCell for Packed<TableCell> {
         styles: StyleChain,
     ) -> Cell<'a> {
         let cell = &mut *self;
-        let colspan = cell.colspan(styles);
-        let rowspan = cell.rowspan(styles);
-        let breakable = cell.breakable(styles).unwrap_or(breakable);
-        let fill = cell.fill(styles).unwrap_or_else(|| fill.clone());
+        let colspan = cell.colspan.get(styles);
+        let rowspan = cell.rowspan.get(styles);
+        let breakable = cell.breakable.get(styles).unwrap_or(breakable);
+        let fill = cell.fill.get_cloned(styles).unwrap_or_else(|| fill.clone());
 
-        let cell_stroke = cell.stroke(styles);
+        let cell_stroke = cell.stroke.resolve(styles);
         let stroke_overridden =
             cell_stroke.as_ref().map(|side| matches!(side, Some(Some(_))));
 
@@ -238,22 +238,22 @@ impl ResolvableCell for Packed<TableCell> {
         // cell stroke is the same as specifying 'none', so we equate the two
         // concepts.
         let stroke = cell_stroke.fold(stroke).map(Option::flatten);
-        cell.push_x(Smart::Custom(x));
-        cell.push_y(Smart::Custom(y));
-        cell.push_fill(Smart::Custom(fill.clone()));
-        cell.push_align(match align {
-            Smart::Custom(align) => {
-                Smart::Custom(cell.align(styles).map_or(align, |inner| inner.fold(align)))
-            }
+        cell.x.set(Smart::Custom(x));
+        cell.y.set(Smart::Custom(y));
+        cell.fill.set(Smart::Custom(fill.clone()));
+        cell.align.set(match align {
+            Smart::Custom(align) => Smart::Custom(
+                cell.align.get(styles).map_or(align, |inner| inner.fold(align)),
+            ),
             // Don't fold if the table is using outer alignment. Use the
             // cell's alignment instead (which, in the end, will fold with
             // the outer alignment when it is effectively displayed).
-            Smart::Auto => cell.align(styles),
+            Smart::Auto => cell.align.get(styles),
         });
-        cell.push_inset(Smart::Custom(
-            cell.inset(styles).map_or(inset, |inner| inner.fold(inset)),
+        cell.inset.set(Smart::Custom(
+            cell.inset.get(styles).map_or(inset, |inner| inner.fold(inset)),
         ));
-        cell.push_stroke(
+        cell.stroke.set(
             // Here we convert the resolved stroke to a regular stroke, however
             // with resolved units (that is, 'em' converted to absolute units).
             // We also convert any stroke unspecified by both the cell and the
@@ -266,7 +266,7 @@ impl ResolvableCell for Packed<TableCell> {
                 }))
             }),
         );
-        cell.push_breakable(Smart::Custom(breakable));
+        cell.breakable.set(Smart::Custom(breakable));
         Cell {
             body: self.pack(),
             locator,
@@ -280,19 +280,19 @@ impl ResolvableCell for Packed<TableCell> {
     }
 
     fn x(&self, styles: StyleChain) -> Smart<usize> {
-        (**self).x(styles)
+        self.x.get(styles)
     }
 
     fn y(&self, styles: StyleChain) -> Smart<usize> {
-        (**self).y(styles)
+        self.y.get(styles)
     }
 
     fn colspan(&self, styles: StyleChain) -> NonZeroUsize {
-        (**self).colspan(styles)
+        self.colspan.get(styles)
     }
 
     fn rowspan(&self, styles: StyleChain) -> NonZeroUsize {
-        (**self).rowspan(styles)
+        self.rowspan.get(styles)
     }
 
     fn span(&self) -> Span {
@@ -314,12 +314,12 @@ impl ResolvableCell for Packed<GridCell> {
         styles: StyleChain,
     ) -> Cell<'a> {
         let cell = &mut *self;
-        let colspan = cell.colspan(styles);
-        let rowspan = cell.rowspan(styles);
-        let breakable = cell.breakable(styles).unwrap_or(breakable);
-        let fill = cell.fill(styles).unwrap_or_else(|| fill.clone());
+        let colspan = cell.colspan.get(styles);
+        let rowspan = cell.rowspan.get(styles);
+        let breakable = cell.breakable.get(styles).unwrap_or(breakable);
+        let fill = cell.fill.get_cloned(styles).unwrap_or_else(|| fill.clone());
 
-        let cell_stroke = cell.stroke(styles);
+        let cell_stroke = cell.stroke.resolve(styles);
         let stroke_overridden =
             cell_stroke.as_ref().map(|side| matches!(side, Some(Some(_))));
 
@@ -333,22 +333,22 @@ impl ResolvableCell for Packed<GridCell> {
         // cell stroke is the same as specifying 'none', so we equate the two
         // concepts.
         let stroke = cell_stroke.fold(stroke).map(Option::flatten);
-        cell.push_x(Smart::Custom(x));
-        cell.push_y(Smart::Custom(y));
-        cell.push_fill(Smart::Custom(fill.clone()));
-        cell.push_align(match align {
-            Smart::Custom(align) => {
-                Smart::Custom(cell.align(styles).map_or(align, |inner| inner.fold(align)))
-            }
+        cell.x.set(Smart::Custom(x));
+        cell.y.set(Smart::Custom(y));
+        cell.fill.set(Smart::Custom(fill.clone()));
+        cell.align.set(match align {
+            Smart::Custom(align) => Smart::Custom(
+                cell.align.get(styles).map_or(align, |inner| inner.fold(align)),
+            ),
             // Don't fold if the grid is using outer alignment. Use the
             // cell's alignment instead (which, in the end, will fold with
             // the outer alignment when it is effectively displayed).
-            Smart::Auto => cell.align(styles),
+            Smart::Auto => cell.align.get(styles),
         });
-        cell.push_inset(Smart::Custom(
-            cell.inset(styles).map_or(inset, |inner| inner.fold(inset)),
+        cell.inset.set(Smart::Custom(
+            cell.inset.get(styles).map_or(inset, |inner| inner.fold(inset)),
         ));
-        cell.push_stroke(
+        cell.stroke.set(
             // Here we convert the resolved stroke to a regular stroke, however
             // with resolved units (that is, 'em' converted to absolute units).
             // We also convert any stroke unspecified by both the cell and the
@@ -361,7 +361,7 @@ impl ResolvableCell for Packed<GridCell> {
                 }))
             }),
         );
-        cell.push_breakable(Smart::Custom(breakable));
+        cell.breakable.set(Smart::Custom(breakable));
         Cell {
             body: self.pack(),
             locator,
@@ -375,19 +375,19 @@ impl ResolvableCell for Packed<GridCell> {
     }
 
     fn x(&self, styles: StyleChain) -> Smart<usize> {
-        (**self).x(styles)
+        self.x.get(styles)
     }
 
     fn y(&self, styles: StyleChain) -> Smart<usize> {
-        (**self).y(styles)
+        self.y.get(styles)
     }
 
     fn colspan(&self, styles: StyleChain) -> NonZeroUsize {
-        (**self).colspan(styles)
+        self.colspan.get(styles)
     }
 
     fn rowspan(&self, styles: StyleChain) -> NonZeroUsize {
-        (**self).rowspan(styles)
+        self.rowspan.get(styles)
     }
 
     fn span(&self) -> Span {
diff --git a/crates/typst-library/src/layout/hide.rs b/crates/typst-library/src/layout/hide.rs
index eca33471a..5f3a5a2d3 100644
--- a/crates/typst-library/src/layout/hide.rs
+++ b/crates/typst-library/src/layout/hide.rs
@@ -29,6 +29,6 @@ pub struct HideElem {
 impl Show for Packed<HideElem> {
     #[typst_macros::time(name = "hide", span = self.span())]
     fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(self.body.clone().styled(HideElem::set_hidden(true)))
+        Ok(self.body.clone().set(HideElem::hidden, true))
     }
 }
diff --git a/crates/typst-library/src/layout/page.rs b/crates/typst-library/src/layout/page.rs
index 98afbd06f..a0b1c6fec 100644
--- a/crates/typst-library/src/layout/page.rs
+++ b/crates/typst-library/src/layout/page.rs
@@ -60,7 +60,6 @@ pub struct PageElem {
     ///   box(square(width: 1cm))
     /// }
     /// ```
-    #[resolve]
     #[parse(
         let paper = args.named_or_find::<Paper>("paper")?;
         args.named("width")?
@@ -77,7 +76,6 @@ pub struct PageElem {
     /// page set rule. Most examples throughout this documentation use `{auto}`
     /// for the height of the page to dynamically grow and shrink to fit their
     /// content.
-    #[resolve]
     #[parse(
         args.named("height")?
             .or_else(|| paper.map(|paper| Smart::Custom(paper.height().into())))
@@ -201,7 +199,6 @@ pub struct PageElem {
     /// #set text(fill: rgb("fdfdfd"))
     /// *Dark mode enabled.*
     /// ```
-    #[borrowed]
     #[ghost]
     pub fill: Smart<Option<Paint>>,
 
@@ -219,7 +216,6 @@ pub struct PageElem {
     ///
     /// #lorem(48)
     /// ```
-    #[borrowed]
     #[ghost]
     pub numbering: Option<Numbering>,
 
@@ -276,12 +272,10 @@ pub struct PageElem {
     ///
     /// #lorem(19)
     /// ```
-    #[borrowed]
     #[ghost]
     pub header: Smart<Option<Content>>,
 
     /// The amount the header is raised into the top margin.
-    #[resolve]
     #[default(Ratio::new(0.3).into())]
     #[ghost]
     pub header_ascent: Rel<Length>,
@@ -314,12 +308,10 @@ pub struct PageElem {
     ///
     /// #lorem(48)
     /// ```
-    #[borrowed]
     #[ghost]
     pub footer: Smart<Option<Content>>,
 
     /// The amount the footer is lowered into the bottom margin.
-    #[resolve]
     #[default(Ratio::new(0.3).into())]
     #[ghost]
     pub footer_descent: Rel<Length>,
@@ -340,7 +332,6 @@ pub struct PageElem {
     /// In the year 2023, we plan to take
     /// over the world (of typesetting).
     /// ```
-    #[borrowed]
     #[ghost]
     pub background: Option<Content>,
 
@@ -355,7 +346,6 @@ pub struct PageElem {
     /// "Weak Reject" because they did
     /// not understand our approach...
     /// ```
-    #[borrowed]
     #[ghost]
     pub foreground: Option<Content>,
 
diff --git a/crates/typst-library/src/layout/place.rs b/crates/typst-library/src/layout/place.rs
index bedeb5076..b6c4a0cc1 100644
--- a/crates/typst-library/src/layout/place.rs
+++ b/crates/typst-library/src/layout/place.rs
@@ -134,7 +134,6 @@ pub struct PlaceElem {
     ///
     /// Has no effect if `float` is `{false}`.
     #[default(Em::new(1.5).into())]
-    #[resolve]
     pub clearance: Length,
 
     /// The horizontal displacement of the placed content.
diff --git a/crates/typst-library/src/math/accent.rs b/crates/typst-library/src/math/accent.rs
index c8569ea23..5a9c47aea 100644
--- a/crates/typst-library/src/math/accent.rs
+++ b/crates/typst-library/src/math/accent.rs
@@ -62,7 +62,6 @@ pub struct AccentElem {
     /// ```example
     /// $dash(A, size: #150%)$
     /// ```
-    #[resolve]
     #[default(Rel::one())]
     pub size: Rel<Length>,
 
diff --git a/crates/typst-library/src/math/attach.rs b/crates/typst-library/src/math/attach.rs
index d526aba57..0dda1d33d 100644
--- a/crates/typst-library/src/math/attach.rs
+++ b/crates/typst-library/src/math/attach.rs
@@ -59,9 +59,9 @@ impl Packed<AttachElem> {
 
             macro_rules! merge {
                 ($content:ident) => {
-                    if base.$content.is_none() && elem.$content.is_some() {
+                    if !base.$content.is_set() && elem.$content.is_set() {
                         base.$content = elem.$content.clone();
-                        elem.$content = None;
+                        elem.$content.unset();
                     }
                 };
             }
@@ -152,7 +152,6 @@ pub struct StretchElem {
 
     /// The size to stretch to, relative to the maximum size of the glyph and
     /// its attachments.
-    #[resolve]
     #[default(Rel::one())]
     pub size: Rel<Length>,
 }
diff --git a/crates/typst-library/src/math/cancel.rs b/crates/typst-library/src/math/cancel.rs
index 17f4dcfb9..886370954 100644
--- a/crates/typst-library/src/math/cancel.rs
+++ b/crates/typst-library/src/math/cancel.rs
@@ -29,7 +29,6 @@ pub struct CancelElem {
     /// $ a + cancel(x, length: #200%)
     ///     - cancel(x, length: #200%) $
     /// ```
-    #[resolve]
     #[default(Rel::new(Ratio::one(), Abs::pt(3.0).into()))]
     pub length: Rel<Length>,
 
@@ -89,7 +88,6 @@ pub struct CancelElem {
     ///   ),
     /// ) $
     /// ```
-    #[resolve]
     #[fold]
     #[default(Stroke {
         // Default stroke has 0.5pt for better visuals.
diff --git a/crates/typst-library/src/math/equation.rs b/crates/typst-library/src/math/equation.rs
index 32be216a4..b97bb18da 100644
--- a/crates/typst-library/src/math/equation.rs
+++ b/crates/typst-library/src/math/equation.rs
@@ -63,7 +63,6 @@ pub struct EquationElem {
     /// With @ratio, we get:
     /// $ F_n = floor(1 / sqrt(5) phi.alt^n) $
     /// ```
-    #[borrowed]
     pub numbering: Option<Numbering>,
 
     /// The alignment of the equation numbering.
@@ -152,7 +151,7 @@ impl Synthesize for Packed<EquationElem> {
         engine: &mut Engine,
         styles: StyleChain,
     ) -> SourceResult<()> {
-        let supplement = match self.as_ref().supplement(styles) {
+        let supplement = match self.as_ref().supplement.get_ref(styles) {
             Smart::Auto => TextElem::packed(Self::local_name_in(styles)),
             Smart::Custom(None) => Content::empty(),
             Smart::Custom(Some(supplement)) => {
@@ -160,14 +159,15 @@ impl Synthesize for Packed<EquationElem> {
             }
         };
 
-        self.push_supplement(Smart::Custom(Some(Supplement::Content(supplement))));
+        self.supplement
+            .set(Smart::Custom(Some(Supplement::Content(supplement))));
         Ok(())
     }
 }
 
 impl Show for Packed<EquationElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if self.block(styles) {
+        if self.block.get(styles) {
             Ok(BlockElem::multi_layouter(
                 self.clone(),
                 engine.routines.layout_equation_block,
@@ -185,25 +185,27 @@ impl Show for Packed<EquationElem> {
 impl ShowSet for Packed<EquationElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
-        if self.block(styles) {
-            out.set(AlignElem::set_alignment(Alignment::CENTER));
-            out.set(BlockElem::set_breakable(false));
-            out.set(ParLine::set_numbering(None));
-            out.set(EquationElem::set_size(MathSize::Display));
+        if self.block.get(styles) {
+            out.set(AlignElem::alignment, Alignment::CENTER);
+            out.set(AlignElem::alignment, Alignment::CENTER);
+            out.set(BlockElem::breakable, false);
+            out.set(ParLine::numbering, None);
+            out.set(EquationElem::size, MathSize::Display);
         } else {
-            out.set(EquationElem::set_size(MathSize::Text));
+            out.set(EquationElem::size, MathSize::Text);
         }
-        out.set(TextElem::set_weight(FontWeight::from_number(450)));
-        out.set(TextElem::set_font(FontList(vec![FontFamily::new(
-            "New Computer Modern Math",
-        )])));
+        out.set(TextElem::weight, FontWeight::from_number(450));
+        out.set(
+            TextElem::font,
+            FontList(vec![FontFamily::new("New Computer Modern Math")]),
+        );
         out
     }
 }
 
 impl Count for Packed<EquationElem> {
     fn update(&self) -> Option<CounterUpdate> {
-        (self.block(StyleChain::default()) && self.numbering().is_some())
+        (self.block.get(StyleChain::default()) && self.numbering().is_some())
             .then(|| CounterUpdate::Step(NonZeroUsize::ONE))
     }
 }
@@ -215,24 +217,24 @@ impl LocalName for Packed<EquationElem> {
 impl Refable for Packed<EquationElem> {
     fn supplement(&self) -> Content {
         // After synthesis, this should always be custom content.
-        match (**self).supplement(StyleChain::default()) {
+        match self.supplement.get_cloned(StyleChain::default()) {
             Smart::Custom(Some(Supplement::Content(content))) => content,
             _ => Content::empty(),
         }
     }
 
     fn counter(&self) -> Counter {
-        Counter::of(EquationElem::elem())
+        Counter::of(EquationElem::ELEM)
     }
 
     fn numbering(&self) -> Option<&Numbering> {
-        (**self).numbering(StyleChain::default()).as_ref()
+        self.numbering.get_ref(StyleChain::default()).as_ref()
     }
 }
 
 impl Outlinable for Packed<EquationElem> {
     fn outlined(&self) -> bool {
-        self.block(StyleChain::default()) && self.numbering().is_some()
+        self.block.get(StyleChain::default()) && self.numbering().is_some()
     }
 
     fn prefix(&self, numbers: Content) -> Content {
diff --git a/crates/typst-library/src/math/lr.rs b/crates/typst-library/src/math/lr.rs
index 7558717af..5f5cb8616 100644
--- a/crates/typst-library/src/math/lr.rs
+++ b/crates/typst-library/src/math/lr.rs
@@ -9,7 +9,6 @@ use crate::math::Mathy;
 #[elem(title = "Left/Right", Mathy)]
 pub struct LrElem {
     /// The size of the brackets, relative to the height of the wrapped content.
-    #[resolve]
     #[default(Rel::one())]
     pub size: Rel<Length>,
 
@@ -130,7 +129,7 @@ fn delimited(
     ]));
     // Push size only if size is provided
     if let Some(size) = size {
-        elem.push_size(size);
+        elem.size.set(size);
     }
     elem.pack().spanned(span)
 }
diff --git a/crates/typst-library/src/math/matrix.rs b/crates/typst-library/src/math/matrix.rs
index b6c4654ed..2a51caefd 100644
--- a/crates/typst-library/src/math/matrix.rs
+++ b/crates/typst-library/src/math/matrix.rs
@@ -46,7 +46,6 @@ pub struct VecElem {
     /// #set math.vec(align: right)
     /// $ vec(-1, 1, -1) $
     /// ```
-    #[resolve]
     #[default(HAlignment::Center)]
     pub align: HAlignment,
 
@@ -56,7 +55,6 @@ pub struct VecElem {
     /// #set math.vec(gap: 1em)
     /// $ vec(1, 2) $
     /// ```
-    #[resolve]
     #[default(DEFAULT_ROW_GAP.into())]
     pub gap: Rel<Length>,
 
@@ -107,7 +105,6 @@ pub struct MatElem {
     /// #set math.mat(align: right)
     /// $ mat(-1, 1, 1; 1, -1, 1; 1, 1, -1) $
     /// ```
-    #[resolve]
     #[default(HAlignment::Center)]
     pub align: HAlignment,
 
@@ -141,7 +138,6 @@ pub struct MatElem {
     /// ```example
     /// $ mat(0, 0, 0; 1, 1, 1; augment: #(hline: 1, stroke: 2pt + green)) $
     /// ```
-    #[resolve]
     #[fold]
     pub augment: Option<Augment>,
 
@@ -162,7 +158,6 @@ pub struct MatElem {
     /// #set math.mat(row-gap: 1em)
     /// $ mat(1, 2; 3, 4) $
     /// ```
-    #[resolve]
     #[parse(
         let gap = args.named("gap")?;
         args.named("row-gap")?.or(gap)
@@ -176,7 +171,6 @@ pub struct MatElem {
     /// #set math.mat(column-gap: 1em)
     /// $ mat(1, 2; 3, 4) $
     /// ```
-    #[resolve]
     #[parse(args.named("column-gap")?.or(gap))]
     #[default(DEFAULT_COL_GAP.into())]
     pub column_gap: Rel<Length>,
@@ -259,7 +253,6 @@ pub struct CasesElem {
     /// #set math.cases(gap: 1em)
     /// $ x = cases(1, 2) $
     /// ```
-    #[resolve]
     #[default(DEFAULT_ROW_GAP.into())]
     pub gap: Rel<Length>,
 
diff --git a/crates/typst-library/src/math/style.rs b/crates/typst-library/src/math/style.rs
index f3d28f2a9..53242e6e0 100644
--- a/crates/typst-library/src/math/style.rs
+++ b/crates/typst-library/src/math/style.rs
@@ -11,7 +11,7 @@ pub fn bold(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_bold(true))
+    body.set(EquationElem::bold, true)
 }
 
 /// Upright (non-italic) font style in math.
@@ -24,7 +24,7 @@ pub fn upright(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_italic(Smart::Custom(false)))
+    body.set(EquationElem::italic, Smart::Custom(false))
 }
 
 /// Italic font style in math.
@@ -35,7 +35,7 @@ pub fn italic(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_italic(Smart::Custom(true)))
+    body.set(EquationElem::italic, Smart::Custom(true))
 }
 
 /// Serif (roman) font style in math.
@@ -46,7 +46,7 @@ pub fn serif(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_variant(MathVariant::Serif))
+    body.set(EquationElem::variant, MathVariant::Serif)
 }
 
 /// Sans-serif font style in math.
@@ -59,7 +59,7 @@ pub fn sans(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_variant(MathVariant::Sans))
+    body.set(EquationElem::variant, MathVariant::Sans)
 }
 
 /// Calligraphic font style in math.
@@ -93,7 +93,7 @@ pub fn cal(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_variant(MathVariant::Cal))
+    body.set(EquationElem::variant, MathVariant::Cal)
 }
 
 /// Fraktur font style in math.
@@ -106,7 +106,7 @@ pub fn frak(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_variant(MathVariant::Frak))
+    body.set(EquationElem::variant, MathVariant::Frak)
 }
 
 /// Monospace font style in math.
@@ -119,7 +119,7 @@ pub fn mono(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_variant(MathVariant::Mono))
+    body.set(EquationElem::variant, MathVariant::Mono)
 }
 
 /// Blackboard bold (double-struck) font style in math.
@@ -137,7 +137,7 @@ pub fn bb(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.styled(EquationElem::set_variant(MathVariant::Bb))
+    body.set(EquationElem::variant, MathVariant::Bb)
 }
 
 /// Forced display style in math.
@@ -157,8 +157,8 @@ pub fn display(
     #[default(false)]
     cramped: bool,
 ) -> Content {
-    body.styled(EquationElem::set_size(MathSize::Display))
-        .styled(EquationElem::set_cramped(cramped))
+    body.set(EquationElem::size, MathSize::Display)
+        .set(EquationElem::cramped, cramped)
 }
 
 /// Forced inline (text) style in math.
@@ -179,8 +179,8 @@ pub fn inline(
     #[default(false)]
     cramped: bool,
 ) -> Content {
-    body.styled(EquationElem::set_size(MathSize::Text))
-        .styled(EquationElem::set_cramped(cramped))
+    body.set(EquationElem::size, MathSize::Text)
+        .set(EquationElem::cramped, cramped)
 }
 
 /// Forced script style in math.
@@ -200,8 +200,8 @@ pub fn script(
     #[default(true)]
     cramped: bool,
 ) -> Content {
-    body.styled(EquationElem::set_size(MathSize::Script))
-        .styled(EquationElem::set_cramped(cramped))
+    body.set(EquationElem::size, MathSize::Script)
+        .set(EquationElem::cramped, cramped)
 }
 
 /// Forced second script style in math.
@@ -222,8 +222,8 @@ pub fn sscript(
     #[default(true)]
     cramped: bool,
 ) -> Content {
-    body.styled(EquationElem::set_size(MathSize::ScriptScript))
-        .styled(EquationElem::set_cramped(cramped))
+    body.set(EquationElem::size, MathSize::ScriptScript)
+        .set(EquationElem::cramped, cramped)
 }
 
 /// The size of elements in an equation.
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index f56f5813e..c44748a95 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -158,7 +158,7 @@ pub struct BibliographyElem {
 impl BibliographyElem {
     /// Find the document's bibliography.
     pub fn find(introspector: Tracked<Introspector>) -> StrResult<Packed<Self>> {
-        let query = introspector.query(&Self::elem().select());
+        let query = introspector.query(&Self::ELEM.select());
         let mut iter = query.iter();
         let Some(elem) = iter.next() else {
             bail!("the document does not contain a bibliography");
@@ -175,7 +175,7 @@ impl BibliographyElem {
     pub fn has(engine: &Engine, key: Label) -> bool {
         engine
             .introspector
-            .query(&Self::elem().select())
+            .query(&Self::ELEM.select())
             .iter()
             .any(|elem| elem.to_packed::<Self>().unwrap().sources.derived.has(key))
     }
@@ -183,7 +183,7 @@ impl BibliographyElem {
     /// Find all bibliography keys.
     pub fn keys(introspector: Tracked<Introspector>) -> Vec<(Label, Option<EcoString>)> {
         let mut vec = vec![];
-        for elem in introspector.query(&Self::elem().select()).iter() {
+        for elem in introspector.query(&Self::ELEM.select()).iter() {
             let this = elem.to_packed::<Self>().unwrap();
             for (key, entry) in this.sources.derived.iter() {
                 let detail = entry.title().map(|title| title.value.to_str().into());
@@ -197,8 +197,8 @@ impl BibliographyElem {
 impl Synthesize for Packed<BibliographyElem> {
     fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         let elem = self.as_mut();
-        elem.push_lang(TextElem::lang_in(styles));
-        elem.push_region(TextElem::region_in(styles));
+        elem.lang = Some(styles.get(TextElem::lang));
+        elem.region = Some(styles.get(TextElem::region));
         Ok(())
     }
 }
@@ -212,7 +212,7 @@ impl Show for Packed<BibliographyElem> {
         let span = self.span();
 
         let mut seq = vec![];
-        if let Some(title) = self.title(styles).unwrap_or_else(|| {
+        if let Some(title) = self.title.get_ref(styles).clone().unwrap_or_else(|| {
             Some(TextElem::packed(Self::local_name_in(styles)).spanned(span))
         }) {
             seq.push(
@@ -227,7 +227,7 @@ impl Show for Packed<BibliographyElem> {
         let references = works
             .references
             .as_ref()
-            .ok_or_else(|| match self.style(styles).source {
+            .ok_or_else(|| match self.style.get_ref(styles).source {
                 CslSource::Named(style) => eco_format!(
                     "CSL style \"{}\" is not suitable for bibliographies",
                     style.display_name()
@@ -239,7 +239,7 @@ impl Show for Packed<BibliographyElem> {
             .at(span)?;
 
         if references.iter().any(|(prefix, _)| prefix.is_some()) {
-            let row_gutter = ParElem::spacing_in(styles);
+            let row_gutter = styles.get(ParElem::spacing);
 
             let mut cells = vec![];
             for (prefix, reference) in references {
@@ -265,7 +265,7 @@ impl Show for Packed<BibliographyElem> {
                 let block = if works.hanging_indent {
                     let body = HElem::new((-INDENT).into()).pack() + realized;
                     let inset = Sides::default()
-                        .with(TextElem::dir_in(styles).start(), Some(INDENT.into()));
+                        .with(styles.resolve(TextElem::dir).start(), Some(INDENT.into()));
                     BlockElem::new()
                         .with_body(Some(BlockBody::Content(body)))
                         .with_inset(inset)
@@ -285,8 +285,8 @@ impl ShowSet for Packed<BibliographyElem> {
     fn show_set(&self, _: StyleChain) -> Styles {
         const INDENT: Em = Em::new(1.0);
         let mut out = Styles::new();
-        out.set(HeadingElem::set_numbering(None));
-        out.set(PadElem::set_left(INDENT.into()));
+        out.set(HeadingElem::numbering, None);
+        out.set(PadElem::left, INDENT.into());
         out
     }
 }
@@ -643,7 +643,7 @@ impl<'a> Generator<'a> {
         introspector: Tracked<Introspector>,
     ) -> StrResult<Self> {
         let bibliography = BibliographyElem::find(introspector)?;
-        let groups = introspector.query(&CiteGroup::elem().select());
+        let groups = introspector.query(&CiteGroup::ELEM.select());
         let infos = Vec::with_capacity(groups.len());
         Ok(Self {
             routines,
@@ -661,7 +661,8 @@ impl<'a> Generator<'a> {
             LazyLock::new(hayagriva::archive::locales);
 
         let database = &self.bibliography.sources.derived;
-        let bibliography_style = &self.bibliography.style(StyleChain::default()).derived;
+        let bibliography_style =
+            &self.bibliography.style.get_ref(StyleChain::default()).derived;
 
         // Process all citation groups.
         let mut driver = BibliographyDriver::new();
@@ -689,7 +690,7 @@ impl<'a> Generator<'a> {
                     continue;
                 };
 
-                let supplement = child.supplement(StyleChain::default());
+                let supplement = child.supplement.get_cloned(StyleChain::default());
                 let locator = supplement.as_ref().map(|_| {
                     SpecificLocator(
                         citationberg::taxonomy::Locator::Custom,
@@ -698,7 +699,7 @@ impl<'a> Generator<'a> {
                 });
 
                 let mut hidden = false;
-                let special_form = match child.form(StyleChain::default()) {
+                let special_form = match child.form.get(StyleChain::default()) {
                     None => {
                         hidden = true;
                         None
@@ -720,7 +721,7 @@ impl<'a> Generator<'a> {
                 continue;
             }
 
-            let style = match first.style(StyleChain::default()) {
+            let style = match first.style.get_ref(StyleChain::default()) {
                 Smart::Auto => bibliography_style.get(),
                 Smart::Custom(style) => style.derived.get(),
             };
@@ -736,23 +737,20 @@ impl<'a> Generator<'a> {
             driver.citation(CitationRequest::new(
                 items,
                 style,
-                Some(locale(
-                    first.lang().copied().unwrap_or(Lang::ENGLISH),
-                    first.region().copied().flatten(),
-                )),
+                Some(locale(first.lang.unwrap_or(Lang::ENGLISH), first.region.flatten())),
                 &LOCALES,
                 None,
             ));
         }
 
         let locale = locale(
-            self.bibliography.lang().copied().unwrap_or(Lang::ENGLISH),
-            self.bibliography.region().copied().flatten(),
+            self.bibliography.lang.unwrap_or(Lang::ENGLISH),
+            self.bibliography.region.flatten(),
         );
 
         // Add hidden items for everything if we should print the whole
         // bibliography.
-        if self.bibliography.full(StyleChain::default()) {
+        if self.bibliography.full.get(StyleChain::default()) {
             for (_, entry) in database.iter() {
                 driver.citation(CitationRequest::new(
                     vec![CitationItem::new(entry, None, None, true, None)],
@@ -1071,25 +1069,24 @@ fn apply_formatting(mut content: Content, format: &hayagriva::Formatting) -> Con
     match format.font_style {
         citationberg::FontStyle::Normal => {}
         citationberg::FontStyle::Italic => {
-            content = content.styled(TextElem::set_style(FontStyle::Italic));
+            content = content.set(TextElem::style, FontStyle::Italic);
         }
     }
 
     match format.font_variant {
         citationberg::FontVariant::Normal => {}
         citationberg::FontVariant::SmallCaps => {
-            content =
-                content.styled(TextElem::set_smallcaps(Some(Smallcaps::Minuscules)));
+            content = content.set(TextElem::smallcaps, Some(Smallcaps::Minuscules));
         }
     }
 
     match format.font_weight {
         citationberg::FontWeight::Normal => {}
         citationberg::FontWeight::Bold => {
-            content = content.styled(TextElem::set_delta(WeightDelta(300)));
+            content = content.set(TextElem::delta, WeightDelta(300));
         }
         citationberg::FontWeight::Light => {
-            content = content.styled(TextElem::set_delta(WeightDelta(-100)));
+            content = content.set(TextElem::delta, WeightDelta(-100));
         }
     }
 
diff --git a/crates/typst-library/src/model/cite.rs b/crates/typst-library/src/model/cite.rs
index 29497993d..195139907 100644
--- a/crates/typst-library/src/model/cite.rs
+++ b/crates/typst-library/src/model/cite.rs
@@ -106,7 +106,6 @@ pub struct CiteElem {
         Some(Spanned { v: Smart::Auto, .. }) => Some(Smart::Auto),
         None => None,
     })]
-    #[borrowed]
     pub style: Smart<Derived<CslSource, CslStyle>>,
 
     /// The text language setting where the citation is.
@@ -123,8 +122,8 @@ pub struct CiteElem {
 impl Synthesize for Packed<CiteElem> {
     fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         let elem = self.as_mut();
-        elem.push_lang(TextElem::lang_in(styles));
-        elem.push_region(TextElem::region_in(styles));
+        elem.lang = Some(styles.get(TextElem::lang));
+        elem.region = Some(styles.get(TextElem::region));
         Ok(())
     }
 }
diff --git a/crates/typst-library/src/model/document.rs b/crates/typst-library/src/model/document.rs
index 1bce6b357..47e999735 100644
--- a/crates/typst-library/src/model/document.rs
+++ b/crates/typst-library/src/model/document.rs
@@ -3,7 +3,7 @@ use ecow::EcoString;
 use crate::diag::{bail, HintedStrResult, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Args, Array, Construct, Content, Datetime, Fields, OneOrMultiple, Smart,
+    cast, elem, Args, Array, Construct, Content, Datetime, OneOrMultiple, Smart,
     StyleChain, Styles, Value,
 };
 
@@ -109,23 +109,26 @@ impl DocumentInfo {
     /// Document set rules are a bit special, so we need to do this manually.
     pub fn populate(&mut self, styles: &Styles) {
         let chain = StyleChain::new(styles);
-        let has = |field| styles.has::<DocumentElem>(field as _);
-        if has(<DocumentElem as Fields>::Enum::Title) {
-            self.title =
-                DocumentElem::title_in(chain).map(|content| content.plain_text());
+        if styles.has(DocumentElem::title) {
+            self.title = chain
+                .get_ref(DocumentElem::title)
+                .as_ref()
+                .map(|content| content.plain_text());
         }
-        if has(<DocumentElem as Fields>::Enum::Author) {
-            self.author = DocumentElem::author_in(chain).0;
+        if styles.has(DocumentElem::author) {
+            self.author = chain.get_cloned(DocumentElem::author).0;
         }
-        if has(<DocumentElem as Fields>::Enum::Description) {
-            self.description =
-                DocumentElem::description_in(chain).map(|content| content.plain_text());
+        if styles.has(DocumentElem::description) {
+            self.description = chain
+                .get_ref(DocumentElem::description)
+                .as_ref()
+                .map(|content| content.plain_text());
         }
-        if has(<DocumentElem as Fields>::Enum::Keywords) {
-            self.keywords = DocumentElem::keywords_in(chain).0;
+        if styles.has(DocumentElem::keywords) {
+            self.keywords = chain.get_cloned(DocumentElem::keywords).0;
         }
-        if has(<DocumentElem as Fields>::Enum::Date) {
-            self.date = DocumentElem::date_in(chain);
+        if styles.has(DocumentElem::date) {
+            self.date = chain.get(DocumentElem::date);
         }
     }
 }
diff --git a/crates/typst-library/src/model/emph.rs b/crates/typst-library/src/model/emph.rs
index 45097b340..2d9cbec12 100644
--- a/crates/typst-library/src/model/emph.rs
+++ b/crates/typst-library/src/model/emph.rs
@@ -40,13 +40,13 @@ impl Show for Packed<EmphElem> {
     #[typst_macros::time(name = "emph", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
-        Ok(if TargetElem::target_in(styles).is_html() {
+        Ok(if styles.get(TargetElem::target).is_html() {
             HtmlElem::new(tag::em)
                 .with_body(Some(body))
                 .pack()
                 .spanned(self.span())
         } else {
-            body.styled(TextElem::set_emph(ItalicToggle(true)))
+            body.set(TextElem::emph, ItalicToggle(true))
         })
     }
 }
diff --git a/crates/typst-library/src/model/enum.rs b/crates/typst-library/src/model/enum.rs
index f1f93702b..8c1916581 100644
--- a/crates/typst-library/src/model/enum.rs
+++ b/crates/typst-library/src/model/enum.rs
@@ -117,7 +117,6 @@ pub struct EnumElem {
     /// + Numbering!
     /// ```
     #[default(Numbering::Pattern(NumberingPattern::from_str("1.").unwrap()))]
-    #[borrowed]
     pub numbering: Numbering,
 
     /// Which number to start the enumeration with.
@@ -157,11 +156,9 @@ pub struct EnumElem {
     pub reversed: bool,
 
     /// The indentation of each item.
-    #[resolve]
     pub indent: Length,
 
     /// The space between the numbering and the body of each item.
-    #[resolve]
     #[default(Em::new(0.5).into())]
     pub body_indent: Length,
 
@@ -228,19 +225,19 @@ impl EnumElem {
 
 impl Show for Packed<EnumElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let tight = self.tight(styles);
+        let tight = self.tight.get(styles);
 
-        if TargetElem::target_in(styles).is_html() {
+        if styles.get(TargetElem::target).is_html() {
             let mut elem = HtmlElem::new(tag::ol);
-            if self.reversed(styles) {
+            if self.reversed.get(styles) {
                 elem = elem.with_attr(attr::reversed, "reversed");
             }
-            if let Some(n) = self.start(styles).custom() {
+            if let Some(n) = self.start.get(styles).custom() {
                 elem = elem.with_attr(attr::start, eco_format!("{n}"));
             }
             let body = Content::sequence(self.children.iter().map(|item| {
                 let mut li = HtmlElem::new(tag::li);
-                if let Some(nr) = item.number(styles) {
+                if let Some(nr) = item.number.get(styles) {
                     li = li.with_attr(attr::value, eco_format!("{nr}"));
                 }
                 // Text in wide enums shall always turn into paragraphs.
@@ -260,8 +257,9 @@ impl Show for Packed<EnumElem> {
 
         if tight {
             let spacing = self
-                .spacing(styles)
-                .unwrap_or_else(|| ParElem::leading_in(styles).into());
+                .spacing
+                .get(styles)
+                .unwrap_or_else(|| styles.get(ParElem::leading));
             let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
             realized = v + realized;
         }
diff --git a/crates/typst-library/src/model/figure.rs b/crates/typst-library/src/model/figure.rs
index bec667d6e..7ac659a93 100644
--- a/crates/typst-library/src/model/figure.rs
+++ b/crates/typst-library/src/model/figure.rs
@@ -161,7 +161,6 @@ pub struct FigureElem {
     pub scope: PlacementScope,
 
     /// The figure's caption.
-    #[borrowed]
     pub caption: Option<Packed<FigureCaption>>,
 
     /// The kind of figure this is.
@@ -214,13 +213,11 @@ pub struct FigureElem {
     ///   kind: "foo",
     /// )
     /// ```
-    #[borrowed]
     pub supplement: Smart<Option<Supplement>>,
 
     /// How to number the figure. Accepts a
     /// [numbering pattern or function]($numbering).
     #[default(Some(NumberingPattern::from_str("1").unwrap().into()))]
-    #[borrowed]
     pub numbering: Option<Numbering>,
 
     /// The vertical gap between the body and caption.
@@ -259,25 +256,25 @@ impl Synthesize for Packed<FigureElem> {
         let span = self.span();
         let location = self.location();
         let elem = self.as_mut();
-        let numbering = elem.numbering(styles);
+        let numbering = elem.numbering.get_ref(styles);
 
         // Determine the figure's kind.
-        let kind = elem.kind(styles).unwrap_or_else(|| {
+        let kind = elem.kind.get_cloned(styles).unwrap_or_else(|| {
             elem.body
                 .query_first(&Selector::can::<dyn Figurable>())
                 .map(|elem| FigureKind::Elem(elem.func()))
-                .unwrap_or_else(|| FigureKind::Elem(ImageElem::elem()))
+                .unwrap_or_else(|| FigureKind::Elem(ImageElem::ELEM))
         });
 
         // Resolve the supplement.
-        let supplement = match elem.supplement(styles).as_ref() {
+        let supplement = match elem.supplement.get_ref(styles).as_ref() {
             Smart::Auto => {
                 // Default to the local name for the kind, if available.
                 let name = match &kind {
                     FigureKind::Elem(func) => func
                         .local_name(
-                            TextElem::lang_in(styles),
-                            TextElem::region_in(styles),
+                            styles.get(TextElem::lang),
+                            styles.get(TextElem::region),
                         )
                         .map(TextElem::packed),
                     FigureKind::Name(_) => None,
@@ -307,24 +304,25 @@ impl Synthesize for Packed<FigureElem> {
 
         // Construct the figure's counter.
         let counter = Counter::new(CounterKey::Selector(
-            select_where!(FigureElem, Kind => kind.clone()),
+            select_where!(FigureElem, kind => kind.clone()),
         ));
 
         // Fill the figure's caption.
-        let mut caption = elem.caption(styles).clone();
+        let mut caption = elem.caption.get_cloned(styles);
         if let Some(caption) = &mut caption {
             caption.synthesize(engine, styles)?;
-            caption.push_kind(kind.clone());
-            caption.push_supplement(supplement.clone());
-            caption.push_numbering(numbering.clone());
-            caption.push_counter(Some(counter.clone()));
-            caption.push_figure_location(location);
+            caption.kind = Some(kind.clone());
+            caption.supplement = Some(supplement.clone());
+            caption.numbering = Some(numbering.clone());
+            caption.counter = Some(Some(counter.clone()));
+            caption.figure_location = Some(location);
         }
 
-        elem.push_kind(Smart::Custom(kind));
-        elem.push_supplement(Smart::Custom(supplement.map(Supplement::Content)));
-        elem.push_counter(Some(counter));
-        elem.push_caption(caption);
+        elem.kind.set(Smart::Custom(kind));
+        elem.supplement
+            .set(Smart::Custom(supplement.map(Supplement::Content)));
+        elem.counter = Some(Some(counter));
+        elem.caption.set(caption);
 
         Ok(())
     }
@@ -334,19 +332,19 @@ impl Show for Packed<FigureElem> {
     #[typst_macros::time(name = "figure", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let span = self.span();
-        let target = TargetElem::target_in(styles);
+        let target = styles.get(TargetElem::target);
         let mut realized = self.body.clone();
 
         // Build the caption, if any.
-        if let Some(caption) = self.caption(styles).clone() {
-            let (first, second) = match caption.position(styles) {
+        if let Some(caption) = self.caption.get_cloned(styles) {
+            let (first, second) = match caption.position.get(styles) {
                 OuterVAlignment::Top => (caption.pack(), realized),
                 OuterVAlignment::Bottom => (realized, caption.pack()),
             };
             let mut seq = Vec::with_capacity(3);
             seq.push(first);
             if !target.is_html() {
-                let v = VElem::new(self.gap(styles).into()).with_weak(true);
+                let v = VElem::new(self.gap.get(styles).into()).with_weak(true);
                 seq.push(v.pack().spanned(span))
             }
             seq.push(second);
@@ -370,14 +368,14 @@ impl Show for Packed<FigureElem> {
             .spanned(span);
 
         // Wrap in a float.
-        if let Some(align) = self.placement(styles) {
+        if let Some(align) = self.placement.get(styles) {
             realized = PlaceElem::new(realized)
                 .with_alignment(align.map(|align| HAlignment::Center + align))
-                .with_scope(self.scope(styles))
+                .with_scope(self.scope.get(styles))
                 .with_float(true)
                 .pack()
                 .spanned(span);
-        } else if self.scope(styles) == PlacementScope::Parent {
+        } else if self.scope.get(styles) == PlacementScope::Parent {
             bail!(
                 span,
                 "parent-scoped placement is only available for floating figures";
@@ -394,8 +392,8 @@ impl ShowSet for Packed<FigureElem> {
         // Still allows breakable figures with
         // `show figure: set block(breakable: true)`.
         let mut map = Styles::new();
-        map.set(BlockElem::set_breakable(false));
-        map.set(AlignElem::set_alignment(Alignment::CENTER));
+        map.set(BlockElem::breakable, false);
+        map.set(AlignElem::alignment, Alignment::CENTER);
         map
     }
 }
@@ -413,29 +411,28 @@ impl Count for Packed<FigureElem> {
 impl Refable for Packed<FigureElem> {
     fn supplement(&self) -> Content {
         // After synthesis, this should always be custom content.
-        match (**self).supplement(StyleChain::default()).as_ref() {
-            Smart::Custom(Some(Supplement::Content(content))) => content.clone(),
+        match self.supplement.get_cloned(StyleChain::default()) {
+            Smart::Custom(Some(Supplement::Content(content))) => content,
             _ => Content::empty(),
         }
     }
 
     fn counter(&self) -> Counter {
-        (**self)
-            .counter()
-            .cloned()
+        self.counter
+            .clone()
             .flatten()
-            .unwrap_or_else(|| Counter::of(FigureElem::elem()))
+            .unwrap_or_else(|| Counter::of(FigureElem::ELEM))
     }
 
     fn numbering(&self) -> Option<&Numbering> {
-        (**self).numbering(StyleChain::default()).as_ref()
+        self.numbering.get_ref(StyleChain::default()).as_ref()
     }
 }
 
 impl Outlinable for Packed<FigureElem> {
     fn outlined(&self) -> bool {
-        (**self).outlined(StyleChain::default())
-            && (self.caption(StyleChain::default()).is_some()
+        self.outlined.get(StyleChain::default())
+            && (self.caption.get_ref(StyleChain::default()).is_some()
                 || self.numbering().is_some())
     }
 
@@ -449,7 +446,8 @@ impl Outlinable for Packed<FigureElem> {
     }
 
     fn body(&self) -> Content {
-        self.caption(StyleChain::default())
+        self.caption
+            .get_ref(StyleChain::default())
             .as_ref()
             .map(|caption| caption.body.clone())
             .unwrap_or_default()
@@ -573,10 +571,10 @@ impl FigureCaption {
     }
 
     fn get_separator(&self, styles: StyleChain) -> Content {
-        self.separator(styles).unwrap_or_else(|| {
+        self.separator.get_cloned(styles).unwrap_or_else(|| {
             TextElem::packed(Self::local_separator(
-                TextElem::lang_in(styles),
-                TextElem::region_in(styles),
+                styles.get(TextElem::lang),
+                styles.get(TextElem::region),
             ))
         })
     }
@@ -585,7 +583,7 @@ impl FigureCaption {
 impl Synthesize for Packed<FigureCaption> {
     fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         let elem = self.as_mut();
-        elem.push_separator(Smart::Custom(elem.get_separator(styles)));
+        elem.separator.set(Smart::Custom(elem.get_separator(styles)));
         Ok(())
     }
 }
@@ -601,10 +599,10 @@ impl Show for Packed<FigureCaption> {
             Some(Some(counter)),
             Some(Some(location)),
         ) = (
-            self.supplement().cloned(),
-            self.numbering(),
-            self.counter(),
-            self.figure_location(),
+            self.supplement.clone(),
+            &self.numbering,
+            &self.counter,
+            &self.figure_location,
         ) {
             let numbers = counter.display_at_loc(engine, *location, styles, numbering)?;
             if !supplement.is_empty() {
@@ -613,7 +611,7 @@ impl Show for Packed<FigureCaption> {
             realized = supplement + numbers + self.get_separator(styles) + realized;
         }
 
-        Ok(if TargetElem::target_in(styles).is_html() {
+        Ok(if styles.get(TargetElem::target).is_html() {
             HtmlElem::new(tag::figcaption)
                 .with_body(Some(realized))
                 .pack()
diff --git a/crates/typst-library/src/model/footnote.rs b/crates/typst-library/src/model/footnote.rs
index dfa3933bb..63a461bd6 100644
--- a/crates/typst-library/src/model/footnote.rs
+++ b/crates/typst-library/src/model/footnote.rs
@@ -67,7 +67,6 @@ pub struct FootnoteElem {
     /// #footnote[Star],
     /// #footnote[Dagger]
     /// ```
-    #[borrowed]
     #[default(Numbering::Pattern(NumberingPattern::from_str("1").unwrap()))]
     pub numbering: Numbering,
 
@@ -141,8 +140,8 @@ impl Show for Packed<FootnoteElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let span = self.span();
         let loc = self.declaration_location(engine).at(span)?;
-        let numbering = self.numbering(styles);
-        let counter = Counter::of(FootnoteElem::elem());
+        let numbering = self.numbering.get_ref(styles);
+        let counter = Counter::of(FootnoteElem::ELEM);
         let num = counter.display_at_loc(engine, loc, styles, numbering)?;
         let sup = SuperElem::new(num).pack().spanned(span);
         let loc = loc.variant(1);
@@ -248,7 +247,6 @@ pub struct FootnoteEntry {
     /// ]
     /// ```
     #[default(Em::new(1.0).into())]
-    #[resolve]
     pub clearance: Length,
 
     /// The gap between footnote entries.
@@ -261,7 +259,6 @@ pub struct FootnoteEntry {
     /// #footnote[Apart]
     /// ```
     #[default(Em::new(0.5).into())]
-    #[resolve]
     pub gap: Length,
 
     /// The indent of each footnote entry.
@@ -283,8 +280,8 @@ impl Show for Packed<FootnoteEntry> {
         let span = self.span();
         let number_gap = Em::new(0.05);
         let default = StyleChain::default();
-        let numbering = self.note.numbering(default);
-        let counter = Counter::of(FootnoteElem::elem());
+        let numbering = self.note.numbering.get_ref(default);
+        let counter = Counter::of(FootnoteElem::ELEM);
         let Some(loc) = self.note.location() else {
             bail!(
                 span, "footnote entry must have a location";
@@ -300,7 +297,7 @@ impl Show for Packed<FootnoteEntry> {
             .located(loc.variant(1));
 
         Ok(Content::sequence([
-            HElem::new(self.indent(styles).into()).pack(),
+            HElem::new(self.indent.get(styles).into()).pack(),
             sup,
             HElem::new(number_gap.into()).with_weak(true).pack(),
             self.note.body_content().unwrap().clone(),
@@ -311,8 +308,8 @@ impl Show for Packed<FootnoteEntry> {
 impl ShowSet for Packed<FootnoteEntry> {
     fn show_set(&self, _: StyleChain) -> Styles {
         let mut out = Styles::new();
-        out.set(ParElem::set_leading(Em::new(0.5).into()));
-        out.set(TextElem::set_size(TextSize(Em::new(0.85).into())));
+        out.set(ParElem::leading, Em::new(0.5).into());
+        out.set(TextElem::size, TextSize(Em::new(0.85).into()));
         out
     }
 }
diff --git a/crates/typst-library/src/model/heading.rs b/crates/typst-library/src/model/heading.rs
index 00931c815..d6f6d01f9 100644
--- a/crates/typst-library/src/model/heading.rs
+++ b/crates/typst-library/src/model/heading.rs
@@ -106,7 +106,6 @@ pub struct HeadingElem {
     /// == A subsection
     /// === A sub-subsection
     /// ```
-    #[borrowed]
     pub numbering: Option<Numbering>,
 
     /// A supplement for the heading.
@@ -187,8 +186,8 @@ pub struct HeadingElem {
 
 impl HeadingElem {
     pub fn resolve_level(&self, styles: StyleChain) -> NonZeroUsize {
-        self.level(styles).unwrap_or_else(|| {
-            NonZeroUsize::new(self.offset(styles) + self.depth(styles).get())
+        self.level.get(styles).unwrap_or_else(|| {
+            NonZeroUsize::new(self.offset.get(styles) + self.depth.get(styles).get())
                 .expect("overflow to 0 on NoneZeroUsize + usize")
         })
     }
@@ -200,7 +199,7 @@ impl Synthesize for Packed<HeadingElem> {
         engine: &mut Engine,
         styles: StyleChain,
     ) -> SourceResult<()> {
-        let supplement = match (**self).supplement(styles) {
+        let supplement = match self.supplement.get_ref(styles) {
             Smart::Auto => TextElem::packed(Self::local_name_in(styles)),
             Smart::Custom(None) => Content::empty(),
             Smart::Custom(Some(supplement)) => {
@@ -209,8 +208,9 @@ impl Synthesize for Packed<HeadingElem> {
         };
 
         let elem = self.as_mut();
-        elem.push_level(Smart::Custom(elem.resolve_level(styles)));
-        elem.push_supplement(Smart::Custom(Some(Supplement::Content(supplement))));
+        elem.level.set(Smart::Custom(elem.resolve_level(styles)));
+        elem.supplement
+            .set(Smart::Custom(Some(Supplement::Content(supplement))));
         Ok(())
     }
 }
@@ -218,22 +218,22 @@ impl Synthesize for Packed<HeadingElem> {
 impl Show for Packed<HeadingElem> {
     #[typst_macros::time(name = "heading", span = self.span())]
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let html = TargetElem::target_in(styles).is_html();
+        let html = styles.get(TargetElem::target).is_html();
 
         const SPACING_TO_NUMBERING: Em = Em::new(0.3);
 
         let span = self.span();
         let mut realized = self.body.clone();
 
-        let hanging_indent = self.hanging_indent(styles);
+        let hanging_indent = self.hanging_indent.get(styles);
         let mut indent = match hanging_indent {
             Smart::Custom(length) => length.resolve(styles),
             Smart::Auto => Abs::zero(),
         };
 
-        if let Some(numbering) = (**self).numbering(styles).as_ref() {
+        if let Some(numbering) = self.numbering.get_ref(styles).as_ref() {
             let location = self.location().unwrap();
-            let numbering = Counter::of(HeadingElem::elem())
+            let numbering = Counter::of(HeadingElem::ELEM)
                 .display_at_loc(engine, location, styles, numbering)?
                 .spanned(span);
 
@@ -293,7 +293,7 @@ impl Show for Packed<HeadingElem> {
             let block = if indent != Abs::zero() {
                 let body = HElem::new((-indent).into()).pack() + realized;
                 let inset = Sides::default()
-                    .with(TextElem::dir_in(styles).start(), Some(indent.into()));
+                    .with(styles.resolve(TextElem::dir).start(), Some(indent.into()));
                 BlockElem::new()
                     .with_body(Some(BlockBody::Content(body)))
                     .with_inset(inset)
@@ -307,7 +307,7 @@ impl Show for Packed<HeadingElem> {
 
 impl ShowSet for Packed<HeadingElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
-        let level = (**self).resolve_level(styles).get();
+        let level = self.resolve_level(styles).get();
         let scale = match level {
             1 => 1.4,
             2 => 1.2,
@@ -319,49 +319,49 @@ impl ShowSet for Packed<HeadingElem> {
         let below = Em::new(0.75) / scale;
 
         let mut out = Styles::new();
-        out.set(TextElem::set_size(TextSize(size.into())));
-        out.set(TextElem::set_weight(FontWeight::BOLD));
-        out.set(BlockElem::set_above(Smart::Custom(above.into())));
-        out.set(BlockElem::set_below(Smart::Custom(below.into())));
-        out.set(BlockElem::set_sticky(true));
+        out.set(TextElem::size, TextSize(size.into()));
+        out.set(TextElem::weight, FontWeight::BOLD);
+        out.set(BlockElem::above, Smart::Custom(above.into()));
+        out.set(BlockElem::below, Smart::Custom(below.into()));
+        out.set(BlockElem::sticky, true);
         out
     }
 }
 
 impl Count for Packed<HeadingElem> {
     fn update(&self) -> Option<CounterUpdate> {
-        (**self)
-            .numbering(StyleChain::default())
+        self.numbering
+            .get_ref(StyleChain::default())
             .is_some()
-            .then(|| CounterUpdate::Step((**self).resolve_level(StyleChain::default())))
+            .then(|| CounterUpdate::Step(self.resolve_level(StyleChain::default())))
     }
 }
 
 impl Refable for Packed<HeadingElem> {
     fn supplement(&self) -> Content {
         // After synthesis, this should always be custom content.
-        match (**self).supplement(StyleChain::default()) {
+        match self.supplement.get_cloned(StyleChain::default()) {
             Smart::Custom(Some(Supplement::Content(content))) => content,
             _ => Content::empty(),
         }
     }
 
     fn counter(&self) -> Counter {
-        Counter::of(HeadingElem::elem())
+        Counter::of(HeadingElem::ELEM)
     }
 
     fn numbering(&self) -> Option<&Numbering> {
-        (**self).numbering(StyleChain::default()).as_ref()
+        self.numbering.get_ref(StyleChain::default()).as_ref()
     }
 }
 
 impl Outlinable for Packed<HeadingElem> {
     fn outlined(&self) -> bool {
-        (**self).outlined(StyleChain::default())
+        self.outlined.get(StyleChain::default())
     }
 
     fn level(&self) -> NonZeroUsize {
-        (**self).resolve_level(StyleChain::default())
+        self.resolve_level(StyleChain::default())
     }
 
     fn prefix(&self, numbers: Content) -> Content {
diff --git a/crates/typst-library/src/model/link.rs b/crates/typst-library/src/model/link.rs
index ea85aa945..1e2c708e8 100644
--- a/crates/typst-library/src/model/link.rs
+++ b/crates/typst-library/src/model/link.rs
@@ -108,7 +108,7 @@ impl Show for Packed<LinkElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
 
-        Ok(if TargetElem::target_in(styles).is_html() {
+        Ok(if styles.get(TargetElem::target).is_html() {
             if let LinkTarget::Dest(Destination::Url(url)) = &self.dest {
                 HtmlElem::new(tag::a)
                     .with_attr(attr::href, url.clone().into_inner())
@@ -138,7 +138,7 @@ impl Show for Packed<LinkElem> {
 impl ShowSet for Packed<LinkElem> {
     fn show_set(&self, _: StyleChain) -> Styles {
         let mut out = Styles::new();
-        out.set(TextElem::set_hyphenate(Smart::Custom(false)));
+        out.set(TextElem::hyphenate, Smart::Custom(false));
         out
     }
 }
diff --git a/crates/typst-library/src/model/list.rs b/crates/typst-library/src/model/list.rs
index 3c3afd338..5e6db1faa 100644
--- a/crates/typst-library/src/model/list.rs
+++ b/crates/typst-library/src/model/list.rs
@@ -86,7 +86,6 @@ pub struct ListElem {
     ///   - Items
     /// - Items
     /// ```
-    #[borrowed]
     #[default(ListMarker::Content(vec![
         // These are all available in the default font, vertically centered, and
         // roughly of the same size (with the last one having slightly lower
@@ -98,11 +97,9 @@ pub struct ListElem {
     pub marker: ListMarker,
 
     /// The indent of each item.
-    #[resolve]
     pub indent: Length,
 
     /// The spacing between the marker and the body of each item.
-    #[resolve]
     #[default(Em::new(0.5).into())]
     pub body_indent: Length,
 
@@ -141,9 +138,9 @@ impl ListElem {
 
 impl Show for Packed<ListElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let tight = self.tight(styles);
+        let tight = self.tight.get(styles);
 
-        if TargetElem::target_in(styles).is_html() {
+        if styles.get(TargetElem::target).is_html() {
             return Ok(HtmlElem::new(tag::ul)
                 .with_body(Some(Content::sequence(self.children.iter().map(|item| {
                     // Text in wide lists shall always turn into paragraphs.
@@ -167,8 +164,9 @@ impl Show for Packed<ListElem> {
 
         if tight {
             let spacing = self
-                .spacing(styles)
-                .unwrap_or_else(|| ParElem::leading_in(styles).into());
+                .spacing
+                .get(styles)
+                .unwrap_or_else(|| styles.get(ParElem::leading));
             let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
             realized = v + realized;
         }
diff --git a/crates/typst-library/src/model/outline.rs b/crates/typst-library/src/model/outline.rs
index 16a116146..bb061fb7b 100644
--- a/crates/typst-library/src/model/outline.rs
+++ b/crates/typst-library/src/model/outline.rs
@@ -183,8 +183,7 @@ pub struct OutlineElem {
     ///   caption: [Experiment results],
     /// )
     /// ```
-    #[default(LocatableSelector(HeadingElem::elem().select()))]
-    #[borrowed]
+    #[default(LocatableSelector(HeadingElem::ELEM.select()))]
     pub target: LocatableSelector,
 
     /// The maximum level up to which elements are included in the outline. When
@@ -257,7 +256,7 @@ impl Show for Packed<OutlineElem> {
 
         // Build the outline title.
         let mut seq = vec![];
-        if let Some(title) = self.title(styles).unwrap_or_else(|| {
+        if let Some(title) = self.title.get_cloned(styles).unwrap_or_else(|| {
             Some(TextElem::packed(Self::local_name_in(styles)).spanned(span))
         }) {
             seq.push(
@@ -268,8 +267,8 @@ impl Show for Packed<OutlineElem> {
             );
         }
 
-        let elems = engine.introspector.query(&self.target(styles).0);
-        let depth = self.depth(styles).unwrap_or(NonZeroUsize::MAX);
+        let elems = engine.introspector.query(&self.target.get_ref(styles).0);
+        let depth = self.depth.get(styles).unwrap_or(NonZeroUsize::MAX);
 
         // Build the outline entries.
         for elem in elems {
@@ -291,13 +290,13 @@ impl Show for Packed<OutlineElem> {
 impl ShowSet for Packed<OutlineElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
-        out.set(HeadingElem::set_outlined(false));
-        out.set(HeadingElem::set_numbering(None));
-        out.set(ParElem::set_justify(false));
-        out.set(BlockElem::set_above(Smart::Custom(ParElem::leading_in(styles).into())));
+        out.set(HeadingElem::outlined, false);
+        out.set(HeadingElem::numbering, None);
+        out.set(ParElem::justify, false);
+        out.set(BlockElem::above, Smart::Custom(styles.get(ParElem::leading).into()));
         // Makes the outline itself available to its entries. Should be
         // superseded by a proper ancestry mechanism in the future.
-        out.set(OutlineEntry::set_parent(Some(self.clone())));
+        out.set(OutlineEntry::parent, Some(self.clone()));
         out
     }
 }
@@ -395,7 +394,6 @@ pub struct OutlineEntry {
     ///
     /// = A New Beginning
     /// ```
-    #[borrowed]
     #[default(Some(
         RepeatElem::new(TextElem::packed("."))
             .with_gap(Em::new(0.15).into())
@@ -472,7 +470,9 @@ impl OutlineEntry {
         gap: Length,
     ) -> SourceResult<Content> {
         let styles = context.styles().at(span)?;
-        let outline = Self::parent_in(styles)
+        let outline = styles
+            .get_ref(Self::parent)
+            .as_ref()
             .ok_or("must be called within the context of an outline")
             .at(span)?;
         let outline_loc = outline.location().unwrap();
@@ -483,7 +483,7 @@ impl OutlineEntry {
             .transpose()?;
         let prefix_inset = prefix_width.map(|w| w + gap.resolve(styles));
 
-        let indent = outline.indent(styles);
+        let indent = outline.indent.get_ref(styles);
         let (base_indent, hanging_indent) = match &indent {
             Smart::Auto => compute_auto_indents(
                 engine.introspector,
@@ -527,7 +527,7 @@ impl OutlineEntry {
         };
 
         let inset = Sides::default().with(
-            TextElem::dir_in(styles).start(),
+            styles.resolve(TextElem::dir).start(),
             Some(base_indent + Rel::from(hanging_indent.unwrap_or_default())),
         );
 
@@ -582,7 +582,7 @@ impl OutlineEntry {
         // See also:
         // - https://github.com/typst/typst/issues/4476
         // - https://github.com/typst/typst/issues/5176
-        let rtl = TextElem::dir_in(styles) == Dir::RTL;
+        let rtl = styles.resolve(TextElem::dir) == Dir::RTL;
         if rtl {
             // "Right-to-Left Embedding"
             seq.push(TextElem::packed("\u{202B}"));
@@ -596,11 +596,11 @@ impl OutlineEntry {
         }
 
         // Add the filler between the section name and page number.
-        if let Some(filler) = self.fill(styles) {
+        if let Some(filler) = self.fill.get_cloned(styles) {
             seq.push(SpaceElem::shared().clone());
             seq.push(
                 BoxElem::new()
-                    .with_body(Some(filler.clone()))
+                    .with_body(Some(filler))
                     .with_width(Fr::one().into())
                     .pack()
                     .spanned(span),
@@ -717,7 +717,7 @@ fn query_prefix_widths(
     outline_loc: Location,
 ) -> SmallVec<[Option<Abs>; 4]> {
     let mut widths = SmallVec::<[Option<Abs>; 4]>::new();
-    let elems = introspector.query(&select_where!(PrefixInfo, Key => outline_loc));
+    let elems = introspector.query(&select_where!(PrefixInfo, key => outline_loc));
     for elem in &elems {
         let info = elem.to_packed::<PrefixInfo>().unwrap();
         let level = info.level.get();
diff --git a/crates/typst-library/src/model/par.rs b/crates/typst-library/src/model/par.rs
index cf31b5195..8aceec2c7 100644
--- a/crates/typst-library/src/model/par.rs
+++ b/crates/typst-library/src/model/par.rs
@@ -108,7 +108,6 @@ pub struct ParElem {
     /// to `{-0.2em}` to get a baseline gap of exactly `{2em}`. The exact
     /// distribution of the top- and bottom-edge values affects the bounds of
     /// the first and last line.
-    #[resolve]
     #[default(Em::new(0.65).into())]
     pub leading: Length,
 
@@ -122,7 +121,6 @@ pub struct ParElem {
     /// that block's [`above`]($block.above) or [`below`]($block.below) property
     /// takes precedence over the paragraph spacing. Headings, for instance,
     /// reduce the spacing below them by default for a better look.
-    #[resolve]
     #[default(Em::new(1.2).into())]
     pub spacing: Length,
 
@@ -213,7 +211,6 @@ pub struct ParElem {
     ///
     /// #lorem(15)
     /// ```
-    #[resolve]
     pub hanging_indent: Length,
 
     /// The contents of the paragraph.
diff --git a/crates/typst-library/src/model/quote.rs b/crates/typst-library/src/model/quote.rs
index cd45eec8e..a8cf3eaef 100644
--- a/crates/typst-library/src/model/quote.rs
+++ b/crates/typst-library/src/model/quote.rs
@@ -123,7 +123,6 @@ pub struct QuoteElem {
     ///
     /// #bibliography("works.bib", style: "apa")
     /// ```
-    #[borrowed]
     attribution: Option<Attribution>,
 
     /// The quote.
@@ -158,19 +157,19 @@ impl Show for Packed<QuoteElem> {
     #[typst_macros::time(name = "quote", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let mut realized = self.body.clone();
-        let block = self.block(styles);
-        let html = TargetElem::target_in(styles).is_html();
+        let block = self.block.get(styles);
+        let html = styles.get(TargetElem::target).is_html();
 
-        if self.quotes(styles).unwrap_or(!block) {
+        if self.quotes.get(styles).unwrap_or(!block) {
             let quotes = SmartQuotes::get(
-                SmartQuoteElem::quotes_in(styles),
-                TextElem::lang_in(styles),
-                TextElem::region_in(styles),
-                SmartQuoteElem::alternative_in(styles),
+                styles.get_ref(SmartQuoteElem::quotes),
+                styles.get(TextElem::lang),
+                styles.get(TextElem::region),
+                styles.get(SmartQuoteElem::alternative),
             );
 
             // Alternate between single and double quotes.
-            let Depth(depth) = QuoteElem::depth_in(styles);
+            let Depth(depth) = styles.get(QuoteElem::depth);
             let double = depth % 2 == 0;
 
             if !html {
@@ -183,10 +182,10 @@ impl Show for Packed<QuoteElem> {
                 realized,
                 TextElem::packed(quotes.close(double)),
             ])
-            .styled(QuoteElem::set_depth(Depth(1)));
+            .set(QuoteElem::depth, Depth(1));
         }
 
-        let attribution = self.attribution(styles);
+        let attribution = self.attribution.get_ref(styles);
 
         if block {
             realized = if html {
@@ -204,7 +203,7 @@ impl Show for Packed<QuoteElem> {
             }
             .spanned(self.span());
 
-            if let Some(attribution) = attribution.as_ref() {
+            if let Some(attribution) = attribution {
                 let attribution = match attribution {
                     Attribution::Content(content) => content.clone(),
                     Attribution::Label(label) => CiteElem::new(*label)
@@ -247,11 +246,11 @@ impl Show for Packed<QuoteElem> {
 impl ShowSet for Packed<QuoteElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
-        if self.block(styles) {
-            out.set(PadElem::set_left(Em::new(1.0).into()));
-            out.set(PadElem::set_right(Em::new(1.0).into()));
-            out.set(BlockElem::set_above(Smart::Custom(Em::new(2.4).into())));
-            out.set(BlockElem::set_below(Smart::Custom(Em::new(1.8).into())));
+        if self.block.get(styles) {
+            out.set(PadElem::left, Em::new(1.0).into());
+            out.set(PadElem::right, Em::new(1.0).into());
+            out.set(BlockElem::above, Smart::Custom(Em::new(2.4).into()));
+            out.set(BlockElem::below, Smart::Custom(Em::new(1.8).into()));
         }
         out
     }
diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index 17f93b7c4..2d04a97a4 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -175,7 +175,6 @@ pub struct RefElem {
     /// in @intro[Part], it is done
     /// manually.
     /// ```
-    #[borrowed]
     pub supplement: Smart<Option<Supplement>>,
 
     /// The kind of reference to produce.
@@ -207,12 +206,12 @@ impl Synthesize for Packed<RefElem> {
         let citation = to_citation(self, engine, styles)?;
 
         let elem = self.as_mut();
-        elem.push_citation(Some(citation));
-        elem.push_element(None);
+        elem.citation = Some(Some(citation));
+        elem.element = Some(None);
 
         if !BibliographyElem::has(engine, elem.target) {
             if let Ok(found) = engine.introspector.query_label(elem.target).cloned() {
-                elem.push_element(Some(found));
+                elem.element = Some(Some(found));
                 return Ok(());
             }
         }
@@ -227,7 +226,7 @@ impl Show for Packed<RefElem> {
         let elem = engine.introspector.query_label(self.target);
         let span = self.span();
 
-        let form = self.form(styles);
+        let form = self.form.get(styles);
         if form == RefForm::Page {
             let elem = elem.at(span)?;
             let elem = elem.clone();
@@ -299,7 +298,7 @@ impl Show for Packed<RefElem> {
             .hint(eco_format!(
                 "you can enable {} numbering with `#set {}(numbering: \"1.\")`",
                 elem.func().name(),
-                if elem.func() == EquationElem::elem() {
+                if elem.func() == EquationElem::ELEM {
                     "math.equation"
                 } else {
                     elem.func().name()
@@ -332,7 +331,7 @@ fn show_reference(
     let loc = elem.location().unwrap();
     let numbers = counter.display_at_loc(engine, loc, styles, &numbering.trimmed())?;
 
-    let supplement = match reference.supplement(styles).as_ref() {
+    let supplement = match reference.supplement.get_ref(styles) {
         Smart::Auto => supplement,
         Smart::Custom(None) => Content::empty(),
         Smart::Custom(Some(supplement)) => supplement.resolve(engine, styles, [elem])?,
@@ -353,7 +352,7 @@ fn to_citation(
     styles: StyleChain,
 ) -> SourceResult<Packed<CiteElem>> {
     let mut elem = Packed::new(CiteElem::new(reference.target).with_supplement(
-        match reference.supplement(styles).clone() {
+        match reference.supplement.get_cloned(styles) {
             Smart::Custom(Some(Supplement::Content(content))) => Some(content),
             _ => None,
         },
diff --git a/crates/typst-library/src/model/strong.rs b/crates/typst-library/src/model/strong.rs
index 16d04ba97..08cf48391 100644
--- a/crates/typst-library/src/model/strong.rs
+++ b/crates/typst-library/src/model/strong.rs
@@ -44,13 +44,13 @@ impl Show for Packed<StrongElem> {
     #[typst_macros::time(name = "strong", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
-        Ok(if TargetElem::target_in(styles).is_html() {
+        Ok(if styles.get(TargetElem::target).is_html() {
             HtmlElem::new(tag::strong)
                 .with_body(Some(body))
                 .pack()
                 .spanned(self.span())
         } else {
-            body.styled(TextElem::set_delta(WeightDelta(self.delta(styles))))
+            body.set(TextElem::delta, WeightDelta(self.delta.get(styles)))
         })
     }
 }
diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index dcc77b0dc..72c5acc5d 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -125,12 +125,10 @@ use crate::visualize::{Paint, Stroke};
 pub struct TableElem {
     /// The column sizes. See the [grid documentation]($grid) for more
     /// information on track sizing.
-    #[borrowed]
     pub columns: TrackSizings,
 
     /// The row sizes. See the [grid documentation]($grid) for more information
     /// on track sizing.
-    #[borrowed]
     pub rows: TrackSizings,
 
     /// The gaps between rows and columns. This is a shorthand for setting
@@ -141,7 +139,6 @@ pub struct TableElem {
 
     /// The gaps between columns. Takes precedence over `gutter`. See the
     /// [grid documentation]($grid) for more information on gutters.
-    #[borrowed]
     #[parse(
         let gutter = args.named("gutter")?;
         args.named("column-gutter")?.or_else(|| gutter.clone())
@@ -151,7 +148,6 @@ pub struct TableElem {
     /// The gaps between rows. Takes precedence over `gutter`. See the
     /// [grid documentation]($grid) for more information on gutters.
     #[parse(args.named("row-gutter")?.or_else(|| gutter.clone()))]
-    #[borrowed]
     pub row_gutter: TrackSizings,
 
     /// How to fill the cells.
@@ -176,7 +172,6 @@ pub struct TableElem {
     ///   [Profit:], [500 €], [1000 €], [1500 €],
     /// )
     /// ```
-    #[borrowed]
     pub fill: Celled<Option<Paint>>,
 
     /// How to align the cells' content.
@@ -194,7 +189,6 @@ pub struct TableElem {
     ///   [A], [B], [C],
     /// )
     /// ```
-    #[borrowed]
     pub align: Celled<Smart<Alignment>>,
 
     /// How to [stroke] the cells.
@@ -209,7 +203,6 @@ pub struct TableElem {
     ///
     /// See the [grid documentation]($grid.stroke) for more information on
     /// strokes.
-    #[resolve]
     #[fold]
     #[default(Celled::Value(Sides::splat(Some(Some(Arc::new(Stroke::default()))))))]
     pub stroke: Celled<Sides<Option<Option<Arc<Stroke>>>>>,
@@ -267,10 +260,10 @@ fn show_cell_html(tag: HtmlTag, cell: &Cell, styles: StyleChain) -> Content {
     let Some(cell) = cell.to_packed::<TableCell>() else { return cell };
     let mut attrs = HtmlAttrs::default();
     let span = |n: NonZeroUsize| (n != NonZeroUsize::MIN).then(|| n.to_string());
-    if let Some(colspan) = span(cell.colspan(styles)) {
+    if let Some(colspan) = span(cell.colspan.get(styles)) {
         attrs.push(attr::colspan, colspan);
     }
-    if let Some(rowspan) = span(cell.rowspan(styles)) {
+    if let Some(rowspan) = span(cell.rowspan.get(styles)) {
         attrs.push(attr::rowspan, rowspan);
     }
     HtmlElem::new(tag)
@@ -357,7 +350,7 @@ fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
 
 impl Show for Packed<TableElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(if TargetElem::target_in(styles).is_html() {
+        Ok(if styles.get(TargetElem::target).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();
@@ -621,7 +614,6 @@ pub struct TableHLine {
     ///
     /// Specifying `{none}` removes any lines previously placed across this
     /// line's range, including hlines or per-cell stroke below it.
-    #[resolve]
     #[fold]
     #[default(Some(Arc::new(Stroke::default())))]
     pub stroke: Option<Arc<Stroke>>,
@@ -666,7 +658,6 @@ pub struct TableVLine {
     ///
     /// Specifying `{none}` removes any lines previously placed across this
     /// line's range, including vlines or per-cell stroke below it.
-    #[resolve]
     #[fold]
     #[default(Some(Arc::new(Stroke::default())))]
     pub stroke: Option<Arc<Stroke>>,
@@ -802,7 +793,6 @@ pub struct TableCell {
     pub inset: Smart<Sides<Option<Rel<Length>>>>,
 
     /// The cell's [stroke]($table.stroke) override.
-    #[resolve]
     #[fold]
     pub stroke: Sides<Option<Option<Arc<Stroke>>>>,
 
@@ -820,7 +810,7 @@ cast! {
 
 impl Show for Packed<TableCell> {
     fn show(&self, _engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        show_grid_cell(self.body.clone(), self.inset(styles), self.align(styles))
+        show_grid_cell(self.body.clone(), self.inset.get(styles), self.align.get(styles))
     }
 }
 
diff --git a/crates/typst-library/src/model/terms.rs b/crates/typst-library/src/model/terms.rs
index 3df74cd9e..280c2d67e 100644
--- a/crates/typst-library/src/model/terms.rs
+++ b/crates/typst-library/src/model/terms.rs
@@ -66,7 +66,6 @@ pub struct TermsElem {
     /// / Colon: A nice separator symbol.
     /// ```
     #[default(HElem::new(Em::new(0.6).into()).with_weak(true).pack())]
-    #[borrowed]
     pub separator: Content,
 
     /// The indentation of each item.
@@ -121,9 +120,9 @@ impl TermsElem {
 impl Show for Packed<TermsElem> {
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let span = self.span();
-        let tight = self.tight(styles);
+        let tight = self.tight.get(styles);
 
-        if TargetElem::target_in(styles).is_html() {
+        if styles.get(TargetElem::target).is_html() {
             return Ok(HtmlElem::new(tag::dl)
                 .with_body(Some(Content::sequence(self.children.iter().flat_map(
                     |item| {
@@ -148,14 +147,14 @@ impl Show for Packed<TermsElem> {
                 .pack());
         }
 
-        let separator = self.separator(styles);
-        let indent = self.indent(styles);
-        let hanging_indent = self.hanging_indent(styles);
-        let gutter = self.spacing(styles).unwrap_or_else(|| {
+        let separator = self.separator.get_ref(styles);
+        let indent = self.indent.get(styles);
+        let hanging_indent = self.hanging_indent.get(styles);
+        let gutter = self.spacing.get(styles).unwrap_or_else(|| {
             if tight {
-                ParElem::leading_in(styles).into()
+                styles.get(ParElem::leading)
             } else {
-                ParElem::spacing_in(styles).into()
+                styles.get(ParElem::spacing)
             }
         });
 
@@ -179,19 +178,21 @@ impl Show for Packed<TermsElem> {
             children.push(StackChild::Block(Content::sequence(seq)));
         }
 
-        let padding = Sides::default().with(TextElem::dir_in(styles).start(), pad.into());
+        let padding =
+            Sides::default().with(styles.resolve(TextElem::dir).start(), pad.into());
 
         let mut realized = StackElem::new(children)
             .with_spacing(Some(gutter.into()))
             .pack()
             .spanned(span)
             .padded(padding)
-            .styled(TermsElem::set_within(true));
+            .set(TermsElem::within, true);
 
         if tight {
             let spacing = self
-                .spacing(styles)
-                .unwrap_or_else(|| ParElem::leading_in(styles).into());
+                .spacing
+                .get(styles)
+                .unwrap_or_else(|| styles.get(ParElem::leading));
             let v = VElem::new(spacing.into())
                 .with_weak(true)
                 .with_attach(true)
diff --git a/crates/typst-library/src/pdf/embed.rs b/crates/typst-library/src/pdf/embed.rs
index 4c01cd651..0f93f95af 100644
--- a/crates/typst-library/src/pdf/embed.rs
+++ b/crates/typst-library/src/pdf/embed.rs
@@ -48,7 +48,6 @@ pub struct EmbedElem {
         let resolved = id.vpath().as_rootless_path().to_string_lossy().replace("\\", "/").into();
         Derived::new(path.clone(), resolved)
     )]
-    #[borrowed]
     pub path: Derived<EcoString, EcoString>,
 
     /// Raw file data, optionally.
@@ -72,17 +71,15 @@ pub struct EmbedElem {
     pub relationship: Option<EmbeddedFileRelationship>,
 
     /// The MIME type of the embedded file.
-    #[borrowed]
     pub mime_type: Option<EcoString>,
 
     /// A description for the embedded file.
-    #[borrowed]
     pub description: Option<EcoString>,
 }
 
 impl Show for Packed<EmbedElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if TargetElem::target_in(styles) == Target::Html {
+        if styles.get(TargetElem::target) == Target::Html {
             engine
                 .sink
                 .warn(warning!(self.span(), "embed was ignored during HTML export"));
diff --git a/crates/typst-library/src/text/case.rs b/crates/typst-library/src/text/case.rs
index 69dbf5e13..3b2ae450a 100644
--- a/crates/typst-library/src/text/case.rs
+++ b/crates/typst-library/src/text/case.rs
@@ -37,9 +37,7 @@ pub fn upper(
 fn case(text: Caseable, case: Case) -> Caseable {
     match text {
         Caseable::Str(v) => Caseable::Str(case.apply(&v).into()),
-        Caseable::Content(v) => {
-            Caseable::Content(v.styled(TextElem::set_case(Some(case))))
-        }
+        Caseable::Content(v) => Caseable::Content(v.set(TextElem::case, Some(case))),
     }
 }
 
diff --git a/crates/typst-library/src/text/deco.rs b/crates/typst-library/src/text/deco.rs
index d745a48fd..8c1d56345 100644
--- a/crates/typst-library/src/text/deco.rs
+++ b/crates/typst-library/src/text/deco.rs
@@ -30,7 +30,6 @@ pub struct UnderlineElem {
     ///   [care],
     /// )
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Smart<Stroke>,
 
@@ -42,7 +41,6 @@ pub struct UnderlineElem {
     ///   The Tale Of A Faraway Line I
     /// ]
     /// ```
-    #[resolve]
     pub offset: Smart<Length>,
 
     /// The amount by which to extend the line beyond (or within if negative)
@@ -53,7 +51,6 @@ pub struct UnderlineElem {
     ///   underline(extent: 2pt)[Chapter 1]
     /// )
     /// ```
-    #[resolve]
     pub extent: Length,
 
     /// Whether the line skips sections in which it would collide with the
@@ -84,7 +81,7 @@ 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() {
+        if styles.get(TargetElem::target).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.
@@ -94,15 +91,18 @@ impl Show for Packed<UnderlineElem> {
                 .pack());
         }
 
-        Ok(self.body.clone().styled(TextElem::set_deco(smallvec![Decoration {
-            line: DecoLine::Underline {
-                stroke: self.stroke(styles).unwrap_or_default(),
-                offset: self.offset(styles),
-                evade: self.evade(styles),
-                background: self.background(styles),
-            },
-            extent: self.extent(styles),
-        }])))
+        Ok(self.body.clone().set(
+            TextElem::deco,
+            smallvec![Decoration {
+                line: DecoLine::Underline {
+                    stroke: self.stroke.resolve(styles).unwrap_or_default(),
+                    offset: self.offset.resolve(styles),
+                    evade: self.evade.get(styles),
+                    background: self.background.get(styles),
+                },
+                extent: self.extent.resolve(styles),
+            }],
+        ))
     }
 }
 
@@ -127,7 +127,6 @@ pub struct OverlineElem {
     ///   [The Forest Theme],
     /// )
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Smart<Stroke>,
 
@@ -139,7 +138,6 @@ pub struct OverlineElem {
     ///   The Tale Of A Faraway Line II
     /// ]
     /// ```
-    #[resolve]
     pub offset: Smart<Length>,
 
     /// The amount by which to extend the line beyond (or within if negative)
@@ -150,7 +148,6 @@ pub struct OverlineElem {
     /// #set underline(extent: 4pt)
     /// #overline(underline[Typography Today])
     /// ```
-    #[resolve]
     pub extent: Length,
 
     /// Whether the line skips sections in which it would collide with the
@@ -186,22 +183,25 @@ 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() {
+        if styles.get(TargetElem::target).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(),
-                offset: self.offset(styles),
-                evade: self.evade(styles),
-                background: self.background(styles),
-            },
-            extent: self.extent(styles),
-        }])))
+        Ok(self.body.clone().set(
+            TextElem::deco,
+            smallvec![Decoration {
+                line: DecoLine::Overline {
+                    stroke: self.stroke.resolve(styles).unwrap_or_default(),
+                    offset: self.offset.resolve(styles),
+                    evade: self.evade.get(styles),
+                    background: self.background.get(styles),
+                },
+                extent: self.extent.resolve(styles),
+            }],
+        ))
     }
 }
 
@@ -225,7 +225,6 @@ pub struct StrikeElem {
     /// This is #strike(stroke: 1.5pt + red)[very stricken through]. \
     /// This is #strike(stroke: 10pt)[redacted].
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Smart<Stroke>,
 
@@ -239,7 +238,6 @@ pub struct StrikeElem {
     /// This is #strike(offset: auto)[low-ish]. \
     /// This is #strike(offset: -3.5pt)[on-top].
     /// ```
-    #[resolve]
     pub offset: Smart<Length>,
 
     /// The amount by which to extend the line beyond (or within if negative)
@@ -249,7 +247,6 @@ pub struct StrikeElem {
     /// This #strike(extent: -2pt)[skips] parts of the word.
     /// This #strike(extent: 2pt)[extends] beyond the word.
     /// ```
-    #[resolve]
     pub extent: Length,
 
     /// Whether the line is placed behind the content.
@@ -270,19 +267,22 @@ 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() {
+        if styles.get(TargetElem::target).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 {
-                stroke: self.stroke(styles).unwrap_or_default(),
-                offset: self.offset(styles),
-                background: self.background(styles),
-            },
-            extent: self.extent(styles),
-        }])))
+        Ok(self.body.clone().set(
+            TextElem::deco,
+            smallvec![Decoration {
+                // Note that we do not support evade option for strikethrough.
+                line: DecoLine::Strikethrough {
+                    stroke: self.stroke.resolve(styles).unwrap_or_default(),
+                    offset: self.offset.resolve(styles),
+                    background: self.background.get(styles),
+                },
+                extent: self.extent.resolve(styles),
+            }],
+        ))
     }
 }
 
@@ -312,7 +312,6 @@ pub struct HighlightElem {
     ///   stroke: fuchsia
     /// )[stroked highlighting].
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Sides<Option<Option<Stroke>>>,
 
@@ -346,7 +345,6 @@ pub struct HighlightElem {
     /// ```example
     /// A long #highlight(extent: 4pt)[background].
     /// ```
-    #[resolve]
     pub extent: Length,
 
     /// How much to round the highlight's corners. See the
@@ -357,7 +355,6 @@ pub struct HighlightElem {
     ///   radius: 5pt, extent: 2pt
     /// )[carefully], it will be on the test.
     /// ```
-    #[resolve]
     #[fold]
     pub radius: Corners<Option<Rel<Length>>>,
 
@@ -369,25 +366,29 @@ 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() {
+        if styles.get(TargetElem::target).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),
-                stroke: self
-                    .stroke(styles)
-                    .unwrap_or_default()
-                    .map(|stroke| stroke.map(Stroke::unwrap_or_default)),
-                top_edge: self.top_edge(styles),
-                bottom_edge: self.bottom_edge(styles),
-                radius: self.radius(styles).unwrap_or_default(),
-            },
-            extent: self.extent(styles),
-        }])))
+        Ok(self.body.clone().set(
+            TextElem::deco,
+            smallvec![Decoration {
+                line: DecoLine::Highlight {
+                    fill: self.fill.get_cloned(styles),
+                    stroke: self
+                        .stroke
+                        .resolve(styles)
+                        .unwrap_or_default()
+                        .map(|stroke| stroke.map(Stroke::unwrap_or_default)),
+                    top_edge: self.top_edge.get(styles),
+                    bottom_edge: self.bottom_edge.get(styles),
+                    radius: self.radius.resolve(styles).unwrap_or_default(),
+                },
+                extent: self.extent.resolve(styles),
+            }],
+        ))
     }
 }
 
diff --git a/crates/typst-library/src/text/lang.rs b/crates/typst-library/src/text/lang.rs
index a170714b5..530b1f004 100644
--- a/crates/typst-library/src/text/lang.rs
+++ b/crates/typst-library/src/text/lang.rs
@@ -250,7 +250,7 @@ pub trait LocalName {
     where
         Self: Sized,
     {
-        Self::local_name(TextElem::lang_in(styles), TextElem::region_in(styles))
+        Self::local_name(styles.get(TextElem::lang), styles.get(TextElem::region))
     }
 }
 
diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index 230f8e501..51663633f 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -165,7 +165,6 @@ pub struct TextElem {
         font_list.map(|font_list| font_list.v)
     })]
     #[default(FontList(vec![FontFamily::new("Libertinus Serif")]))]
-    #[borrowed]
     #[ghost]
     pub font: FontList,
 
@@ -260,7 +259,6 @@ pub struct TextElem {
     #[parse(args.named_or_find("size")?)]
     #[fold]
     #[default(TextSize(Abs::pt(11.0).into()))]
-    #[resolve]
     #[ghost]
     pub size: TextSize,
 
@@ -292,7 +290,6 @@ pub struct TextElem {
     /// ```example
     /// #text(stroke: 0.5pt + red)[Stroked]
     /// ```
-    #[resolve]
     #[ghost]
     pub stroke: Option<Stroke>,
 
@@ -302,7 +299,6 @@ pub struct TextElem {
     /// #set text(tracking: 1.5pt)
     /// Distant text.
     /// ```
-    #[resolve]
     #[ghost]
     pub tracking: Length,
 
@@ -318,7 +314,6 @@ pub struct TextElem {
     /// #set text(spacing: 200%)
     /// Text with distant words.
     /// ```
-    #[resolve]
     #[default(Rel::one())]
     #[ghost]
     pub spacing: Rel<Length>,
@@ -341,7 +336,6 @@ pub struct TextElem {
     /// A #text(baseline: 3pt)[lowered]
     /// word.
     /// ```
-    #[resolve]
     #[ghost]
     pub baseline: Length,
 
@@ -483,7 +477,6 @@ pub struct TextElem {
     /// #set text(dir: rtl)
     /// هذا عربي.
     /// ```
-    #[resolve]
     #[ghost]
     pub dir: TextDir,
 
@@ -950,24 +943,24 @@ pub fn families(styles: StyleChain<'_>) -> impl Iterator<Item = &'_ FontFamily>
         .collect()
     });
 
-    let tail = if TextElem::fallback_in(styles) { fallbacks.as_slice() } else { &[] };
-    TextElem::font_in(styles).into_iter().chain(tail.iter())
+    let tail = if styles.get(TextElem::fallback) { fallbacks.as_slice() } else { &[] };
+    styles.get_ref(TextElem::font).into_iter().chain(tail.iter())
 }
 
 /// Resolve the font variant.
 pub fn variant(styles: StyleChain) -> FontVariant {
     let mut variant = FontVariant::new(
-        TextElem::style_in(styles),
-        TextElem::weight_in(styles),
-        TextElem::stretch_in(styles),
+        styles.get(TextElem::style),
+        styles.get(TextElem::weight),
+        styles.get(TextElem::stretch),
     );
 
-    let WeightDelta(delta) = TextElem::delta_in(styles);
+    let WeightDelta(delta) = styles.get(TextElem::delta);
     variant.weight = variant
         .weight
         .thicken(delta.clamp(i16::MIN as i64, i16::MAX as i64) as i16);
 
-    if TextElem::emph_in(styles).0 {
+    if styles.get(TextElem::emph).0 {
         variant.style = match variant.style {
             FontStyle::Normal => FontStyle::Italic,
             FontStyle::Italic => FontStyle::Normal,
@@ -996,11 +989,11 @@ impl Resolve for TextSize {
     type Output = Abs;
 
     fn resolve(self, styles: StyleChain) -> Self::Output {
-        let factor = match EquationElem::size_in(styles) {
+        let factor = match styles.get(EquationElem::size) {
             MathSize::Display | MathSize::Text => 1.0,
-            MathSize::Script => EquationElem::script_scale_in(styles).0 as f64 / 100.0,
+            MathSize::Script => styles.get(EquationElem::script_scale).0 as f64 / 100.0,
             MathSize::ScriptScript => {
-                EquationElem::script_scale_in(styles).1 as f64 / 100.0
+                styles.get(EquationElem::script_scale).1 as f64 / 100.0
             }
         };
         factor * self.0.resolve(styles)
@@ -1123,7 +1116,7 @@ impl Resolve for TextDir {
 
     fn resolve(self, styles: StyleChain) -> Self::Output {
         match self.0 {
-            Smart::Auto => TextElem::lang_in(styles).dir(),
+            Smart::Auto => styles.get(TextElem::lang).dir(),
             Smart::Custom(dir) => dir,
         }
     }
@@ -1236,67 +1229,67 @@ pub fn features(styles: StyleChain) -> Vec<Feature> {
     };
 
     // Features that are on by default in Harfbuzz are only added if disabled.
-    if !TextElem::kerning_in(styles) {
+    if !styles.get(TextElem::kerning) {
         feat(b"kern", 0);
     }
 
     // Features that are off by default in Harfbuzz are only added if enabled.
-    if let Some(sc) = TextElem::smallcaps_in(styles) {
+    if let Some(sc) = styles.get(TextElem::smallcaps) {
         feat(b"smcp", 1);
         if sc == Smallcaps::All {
             feat(b"c2sc", 1);
         }
     }
 
-    if TextElem::alternates_in(styles) {
+    if styles.get(TextElem::alternates) {
         feat(b"salt", 1);
     }
 
-    for set in TextElem::stylistic_set_in(styles).sets() {
+    for set in styles.get(TextElem::stylistic_set).sets() {
         let storage = [b's', b's', b'0' + set / 10, b'0' + set % 10];
         feat(&storage, 1);
     }
 
-    if !TextElem::ligatures_in(styles) {
+    if !styles.get(TextElem::ligatures) {
         feat(b"liga", 0);
         feat(b"clig", 0);
     }
 
-    if TextElem::discretionary_ligatures_in(styles) {
+    if styles.get(TextElem::discretionary_ligatures) {
         feat(b"dlig", 1);
     }
 
-    if TextElem::historical_ligatures_in(styles) {
+    if styles.get(TextElem::historical_ligatures) {
         feat(b"hlig", 1);
     }
 
-    match TextElem::number_type_in(styles) {
+    match styles.get(TextElem::number_type) {
         Smart::Auto => {}
         Smart::Custom(NumberType::Lining) => feat(b"lnum", 1),
         Smart::Custom(NumberType::OldStyle) => feat(b"onum", 1),
     }
 
-    match TextElem::number_width_in(styles) {
+    match styles.get(TextElem::number_width) {
         Smart::Auto => {}
         Smart::Custom(NumberWidth::Proportional) => feat(b"pnum", 1),
         Smart::Custom(NumberWidth::Tabular) => feat(b"tnum", 1),
     }
 
-    if TextElem::slashed_zero_in(styles) {
+    if styles.get(TextElem::slashed_zero) {
         feat(b"zero", 1);
     }
 
-    if TextElem::fractions_in(styles) {
+    if styles.get(TextElem::fractions) {
         feat(b"frac", 1);
     }
 
-    match EquationElem::size_in(styles) {
+    match styles.get(EquationElem::size) {
         MathSize::Script => feat(b"ssty", 1),
         MathSize::ScriptScript => feat(b"ssty", 2),
         _ => {}
     }
 
-    for (tag, value) in TextElem::features_in(styles).0 {
+    for (tag, value) in styles.get_cloned(TextElem::features).0 {
         tags.push(Feature::new(tag, value, ..))
     }
 
@@ -1306,8 +1299,8 @@ pub fn features(styles: StyleChain) -> Vec<Feature> {
 /// Process the language and region of a style chain into a
 /// rustybuzz-compatible BCP 47 language.
 pub fn language(styles: StyleChain) -> rustybuzz::Language {
-    let mut bcp: EcoString = TextElem::lang_in(styles).as_str().into();
-    if let Some(region) = TextElem::region_in(styles) {
+    let mut bcp: EcoString = styles.get(TextElem::lang).as_str().into();
+    if let Some(region) = styles.get(TextElem::region) {
         bcp.push('-');
         bcp.push_str(region.as_str());
     }
diff --git a/crates/typst-library/src/text/raw.rs b/crates/typst-library/src/text/raw.rs
index e1f4cf13d..67038163d 100644
--- a/crates/typst-library/src/text/raw.rs
+++ b/crates/typst-library/src/text/raw.rs
@@ -158,7 +158,6 @@ pub struct RawElem {
     ///
     /// This is ```typ also *Typst*```, but inline!
     /// ````
-    #[borrowed]
     pub lang: Option<EcoString>,
 
     /// The horizontal alignment that each line in a raw block should have.
@@ -250,7 +249,6 @@ pub struct RawElem {
         Some(Spanned { v: Smart::Auto, .. }) => Some(Smart::Auto),
         None => None,
     })]
-    #[borrowed]
     pub theme: Smart<Option<Derived<DataSource, RawTheme>>>,
 
     /// The size for a tab stop in spaces. A tab is replaced with enough spaces to
@@ -306,7 +304,7 @@ impl RawElem {
 impl Synthesize for Packed<RawElem> {
     fn synthesize(&mut self, _: &mut Engine, styles: StyleChain) -> SourceResult<()> {
         let seq = self.highlight(styles);
-        self.push_lines(seq);
+        self.lines = Some(seq);
         Ok(())
     }
 }
@@ -319,8 +317,8 @@ impl Packed<RawElem> {
 
         let count = lines.len() as i64;
         let lang = elem
-            .lang(styles)
-            .as_ref()
+            .lang
+            .get_ref(styles)
             .as_ref()
             .map(|s| s.to_lowercase())
             .or(Some("txt".into()));
@@ -337,8 +335,8 @@ impl Packed<RawElem> {
             })
         };
 
-        let syntaxes = LazyCell::new(|| elem.syntaxes(styles));
-        let theme: &synt::Theme = match elem.theme(styles) {
+        let syntaxes = LazyCell::new(|| elem.syntaxes.get_cloned(styles));
+        let theme: &synt::Theme = match elem.theme.get_ref(styles) {
             Smart::Auto => &RAW_THEME,
             Smart::Custom(Some(theme)) => theme.derived.get(),
             Smart::Custom(None) => return non_highlighted_result(lines).collect(),
@@ -434,7 +432,7 @@ impl Packed<RawElem> {
 impl Show for Packed<RawElem> {
     #[typst_macros::time(name = "raw", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let lines = self.lines().map(|v| v.as_slice()).unwrap_or_default();
+        let lines = self.lines.as_deref().unwrap_or_default();
 
         let mut seq = EcoVec::with_capacity((2 * lines.len()).saturating_sub(1));
         for (i, line) in lines.iter().enumerate() {
@@ -447,8 +445,8 @@ impl Show for Packed<RawElem> {
 
         let mut realized = Content::sequence(seq);
 
-        if TargetElem::target_in(styles).is_html() {
-            return Ok(HtmlElem::new(if self.block(styles) {
+        if styles.get(TargetElem::target).is_html() {
+            return Ok(HtmlElem::new(if self.block.get(styles) {
                 tag::pre
             } else {
                 tag::code
@@ -458,9 +456,9 @@ impl Show for Packed<RawElem> {
             .spanned(self.span()));
         }
 
-        if self.block(styles) {
+        if self.block.get(styles) {
             // Align the text before inserting it into the block.
-            realized = realized.aligned(self.align(styles).into());
+            realized = realized.aligned(self.align.get(styles).into());
             realized = BlockElem::new()
                 .with_body(Some(BlockBody::Content(realized)))
                 .pack()
@@ -474,14 +472,14 @@ impl Show for Packed<RawElem> {
 impl ShowSet for Packed<RawElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
-        out.set(TextElem::set_overhang(false));
-        out.set(TextElem::set_lang(Lang::ENGLISH));
-        out.set(TextElem::set_hyphenate(Smart::Custom(false)));
-        out.set(TextElem::set_size(TextSize(Em::new(0.8).into())));
-        out.set(TextElem::set_font(FontList(vec![FontFamily::new("DejaVu Sans Mono")])));
-        out.set(TextElem::set_cjk_latin_spacing(Smart::Custom(None)));
-        if self.block(styles) {
-            out.set(ParElem::set_justify(false));
+        out.set(TextElem::overhang, false);
+        out.set(TextElem::lang, Lang::ENGLISH);
+        out.set(TextElem::hyphenate, Smart::Custom(false));
+        out.set(TextElem::size, TextSize(Em::new(0.8).into()));
+        out.set(TextElem::font, FontList(vec![FontFamily::new("DejaVu Sans Mono")]));
+        out.set(TextElem::cjk_latin_spacing, Smart::Custom(None));
+        if self.block.get(styles) {
+            out.set(ParElem::justify, false);
         }
         out
     }
@@ -789,7 +787,7 @@ fn preprocess(
 
     let mut text = text.get();
     if text.contains('\t') {
-        let tab_size = RawElem::tab_size_in(styles);
+        let tab_size = styles.get(RawElem::tab_size);
         text = align_tabs(&text, tab_size);
     }
     split_newlines(&text)
@@ -809,11 +807,11 @@ fn styled(
     let mut body = TextElem::packed(piece).spanned(span);
 
     if span_offset > 0 {
-        body = body.styled(TextElem::set_span_offset(span_offset));
+        body = body.set(TextElem::span_offset, span_offset);
     }
 
     if style.foreground != foreground {
-        body = body.styled(TextElem::set_fill(to_typst(style.foreground).into()));
+        body = body.set(TextElem::fill, to_typst(style.foreground).into());
     }
 
     if style.font_style.contains(synt::FontStyle::BOLD) {
diff --git a/crates/typst-library/src/text/shift.rs b/crates/typst-library/src/text/shift.rs
index b7f3ed926..1a05d8f9c 100644
--- a/crates/typst-library/src/text/shift.rs
+++ b/crates/typst-library/src/text/shift.rs
@@ -69,7 +69,7 @@ impl Show for Packed<SubElem> {
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
 
-        if TargetElem::target_in(styles).is_html() {
+        if styles.get(TargetElem::target).is_html() {
             return Ok(HtmlElem::new(tag::sub)
                 .with_body(Some(body))
                 .pack()
@@ -79,9 +79,9 @@ impl Show for Packed<SubElem> {
         show_script(
             styles,
             body,
-            self.typographic(styles),
-            self.baseline(styles),
-            self.size(styles),
+            self.typographic.get(styles),
+            self.baseline.get(styles),
+            self.size.get(styles),
             ScriptKind::Sub,
         )
     }
@@ -151,7 +151,7 @@ impl Show for Packed<SuperElem> {
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         let body = self.body.clone();
 
-        if TargetElem::target_in(styles).is_html() {
+        if styles.get(TargetElem::target).is_html() {
             return Ok(HtmlElem::new(tag::sup)
                 .with_body(Some(body))
                 .pack()
@@ -161,9 +161,9 @@ impl Show for Packed<SuperElem> {
         show_script(
             styles,
             body,
-            self.typographic(styles),
-            self.baseline(styles),
-            self.size(styles),
+            self.typographic.get(styles),
+            self.baseline.get(styles),
+            self.size.get(styles),
             ScriptKind::Super,
         )
     }
@@ -177,13 +177,16 @@ fn show_script(
     size: Smart<TextSize>,
     kind: ScriptKind,
 ) -> SourceResult<Content> {
-    let font_size = TextElem::size_in(styles);
-    Ok(body.styled(TextElem::set_shift_settings(Some(ShiftSettings {
-        typographic,
-        shift: baseline.map(|l| -Em::from_length(l, font_size)),
-        size: size.map(|t| Em::from_length(t.0, font_size)),
-        kind,
-    }))))
+    let font_size = styles.resolve(TextElem::size);
+    Ok(body.set(
+        TextElem::shift_settings,
+        Some(ShiftSettings {
+            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.
diff --git a/crates/typst-library/src/text/smallcaps.rs b/crates/typst-library/src/text/smallcaps.rs
index 924a45e8c..1c2838933 100644
--- a/crates/typst-library/src/text/smallcaps.rs
+++ b/crates/typst-library/src/text/smallcaps.rs
@@ -64,8 +64,9 @@ pub struct SmallcapsElem {
 impl Show for Packed<SmallcapsElem> {
     #[typst_macros::time(name = "smallcaps", span = self.span())]
     fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let sc = if self.all(styles) { Smallcaps::All } else { Smallcaps::Minuscules };
-        Ok(self.body.clone().styled(TextElem::set_smallcaps(Some(sc))))
+        let sc =
+            if self.all.get(styles) { Smallcaps::All } else { Smallcaps::Minuscules };
+        Ok(self.body.clone().set(TextElem::smallcaps, Some(sc)))
     }
 }
 
diff --git a/crates/typst-library/src/text/smartquote.rs b/crates/typst-library/src/text/smartquote.rs
index 09cefd013..24787d062 100644
--- a/crates/typst-library/src/text/smartquote.rs
+++ b/crates/typst-library/src/text/smartquote.rs
@@ -83,13 +83,12 @@ pub struct SmartQuoteElem {
     /// #set smartquote(quotes: (single: ("[[", "]]"),  double: auto))
     /// 'Das sind eigene Anführungszeichen.'
     /// ```
-    #[borrowed]
     pub quotes: Smart<SmartQuoteDict>,
 }
 
 impl PlainText for Packed<SmartQuoteElem> {
     fn plain_text(&self, text: &mut EcoString) {
-        if self.double.unwrap_or(true) {
+        if self.double.as_option().unwrap_or(true) {
             text.push_str("\"");
         } else {
             text.push_str("'");
diff --git a/crates/typst-library/src/visualize/curve.rs b/crates/typst-library/src/visualize/curve.rs
index 50944a516..587f0d4a2 100644
--- a/crates/typst-library/src/visualize/curve.rs
+++ b/crates/typst-library/src/visualize/curve.rs
@@ -86,7 +86,6 @@ pub struct CurveElem {
     ///   down, up, down, up, down,
     /// )
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Smart<Option<Stroke>>,
 
diff --git a/crates/typst-library/src/visualize/image/mod.rs b/crates/typst-library/src/visualize/image/mod.rs
index f5109798b..48a14f0ed 100644
--- a/crates/typst-library/src/visualize/image/mod.rs
+++ b/crates/typst-library/src/visualize/image/mod.rs
@@ -160,7 +160,6 @@ pub struct ImageElem {
         Some(Spanned { v: Smart::Auto, .. }) => Some(Smart::Auto),
         None => None,
     })]
-    #[borrowed]
     pub icc: Smart<Derived<DataSource, Bytes>>,
 }
 
@@ -199,22 +198,22 @@ impl ImageElem {
         let source = Derived::new(DataSource::Bytes(bytes), loaded);
         let mut elem = ImageElem::new(source);
         if let Some(format) = format {
-            elem.push_format(format);
+            elem.format.set(format);
         }
         if let Some(width) = width {
-            elem.push_width(width);
+            elem.width.set(width);
         }
         if let Some(height) = height {
-            elem.push_height(height);
+            elem.height.set(height);
         }
         if let Some(alt) = alt {
-            elem.push_alt(alt);
+            elem.alt.set(alt);
         }
         if let Some(fit) = fit {
-            elem.push_fit(fit);
+            elem.fit.set(fit);
         }
         if let Some(scaling) = scaling {
-            elem.push_scaling(scaling);
+            elem.scaling.set(scaling);
         }
         Ok(elem.pack().spanned(span))
     }
@@ -223,8 +222,8 @@ impl ImageElem {
 impl Show for Packed<ImageElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_image)
-            .with_width(self.width(styles))
-            .with_height(self.height(styles))
+            .with_width(self.width.get(styles))
+            .with_height(self.height.get(styles))
             .pack()
             .spanned(self.span()))
     }
diff --git a/crates/typst-library/src/visualize/line.rs b/crates/typst-library/src/visualize/line.rs
index 689321f1b..d058b926a 100644
--- a/crates/typst-library/src/visualize/line.rs
+++ b/crates/typst-library/src/visualize/line.rs
@@ -22,15 +22,12 @@ pub struct LineElem {
     /// The start point of the line.
     ///
     /// Must be an array of exactly two relative lengths.
-    #[resolve]
     pub start: Axes<Rel<Length>>,
 
     /// The point where the line ends.
-    #[resolve]
     pub end: Option<Axes<Rel<Length>>>,
 
     /// The line's length. This is only respected if `end` is `{none}`.
-    #[resolve]
     #[default(Abs::pt(30.0).into())]
     pub length: Rel<Length>,
 
@@ -50,7 +47,6 @@ pub struct LineElem {
     ///   line(stroke: (paint: blue, thickness: 1pt, dash: ("dot", 2pt, 4pt, 2pt))),
     /// )
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Stroke,
 }
diff --git a/crates/typst-library/src/visualize/path.rs b/crates/typst-library/src/visualize/path.rs
index 968146cda..e19e091df 100644
--- a/crates/typst-library/src/visualize/path.rs
+++ b/crates/typst-library/src/visualize/path.rs
@@ -55,7 +55,6 @@ pub struct PathElem {
     ///
     /// Can be set to  `{none}` to disable the stroke or to `{auto}` for a
     /// stroke of `{1pt}` black if and if only if no fill is given.
-    #[resolve]
     #[fold]
     pub stroke: Smart<Option<Stroke>>,
 
diff --git a/crates/typst-library/src/visualize/polygon.rs b/crates/typst-library/src/visualize/polygon.rs
index 42b083431..d75e1a657 100644
--- a/crates/typst-library/src/visualize/polygon.rs
+++ b/crates/typst-library/src/visualize/polygon.rs
@@ -43,7 +43,6 @@ pub struct PolygonElem {
     ///
     /// Can be set to  `{none}` to disable the stroke or to `{auto}` for a
     /// stroke of `{1pt}` black if and if only if no fill is given.
-    #[resolve]
     #[fold]
     pub stroke: Smart<Option<Stroke>>,
 
@@ -117,10 +116,10 @@ impl PolygonElem {
 
         let mut elem = PolygonElem::new(vertices);
         if let Some(fill) = fill {
-            elem.push_fill(fill);
+            elem.fill.set(fill);
         }
         if let Some(stroke) = stroke {
-            elem.push_stroke(stroke);
+            elem.stroke.set(stroke);
         }
         elem.pack().spanned(span)
     }
diff --git a/crates/typst-library/src/visualize/shape.rs b/crates/typst-library/src/visualize/shape.rs
index ff05be2be..f21bf93e9 100644
--- a/crates/typst-library/src/visualize/shape.rs
+++ b/crates/typst-library/src/visualize/shape.rs
@@ -63,7 +63,6 @@ pub struct RectElem {
     ///   rect(stroke: 2pt + red),
     /// )
     /// ```
-    #[resolve]
     #[fold]
     pub stroke: Smart<Sides<Option<Option<Stroke>>>>,
 
@@ -101,20 +100,17 @@ pub struct RectElem {
     ///   ),
     /// )
     /// ```
-    #[resolve]
     #[fold]
     pub radius: Corners<Option<Rel<Length>>>,
 
     /// How much to pad the rectangle's content.
     /// See the [box's documentation]($box.inset) for more details.
-    #[resolve]
     #[fold]
     #[default(Sides::splat(Some(Abs::pt(5.0).into())))]
     pub inset: Sides<Option<Rel<Length>>>,
 
     /// How much to expand the rectangle's size without affecting the layout.
     /// See the [box's documentation]($box.outset) for more details.
-    #[resolve]
     #[fold]
     pub outset: Sides<Option<Rel<Length>>>,
 
@@ -123,15 +119,14 @@ pub struct RectElem {
     /// When this is omitted, the rectangle takes on a default size of at most
     /// `{45pt}` by `{30pt}`.
     #[positional]
-    #[borrowed]
     pub body: Option<Content>,
 }
 
 impl Show for Packed<RectElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_rect)
-            .with_width(self.width(styles))
-            .with_height(self.height(styles))
+            .with_width(self.width.get(styles))
+            .with_height(self.height.get(styles))
             .pack()
             .spanned(self.span()))
     }
@@ -186,26 +181,22 @@ pub struct SquareElem {
 
     /// How to stroke the square. See the
     /// [rectangle's documentation]($rect.stroke) for more details.
-    #[resolve]
     #[fold]
     pub stroke: Smart<Sides<Option<Option<Stroke>>>>,
 
     /// How much to round the square's corners. See the
     /// [rectangle's documentation]($rect.radius) for more details.
-    #[resolve]
     #[fold]
     pub radius: Corners<Option<Rel<Length>>>,
 
     /// How much to pad the square's content. See the
     /// [box's documentation]($box.inset) for more details.
-    #[resolve]
     #[fold]
     #[default(Sides::splat(Some(Abs::pt(5.0).into())))]
     pub inset: Sides<Option<Rel<Length>>>,
 
     /// How much to expand the square's size without affecting the layout. See
     /// the [box's documentation]($box.outset) for more details.
-    #[resolve]
     #[fold]
     pub outset: Sides<Option<Rel<Length>>>,
 
@@ -215,15 +206,14 @@ pub struct SquareElem {
     /// When this is omitted, the square takes on a default size of at most
     /// `{30pt}`.
     #[positional]
-    #[borrowed]
     pub body: Option<Content>,
 }
 
 impl Show for Packed<SquareElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_square)
-            .with_width(self.width(styles))
-            .with_height(self.height(styles))
+            .with_width(self.width.get(styles))
+            .with_height(self.height.get(styles))
             .pack()
             .spanned(self.span()))
     }
@@ -257,20 +247,17 @@ pub struct EllipseElem {
 
     /// How to stroke the ellipse. See the
     /// [rectangle's documentation]($rect.stroke) for more details.
-    #[resolve]
     #[fold]
     pub stroke: Smart<Option<Stroke>>,
 
     /// How much to pad the ellipse's content. See the
     /// [box's documentation]($box.inset) for more details.
-    #[resolve]
     #[fold]
     #[default(Sides::splat(Some(Abs::pt(5.0).into())))]
     pub inset: Sides<Option<Rel<Length>>>,
 
     /// How much to expand the ellipse's size without affecting the layout. See
     /// the [box's documentation]($box.outset) for more details.
-    #[resolve]
     #[fold]
     pub outset: Sides<Option<Rel<Length>>>,
 
@@ -279,15 +266,14 @@ pub struct EllipseElem {
     /// When this is omitted, the ellipse takes on a default size of at most
     /// `{45pt}` by `{30pt}`.
     #[positional]
-    #[borrowed]
     pub body: Option<Content>,
 }
 
 impl Show for Packed<EllipseElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_ellipse)
-            .with_width(self.width(styles))
-            .with_height(self.height(styles))
+            .with_width(self.width.get(styles))
+            .with_height(self.height.get(styles))
             .pack()
             .spanned(self.span()))
     }
@@ -347,36 +333,32 @@ pub struct CircleElem {
 
     /// How to stroke the circle. See the
     /// [rectangle's documentation]($rect.stroke) for more details.
-    #[resolve]
     #[fold]
     #[default(Smart::Auto)]
     pub stroke: Smart<Option<Stroke>>,
 
     /// How much to pad the circle's content. See the
     /// [box's documentation]($box.inset) for more details.
-    #[resolve]
     #[fold]
     #[default(Sides::splat(Some(Abs::pt(5.0).into())))]
     pub inset: Sides<Option<Rel<Length>>>,
 
     /// How much to expand the circle's size without affecting the layout. See
     /// the [box's documentation]($box.outset) for more details.
-    #[resolve]
     #[fold]
     pub outset: Sides<Option<Rel<Length>>>,
 
     /// The content to place into the circle. The circle expands to fit this
     /// content, keeping the 1-1 aspect ratio.
     #[positional]
-    #[borrowed]
     pub body: Option<Content>,
 }
 
 impl Show for Packed<CircleElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_circle)
-            .with_width(self.width(styles))
-            .with_height(self.height(styles))
+            .with_width(self.width.get(styles))
+            .with_height(self.height.get(styles))
             .pack()
             .spanned(self.span()))
     }
diff --git a/crates/typst-macros/src/elem.rs b/crates/typst-macros/src/elem.rs
index 67fe7ed6a..e1c901d8a 100644
--- a/crates/typst-macros/src/elem.rs
+++ b/crates/typst-macros/src/elem.rs
@@ -1,9 +1,9 @@
-use heck::{ToKebabCase, ToShoutySnakeCase, ToUpperCamelCase};
+use heck::ToKebabCase;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
-use syn::{parse_quote, Ident, Result, Token};
+use syn::{Ident, Result, Token};
 
 use crate::util::{
     determine_name_and_title, documentation, foundations, has_attr, kw, parse_attr,
@@ -39,14 +39,13 @@ struct Elem {
 }
 
 impl Elem {
-    /// Calls the closure to produce a token stream if the
-    /// element has the given capability.
+    /// Whether the element has the given trait listed as a capability.
     fn can(&self, name: &str) -> bool {
         self.capabilities.iter().any(|capability| capability == name)
     }
 
-    /// Calls the closure to produce a token stream if the
-    /// element does not have the given capability.
+    /// Whether the element does not have the given trait listed as a
+    /// capability.
     fn cannot(&self, name: &str) -> bool {
         !self.can(name)
     }
@@ -68,21 +67,6 @@ impl Elem {
         self.struct_fields().filter(|field| !field.required)
     }
 
-    /// Fields that are relevant for equality.
-    ///
-    /// Synthesized fields are excluded to ensure equality before and after
-    /// synthesis.
-    fn eq_fields(&self) -> impl Iterator<Item = &Field> + Clone {
-        self.struct_fields().filter(|field| !field.synthesized)
-    }
-
-    /// Fields that show up in the documentation.
-    fn doc_fields(&self) -> impl Iterator<Item = &Field> + Clone {
-        self.fields
-            .iter()
-            .filter(|field| !field.internal && !field.synthesized)
-    }
-
     /// Fields that are relevant for `Construct` impl.
     ///
     /// The reason why fields that are `parse` and internal are allowed is
@@ -98,44 +82,20 @@ impl Elem {
     fn set_fields(&self) -> impl Iterator<Item = &Field> + Clone {
         self.construct_fields().filter(|field| !field.required)
     }
-
-    /// Fields that can be accessed from the style chain.
-    fn style_fields(&self) -> impl Iterator<Item = &Field> + Clone {
-        self.real_fields()
-            .filter(|field| !field.required && !field.synthesized)
-    }
-
-    /// Fields that are visible to the user.
-    fn visible_fields(&self) -> impl Iterator<Item = &Field> + Clone {
-        self.real_fields().filter(|field| !field.internal)
-    }
 }
 
 /// A field of an [element definition][`Elem`].
 struct Field {
+    /// The index of the field among all.
+    i: u8,
     /// The name of this field.
     ident: Ident,
-    /// The identifier `{ident}_in`.
-    ident_in: Ident,
     /// The identifier `with_{ident}`.
     with_ident: Ident,
-    /// The identifier `push_{ident}`.
-    push_ident: Ident,
-    /// The identifier `set_{ident}`.
-    set_ident: Ident,
-    /// The upper camel-case version of `ident`, used for the enum variant name.
-    enum_ident: Ident,
-    /// The all-caps snake-case version of `ident`, used for the constant name.
-    const_ident: Ident,
     /// The visibility of this field.
     vis: syn::Visibility,
     /// The type of this field.
     ty: syn::Type,
-    /// The type returned by accessor methods for this field.
-    ///
-    /// Usually, this is the same as `ty`, but this might be different
-    /// if this field has a `#[resolve]` attribute.
-    output: syn::Type,
     /// The field's identifier as exposed to Typst.
     name: String,
     /// The documentation for this field as a string.
@@ -147,16 +107,12 @@ struct Field {
     /// Whether this field is variadic; that is, has its values
     /// taken from a variable number of arguments.
     variadic: bool,
-    /// Whether this field has a `#[resolve]` attribute.
-    resolve: bool,
     /// Whether this field has a `#[fold]` attribute.
     fold: bool,
     /// Whether this field is excluded from documentation.
     internal: bool,
     /// Whether this field exists only in documentation.
     external: bool,
-    /// Whether this field has a `#[borrowed]` attribute.
-    borrowed: bool,
     /// Whether this field has a `#[ghost]` attribute.
     ghost: bool,
     /// Whether this field has a `#[synthesized]` attribute.
@@ -206,7 +162,12 @@ fn parse(stream: TokenStream, body: &syn::ItemStruct) -> Result<Elem> {
         bail!(body, "expected named fields");
     };
 
-    let fields = named.named.iter().map(parse_field).collect::<Result<Vec<_>>>()?;
+    let mut fields = named.named.iter().map(parse_field).collect::<Result<Vec<_>>>()?;
+    fields.sort_by_key(|field| field.internal);
+    for (i, field) in fields.iter_mut().enumerate() {
+        field.i = i as u8;
+    }
+
     if fields.iter().any(|field| field.ghost && !field.internal)
         && meta.capabilities.iter().all(|capability| capability != "Construct")
     {
@@ -243,27 +204,20 @@ fn parse_field(field: &syn::Field) -> Result<Field> {
     let required = has_attr(&mut attrs, "required") || variadic;
     let positional = has_attr(&mut attrs, "positional") || required;
 
-    let mut field = Field {
+    let field = Field {
+        i: 0,
         ident: ident.clone(),
-        ident_in: format_ident!("{ident}_in"),
         with_ident: format_ident!("with_{ident}"),
-        push_ident: format_ident!("push_{ident}"),
-        set_ident: format_ident!("set_{ident}"),
-        enum_ident: Ident::new(&ident.to_string().to_upper_camel_case(), ident.span()),
-        const_ident: Ident::new(&ident.to_string().to_shouty_snake_case(), ident.span()),
         vis: field.vis.clone(),
         ty: field.ty.clone(),
-        output: field.ty.clone(),
         name: ident.to_string().to_kebab_case(),
         docs: documentation(&attrs),
         positional,
         required,
         variadic,
-        resolve: has_attr(&mut attrs, "resolve"),
         fold: has_attr(&mut attrs, "fold"),
         internal: has_attr(&mut attrs, "internal"),
         external: has_attr(&mut attrs, "external"),
-        borrowed: has_attr(&mut attrs, "borrowed"),
         ghost: has_attr(&mut attrs, "ghost"),
         synthesized: has_attr(&mut attrs, "synthesized"),
         parse: parse_attr(&mut attrs, "parse")?.flatten(),
@@ -275,17 +229,9 @@ fn parse_field(field: &syn::Field) -> Result<Field> {
     }
 
     if (field.required || field.synthesized)
-        && (field.default.is_some() || field.fold || field.resolve || field.ghost)
+        && (field.default.is_some() || field.fold || field.ghost)
     {
-        bail!(
-            ident,
-            "required and synthesized fields cannot be default, fold, resolve, or ghost"
-        );
-    }
-
-    if field.resolve {
-        let ty = &field.ty;
-        field.output = parse_quote! { <#ty as #foundations::Resolve>::Output };
+        bail!(ident, "required and synthesized fields cannot be default, fold, or ghost");
     }
 
     validate_attrs(&attrs)?;
@@ -297,30 +243,17 @@ fn parse_field(field: &syn::Field) -> Result<Field> {
 fn create(element: &Elem) -> Result<TokenStream> {
     // The struct itself.
     let struct_ = create_struct(element);
+
+    // Implementations.
     let inherent_impl = create_inherent_impl(element);
-
-    // The enum with the struct's fields.
-    let fields_enum = create_fields_enum(element);
-
-    // The statics with borrowed fields' default values.
-    let default_statics = element
-        .style_fields()
-        .filter(|field| field.borrowed)
-        .map(create_default_static);
-
-    // Trait implementations.
     let native_element_impl = create_native_elem_impl(element);
-    let partial_eq_impl =
-        element.cannot("PartialEq").then(|| create_partial_eq_impl(element));
+    let field_impls =
+        element.fields.iter().map(|field| create_field_impl(element, field));
     let construct_impl =
         element.cannot("Construct").then(|| create_construct_impl(element));
     let set_impl = element.cannot("Set").then(|| create_set_impl(element));
-    let capable_impl = create_capable_impl(element);
-    let fields_impl = create_fields_impl(element);
-    let repr_impl = element.cannot("Repr").then(|| create_repr_impl(element));
     let locatable_impl = element.can("Locatable").then(|| create_locatable_impl(element));
     let mathy_impl = element.can("Mathy").then(|| create_mathy_impl(element));
-    let into_value_impl = create_into_value_impl(element);
 
     // We use a const block to create an anonymous scope, as to not leak any
     // local definitions.
@@ -328,19 +261,13 @@ fn create(element: &Elem) -> Result<TokenStream> {
         #struct_
 
         const _: () = {
-            #fields_enum
-            #(#default_statics)*
             #inherent_impl
             #native_element_impl
-            #fields_impl
-            #capable_impl
+            #(#field_impls)*
             #construct_impl
             #set_impl
-            #partial_eq_impl
-            #repr_impl
             #locatable_impl
             #mathy_impl
-            #into_value_impl
         };
     })
 }
@@ -365,80 +292,13 @@ fn create_struct(element: &Elem) -> TokenStream {
 
 /// Create a field declaration for the struct.
 fn create_field(field: &Field) -> TokenStream {
-    let Field { vis, ident, ty, .. } = field;
+    let Field { i, vis, ident, ty, .. } = field;
     if field.required {
         quote! { #vis #ident: #ty }
+    } else if field.synthesized {
+        quote! { #vis #ident: ::std::option::Option<#ty> }
     } else {
-        quote! { #ident: ::std::option::Option<#ty> }
-    }
-}
-
-/// Creates the element's enum for field identifiers.
-fn create_fields_enum(element: &Elem) -> TokenStream {
-    let variants: Vec<_> = element.real_fields().map(|field| &field.enum_ident).collect();
-    let names: Vec<_> = element.real_fields().map(|field| &field.name).collect();
-    let consts: Vec<_> = element.real_fields().map(|field| &field.const_ident).collect();
-    let repr = (!variants.is_empty()).then(|| quote! { #[repr(u8)] });
-
-    quote! {
-        #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-        #repr
-        pub enum Fields {
-            #(#variants,)*
-        }
-
-        impl Fields {
-            /// Converts the field identifier to the field name.
-            pub fn to_str(self) -> &'static str {
-                match self {
-                    #(Self::#variants => #names,)*
-                }
-            }
-        }
-
-        impl ::std::convert::TryFrom<u8> for Fields {
-            type Error = #foundations::FieldAccessError;
-
-            fn try_from(value: u8) -> Result<Self, Self::Error> {
-                #(const #consts: u8 = Fields::#variants as u8;)*
-                match value {
-                    #(#consts => Ok(Self::#variants),)*
-                    _ => Err(#foundations::FieldAccessError::Internal),
-                }
-            }
-        }
-
-        impl ::std::str::FromStr for Fields {
-            type Err = ();
-
-            fn from_str(s: &str) -> Result<Self, Self::Err> {
-                match s {
-                    #(#names => Ok(Self::#variants),)*
-                    _ => Err(()),
-                }
-            }
-        }
-
-        impl ::std::fmt::Display for Fields {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                f.pad(self.to_str())
-            }
-        }
-    }
-}
-
-/// Creates a static with a borrowed field's default value.
-fn create_default_static(field: &Field) -> TokenStream {
-    let Field { const_ident, default, ty, .. } = field;
-
-    let init = match default {
-        Some(default) => quote! { || #default },
-        None => quote! { ::std::default::Default::default },
-    };
-
-    quote! {
-        static #const_ident: ::std::sync::LazyLock<#ty> =
-            ::std::sync::LazyLock::new(#init);
+        quote! { #vis #ident: #foundations::Settable<Self, #i> }
     }
 }
 
@@ -448,19 +308,23 @@ fn create_inherent_impl(element: &Elem) -> TokenStream {
 
     let new_func = create_new_func(element);
     let with_field_methods = element.accessor_fields().map(create_with_field_method);
-    let push_field_methods = element.accessor_fields().map(create_push_field_method);
-    let field_methods = element.accessor_fields().map(create_field_method);
-    let field_in_methods = element.style_fields().map(create_field_in_method);
-    let set_field_methods = element.style_fields().map(create_set_field_method);
+
+    let style_consts = element.real_fields().map(|field| {
+        let Field { i, vis, ident, .. } = field;
+        quote! {
+            #vis const #ident: #foundations::Field<Self, #i>
+                = #foundations::Field::new();
+        }
+    });
 
     quote! {
         impl #ident {
             #new_func
             #(#with_field_methods)*
-            #(#push_field_methods)*
-            #(#field_methods)*
-            #(#field_in_methods)*
-            #(#set_field_methods)*
+        }
+        #[allow(non_upper_case_globals)]
+        impl #ident {
+            #(#style_consts)*
         }
     }
 }
@@ -476,8 +340,10 @@ fn create_new_func(element: &Elem) -> TokenStream {
         let ident = &field.ident;
         if field.required {
             quote! { #ident }
-        } else {
+        } else if field.synthesized {
             quote! { #ident: None }
+        } else {
+            quote! { #ident: #foundations::Settable::new() }
         }
     });
 
@@ -491,254 +357,189 @@ fn create_new_func(element: &Elem) -> TokenStream {
 
 /// Create a builder-style setter method for a field.
 fn create_with_field_method(field: &Field) -> TokenStream {
-    let Field { vis, ident, with_ident, push_ident, name, ty, .. } = field;
+    let Field { vis, ident, with_ident, name, ty, .. } = field;
     let doc = format!("Builder-style setter for the [`{name}`](Self::{ident}) field.");
+
+    let expr = if field.required {
+        quote! { self.#ident = #ident }
+    } else if field.synthesized {
+        quote! { self.#ident = Some(#ident) }
+    } else {
+        quote! { self.#ident.set(#ident) }
+    };
+
     quote! {
         #[doc = #doc]
         #vis fn #with_ident(mut self, #ident: #ty) -> Self {
-            self.#push_ident(#ident);
+            #expr;
             self
         }
     }
 }
 
-/// Create a setter method for a field.
-fn create_push_field_method(field: &Field) -> TokenStream {
-    let Field { vis, ident, push_ident, name, ty, .. } = field;
-    let doc = format!("Setter for the [`{name}`](Self::{ident}) field.");
-
-    let expr = if field.required {
-        quote! { #ident }
-    } else {
-        quote! { Some(#ident) }
-    };
-
-    quote! {
-        #[doc = #doc]
-        #vis fn #push_ident(&mut self, #ident: #ty) {
-            self.#ident = #expr;
-        }
-    }
-}
-
-/// Create an accessor method for a field.
-fn create_field_method(field: &Field) -> TokenStream {
-    let Field { vis, docs, ident, output, .. } = field;
-
-    if field.required {
-        quote! {
-            #[doc = #docs]
-            #vis fn #ident(&self) -> &#output {
-                &self.#ident
-            }
-        }
-    } else if field.synthesized {
-        quote! {
-            #[doc = #docs]
-            #[track_caller]
-            #vis fn #ident(&self) -> ::std::option::Option<&#output> {
-                self.#ident.as_ref()
-            }
-        }
-    } else {
-        let sig = if field.borrowed {
-            quote! { <'a>(&'a self, styles: #foundations::StyleChain<'a>) -> &'a #output }
-        } else {
-            quote! { (&self, styles: #foundations::StyleChain) -> #output }
-        };
-
-        let mut value = create_style_chain_access(
-            field,
-            field.borrowed,
-            quote! { self.#ident.as_ref() },
-        );
-        if field.resolve {
-            value = quote! { #foundations::Resolve::resolve(#value, styles) };
-        }
-
-        quote! {
-            #[doc = #docs]
-            #vis fn #ident #sig {
-                #value
-            }
-        }
-    }
-}
-
-/// Create a style accessor method for a field.
-fn create_field_in_method(field: &Field) -> TokenStream {
-    let Field { vis, ident_in, name, output, .. } = field;
-    let doc = format!("Access the `{name}` field in the given style chain.");
-
-    let ref_ = field.borrowed.then(|| quote! { & });
-
-    let mut value = create_style_chain_access(field, field.borrowed, quote! { None });
-    if field.resolve {
-        value = quote! { #foundations::Resolve::resolve(#value, styles) };
-    }
-
-    quote! {
-        #[doc = #doc]
-        #vis fn #ident_in(styles: #foundations::StyleChain) -> #ref_ #output {
-            #value
-        }
-    }
-}
-
-/// Create a style setter method for a field.
-fn create_set_field_method(field: &Field) -> TokenStream {
-    let Field { vis, ident, set_ident, enum_ident, ty, name, .. } = field;
-    let doc = format!("Create a style property for the `{name}` field.");
-
-    quote! {
-        #[doc = #doc]
-        #vis fn #set_ident(#ident: #ty) -> #foundations::Property {
-            #foundations::Property::new::<Self, _>(
-                Fields::#enum_ident as u8,
-                #ident,
-            )
-        }
-    }
-}
-
-/// Create a style chain access method for a field.
-fn create_style_chain_access(
-    field: &Field,
-    borrowed: bool,
-    inherent: TokenStream,
-) -> TokenStream {
-    let Field { ty, default, enum_ident, const_ident, .. } = field;
-
-    let getter = match (field.fold, borrowed) {
-        (false, false) => quote! { get },
-        (false, true) => quote! { get_ref },
-        (true, _) => quote! { get_folded },
-    };
-
-    let default = if borrowed {
-        quote! { || &#const_ident }
-    } else {
-        match default {
-            Some(default) => quote! { || #default },
-            None => quote! { ::std::default::Default::default },
-        }
-    };
-
-    quote! {
-        styles.#getter::<#ty>(
-            <Self as #foundations::NativeElement>::elem(),
-            Fields::#enum_ident as u8,
-            #inherent,
-            #default,
-        )
-    }
-}
-
 /// Creates the element's `NativeElement` implementation.
 fn create_native_elem_impl(element: &Elem) -> TokenStream {
     let Elem { name, ident, title, scope, keywords, docs, .. } = element;
 
-    let local_name = if element.can("LocalName") {
-        quote! { Some(<#foundations::Packed<#ident> as ::typst_library::text::LocalName>::local_name) }
-    } else {
-        quote! { None }
-    };
+    let fields = element.fields.iter().filter(|field| !field.internal).map(|field| {
+        let i = field.i;
+        if field.external {
+            quote! { #foundations::ExternalFieldData::<#ident, #i>::vtable() }
+        } else if field.variadic {
+            quote! { #foundations::RequiredFieldData::<#ident, #i>::vtable_variadic() }
+        } else if field.required {
+            quote! { #foundations::RequiredFieldData::<#ident, #i>::vtable() }
+        } else if field.synthesized {
+            quote! { #foundations::SynthesizedFieldData::<#ident, #i>::vtable() }
+        } else if field.ghost {
+            quote! { #foundations::SettablePropertyData::<#ident, #i>::vtable() }
+        } else {
+            quote! { #foundations::SettableFieldData::<#ident, #i>::vtable() }
+        }
+    });
 
-    let scope = if *scope {
-        quote! { <#ident as #foundations::NativeScope>::scope() }
-    } else {
-        quote! { #foundations::Scope::new() }
-    };
-
-    let params = element.doc_fields().map(create_param_info);
-
-    let data = quote! {
-        #foundations::NativeElementData {
-            name: #name,
-            title: #title,
-            docs: #docs,
-            keywords: &[#(#keywords),*],
-            construct: <#ident as #foundations::Construct>::construct,
-            set: <#ident as #foundations::Set>::set,
-            vtable:  <#ident as #foundations::Capable>::vtable,
-            field_id: |name| name.parse().ok().map(|id: Fields| id as u8),
-            field_name: |id| id.try_into().ok().map(Fields::to_str),
-            field_from_styles: <#ident as #foundations::Fields>::field_from_styles,
-            local_name: #local_name,
-            scope: ::std::sync::LazyLock::new(|| #scope),
-            params: ::std::sync::LazyLock::new(|| ::std::vec![#(#params),*])
+    let field_arms = element
+        .fields
+        .iter()
+        .filter(|field| !field.internal && !field.external)
+        .map(|field| {
+            let Field { name, i, .. } = field;
+            quote! { #name => Some(#i) }
+        });
+    let field_id = quote! {
+        |name| match name {
+            #(#field_arms,)*
+            _ => None,
         }
     };
 
+    let capable_func = create_capable_func(element);
+
+    let with_keywords =
+        (!keywords.is_empty()).then(|| quote! { .with_keywords(&[#(#keywords),*]) });
+    let with_repr = element.can("Repr").then(|| quote! { .with_repr() });
+    let with_partial_eq = element.can("PartialEq").then(|| quote! { .with_partial_eq() });
+    let with_local_name = element.can("LocalName").then(|| quote! { .with_local_name() });
+    let with_scope = scope.then(|| quote! { .with_scope() });
+
     quote! {
-        impl #foundations::NativeElement for #ident {
-            fn data() -> &'static #foundations::NativeElementData {
-                static DATA: #foundations::NativeElementData = #data;
-                &DATA
+        unsafe impl #foundations::NativeElement for #ident {
+            const ELEM: #foundations::Element = #foundations::Element::from_vtable({
+                static STORE: #foundations::LazyElementStore
+                    = #foundations::LazyElementStore::new();
+                static VTABLE: #foundations::ContentVtable =
+                    #foundations::ContentVtable::new::<#ident>(
+                        #name,
+                        #title,
+                        #docs,
+                        &[#(#fields),*],
+                        #field_id,
+                        #capable_func,
+                        || &STORE,
+                    ) #with_keywords
+                    #with_repr
+                    #with_partial_eq
+                    #with_local_name
+                    #with_scope
+                    .erase();
+                &VTABLE
+            });
+        }
+    }
+}
+
+/// Creates the appropriate trait implementation for a field.
+fn create_field_impl(element: &Elem, field: &Field) -> TokenStream {
+    let elem_ident = &element.ident;
+    let Field { i, ty, ident, default, positional, name, docs, .. } = field;
+
+    let default = match default {
+        Some(default) => quote! { || #default },
+        None => quote! { std::default::Default::default },
+    };
+
+    if field.external {
+        quote! {
+            impl #foundations::ExternalField<#i> for #elem_ident {
+                type Type = #ty;
+                const FIELD: #foundations::ExternalFieldData<Self, #i> =
+                    #foundations::ExternalFieldData::<Self, #i>::new(
+                        #name,
+                        #docs,
+                        #default,
+                    );
             }
         }
-    }
-}
-
-/// Creates a parameter info for a field.
-fn create_param_info(field: &Field) -> TokenStream {
-    let Field {
-        name,
-        docs,
-        positional,
-        variadic,
-        required,
-        default,
-        ty,
-        ..
-    } = field;
-
-    let named = !positional;
-    let settable = !field.required;
-
-    let default = if settable {
-        let default = default
-            .clone()
-            .unwrap_or_else(|| parse_quote! { ::std::default::Default::default() });
+    } else if field.required {
         quote! {
-            Some(|| <#ty as #foundations::IntoValue>::into_value(#default))
+            impl #foundations::RequiredField<#i> for #elem_ident {
+                type Type = #ty;
+                const FIELD: #foundations::RequiredFieldData<Self, #i> =
+                    #foundations::RequiredFieldData::<Self, #i>::new(
+                        #name,
+                        #docs,
+                        |elem| &elem.#ident,
+                    );
+            }
+        }
+    } else if field.synthesized {
+        quote! {
+            impl #foundations::SynthesizedField<#i> for #elem_ident {
+                type Type = #ty;
+                const FIELD: #foundations::SynthesizedFieldData<Self, #i> =
+                    #foundations::SynthesizedFieldData::<Self, #i>::new(
+                        #name,
+                        #docs,
+                        |elem| &elem.#ident,
+                    );
+            }
         }
     } else {
-        quote! { None }
-    };
+        let slot = quote! {
+            || {
+                static LOCK: ::std::sync::OnceLock<#ty> = ::std::sync::OnceLock::new();
+                &LOCK
+            }
+        };
 
-    let ty = if *variadic {
-        quote! { <#ty as #foundations::Container>::Inner }
-    } else {
-        quote! { #ty }
-    };
+        let with_fold = field.fold.then(|| quote! { .with_fold() });
+        let refable = (!field.fold).then(|| {
+            quote! {
+                impl #foundations::RefableProperty<#i> for #elem_ident {}
+            }
+        });
 
-    quote! {
-        #foundations::ParamInfo {
-            name: #name,
-            docs: #docs,
-            input: <#ty as #foundations::Reflect>::input(),
-            default: #default,
-            positional: #positional,
-            named: #named,
-            variadic: #variadic,
-            required: #required,
-            settable: #settable,
-        }
-    }
-}
-
-/// Creates the element's `PartialEq` implementation.
-fn create_partial_eq_impl(element: &Elem) -> TokenStream {
-    let ident = &element.ident;
-    let empty = element.eq_fields().next().is_none().then(|| quote! { true });
-    let fields = element.eq_fields().map(|field| &field.ident);
-
-    quote! {
-        impl PartialEq for #ident {
-            fn eq(&self, other: &Self) -> bool {
-                #empty
-                #(self.#fields == other.#fields)&&*
+        if field.ghost {
+            quote! {
+                impl #foundations::SettableProperty<#i> for #elem_ident {
+                    type Type = #ty;
+                    const FIELD: #foundations::SettablePropertyData<Self, #i> =
+                        #foundations::SettablePropertyData::<Self, #i>::new(
+                            #name,
+                            #docs,
+                            #positional,
+                            #default,
+                            #slot,
+                        ) #with_fold;
+                }
+                #refable
+            }
+        } else {
+            quote! {
+                impl #foundations::SettableField<#i> for #elem_ident {
+                    type Type = #ty;
+                    const FIELD: #foundations::SettableFieldData<Self, #i> =
+                        #foundations::SettableFieldData::<Self, #i>::new(
+                            #name,
+                            #docs,
+                            #positional,
+                            |elem| &elem.#ident,
+                            |elem| &mut elem.#ident,
+                            #default,
+                            #slot,
+                        ) #with_fold;
+                }
+                #refable
             }
         }
     }
@@ -758,10 +559,12 @@ fn create_construct_impl(element: &Elem) -> TokenStream {
 
     let fields = element.struct_fields().map(|field| {
         let ident = &field.ident;
-        if field.synthesized {
+        if field.required {
+            quote! { #ident }
+        } else if field.synthesized {
             quote! { #ident: None }
         } else {
-            quote! { #ident }
+            quote! { #ident: #foundations::Settable::from(#ident) }
         }
     });
 
@@ -782,12 +585,12 @@ fn create_construct_impl(element: &Elem) -> TokenStream {
 fn create_set_impl(element: &Elem) -> TokenStream {
     let ident = &element.ident;
     let handlers = element.set_fields().map(|field| {
-        let set_ident = &field.set_ident;
+        let field_ident = &field.ident;
         let (prefix, value) = create_field_parser(field);
         quote! {
             #prefix
             if let Some(value) = #value {
-                styles.set(Self::#set_ident(value));
+                styles.set(Self::#field_ident, value);
             }
         }
     });
@@ -827,7 +630,7 @@ fn create_field_parser(field: &Field) -> (TokenStream, TokenStream) {
 }
 
 /// Creates the element's casting vtable.
-fn create_capable_impl(element: &Elem) -> TokenStream {
+fn create_capable_func(element: &Elem) -> TokenStream {
     // Forbidden capabilities (i.e capabilities that are not object safe).
     const FORBIDDEN: &[&str] =
         &["Debug", "PartialEq", "Hash", "Construct", "Set", "Repr", "LocalName"];
@@ -851,202 +654,10 @@ fn create_capable_impl(element: &Elem) -> TokenStream {
     });
 
     quote! {
-        unsafe impl #foundations::Capable for #ident {
-            fn vtable(capability: ::std::any::TypeId) -> ::std::option::Option<::std::ptr::NonNull<()>> {
-                let dangling = ::std::ptr::NonNull::<#foundations::Packed<#ident>>::dangling().as_ptr();
-                #(#checks)*
-                None
-            }
-        }
-    }
-}
-
-/// Creates the element's `Fields` implementation.
-fn create_fields_impl(element: &Elem) -> TokenStream {
-    let into_value = quote! { #foundations::IntoValue::into_value };
-    let visible_non_ghost = || element.visible_fields().filter(|field| !field.ghost);
-
-    // Fields that can be checked using the `has` method.
-    let has_arms = visible_non_ghost().map(|field| {
-        let Field { enum_ident, ident, .. } = field;
-
-        let expr = if field.required {
-            quote! { true }
-        } else {
-            quote! { self.#ident.is_some() }
-        };
-
-        quote! { Fields::#enum_ident => #expr }
-    });
-
-    // Fields that can be accessed using the `field` method.
-    let field_arms = visible_non_ghost().map(|field| {
-        let Field { enum_ident, ident, .. } = field;
-
-        let expr = if field.required {
-            quote! { Ok(#into_value(self.#ident.clone())) }
-        } else {
-            quote! { self.#ident.clone().map(#into_value).ok_or(#foundations::FieldAccessError::Unset) }
-        };
-
-        quote! { Fields::#enum_ident => #expr }
-    });
-
-    // Fields that can be accessed using the `field_with_styles` method.
-    let field_with_styles_arms = element.visible_fields().map(|field| {
-        let Field { enum_ident, ident, .. } = field;
-
-        let expr = if field.required {
-            quote! { Ok(#into_value(self.#ident.clone())) }
-        } else if field.synthesized {
-            quote! { self.#ident.clone().map(#into_value).ok_or(#foundations::FieldAccessError::Unset) }
-        } else {
-            let value = create_style_chain_access(
-                field,
-                false,
-                if field.ghost { quote!(None) } else { quote!(self.#ident.as_ref()) },
-            );
-
-            quote! { Ok(#into_value(#value)) }
-        };
-
-        quote! { Fields::#enum_ident => #expr }
-    });
-
-    // Fields that can be accessed using the `field_from_styles` method.
-    let field_from_styles_arms = element.visible_fields().map(|field| {
-        let Field { enum_ident, .. } = field;
-
-        let expr = if field.required || field.synthesized {
-            quote! { Err(#foundations::FieldAccessError::Unknown) }
-        } else {
-            let value = create_style_chain_access(field, false, quote!(None));
-            quote! { Ok(#into_value(#value)) }
-        };
-
-        quote! { Fields::#enum_ident => #expr }
-    });
-
-    // Sets fields from the style chain.
-    let materializes = visible_non_ghost()
-        .filter(|field| !field.required && !field.synthesized)
-        .map(|field| {
-            let Field { ident, .. } = field;
-            let value = create_style_chain_access(
-                field,
-                false,
-                if field.ghost { quote!(None) } else { quote!(self.#ident.as_ref()) },
-            );
-
-            if field.fold {
-                quote! { self.#ident = Some(#value); }
-            } else {
-                quote! {
-                    if self.#ident.is_none() {
-                        self.#ident = Some(#value);
-                    }
-                }
-            }
-        });
-
-    // Creation of the `fields` dictionary for inherent fields.
-    let field_inserts = visible_non_ghost().map(|field| {
-        let Field { ident, name, .. } = field;
-        let string = quote! { #name.into() };
-
-        if field.required {
-            quote! {
-                fields.insert(#string, #into_value(self.#ident.clone()));
-            }
-        } else {
-            quote! {
-                if let Some(value) = &self.#ident {
-                    fields.insert(#string, #into_value(value.clone()));
-                }
-            }
-        }
-    });
-
-    let Elem { ident, .. } = element;
-
-    let result = quote! {
-        Result<#foundations::Value, #foundations::FieldAccessError>
-    };
-
-    quote! {
-        impl #foundations::Fields for #ident {
-            type Enum = Fields;
-
-            fn has(&self, id: u8) -> bool {
-                let Ok(id) = Fields::try_from(id) else {
-                    return false;
-                };
-
-                match id {
-                    #(#has_arms,)*
-                    _ => false,
-                }
-            }
-
-            fn field(&self, id: u8) -> #result {
-                let id = Fields::try_from(id)?;
-                match id {
-                    #(#field_arms,)*
-                    // This arm might be reached if someone tries to access an
-                    // internal field.
-                    _ => Err(#foundations::FieldAccessError::Unknown),
-                }
-            }
-
-            fn field_with_styles(&self, id: u8, styles: #foundations::StyleChain) -> #result {
-                let id = Fields::try_from(id)?;
-                match id {
-                    #(#field_with_styles_arms,)*
-                    // This arm might be reached if someone tries to access an
-                    // internal field.
-                    _ => Err(#foundations::FieldAccessError::Unknown),
-                }
-            }
-
-            fn field_from_styles(id: u8, styles: #foundations::StyleChain) -> #result {
-                let id = Fields::try_from(id)?;
-                match id {
-                    #(#field_from_styles_arms,)*
-                    // This arm might be reached if someone tries to access an
-                    // internal field.
-                    _ => Err(#foundations::FieldAccessError::Unknown),
-                }
-            }
-
-            fn materialize(&mut self, styles: #foundations::StyleChain) {
-               #(#materializes)*
-            }
-
-            fn fields(&self) -> #foundations::Dict {
-                let mut fields = #foundations::Dict::new();
-                #(#field_inserts)*
-                fields
-            }
-        }
-    }
-}
-
-/// Creates the element's `Repr` implementation.
-fn create_repr_impl(element: &Elem) -> TokenStream {
-    let ident = &element.ident;
-    let repr_format = format!("{}{{}}", element.name);
-    quote! {
-        impl #foundations::Repr for #ident {
-            fn repr(&self) -> ::ecow::EcoString {
-                let fields = #foundations::Fields::fields(self)
-                    .into_iter()
-                    .map(|(name, value)| ::ecow::eco_format!("{}: {}", name, value.repr()))
-                    .collect::<Vec<_>>();
-                ::ecow::eco_format!(
-                    #repr_format,
-                    #foundations::repr::pretty_array_like(&fields, false),
-                )
-            }
+        |capability| {
+            let dangling = ::std::ptr::NonNull::<#foundations::Packed<#ident>>::dangling().as_ptr();
+            #(#checks)*
+            None
         }
     }
 }
@@ -1062,15 +673,3 @@ fn create_mathy_impl(element: &Elem) -> TokenStream {
     let ident = &element.ident;
     quote! { impl ::typst_library::math::Mathy for #foundations::Packed<#ident> {} }
 }
-
-/// Creates the element's `IntoValue` implementation.
-fn create_into_value_impl(element: &Elem) -> TokenStream {
-    let Elem { ident, .. } = element;
-    quote! {
-        impl #foundations::IntoValue for #ident {
-            fn into_value(self) -> #foundations::Value {
-                #foundations::Value::Content(#foundations::Content::new(self))
-            }
-        }
-    }
-}
diff --git a/crates/typst-pdf/src/convert.rs b/crates/typst-pdf/src/convert.rs
index 645d56f11..9e2aa87b7 100644
--- a/crates/typst-pdf/src/convert.rs
+++ b/crates/typst-pdf/src/convert.rs
@@ -597,7 +597,7 @@ fn collect_named_destinations(
         let mut seen = HashSet::new();
         document
             .introspector
-            .query(&HeadingElem::elem().select())
+            .query(&HeadingElem::ELEM.select())
             .iter()
             .filter_map(|elem| elem.location().zip(elem.label()))
             .filter(|&(_, label)| seen.insert(label))
diff --git a/crates/typst-pdf/src/embed.rs b/crates/typst-pdf/src/embed.rs
index 36330c445..c62178cf2 100644
--- a/crates/typst-pdf/src/embed.rs
+++ b/crates/typst-pdf/src/embed.rs
@@ -11,20 +11,24 @@ pub(crate) fn embed_files(
     typst_doc: &PagedDocument,
     document: &mut Document,
 ) -> SourceResult<()> {
-    let elements = typst_doc.introspector.query(&EmbedElem::elem().select());
+    let elements = typst_doc.introspector.query(&EmbedElem::ELEM.select());
 
     for elem in &elements {
         let embed = elem.to_packed::<EmbedElem>().unwrap();
         let span = embed.span();
         let derived_path = &embed.path.derived;
         let path = derived_path.to_string();
-        let mime_type =
-            embed.mime_type(StyleChain::default()).clone().map(|s| s.to_string());
-        let description = embed
-            .description(StyleChain::default())
-            .clone()
+        let mime_type = embed
+            .mime_type
+            .get_ref(StyleChain::default())
+            .as_ref()
             .map(|s| s.to_string());
-        let association_kind = match embed.relationship(StyleChain::default()) {
+        let description = embed
+            .description
+            .get_ref(StyleChain::default())
+            .as_ref()
+            .map(|s| s.to_string());
+        let association_kind = match embed.relationship.get(StyleChain::default()) {
             None => AssociationKind::Unspecified,
             Some(e) => match e {
                 EmbeddedFileRelationship::Source => AssociationKind::Source,
diff --git a/crates/typst-pdf/src/outline.rs b/crates/typst-pdf/src/outline.rs
index e6324309f..f73822c4b 100644
--- a/crates/typst-pdf/src/outline.rs
+++ b/crates/typst-pdf/src/outline.rs
@@ -18,7 +18,7 @@ pub(crate) fn build_outline(gc: &GlobalContext) -> Outline {
     // Therefore, its next descendant must be added at its level, which is
     // enforced in the manner shown below.
     let mut last_skipped_level = None;
-    let elements = &gc.document.introspector.query(&HeadingElem::elem().select());
+    let elements = &gc.document.introspector.query(&HeadingElem::ELEM.select());
 
     for elem in elements.iter() {
         if let Some(page_ranges) = &gc.options.page_ranges {
@@ -115,8 +115,9 @@ impl<'a> HeadingNode<'a> {
             level: element.resolve_level(StyleChain::default()),
             // 'bookmarked' set to 'auto' falls back to the value of 'outlined'.
             bookmarked: element
-                .bookmarked(StyleChain::default())
-                .unwrap_or_else(|| element.outlined(StyleChain::default())),
+                .bookmarked
+                .get(StyleChain::default())
+                .unwrap_or_else(|| element.outlined.get(StyleChain::default())),
             element,
             children: Vec::new(),
         }
diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index 526f4631a..fcfb40667 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -590,7 +590,7 @@ fn visit_styled<'a>(
     let mut pagebreak = false;
     for style in local.iter() {
         let Some(elem) = style.element() else { continue };
-        if elem == DocumentElem::elem() {
+        if elem == DocumentElem::ELEM {
             if let Some(info) = s.kind.as_document_mut() {
                 info.populate(&local)
             } else {
@@ -599,7 +599,7 @@ fn visit_styled<'a>(
                     "document set rules are not allowed inside of containers"
                 );
             }
-        } else if elem == PageElem::elem() {
+        } else if elem == PageElem::ELEM {
             if !matches!(s.kind, RealizationKind::LayoutDocument(_)) {
                 bail!(
                     style.span(),
@@ -633,7 +633,7 @@ fn visit_styled<'a>(
     if pagebreak {
         let relevant = local
             .as_slice()
-            .trim_end_matches(|style| style.element() != Some(PageElem::elem()));
+            .trim_end_matches(|style| style.element() != Some(PageElem::ELEM));
         visit(s, PagebreakElem::shared_weak(), outer.chain(relevant))?;
     }
 
@@ -722,7 +722,9 @@ fn visit_filter_rules<'a>(
         s.saw_parbreak = true;
         return Ok(true);
     } else if !s.may_attach
-        && content.to_packed::<VElem>().is_some_and(|elem| elem.attach(styles))
+        && content
+            .to_packed::<VElem>()
+            .is_some_and(|elem| elem.attach.get(styles))
     {
         // Attach spacing collapses if not immediately following a paragraph.
         return Ok(true);
@@ -867,11 +869,11 @@ static TEXTUAL: GroupingRule = GroupingRule {
         // Note that `SymbolElem` converts into `TextElem` before textual show
         // rules run, and we apply textual rules to elements manually during
         // math realization, so we don't check for it here.
-        elem == TextElem::elem()
-            || elem == LinebreakElem::elem()
-            || elem == SmartQuoteElem::elem()
+        elem == TextElem::ELEM
+            || elem == LinebreakElem::ELEM
+            || elem == SmartQuoteElem::ELEM
     },
-    inner: |content| content.elem() == SpaceElem::elem(),
+    inner: |content| content.elem() == SpaceElem::ELEM,
     // Any kind of style interrupts this kind of grouping since regex show
     // rules cannot match over style changes anyway.
     interrupt: |_| true,
@@ -884,19 +886,19 @@ static PAR: GroupingRule = GroupingRule {
     tags: true,
     trigger: |content, kind| {
         let elem = content.elem();
-        elem == TextElem::elem()
-            || elem == HElem::elem()
-            || elem == LinebreakElem::elem()
-            || elem == SmartQuoteElem::elem()
-            || elem == InlineElem::elem()
-            || elem == BoxElem::elem()
+        elem == TextElem::ELEM
+            || elem == HElem::ELEM
+            || elem == LinebreakElem::ELEM
+            || elem == SmartQuoteElem::ELEM
+            || elem == InlineElem::ELEM
+            || elem == BoxElem::ELEM
             || (kind.is_html()
                 && content
                     .to_packed::<HtmlElem>()
                     .is_some_and(|elem| tag::is_inline_by_default(elem.tag)))
     },
-    inner: |content| content.elem() == SpaceElem::elem(),
-    interrupt: |elem| elem == ParElem::elem() || elem == AlignElem::elem(),
+    inner: |content| content.elem() == SpaceElem::ELEM,
+    interrupt: |elem| elem == ParElem::ELEM || elem == AlignElem::ELEM,
     finish: finish_par,
 };
 
@@ -904,10 +906,10 @@ static PAR: GroupingRule = GroupingRule {
 static CITES: GroupingRule = GroupingRule {
     priority: 2,
     tags: false,
-    trigger: |content, _| content.elem() == CiteElem::elem(),
-    inner: |content| content.elem() == SpaceElem::elem(),
+    trigger: |content, _| content.elem() == CiteElem::ELEM,
+    inner: |content| content.elem() == SpaceElem::ELEM,
     interrupt: |elem| {
-        elem == CiteGroup::elem() || elem == ParElem::elem() || elem == AlignElem::elem()
+        elem == CiteGroup::ELEM || elem == ParElem::ELEM || elem == AlignElem::ELEM
     },
     finish: finish_cites,
 };
@@ -926,12 +928,12 @@ const fn list_like_grouping<T: ListLike>() -> GroupingRule {
     GroupingRule {
         priority: 2,
         tags: false,
-        trigger: |content, _| content.elem() == T::Item::elem(),
+        trigger: |content, _| content.elem() == T::Item::ELEM,
         inner: |content| {
             let elem = content.elem();
-            elem == SpaceElem::elem() || elem == ParbreakElem::elem()
+            elem == SpaceElem::ELEM || elem == ParbreakElem::ELEM
         },
-        interrupt: |elem| elem == T::elem() || elem == AlignElem::elem(),
+        interrupt: |elem| elem == T::ELEM || elem == AlignElem::ELEM,
         finish: finish_list_like::<T>,
     }
 }
@@ -1118,7 +1120,7 @@ fn find_regex_match_in_elems<'a>(
             buf.push('\n');
             SpaceState::Destructive
         } else if let Some(elem) = content.to_packed::<SmartQuoteElem>() {
-            buf.push(if elem.double(styles) { '"' } else { '\'' });
+            buf.push(if elem.double.get(styles) { '"' } else { '\'' });
             SpaceState::Supportive
         } else if let Some(elem) = content.to_packed::<TextElem>() {
             buf.push_str(&elem.text);
@@ -1310,7 +1312,7 @@ fn collapse_spaces(buf: &mut Vec<Pair>, start: usize) {
         } else if content.is::<LinebreakElem>() {
             destruct_space(buf, &mut k, &mut state);
         } else if let Some(elem) = content.to_packed::<HElem>() {
-            if elem.amount.is_fractional() || elem.weak(styles) {
+            if elem.amount.is_fractional() || elem.weak.get(styles) {
                 destruct_space(buf, &mut k, &mut state);
             }
         } else {
diff --git a/crates/typst-utils/src/hash.rs b/crates/typst-utils/src/hash.rs
index 9687da20b..eaf8a6721 100644
--- a/crates/typst-utils/src/hash.rs
+++ b/crates/typst-utils/src/hash.rs
@@ -30,9 +30,10 @@ use siphasher::sip128::{Hasher128, SipHasher13};
 /// # Usage
 /// If the value is expected to be cloned, it is best used inside of an `Arc`
 /// or `Rc` to best re-use the hash once it has been computed.
+#[derive(Clone)]
 pub struct LazyHash<T: ?Sized> {
     /// The hash for the value.
-    hash: AtomicU128,
+    hash: HashLock,
     /// The underlying value.
     value: T,
 }
@@ -48,16 +49,7 @@ impl<T> LazyHash<T> {
     /// Wraps an item without pre-computed hash.
     #[inline]
     pub fn new(value: T) -> Self {
-        Self { hash: AtomicU128::new(0), value }
-    }
-
-    /// Wrap an item with a pre-computed hash.
-    ///
-    /// **Important:** The hash must be correct for the value. This cannot be
-    /// enforced at compile time, so use with caution.
-    #[inline]
-    pub fn reuse<U: ?Sized>(value: T, existing: &LazyHash<U>) -> Self {
-        LazyHash { hash: AtomicU128::new(existing.load_hash()), value }
+        Self { hash: HashLock::new(), value }
     }
 
     /// Returns the wrapped value.
@@ -67,33 +59,11 @@ impl<T> LazyHash<T> {
     }
 }
 
-impl<T: ?Sized> LazyHash<T> {
-    /// Get the hash, returns zero if not computed yet.
-    #[inline]
-    fn load_hash(&self) -> u128 {
-        // We only need atomicity and no synchronization of other operations, so
-        // `Relaxed` is fine.
-        self.hash.load(Ordering::Relaxed)
-    }
-}
-
 impl<T: Hash + ?Sized + 'static> LazyHash<T> {
     /// Get the hash or compute it if not set yet.
     #[inline]
     fn load_or_compute_hash(&self) -> u128 {
-        let mut hash = self.load_hash();
-        if hash == 0 {
-            hash = hash_item(&self.value);
-            self.hash.store(hash, Ordering::Relaxed);
-        }
-        hash
-    }
-
-    /// Reset the hash to zero.
-    #[inline]
-    fn reset_hash(&mut self) {
-        // Because we have a mutable reference, we can skip the atomic.
-        *self.hash.get_mut() = 0;
+        self.hash.get_or_insert_with(|| hash_item(&self.value))
     }
 }
 
@@ -140,23 +110,14 @@ impl<T: ?Sized> Deref for LazyHash<T> {
     }
 }
 
-impl<T: Hash + ?Sized + 'static> DerefMut for LazyHash<T> {
+impl<T: ?Sized + 'static> DerefMut for LazyHash<T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
-        self.reset_hash();
+        self.hash.reset();
         &mut self.value
     }
 }
 
-impl<T: Hash + Clone + 'static> Clone for LazyHash<T> {
-    fn clone(&self) -> Self {
-        Self {
-            hash: AtomicU128::new(self.load_hash()),
-            value: self.value.clone(),
-        }
-    }
-}
-
 impl<T: Debug> Debug for LazyHash<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         self.value.fmt(f)
@@ -233,3 +194,51 @@ impl<T: Debug> Debug for ManuallyHash<T> {
         self.value.fmt(f)
     }
 }
+
+/// Storage for lazy hash computation.
+pub struct HashLock(AtomicU128);
+
+impl HashLock {
+    /// Create a new unset hash cell.
+    pub const fn new() -> Self {
+        Self(AtomicU128::new(0))
+    }
+
+    /// Get the hash or compute it if not set yet.
+    #[inline]
+    pub fn get_or_insert_with(&self, f: impl FnOnce() -> u128) -> u128 {
+        let mut hash = self.get();
+        if hash == 0 {
+            hash = f();
+            self.0.store(hash, Ordering::Relaxed);
+        }
+        hash
+    }
+
+    /// Reset the hash to unset.
+    #[inline]
+    pub fn reset(&mut self) {
+        // Because we have a mutable reference, we can skip the atomic.
+        *self.0.get_mut() = 0;
+    }
+
+    /// Get the hash, returns zero if not computed yet.
+    #[inline]
+    fn get(&self) -> u128 {
+        // We only need atomicity and no synchronization of other operations, so
+        // `Relaxed` is fine.
+        self.0.load(Ordering::Relaxed)
+    }
+}
+
+impl Default for HashLock {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Clone for HashLock {
+    fn clone(&self) -> Self {
+        Self(AtomicU128::new(self.get()))
+    }
+}
diff --git a/crates/typst-utils/src/lib.rs b/crates/typst-utils/src/lib.rs
index 8d0cdc15a..6a833b17f 100644
--- a/crates/typst-utils/src/lib.rs
+++ b/crates/typst-utils/src/lib.rs
@@ -15,7 +15,7 @@ mod scalar;
 pub use self::bitset::{BitSet, SmallBitSet};
 pub use self::deferred::Deferred;
 pub use self::duration::format_duration;
-pub use self::hash::{LazyHash, ManuallyHash};
+pub use self::hash::{HashLock, LazyHash, ManuallyHash};
 pub use self::pico::{PicoStr, ResolvedPicoStr};
 pub use self::round::{round_int_with_precision, round_with_precision};
 pub use self::scalar::Scalar;
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index a6bb4fe38..eee7966a7 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -98,7 +98,7 @@ fn compile_impl<D: Document>(
 
     let library = world.library();
     let base = StyleChain::new(&library.styles);
-    let target = TargetElem::set_target(D::TARGET).wrap();
+    let target = TargetElem::target.set(D::TARGET).wrap();
     let styles = base.chain(&target);
     let empty_introspector = Introspector::default();
 
diff --git a/docs/src/lib.rs b/docs/src/lib.rs
index dc6b62c72..ddc956e60 100644
--- a/docs/src/lib.rs
+++ b/docs/src/lib.rs
@@ -63,12 +63,10 @@ static LIBRARY: LazyLock<LazyHash<Library>> = LazyLock::new(|| {
     scope.reset_category();
 
     // Adjust the default look.
+    lib.styles.set(PageElem::width, Smart::Custom(Abs::pt(240.0).into()));
+    lib.styles.set(PageElem::height, Smart::Auto);
     lib.styles
-        .set(PageElem::set_width(Smart::Custom(Abs::pt(240.0).into())));
-    lib.styles.set(PageElem::set_height(Smart::Auto));
-    lib.styles.set(PageElem::set_margin(Margin::splat(Some(Smart::Custom(
-        Abs::pt(15.0).into(),
-    )))));
+        .set(PageElem::margin, Margin::splat(Some(Smart::Custom(Abs::pt(15.0).into()))));
 
     LazyHash::new(lib)
 });
diff --git a/tests/src/world.rs b/tests/src/world.rs
index 6fa1cf60f..9b16d6126 100644
--- a/tests/src/world.rs
+++ b/tests/src/world.rs
@@ -214,13 +214,11 @@ fn library() -> Library {
         .define("forest", Color::from_u8(0x43, 0xA1, 0x27, 0xFF));
 
     // Hook up default styles.
+    lib.styles.set(PageElem::width, Smart::Custom(Abs::pt(120.0).into()));
+    lib.styles.set(PageElem::height, Smart::Auto);
     lib.styles
-        .set(PageElem::set_width(Smart::Custom(Abs::pt(120.0).into())));
-    lib.styles.set(PageElem::set_height(Smart::Auto));
-    lib.styles.set(PageElem::set_margin(Margin::splat(Some(Smart::Custom(
-        Abs::pt(10.0).into(),
-    )))));
-    lib.styles.set(TextElem::set_size(TextSize(Abs::pt(10.0).into())));
+        .set(PageElem::margin, Margin::splat(Some(Smart::Custom(Abs::pt(10.0).into()))));
+    lib.styles.set(TextElem::size, TextSize(Abs::pt(10.0).into()));
 
     lib
 }

From e5e1dcd9c01341d2cd3473ac94a70223d5966086 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 9 Jul 2025 10:16:36 +0200
Subject: [PATCH 059/101] Target-specific native show rules (#6569)

---
 crates/typst-html/src/lib.rs                  |   2 +
 crates/typst-html/src/rules.rs                | 411 ++++++++
 crates/typst-layout/src/lib.rs                |  16 +-
 crates/typst-layout/src/rules.rs              | 890 ++++++++++++++++++
 .../src/foundations/content/element.rs        |   6 -
 .../typst-library/src/foundations/context.rs  |  17 +-
 .../typst-library/src/foundations/styles.rs   | 129 ++-
 .../typst-library/src/foundations/target.rs   |   2 +-
 .../src/introspection/counter.rs              |  40 +-
 .../src/introspection/metadata.rs             |  12 +-
 .../typst-library/src/introspection/state.rs  |  13 +-
 crates/typst-library/src/layout/align.rs      |  16 +-
 crates/typst-library/src/layout/columns.rs    |  16 +-
 crates/typst-library/src/layout/grid/mod.rs   |  44 +-
 crates/typst-library/src/layout/hide.rs       |  13 +-
 crates/typst-library/src/layout/layout.rs     |  42 +-
 crates/typst-library/src/layout/pad.rs        |  16 +-
 crates/typst-library/src/layout/repeat.rs     |  16 +-
 crates/typst-library/src/layout/stack.rs      |  16 +-
 crates/typst-library/src/layout/transform.rs  |  50 +-
 crates/typst-library/src/math/equation.rs     |  25 +-
 .../typst-library/src/model/bibliography.rs   |  92 +-
 crates/typst-library/src/model/cite.rs        |  10 +-
 crates/typst-library/src/model/emph.rs        |  25 +-
 crates/typst-library/src/model/enum.rs        |  63 +-
 crates/typst-library/src/model/figure.rs      | 140 +--
 crates/typst-library/src/model/footnote.rs    |  64 +-
 crates/typst-library/src/model/heading.rs     | 109 +--
 crates/typst-library/src/model/link.rs        |  41 +-
 crates/typst-library/src/model/list.rs        |  49 +-
 crates/typst-library/src/model/mod.rs         |  20 +-
 crates/typst-library/src/model/outline.rs     |  86 +-
 crates/typst-library/src/model/quote.rs       | 155 +--
 crates/typst-library/src/model/reference.rs   |  20 +-
 crates/typst-library/src/model/strong.rs      |  25 +-
 crates/typst-library/src/model/table.rs       | 133 +--
 crates/typst-library/src/model/terms.rs       | 104 +-
 crates/typst-library/src/pdf/embed.rs         |  21 +-
 crates/typst-library/src/routines.rs          | 237 +----
 crates/typst-library/src/text/deco.rs         | 123 +--
 crates/typst-library/src/text/raw.rs          |  59 +-
 crates/typst-library/src/text/shift.rs        |  83 +-
 crates/typst-library/src/text/smallcaps.rs    |  16 +-
 crates/typst-library/src/text/smartquote.rs   |  13 +-
 crates/typst-library/src/visualize/curve.rs   |  19 +-
 .../typst-library/src/visualize/image/mod.rs  |  20 +-
 crates/typst-library/src/visualize/line.rs    |  16 +-
 crates/typst-library/src/visualize/path.rs    |  20 +-
 crates/typst-library/src/visualize/polygon.rs |  18 +-
 crates/typst-library/src/visualize/shape.rs   |  56 +-
 crates/typst-realize/src/lib.rs               |  75 +-
 crates/typst/src/lib.rs                       |  37 +-
 52 files changed, 1778 insertions(+), 1963 deletions(-)
 create mode 100644 crates/typst-html/src/rules.rs
 create mode 100644 crates/typst-layout/src/rules.rs

diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index 60ffa78ee..19eb14464 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -1,8 +1,10 @@
 //! Typst's HTML exporter.
 
 mod encode;
+mod rules;
 
 pub use self::encode::html;
+pub use self::rules::register;
 
 use comemo::{Track, Tracked, TrackedMut};
 use typst_library::diag::{bail, warning, At, SourceResult};
diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
new file mode 100644
index 000000000..f361bfbb3
--- /dev/null
+++ b/crates/typst-html/src/rules.rs
@@ -0,0 +1,411 @@
+use std::num::NonZeroUsize;
+
+use ecow::{eco_format, EcoVec};
+use typst_library::diag::warning;
+use typst_library::foundations::{
+    Content, NativeElement, NativeRuleMap, ShowFn, StyleChain, Target,
+};
+use typst_library::html::{attr, tag, HtmlAttrs, HtmlElem, HtmlTag};
+use typst_library::introspection::{Counter, Locator};
+use typst_library::layout::resolve::{table_to_cellgrid, Cell, CellGrid, Entry};
+use typst_library::layout::OuterVAlignment;
+use typst_library::model::{
+    Attribution, CiteElem, CiteGroup, Destination, EmphElem, EnumElem, FigureCaption,
+    FigureElem, HeadingElem, LinkElem, LinkTarget, ListElem, ParbreakElem, QuoteElem,
+    RefElem, StrongElem, TableCell, TableElem, TermsElem,
+};
+use typst_library::text::{
+    HighlightElem, LinebreakElem, OverlineElem, RawElem, RawLine, SpaceElem, StrikeElem,
+    SubElem, SuperElem, UnderlineElem,
+};
+
+/// Register show rules for the [HTML target](Target::Html).
+pub fn register(rules: &mut NativeRuleMap) {
+    use Target::Html;
+
+    // Model.
+    rules.register(Html, STRONG_RULE);
+    rules.register(Html, EMPH_RULE);
+    rules.register(Html, LIST_RULE);
+    rules.register(Html, ENUM_RULE);
+    rules.register(Html, TERMS_RULE);
+    rules.register(Html, LINK_RULE);
+    rules.register(Html, HEADING_RULE);
+    rules.register(Html, FIGURE_RULE);
+    rules.register(Html, FIGURE_CAPTION_RULE);
+    rules.register(Html, QUOTE_RULE);
+    rules.register(Html, REF_RULE);
+    rules.register(Html, CITE_GROUP_RULE);
+    rules.register(Html, TABLE_RULE);
+
+    // Text.
+    rules.register(Html, SUB_RULE);
+    rules.register(Html, SUPER_RULE);
+    rules.register(Html, UNDERLINE_RULE);
+    rules.register(Html, OVERLINE_RULE);
+    rules.register(Html, STRIKE_RULE);
+    rules.register(Html, HIGHLIGHT_RULE);
+    rules.register(Html, RAW_RULE);
+    rules.register(Html, RAW_LINE_RULE);
+}
+
+const STRONG_RULE: ShowFn<StrongElem> = |elem, _, _| {
+    Ok(HtmlElem::new(tag::strong)
+        .with_body(Some(elem.body.clone()))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const EMPH_RULE: ShowFn<EmphElem> = |elem, _, _| {
+    Ok(HtmlElem::new(tag::em)
+        .with_body(Some(elem.body.clone()))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const LIST_RULE: ShowFn<ListElem> = |elem, _, styles| {
+    Ok(HtmlElem::new(tag::ul)
+        .with_body(Some(Content::sequence(elem.children.iter().map(|item| {
+            // Text in wide lists shall always turn into paragraphs.
+            let mut body = item.body.clone();
+            if !elem.tight.get(styles) {
+                body += ParbreakElem::shared();
+            }
+            HtmlElem::new(tag::li)
+                .with_body(Some(body))
+                .pack()
+                .spanned(item.span())
+        }))))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const ENUM_RULE: ShowFn<EnumElem> = |elem, _, styles| {
+    let mut ol = HtmlElem::new(tag::ol);
+
+    if elem.reversed.get(styles) {
+        ol = ol.with_attr(attr::reversed, "reversed");
+    }
+
+    if let Some(n) = elem.start.get(styles).custom() {
+        ol = ol.with_attr(attr::start, eco_format!("{n}"));
+    }
+
+    let body = Content::sequence(elem.children.iter().map(|item| {
+        let mut li = HtmlElem::new(tag::li);
+        if let Some(nr) = item.number.get(styles) {
+            li = li.with_attr(attr::value, eco_format!("{nr}"));
+        }
+        // Text in wide enums shall always turn into paragraphs.
+        let mut body = item.body.clone();
+        if !elem.tight.get(styles) {
+            body += ParbreakElem::shared();
+        }
+        li.with_body(Some(body)).pack().spanned(item.span())
+    }));
+
+    Ok(ol.with_body(Some(body)).pack().spanned(elem.span()))
+};
+
+const TERMS_RULE: ShowFn<TermsElem> = |elem, _, styles| {
+    Ok(HtmlElem::new(tag::dl)
+        .with_body(Some(Content::sequence(elem.children.iter().flat_map(|item| {
+            // Text in wide term lists shall always turn into paragraphs.
+            let mut description = item.description.clone();
+            if !elem.tight.get(styles) {
+                description += ParbreakElem::shared();
+            }
+
+            [
+                HtmlElem::new(tag::dt)
+                    .with_body(Some(item.term.clone()))
+                    .pack()
+                    .spanned(item.term.span()),
+                HtmlElem::new(tag::dd)
+                    .with_body(Some(description))
+                    .pack()
+                    .spanned(item.description.span()),
+            ]
+        }))))
+        .pack())
+};
+
+const LINK_RULE: ShowFn<LinkElem> = |elem, engine, _| {
+    let body = elem.body.clone();
+    Ok(if let LinkTarget::Dest(Destination::Url(url)) = &elem.dest {
+        HtmlElem::new(tag::a)
+            .with_attr(attr::href, url.clone().into_inner())
+            .with_body(Some(body))
+            .pack()
+            .spanned(elem.span())
+    } else {
+        engine.sink.warn(warning!(
+            elem.span(),
+            "non-URL links are not yet supported by HTML export"
+        ));
+        body
+    })
+};
+
+const HEADING_RULE: ShowFn<HeadingElem> = |elem, engine, styles| {
+    let span = elem.span();
+
+    let mut realized = elem.body.clone();
+    if let Some(numbering) = elem.numbering.get_ref(styles).as_ref() {
+        let location = elem.location().unwrap();
+        let numbering = Counter::of(HeadingElem::ELEM)
+            .display_at_loc(engine, location, styles, numbering)?
+            .spanned(span);
+        realized = numbering + SpaceElem::shared().clone() + realized;
+    }
+
+    // HTML's h1 is closer to a title element. There should only be one.
+    // Meanwhile, a level 1 Typst heading is a section heading. For this
+    // reason, levels are offset by one: A Typst level 1 heading becomes
+    // a `<h2>`.
+    let level = elem.resolve_level(styles).get();
+    Ok(if level >= 6 {
+        engine.sink.warn(warning!(
+            span,
+            "heading of level {} was transformed to \
+             <div role=\"heading\" aria-level=\"{}\">, which is not \
+             supported by all assistive technology",
+            level, level + 1;
+            hint: "HTML only supports <h1> to <h6>, not <h{}>", level + 1;
+            hint: "you may want to restructure your document so that \
+                   it doesn't contain deep headings"
+        ));
+        HtmlElem::new(tag::div)
+            .with_body(Some(realized))
+            .with_attr(attr::role, "heading")
+            .with_attr(attr::aria_level, eco_format!("{}", level + 1))
+            .pack()
+            .spanned(span)
+    } else {
+        let t = [tag::h2, tag::h3, tag::h4, tag::h5, tag::h6][level - 1];
+        HtmlElem::new(t).with_body(Some(realized)).pack().spanned(span)
+    })
+};
+
+const FIGURE_RULE: ShowFn<FigureElem> = |elem, _, styles| {
+    let span = elem.span();
+    let mut realized = elem.body.clone();
+
+    // Build the caption, if any.
+    if let Some(caption) = elem.caption.get_cloned(styles) {
+        realized = match caption.position.get(styles) {
+            OuterVAlignment::Top => caption.pack() + realized,
+            OuterVAlignment::Bottom => realized + caption.pack(),
+        };
+    }
+
+    // Ensure that the body is considered a paragraph.
+    realized += ParbreakElem::shared().clone().spanned(span);
+
+    Ok(HtmlElem::new(tag::figure)
+        .with_body(Some(realized))
+        .pack()
+        .spanned(span))
+};
+
+const FIGURE_CAPTION_RULE: ShowFn<FigureCaption> = |elem, engine, styles| {
+    Ok(HtmlElem::new(tag::figcaption)
+        .with_body(Some(elem.realize(engine, styles)?))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const QUOTE_RULE: ShowFn<QuoteElem> = |elem, _, styles| {
+    let span = elem.span();
+    let block = elem.block.get(styles);
+
+    let mut realized = elem.body.clone();
+
+    if elem.quotes.get(styles).unwrap_or(!block) {
+        realized = QuoteElem::quoted(realized, styles);
+    }
+
+    let attribution = elem.attribution.get_ref(styles);
+
+    if block {
+        let mut blockquote = HtmlElem::new(tag::blockquote).with_body(Some(realized));
+        if let Some(Attribution::Content(attribution)) = attribution {
+            if let Some(link) = attribution.to_packed::<LinkElem>() {
+                if let LinkTarget::Dest(Destination::Url(url)) = &link.dest {
+                    blockquote =
+                        blockquote.with_attr(attr::cite, url.clone().into_inner());
+                }
+            }
+        }
+
+        realized = blockquote.pack().spanned(span);
+
+        if let Some(attribution) = attribution.as_ref() {
+            realized += attribution.realize(span);
+        }
+    } else if let Some(Attribution::Label(label)) = attribution {
+        realized += SpaceElem::shared().clone();
+        realized += CiteElem::new(*label).pack().spanned(span);
+    }
+
+    Ok(realized)
+};
+
+const REF_RULE: ShowFn<RefElem> = |elem, engine, styles| elem.realize(engine, styles);
+
+const CITE_GROUP_RULE: ShowFn<CiteGroup> = |elem, engine, _| elem.realize(engine);
+
+const TABLE_RULE: ShowFn<TableElem> = |elem, engine, styles| {
+    // The locator is not used by HTML export, so we can just fabricate one.
+    let locator = Locator::root();
+    Ok(show_cellgrid(table_to_cellgrid(elem, engine, locator, styles)?, styles))
+};
+
+fn show_cellgrid(grid: CellGrid, styles: StyleChain) -> Content {
+    let elem = |tag, body| HtmlElem::new(tag).with_body(Some(body)).pack();
+    let mut rows: Vec<_> = grid.entries.chunks(grid.non_gutter_column_count()).collect();
+
+    let tr = |tag, row: &[Entry]| {
+        let row = row
+            .iter()
+            .flat_map(|entry| entry.as_cell())
+            .map(|cell| show_cell(tag, cell, styles));
+        elem(tag::tr, Content::sequence(row))
+    };
+
+    // TODO(subfooters): similarly to headers, take consecutive footers from
+    // the end for 'tfoot'.
+    let footer = grid.footer.map(|ft| {
+        let rows = rows.drain(ft.start..);
+        elem(tag::tfoot, Content::sequence(rows.map(|row| tr(tag::td, row))))
+    });
+
+    // Store all consecutive headers at the start in 'thead'. All remaining
+    // headers are just 'th' rows across the table body.
+    let mut consecutive_header_end = 0;
+    let first_mid_table_header = grid
+        .headers
+        .iter()
+        .take_while(|hd| {
+            let is_consecutive = hd.range.start == consecutive_header_end;
+            consecutive_header_end = hd.range.end;
+            is_consecutive
+        })
+        .count();
+
+    let (y_offset, header) = if first_mid_table_header > 0 {
+        let removed_header_rows =
+            grid.headers.get(first_mid_table_header - 1).unwrap().range.end;
+        let rows = rows.drain(..removed_header_rows);
+
+        (
+            removed_header_rows,
+            Some(elem(tag::thead, Content::sequence(rows.map(|row| tr(tag::th, row))))),
+        )
+    } else {
+        (0, None)
+    };
+
+    // TODO: Consider improving accessibility properties of multi-level headers
+    // inside tables in the future, e.g. indicating which columns they are
+    // relative to and so on. See also:
+    // https://www.w3.org/WAI/tutorials/tables/multi-level/
+    let mut next_header = first_mid_table_header;
+    let mut body =
+        Content::sequence(rows.into_iter().enumerate().map(|(relative_y, row)| {
+            let y = relative_y + y_offset;
+            if let Some(current_header) =
+                grid.headers.get(next_header).filter(|h| h.range.contains(&y))
+            {
+                if y + 1 == current_header.range.end {
+                    next_header += 1;
+                }
+
+                tr(tag::th, row)
+            } else {
+                tr(tag::td, row)
+            }
+        }));
+
+    if header.is_some() || footer.is_some() {
+        body = elem(tag::tbody, body);
+    }
+
+    let content = header.into_iter().chain(core::iter::once(body)).chain(footer);
+    elem(tag::table, Content::sequence(content))
+}
+
+fn show_cell(tag: HtmlTag, cell: &Cell, styles: StyleChain) -> Content {
+    let cell = cell.body.clone();
+    let Some(cell) = cell.to_packed::<TableCell>() else { return cell };
+    let mut attrs = HtmlAttrs::default();
+    let span = |n: NonZeroUsize| (n != NonZeroUsize::MIN).then(|| n.to_string());
+    if let Some(colspan) = span(cell.colspan.get(styles)) {
+        attrs.push(attr::colspan, colspan);
+    }
+    if let Some(rowspan) = span(cell.rowspan.get(styles)) {
+        attrs.push(attr::rowspan, rowspan);
+    }
+    HtmlElem::new(tag)
+        .with_body(Some(cell.body.clone()))
+        .with_attrs(attrs)
+        .pack()
+        .spanned(cell.span())
+}
+
+const SUB_RULE: ShowFn<SubElem> = |elem, _, _| {
+    Ok(HtmlElem::new(tag::sub)
+        .with_body(Some(elem.body.clone()))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const SUPER_RULE: ShowFn<SuperElem> = |elem, _, _| {
+    Ok(HtmlElem::new(tag::sup)
+        .with_body(Some(elem.body.clone()))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const UNDERLINE_RULE: ShowFn<UnderlineElem> = |elem, _, _| {
+    // 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.
+    Ok(HtmlElem::new(tag::span)
+        .with_attr(attr::style, "text-decoration: underline")
+        .with_body(Some(elem.body.clone()))
+        .pack())
+};
+
+const OVERLINE_RULE: ShowFn<OverlineElem> = |elem, _, _| {
+    Ok(HtmlElem::new(tag::span)
+        .with_attr(attr::style, "text-decoration: overline")
+        .with_body(Some(elem.body.clone()))
+        .pack())
+};
+
+const STRIKE_RULE: ShowFn<StrikeElem> =
+    |elem, _, _| Ok(HtmlElem::new(tag::s).with_body(Some(elem.body.clone())).pack());
+
+const HIGHLIGHT_RULE: ShowFn<HighlightElem> =
+    |elem, _, _| Ok(HtmlElem::new(tag::mark).with_body(Some(elem.body.clone())).pack());
+
+const RAW_RULE: ShowFn<RawElem> = |elem, _, styles| {
+    let lines = elem.lines.as_deref().unwrap_or_default();
+
+    let mut seq = EcoVec::with_capacity((2 * lines.len()).saturating_sub(1));
+    for (i, line) in lines.iter().enumerate() {
+        if i != 0 {
+            seq.push(LinebreakElem::shared().clone());
+        }
+
+        seq.push(line.clone().pack());
+    }
+
+    Ok(HtmlElem::new(if elem.block.get(styles) { tag::pre } else { tag::code })
+        .with_body(Some(Content::sequence(seq)))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const RAW_LINE_RULE: ShowFn<RawLine> = |elem, _, _| Ok(elem.body.clone());
diff --git a/crates/typst-layout/src/lib.rs b/crates/typst-layout/src/lib.rs
index 443e90d61..361bab463 100644
--- a/crates/typst-layout/src/lib.rs
+++ b/crates/typst-layout/src/lib.rs
@@ -10,21 +10,11 @@ mod modifiers;
 mod pad;
 mod pages;
 mod repeat;
+mod rules;
 mod shapes;
 mod stack;
 mod transforms;
 
-pub use self::flow::{layout_columns, layout_fragment, layout_frame};
-pub use self::grid::{layout_grid, layout_table};
-pub use self::image::layout_image;
-pub use self::lists::{layout_enum, layout_list};
-pub use self::math::{layout_equation_block, layout_equation_inline};
-pub use self::pad::layout_pad;
+pub use self::flow::{layout_fragment, layout_frame};
 pub use self::pages::layout_document;
-pub use self::repeat::layout_repeat;
-pub use self::shapes::{
-    layout_circle, layout_curve, layout_ellipse, layout_line, layout_path,
-    layout_polygon, layout_rect, layout_square,
-};
-pub use self::stack::layout_stack;
-pub use self::transforms::{layout_move, layout_rotate, layout_scale, layout_skew};
+pub use self::rules::register;
diff --git a/crates/typst-layout/src/rules.rs b/crates/typst-layout/src/rules.rs
new file mode 100644
index 000000000..ebccd92e8
--- /dev/null
+++ b/crates/typst-layout/src/rules.rs
@@ -0,0 +1,890 @@
+use std::num::NonZeroUsize;
+
+use comemo::Track;
+use ecow::{eco_format, EcoVec};
+use smallvec::smallvec;
+use typst_library::diag::{bail, At, SourceResult};
+use typst_library::foundations::{
+    dict, Content, Context, NativeElement, NativeRuleMap, Packed, Resolve, ShowFn, Smart,
+    StyleChain, Target,
+};
+use typst_library::introspection::{Counter, Locator, LocatorLink};
+use typst_library::layout::{
+    Abs, AlignElem, Alignment, Axes, BlockBody, BlockElem, ColumnsElem, Em, GridCell,
+    GridChild, GridElem, GridItem, HAlignment, HElem, HideElem, InlineElem, LayoutElem,
+    Length, MoveElem, OuterVAlignment, PadElem, PlaceElem, PlacementScope, Region, Rel,
+    RepeatElem, RotateElem, ScaleElem, Sides, Size, Sizing, SkewElem, Spacing,
+    StackChild, StackElem, TrackSizings, VElem,
+};
+use typst_library::math::EquationElem;
+use typst_library::model::{
+    Attribution, BibliographyElem, CiteElem, CiteGroup, CslSource, Destination, EmphElem,
+    EnumElem, FigureCaption, FigureElem, FootnoteElem, FootnoteEntry, HeadingElem,
+    LinkElem, LinkTarget, ListElem, Outlinable, OutlineElem, OutlineEntry, ParElem,
+    ParbreakElem, QuoteElem, RefElem, StrongElem, TableCell, TableElem, TermsElem, Works,
+};
+use typst_library::pdf::EmbedElem;
+use typst_library::text::{
+    DecoLine, Decoration, HighlightElem, ItalicToggle, LinebreakElem, LocalName,
+    OverlineElem, RawElem, RawLine, ScriptKind, ShiftSettings, Smallcaps, SmallcapsElem,
+    SpaceElem, StrikeElem, SubElem, SuperElem, TextElem, TextSize, UnderlineElem,
+    WeightDelta,
+};
+use typst_library::visualize::{
+    CircleElem, CurveElem, EllipseElem, ImageElem, LineElem, PathElem, PolygonElem,
+    RectElem, SquareElem, Stroke,
+};
+use typst_utils::{Get, NonZeroExt, Numeric};
+
+/// Register show rules for the [paged target](Target::Paged).
+pub fn register(rules: &mut NativeRuleMap) {
+    use Target::Paged;
+
+    // Model.
+    rules.register(Paged, STRONG_RULE);
+    rules.register(Paged, EMPH_RULE);
+    rules.register(Paged, LIST_RULE);
+    rules.register(Paged, ENUM_RULE);
+    rules.register(Paged, TERMS_RULE);
+    rules.register(Paged, LINK_RULE);
+    rules.register(Paged, HEADING_RULE);
+    rules.register(Paged, FIGURE_RULE);
+    rules.register(Paged, FIGURE_CAPTION_RULE);
+    rules.register(Paged, QUOTE_RULE);
+    rules.register(Paged, FOOTNOTE_RULE);
+    rules.register(Paged, FOOTNOTE_ENTRY_RULE);
+    rules.register(Paged, OUTLINE_RULE);
+    rules.register(Paged, OUTLINE_ENTRY_RULE);
+    rules.register(Paged, REF_RULE);
+    rules.register(Paged, CITE_GROUP_RULE);
+    rules.register(Paged, BIBLIOGRAPHY_RULE);
+    rules.register(Paged, TABLE_RULE);
+    rules.register(Paged, TABLE_CELL_RULE);
+
+    // Text.
+    rules.register(Paged, SUB_RULE);
+    rules.register(Paged, SUPER_RULE);
+    rules.register(Paged, UNDERLINE_RULE);
+    rules.register(Paged, OVERLINE_RULE);
+    rules.register(Paged, STRIKE_RULE);
+    rules.register(Paged, HIGHLIGHT_RULE);
+    rules.register(Paged, SMALLCAPS_RULE);
+    rules.register(Paged, RAW_RULE);
+    rules.register(Paged, RAW_LINE_RULE);
+
+    // Layout.
+    rules.register(Paged, ALIGN_RULE);
+    rules.register(Paged, PAD_RULE);
+    rules.register(Paged, COLUMNS_RULE);
+    rules.register(Paged, STACK_RULE);
+    rules.register(Paged, GRID_RULE);
+    rules.register(Paged, GRID_CELL_RULE);
+    rules.register(Paged, MOVE_RULE);
+    rules.register(Paged, SCALE_RULE);
+    rules.register(Paged, ROTATE_RULE);
+    rules.register(Paged, SKEW_RULE);
+    rules.register(Paged, REPEAT_RULE);
+    rules.register(Paged, HIDE_RULE);
+    rules.register(Paged, LAYOUT_RULE);
+
+    // Visualize.
+    rules.register(Paged, IMAGE_RULE);
+    rules.register(Paged, LINE_RULE);
+    rules.register(Paged, RECT_RULE);
+    rules.register(Paged, SQUARE_RULE);
+    rules.register(Paged, ELLIPSE_RULE);
+    rules.register(Paged, CIRCLE_RULE);
+    rules.register(Paged, POLYGON_RULE);
+    rules.register(Paged, CURVE_RULE);
+    rules.register(Paged, PATH_RULE);
+
+    // Math.
+    rules.register(Paged, EQUATION_RULE);
+
+    // PDF.
+    rules.register(Paged, EMBED_RULE);
+}
+
+const STRONG_RULE: ShowFn<StrongElem> = |elem, _, styles| {
+    Ok(elem
+        .body
+        .clone()
+        .set(TextElem::delta, WeightDelta(elem.delta.get(styles))))
+};
+
+const EMPH_RULE: ShowFn<EmphElem> =
+    |elem, _, _| Ok(elem.body.clone().set(TextElem::emph, ItalicToggle(true)));
+
+const LIST_RULE: ShowFn<ListElem> = |elem, _, styles| {
+    let tight = elem.tight.get(styles);
+
+    let mut realized = BlockElem::multi_layouter(elem.clone(), crate::lists::layout_list)
+        .pack()
+        .spanned(elem.span());
+
+    if tight {
+        let spacing = elem
+            .spacing
+            .get(styles)
+            .unwrap_or_else(|| styles.get(ParElem::leading));
+        let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
+        realized = v + realized;
+    }
+
+    Ok(realized)
+};
+
+const ENUM_RULE: ShowFn<EnumElem> = |elem, _, styles| {
+    let tight = elem.tight.get(styles);
+
+    let mut realized = BlockElem::multi_layouter(elem.clone(), crate::lists::layout_enum)
+        .pack()
+        .spanned(elem.span());
+
+    if tight {
+        let spacing = elem
+            .spacing
+            .get(styles)
+            .unwrap_or_else(|| styles.get(ParElem::leading));
+        let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
+        realized = v + realized;
+    }
+
+    Ok(realized)
+};
+
+const TERMS_RULE: ShowFn<TermsElem> = |elem, _, styles| {
+    let span = elem.span();
+    let tight = elem.tight.get(styles);
+
+    let separator = elem.separator.get_ref(styles);
+    let indent = elem.indent.get(styles);
+    let hanging_indent = elem.hanging_indent.get(styles);
+    let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
+        if tight {
+            styles.get(ParElem::leading)
+        } else {
+            styles.get(ParElem::spacing)
+        }
+    });
+
+    let pad = hanging_indent + indent;
+    let unpad = (!hanging_indent.is_zero())
+        .then(|| HElem::new((-hanging_indent).into()).pack().spanned(span));
+
+    let mut children = vec![];
+    for child in elem.children.iter() {
+        let mut seq = vec![];
+        seq.extend(unpad.clone());
+        seq.push(child.term.clone().strong());
+        seq.push(separator.clone());
+        seq.push(child.description.clone());
+
+        // Text in wide term lists shall always turn into paragraphs.
+        if !tight {
+            seq.push(ParbreakElem::shared().clone());
+        }
+
+        children.push(StackChild::Block(Content::sequence(seq)));
+    }
+
+    let padding =
+        Sides::default().with(styles.resolve(TextElem::dir).start(), pad.into());
+
+    let mut realized = StackElem::new(children)
+        .with_spacing(Some(gutter.into()))
+        .pack()
+        .spanned(span)
+        .padded(padding)
+        .set(TermsElem::within, true);
+
+    if tight {
+        let spacing = elem
+            .spacing
+            .get(styles)
+            .unwrap_or_else(|| styles.get(ParElem::leading));
+        let v = VElem::new(spacing.into())
+            .with_weak(true)
+            .with_attach(true)
+            .pack()
+            .spanned(span);
+        realized = v + realized;
+    }
+
+    Ok(realized)
+};
+
+const LINK_RULE: ShowFn<LinkElem> = |elem, engine, _| {
+    let body = elem.body.clone();
+    Ok(match &elem.dest {
+        LinkTarget::Dest(dest) => body.linked(dest.clone()),
+        LinkTarget::Label(label) => {
+            let elem = engine.introspector.query_label(*label).at(elem.span())?;
+            let dest = Destination::Location(elem.location().unwrap());
+            body.linked(dest)
+        }
+    })
+};
+
+const HEADING_RULE: ShowFn<HeadingElem> = |elem, engine, styles| {
+    const SPACING_TO_NUMBERING: Em = Em::new(0.3);
+
+    let span = elem.span();
+    let mut realized = elem.body.clone();
+
+    let hanging_indent = elem.hanging_indent.get(styles);
+    let mut indent = match hanging_indent {
+        Smart::Custom(length) => length.resolve(styles),
+        Smart::Auto => Abs::zero(),
+    };
+
+    if let Some(numbering) = elem.numbering.get_ref(styles).as_ref() {
+        let location = elem.location().unwrap();
+        let numbering = Counter::of(HeadingElem::ELEM)
+            .display_at_loc(engine, location, styles, numbering)?
+            .spanned(span);
+
+        if hanging_indent.is_auto() {
+            let pod = Region::new(Axes::splat(Abs::inf()), Axes::splat(false));
+
+            // We don't have a locator for the numbering here, so we just
+            // use the measurement infrastructure for now.
+            let link = LocatorLink::measure(location);
+            let size = (engine.routines.layout_frame)(
+                engine,
+                &numbering,
+                Locator::link(&link),
+                styles,
+                pod,
+            )?
+            .size();
+
+            indent = size.x + SPACING_TO_NUMBERING.resolve(styles);
+        }
+
+        let spacing = HElem::new(SPACING_TO_NUMBERING.into()).with_weak(true).pack();
+
+        realized = numbering + spacing + realized;
+    }
+
+    let block = if indent != Abs::zero() {
+        let body = HElem::new((-indent).into()).pack() + realized;
+        let inset = Sides::default()
+            .with(styles.resolve(TextElem::dir).start(), Some(indent.into()));
+        BlockElem::new()
+            .with_body(Some(BlockBody::Content(body)))
+            .with_inset(inset)
+    } else {
+        BlockElem::new().with_body(Some(BlockBody::Content(realized)))
+    };
+
+    Ok(block.pack().spanned(span))
+};
+
+const FIGURE_RULE: ShowFn<FigureElem> = |elem, _, styles| {
+    let span = elem.span();
+    let mut realized = elem.body.clone();
+
+    // Build the caption, if any.
+    if let Some(caption) = elem.caption.get_cloned(styles) {
+        let (first, second) = match caption.position.get(styles) {
+            OuterVAlignment::Top => (caption.pack(), realized),
+            OuterVAlignment::Bottom => (realized, caption.pack()),
+        };
+        realized = Content::sequence(vec![
+            first,
+            VElem::new(elem.gap.get(styles).into())
+                .with_weak(true)
+                .pack()
+                .spanned(span),
+            second,
+        ]);
+    }
+
+    // Ensure that the body is considered a paragraph.
+    realized += ParbreakElem::shared().clone().spanned(span);
+
+    // Wrap the contents in a block.
+    realized = BlockElem::new()
+        .with_body(Some(BlockBody::Content(realized)))
+        .pack()
+        .spanned(span);
+
+    // Wrap in a float.
+    if let Some(align) = elem.placement.get(styles) {
+        realized = PlaceElem::new(realized)
+            .with_alignment(align.map(|align| HAlignment::Center + align))
+            .with_scope(elem.scope.get(styles))
+            .with_float(true)
+            .pack()
+            .spanned(span);
+    } else if elem.scope.get(styles) == PlacementScope::Parent {
+        bail!(
+            span,
+            "parent-scoped placement is only available for floating figures";
+            hint: "you can enable floating placement with `figure(placement: auto, ..)`"
+        );
+    }
+
+    Ok(realized)
+};
+
+const FIGURE_CAPTION_RULE: ShowFn<FigureCaption> = |elem, engine, styles| {
+    Ok(BlockElem::new()
+        .with_body(Some(BlockBody::Content(elem.realize(engine, styles)?)))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const QUOTE_RULE: ShowFn<QuoteElem> = |elem, _, styles| {
+    let span = elem.span();
+    let block = elem.block.get(styles);
+
+    let mut realized = elem.body.clone();
+
+    if elem.quotes.get(styles).unwrap_or(!block) {
+        // Add zero-width weak spacing to make the quotes "sticky".
+        let hole = HElem::hole().pack();
+        let sticky = Content::sequence([hole.clone(), realized, hole]);
+        realized = QuoteElem::quoted(sticky, styles);
+    }
+
+    let attribution = elem.attribution.get_ref(styles);
+
+    if block {
+        realized = BlockElem::new()
+            .with_body(Some(BlockBody::Content(realized)))
+            .pack()
+            .spanned(span);
+
+        if let Some(attribution) = attribution.as_ref() {
+            // Bring the attribution a bit closer to the quote.
+            let gap = Spacing::Rel(Em::new(0.9).into());
+            let v = VElem::new(gap).with_weak(true).pack();
+            realized += v;
+            realized += BlockElem::new()
+                .with_body(Some(BlockBody::Content(attribution.realize(span))))
+                .pack()
+                .aligned(Alignment::END);
+        }
+
+        realized = PadElem::new(realized).pack();
+    } else if let Some(Attribution::Label(label)) = attribution {
+        realized += SpaceElem::shared().clone();
+        realized += CiteElem::new(*label).pack().spanned(span);
+    }
+
+    Ok(realized)
+};
+
+const FOOTNOTE_RULE: ShowFn<FootnoteElem> = |elem, engine, styles| {
+    let span = elem.span();
+    let loc = elem.declaration_location(engine).at(span)?;
+    let numbering = elem.numbering.get_ref(styles);
+    let counter = Counter::of(FootnoteElem::ELEM);
+    let num = counter.display_at_loc(engine, loc, styles, numbering)?;
+    let sup = SuperElem::new(num).pack().spanned(span);
+    let loc = loc.variant(1);
+    // Add zero-width weak spacing to make the footnote "sticky".
+    Ok(HElem::hole().pack() + sup.linked(Destination::Location(loc)))
+};
+
+const FOOTNOTE_ENTRY_RULE: ShowFn<FootnoteEntry> = |elem, engine, styles| {
+    let span = elem.span();
+    let number_gap = Em::new(0.05);
+    let default = StyleChain::default();
+    let numbering = elem.note.numbering.get_ref(default);
+    let counter = Counter::of(FootnoteElem::ELEM);
+    let Some(loc) = elem.note.location() else {
+        bail!(
+            span, "footnote entry must have a location";
+            hint: "try using a query or a show rule to customize the footnote instead"
+        );
+    };
+
+    let num = counter.display_at_loc(engine, loc, styles, numbering)?;
+    let sup = SuperElem::new(num)
+        .pack()
+        .spanned(span)
+        .linked(Destination::Location(loc))
+        .located(loc.variant(1));
+
+    Ok(Content::sequence([
+        HElem::new(elem.indent.get(styles).into()).pack(),
+        sup,
+        HElem::new(number_gap.into()).with_weak(true).pack(),
+        elem.note.body_content().unwrap().clone(),
+    ]))
+};
+
+const OUTLINE_RULE: ShowFn<OutlineElem> = |elem, engine, styles| {
+    let span = elem.span();
+
+    // Build the outline title.
+    let mut seq = vec![];
+    if let Some(title) = elem.title.get_cloned(styles).unwrap_or_else(|| {
+        Some(TextElem::packed(Packed::<OutlineElem>::local_name_in(styles)).spanned(span))
+    }) {
+        seq.push(
+            HeadingElem::new(title)
+                .with_depth(NonZeroUsize::ONE)
+                .pack()
+                .spanned(span),
+        );
+    }
+
+    let elems = engine.introspector.query(&elem.target.get_ref(styles).0);
+    let depth = elem.depth.get(styles).unwrap_or(NonZeroUsize::MAX);
+
+    // Build the outline entries.
+    for elem in elems {
+        let Some(outlinable) = elem.with::<dyn Outlinable>() else {
+            bail!(span, "cannot outline {}", elem.func().name());
+        };
+
+        let level = outlinable.level();
+        if outlinable.outlined() && level <= depth {
+            let entry = OutlineEntry::new(level, elem);
+            seq.push(entry.pack().spanned(span));
+        }
+    }
+
+    Ok(Content::sequence(seq))
+};
+
+const OUTLINE_ENTRY_RULE: ShowFn<OutlineEntry> = |elem, engine, styles| {
+    let span = elem.span();
+    let context = Context::new(None, Some(styles));
+    let context = context.track();
+
+    let prefix = elem.prefix(engine, context, span)?;
+    let inner = elem.inner(engine, context, span)?;
+    let block = if elem.element.is::<EquationElem>() {
+        let body = prefix.unwrap_or_default() + inner;
+        BlockElem::new()
+            .with_body(Some(BlockBody::Content(body)))
+            .pack()
+            .spanned(span)
+    } else {
+        elem.indented(engine, context, span, prefix, inner, Em::new(0.5).into())?
+    };
+
+    let loc = elem.element_location().at(span)?;
+    Ok(block.linked(Destination::Location(loc)))
+};
+
+const REF_RULE: ShowFn<RefElem> = |elem, engine, styles| elem.realize(engine, styles);
+
+const CITE_GROUP_RULE: ShowFn<CiteGroup> = |elem, engine, _| elem.realize(engine);
+
+const BIBLIOGRAPHY_RULE: ShowFn<BibliographyElem> = |elem, engine, styles| {
+    const COLUMN_GUTTER: Em = Em::new(0.65);
+    const INDENT: Em = Em::new(1.5);
+
+    let span = elem.span();
+
+    let mut seq = vec![];
+    if let Some(title) = elem.title.get_ref(styles).clone().unwrap_or_else(|| {
+        Some(
+            TextElem::packed(Packed::<BibliographyElem>::local_name_in(styles))
+                .spanned(span),
+        )
+    }) {
+        seq.push(
+            HeadingElem::new(title)
+                .with_depth(NonZeroUsize::ONE)
+                .pack()
+                .spanned(span),
+        );
+    }
+
+    let works = Works::generate(engine).at(span)?;
+    let references = works
+        .references
+        .as_ref()
+        .ok_or_else(|| match elem.style.get_ref(styles).source {
+            CslSource::Named(style) => eco_format!(
+                "CSL style \"{}\" is not suitable for bibliographies",
+                style.display_name()
+            ),
+            CslSource::Normal(..) => {
+                "CSL style is not suitable for bibliographies".into()
+            }
+        })
+        .at(span)?;
+
+    if references.iter().any(|(prefix, _)| prefix.is_some()) {
+        let row_gutter = styles.get(ParElem::spacing);
+
+        let mut cells = vec![];
+        for (prefix, reference) in references {
+            cells.push(GridChild::Item(GridItem::Cell(
+                Packed::new(GridCell::new(prefix.clone().unwrap_or_default()))
+                    .spanned(span),
+            )));
+            cells.push(GridChild::Item(GridItem::Cell(
+                Packed::new(GridCell::new(reference.clone())).spanned(span),
+            )));
+        }
+        seq.push(
+            GridElem::new(cells)
+                .with_columns(TrackSizings(smallvec![Sizing::Auto; 2]))
+                .with_column_gutter(TrackSizings(smallvec![COLUMN_GUTTER.into()]))
+                .with_row_gutter(TrackSizings(smallvec![row_gutter.into()]))
+                .pack()
+                .spanned(span),
+        );
+    } else {
+        for (_, reference) in references {
+            let realized = reference.clone();
+            let block = if works.hanging_indent {
+                let body = HElem::new((-INDENT).into()).pack() + realized;
+                let inset = Sides::default()
+                    .with(styles.resolve(TextElem::dir).start(), Some(INDENT.into()));
+                BlockElem::new()
+                    .with_body(Some(BlockBody::Content(body)))
+                    .with_inset(inset)
+            } else {
+                BlockElem::new().with_body(Some(BlockBody::Content(realized)))
+            };
+
+            seq.push(block.pack().spanned(span));
+        }
+    }
+
+    Ok(Content::sequence(seq))
+};
+
+const TABLE_RULE: ShowFn<TableElem> = |elem, _, _| {
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::grid::layout_table)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const TABLE_CELL_RULE: ShowFn<TableCell> = |elem, _, styles| {
+    show_cell(elem.body.clone(), elem.inset.get(styles), elem.align.get(styles))
+};
+
+const SUB_RULE: ShowFn<SubElem> = |elem, _, styles| {
+    show_script(
+        styles,
+        elem.body.clone(),
+        elem.typographic.get(styles),
+        elem.baseline.get(styles),
+        elem.size.get(styles),
+        ScriptKind::Sub,
+    )
+};
+
+const SUPER_RULE: ShowFn<SuperElem> = |elem, _, styles| {
+    show_script(
+        styles,
+        elem.body.clone(),
+        elem.typographic.get(styles),
+        elem.baseline.get(styles),
+        elem.size.get(styles),
+        ScriptKind::Super,
+    )
+};
+
+fn show_script(
+    styles: StyleChain,
+    body: Content,
+    typographic: bool,
+    baseline: Smart<Length>,
+    size: Smart<TextSize>,
+    kind: ScriptKind,
+) -> SourceResult<Content> {
+    let font_size = styles.resolve(TextElem::size);
+    Ok(body.set(
+        TextElem::shift_settings,
+        Some(ShiftSettings {
+            typographic,
+            shift: baseline.map(|l| -Em::from_length(l, font_size)),
+            size: size.map(|t| Em::from_length(t.0, font_size)),
+            kind,
+        }),
+    ))
+}
+
+const UNDERLINE_RULE: ShowFn<UnderlineElem> = |elem, _, styles| {
+    Ok(elem.body.clone().set(
+        TextElem::deco,
+        smallvec![Decoration {
+            line: DecoLine::Underline {
+                stroke: elem.stroke.resolve(styles).unwrap_or_default(),
+                offset: elem.offset.resolve(styles),
+                evade: elem.evade.get(styles),
+                background: elem.background.get(styles),
+            },
+            extent: elem.extent.resolve(styles),
+        }],
+    ))
+};
+
+const OVERLINE_RULE: ShowFn<OverlineElem> = |elem, _, styles| {
+    Ok(elem.body.clone().set(
+        TextElem::deco,
+        smallvec![Decoration {
+            line: DecoLine::Overline {
+                stroke: elem.stroke.resolve(styles).unwrap_or_default(),
+                offset: elem.offset.resolve(styles),
+                evade: elem.evade.get(styles),
+                background: elem.background.get(styles),
+            },
+            extent: elem.extent.resolve(styles),
+        }],
+    ))
+};
+
+const STRIKE_RULE: ShowFn<StrikeElem> = |elem, _, styles| {
+    Ok(elem.body.clone().set(
+        TextElem::deco,
+        smallvec![Decoration {
+            // Note that we do not support evade option for strikethrough.
+            line: DecoLine::Strikethrough {
+                stroke: elem.stroke.resolve(styles).unwrap_or_default(),
+                offset: elem.offset.resolve(styles),
+                background: elem.background.get(styles),
+            },
+            extent: elem.extent.resolve(styles),
+        }],
+    ))
+};
+
+const HIGHLIGHT_RULE: ShowFn<HighlightElem> = |elem, _, styles| {
+    Ok(elem.body.clone().set(
+        TextElem::deco,
+        smallvec![Decoration {
+            line: DecoLine::Highlight {
+                fill: elem.fill.get_cloned(styles),
+                stroke: elem
+                    .stroke
+                    .resolve(styles)
+                    .unwrap_or_default()
+                    .map(|stroke| stroke.map(Stroke::unwrap_or_default)),
+                top_edge: elem.top_edge.get(styles),
+                bottom_edge: elem.bottom_edge.get(styles),
+                radius: elem.radius.resolve(styles).unwrap_or_default(),
+            },
+            extent: elem.extent.resolve(styles),
+        }],
+    ))
+};
+
+const SMALLCAPS_RULE: ShowFn<SmallcapsElem> = |elem, _, styles| {
+    let sc = if elem.all.get(styles) { Smallcaps::All } else { Smallcaps::Minuscules };
+    Ok(elem.body.clone().set(TextElem::smallcaps, Some(sc)))
+};
+
+const RAW_RULE: ShowFn<RawElem> = |elem, _, styles| {
+    let lines = elem.lines.as_deref().unwrap_or_default();
+
+    let mut seq = EcoVec::with_capacity((2 * lines.len()).saturating_sub(1));
+    for (i, line) in lines.iter().enumerate() {
+        if i != 0 {
+            seq.push(LinebreakElem::shared().clone());
+        }
+
+        seq.push(line.clone().pack());
+    }
+
+    let mut realized = Content::sequence(seq);
+
+    if elem.block.get(styles) {
+        // Align the text before inserting it into the block.
+        realized = realized.aligned(elem.align.get(styles).into());
+        realized = BlockElem::new()
+            .with_body(Some(BlockBody::Content(realized)))
+            .pack()
+            .spanned(elem.span());
+    }
+
+    Ok(realized)
+};
+
+const RAW_LINE_RULE: ShowFn<RawLine> = |elem, _, _| Ok(elem.body.clone());
+
+const ALIGN_RULE: ShowFn<AlignElem> =
+    |elem, _, styles| Ok(elem.body.clone().aligned(elem.alignment.get(styles)));
+
+const PAD_RULE: ShowFn<PadElem> = |elem, _, _| {
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::pad::layout_pad)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const COLUMNS_RULE: ShowFn<ColumnsElem> = |elem, _, _| {
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::flow::layout_columns)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const STACK_RULE: ShowFn<StackElem> = |elem, _, _| {
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::stack::layout_stack)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const GRID_RULE: ShowFn<GridElem> = |elem, _, _| {
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::grid::layout_grid)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const GRID_CELL_RULE: ShowFn<GridCell> = |elem, _, styles| {
+    show_cell(elem.body.clone(), elem.inset.get(styles), elem.align.get(styles))
+};
+
+/// Function with common code to display a grid cell or table cell.
+fn show_cell(
+    mut body: Content,
+    inset: Smart<Sides<Option<Rel<Length>>>>,
+    align: Smart<Alignment>,
+) -> SourceResult<Content> {
+    let inset = inset.unwrap_or_default().map(Option::unwrap_or_default);
+
+    if inset != Sides::default() {
+        // Only pad if some inset is not 0pt.
+        // Avoids a bug where using .padded() in any way inside Show causes
+        // alignment in align(...) to break.
+        body = body.padded(inset);
+    }
+
+    if let Smart::Custom(alignment) = align {
+        body = body.aligned(alignment);
+    }
+
+    Ok(body)
+}
+
+const MOVE_RULE: ShowFn<MoveElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_move)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const SCALE_RULE: ShowFn<ScaleElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_scale)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const ROTATE_RULE: ShowFn<RotateElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_rotate)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const SKEW_RULE: ShowFn<SkewElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_skew)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const REPEAT_RULE: ShowFn<RepeatElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::repeat::layout_repeat)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const HIDE_RULE: ShowFn<HideElem> =
+    |elem, _, _| Ok(elem.body.clone().set(HideElem::hidden, true));
+
+const LAYOUT_RULE: ShowFn<LayoutElem> = |elem, _, _| {
+    Ok(BlockElem::multi_layouter(
+        elem.clone(),
+        |elem, engine, locator, styles, regions| {
+            // Gets the current region's base size, which will be the size of the
+            // outer container, or of the page if there is no such container.
+            let Size { x, y } = regions.base();
+            let loc = elem.location().unwrap();
+            let context = Context::new(Some(loc), Some(styles));
+            let result = elem
+                .func
+                .call(engine, context.track(), [dict! { "width" => x, "height" => y }])?
+                .display();
+            crate::flow::layout_fragment(engine, &result, locator, styles, regions)
+        },
+    )
+    .pack()
+    .spanned(elem.span()))
+};
+
+const IMAGE_RULE: ShowFn<ImageElem> = |elem, _, styles| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::image::layout_image)
+        .with_width(elem.width.get(styles))
+        .with_height(elem.height.get(styles))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const LINE_RULE: ShowFn<LineElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_line)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const RECT_RULE: ShowFn<RectElem> = |elem, _, styles| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_rect)
+        .with_width(elem.width.get(styles))
+        .with_height(elem.height.get(styles))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const SQUARE_RULE: ShowFn<SquareElem> = |elem, _, styles| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_square)
+        .with_width(elem.width.get(styles))
+        .with_height(elem.height.get(styles))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const ELLIPSE_RULE: ShowFn<EllipseElem> = |elem, _, styles| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_ellipse)
+        .with_width(elem.width.get(styles))
+        .with_height(elem.height.get(styles))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const CIRCLE_RULE: ShowFn<CircleElem> = |elem, _, styles| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_circle)
+        .with_width(elem.width.get(styles))
+        .with_height(elem.height.get(styles))
+        .pack()
+        .spanned(elem.span()))
+};
+
+const POLYGON_RULE: ShowFn<PolygonElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_polygon)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const CURVE_RULE: ShowFn<CurveElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_curve)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const PATH_RULE: ShowFn<PathElem> = |elem, _, _| {
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_path)
+        .pack()
+        .spanned(elem.span()))
+};
+
+const EQUATION_RULE: ShowFn<EquationElem> = |elem, _, styles| {
+    if elem.block.get(styles) {
+        Ok(BlockElem::multi_layouter(elem.clone(), crate::math::layout_equation_block)
+            .pack()
+            .spanned(elem.span()))
+    } else {
+        Ok(InlineElem::layouter(elem.clone(), crate::math::layout_equation_inline)
+            .pack()
+            .spanned(elem.span()))
+    }
+};
+
+const EMBED_RULE: ShowFn<EmbedElem> = |_, _, _| Ok(Content::empty());
diff --git a/crates/typst-library/src/foundations/content/element.rs b/crates/typst-library/src/foundations/content/element.rs
index 49b0b0f9b..65c2e28b5 100644
--- a/crates/typst-library/src/foundations/content/element.rs
+++ b/crates/typst-library/src/foundations/content/element.rs
@@ -246,12 +246,6 @@ pub trait Synthesize {
         -> SourceResult<()>;
 }
 
-/// Defines a built-in show rule for an element.
-pub trait Show {
-    /// Execute the base recipe for this element.
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content>;
-}
-
 /// Defines built-in show set rules for an element.
 ///
 /// This is a bit more powerful than a user-defined show-set because it can
diff --git a/crates/typst-library/src/foundations/context.rs b/crates/typst-library/src/foundations/context.rs
index bf4bdcd25..56d87775e 100644
--- a/crates/typst-library/src/foundations/context.rs
+++ b/crates/typst-library/src/foundations/context.rs
@@ -3,7 +3,7 @@ use comemo::Track;
 use crate::diag::{bail, Hint, HintedStrResult, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Args, Construct, Content, Func, Packed, Show, StyleChain, Value,
+    elem, Args, Construct, Content, Func, ShowFn, StyleChain, Value,
 };
 use crate::introspection::{Locatable, Location};
 
@@ -61,7 +61,7 @@ fn require<T>(val: Option<T>) -> HintedStrResult<T> {
 }
 
 /// Executes a `context` block.
-#[elem(Construct, Locatable, Show)]
+#[elem(Construct, Locatable)]
 pub struct ContextElem {
     /// The function to call with the context.
     #[required]
@@ -75,11 +75,8 @@ impl Construct for ContextElem {
     }
 }
 
-impl Show for Packed<ContextElem> {
-    #[typst_macros::time(name = "context", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let loc = self.location().unwrap();
-        let context = Context::new(Some(loc), Some(styles));
-        Ok(self.func.call::<[Value; 0]>(engine, context.track(), [])?.display())
-    }
-}
+pub const CONTEXT_RULE: ShowFn<ContextElem> = |elem, engine, styles| {
+    let loc = elem.location().unwrap();
+    let context = Context::new(Some(loc), Some(styles));
+    Ok(elem.func.call::<[Value; 0]>(engine, context.track(), [])?.display())
+};
diff --git a/crates/typst-library/src/foundations/styles.rs b/crates/typst-library/src/foundations/styles.rs
index 978b47d5f..0da036f6f 100644
--- a/crates/typst-library/src/foundations/styles.rs
+++ b/crates/typst-library/src/foundations/styles.rs
@@ -1,4 +1,5 @@
 use std::any::{Any, TypeId};
+use std::collections::HashMap;
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::{mem, ptr};
@@ -13,7 +14,7 @@ use crate::diag::{SourceResult, Trace, Tracepoint};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, ty, Content, Context, Element, Field, Func, NativeElement, OneOrMultiple,
-    RefableProperty, Repr, Selector, SettableProperty,
+    Packed, RefableProperty, Repr, Selector, SettableProperty, Target,
 };
 use crate::text::{FontFamily, FontList, TextElem};
 
@@ -938,3 +939,129 @@ fn block_wrong_type(func: Element, id: u8, value: &Block) -> ! {
         value
     )
 }
+
+/// Holds native show rules.
+pub struct NativeRuleMap {
+    rules: HashMap<(Element, Target), NativeShowRule>,
+}
+
+/// The signature of a native show rule.
+pub type ShowFn<T> = fn(
+    elem: &Packed<T>,
+    engine: &mut Engine,
+    styles: StyleChain,
+) -> SourceResult<Content>;
+
+impl NativeRuleMap {
+    /// Creates a new rule map.
+    ///
+    /// Should be populated with rules for all target-element combinations that
+    /// are supported.
+    ///
+    /// Contains built-in rules for a few special elements.
+    pub fn new() -> Self {
+        let mut rules = Self { rules: HashMap::new() };
+
+        // ContextElem is as special as SequenceElem and StyledElem and could,
+        // in theory, also be special cased in realization.
+        rules.register_builtin(crate::foundations::CONTEXT_RULE);
+
+        // CounterDisplayElem only exists because the compiler can't currently
+        // express the equivalent of `context counter(..).display(..)` in native
+        // code (no native closures).
+        rules.register_builtin(crate::introspection::COUNTER_DISPLAY_RULE);
+
+        // These are all only for introspection and empty on all targets.
+        rules.register_empty::<crate::introspection::CounterUpdateElem>();
+        rules.register_empty::<crate::introspection::StateUpdateElem>();
+        rules.register_empty::<crate::introspection::MetadataElem>();
+        rules.register_empty::<crate::model::PrefixInfo>();
+
+        rules
+    }
+
+    /// Registers a rule for all targets.
+    fn register_empty<T: NativeElement>(&mut self) {
+        self.register_builtin::<T>(|_, _, _| Ok(Content::empty()));
+    }
+
+    /// Registers a rule for all targets.
+    fn register_builtin<T: NativeElement>(&mut self, f: ShowFn<T>) {
+        self.register(Target::Paged, f);
+        self.register(Target::Html, f);
+    }
+
+    /// Registers a rule for a target.
+    ///
+    /// Panics if a rule already exists for this target-element combination.
+    pub fn register<T: NativeElement>(&mut self, target: Target, f: ShowFn<T>) {
+        let res = self.rules.insert((T::ELEM, target), NativeShowRule::new(f));
+        if res.is_some() {
+            panic!(
+                "duplicate native show rule for `{}` on {target:?} target",
+                T::ELEM.name()
+            )
+        }
+    }
+
+    /// Retrieves the rule that applies to the `content` on the current
+    /// `target`.
+    pub fn get(&self, target: Target, content: &Content) -> Option<NativeShowRule> {
+        self.rules.get(&(content.func(), target)).copied()
+    }
+}
+
+impl Default for NativeRuleMap {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub use rule::NativeShowRule;
+
+mod rule {
+    use super::*;
+
+    /// The show rule for a native element.
+    #[derive(Copy, Clone)]
+    pub struct NativeShowRule {
+        /// The element to which this rule applies.
+        elem: Element,
+        /// Must only be called with content of the appropriate type.
+        f: unsafe fn(
+            elem: &Content,
+            engine: &mut Engine,
+            styles: StyleChain,
+        ) -> SourceResult<Content>,
+    }
+
+    impl NativeShowRule {
+        /// Create a new type-erased show rule.
+        pub fn new<T: NativeElement>(f: ShowFn<T>) -> Self {
+            Self {
+                elem: T::ELEM,
+                // Safety: The two function pointer types only differ in the
+                // first argument, which changes from `&Packed<T>` to
+                // `&Content`. `Packed<T>` is a transparent wrapper around
+                // `Content`. The resulting function is unsafe to call because
+                // content of the correct type must be passed to it.
+                #[allow(clippy::missing_transmute_annotations)]
+                f: unsafe { std::mem::transmute(f) },
+            }
+        }
+
+        /// Applies the rule to content. Panics if the content is of the wrong
+        /// type.
+        pub fn apply(
+            &self,
+            content: &Content,
+            engine: &mut Engine,
+            styles: StyleChain,
+        ) -> SourceResult<Content> {
+            assert_eq!(content.elem(), self.elem);
+
+            // Safety: We just checked that the element is of the correct type.
+            unsafe { (self.f)(content, engine, styles) }
+        }
+    }
+}
diff --git a/crates/typst-library/src/foundations/target.rs b/crates/typst-library/src/foundations/target.rs
index 71e7554e0..ff90f1f7b 100644
--- a/crates/typst-library/src/foundations/target.rs
+++ b/crates/typst-library/src/foundations/target.rs
@@ -4,7 +4,7 @@ use crate::diag::HintedStrResult;
 use crate::foundations::{elem, func, Cast, Context};
 
 /// The export target.
-#[derive(Debug, Default, Copy, Clone, PartialEq, Hash, Cast)]
+#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Hash, Cast)]
 pub enum Target {
     /// The target that is used for paged, fully laid-out content.
     #[default]
diff --git a/crates/typst-library/src/introspection/counter.rs b/crates/typst-library/src/introspection/counter.rs
index a7925e13a..b3c52de4e 100644
--- a/crates/typst-library/src/introspection/counter.rs
+++ b/crates/typst-library/src/introspection/counter.rs
@@ -12,7 +12,7 @@ use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
     cast, elem, func, scope, select_where, ty, Args, Array, Construct, Content, Context,
     Element, Func, IntoValue, Label, LocatableSelector, NativeElement, Packed, Repr,
-    Selector, Show, Smart, Str, StyleChain, Value,
+    Selector, ShowFn, Smart, Str, StyleChain, Value,
 };
 use crate::introspection::{Introspector, Locatable, Location, Tag};
 use crate::layout::{Frame, FrameItem, PageElem};
@@ -683,8 +683,8 @@ cast! {
 }
 
 /// Executes an update of a counter.
-#[elem(Construct, Locatable, Show, Count)]
-struct CounterUpdateElem {
+#[elem(Construct, Locatable, Count)]
+pub struct CounterUpdateElem {
     /// The key that identifies the counter.
     #[required]
     key: CounterKey,
@@ -701,12 +701,6 @@ impl Construct for CounterUpdateElem {
     }
 }
 
-impl Show for Packed<CounterUpdateElem> {
-    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(Content::empty())
-    }
-}
-
 impl Count for Packed<CounterUpdateElem> {
     fn update(&self) -> Option<CounterUpdate> {
         Some(self.update.clone())
@@ -714,7 +708,7 @@ impl Count for Packed<CounterUpdateElem> {
 }
 
 /// Executes a display of a counter.
-#[elem(Construct, Locatable, Show)]
+#[elem(Construct, Locatable)]
 pub struct CounterDisplayElem {
     /// The counter.
     #[required]
@@ -738,20 +732,18 @@ impl Construct for CounterDisplayElem {
     }
 }
 
-impl Show for Packed<CounterDisplayElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(self
-            .counter
-            .display_impl(
-                engine,
-                self.location().unwrap(),
-                self.numbering.clone(),
-                self.both,
-                Some(styles),
-            )?
-            .display())
-    }
-}
+pub const COUNTER_DISPLAY_RULE: ShowFn<CounterDisplayElem> = |elem, engine, styles| {
+    Ok(elem
+        .counter
+        .display_impl(
+            engine,
+            elem.location().unwrap(),
+            elem.numbering.clone(),
+            elem.both,
+            Some(styles),
+        )?
+        .display())
+};
 
 /// An specialized handler of the page counter that tracks both the physical
 /// and the logical page counter.
diff --git a/crates/typst-library/src/introspection/metadata.rs b/crates/typst-library/src/introspection/metadata.rs
index 06000174f..8ad74b96b 100644
--- a/crates/typst-library/src/introspection/metadata.rs
+++ b/crates/typst-library/src/introspection/metadata.rs
@@ -1,6 +1,4 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{elem, Content, Packed, Show, StyleChain, Value};
+use crate::foundations::{elem, Value};
 use crate::introspection::Locatable;
 
 /// Exposes a value to the query system without producing visible content.
@@ -24,15 +22,9 @@ use crate::introspection::Locatable;
 ///   query(<note>).first().value
 /// }
 /// ```
-#[elem(Show, Locatable)]
+#[elem(Locatable)]
 pub struct MetadataElem {
     /// The value to embed into the document.
     #[required]
     pub value: Value,
 }
-
-impl Show for Packed<MetadataElem> {
-    fn show(&self, _: &mut Engine, _styles: StyleChain) -> SourceResult<Content> {
-        Ok(Content::empty())
-    }
-}
diff --git a/crates/typst-library/src/introspection/state.rs b/crates/typst-library/src/introspection/state.rs
index 784f2acb2..2d15a5de0 100644
--- a/crates/typst-library/src/introspection/state.rs
+++ b/crates/typst-library/src/introspection/state.rs
@@ -6,8 +6,7 @@ use crate::diag::{bail, At, SourceResult};
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
     cast, elem, func, scope, select_where, ty, Args, Construct, Content, Context, Func,
-    LocatableSelector, NativeElement, Packed, Repr, Selector, Show, Str, StyleChain,
-    Value,
+    LocatableSelector, NativeElement, Repr, Selector, Str, Value,
 };
 use crate::introspection::{Introspector, Locatable, Location};
 use crate::routines::Routines;
@@ -372,8 +371,8 @@ cast! {
 }
 
 /// Executes a display of a state.
-#[elem(Construct, Locatable, Show)]
-struct StateUpdateElem {
+#[elem(Construct, Locatable)]
+pub struct StateUpdateElem {
     /// The key that identifies the state.
     #[required]
     key: Str,
@@ -389,9 +388,3 @@ impl Construct for StateUpdateElem {
         bail!(args.span, "cannot be constructed manually");
     }
 }
-
-impl Show for Packed<StateUpdateElem> {
-    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(Content::empty())
-    }
-}
diff --git a/crates/typst-library/src/layout/align.rs b/crates/typst-library/src/layout/align.rs
index e5ceddf65..447648f01 100644
--- a/crates/typst-library/src/layout/align.rs
+++ b/crates/typst-library/src/layout/align.rs
@@ -2,11 +2,10 @@ use std::ops::Add;
 
 use ecow::{eco_format, EcoString};
 
-use crate::diag::{bail, HintedStrResult, SourceResult, StrResult};
-use crate::engine::Engine;
+use crate::diag::{bail, HintedStrResult, StrResult};
 use crate::foundations::{
-    cast, elem, func, scope, ty, CastInfo, Content, Fold, FromValue, IntoValue, Packed,
-    Reflect, Repr, Resolve, Show, StyleChain, Value,
+    cast, elem, func, scope, ty, CastInfo, Content, Fold, FromValue, IntoValue, Reflect,
+    Repr, Resolve, StyleChain, Value,
 };
 use crate::layout::{Abs, Axes, Axis, Dir, Side};
 use crate::text::TextElem;
@@ -73,7 +72,7 @@ use crate::text::TextElem;
 /// ```example
 /// Start #h(1fr) End
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct AlignElem {
     /// The [alignment] along both axes.
     ///
@@ -97,13 +96,6 @@ pub struct AlignElem {
     pub body: Content,
 }
 
-impl Show for Packed<AlignElem> {
-    #[typst_macros::time(name = "align", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(self.body.clone().aligned(self.alignment.get(styles)))
-    }
-}
-
 /// Where to align something along an axis.
 ///
 /// Possible values are:
diff --git a/crates/typst-library/src/layout/columns.rs b/crates/typst-library/src/layout/columns.rs
index 1cea52759..e7bce393b 100644
--- a/crates/typst-library/src/layout/columns.rs
+++ b/crates/typst-library/src/layout/columns.rs
@@ -1,9 +1,7 @@
 use std::num::NonZeroUsize;
 
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{elem, Content, NativeElement, Packed, Show, StyleChain};
-use crate::layout::{BlockElem, Length, Ratio, Rel};
+use crate::foundations::{elem, Content};
+use crate::layout::{Length, Ratio, Rel};
 
 /// Separates a region into multiple equally sized columns.
 ///
@@ -41,7 +39,7 @@ use crate::layout::{BlockElem, Length, Ratio, Rel};
 ///
 /// #lorem(40)
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct ColumnsElem {
     /// The number of columns.
     #[positional]
@@ -57,14 +55,6 @@ pub struct ColumnsElem {
     pub body: Content,
 }
 
-impl Show for Packed<ColumnsElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::multi_layouter(self.clone(), engine.routines.layout_columns)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// Forces a column break.
 ///
 /// The function will behave like a [page break]($pagebreak) when used in a
diff --git a/crates/typst-library/src/layout/grid/mod.rs b/crates/typst-library/src/layout/grid/mod.rs
index 64e7464be..658523ec6 100644
--- a/crates/typst-library/src/layout/grid/mod.rs
+++ b/crates/typst-library/src/layout/grid/mod.rs
@@ -11,10 +11,10 @@ use crate::diag::{bail, At, HintedStrResult, HintedString, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, Array, CastInfo, Content, Context, Fold, FromValue, Func,
-    IntoValue, NativeElement, Packed, Reflect, Resolve, Show, Smart, StyleChain, Value,
+    IntoValue, Packed, Reflect, Resolve, Smart, StyleChain, Value,
 };
 use crate::layout::{
-    Alignment, BlockElem, Length, OuterHAlignment, OuterVAlignment, Rel, Sides, Sizing,
+    Alignment, Length, OuterHAlignment, OuterVAlignment, Rel, Sides, Sizing,
 };
 use crate::model::{TableCell, TableFooter, TableHLine, TableHeader, TableVLine};
 use crate::visualize::{Paint, Stroke};
@@ -136,7 +136,7 @@ use crate::visualize::{Paint, Stroke};
 ///
 /// Furthermore, strokes of a repeated grid header or footer will take
 /// precedence over regular cell strokes.
-#[elem(scope, Show)]
+#[elem(scope)]
 pub struct GridElem {
     /// The column sizes.
     ///
@@ -320,14 +320,6 @@ impl GridElem {
     type GridFooter;
 }
 
-impl Show for Packed<GridElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::multi_layouter(self.clone(), engine.routines.layout_grid)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// Track sizing definitions.
 #[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
 pub struct TrackSizings(pub SmallVec<[Sizing; 4]>);
@@ -648,7 +640,7 @@ pub struct GridVLine {
 /// which allows you, for example, to apply styles based on a cell's position.
 /// Refer to the examples of the [`table.cell`]($table.cell) element to learn
 /// more about this.
-#[elem(name = "cell", title = "Grid Cell", Show)]
+#[elem(name = "cell", title = "Grid Cell")]
 pub struct GridCell {
     /// The cell's body.
     #[required]
@@ -748,12 +740,6 @@ cast! {
     v: Content => v.into(),
 }
 
-impl Show for Packed<GridCell> {
-    fn show(&self, _engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        show_grid_cell(self.body.clone(), self.inset.get(styles), self.align.get(styles))
-    }
-}
-
 impl Default for Packed<GridCell> {
     fn default() -> Self {
         Packed::new(
@@ -774,28 +760,6 @@ impl From<Content> for GridCell {
     }
 }
 
-/// Function with common code to display a grid cell or table cell.
-pub(crate) fn show_grid_cell(
-    mut body: Content,
-    inset: Smart<Sides<Option<Rel<Length>>>>,
-    align: Smart<Alignment>,
-) -> SourceResult<Content> {
-    let inset = inset.unwrap_or_default().map(Option::unwrap_or_default);
-
-    if inset != Sides::default() {
-        // Only pad if some inset is not 0pt.
-        // Avoids a bug where using .padded() in any way inside Show causes
-        // alignment in align(...) to break.
-        body = body.padded(inset);
-    }
-
-    if let Smart::Custom(alignment) = align {
-        body = body.aligned(alignment);
-    }
-
-    Ok(body)
-}
-
 /// A value that can be configured per cell.
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub enum Celled<T> {
diff --git a/crates/typst-library/src/layout/hide.rs b/crates/typst-library/src/layout/hide.rs
index 5f3a5a2d3..bb40447d5 100644
--- a/crates/typst-library/src/layout/hide.rs
+++ b/crates/typst-library/src/layout/hide.rs
@@ -1,6 +1,4 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{elem, Content, Packed, Show, StyleChain};
+use crate::foundations::{elem, Content};
 
 /// Hides content without affecting layout.
 ///
@@ -14,7 +12,7 @@ use crate::foundations::{elem, Content, Packed, Show, StyleChain};
 /// Hello Jane \
 /// #hide[Hello] Joe
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct HideElem {
     /// The content to hide.
     #[required]
@@ -25,10 +23,3 @@ pub struct HideElem {
     #[ghost]
     pub hidden: bool,
 }
-
-impl Show for Packed<HideElem> {
-    #[typst_macros::time(name = "hide", span = self.span())]
-    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(self.body.clone().set(HideElem::hidden, true))
-    }
-}
diff --git a/crates/typst-library/src/layout/layout.rs b/crates/typst-library/src/layout/layout.rs
index 46271ff22..00897bcfe 100644
--- a/crates/typst-library/src/layout/layout.rs
+++ b/crates/typst-library/src/layout/layout.rs
@@ -1,13 +1,7 @@
-use comemo::Track;
 use typst_syntax::Span;
 
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    dict, elem, func, Content, Context, Func, NativeElement, Packed, Show, StyleChain,
-};
+use crate::foundations::{elem, func, Content, Func, NativeElement};
 use crate::introspection::Locatable;
-use crate::layout::{BlockElem, Size};
 
 /// Provides access to the current outer container's (or page's, if none)
 /// dimensions (width and height).
@@ -86,37 +80,9 @@ pub fn layout(
 }
 
 /// Executes a `layout` call.
-#[elem(Locatable, Show)]
-struct LayoutElem {
+#[elem(Locatable)]
+pub struct LayoutElem {
     /// The function to call with the outer container's (or page's) size.
     #[required]
-    func: Func,
-}
-
-impl Show for Packed<LayoutElem> {
-    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::multi_layouter(
-            self.clone(),
-            |elem, engine, locator, styles, regions| {
-                // Gets the current region's base size, which will be the size of the
-                // outer container, or of the page if there is no such container.
-                let Size { x, y } = regions.base();
-                let loc = elem.location().unwrap();
-                let context = Context::new(Some(loc), Some(styles));
-                let result = elem
-                    .func
-                    .call(
-                        engine,
-                        context.track(),
-                        [dict! { "width" => x, "height" => y }],
-                    )?
-                    .display();
-                (engine.routines.layout_fragment)(
-                    engine, &result, locator, styles, regions,
-                )
-            },
-        )
-        .pack()
-        .spanned(self.span()))
-    }
+    pub func: Func,
 }
diff --git a/crates/typst-library/src/layout/pad.rs b/crates/typst-library/src/layout/pad.rs
index 1dc6d1316..d533df35b 100644
--- a/crates/typst-library/src/layout/pad.rs
+++ b/crates/typst-library/src/layout/pad.rs
@@ -1,7 +1,5 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{elem, Content, NativeElement, Packed, Show, StyleChain};
-use crate::layout::{BlockElem, Length, Rel};
+use crate::foundations::{elem, Content};
+use crate::layout::{Length, Rel};
 
 /// Adds spacing around content.
 ///
@@ -16,7 +14,7 @@ use crate::layout::{BlockElem, Length, Rel};
 /// _Typing speeds can be
 ///  measured in words per minute._
 /// ```
-#[elem(title = "Padding", Show)]
+#[elem(title = "Padding")]
 pub struct PadElem {
     /// The padding at the left side.
     #[parse(
@@ -55,11 +53,3 @@ pub struct PadElem {
     #[required]
     pub body: Content,
 }
-
-impl Show for Packed<PadElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::multi_layouter(self.clone(), engine.routines.layout_pad)
-            .pack()
-            .spanned(self.span()))
-    }
-}
diff --git a/crates/typst-library/src/layout/repeat.rs b/crates/typst-library/src/layout/repeat.rs
index 9579f1856..a38d5f896 100644
--- a/crates/typst-library/src/layout/repeat.rs
+++ b/crates/typst-library/src/layout/repeat.rs
@@ -1,7 +1,5 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{elem, Content, NativeElement, Packed, Show, StyleChain};
-use crate::layout::{BlockElem, Length};
+use crate::foundations::{elem, Content};
+use crate::layout::Length;
 
 /// Repeats content to the available space.
 ///
@@ -24,7 +22,7 @@ use crate::layout::{BlockElem, Length};
 ///   Berlin, the 22nd of December, 2022
 /// ]
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct RepeatElem {
     /// The content to repeat.
     #[required]
@@ -39,11 +37,3 @@ pub struct RepeatElem {
     #[default(true)]
     pub justify: bool,
 }
-
-impl Show for Packed<RepeatElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_repeat)
-            .pack()
-            .spanned(self.span()))
-    }
-}
diff --git a/crates/typst-library/src/layout/stack.rs b/crates/typst-library/src/layout/stack.rs
index 5fc78480e..fca1ecb86 100644
--- a/crates/typst-library/src/layout/stack.rs
+++ b/crates/typst-library/src/layout/stack.rs
@@ -1,9 +1,7 @@
 use std::fmt::{self, Debug, Formatter};
 
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{cast, elem, Content, NativeElement, Packed, Show, StyleChain};
-use crate::layout::{BlockElem, Dir, Spacing};
+use crate::foundations::{cast, elem, Content};
+use crate::layout::{Dir, Spacing};
 
 /// Arranges content and spacing horizontally or vertically.
 ///
@@ -19,7 +17,7 @@ use crate::layout::{BlockElem, Dir, Spacing};
 ///   rect(width: 90pt),
 /// )
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct StackElem {
     /// The direction along which the items are stacked. Possible values are:
     ///
@@ -47,14 +45,6 @@ pub struct StackElem {
     pub children: Vec<StackChild>,
 }
 
-impl Show for Packed<StackElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::multi_layouter(self.clone(), engine.routines.layout_stack)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// A child of a stack element.
 #[derive(Clone, PartialEq, Hash)]
 pub enum StackChild {
diff --git a/crates/typst-library/src/layout/transform.rs b/crates/typst-library/src/layout/transform.rs
index d153d97db..c2d9a21c7 100644
--- a/crates/typst-library/src/layout/transform.rs
+++ b/crates/typst-library/src/layout/transform.rs
@@ -1,11 +1,5 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    cast, elem, Content, NativeElement, Packed, Show, Smart, StyleChain,
-};
-use crate::layout::{
-    Abs, Alignment, Angle, BlockElem, HAlignment, Length, Ratio, Rel, VAlignment,
-};
+use crate::foundations::{cast, elem, Content, Smart};
+use crate::layout::{Abs, Alignment, Angle, HAlignment, Length, Ratio, Rel, VAlignment};
 
 /// Moves content without affecting layout.
 ///
@@ -25,7 +19,7 @@ use crate::layout::{
 ///   )
 /// ))
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct MoveElem {
     /// The horizontal displacement of the content.
     pub dx: Rel<Length>,
@@ -38,14 +32,6 @@ pub struct MoveElem {
     pub body: Content,
 }
 
-impl Show for Packed<MoveElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_move)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// Rotates content without affecting layout.
 ///
 /// Rotates an element by a given angle. The layout will act as if the element
@@ -60,7 +46,7 @@ impl Show for Packed<MoveElem> {
 ///     .map(i => rotate(24deg * i)[X]),
 /// )
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct RotateElem {
     /// The amount of rotation.
     ///
@@ -107,14 +93,6 @@ pub struct RotateElem {
     pub body: Content,
 }
 
-impl Show for Packed<RotateElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_rotate)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// Scales content without affecting layout.
 ///
 /// Lets you mirror content by specifying a negative scale on a single axis.
@@ -125,7 +103,7 @@ impl Show for Packed<RotateElem> {
 /// #scale(x: -100%)[This is mirrored.]
 /// #scale(x: -100%, reflow: true)[This is mirrored.]
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct ScaleElem {
     /// The scaling factor for both axes, as a positional argument. This is just
     /// an optional shorthand notation for setting `x` and `y` to the same
@@ -179,14 +157,6 @@ pub struct ScaleElem {
     pub body: Content,
 }
 
-impl Show for Packed<ScaleElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_scale)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// To what size something shall be scaled.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum ScaleAmount {
@@ -215,7 +185,7 @@ cast! {
 ///   This is some fake italic text.
 /// ]
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct SkewElem {
     /// The horizontal skewing angle.
     ///
@@ -265,14 +235,6 @@ pub struct SkewElem {
     pub body: Content,
 }
 
-impl Show for Packed<SkewElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_skew)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// A scale-skew-translate transformation.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Transform {
diff --git a/crates/typst-library/src/math/equation.rs b/crates/typst-library/src/math/equation.rs
index b97bb18da..0c9ba11df 100644
--- a/crates/typst-library/src/math/equation.rs
+++ b/crates/typst-library/src/math/equation.rs
@@ -6,13 +6,11 @@ use unicode_math_class::MathClass;
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, Show, ShowSet, Smart, StyleChain, Styles,
-    Synthesize,
+    elem, Content, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles, Synthesize,
 };
 use crate::introspection::{Count, Counter, CounterUpdate, Locatable};
 use crate::layout::{
-    AlignElem, Alignment, BlockElem, InlineElem, OuterHAlignment, SpecificAlignment,
-    VAlignment,
+    AlignElem, Alignment, BlockElem, OuterHAlignment, SpecificAlignment, VAlignment,
 };
 use crate::math::{MathSize, MathVariant};
 use crate::model::{Numbering, Outlinable, ParLine, Refable, Supplement};
@@ -46,7 +44,7 @@ use crate::text::{FontFamily, FontList, FontWeight, LocalName, TextElem};
 /// least one space lifts it into a separate block that is centered
 /// horizontally. For more details about math syntax, see the
 /// [main math page]($category/math).
-#[elem(Locatable, Synthesize, Show, ShowSet, Count, LocalName, Refable, Outlinable)]
+#[elem(Locatable, Synthesize, ShowSet, Count, LocalName, Refable, Outlinable)]
 pub struct EquationElem {
     /// Whether the equation is displayed as a separate block.
     #[default(false)]
@@ -165,23 +163,6 @@ impl Synthesize for Packed<EquationElem> {
     }
 }
 
-impl Show for Packed<EquationElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if self.block.get(styles) {
-            Ok(BlockElem::multi_layouter(
-                self.clone(),
-                engine.routines.layout_equation_block,
-            )
-            .pack()
-            .spanned(self.span()))
-        } else {
-            Ok(InlineElem::layouter(self.clone(), engine.routines.layout_equation_inline)
-                .pack()
-                .spanned(self.span()))
-        }
-    }
-}
-
 impl ShowSet for Packed<EquationElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index c44748a95..188af4da1 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -2,7 +2,6 @@ use std::any::TypeId;
 use std::collections::HashMap;
 use std::ffi::OsStr;
 use std::fmt::{self, Debug, Formatter};
-use std::num::NonZeroUsize;
 use std::path::Path;
 use std::sync::{Arc, LazyLock};
 
@@ -17,7 +16,7 @@ use hayagriva::{
 use indexmap::IndexMap;
 use smallvec::{smallvec, SmallVec};
 use typst_syntax::{Span, Spanned, SyntaxMode};
-use typst_utils::{Get, ManuallyHash, NonZeroExt, PicoStr};
+use typst_utils::{ManuallyHash, PicoStr};
 
 use crate::diag::{
     bail, error, At, HintedStrResult, LoadError, LoadResult, LoadedWithin, ReportPos,
@@ -26,18 +25,17 @@ use crate::diag::{
 use crate::engine::{Engine, Sink};
 use crate::foundations::{
     elem, Bytes, CastInfo, Content, Derived, FromValue, IntoValue, Label, NativeElement,
-    OneOrMultiple, Packed, Reflect, Scope, Show, ShowSet, Smart, StyleChain, Styles,
+    OneOrMultiple, Packed, Reflect, Scope, ShowSet, Smart, StyleChain, Styles,
     Synthesize, Value,
 };
 use crate::introspection::{Introspector, Locatable, Location};
 use crate::layout::{
     BlockBody, BlockElem, Em, GridCell, GridChild, GridElem, GridItem, HElem, PadElem,
-    Sides, Sizing, TrackSizings,
+    Sizing, TrackSizings,
 };
 use crate::loading::{format_yaml_error, DataSource, Load, LoadSource, Loaded};
 use crate::model::{
-    CitationForm, CiteGroup, Destination, FootnoteElem, HeadingElem, LinkElem, ParElem,
-    Url,
+    CitationForm, CiteGroup, Destination, FootnoteElem, HeadingElem, LinkElem, Url,
 };
 use crate::routines::Routines;
 use crate::text::{
@@ -88,7 +86,7 @@ use crate::World;
 ///
 /// #bibliography("works.bib")
 /// ```
-#[elem(Locatable, Synthesize, Show, ShowSet, LocalName)]
+#[elem(Locatable, Synthesize, ShowSet, LocalName)]
 pub struct BibliographyElem {
     /// One or multiple paths to or raw bytes for Hayagriva `.yaml` and/or
     /// BibLaTeX `.bib` files.
@@ -203,84 +201,6 @@ impl Synthesize for Packed<BibliographyElem> {
     }
 }
 
-impl Show for Packed<BibliographyElem> {
-    #[typst_macros::time(name = "bibliography", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        const COLUMN_GUTTER: Em = Em::new(0.65);
-        const INDENT: Em = Em::new(1.5);
-
-        let span = self.span();
-
-        let mut seq = vec![];
-        if let Some(title) = self.title.get_ref(styles).clone().unwrap_or_else(|| {
-            Some(TextElem::packed(Self::local_name_in(styles)).spanned(span))
-        }) {
-            seq.push(
-                HeadingElem::new(title)
-                    .with_depth(NonZeroUsize::ONE)
-                    .pack()
-                    .spanned(span),
-            );
-        }
-
-        let works = Works::generate(engine).at(span)?;
-        let references = works
-            .references
-            .as_ref()
-            .ok_or_else(|| match self.style.get_ref(styles).source {
-                CslSource::Named(style) => eco_format!(
-                    "CSL style \"{}\" is not suitable for bibliographies",
-                    style.display_name()
-                ),
-                CslSource::Normal(..) => {
-                    "CSL style is not suitable for bibliographies".into()
-                }
-            })
-            .at(span)?;
-
-        if references.iter().any(|(prefix, _)| prefix.is_some()) {
-            let row_gutter = styles.get(ParElem::spacing);
-
-            let mut cells = vec![];
-            for (prefix, reference) in references {
-                cells.push(GridChild::Item(GridItem::Cell(
-                    Packed::new(GridCell::new(prefix.clone().unwrap_or_default()))
-                        .spanned(span),
-                )));
-                cells.push(GridChild::Item(GridItem::Cell(
-                    Packed::new(GridCell::new(reference.clone())).spanned(span),
-                )));
-            }
-            seq.push(
-                GridElem::new(cells)
-                    .with_columns(TrackSizings(smallvec![Sizing::Auto; 2]))
-                    .with_column_gutter(TrackSizings(smallvec![COLUMN_GUTTER.into()]))
-                    .with_row_gutter(TrackSizings(smallvec![row_gutter.into()]))
-                    .pack()
-                    .spanned(span),
-            );
-        } else {
-            for (_, reference) in references {
-                let realized = reference.clone();
-                let block = if works.hanging_indent {
-                    let body = HElem::new((-INDENT).into()).pack() + realized;
-                    let inset = Sides::default()
-                        .with(styles.resolve(TextElem::dir).start(), Some(INDENT.into()));
-                    BlockElem::new()
-                        .with_body(Some(BlockBody::Content(body)))
-                        .with_inset(inset)
-                } else {
-                    BlockElem::new().with_body(Some(BlockBody::Content(realized)))
-                };
-
-                seq.push(block.pack().spanned(span));
-            }
-        }
-
-        Ok(Content::sequence(seq))
-    }
-}
-
 impl ShowSet for Packed<BibliographyElem> {
     fn show_set(&self, _: StyleChain) -> Styles {
         const INDENT: Em = Em::new(1.0);
@@ -564,7 +484,7 @@ impl IntoValue for CslSource {
 /// memoization) for the whole document. This setup is necessary because
 /// citation formatting is inherently stateful and we need access to all
 /// citations to do it.
-pub(super) struct Works {
+pub struct Works {
     /// Maps from the location of a citation group to its rendered content.
     pub citations: HashMap<Location, SourceResult<Content>>,
     /// Lists all references in the bibliography, with optional prefix, or
diff --git a/crates/typst-library/src/model/cite.rs b/crates/typst-library/src/model/cite.rs
index 195139907..b3ae3e522 100644
--- a/crates/typst-library/src/model/cite.rs
+++ b/crates/typst-library/src/model/cite.rs
@@ -3,8 +3,7 @@ use typst_syntax::Spanned;
 use crate::diag::{error, At, HintedString, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Cast, Content, Derived, Label, Packed, Show, Smart, StyleChain,
-    Synthesize,
+    cast, elem, Cast, Content, Derived, Label, Packed, Smart, StyleChain, Synthesize,
 };
 use crate::introspection::Locatable;
 use crate::model::bibliography::Works;
@@ -153,16 +152,15 @@ pub enum CitationForm {
 ///
 /// This is automatically created from adjacent citations during show rule
 /// application.
-#[elem(Locatable, Show)]
+#[elem(Locatable)]
 pub struct CiteGroup {
     /// The citations.
     #[required]
     pub children: Vec<Packed<CiteElem>>,
 }
 
-impl Show for Packed<CiteGroup> {
-    #[typst_macros::time(name = "cite", span = self.span())]
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
+impl Packed<CiteGroup> {
+    pub fn realize(&self, engine: &mut Engine) -> SourceResult<Content> {
         let location = self.location().unwrap();
         let span = self.span();
         Works::generate(engine)
diff --git a/crates/typst-library/src/model/emph.rs b/crates/typst-library/src/model/emph.rs
index 2d9cbec12..6267736b3 100644
--- a/crates/typst-library/src/model/emph.rs
+++ b/crates/typst-library/src/model/emph.rs
@@ -1,10 +1,4 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    elem, Content, NativeElement, Packed, Show, StyleChain, TargetElem,
-};
-use crate::html::{tag, HtmlElem};
-use crate::text::{ItalicToggle, TextElem};
+use crate::foundations::{elem, Content};
 
 /// Emphasizes content by toggling italics.
 ///
@@ -29,24 +23,9 @@ use crate::text::{ItalicToggle, TextElem};
 /// This function also has dedicated syntax: To emphasize content, simply
 /// enclose it in underscores (`_`). Note that this only works at word
 /// boundaries. To emphasize part of a word, you have to use the function.
-#[elem(title = "Emphasis", keywords = ["italic"], Show)]
+#[elem(title = "Emphasis", keywords = ["italic"])]
 pub struct EmphElem {
     /// The content to emphasize.
     #[required]
     pub body: Content,
 }
-
-impl Show for Packed<EmphElem> {
-    #[typst_macros::time(name = "emph", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let body = self.body.clone();
-        Ok(if styles.get(TargetElem::target).is_html() {
-            HtmlElem::new(tag::em)
-                .with_body(Some(body))
-                .pack()
-                .spanned(self.span())
-        } else {
-            body.set(TextElem::emph, ItalicToggle(true))
-        })
-    }
-}
diff --git a/crates/typst-library/src/model/enum.rs b/crates/typst-library/src/model/enum.rs
index 8c1916581..388fb9eda 100644
--- a/crates/typst-library/src/model/enum.rs
+++ b/crates/typst-library/src/model/enum.rs
@@ -1,19 +1,11 @@
 use std::str::FromStr;
 
-use ecow::eco_format;
 use smallvec::SmallVec;
 
-use crate::diag::{bail, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{
-    cast, elem, scope, Array, Content, NativeElement, Packed, Show, Smart, StyleChain,
-    Styles, TargetElem,
-};
-use crate::html::{attr, tag, HtmlElem};
-use crate::layout::{Alignment, BlockElem, Em, HAlignment, Length, VAlignment, VElem};
-use crate::model::{
-    ListItemLike, ListLike, Numbering, NumberingPattern, ParElem, ParbreakElem,
-};
+use crate::diag::bail;
+use crate::foundations::{cast, elem, scope, Array, Content, Packed, Smart, Styles};
+use crate::layout::{Alignment, Em, HAlignment, Length, VAlignment};
+use crate::model::{ListItemLike, ListLike, Numbering, NumberingPattern};
 
 /// A numbered list.
 ///
@@ -71,7 +63,7 @@ use crate::model::{
 /// Enumeration items can contain multiple paragraphs and other block-level
 /// content. All content that is indented more than an item's marker becomes
 /// part of that item.
-#[elem(scope, title = "Numbered List", Show)]
+#[elem(scope, title = "Numbered List")]
 pub struct EnumElem {
     /// Defines the default [spacing]($enum.spacing) of the enumeration. If it
     /// is `{false}`, the items are spaced apart with
@@ -223,51 +215,6 @@ impl EnumElem {
     type EnumItem;
 }
 
-impl Show for Packed<EnumElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let tight = self.tight.get(styles);
-
-        if styles.get(TargetElem::target).is_html() {
-            let mut elem = HtmlElem::new(tag::ol);
-            if self.reversed.get(styles) {
-                elem = elem.with_attr(attr::reversed, "reversed");
-            }
-            if let Some(n) = self.start.get(styles).custom() {
-                elem = elem.with_attr(attr::start, eco_format!("{n}"));
-            }
-            let body = Content::sequence(self.children.iter().map(|item| {
-                let mut li = HtmlElem::new(tag::li);
-                if let Some(nr) = item.number.get(styles) {
-                    li = li.with_attr(attr::value, eco_format!("{nr}"));
-                }
-                // Text in wide enums shall always turn into paragraphs.
-                let mut body = item.body.clone();
-                if !tight {
-                    body += ParbreakElem::shared();
-                }
-                li.with_body(Some(body)).pack().spanned(item.span())
-            }));
-            return Ok(elem.with_body(Some(body)).pack().spanned(self.span()));
-        }
-
-        let mut realized =
-            BlockElem::multi_layouter(self.clone(), engine.routines.layout_enum)
-                .pack()
-                .spanned(self.span());
-
-        if tight {
-            let spacing = self
-                .spacing
-                .get(styles)
-                .unwrap_or_else(|| styles.get(ParElem::leading));
-            let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
-            realized = v + realized;
-        }
-
-        Ok(realized)
-    }
-}
-
 /// An enumeration item.
 #[elem(name = "item", title = "Numbered List Item")]
 pub struct EnumItem {
diff --git a/crates/typst-library/src/model/figure.rs b/crates/typst-library/src/model/figure.rs
index 7ac659a93..ac3676eea 100644
--- a/crates/typst-library/src/model/figure.rs
+++ b/crates/typst-library/src/model/figure.rs
@@ -9,19 +9,16 @@ use crate::diag::{bail, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, scope, select_where, Content, Element, NativeElement, Packed, Selector,
-    Show, ShowSet, Smart, StyleChain, Styles, Synthesize, TargetElem,
+    ShowSet, Smart, StyleChain, Styles, Synthesize,
 };
-use crate::html::{tag, HtmlElem};
 use crate::introspection::{
     Count, Counter, CounterKey, CounterUpdate, Locatable, Location,
 };
 use crate::layout::{
-    AlignElem, Alignment, BlockBody, BlockElem, Em, HAlignment, Length, OuterVAlignment,
-    PlaceElem, PlacementScope, VAlignment, VElem,
-};
-use crate::model::{
-    Numbering, NumberingPattern, Outlinable, ParbreakElem, Refable, Supplement,
+    AlignElem, Alignment, BlockElem, Em, Length, OuterVAlignment, PlacementScope,
+    VAlignment,
 };
+use crate::model::{Numbering, NumberingPattern, Outlinable, Refable, Supplement};
 use crate::text::{Lang, Region, TextElem};
 use crate::visualize::ImageElem;
 
@@ -104,7 +101,7 @@ use crate::visualize::ImageElem;
 ///   caption: [I'm up here],
 /// )
 /// ```
-#[elem(scope, Locatable, Synthesize, Count, Show, ShowSet, Refable, Outlinable)]
+#[elem(scope, Locatable, Synthesize, Count, ShowSet, Refable, Outlinable)]
 pub struct FigureElem {
     /// The content of the figure. Often, an [image].
     #[required]
@@ -328,65 +325,6 @@ impl Synthesize for Packed<FigureElem> {
     }
 }
 
-impl Show for Packed<FigureElem> {
-    #[typst_macros::time(name = "figure", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let span = self.span();
-        let target = styles.get(TargetElem::target);
-        let mut realized = self.body.clone();
-
-        // Build the caption, if any.
-        if let Some(caption) = self.caption.get_cloned(styles) {
-            let (first, second) = match caption.position.get(styles) {
-                OuterVAlignment::Top => (caption.pack(), realized),
-                OuterVAlignment::Bottom => (realized, caption.pack()),
-            };
-            let mut seq = Vec::with_capacity(3);
-            seq.push(first);
-            if !target.is_html() {
-                let v = VElem::new(self.gap.get(styles).into()).with_weak(true);
-                seq.push(v.pack().spanned(span))
-            }
-            seq.push(second);
-            realized = Content::sequence(seq)
-        }
-
-        // Ensure that the body is considered a paragraph.
-        realized += ParbreakElem::shared().clone().spanned(span);
-
-        if target.is_html() {
-            return Ok(HtmlElem::new(tag::figure)
-                .with_body(Some(realized))
-                .pack()
-                .spanned(span));
-        }
-
-        // Wrap the contents in a block.
-        realized = BlockElem::new()
-            .with_body(Some(BlockBody::Content(realized)))
-            .pack()
-            .spanned(span);
-
-        // Wrap in a float.
-        if let Some(align) = self.placement.get(styles) {
-            realized = PlaceElem::new(realized)
-                .with_alignment(align.map(|align| HAlignment::Center + align))
-                .with_scope(self.scope.get(styles))
-                .with_float(true)
-                .pack()
-                .spanned(span);
-        } else if self.scope.get(styles) == PlacementScope::Parent {
-            bail!(
-                span,
-                "parent-scoped placement is only available for floating figures";
-                hint: "you can enable floating placement with `figure(placement: auto, ..)`"
-            );
-        }
-
-        Ok(realized)
-    }
-}
-
 impl ShowSet for Packed<FigureElem> {
     fn show_set(&self, _: StyleChain) -> Styles {
         // Still allows breakable figures with
@@ -471,7 +409,7 @@ impl Outlinable for Packed<FigureElem> {
 ///   caption: [A rectangle],
 /// )
 /// ```
-#[elem(name = "caption", Synthesize, Show)]
+#[elem(name = "caption", Synthesize)]
 pub struct FigureCaption {
     /// The caption's position in the figure. Either `{top}` or `{bottom}`.
     ///
@@ -559,6 +497,35 @@ pub struct FigureCaption {
 }
 
 impl FigureCaption {
+    /// Realizes the textual caption content.
+    pub fn realize(
+        &self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<Content> {
+        let mut realized = self.body.clone();
+
+        if let (
+            Some(Some(mut supplement)),
+            Some(Some(numbering)),
+            Some(Some(counter)),
+            Some(Some(location)),
+        ) = (
+            self.supplement.clone(),
+            &self.numbering,
+            &self.counter,
+            &self.figure_location,
+        ) {
+            let numbers = counter.display_at_loc(engine, *location, styles, numbering)?;
+            if !supplement.is_empty() {
+                supplement += TextElem::packed('\u{a0}');
+            }
+            realized = supplement + numbers + self.get_separator(styles) + realized;
+        }
+
+        Ok(realized)
+    }
+
     /// Gets the default separator in the given language and (optionally)
     /// region.
     fn local_separator(lang: Lang, _: Option<Region>) -> &'static str {
@@ -588,43 +555,6 @@ impl Synthesize for Packed<FigureCaption> {
     }
 }
 
-impl Show for Packed<FigureCaption> {
-    #[typst_macros::time(name = "figure.caption", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let mut realized = self.body.clone();
-
-        if let (
-            Some(Some(mut supplement)),
-            Some(Some(numbering)),
-            Some(Some(counter)),
-            Some(Some(location)),
-        ) = (
-            self.supplement.clone(),
-            &self.numbering,
-            &self.counter,
-            &self.figure_location,
-        ) {
-            let numbers = counter.display_at_loc(engine, *location, styles, numbering)?;
-            if !supplement.is_empty() {
-                supplement += TextElem::packed('\u{a0}');
-            }
-            realized = supplement + numbers + self.get_separator(styles) + realized;
-        }
-
-        Ok(if styles.get(TargetElem::target).is_html() {
-            HtmlElem::new(tag::figcaption)
-                .with_body(Some(realized))
-                .pack()
-                .spanned(self.span())
-        } else {
-            BlockElem::new()
-                .with_body(Some(BlockBody::Content(realized)))
-                .pack()
-                .spanned(self.span())
-        })
-    }
-}
-
 cast! {
     FigureCaption,
     v: Content => v.unpack::<Self>().unwrap_or_else(Self::new),
diff --git a/crates/typst-library/src/model/footnote.rs b/crates/typst-library/src/model/footnote.rs
index 63a461bd6..b920a8ae4 100644
--- a/crates/typst-library/src/model/footnote.rs
+++ b/crates/typst-library/src/model/footnote.rs
@@ -3,16 +3,16 @@ use std::str::FromStr;
 
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, At, SourceResult, StrResult};
+use crate::diag::{bail, StrResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, Content, Label, NativeElement, Packed, Show, ShowSet, Smart,
-    StyleChain, Styles,
+    cast, elem, scope, Content, Label, NativeElement, Packed, ShowSet, Smart, StyleChain,
+    Styles,
 };
-use crate::introspection::{Count, Counter, CounterUpdate, Locatable, Location};
-use crate::layout::{Abs, Em, HElem, Length, Ratio};
-use crate::model::{Destination, Numbering, NumberingPattern, ParElem};
-use crate::text::{SuperElem, TextElem, TextSize};
+use crate::introspection::{Count, CounterUpdate, Locatable, Location};
+use crate::layout::{Abs, Em, Length, Ratio};
+use crate::model::{Numbering, NumberingPattern, ParElem};
+use crate::text::{TextElem, TextSize};
 use crate::visualize::{LineElem, Stroke};
 
 /// A footnote.
@@ -51,7 +51,7 @@ use crate::visualize::{LineElem, Stroke};
 /// apply to the footnote's content. See [here][issue] for more information.
 ///
 /// [issue]: https://github.com/typst/typst/issues/1467#issuecomment-1588799440
-#[elem(scope, Locatable, Show, Count)]
+#[elem(scope, Locatable, Count)]
 pub struct FootnoteElem {
     /// How to number footnotes.
     ///
@@ -135,21 +135,6 @@ impl Packed<FootnoteElem> {
     }
 }
 
-impl Show for Packed<FootnoteElem> {
-    #[typst_macros::time(name = "footnote", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let span = self.span();
-        let loc = self.declaration_location(engine).at(span)?;
-        let numbering = self.numbering.get_ref(styles);
-        let counter = Counter::of(FootnoteElem::ELEM);
-        let num = counter.display_at_loc(engine, loc, styles, numbering)?;
-        let sup = SuperElem::new(num).pack().spanned(span);
-        let loc = loc.variant(1);
-        // Add zero-width weak spacing to make the footnote "sticky".
-        Ok(HElem::hole().pack() + sup.linked(Destination::Location(loc)))
-    }
-}
-
 impl Count for Packed<FootnoteElem> {
     fn update(&self) -> Option<CounterUpdate> {
         (!self.is_ref()).then(|| CounterUpdate::Step(NonZeroUsize::ONE))
@@ -191,7 +176,7 @@ cast! {
 /// page run is a sequence of pages without an explicit pagebreak in between).
 /// For this reason, set and show rules for footnote entries should be defined
 /// before any page content, typically at the very start of the document.
-#[elem(name = "entry", title = "Footnote Entry", Show, ShowSet)]
+#[elem(name = "entry", title = "Footnote Entry", ShowSet)]
 pub struct FootnoteEntry {
     /// The footnote for this entry. Its location can be used to determine
     /// the footnote counter state.
@@ -274,37 +259,6 @@ pub struct FootnoteEntry {
     pub indent: Length,
 }
 
-impl Show for Packed<FootnoteEntry> {
-    #[typst_macros::time(name = "footnote.entry", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let span = self.span();
-        let number_gap = Em::new(0.05);
-        let default = StyleChain::default();
-        let numbering = self.note.numbering.get_ref(default);
-        let counter = Counter::of(FootnoteElem::ELEM);
-        let Some(loc) = self.note.location() else {
-            bail!(
-                span, "footnote entry must have a location";
-                hint: "try using a query or a show rule to customize the footnote instead"
-            );
-        };
-
-        let num = counter.display_at_loc(engine, loc, styles, numbering)?;
-        let sup = SuperElem::new(num)
-            .pack()
-            .spanned(span)
-            .linked(Destination::Location(loc))
-            .located(loc.variant(1));
-
-        Ok(Content::sequence([
-            HElem::new(self.indent.get(styles).into()).pack(),
-            sup,
-            HElem::new(number_gap.into()).with_weak(true).pack(),
-            self.note.body_content().unwrap().clone(),
-        ]))
-    }
-}
-
 impl ShowSet for Packed<FootnoteEntry> {
     fn show_set(&self, _: StyleChain) -> Styles {
         let mut out = Styles::new();
diff --git a/crates/typst-library/src/model/heading.rs b/crates/typst-library/src/model/heading.rs
index d6f6d01f9..0f2a1d338 100644
--- a/crates/typst-library/src/model/heading.rs
+++ b/crates/typst-library/src/model/heading.rs
@@ -1,21 +1,16 @@
 use std::num::NonZeroUsize;
 
-use ecow::eco_format;
-use typst_utils::{Get, NonZeroExt};
+use typst_utils::NonZeroExt;
 
-use crate::diag::{warning, SourceResult};
+use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, Resolve, Show, ShowSet, Smart, StyleChain,
-    Styles, Synthesize, TargetElem,
+    elem, Content, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles, Synthesize,
 };
-use crate::html::{attr, tag, HtmlElem};
-use crate::introspection::{
-    Count, Counter, CounterUpdate, Locatable, Locator, LocatorLink,
-};
-use crate::layout::{Abs, Axes, BlockBody, BlockElem, Em, HElem, Length, Region, Sides};
+use crate::introspection::{Count, Counter, CounterUpdate, Locatable};
+use crate::layout::{BlockElem, Em, Length};
 use crate::model::{Numbering, Outlinable, Refable, Supplement};
-use crate::text::{FontWeight, LocalName, SpaceElem, TextElem, TextSize};
+use crate::text::{FontWeight, LocalName, TextElem, TextSize};
 
 /// A section heading.
 ///
@@ -49,7 +44,7 @@ use crate::text::{FontWeight, LocalName, SpaceElem, TextElem, TextSize};
 /// one or multiple equals signs, followed by a space. The number of equals
 /// signs determines the heading's logical nesting depth. The `{offset}` field
 /// can be set to configure the starting depth.
-#[elem(Locatable, Synthesize, Count, Show, ShowSet, LocalName, Refable, Outlinable)]
+#[elem(Locatable, Synthesize, Count, ShowSet, LocalName, Refable, Outlinable)]
 pub struct HeadingElem {
     /// The absolute nesting depth of the heading, starting from one. If set
     /// to `{auto}`, it is computed from `{offset + depth}`.
@@ -215,96 +210,6 @@ impl Synthesize for Packed<HeadingElem> {
     }
 }
 
-impl Show for Packed<HeadingElem> {
-    #[typst_macros::time(name = "heading", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let html = styles.get(TargetElem::target).is_html();
-
-        const SPACING_TO_NUMBERING: Em = Em::new(0.3);
-
-        let span = self.span();
-        let mut realized = self.body.clone();
-
-        let hanging_indent = self.hanging_indent.get(styles);
-        let mut indent = match hanging_indent {
-            Smart::Custom(length) => length.resolve(styles),
-            Smart::Auto => Abs::zero(),
-        };
-
-        if let Some(numbering) = self.numbering.get_ref(styles).as_ref() {
-            let location = self.location().unwrap();
-            let numbering = Counter::of(HeadingElem::ELEM)
-                .display_at_loc(engine, location, styles, numbering)?
-                .spanned(span);
-
-            if hanging_indent.is_auto() && !html {
-                let pod = Region::new(Axes::splat(Abs::inf()), Axes::splat(false));
-
-                // We don't have a locator for the numbering here, so we just
-                // use the measurement infrastructure for now.
-                let link = LocatorLink::measure(location);
-                let size = (engine.routines.layout_frame)(
-                    engine,
-                    &numbering,
-                    Locator::link(&link),
-                    styles,
-                    pod,
-                )?
-                .size();
-
-                indent = size.x + SPACING_TO_NUMBERING.resolve(styles);
-            }
-
-            let spacing = if html {
-                SpaceElem::shared().clone()
-            } else {
-                HElem::new(SPACING_TO_NUMBERING.into()).with_weak(true).pack()
-            };
-
-            realized = numbering + spacing + realized;
-        }
-
-        Ok(if html {
-            // HTML's h1 is closer to a title element. There should only be one.
-            // Meanwhile, a level 1 Typst heading is a section heading. For this
-            // reason, levels are offset by one: A Typst level 1 heading becomes
-            // a `<h2>`.
-            let level = self.resolve_level(styles).get();
-            if level >= 6 {
-                engine.sink.warn(warning!(span,
-                    "heading of level {} was transformed to \
-                    <div role=\"heading\" aria-level=\"{}\">, which is not \
-                    supported by all assistive technology",
-                    level, level + 1;
-                    hint: "HTML only supports <h1> to <h6>, not <h{}>", level + 1;
-                    hint: "you may want to restructure your document so that \
-                          it doesn't contain deep headings"));
-                HtmlElem::new(tag::div)
-                    .with_body(Some(realized))
-                    .with_attr(attr::role, "heading")
-                    .with_attr(attr::aria_level, eco_format!("{}", level + 1))
-                    .pack()
-                    .spanned(span)
-            } else {
-                let t = [tag::h2, tag::h3, tag::h4, tag::h5, tag::h6][level - 1];
-                HtmlElem::new(t).with_body(Some(realized)).pack().spanned(span)
-            }
-        } else {
-            let block = if indent != Abs::zero() {
-                let body = HElem::new((-indent).into()).pack() + realized;
-                let inset = Sides::default()
-                    .with(styles.resolve(TextElem::dir).start(), Some(indent.into()));
-                BlockElem::new()
-                    .with_body(Some(BlockBody::Content(body)))
-                    .with_inset(inset)
-            } else {
-                BlockElem::new().with_body(Some(BlockBody::Content(realized)))
-            };
-            block.pack().spanned(span)
-        })
-    }
-}
-
 impl ShowSet for Packed<HeadingElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let level = self.resolve_level(styles).get();
diff --git a/crates/typst-library/src/model/link.rs b/crates/typst-library/src/model/link.rs
index 1e2c708e8..c630835e0 100644
--- a/crates/typst-library/src/model/link.rs
+++ b/crates/typst-library/src/model/link.rs
@@ -2,13 +2,10 @@ use std::ops::Deref;
 
 use ecow::{eco_format, EcoString};
 
-use crate::diag::{bail, warning, At, SourceResult, StrResult};
-use crate::engine::Engine;
+use crate::diag::{bail, StrResult};
 use crate::foundations::{
-    cast, elem, Content, Label, NativeElement, Packed, Repr, Show, ShowSet, Smart,
-    StyleChain, Styles, TargetElem,
+    cast, elem, Content, Label, Packed, Repr, ShowSet, Smart, StyleChain, Styles,
 };
-use crate::html::{attr, tag, HtmlElem};
 use crate::introspection::Location;
 use crate::layout::Position;
 use crate::text::TextElem;
@@ -38,7 +35,7 @@ use crate::text::TextElem;
 /// # Syntax
 /// This function also has dedicated syntax: Text that starts with `http://` or
 /// `https://` is automatically turned into a link.
-#[elem(Show)]
+#[elem]
 pub struct LinkElem {
     /// The destination the link points to.
     ///
@@ -103,38 +100,6 @@ impl LinkElem {
     }
 }
 
-impl Show for Packed<LinkElem> {
-    #[typst_macros::time(name = "link", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let body = self.body.clone();
-
-        Ok(if styles.get(TargetElem::target).is_html() {
-            if let LinkTarget::Dest(Destination::Url(url)) = &self.dest {
-                HtmlElem::new(tag::a)
-                    .with_attr(attr::href, url.clone().into_inner())
-                    .with_body(Some(body))
-                    .pack()
-                    .spanned(self.span())
-            } else {
-                engine.sink.warn(warning!(
-                    self.span(),
-                    "non-URL links are not yet supported by HTML export"
-                ));
-                body
-            }
-        } else {
-            match &self.dest {
-                LinkTarget::Dest(dest) => body.linked(dest.clone()),
-                LinkTarget::Label(label) => {
-                    let elem = engine.introspector.query_label(*label).at(self.span())?;
-                    let dest = Destination::Location(elem.location().unwrap());
-                    body.clone().linked(dest)
-                }
-            }
-        })
-    }
-}
-
 impl ShowSet for Packed<LinkElem> {
     fn show_set(&self, _: StyleChain) -> Styles {
         let mut out = Styles::new();
diff --git a/crates/typst-library/src/model/list.rs b/crates/typst-library/src/model/list.rs
index 5e6db1faa..660716de7 100644
--- a/crates/typst-library/src/model/list.rs
+++ b/crates/typst-library/src/model/list.rs
@@ -3,12 +3,10 @@ use comemo::Track;
 use crate::diag::{bail, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, Array, Content, Context, Depth, Func, NativeElement, Packed, Show,
-    Smart, StyleChain, Styles, TargetElem, Value,
+    cast, elem, scope, Array, Content, Context, Depth, Func, NativeElement, Packed,
+    Smart, StyleChain, Styles, Value,
 };
-use crate::html::{tag, HtmlElem};
-use crate::layout::{BlockElem, Em, Length, VElem};
-use crate::model::{ParElem, ParbreakElem};
+use crate::layout::{Em, Length};
 use crate::text::TextElem;
 
 /// A bullet list.
@@ -42,7 +40,7 @@ use crate::text::TextElem;
 /// followed by a space to create a list item. A list item can contain multiple
 /// paragraphs and other block-level content. All content that is indented
 /// more than an item's marker becomes part of that item.
-#[elem(scope, title = "Bullet List", Show)]
+#[elem(scope, title = "Bullet List")]
 pub struct ListElem {
     /// Defines the default [spacing]($list.spacing) of the list. If it is
     /// `{false}`, the items are spaced apart with
@@ -136,45 +134,6 @@ impl ListElem {
     type ListItem;
 }
 
-impl Show for Packed<ListElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let tight = self.tight.get(styles);
-
-        if styles.get(TargetElem::target).is_html() {
-            return Ok(HtmlElem::new(tag::ul)
-                .with_body(Some(Content::sequence(self.children.iter().map(|item| {
-                    // Text in wide lists shall always turn into paragraphs.
-                    let mut body = item.body.clone();
-                    if !tight {
-                        body += ParbreakElem::shared();
-                    }
-                    HtmlElem::new(tag::li)
-                        .with_body(Some(body))
-                        .pack()
-                        .spanned(item.span())
-                }))))
-                .pack()
-                .spanned(self.span()));
-        }
-
-        let mut realized =
-            BlockElem::multi_layouter(self.clone(), engine.routines.layout_list)
-                .pack()
-                .spanned(self.span());
-
-        if tight {
-            let spacing = self
-                .spacing
-                .get(styles)
-                .unwrap_or_else(|| styles.get(ParElem::leading));
-            let v = VElem::new(spacing.into()).with_weak(true).with_attach(true).pack();
-            realized = v + realized;
-        }
-
-        Ok(realized)
-    }
-}
-
 /// A bullet list item.
 #[elem(name = "item", title = "Bullet List Item")]
 pub struct ListItem {
diff --git a/crates/typst-library/src/model/mod.rs b/crates/typst-library/src/model/mod.rs
index 9bdbf0013..a0f7e11af 100644
--- a/crates/typst-library/src/model/mod.rs
+++ b/crates/typst-library/src/model/mod.rs
@@ -46,23 +46,23 @@ use crate::foundations::Scope;
 pub fn define(global: &mut Scope) {
     global.start_category(crate::Category::Model);
     global.define_elem::<DocumentElem>();
-    global.define_elem::<RefElem>();
+    global.define_elem::<ParElem>();
+    global.define_elem::<ParbreakElem>();
+    global.define_elem::<StrongElem>();
+    global.define_elem::<EmphElem>();
+    global.define_elem::<ListElem>();
+    global.define_elem::<EnumElem>();
+    global.define_elem::<TermsElem>();
     global.define_elem::<LinkElem>();
-    global.define_elem::<OutlineElem>();
     global.define_elem::<HeadingElem>();
     global.define_elem::<FigureElem>();
-    global.define_elem::<FootnoteElem>();
     global.define_elem::<QuoteElem>();
+    global.define_elem::<FootnoteElem>();
+    global.define_elem::<OutlineElem>();
+    global.define_elem::<RefElem>();
     global.define_elem::<CiteElem>();
     global.define_elem::<BibliographyElem>();
-    global.define_elem::<EnumElem>();
-    global.define_elem::<ListElem>();
-    global.define_elem::<ParbreakElem>();
-    global.define_elem::<ParElem>();
     global.define_elem::<TableElem>();
-    global.define_elem::<TermsElem>();
-    global.define_elem::<EmphElem>();
-    global.define_elem::<StrongElem>();
     global.define_func::<numbering>();
     global.reset_category();
 }
diff --git a/crates/typst-library/src/model/outline.rs b/crates/typst-library/src/model/outline.rs
index bb061fb7b..4bda02ba3 100644
--- a/crates/typst-library/src/model/outline.rs
+++ b/crates/typst-library/src/model/outline.rs
@@ -1,7 +1,7 @@
 use std::num::NonZeroUsize;
 use std::str::FromStr;
 
-use comemo::{Track, Tracked};
+use comemo::Tracked;
 use smallvec::SmallVec;
 use typst_syntax::Span;
 use typst_utils::{Get, NonZeroExt};
@@ -10,7 +10,7 @@ use crate::diag::{bail, error, At, HintedStrResult, SourceResult, StrResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, func, scope, select_where, Args, Construct, Content, Context, Func,
-    LocatableSelector, NativeElement, Packed, Resolve, Show, ShowSet, Smart, StyleChain,
+    LocatableSelector, NativeElement, Packed, Resolve, ShowSet, Smart, StyleChain,
     Styles,
 };
 use crate::introspection::{
@@ -20,8 +20,7 @@ use crate::layout::{
     Abs, Axes, BlockBody, BlockElem, BoxElem, Dir, Em, Fr, HElem, Length, Region, Rel,
     RepeatElem, Sides,
 };
-use crate::math::EquationElem;
-use crate::model::{Destination, HeadingElem, NumberingPattern, ParElem, Refable};
+use crate::model::{HeadingElem, NumberingPattern, ParElem, Refable};
 use crate::text::{LocalName, SpaceElem, TextElem};
 
 /// A table of contents, figures, or other elements.
@@ -147,7 +146,7 @@ use crate::text::{LocalName, SpaceElem, TextElem};
 ///
 /// [^1]: The outline of equations is the exception to this rule as it does not
 ///       have a body and thus does not use indented layout.
-#[elem(scope, keywords = ["Table of Contents", "toc"], Show, ShowSet, LocalName, Locatable)]
+#[elem(scope, keywords = ["Table of Contents", "toc"], ShowSet, LocalName, Locatable)]
 pub struct OutlineElem {
     /// The title of the outline.
     ///
@@ -249,44 +248,6 @@ impl OutlineElem {
     type OutlineEntry;
 }
 
-impl Show for Packed<OutlineElem> {
-    #[typst_macros::time(name = "outline", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let span = self.span();
-
-        // Build the outline title.
-        let mut seq = vec![];
-        if let Some(title) = self.title.get_cloned(styles).unwrap_or_else(|| {
-            Some(TextElem::packed(Self::local_name_in(styles)).spanned(span))
-        }) {
-            seq.push(
-                HeadingElem::new(title)
-                    .with_depth(NonZeroUsize::ONE)
-                    .pack()
-                    .spanned(span),
-            );
-        }
-
-        let elems = engine.introspector.query(&self.target.get_ref(styles).0);
-        let depth = self.depth.get(styles).unwrap_or(NonZeroUsize::MAX);
-
-        // Build the outline entries.
-        for elem in elems {
-            let Some(outlinable) = elem.with::<dyn Outlinable>() else {
-                bail!(span, "cannot outline {}", elem.func().name());
-            };
-
-            let level = outlinable.level();
-            if outlinable.outlined() && level <= depth {
-                let entry = OutlineEntry::new(level, elem);
-                seq.push(entry.pack().spanned(span));
-            }
-        }
-
-        Ok(Content::sequence(seq))
-    }
-}
-
 impl ShowSet for Packed<OutlineElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
@@ -363,7 +324,7 @@ pub trait Outlinable: Refable {
 /// With show-set and show rules on outline entries, you can richly customize
 /// the outline's appearance. See the
 /// [section on styling the outline]($outline/#styling-the-outline) for details.
-#[elem(scope, name = "entry", title = "Outline Entry", Show)]
+#[elem(scope, name = "entry", title = "Outline Entry")]
 pub struct OutlineEntry {
     /// The nesting level of this outline entry. Starts at `{1}` for top-level
     /// entries.
@@ -408,30 +369,6 @@ pub struct OutlineEntry {
     pub parent: Option<Packed<OutlineElem>>,
 }
 
-impl Show for Packed<OutlineEntry> {
-    #[typst_macros::time(name = "outline.entry", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let span = self.span();
-        let context = Context::new(None, Some(styles));
-        let context = context.track();
-
-        let prefix = self.prefix(engine, context, span)?;
-        let inner = self.inner(engine, context, span)?;
-        let block = if self.element.is::<EquationElem>() {
-            let body = prefix.unwrap_or_default() + inner;
-            BlockElem::new()
-                .with_body(Some(BlockBody::Content(body)))
-                .pack()
-                .spanned(span)
-        } else {
-            self.indented(engine, context, span, prefix, inner, Em::new(0.5).into())?
-        };
-
-        let loc = self.element_location().at(span)?;
-        Ok(block.linked(Destination::Location(loc)))
-    }
-}
-
 #[scope]
 impl OutlineEntry {
     /// A helper function for producing an indented entry layout: Lays out a
@@ -654,7 +591,8 @@ impl OutlineEntry {
             .ok_or_else(|| error!("cannot outline {}", self.element.func().name()))
     }
 
-    fn element_location(&self) -> HintedStrResult<Location> {
+    /// Returns the location of the outlined element.
+    pub fn element_location(&self) -> HintedStrResult<Location> {
         let elem = &self.element;
         elem.location().ok_or_else(|| {
             if elem.can::<dyn Locatable>() && elem.can::<dyn Outlinable>() {
@@ -730,8 +668,8 @@ fn query_prefix_widths(
 }
 
 /// Helper type for introspection-based prefix alignment.
-#[elem(Construct, Locatable, Show)]
-struct PrefixInfo {
+#[elem(Construct, Locatable)]
+pub(crate) struct PrefixInfo {
     /// The location of the outline this prefix is part of. This is used to
     /// scope prefix computations to a specific outline.
     #[required]
@@ -753,9 +691,3 @@ impl Construct for PrefixInfo {
         bail!(args.span, "cannot be constructed manually");
     }
 }
-
-impl Show for Packed<PrefixInfo> {
-    fn show(&self, _: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(Content::empty())
-    }
-}
diff --git a/crates/typst-library/src/model/quote.rs b/crates/typst-library/src/model/quote.rs
index a8cf3eaef..9960b7587 100644
--- a/crates/typst-library/src/model/quote.rs
+++ b/crates/typst-library/src/model/quote.rs
@@ -1,16 +1,13 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
+use typst_syntax::Span;
+
 use crate::foundations::{
-    cast, elem, Content, Depth, Label, NativeElement, Packed, Show, ShowSet, Smart,
-    StyleChain, Styles, TargetElem,
+    cast, elem, Content, Depth, Label, NativeElement, Packed, ShowSet, Smart, StyleChain,
+    Styles,
 };
-use crate::html::{attr, tag, HtmlElem};
 use crate::introspection::Locatable;
-use crate::layout::{
-    Alignment, BlockBody, BlockElem, Em, HElem, PadElem, Spacing, VElem,
-};
-use crate::model::{CitationForm, CiteElem, Destination, LinkElem, LinkTarget};
-use crate::text::{SmartQuoteElem, SmartQuotes, SpaceElem, TextElem};
+use crate::layout::{BlockElem, Em, PadElem};
+use crate::model::{CitationForm, CiteElem};
+use crate::text::{SmartQuotes, SpaceElem, TextElem};
 
 /// Displays a quote alongside an optional attribution.
 ///
@@ -44,7 +41,7 @@ use crate::text::{SmartQuoteElem, SmartQuotes, SpaceElem, TextElem};
 ///   flame of Udûn. Go back to the Shadow! You cannot pass.
 /// ]
 /// ```
-#[elem(Locatable, ShowSet, Show)]
+#[elem(Locatable, ShowSet)]
 pub struct QuoteElem {
     /// Whether this is a block quote.
     ///
@@ -62,7 +59,7 @@ pub struct QuoteElem {
     ///   Ich bin ein Berliner.
     /// ]
     /// ```
-    block: bool,
+    pub block: bool,
 
     /// Whether double quotes should be added around this quote.
     ///
@@ -88,7 +85,7 @@ pub struct QuoteElem {
     /// translate the quote:
     /// #quote[I am a Berliner.]
     /// ```
-    quotes: Smart<bool>,
+    pub quotes: Smart<bool>,
 
     /// The attribution of this quote, usually the author or source. Can be a
     /// label pointing to a bibliography entry or any content. By default only
@@ -123,17 +120,36 @@ pub struct QuoteElem {
     ///
     /// #bibliography("works.bib", style: "apa")
     /// ```
-    attribution: Option<Attribution>,
+    pub attribution: Option<Attribution>,
 
     /// The quote.
     #[required]
-    body: Content,
+    pub body: Content,
 
     /// The nesting depth.
     #[internal]
     #[fold]
     #[ghost]
-    depth: Depth,
+    pub depth: Depth,
+}
+
+impl QuoteElem {
+    /// Quotes the body content with the appropriate quotes based on the current
+    /// styles and surroundings.
+    pub fn quoted(body: Content, styles: StyleChain<'_>) -> Content {
+        let quotes = SmartQuotes::get_in(styles);
+
+        // Alternate between single and double quotes.
+        let Depth(depth) = styles.get(QuoteElem::depth);
+        let double = depth % 2 == 0;
+
+        Content::sequence([
+            TextElem::packed(quotes.open(double)),
+            body,
+            TextElem::packed(quotes.close(double)),
+        ])
+        .set(QuoteElem::depth, Depth(1))
+    }
 }
 
 /// Attribution for a [quote](QuoteElem).
@@ -143,6 +159,23 @@ pub enum Attribution {
     Label(Label),
 }
 
+impl Attribution {
+    /// Realize as an em dash followed by text or a citation.
+    pub fn realize(&self, span: Span) -> Content {
+        Content::sequence([
+            TextElem::packed('—'),
+            SpaceElem::shared().clone(),
+            match self {
+                Attribution::Content(content) => content.clone(),
+                Attribution::Label(label) => CiteElem::new(*label)
+                    .with_form(Some(CitationForm::Prose))
+                    .pack()
+                    .spanned(span),
+            },
+        ])
+    }
+}
+
 cast! {
     Attribution,
     self => match self {
@@ -153,96 +186,6 @@ cast! {
     label: Label => Self::Label(label),
 }
 
-impl Show for Packed<QuoteElem> {
-    #[typst_macros::time(name = "quote", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let mut realized = self.body.clone();
-        let block = self.block.get(styles);
-        let html = styles.get(TargetElem::target).is_html();
-
-        if self.quotes.get(styles).unwrap_or(!block) {
-            let quotes = SmartQuotes::get(
-                styles.get_ref(SmartQuoteElem::quotes),
-                styles.get(TextElem::lang),
-                styles.get(TextElem::region),
-                styles.get(SmartQuoteElem::alternative),
-            );
-
-            // Alternate between single and double quotes.
-            let Depth(depth) = styles.get(QuoteElem::depth);
-            let double = depth % 2 == 0;
-
-            if !html {
-                // Add zero-width weak spacing to make the quotes "sticky".
-                let hole = HElem::hole().pack();
-                realized = Content::sequence([hole.clone(), realized, hole]);
-            }
-            realized = Content::sequence([
-                TextElem::packed(quotes.open(double)),
-                realized,
-                TextElem::packed(quotes.close(double)),
-            ])
-            .set(QuoteElem::depth, Depth(1));
-        }
-
-        let attribution = self.attribution.get_ref(styles);
-
-        if block {
-            realized = if html {
-                let mut elem = HtmlElem::new(tag::blockquote).with_body(Some(realized));
-                if let Some(Attribution::Content(attribution)) = attribution {
-                    if let Some(link) = attribution.to_packed::<LinkElem>() {
-                        if let LinkTarget::Dest(Destination::Url(url)) = &link.dest {
-                            elem = elem.with_attr(attr::cite, url.clone().into_inner());
-                        }
-                    }
-                }
-                elem.pack()
-            } else {
-                BlockElem::new().with_body(Some(BlockBody::Content(realized))).pack()
-            }
-            .spanned(self.span());
-
-            if let Some(attribution) = attribution {
-                let attribution = match attribution {
-                    Attribution::Content(content) => content.clone(),
-                    Attribution::Label(label) => CiteElem::new(*label)
-                        .with_form(Some(CitationForm::Prose))
-                        .pack()
-                        .spanned(self.span()),
-                };
-                let attribution = Content::sequence([
-                    TextElem::packed('—'),
-                    SpaceElem::shared().clone(),
-                    attribution,
-                ]);
-
-                if html {
-                    realized += attribution;
-                } else {
-                    // Bring the attribution a bit closer to the quote.
-                    let gap = Spacing::Rel(Em::new(0.9).into());
-                    let v = VElem::new(gap).with_weak(true).pack();
-                    realized += v;
-                    realized += BlockElem::new()
-                        .with_body(Some(BlockBody::Content(attribution)))
-                        .pack()
-                        .aligned(Alignment::END);
-                }
-            }
-
-            if !html {
-                realized = PadElem::new(realized).pack();
-            }
-        } else if let Some(Attribution::Label(label)) = attribution {
-            realized += SpaceElem::shared().clone()
-                + CiteElem::new(*label).pack().spanned(self.span());
-        }
-
-        Ok(realized)
-    }
-}
-
 impl ShowSet for Packed<QuoteElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index 2d04a97a4..4877409fa 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -5,7 +5,7 @@ use crate::diag::{bail, At, Hint, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Cast, Content, Context, Func, IntoValue, Label, NativeElement, Packed,
-    Repr, Show, Smart, StyleChain, Synthesize,
+    Repr, Smart, StyleChain, Synthesize,
 };
 use crate::introspection::{Counter, CounterKey, Locatable};
 use crate::math::EquationElem;
@@ -134,7 +134,7 @@ use crate::text::TextElem;
 /// In @beginning we prove @pythagoras.
 /// $ a^2 + b^2 = c^2 $ <pythagoras>
 /// ```
-#[elem(title = "Reference", Synthesize, Locatable, Show)]
+#[elem(title = "Reference", Synthesize, Locatable)]
 pub struct RefElem {
     /// The target label that should be referenced.
     ///
@@ -220,9 +220,13 @@ impl Synthesize for Packed<RefElem> {
     }
 }
 
-impl Show for Packed<RefElem> {
-    #[typst_macros::time(name = "ref", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
+impl Packed<RefElem> {
+    /// Realize as a linked, textual reference.
+    pub fn realize(
+        &self,
+        engine: &mut Engine,
+        styles: StyleChain,
+    ) -> SourceResult<Content> {
         let elem = engine.introspector.query_label(self.target);
         let span = self.span();
 
@@ -242,7 +246,7 @@ impl Show for Packed<RefElem> {
                 .at(span)?;
             let supplement = engine.introspector.page_supplement(loc);
 
-            return show_reference(
+            return realize_reference(
                 self,
                 engine,
                 styles,
@@ -306,7 +310,7 @@ impl Show for Packed<RefElem> {
             ))
             .at(span)?;
 
-        show_reference(
+        realize_reference(
             self,
             engine,
             styles,
@@ -319,7 +323,7 @@ impl Show for Packed<RefElem> {
 }
 
 /// Show a reference.
-fn show_reference(
+fn realize_reference(
     reference: &Packed<RefElem>,
     engine: &mut Engine,
     styles: StyleChain,
diff --git a/crates/typst-library/src/model/strong.rs b/crates/typst-library/src/model/strong.rs
index 08cf48391..7751c95bc 100644
--- a/crates/typst-library/src/model/strong.rs
+++ b/crates/typst-library/src/model/strong.rs
@@ -1,10 +1,4 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    elem, Content, NativeElement, Packed, Show, StyleChain, TargetElem,
-};
-use crate::html::{tag, HtmlElem};
-use crate::text::{TextElem, WeightDelta};
+use crate::foundations::{elem, Content};
 
 /// Strongly emphasizes content by increasing the font weight.
 ///
@@ -24,7 +18,7 @@ use crate::text::{TextElem, WeightDelta};
 /// simply enclose it in stars/asterisks (`*`). Note that this only works at
 /// word boundaries. To strongly emphasize part of a word, you have to use the
 /// function.
-#[elem(title = "Strong Emphasis", keywords = ["bold", "weight"], Show)]
+#[elem(title = "Strong Emphasis", keywords = ["bold", "weight"])]
 pub struct StrongElem {
     /// The delta to apply on the font weight.
     ///
@@ -39,18 +33,3 @@ pub struct StrongElem {
     #[required]
     pub body: Content,
 }
-
-impl Show for Packed<StrongElem> {
-    #[typst_macros::time(name = "strong", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let body = self.body.clone();
-        Ok(if styles.get(TargetElem::target).is_html() {
-            HtmlElem::new(tag::strong)
-                .with_body(Some(body))
-                .pack()
-                .spanned(self.span())
-        } else {
-            body.set(TextElem::delta, WeightDelta(self.delta.get(styles)))
-        })
-    }
-}
diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index 72c5acc5d..e46efc818 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -3,19 +3,11 @@ use std::sync::Arc;
 
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, HintedStrResult, HintedString, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{
-    cast, elem, scope, Content, NativeElement, Packed, Show, Smart, StyleChain,
-    TargetElem,
-};
-use crate::html::{attr, tag, HtmlAttrs, HtmlElem, HtmlTag};
-use crate::introspection::Locator;
-use crate::layout::grid::resolve::{table_to_cellgrid, Cell, CellGrid, Entry};
+use crate::diag::{bail, HintedStrResult, HintedString};
+use crate::foundations::{cast, elem, scope, Content, Packed, Smart};
 use crate::layout::{
-    show_grid_cell, Abs, Alignment, BlockElem, Celled, GridCell, GridFooter, GridHLine,
-    GridHeader, GridVLine, Length, OuterHAlignment, OuterVAlignment, Rel, Sides,
-    TrackSizings,
+    Abs, Alignment, Celled, GridCell, GridFooter, GridHLine, GridHeader, GridVLine,
+    Length, OuterHAlignment, OuterVAlignment, Rel, Sides, TrackSizings,
 };
 use crate::model::Figurable;
 use crate::text::LocalName;
@@ -121,7 +113,7 @@ use crate::visualize::{Paint, Stroke};
 ///   [Robert], b, a, b,
 /// )
 /// ```
-#[elem(scope, Show, LocalName, Figurable)]
+#[elem(scope, LocalName, Figurable)]
 pub struct TableElem {
     /// The column sizes. See the [grid documentation]($grid) for more
     /// information on track sizing.
@@ -255,113 +247,6 @@ impl TableElem {
     type TableFooter;
 }
 
-fn show_cell_html(tag: HtmlTag, cell: &Cell, styles: StyleChain) -> Content {
-    let cell = cell.body.clone();
-    let Some(cell) = cell.to_packed::<TableCell>() else { return cell };
-    let mut attrs = HtmlAttrs::default();
-    let span = |n: NonZeroUsize| (n != NonZeroUsize::MIN).then(|| n.to_string());
-    if let Some(colspan) = span(cell.colspan.get(styles)) {
-        attrs.push(attr::colspan, colspan);
-    }
-    if let Some(rowspan) = span(cell.rowspan.get(styles)) {
-        attrs.push(attr::rowspan, rowspan);
-    }
-    HtmlElem::new(tag)
-        .with_body(Some(cell.body.clone()))
-        .with_attrs(attrs)
-        .pack()
-        .spanned(cell.span())
-}
-
-fn show_cellgrid_html(grid: CellGrid, styles: StyleChain) -> Content {
-    let elem = |tag, body| HtmlElem::new(tag).with_body(Some(body)).pack();
-    let mut rows: Vec<_> = grid.entries.chunks(grid.non_gutter_column_count()).collect();
-
-    let tr = |tag, row: &[Entry]| {
-        let row = row
-            .iter()
-            .flat_map(|entry| entry.as_cell())
-            .map(|cell| show_cell_html(tag, cell, styles));
-        elem(tag::tr, Content::sequence(row))
-    };
-
-    // TODO(subfooters): similarly to headers, take consecutive footers from
-    // the end for 'tfoot'.
-    let footer = grid.footer.map(|ft| {
-        let rows = rows.drain(ft.start..);
-        elem(tag::tfoot, Content::sequence(rows.map(|row| tr(tag::td, row))))
-    });
-
-    // Store all consecutive headers at the start in 'thead'. All remaining
-    // headers are just 'th' rows across the table body.
-    let mut consecutive_header_end = 0;
-    let first_mid_table_header = grid
-        .headers
-        .iter()
-        .take_while(|hd| {
-            let is_consecutive = hd.range.start == consecutive_header_end;
-            consecutive_header_end = hd.range.end;
-
-            is_consecutive
-        })
-        .count();
-
-    let (y_offset, header) = if first_mid_table_header > 0 {
-        let removed_header_rows =
-            grid.headers.get(first_mid_table_header - 1).unwrap().range.end;
-        let rows = rows.drain(..removed_header_rows);
-
-        (
-            removed_header_rows,
-            Some(elem(tag::thead, Content::sequence(rows.map(|row| tr(tag::th, row))))),
-        )
-    } else {
-        (0, None)
-    };
-
-    // TODO: Consider improving accessibility properties of multi-level headers
-    // inside tables in the future, e.g. indicating which columns they are
-    // relative to and so on. See also:
-    // https://www.w3.org/WAI/tutorials/tables/multi-level/
-    let mut next_header = first_mid_table_header;
-    let mut body =
-        Content::sequence(rows.into_iter().enumerate().map(|(relative_y, row)| {
-            let y = relative_y + y_offset;
-            if let Some(current_header) =
-                grid.headers.get(next_header).filter(|h| h.range.contains(&y))
-            {
-                if y + 1 == current_header.range.end {
-                    next_header += 1;
-                }
-
-                tr(tag::th, row)
-            } else {
-                tr(tag::td, row)
-            }
-        }));
-
-    if header.is_some() || footer.is_some() {
-        body = elem(tag::tbody, body);
-    }
-
-    let content = header.into_iter().chain(core::iter::once(body)).chain(footer);
-    elem(tag::table, Content::sequence(content))
-}
-
-impl Show for Packed<TableElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(if styles.get(TargetElem::target).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 {
-            BlockElem::multi_layouter(self.clone(), engine.routines.layout_table).pack()
-        }
-        .spanned(self.span()))
-    }
-}
-
 impl LocalName for Packed<TableElem> {
     const KEY: &'static str = "table";
 }
@@ -761,7 +646,7 @@ pub struct TableVLine {
 ///   [Vikram], [49], [Perseverance],
 /// )
 /// ```
-#[elem(name = "cell", title = "Table Cell", Show)]
+#[elem(name = "cell", title = "Table Cell")]
 pub struct TableCell {
     /// The cell's body.
     #[required]
@@ -808,12 +693,6 @@ cast! {
     v: Content => v.into(),
 }
 
-impl Show for Packed<TableCell> {
-    fn show(&self, _engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        show_grid_cell(self.body.clone(), self.inset.get(styles), self.align.get(styles))
-    }
-}
-
 impl Default for Packed<TableCell> {
     fn default() -> Self {
         Packed::new(
diff --git a/crates/typst-library/src/model/terms.rs b/crates/typst-library/src/model/terms.rs
index 280c2d67e..71b1bad6d 100644
--- a/crates/typst-library/src/model/terms.rs
+++ b/crates/typst-library/src/model/terms.rs
@@ -1,15 +1,9 @@
-use typst_utils::{Get, Numeric};
-
-use crate::diag::{bail, SourceResult};
-use crate::engine::Engine;
+use crate::diag::bail;
 use crate::foundations::{
-    cast, elem, scope, Array, Content, NativeElement, Packed, Show, Smart, StyleChain,
-    Styles, TargetElem,
+    cast, elem, scope, Array, Content, NativeElement, Packed, Smart, Styles,
 };
-use crate::html::{tag, HtmlElem};
-use crate::layout::{Em, HElem, Length, Sides, StackChild, StackElem, VElem};
-use crate::model::{ListItemLike, ListLike, ParElem, ParbreakElem};
-use crate::text::TextElem;
+use crate::layout::{Em, HElem, Length};
+use crate::model::{ListItemLike, ListLike};
 
 /// A list of terms and their descriptions.
 ///
@@ -27,7 +21,7 @@ use crate::text::TextElem;
 /// # Syntax
 /// This function also has dedicated syntax: Starting a line with a slash,
 /// followed by a term, a colon and a description creates a term list item.
-#[elem(scope, title = "Term List", Show)]
+#[elem(scope, title = "Term List")]
 pub struct TermsElem {
     /// Defines the default [spacing]($terms.spacing) of the term list. If it is
     /// `{false}`, the items are spaced apart with
@@ -117,94 +111,6 @@ impl TermsElem {
     type TermItem;
 }
 
-impl Show for Packed<TermsElem> {
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let span = self.span();
-        let tight = self.tight.get(styles);
-
-        if styles.get(TargetElem::target).is_html() {
-            return Ok(HtmlElem::new(tag::dl)
-                .with_body(Some(Content::sequence(self.children.iter().flat_map(
-                    |item| {
-                        // Text in wide term lists shall always turn into paragraphs.
-                        let mut description = item.description.clone();
-                        if !tight {
-                            description += ParbreakElem::shared();
-                        }
-
-                        [
-                            HtmlElem::new(tag::dt)
-                                .with_body(Some(item.term.clone()))
-                                .pack()
-                                .spanned(item.term.span()),
-                            HtmlElem::new(tag::dd)
-                                .with_body(Some(description))
-                                .pack()
-                                .spanned(item.description.span()),
-                        ]
-                    },
-                ))))
-                .pack());
-        }
-
-        let separator = self.separator.get_ref(styles);
-        let indent = self.indent.get(styles);
-        let hanging_indent = self.hanging_indent.get(styles);
-        let gutter = self.spacing.get(styles).unwrap_or_else(|| {
-            if tight {
-                styles.get(ParElem::leading)
-            } else {
-                styles.get(ParElem::spacing)
-            }
-        });
-
-        let pad = hanging_indent + indent;
-        let unpad = (!hanging_indent.is_zero())
-            .then(|| HElem::new((-hanging_indent).into()).pack().spanned(span));
-
-        let mut children = vec![];
-        for child in self.children.iter() {
-            let mut seq = vec![];
-            seq.extend(unpad.clone());
-            seq.push(child.term.clone().strong());
-            seq.push((*separator).clone());
-            seq.push(child.description.clone());
-
-            // Text in wide term lists shall always turn into paragraphs.
-            if !tight {
-                seq.push(ParbreakElem::shared().clone());
-            }
-
-            children.push(StackChild::Block(Content::sequence(seq)));
-        }
-
-        let padding =
-            Sides::default().with(styles.resolve(TextElem::dir).start(), pad.into());
-
-        let mut realized = StackElem::new(children)
-            .with_spacing(Some(gutter.into()))
-            .pack()
-            .spanned(span)
-            .padded(padding)
-            .set(TermsElem::within, true);
-
-        if tight {
-            let spacing = self
-                .spacing
-                .get(styles)
-                .unwrap_or_else(|| styles.get(ParElem::leading));
-            let v = VElem::new(spacing.into())
-                .with_weak(true)
-                .with_attach(true)
-                .pack()
-                .spanned(span);
-            realized = v + realized;
-        }
-
-        Ok(realized)
-    }
-}
-
 /// A term list item.
 #[elem(name = "item", title = "Term List Item")]
 pub struct TermItem {
diff --git a/crates/typst-library/src/pdf/embed.rs b/crates/typst-library/src/pdf/embed.rs
index 0f93f95af..3aba85623 100644
--- a/crates/typst-library/src/pdf/embed.rs
+++ b/crates/typst-library/src/pdf/embed.rs
@@ -1,12 +1,8 @@
 use ecow::EcoString;
-use typst_library::foundations::Target;
 use typst_syntax::Spanned;
 
-use crate::diag::{warning, At, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{
-    elem, Bytes, Cast, Content, Derived, Packed, Show, StyleChain, TargetElem,
-};
+use crate::diag::At;
+use crate::foundations::{elem, Bytes, Cast, Derived};
 use crate::introspection::Locatable;
 use crate::World;
 
@@ -33,7 +29,7 @@ use crate::World;
 /// - This element is ignored if exporting to a format other than PDF.
 /// - File embeddings are not currently supported for PDF/A-2, even if the
 ///   embedded file conforms to PDF/A-1 or PDF/A-2.
-#[elem(Show, Locatable)]
+#[elem(Locatable)]
 pub struct EmbedElem {
     /// The [path]($syntax/#paths) of the file to be embedded.
     ///
@@ -77,17 +73,6 @@ pub struct EmbedElem {
     pub description: Option<EcoString>,
 }
 
-impl Show for Packed<EmbedElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if styles.get(TargetElem::target) == Target::Html {
-            engine
-                .sink
-                .warn(warning!(self.span(), "embed was ignored during HTML export"));
-        }
-        Ok(Content::empty())
-    }
-}
-
 /// The relationship of an embedded file with the document.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Cast)]
 pub enum EmbeddedFileRelationship {
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs
index 59ce83282..4bf8d60c8 100644
--- a/crates/typst-library/src/routines.rs
+++ b/crates/typst-library/src/routines.rs
@@ -1,7 +1,4 @@
-#![allow(unused)]
-
 use std::hash::{Hash, Hasher};
-use std::num::NonZeroUsize;
 
 use comemo::{Tracked, TrackedMut};
 use typst_syntax::{Span, SyntaxMode};
@@ -10,20 +7,12 @@ use typst_utils::LazyHash;
 use crate::diag::SourceResult;
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
-    Args, Cast, Closure, Content, Context, Func, Packed, Scope, StyleChain, Styles, Value,
+    Args, Closure, Content, Context, Func, NativeRuleMap, Scope, StyleChain, Styles,
+    Value,
 };
 use crate::introspection::{Introspector, Locator, SplitLocator};
-use crate::layout::{
-    Abs, BoxElem, ColumnsElem, Fragment, Frame, GridElem, InlineItem, MoveElem, PadElem,
-    PagedDocument, Region, Regions, Rel, RepeatElem, RotateElem, ScaleElem, Size,
-    SkewElem, StackElem,
-};
-use crate::math::EquationElem;
-use crate::model::{DocumentInfo, EnumElem, ListElem, TableElem};
-use crate::visualize::{
-    CircleElem, CurveElem, EllipseElem, ImageElem, LineElem, PathElem, PolygonElem,
-    RectElem, SquareElem,
-};
+use crate::layout::{Frame, Region};
+use crate::model::DocumentInfo;
 use crate::World;
 
 /// Defines the `Routines` struct.
@@ -38,6 +27,8 @@ macro_rules! routines {
         /// This is essentially dynamic linking and done to allow for crate
         /// splitting.
         pub struct Routines {
+            /// Native show rules.
+            pub rules: NativeRuleMap,
             $(
                 $(#[$attr])*
                 pub $name: $(for<$($time),*>)? fn ($($args)*) -> $ret
@@ -86,15 +77,6 @@ routines! {
         styles: StyleChain<'a>,
     ) -> SourceResult<Vec<Pair<'a>>>
 
-    /// Lays out content into multiple regions.
-    fn layout_fragment(
-        engine: &mut Engine,
-        content: &Content,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
     /// Lays out content into a single region, producing a single frame.
     fn layout_frame(
         engine: &mut Engine,
@@ -103,213 +85,6 @@ routines! {
         styles: StyleChain,
         region: Region,
     ) -> SourceResult<Frame>
-
-    /// Lays out a [`ListElem`].
-    fn layout_list(
-        elem: &Packed<ListElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
-    /// Lays out an [`EnumElem`].
-    fn layout_enum(
-        elem: &Packed<EnumElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
-    /// Lays out a [`GridElem`].
-    fn layout_grid(
-        elem: &Packed<GridElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
-    /// Lays out a [`TableElem`].
-    fn layout_table(
-        elem: &Packed<TableElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
-    /// Lays out a [`StackElem`].
-    fn layout_stack(
-        elem: &Packed<StackElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
-    /// Lays out a [`ColumnsElem`].
-    fn layout_columns(
-        elem: &Packed<ColumnsElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
-    /// Lays out a [`MoveElem`].
-    fn layout_move(
-        elem: &Packed<MoveElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`RotateElem`].
-    fn layout_rotate(
-        elem: &Packed<RotateElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`ScaleElem`].
-    fn layout_scale(
-        elem: &Packed<ScaleElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`SkewElem`].
-    fn layout_skew(
-        elem: &Packed<SkewElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`RepeatElem`].
-    fn layout_repeat(
-        elem: &Packed<RepeatElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`PadElem`].
-    fn layout_pad(
-        elem: &Packed<PadElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
-
-    /// Lays out a [`LineElem`].
-    fn layout_line(
-        elem: &Packed<LineElem>,
-        _: &mut Engine,
-        _: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`CurveElem`].
-    fn layout_curve(
-        elem: &Packed<CurveElem>,
-        _: &mut Engine,
-        _: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`PathElem`].
-    fn layout_path(
-        elem: &Packed<PathElem>,
-        _: &mut Engine,
-        _: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`PolygonElem`].
-    fn layout_polygon(
-        elem: &Packed<PolygonElem>,
-        _: &mut Engine,
-        _: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`RectElem`].
-    fn layout_rect(
-        elem: &Packed<RectElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`SquareElem`].
-    fn layout_square(
-        elem: &Packed<SquareElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`EllipseElem`].
-    fn layout_ellipse(
-        elem: &Packed<EllipseElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out a [`CircleElem`].
-    fn layout_circle(
-        elem: &Packed<CircleElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out an [`ImageElem`].
-    fn layout_image(
-        elem: &Packed<ImageElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Region,
-    ) -> SourceResult<Frame>
-
-    /// Lays out an [`EquationElem`] in a paragraph.
-    fn layout_equation_inline(
-        elem: &Packed<EquationElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        region: Size,
-    ) -> SourceResult<Vec<InlineItem>>
-
-    /// Lays out an [`EquationElem`] in a flow.
-    fn layout_equation_block(
-        elem: &Packed<EquationElem>,
-        engine: &mut Engine,
-        locator: Locator,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment>
 }
 
 /// Defines what kind of realization we are performing.
diff --git a/crates/typst-library/src/text/deco.rs b/crates/typst-library/src/text/deco.rs
index 8c1d56345..f7d5c33be 100644
--- a/crates/typst-library/src/text/deco.rs
+++ b/crates/typst-library/src/text/deco.rs
@@ -1,13 +1,6 @@
-use smallvec::smallvec;
-
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
-};
-use crate::html::{attr, tag, HtmlElem};
+use crate::foundations::{elem, Content, Smart};
 use crate::layout::{Abs, Corners, Length, Rel, Sides};
-use crate::text::{BottomEdge, BottomEdgeMetric, TextElem, TopEdge, TopEdgeMetric};
+use crate::text::{BottomEdge, BottomEdgeMetric, TopEdge, TopEdgeMetric};
 use crate::visualize::{Color, FixedStroke, Paint, Stroke};
 
 /// Underlines text.
@@ -16,7 +9,7 @@ use crate::visualize::{Color, FixedStroke, Paint, Stroke};
 /// ```example
 /// This is #underline[important].
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct UnderlineElem {
     /// How to [stroke] the line.
     ///
@@ -78,41 +71,13 @@ pub struct UnderlineElem {
     pub body: Content,
 }
 
-impl Show for Packed<UnderlineElem> {
-    #[typst_macros::time(name = "underline", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if styles.get(TargetElem::target).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().set(
-            TextElem::deco,
-            smallvec![Decoration {
-                line: DecoLine::Underline {
-                    stroke: self.stroke.resolve(styles).unwrap_or_default(),
-                    offset: self.offset.resolve(styles),
-                    evade: self.evade.get(styles),
-                    background: self.background.get(styles),
-                },
-                extent: self.extent.resolve(styles),
-            }],
-        ))
-    }
-}
-
 /// Adds a line over text.
 ///
 /// # Example
 /// ```example
 /// #overline[A line over text.]
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct OverlineElem {
     /// How to [stroke] the line.
     ///
@@ -180,38 +145,13 @@ pub struct OverlineElem {
     pub body: Content,
 }
 
-impl Show for Packed<OverlineElem> {
-    #[typst_macros::time(name = "overline", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if styles.get(TargetElem::target).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().set(
-            TextElem::deco,
-            smallvec![Decoration {
-                line: DecoLine::Overline {
-                    stroke: self.stroke.resolve(styles).unwrap_or_default(),
-                    offset: self.offset.resolve(styles),
-                    evade: self.evade.get(styles),
-                    background: self.background.get(styles),
-                },
-                extent: self.extent.resolve(styles),
-            }],
-        ))
-    }
-}
-
 /// Strikes through text.
 ///
 /// # Example
 /// ```example
 /// This is #strike[not] relevant.
 /// ```
-#[elem(title = "Strikethrough", Show)]
+#[elem(title = "Strikethrough")]
 pub struct StrikeElem {
     /// How to [stroke] the line.
     ///
@@ -264,35 +204,13 @@ pub struct StrikeElem {
     pub body: Content,
 }
 
-impl Show for Packed<StrikeElem> {
-    #[typst_macros::time(name = "strike", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if styles.get(TargetElem::target).is_html() {
-            return Ok(HtmlElem::new(tag::s).with_body(Some(self.body.clone())).pack());
-        }
-
-        Ok(self.body.clone().set(
-            TextElem::deco,
-            smallvec![Decoration {
-                // Note that we do not support evade option for strikethrough.
-                line: DecoLine::Strikethrough {
-                    stroke: self.stroke.resolve(styles).unwrap_or_default(),
-                    offset: self.offset.resolve(styles),
-                    background: self.background.get(styles),
-                },
-                extent: self.extent.resolve(styles),
-            }],
-        ))
-    }
-}
-
 /// Highlights text with a background color.
 ///
 /// # Example
 /// ```example
 /// This is #highlight[important].
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct HighlightElem {
     /// The color to highlight the text with.
     ///
@@ -363,35 +281,6 @@ pub struct HighlightElem {
     pub body: Content,
 }
 
-impl Show for Packed<HighlightElem> {
-    #[typst_macros::time(name = "highlight", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        if styles.get(TargetElem::target).is_html() {
-            return Ok(HtmlElem::new(tag::mark)
-                .with_body(Some(self.body.clone()))
-                .pack());
-        }
-
-        Ok(self.body.clone().set(
-            TextElem::deco,
-            smallvec![Decoration {
-                line: DecoLine::Highlight {
-                    fill: self.fill.get_cloned(styles),
-                    stroke: self
-                        .stroke
-                        .resolve(styles)
-                        .unwrap_or_default()
-                        .map(|stroke| stroke.map(Stroke::unwrap_or_default)),
-                    top_edge: self.top_edge.get(styles),
-                    bottom_edge: self.bottom_edge.get(styles),
-                    radius: self.radius.resolve(styles).unwrap_or_default(),
-                },
-                extent: self.extent.resolve(styles),
-            }],
-        ))
-    }
-}
-
 /// A text decoration.
 ///
 /// Can be positioned over, under, or on top of text, or highlight the text with
diff --git a/crates/typst-library/src/text/raw.rs b/crates/typst-library/src/text/raw.rs
index 67038163d..8cddfbfb5 100644
--- a/crates/typst-library/src/text/raw.rs
+++ b/crates/typst-library/src/text/raw.rs
@@ -16,14 +16,13 @@ use crate::diag::{
 };
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, Bytes, Content, Derived, NativeElement, OneOrMultiple, Packed,
-    PlainText, Show, ShowSet, Smart, StyleChain, Styles, Synthesize, TargetElem,
+    cast, elem, scope, Bytes, Content, Derived, OneOrMultiple, Packed, PlainText,
+    ShowSet, Smart, StyleChain, Styles, Synthesize,
 };
-use crate::html::{tag, HtmlElem};
-use crate::layout::{BlockBody, BlockElem, Em, HAlignment};
+use crate::layout::{Em, HAlignment};
 use crate::loading::{DataSource, Load};
 use crate::model::{Figurable, ParElem};
-use crate::text::{FontFamily, FontList, LinebreakElem, LocalName, TextElem, TextSize};
+use crate::text::{FontFamily, FontList, LocalName, TextElem, TextSize};
 use crate::visualize::Color;
 use crate::World;
 
@@ -78,7 +77,6 @@ use crate::World;
     scope,
     title = "Raw Text / Code",
     Synthesize,
-    Show,
     ShowSet,
     LocalName,
     Figurable,
@@ -429,46 +427,6 @@ impl Packed<RawElem> {
     }
 }
 
-impl Show for Packed<RawElem> {
-    #[typst_macros::time(name = "raw", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let lines = self.lines.as_deref().unwrap_or_default();
-
-        let mut seq = EcoVec::with_capacity((2 * lines.len()).saturating_sub(1));
-        for (i, line) in lines.iter().enumerate() {
-            if i != 0 {
-                seq.push(LinebreakElem::shared().clone());
-            }
-
-            seq.push(line.clone().pack());
-        }
-
-        let mut realized = Content::sequence(seq);
-
-        if styles.get(TargetElem::target).is_html() {
-            return Ok(HtmlElem::new(if self.block.get(styles) {
-                tag::pre
-            } else {
-                tag::code
-            })
-            .with_body(Some(realized))
-            .pack()
-            .spanned(self.span()));
-        }
-
-        if self.block.get(styles) {
-            // Align the text before inserting it into the block.
-            realized = realized.aligned(self.align.get(styles).into());
-            realized = BlockElem::new()
-                .with_body(Some(BlockBody::Content(realized)))
-                .pack()
-                .spanned(self.span());
-        }
-
-        Ok(realized)
-    }
-}
-
 impl ShowSet for Packed<RawElem> {
     fn show_set(&self, styles: StyleChain) -> Styles {
         let mut out = Styles::new();
@@ -634,7 +592,7 @@ fn format_theme_error(error: syntect::LoadingError) -> LoadError {
 /// It allows you to access various properties of the line, such as the line
 /// number, the raw non-highlighted text, the highlighted text, and whether it
 /// is the first or last line of the raw block.
-#[elem(name = "line", title = "Raw Text / Code Line", Show, PlainText)]
+#[elem(name = "line", title = "Raw Text / Code Line", PlainText)]
 pub struct RawLine {
     /// The line number of the raw line inside of the raw block, starts at 1.
     #[required]
@@ -653,13 +611,6 @@ pub struct RawLine {
     pub body: Content,
 }
 
-impl Show for Packed<RawLine> {
-    #[typst_macros::time(name = "raw.line", span = self.span())]
-    fn show(&self, _: &mut Engine, _styles: StyleChain) -> SourceResult<Content> {
-        Ok(self.body.clone())
-    }
-}
-
 impl PlainText for Packed<RawLine> {
     fn plain_text(&self, text: &mut EcoString) {
         text.push_str(&self.text);
diff --git a/crates/typst-library/src/text/shift.rs b/crates/typst-library/src/text/shift.rs
index 1a05d8f9c..87ccae635 100644
--- a/crates/typst-library/src/text/shift.rs
+++ b/crates/typst-library/src/text/shift.rs
@@ -1,13 +1,8 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    elem, Content, NativeElement, Packed, Show, Smart, StyleChain, TargetElem,
-};
-use crate::html::{tag, HtmlElem};
-use crate::layout::{Em, Length};
-use crate::text::{FontMetrics, TextElem, TextSize};
 use ttf_parser::Tag;
-use typst_library::text::ScriptMetrics;
+
+use crate::foundations::{elem, Content, Smart};
+use crate::layout::{Em, Length};
+use crate::text::{FontMetrics, ScriptMetrics, TextSize};
 
 /// Renders text in subscript.
 ///
@@ -17,7 +12,7 @@ use typst_library::text::ScriptMetrics;
 /// ```example
 /// Revenue#sub[yearly]
 /// ```
-#[elem(title = "Subscript", Show)]
+#[elem(title = "Subscript")]
 pub struct SubElem {
     /// Whether to create artificial subscripts by lowering and scaling down
     /// regular glyphs.
@@ -64,29 +59,6 @@ pub struct SubElem {
     pub body: Content,
 }
 
-impl Show for Packed<SubElem> {
-    #[typst_macros::time(name = "sub", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let body = self.body.clone();
-
-        if styles.get(TargetElem::target).is_html() {
-            return Ok(HtmlElem::new(tag::sub)
-                .with_body(Some(body))
-                .pack()
-                .spanned(self.span()));
-        }
-
-        show_script(
-            styles,
-            body,
-            self.typographic.get(styles),
-            self.baseline.get(styles),
-            self.size.get(styles),
-            ScriptKind::Sub,
-        )
-    }
-}
-
 /// Renders text in superscript.
 ///
 /// The text is rendered smaller and its baseline is raised.
@@ -95,7 +67,7 @@ impl Show for Packed<SubElem> {
 /// ```example
 /// 1#super[st] try!
 /// ```
-#[elem(title = "Superscript", Show)]
+#[elem(title = "Superscript")]
 pub struct SuperElem {
     /// Whether to create artificial superscripts by raising and scaling down
     /// regular glyphs.
@@ -146,49 +118,6 @@ pub struct SuperElem {
     pub body: Content,
 }
 
-impl Show for Packed<SuperElem> {
-    #[typst_macros::time(name = "super", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let body = self.body.clone();
-
-        if styles.get(TargetElem::target).is_html() {
-            return Ok(HtmlElem::new(tag::sup)
-                .with_body(Some(body))
-                .pack()
-                .spanned(self.span()));
-        }
-
-        show_script(
-            styles,
-            body,
-            self.typographic.get(styles),
-            self.baseline.get(styles),
-            self.size.get(styles),
-            ScriptKind::Super,
-        )
-    }
-}
-
-fn show_script(
-    styles: StyleChain,
-    body: Content,
-    typographic: bool,
-    baseline: Smart<Length>,
-    size: Smart<TextSize>,
-    kind: ScriptKind,
-) -> SourceResult<Content> {
-    let font_size = styles.resolve(TextElem::size);
-    Ok(body.set(
-        TextElem::shift_settings,
-        Some(ShiftSettings {
-            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 {
diff --git a/crates/typst-library/src/text/smallcaps.rs b/crates/typst-library/src/text/smallcaps.rs
index 1c2838933..199222fed 100644
--- a/crates/typst-library/src/text/smallcaps.rs
+++ b/crates/typst-library/src/text/smallcaps.rs
@@ -1,7 +1,4 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{elem, Content, Packed, Show, StyleChain};
-use crate::text::TextElem;
+use crate::foundations::{elem, Content};
 
 /// Displays text in small capitals.
 ///
@@ -43,7 +40,7 @@ use crate::text::TextElem;
 /// = Introduction
 /// #lorem(40)
 /// ```
-#[elem(title = "Small Capitals", Show)]
+#[elem(title = "Small Capitals")]
 pub struct SmallcapsElem {
     /// Whether to turn uppercase letters into small capitals as well.
     ///
@@ -61,15 +58,6 @@ pub struct SmallcapsElem {
     pub body: Content,
 }
 
-impl Show for Packed<SmallcapsElem> {
-    #[typst_macros::time(name = "smallcaps", span = self.span())]
-    fn show(&self, _: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let sc =
-            if self.all.get(styles) { Smallcaps::All } else { Smallcaps::Minuscules };
-        Ok(self.body.clone().set(TextElem::smallcaps, Some(sc)))
-    }
-}
-
 /// What becomes small capitals.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum Smallcaps {
diff --git a/crates/typst-library/src/text/smartquote.rs b/crates/typst-library/src/text/smartquote.rs
index 24787d062..375b1cf09 100644
--- a/crates/typst-library/src/text/smartquote.rs
+++ b/crates/typst-library/src/text/smartquote.rs
@@ -5,9 +5,10 @@ use unicode_segmentation::UnicodeSegmentation;
 use crate::diag::{bail, HintedStrResult, StrResult};
 use crate::foundations::{
     array, cast, dict, elem, Array, Dict, FromValue, Packed, PlainText, Smart, Str,
+    StyleChain,
 };
 use crate::layout::Dir;
-use crate::text::{Lang, Region};
+use crate::text::{Lang, Region, TextElem};
 
 /// A language-aware quote that reacts to its context.
 ///
@@ -200,6 +201,16 @@ pub struct SmartQuotes<'s> {
 }
 
 impl<'s> SmartQuotes<'s> {
+    /// Retrieve the smart quotes as configured by the current styles.
+    pub fn get_in(styles: StyleChain<'s>) -> Self {
+        Self::get(
+            styles.get_ref(SmartQuoteElem::quotes),
+            styles.get(TextElem::lang),
+            styles.get(TextElem::region),
+            styles.get(SmartQuoteElem::alternative),
+        )
+    }
+
     /// Create a new `Quotes` struct with the given quotes, optionally falling
     /// back to the defaults for a language and region.
     ///
diff --git a/crates/typst-library/src/visualize/curve.rs b/crates/typst-library/src/visualize/curve.rs
index 587f0d4a2..15ae48c61 100644
--- a/crates/typst-library/src/visualize/curve.rs
+++ b/crates/typst-library/src/visualize/curve.rs
@@ -2,12 +2,9 @@ use kurbo::ParamCurveExtrema;
 use typst_macros::{scope, Cast};
 use typst_utils::Numeric;
 
-use crate::diag::{bail, HintedStrResult, HintedString, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{
-    cast, elem, Content, NativeElement, Packed, Show, Smart, StyleChain,
-};
-use crate::layout::{Abs, Axes, BlockElem, Length, Point, Rel, Size};
+use crate::diag::{bail, HintedStrResult, HintedString};
+use crate::foundations::{cast, elem, Content, Packed, Smart};
+use crate::layout::{Abs, Axes, Length, Point, Rel, Size};
 use crate::visualize::{FillRule, Paint, Stroke};
 
 use super::FixedStroke;
@@ -42,7 +39,7 @@ use super::FixedStroke;
 ///   curve.close(),
 /// )
 /// ```
-#[elem(scope, Show)]
+#[elem(scope)]
 pub struct CurveElem {
     /// How to fill the curve.
     ///
@@ -95,14 +92,6 @@ pub struct CurveElem {
     pub components: Vec<CurveComponent>,
 }
 
-impl Show for Packed<CurveElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_curve)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 #[scope]
 impl CurveElem {
     #[elem]
diff --git a/crates/typst-library/src/visualize/image/mod.rs b/crates/typst-library/src/visualize/image/mod.rs
index 48a14f0ed..95021b818 100644
--- a/crates/typst-library/src/visualize/image/mod.rs
+++ b/crates/typst-library/src/visualize/image/mod.rs
@@ -15,13 +15,11 @@ use ecow::EcoString;
 use typst_syntax::{Span, Spanned};
 use typst_utils::LazyHash;
 
-use crate::diag::{SourceResult, StrResult};
-use crate::engine::Engine;
+use crate::diag::StrResult;
 use crate::foundations::{
-    cast, elem, func, scope, Bytes, Cast, Content, Derived, NativeElement, Packed, Show,
-    Smart, StyleChain,
+    cast, elem, func, scope, Bytes, Cast, Content, Derived, NativeElement, Packed, Smart,
 };
-use crate::layout::{BlockElem, Length, Rel, Sizing};
+use crate::layout::{Length, Rel, Sizing};
 use crate::loading::{DataSource, Load, LoadSource, Loaded, Readable};
 use crate::model::Figurable;
 use crate::text::LocalName;
@@ -44,7 +42,7 @@ use crate::text::LocalName;
 ///   ],
 /// )
 /// ```
-#[elem(scope, Show, LocalName, Figurable)]
+#[elem(scope, LocalName, Figurable)]
 pub struct ImageElem {
     /// A [path]($syntax/#paths) to an image file or raw bytes making up an
     /// image in one of the supported [formats]($image.format).
@@ -219,16 +217,6 @@ impl ImageElem {
     }
 }
 
-impl Show for Packed<ImageElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_image)
-            .with_width(self.width.get(styles))
-            .with_height(self.height.get(styles))
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 impl LocalName for Packed<ImageElem> {
     const KEY: &'static str = "figure";
 }
diff --git a/crates/typst-library/src/visualize/line.rs b/crates/typst-library/src/visualize/line.rs
index d058b926a..7eecfc915 100644
--- a/crates/typst-library/src/visualize/line.rs
+++ b/crates/typst-library/src/visualize/line.rs
@@ -1,7 +1,5 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{elem, Content, NativeElement, Packed, Show, StyleChain};
-use crate::layout::{Abs, Angle, Axes, BlockElem, Length, Rel};
+use crate::foundations::elem;
+use crate::layout::{Abs, Angle, Axes, Length, Rel};
 use crate::visualize::Stroke;
 
 /// A line from one point to another.
@@ -17,7 +15,7 @@ use crate::visualize::Stroke;
 ///   stroke: 2pt + maroon,
 /// )
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct LineElem {
     /// The start point of the line.
     ///
@@ -50,11 +48,3 @@ pub struct LineElem {
     #[fold]
     pub stroke: Stroke,
 }
-
-impl Show for Packed<LineElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_line)
-            .pack()
-            .spanned(self.span()))
-    }
-}
diff --git a/crates/typst-library/src/visualize/path.rs b/crates/typst-library/src/visualize/path.rs
index e19e091df..bd8aea02d 100644
--- a/crates/typst-library/src/visualize/path.rs
+++ b/crates/typst-library/src/visualize/path.rs
@@ -1,11 +1,7 @@
 use self::PathVertex::{AllControlPoints, MirroredControlPoint, Vertex};
-use crate::diag::{bail, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{
-    array, cast, elem, Array, Content, NativeElement, Packed, Reflect, Show, Smart,
-    StyleChain,
-};
-use crate::layout::{Axes, BlockElem, Length, Rel};
+use crate::diag::bail;
+use crate::foundations::{array, cast, elem, Array, Reflect, Smart};
+use crate::layout::{Axes, Length, Rel};
 use crate::visualize::{FillRule, Paint, Stroke};
 
 /// A path through a list of points, connected by Bézier curves.
@@ -21,7 +17,7 @@ use crate::visualize::{FillRule, Paint, Stroke};
 ///   ((50%, 0pt), (40pt, 0pt)),
 /// )
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct PathElem {
     /// How to fill the path.
     ///
@@ -83,14 +79,6 @@ pub struct PathElem {
     pub vertices: Vec<PathVertex>,
 }
 
-impl Show for Packed<PathElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_path)
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// A component used for path creation.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum PathVertex {
diff --git a/crates/typst-library/src/visualize/polygon.rs b/crates/typst-library/src/visualize/polygon.rs
index d75e1a657..db75a2670 100644
--- a/crates/typst-library/src/visualize/polygon.rs
+++ b/crates/typst-library/src/visualize/polygon.rs
@@ -2,12 +2,8 @@ use std::f64::consts::PI;
 
 use typst_syntax::Span;
 
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    elem, func, scope, Content, NativeElement, Packed, Show, Smart, StyleChain,
-};
-use crate::layout::{Axes, BlockElem, Em, Length, Rel};
+use crate::foundations::{elem, func, scope, Content, NativeElement, Smart};
+use crate::layout::{Axes, Em, Length, Rel};
 use crate::visualize::{FillRule, Paint, Stroke};
 
 /// A closed polygon.
@@ -25,7 +21,7 @@ use crate::visualize::{FillRule, Paint, Stroke};
 ///   (0%,  2cm),
 /// )
 /// ```
-#[elem(scope, Show)]
+#[elem(scope)]
 pub struct PolygonElem {
     /// How to fill the polygon.
     ///
@@ -124,11 +120,3 @@ impl PolygonElem {
         elem.pack().spanned(span)
     }
 }
-
-impl Show for Packed<PolygonElem> {
-    fn show(&self, engine: &mut Engine, _: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_polygon)
-            .pack()
-            .spanned(self.span()))
-    }
-}
diff --git a/crates/typst-library/src/visualize/shape.rs b/crates/typst-library/src/visualize/shape.rs
index f21bf93e9..fc7b8748e 100644
--- a/crates/typst-library/src/visualize/shape.rs
+++ b/crates/typst-library/src/visualize/shape.rs
@@ -1,9 +1,5 @@
-use crate::diag::SourceResult;
-use crate::engine::Engine;
-use crate::foundations::{
-    elem, Cast, Content, NativeElement, Packed, Show, Smart, StyleChain,
-};
-use crate::layout::{Abs, BlockElem, Corners, Length, Point, Rel, Sides, Size, Sizing};
+use crate::foundations::{elem, Cast, Content, Smart};
+use crate::layout::{Abs, Corners, Length, Point, Rel, Sides, Size, Sizing};
 use crate::visualize::{Curve, FixedStroke, Paint, Stroke};
 
 /// A rectangle with optional content.
@@ -19,7 +15,7 @@ use crate::visualize::{Curve, FixedStroke, Paint, Stroke};
 ///   to fit the content.
 /// ]
 /// ```
-#[elem(title = "Rectangle", Show)]
+#[elem(title = "Rectangle")]
 pub struct RectElem {
     /// The rectangle's width, relative to its parent container.
     pub width: Smart<Rel<Length>>,
@@ -122,16 +118,6 @@ pub struct RectElem {
     pub body: Option<Content>,
 }
 
-impl Show for Packed<RectElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_rect)
-            .with_width(self.width.get(styles))
-            .with_height(self.height.get(styles))
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// A square with optional content.
 ///
 /// # Example
@@ -145,7 +131,7 @@ impl Show for Packed<RectElem> {
 ///   sized to fit.
 /// ]
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct SquareElem {
     /// The square's side length. This is mutually exclusive with `width` and
     /// `height`.
@@ -209,16 +195,6 @@ pub struct SquareElem {
     pub body: Option<Content>,
 }
 
-impl Show for Packed<SquareElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_square)
-            .with_width(self.width.get(styles))
-            .with_height(self.height.get(styles))
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// An ellipse with optional content.
 ///
 /// # Example
@@ -233,7 +209,7 @@ impl Show for Packed<SquareElem> {
 ///   to fit the content.
 /// ]
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct EllipseElem {
     /// The ellipse's width, relative to its parent container.
     pub width: Smart<Rel<Length>>,
@@ -269,16 +245,6 @@ pub struct EllipseElem {
     pub body: Option<Content>,
 }
 
-impl Show for Packed<EllipseElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_ellipse)
-            .with_width(self.width.get(styles))
-            .with_height(self.height.get(styles))
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// A circle with optional content.
 ///
 /// # Example
@@ -293,7 +259,7 @@ impl Show for Packed<EllipseElem> {
 ///   sized to fit.
 /// ]
 /// ```
-#[elem(Show)]
+#[elem]
 pub struct CircleElem {
     /// The circle's radius. This is mutually exclusive with `width` and
     /// `height`.
@@ -354,16 +320,6 @@ pub struct CircleElem {
     pub body: Option<Content>,
 }
 
-impl Show for Packed<CircleElem> {
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        Ok(BlockElem::single_layouter(self.clone(), engine.routines.layout_circle)
-            .with_width(self.width.get(styles))
-            .with_height(self.height.get(styles))
-            .pack()
-            .spanned(self.span()))
-    }
-}
-
 /// A geometric shape with optional fill and stroke.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct Shape {
diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index fcfb40667..6af249cc3 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -14,9 +14,9 @@ use ecow::EcoString;
 use typst_library::diag::{bail, At, SourceResult};
 use typst_library::engine::Engine;
 use typst_library::foundations::{
-    Content, Context, ContextElem, Element, NativeElement, Recipe, RecipeIndex, Selector,
-    SequenceElem, Show, ShowSet, Style, StyleChain, StyledElem, Styles, SymbolElem,
-    Synthesize, Transformation,
+    Content, Context, ContextElem, Element, NativeElement, NativeShowRule, Recipe,
+    RecipeIndex, Selector, SequenceElem, ShowSet, Style, StyleChain, StyledElem, Styles,
+    SymbolElem, Synthesize, TargetElem, Transformation,
 };
 use typst_library::html::{tag, FrameElem, HtmlElem};
 use typst_library::introspection::{Locatable, SplitLocator, Tag, TagElem};
@@ -160,7 +160,7 @@ enum ShowStep<'a> {
     /// A user-defined transformational show rule.
     Recipe(&'a Recipe, RecipeIndex),
     /// The built-in show rule.
-    Builtin,
+    Builtin(NativeShowRule),
 }
 
 /// A match of a regex show rule.
@@ -382,9 +382,7 @@ fn visit_show_rules<'a>(
             }
 
             // Apply a built-in show rule.
-            ShowStep::Builtin => {
-                output.with::<dyn Show>().unwrap().show(s.engine, chained)
-            }
+            ShowStep::Builtin(rule) => rule.apply(&output, s.engine, chained),
         };
 
         // Errors in show rules don't terminate compilation immediately. We just
@@ -426,14 +424,14 @@ fn visit_show_rules<'a>(
     Ok(true)
 }
 
-/// Inspects a target element and the current styles and determines how to
-/// proceed with the styling.
+/// Inspects an element and the current styles and determines how to proceed
+/// with the styling.
 fn verdict<'a>(
     engine: &mut Engine,
-    target: &'a Content,
+    elem: &'a Content,
     styles: StyleChain<'a>,
 ) -> Option<Verdict<'a>> {
-    let prepared = target.is_prepared();
+    let prepared = elem.is_prepared();
     let mut map = Styles::new();
     let mut step = None;
 
@@ -441,20 +439,20 @@ fn verdict<'a>(
     // fields before real synthesis runs (during preparation). It's really
     // unfortunate that we have to do this, but otherwise
     // `show figure.where(kind: table)` won't work :(
-    let mut target = target;
+    let mut elem = elem;
     let mut slot;
-    if !prepared && target.can::<dyn Synthesize>() {
-        slot = target.clone();
+    if !prepared && elem.can::<dyn Synthesize>() {
+        slot = elem.clone();
         slot.with_mut::<dyn Synthesize>()
             .unwrap()
             .synthesize(engine, styles)
             .ok();
-        target = &slot;
+        elem = &slot;
     }
 
     // Lazily computes the total number of recipes in the style chain. We need
     // it to determine whether a particular show rule was already applied to the
-    // `target` previously. For this purpose, show rules are indexed from the
+    // `elem` previously. For this purpose, show rules are indexed from the
     // top of the chain as the chain might grow to the bottom.
     let depth = LazyCell::new(|| styles.recipes().count());
 
@@ -462,7 +460,7 @@ fn verdict<'a>(
         // We're not interested in recipes that don't match.
         if !recipe
             .selector()
-            .is_some_and(|selector| selector.matches(target, Some(styles)))
+            .is_some_and(|selector| selector.matches(elem, Some(styles)))
         {
             continue;
         }
@@ -480,9 +478,9 @@ fn verdict<'a>(
             continue;
         }
 
-        // Check whether this show rule was already applied to the target.
+        // Check whether this show rule was already applied to the element.
         let index = RecipeIndex(*depth - r);
-        if target.is_guarded(index) {
+        if elem.is_guarded(index) {
             continue;
         }
 
@@ -498,19 +496,22 @@ fn verdict<'a>(
     }
 
     // If we found no user-defined rule, also consider the built-in show rule.
-    if step.is_none() && target.can::<dyn Show>() {
-        step = Some(ShowStep::Builtin);
+    if step.is_none() {
+        let target = styles.get(TargetElem::target);
+        if let Some(rule) = engine.routines.rules.get(target, elem) {
+            step = Some(ShowStep::Builtin(rule));
+        }
     }
 
     // If there's no nothing to do, there is also no verdict.
     if step.is_none()
         && map.is_empty()
         && (prepared || {
-            target.label().is_none()
-                && target.location().is_none()
-                && !target.can::<dyn ShowSet>()
-                && !target.can::<dyn Locatable>()
-                && !target.can::<dyn Synthesize>()
+            elem.label().is_none()
+                && elem.location().is_none()
+                && !elem.can::<dyn ShowSet>()
+                && !elem.can::<dyn Locatable>()
+                && !elem.can::<dyn Synthesize>()
         })
     {
         return None;
@@ -523,7 +524,7 @@ fn verdict<'a>(
 fn prepare(
     engine: &mut Engine,
     locator: &mut SplitLocator,
-    target: &mut Content,
+    elem: &mut Content,
     map: &mut Styles,
     styles: StyleChain,
 ) -> SourceResult<Option<(Tag, Tag)>> {
@@ -533,43 +534,43 @@ fn prepare(
     //
     // The element could already have a location even if it is not prepared
     // when it stems from a query.
-    let key = typst_utils::hash128(&target);
-    if target.location().is_none()
-        && (target.can::<dyn Locatable>() || target.label().is_some())
+    let key = typst_utils::hash128(&elem);
+    if elem.location().is_none()
+        && (elem.can::<dyn Locatable>() || elem.label().is_some())
     {
         let loc = locator.next_location(engine.introspector, key);
-        target.set_location(loc);
+        elem.set_location(loc);
     }
 
     // Apply built-in show-set rules. User-defined show-set rules are already
     // considered in the map built while determining the verdict.
-    if let Some(show_settable) = target.with::<dyn ShowSet>() {
+    if let Some(show_settable) = elem.with::<dyn ShowSet>() {
         map.apply(show_settable.show_set(styles));
     }
 
     // If necessary, generated "synthesized" fields (which are derived from
     // other fields or queries). Do this after show-set so that show-set styles
     // are respected.
-    if let Some(synthesizable) = target.with_mut::<dyn Synthesize>() {
+    if let Some(synthesizable) = elem.with_mut::<dyn Synthesize>() {
         synthesizable.synthesize(engine, styles.chain(map))?;
     }
 
     // Copy style chain fields into the element itself, so that they are
     // available in rules.
-    target.materialize(styles.chain(map));
+    elem.materialize(styles.chain(map));
 
     // If the element is locatable, create start and end tags to be able to find
     // the element in the frames after layout. Do this after synthesis and
     // materialization, so that it includes the synthesized fields. Do it before
     // marking as prepared so that show-set rules will apply to this element
     // when queried.
-    let tags = target
+    let tags = elem
         .location()
-        .map(|loc| (Tag::Start(target.clone()), Tag::End(loc, key)));
+        .map(|loc| (Tag::Start(elem.clone()), Tag::End(loc, key)));
 
     // Ensure that this preparation only runs once by marking the element as
     // prepared.
-    target.mark_prepared();
+    elem.mark_prepared();
 
     Ok(tags)
 }
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index eee7966a7..0673c3259 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -39,6 +39,7 @@ pub use typst_syntax as syntax;
 pub use typst_utils as utils;
 
 use std::collections::HashSet;
+use std::sync::LazyLock;
 
 use comemo::{Track, Tracked, Validate};
 use ecow::{eco_format, eco_vec, EcoString, EcoVec};
@@ -46,7 +47,7 @@ use typst_library::diag::{
     bail, warning, FileError, SourceDiagnostic, SourceResult, Warned,
 };
 use typst_library::engine::{Engine, Route, Sink, Traced};
-use typst_library::foundations::{StyleChain, Styles, Value};
+use typst_library::foundations::{NativeRuleMap, StyleChain, Styles, Value};
 use typst_library::html::HtmlDocument;
 use typst_library::introspection::Introspector;
 use typst_library::layout::PagedDocument;
@@ -326,33 +327,15 @@ mod sealed {
 /// function pointers.
 ///
 /// This is essentially dynamic linking and done to allow for crate splitting.
-pub static ROUTINES: Routines = Routines {
+pub static ROUTINES: LazyLock<Routines> = LazyLock::new(|| Routines {
+    rules: {
+        let mut rules = NativeRuleMap::new();
+        typst_layout::register(&mut rules);
+        typst_html::register(&mut rules);
+        rules
+    },
     eval_string: typst_eval::eval_string,
     eval_closure: typst_eval::eval_closure,
     realize: typst_realize::realize,
-    layout_fragment: typst_layout::layout_fragment,
     layout_frame: typst_layout::layout_frame,
-    layout_list: typst_layout::layout_list,
-    layout_enum: typst_layout::layout_enum,
-    layout_grid: typst_layout::layout_grid,
-    layout_table: typst_layout::layout_table,
-    layout_stack: typst_layout::layout_stack,
-    layout_columns: typst_layout::layout_columns,
-    layout_move: typst_layout::layout_move,
-    layout_rotate: typst_layout::layout_rotate,
-    layout_scale: typst_layout::layout_scale,
-    layout_skew: typst_layout::layout_skew,
-    layout_repeat: typst_layout::layout_repeat,
-    layout_pad: typst_layout::layout_pad,
-    layout_line: typst_layout::layout_line,
-    layout_curve: typst_layout::layout_curve,
-    layout_path: typst_layout::layout_path,
-    layout_polygon: typst_layout::layout_polygon,
-    layout_rect: typst_layout::layout_rect,
-    layout_square: typst_layout::layout_square,
-    layout_ellipse: typst_layout::layout_ellipse,
-    layout_circle: typst_layout::layout_circle,
-    layout_image: typst_layout::layout_image,
-    layout_equation_block: typst_layout::layout_equation_block,
-    layout_equation_inline: typst_layout::layout_equation_inline,
-};
+});

From e71674f6b3db0768c3e9d6e0271628377f8c82d8 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 9 Jul 2025 11:28:26 +0200
Subject: [PATCH 060/101] Construct library via extension trait instead of
 default & inherent impl (#6576)

---
 crates/typst-cli/src/world.rs        |  2 +-
 crates/typst-ide/src/tests.rs        |  2 +-
 crates/typst-library/src/lib.rs      | 36 +++++++++++++++-------------
 crates/typst-library/src/routines.rs |  7 ++++++
 crates/typst/src/lib.rs              | 19 +++++++++++++++
 docs/src/lib.rs                      |  4 ++--
 tests/fuzz/src/compile.rs            |  2 +-
 tests/src/world.rs                   |  2 +-
 8 files changed, 52 insertions(+), 22 deletions(-)

diff --git a/crates/typst-cli/src/world.rs b/crates/typst-cli/src/world.rs
index 95bee235c..8ad766b14 100644
--- a/crates/typst-cli/src/world.rs
+++ b/crates/typst-cli/src/world.rs
@@ -12,7 +12,7 @@ use typst::foundations::{Bytes, Datetime, Dict, IntoValue};
 use typst::syntax::{FileId, Lines, Source, VirtualPath};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
-use typst::{Library, World};
+use typst::{Library, LibraryExt, World};
 use typst_kit::fonts::{FontSlot, Fonts};
 use typst_kit::package::PackageStorage;
 use typst_timing::timed;
diff --git a/crates/typst-ide/src/tests.rs b/crates/typst-ide/src/tests.rs
index b3f368f2e..168dfc9f2 100644
--- a/crates/typst-ide/src/tests.rs
+++ b/crates/typst-ide/src/tests.rs
@@ -10,7 +10,7 @@ use typst::syntax::package::{PackageSpec, PackageVersion};
 use typst::syntax::{FileId, Source, VirtualPath};
 use typst::text::{Font, FontBook, TextElem, TextSize};
 use typst::utils::{singleton, LazyHash};
-use typst::{Feature, Library, World};
+use typst::{Feature, Library, LibraryExt, World};
 
 use crate::IdeWorld;
 
diff --git a/crates/typst-library/src/lib.rs b/crates/typst-library/src/lib.rs
index fa7977888..3e2ce99ec 100644
--- a/crates/typst-library/src/lib.rs
+++ b/crates/typst-library/src/lib.rs
@@ -36,6 +36,7 @@ use typst_utils::{LazyHash, SmallBitSet};
 use crate::diag::FileResult;
 use crate::foundations::{Array, Binding, Bytes, Datetime, Dict, Module, Scope, Styles};
 use crate::layout::{Alignment, Dir};
+use crate::routines::Routines;
 use crate::text::{Font, FontBook};
 use crate::visualize::Color;
 
@@ -139,6 +140,11 @@ impl<T: World + ?Sized> WorldExt for T {
 }
 
 /// Definition of Typst's standard library.
+///
+/// To create and configure the standard library, use the `LibraryExt` trait
+/// and call
+/// - `Library::default()` for a standard configuration
+/// - `Library::builder().build()` if you want to customize the library
 #[derive(Debug, Clone, Hash)]
 pub struct Library {
     /// The module that contains the definitions that are available everywhere.
@@ -154,30 +160,28 @@ pub struct Library {
     pub features: Features,
 }
 
-impl Library {
-    /// Create a new builder for a library.
-    pub fn builder() -> LibraryBuilder {
-        LibraryBuilder::default()
-    }
-}
-
-impl Default for Library {
-    /// Constructs the standard library with the default configuration.
-    fn default() -> Self {
-        Self::builder().build()
-    }
-}
-
 /// Configurable builder for the standard library.
 ///
-/// This struct is created by [`Library::builder`].
-#[derive(Debug, Clone, Default)]
+/// Constructed via the `LibraryExt` trait.
+#[derive(Debug, Clone)]
 pub struct LibraryBuilder {
+    #[expect(unused, reason = "will be used in the future")]
+    routines: &'static Routines,
     inputs: Option<Dict>,
     features: Features,
 }
 
 impl LibraryBuilder {
+    /// Creates a new builder.
+    #[doc(hidden)]
+    pub fn from_routines(routines: &'static Routines) -> Self {
+        Self {
+            routines,
+            inputs: None,
+            features: Features::default(),
+        }
+    }
+
     /// Configure the inputs visible through `sys.inputs`.
     pub fn with_inputs(mut self, inputs: Dict) -> Self {
         self.inputs = Some(inputs);
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs
index 4bf8d60c8..6db99ba51 100644
--- a/crates/typst-library/src/routines.rs
+++ b/crates/typst-library/src/routines.rs
@@ -1,3 +1,4 @@
+use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 
 use comemo::{Tracked, TrackedMut};
@@ -38,6 +39,12 @@ macro_rules! routines {
         impl Hash for Routines {
             fn hash<H: Hasher>(&self, _: &mut H) {}
         }
+
+        impl Debug for Routines {
+            fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+                f.pad("Routines(..)")
+            }
+        }
     };
 }
 
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index 0673c3259..11d5c9e05 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -323,6 +323,25 @@ mod sealed {
     }
 }
 
+/// Provides ways to construct a [`Library`].
+pub trait LibraryExt {
+    /// Creates the default library.
+    fn default() -> Library;
+
+    /// Creates a builder for configuring a library.
+    fn builder() -> LibraryBuilder;
+}
+
+impl LibraryExt for Library {
+    fn default() -> Library {
+        Self::builder().build()
+    }
+
+    fn builder() -> LibraryBuilder {
+        LibraryBuilder::from_routines(&ROUTINES)
+    }
+}
+
 /// Defines implementation of various Typst compiler routines as a table of
 /// function pointers.
 ///
diff --git a/docs/src/lib.rs b/docs/src/lib.rs
index ddc956e60..e3eb21f98 100644
--- a/docs/src/lib.rs
+++ b/docs/src/lib.rs
@@ -24,7 +24,7 @@ use typst::foundations::{
 use typst::layout::{Abs, Margin, PageElem, PagedDocument};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
-use typst::{Category, Feature, Library, LibraryBuilder};
+use typst::{Category, Feature, Library, LibraryExt};
 use unicode_math_class::MathClass;
 
 macro_rules! load {
@@ -51,7 +51,7 @@ static GROUPS: LazyLock<Vec<GroupData>> = LazyLock::new(|| {
 });
 
 static LIBRARY: LazyLock<LazyHash<Library>> = LazyLock::new(|| {
-    let mut lib = LibraryBuilder::default()
+    let mut lib = Library::builder()
         .with_features([Feature::Html].into_iter().collect())
         .build();
     let scope = lib.global.scope_mut();
diff --git a/tests/fuzz/src/compile.rs b/tests/fuzz/src/compile.rs
index 3dedfb737..945e9fce8 100644
--- a/tests/fuzz/src/compile.rs
+++ b/tests/fuzz/src/compile.rs
@@ -7,7 +7,7 @@ use typst::layout::PagedDocument;
 use typst::syntax::{FileId, Source};
 use typst::text::{Font, FontBook};
 use typst::utils::LazyHash;
-use typst::{Library, World};
+use typst::{Library, LibraryExt, World};
 
 struct FuzzWorld {
     library: LazyHash<Library>,
diff --git a/tests/src/world.rs b/tests/src/world.rs
index 9b16d6126..4b6cf5a34 100644
--- a/tests/src/world.rs
+++ b/tests/src/world.rs
@@ -19,7 +19,7 @@ use typst::syntax::{FileId, Source, Span};
 use typst::text::{Font, FontBook, TextElem, TextSize};
 use typst::utils::{singleton, LazyHash};
 use typst::visualize::Color;
-use typst::{Feature, Library, World};
+use typst::{Feature, Library, LibraryExt, World};
 use typst_syntax::Lines;
 
 /// A world that provides access to the tests environment.

From 52a708b988cf7d13898194e886790acb7edd510f Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 9 Jul 2025 11:46:40 +0200
Subject: [PATCH 061/101] Move `html` module to `typst-html` crate (#6577)

---
 Cargo.lock                                    |   4 +
 crates/typst-html/Cargo.toml                  |   4 +
 crates/typst-html/src/css.rs                  | 135 ++++++++++++++
 crates/typst-html/src/lib.rs                  |  18 +-
 .../src/html => typst-html/src}/typed.rs      | 166 ++----------------
 crates/typst-library/src/html/mod.rs          |  13 +-
 crates/typst-library/src/lib.rs               |  12 +-
 crates/typst-library/src/routines.rs          |   7 +-
 crates/typst/src/lib.rs                       |   1 +
 9 files changed, 184 insertions(+), 176 deletions(-)
 create mode 100644 crates/typst-html/src/css.rs
 rename crates/{typst-library/src/html => typst-html/src}/typed.rs (79%)

diff --git a/Cargo.lock b/Cargo.lock
index 550c4141a..5526da48c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2971,8 +2971,12 @@ dependencies = [
 name = "typst-html"
 version = "0.13.1"
 dependencies = [
+ "bumpalo",
  "comemo",
  "ecow",
+ "palette",
+ "time",
+ "typst-assets",
  "typst-library",
  "typst-macros",
  "typst-svg",
diff --git a/crates/typst-html/Cargo.toml b/crates/typst-html/Cargo.toml
index 534848f96..54cad0124 100644
--- a/crates/typst-html/Cargo.toml
+++ b/crates/typst-html/Cargo.toml
@@ -13,14 +13,18 @@ keywords = { workspace = true }
 readme = { workspace = true }
 
 [dependencies]
+typst-assets = { workspace = true }
 typst-library = { workspace = true }
 typst-macros = { workspace = true }
 typst-syntax = { workspace = true }
 typst-timing = { workspace = true }
 typst-utils = { workspace = true }
 typst-svg = { workspace = true }
+bumpalo = { workspace = true }
 comemo = { workspace = true }
 ecow = { workspace = true }
+palette = { workspace = true }
+time = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/crates/typst-html/src/css.rs b/crates/typst-html/src/css.rs
new file mode 100644
index 000000000..2b659188a
--- /dev/null
+++ b/crates/typst-html/src/css.rs
@@ -0,0 +1,135 @@
+//! Conversion from Typst data types into CSS data types.
+
+use std::fmt::{self, Display};
+
+use typst_library::layout::Length;
+use typst_library::visualize::{Color, Hsl, LinearRgb, Oklab, Oklch, Rgb};
+use typst_utils::Numeric;
+
+pub fn length(length: Length) -> impl Display {
+    typst_utils::display(move |f| match (length.abs.is_zero(), length.em.is_zero()) {
+        (false, false) => {
+            write!(f, "calc({}pt + {}em)", length.abs.to_pt(), length.em.get())
+        }
+        (true, false) => write!(f, "{}em", length.em.get()),
+        (_, true) => write!(f, "{}pt", length.abs.to_pt()),
+    })
+}
+
+pub fn color(color: Color) -> impl Display {
+    typst_utils::display(move |f| match color {
+        Color::Rgb(_) | Color::Cmyk(_) | Color::Luma(_) => rgb(f, color.to_rgb()),
+        Color::Oklab(v) => oklab(f, v),
+        Color::Oklch(v) => oklch(f, v),
+        Color::LinearRgb(v) => linear_rgb(f, v),
+        Color::Hsl(_) | Color::Hsv(_) => hsl(f, color.to_hsl()),
+    })
+}
+
+fn oklab(f: &mut fmt::Formatter<'_>, v: Oklab) -> fmt::Result {
+    write!(f, "oklab({} {} {}{})", percent(v.l), number(v.a), number(v.b), alpha(v.alpha))
+}
+
+fn oklch(f: &mut fmt::Formatter<'_>, v: Oklch) -> fmt::Result {
+    write!(
+        f,
+        "oklch({} {} {}deg{})",
+        percent(v.l),
+        number(v.chroma),
+        number(v.hue.into_degrees()),
+        alpha(v.alpha)
+    )
+}
+
+fn rgb(f: &mut fmt::Formatter<'_>, v: Rgb) -> fmt::Result {
+    if let Some(v) = rgb_to_8_bit_lossless(v) {
+        let (r, g, b, a) = v.into_components();
+        write!(f, "#{r:02x}{g:02x}{b:02x}")?;
+        if a != u8::MAX {
+            write!(f, "{a:02x}")?;
+        }
+        Ok(())
+    } else {
+        write!(
+            f,
+            "rgb({} {} {}{})",
+            percent(v.red),
+            percent(v.green),
+            percent(v.blue),
+            alpha(v.alpha)
+        )
+    }
+}
+
+/// Converts an f32 RGBA color to its 8-bit representation if the result is
+/// [very close](is_very_close) to the original.
+fn rgb_to_8_bit_lossless(
+    v: Rgb,
+) -> Option<palette::rgb::Rgba<palette::encoding::Srgb, u8>> {
+    let l = v.into_format::<u8, u8>();
+    let h = l.into_format::<f32, f32>();
+    (is_very_close(v.red, h.red)
+        && is_very_close(v.blue, h.blue)
+        && is_very_close(v.green, h.green)
+        && is_very_close(v.alpha, h.alpha))
+    .then_some(l)
+}
+
+fn linear_rgb(f: &mut fmt::Formatter<'_>, v: LinearRgb) -> fmt::Result {
+    write!(
+        f,
+        "color(srgb-linear {} {} {}{})",
+        percent(v.red),
+        percent(v.green),
+        percent(v.blue),
+        alpha(v.alpha),
+    )
+}
+
+fn hsl(f: &mut fmt::Formatter<'_>, v: Hsl) -> fmt::Result {
+    write!(
+        f,
+        "hsl({}deg {} {}{})",
+        number(v.hue.into_degrees()),
+        percent(v.saturation),
+        percent(v.lightness),
+        alpha(v.alpha),
+    )
+}
+
+/// Displays an alpha component if it not 1.
+fn alpha(value: f32) -> impl Display {
+    typst_utils::display(move |f| {
+        if !is_very_close(value, 1.0) {
+            write!(f, " / {}", percent(value))?;
+        }
+        Ok(())
+    })
+}
+
+/// Displays a rounded percentage.
+///
+/// For a percentage, two significant digits after the comma gives us a
+/// precision of 1/10_000, which is more than 12 bits (see `is_very_close`).
+fn percent(ratio: f32) -> impl Display {
+    typst_utils::display(move |f| {
+        write!(f, "{}%", typst_utils::round_with_precision(ratio as f64 * 100.0, 2))
+    })
+}
+
+/// Rounds a number for display.
+///
+/// For a number between 0 and 1, four significant digits give us a
+/// precision of 1/10_000, which is more than 12 bits (see `is_very_close`).
+fn number(value: f32) -> impl Display {
+    typst_utils::round_with_precision(value as f64, 4)
+}
+
+/// Whether two component values are close enough that there is no
+/// difference when encoding them with 12-bit. 12 bit is the highest
+/// reasonable color bit depth found in the industry.
+fn is_very_close(a: f32, b: f32) -> bool {
+    const MAX_BIT_DEPTH: u32 = 12;
+    const EPS: f32 = 0.5 / 2_i32.pow(MAX_BIT_DEPTH) as f32;
+    (a - b).abs() < EPS
+}
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index 19eb14464..7063931b7 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -1,7 +1,9 @@
 //! Typst's HTML exporter.
 
+mod css;
 mod encode;
 mod rules;
+mod typed;
 
 pub use self::encode::html;
 pub use self::rules::register;
@@ -9,7 +11,9 @@ pub use self::rules::register;
 use comemo::{Track, Tracked, TrackedMut};
 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::foundations::{
+    Content, Module, Scope, StyleChain, Target, TargetElem,
+};
 use typst_library::html::{
     attr, tag, FrameElem, HtmlDocument, HtmlElem, HtmlElement, HtmlFrame, HtmlNode,
 };
@@ -20,9 +24,19 @@ use typst_library::layout::{Abs, Axes, BlockBody, BlockElem, BoxElem, Region, Si
 use typst_library::model::{DocumentInfo, ParElem};
 use typst_library::routines::{Arenas, FragmentKind, Pair, RealizationKind, Routines};
 use typst_library::text::{LinebreakElem, SmartQuoteElem, SpaceElem, TextElem};
-use typst_library::World;
+use typst_library::{Category, World};
 use typst_syntax::Span;
 
+/// Create a module with all HTML definitions.
+pub fn module() -> Module {
+    let mut html = Scope::deduplicating();
+    html.start_category(Category::Html);
+    html.define_elem::<HtmlElem>();
+    html.define_elem::<FrameElem>();
+    crate::typed::define(&mut html);
+    Module::new("html", html)
+}
+
 /// Produce an HTML document from content.
 ///
 /// This first performs root-level realization and then turns the resulting
diff --git a/crates/typst-library/src/html/typed.rs b/crates/typst-html/src/typed.rs
similarity index 79%
rename from crates/typst-library/src/html/typed.rs
rename to crates/typst-html/src/typed.rs
index 8240b2963..4b794bbba 100644
--- a/crates/typst-library/src/html/typed.rs
+++ b/crates/typst-html/src/typed.rs
@@ -11,19 +11,20 @@ use bumpalo::Bump;
 use comemo::Tracked;
 use ecow::{eco_format, eco_vec, EcoString};
 use typst_assets::html as data;
-use typst_macros::cast;
-
-use crate::diag::{bail, At, Hint, HintedStrResult, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{
+use typst_library::diag::{bail, At, Hint, HintedStrResult, SourceResult};
+use typst_library::engine::Engine;
+use typst_library::foundations::{
     Args, Array, AutoValue, CastInfo, Content, Context, Datetime, Dict, Duration,
     FromValue, IntoValue, NativeFuncData, NativeFuncPtr, NoneValue, ParamInfo,
     PositiveF64, Reflect, Scope, Str, Type, Value,
 };
-use crate::html::tag;
-use crate::html::{HtmlAttr, HtmlAttrs, HtmlElem, HtmlTag};
-use crate::layout::{Axes, Axis, Dir, Length};
-use crate::visualize::Color;
+use typst_library::html::tag;
+use typst_library::html::{HtmlAttr, HtmlAttrs, HtmlElem, HtmlTag};
+use typst_library::layout::{Axes, Axis, Dir, Length};
+use typst_library::visualize::Color;
+use typst_macros::cast;
+
+use crate::css;
 
 /// Hook up all typed HTML definitions.
 pub(super) fn define(html: &mut Scope) {
@@ -705,153 +706,6 @@ impl IntoAttr for SourceSize {
     }
 }
 
-/// Conversion from Typst data types into CSS data types.
-///
-/// This can be moved elsewhere once we start supporting more CSS stuff.
-mod css {
-    use std::fmt::{self, Display};
-
-    use typst_utils::Numeric;
-
-    use crate::layout::Length;
-    use crate::visualize::{Color, Hsl, LinearRgb, Oklab, Oklch, Rgb};
-
-    pub fn length(length: Length) -> impl Display {
-        typst_utils::display(move |f| match (length.abs.is_zero(), length.em.is_zero()) {
-            (false, false) => {
-                write!(f, "calc({}pt + {}em)", length.abs.to_pt(), length.em.get())
-            }
-            (true, false) => write!(f, "{}em", length.em.get()),
-            (_, true) => write!(f, "{}pt", length.abs.to_pt()),
-        })
-    }
-
-    pub fn color(color: Color) -> impl Display {
-        typst_utils::display(move |f| match color {
-            Color::Rgb(_) | Color::Cmyk(_) | Color::Luma(_) => rgb(f, color.to_rgb()),
-            Color::Oklab(v) => oklab(f, v),
-            Color::Oklch(v) => oklch(f, v),
-            Color::LinearRgb(v) => linear_rgb(f, v),
-            Color::Hsl(_) | Color::Hsv(_) => hsl(f, color.to_hsl()),
-        })
-    }
-
-    fn oklab(f: &mut fmt::Formatter<'_>, v: Oklab) -> fmt::Result {
-        write!(
-            f,
-            "oklab({} {} {}{})",
-            percent(v.l),
-            number(v.a),
-            number(v.b),
-            alpha(v.alpha)
-        )
-    }
-
-    fn oklch(f: &mut fmt::Formatter<'_>, v: Oklch) -> fmt::Result {
-        write!(
-            f,
-            "oklch({} {} {}deg{})",
-            percent(v.l),
-            number(v.chroma),
-            number(v.hue.into_degrees()),
-            alpha(v.alpha)
-        )
-    }
-
-    fn rgb(f: &mut fmt::Formatter<'_>, v: Rgb) -> fmt::Result {
-        if let Some(v) = rgb_to_8_bit_lossless(v) {
-            let (r, g, b, a) = v.into_components();
-            write!(f, "#{r:02x}{g:02x}{b:02x}")?;
-            if a != u8::MAX {
-                write!(f, "{a:02x}")?;
-            }
-            Ok(())
-        } else {
-            write!(
-                f,
-                "rgb({} {} {}{})",
-                percent(v.red),
-                percent(v.green),
-                percent(v.blue),
-                alpha(v.alpha)
-            )
-        }
-    }
-
-    /// Converts an f32 RGBA color to its 8-bit representation if the result is
-    /// [very close](is_very_close) to the original.
-    fn rgb_to_8_bit_lossless(
-        v: Rgb,
-    ) -> Option<palette::rgb::Rgba<palette::encoding::Srgb, u8>> {
-        let l = v.into_format::<u8, u8>();
-        let h = l.into_format::<f32, f32>();
-        (is_very_close(v.red, h.red)
-            && is_very_close(v.blue, h.blue)
-            && is_very_close(v.green, h.green)
-            && is_very_close(v.alpha, h.alpha))
-        .then_some(l)
-    }
-
-    fn linear_rgb(f: &mut fmt::Formatter<'_>, v: LinearRgb) -> fmt::Result {
-        write!(
-            f,
-            "color(srgb-linear {} {} {}{})",
-            percent(v.red),
-            percent(v.green),
-            percent(v.blue),
-            alpha(v.alpha),
-        )
-    }
-
-    fn hsl(f: &mut fmt::Formatter<'_>, v: Hsl) -> fmt::Result {
-        write!(
-            f,
-            "hsl({}deg {} {}{})",
-            number(v.hue.into_degrees()),
-            percent(v.saturation),
-            percent(v.lightness),
-            alpha(v.alpha),
-        )
-    }
-
-    /// Displays an alpha component if it not 1.
-    fn alpha(value: f32) -> impl Display {
-        typst_utils::display(move |f| {
-            if !is_very_close(value, 1.0) {
-                write!(f, " / {}", percent(value))?;
-            }
-            Ok(())
-        })
-    }
-
-    /// Displays a rounded percentage.
-    ///
-    /// For a percentage, two significant digits after the comma gives us a
-    /// precision of 1/10_000, which is more than 12 bits (see `is_very_close`).
-    fn percent(ratio: f32) -> impl Display {
-        typst_utils::display(move |f| {
-            write!(f, "{}%", typst_utils::round_with_precision(ratio as f64 * 100.0, 2))
-        })
-    }
-
-    /// Rounds a number for display.
-    ///
-    /// For a number between 0 and 1, four significant digits give us a
-    /// precision of 1/10_000, which is more than 12 bits (see `is_very_close`).
-    fn number(value: f32) -> impl Display {
-        typst_utils::round_with_precision(value as f64, 4)
-    }
-
-    /// Whether two component values are close enough that there is no
-    /// difference when encoding them with 12-bit. 12 bit is the highest
-    /// reasonable color bit depth found in the industry.
-    fn is_very_close(a: f32, b: f32) -> bool {
-        const MAX_BIT_DEPTH: u32 = 12;
-        const EPS: f32 = 0.5 / 2_i32.pow(MAX_BIT_DEPTH) as f32;
-        (a - b).abs() < EPS
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/typst-library/src/html/mod.rs b/crates/typst-library/src/html/mod.rs
index f98352061..ca2cc0311 100644
--- a/crates/typst-library/src/html/mod.rs
+++ b/crates/typst-library/src/html/mod.rs
@@ -1,23 +1,12 @@
 //! HTML output.
 
 mod dom;
-mod typed;
 
 pub use self::dom::*;
 
 use ecow::EcoString;
 
-use crate::foundations::{elem, Content, Module, Scope};
-
-/// Create a module with all HTML definitions.
-pub fn module() -> Module {
-    let mut html = Scope::deduplicating();
-    html.start_category(crate::Category::Html);
-    html.define_elem::<HtmlElem>();
-    html.define_elem::<FrameElem>();
-    self::typed::define(&mut html);
-    Module::new("html", html)
-}
+use crate::foundations::{elem, Content};
 
 /// An HTML element that can contain Typst content.
 ///
diff --git a/crates/typst-library/src/lib.rs b/crates/typst-library/src/lib.rs
index 3e2ce99ec..5d047570b 100644
--- a/crates/typst-library/src/lib.rs
+++ b/crates/typst-library/src/lib.rs
@@ -165,7 +165,6 @@ pub struct Library {
 /// Constructed via the `LibraryExt` trait.
 #[derive(Debug, Clone)]
 pub struct LibraryBuilder {
-    #[expect(unused, reason = "will be used in the future")]
     routines: &'static Routines,
     inputs: Option<Dict>,
     features: Features,
@@ -200,7 +199,7 @@ impl LibraryBuilder {
     pub fn build(self) -> Library {
         let math = math::module();
         let inputs = self.inputs.unwrap_or_default();
-        let global = global(math.clone(), inputs, &self.features);
+        let global = global(self.routines, math.clone(), inputs, &self.features);
         Library {
             global: global.clone(),
             math,
@@ -282,7 +281,12 @@ impl Category {
 }
 
 /// Construct the module with global definitions.
-fn global(math: Module, inputs: Dict, features: &Features) -> Module {
+fn global(
+    routines: &Routines,
+    math: Module,
+    inputs: Dict,
+    features: &Features,
+) -> Module {
     let mut global = Scope::deduplicating();
 
     self::foundations::define(&mut global, inputs, features);
@@ -297,7 +301,7 @@ fn global(math: Module, inputs: Dict, features: &Features) -> Module {
     global.define("math", math);
     global.define("pdf", self::pdf::module());
     if features.is_enabled(Feature::Html) {
-        global.define("html", self::html::module());
+        global.define("html", (routines.html_module)());
     }
 
     prelude(&mut global);
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs
index 6db99ba51..a81806fd5 100644
--- a/crates/typst-library/src/routines.rs
+++ b/crates/typst-library/src/routines.rs
@@ -8,8 +8,8 @@ use typst_utils::LazyHash;
 use crate::diag::SourceResult;
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
-    Args, Closure, Content, Context, Func, NativeRuleMap, Scope, StyleChain, Styles,
-    Value,
+    Args, Closure, Content, Context, Func, Module, NativeRuleMap, Scope, StyleChain,
+    Styles, Value,
 };
 use crate::introspection::{Introspector, Locator, SplitLocator};
 use crate::layout::{Frame, Region};
@@ -92,6 +92,9 @@ routines! {
         styles: StyleChain,
         region: Region,
     ) -> SourceResult<Frame>
+
+    /// Constructs the `html` module.
+    fn html_module() -> Module
 }
 
 /// Defines what kind of realization we are performing.
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index 11d5c9e05..591e5a9b9 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -357,4 +357,5 @@ pub static ROUTINES: LazyLock<Routines> = LazyLock::new(|| Routines {
     eval_closure: typst_eval::eval_closure,
     realize: typst_realize::realize,
     layout_frame: typst_layout::layout_frame,
+    html_module: typst_html::module,
 });

From e5e813219edd3553535c4c6cf885138dbc9f3f9a Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Wed, 9 Jul 2025 14:01:57 +0200
Subject: [PATCH 062/101] Fix typo of Typst domain in quote docs (#6573)

---
 crates/typst-library/src/model/quote.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-library/src/model/quote.rs b/crates/typst-library/src/model/quote.rs
index 9960b7587..5ce4a92f5 100644
--- a/crates/typst-library/src/model/quote.rs
+++ b/crates/typst-library/src/model/quote.rs
@@ -102,7 +102,7 @@ pub struct QuoteElem {
     /// }
     ///
     /// #quote(
-    ///   attribution: link("https://typst.app/home")[typst.com]
+    ///   attribution: link("https://typst.app/home")[typst.app]
     /// )[
     ///   Compose papers faster
     /// ]

From 9ad1879e9d0978d828790fdf7978ba4aff240a71 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 9 Jul 2025 14:02:13 +0200
Subject: [PATCH 063/101] Anti-alias clip paths (#6570)

---
 crates/typst-render/src/lib.rs                |   4 ++--
 tests/ref/block-clip-svg-glyphs.png           | Bin 1862 -> 1938 bytes
 tests/ref/block-clip-text.png                 | Bin 908 -> 965 bytes
 tests/ref/block-clipping-multiple-pages.png   | Bin 2029 -> 2085 bytes
 tests/ref/box-clip-radius-without-stroke.png  | Bin 1255 -> 1256 bytes
 tests/ref/box-clip-radius.png                 | Bin 1250 -> 1255 bytes
 tests/ref/box-clip-rect.png                   | Bin 1680 -> 1691 bytes
 .../closure-path-resolve-in-layout-phase.png  | Bin 2256 -> 2263 bytes
 tests/ref/hide-image.png                      | Bin 8877 -> 9123 bytes
 tests/ref/image-baseline-with-box.png         | Bin 6375 -> 6613 bytes
 .../issue-5499-text-fill-in-clip-block.png    | Bin 1502 -> 1518 bytes
 tests/ref/issue-6267-clip-anti-alias.png      | Bin 0 -> 251 bytes
 .../ref/transform-rotate-relative-sizing.png  | Bin 2414 -> 2491 bytes
 tests/ref/transform-scale-relative-sizing.png | Bin 2023 -> 2034 bytes
 tests/ref/transform-skew-relative-sizing.png  | Bin 828 -> 834 bytes
 tests/suite/layout/container.typ              |   7 +++++++
 16 files changed, 9 insertions(+), 2 deletions(-)
 create mode 100644 tests/ref/issue-6267-clip-anti-alias.png

diff --git a/crates/typst-render/src/lib.rs b/crates/typst-render/src/lib.rs
index f43cd019b..2c57fe2db 100644
--- a/crates/typst-render/src/lib.rs
+++ b/crates/typst-render/src/lib.rs
@@ -202,7 +202,7 @@ fn render_group(canvas: &mut sk::Pixmap, state: State, pos: Point, group: &Group
                 mask.intersect_path(
                     &path,
                     sk::FillRule::default(),
-                    false,
+                    true,
                     sk::Transform::default(),
                 );
                 storage = mask;
@@ -218,7 +218,7 @@ fn render_group(canvas: &mut sk::Pixmap, state: State, pos: Point, group: &Group
                 mask.fill_path(
                     &path,
                     sk::FillRule::default(),
-                    false,
+                    true,
                     sk::Transform::default(),
                 );
                 storage = mask;
diff --git a/tests/ref/block-clip-svg-glyphs.png b/tests/ref/block-clip-svg-glyphs.png
index 0fc2c962fc63fb26f6828d5c67a72bc22da6c4cc..bf13b7ea6f19a6fc430029ae27cc8ee4bbf8d26b 100644
GIT binary patch
delta 1923
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
JPDHLkV1hZm$Uy)A

delta 1847
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

diff --git a/tests/ref/block-clip-text.png b/tests/ref/block-clip-text.png
index 8c82bc30934ebef06296654c08655e8a7d4df64d..2b099b48a2b6071e1bf84cf639b4618a5cc3c6bd 100644
GIT binary patch
delta 943
zcmV;g15o^o2gL`FB!7%aL_t(|+U?ovOOtH?$MOD#=gsr(fhQt5X=;a|Wf_fZZ(P$g
z4|kTCmTpeXxolf`UxrvQquIgCLzLEHW#=+QvO?0*5IYfBt1MTh*-6_x%=;HP3p6Q+
z`)Ux^_uVeWKCl-z*Y=wPFExq53}*1(1e2d-h&KIrC=N`f|9>Nwa=a%!KQ5nywV8a@
ze`C%<cyVBU3VQtDX)eY#B*mFL^!biCBx1o+J4^S&e881-qh<0TCjbl<Y_E6cmmb8~
z8D$z}E!NP1C)aFS>Aac={sJVPvxcOPZ6)O}l=n$-W+zZU2c8CG9IMYn?!|BLa8BUU
z<Z4uI9)<5vfq%FD3nbRvj}+pH5HR3w08r^XSy-V4xzrtm^W-z?slX8_g~wX~Oa9R!
z!D4YK1mH$Nu?sef4QJDDzfHaF<SD@8Kc@ErCW<}`F!-;92b%iEyrZWHqxIi((S*AL
z9%Hm2H-JVTJUNZ8b<T7EfRhpo?kPr7bpU__=*LJaI)4Gw5V7G<oju{&BdwjQ+PD|p
zr}=jd|6R{UU`rWVPHx@PtEf#YhCxvyGOQ2A`l`VqaEGw~=ii*#4aIAWz?TgOMP4-&
zHemrS=8FDRueryo&UJ&cWAVVN!n};{aGe2Rts2MI*Ag0VL*O&H8Bjh%;HOp3>(UV3
zE&#)`aDO=i`Hdd{Sv&lOs<H)<;SjQn#BCty0pY2$Bcqop=jm1k=?IDONnA2tzi_^v
zG}T|F@#XaX9Ptz)4h;S$Z4Bo5MaJ=`pntvXmzP;<y>qV?*e?lD;lan4xb{Apuz;&G
zFkxMDn<>Jb(SQUKr*5GL+vZpictzLh%Bj^4HGdqi4&Ta#wHz-`nfJd^S8pk%26sdN
z|KGfufSeS2dn}Ha;ETJfpzJTHfO@-gp_?Ww!Fw6Zl{iY!5ey01Vi9#`M<diN2<xH+
zJHmk3=#nDuIGSW=Ou`&@vl9EN+knJdkU40<g0i$~`GXVk=ESsKROIaJLAj|U!k(*+
zGk-f`_Pq!{{AV8^t~6lBOD{aR+@UtB%{!0GckJ&b1~Zt!3}!Hcy}n6&i`pg;B-;?L
z<vkhsaj7!Wjl4<DHVL*#{1%+;txY1CZ4wM-n*`e=eivTntxdwnHi<vCNvtF3nPhWx
za#m!DHeMZL)WjMH(W-Q7Ipb<BDn2VpvnVN2Yl=#xyh;2zcCThIgBk3Vz5pvjypHs5
R@~Qv;002ovPDHLkV1j<3%C`Uj

delta 885
zcmV-*1B(2`2aE@hB!5#$L_t(|+U?o@Pt<h)$8rCLe(ATiTx(^4faVRAqIHY-1v)q}
zJe{;b(P5y#tuE5{hsIEMw2o3FzBB_ncZpw8Ll_HdOi*YHt=7U$BRL}wzkzprIX+M4
zK!<wM&3)dxP2bPoK0iHv`|SOGzZMXo7ARQ33Vxhm?Lj#+OMkTcG6vROd@9v!6SFzQ
zJw;`|TP!|$M$9i!7z2yv7>!}JrQF@LnS<qwM>9XoDERrIx}CUo1#?gIF8n3{Fjcv=
zBUDlMHHQ|}=ULlWF9%-O`q`?$@nXagOaRcCd#%5=0cXRwnS<M*QV#qA6n@uHOxe-f
z@Jwm^xer=s`hR#1J}m{_{50gW|Grw!swQqS)Cn{N_Ek07(S96R&SC8a9a7-*4OM&l
zz+JJYT6epH79CDh)&%joy&T&3>!ti(0zwKbnBUkD!X+OD1wXd%WcN7p8|`MUiIYK@
z@JQTQ=9&%xT~Yjf0Dz&F`~U$-Ft&5dl`#llf(Zb4dw&RM)r^LdihS8W|Mj8I*1YK}
zMh=L}{@BmY118+{^zPgI<(Q?dpa!R<)nM3>z<bS8)!25kg2Vss{{qW@049z(Nus<3
zi&tO4(J~B%#roew#t$Rde7rV!v8ufA4&3e}r7zEa>)Rv)?u<X5>H_PZ#9v?gPkRAr
z13JvS%zv>$D!Q&h@&GZ@&0BPX;Y96CE$e-4V_aJP;?<dNSYIhxwY*5v)<osJzRa<5
zS&TV9HX|?E=7_avvn3h>BOcJE1R-AiMBEedkGB)4^`5rKoU3(plQ0yXI!pKl#%01f
z#}^T{;iWwi;h{`05k7mbMA*B;L;O!geZkT;$A5I^F3-%VEqEHZu-~=wqP^wQ8foxg
zIy`&wOg5z(d;{zFwuETTti?J}+lYN@U}Z=qY~o5Xt|s<q3?^Wre;x0f-qwY^my}^y
zus;PBGi;`OFWt#><+3EyV`WE6KjfSu*)I#$t#!?B{qcQjPfo!YjiuX1X(*{p_m$bR
zTyFj~JN`}EEej4`umHAQh`^sKl;rhzi2w|j)pL`A6|7(dD_Fr1+aw+y23^d>!&94t
z+9Vzgj?^Y0)Fz=|wMnQ=;*sG<Z4yFl5>NCd5k7UUR<ME<9FcAUMDDs~al;=a00000
LNkvXXu0mjfHLA9)

diff --git a/tests/ref/block-clipping-multiple-pages.png b/tests/ref/block-clipping-multiple-pages.png
index 0b6e7c85f845e069aea67125212b33eba281eea2..1305ff204c5ccad8a724f8b76ab4236089d5a8cc 100644
GIT binary patch
delta 2072
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
C+7cT8

delta 2015
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

diff --git a/tests/ref/box-clip-radius-without-stroke.png b/tests/ref/box-clip-radius-without-stroke.png
index 2be772cc529cf8bd856067ace6e11a93208eccdf..c7d83de2253009cb7f637b110c87a2a5a2fefcdf 100644
GIT binary patch
delta 1236
zcmV;_1S|XJ3FrxsB!90-L_t(|+U?rOZyQw{!13Ab@iJawXQ`JgP1+`DBP5_{C=$>`
zDM)bW0f8!(1OEU=Zu}WY8~|~Ef&_>~P=OGrpooIlA~k6mJC2ih>Lp{3GxKJ9Zytku
zspx^sfdlIAD<AxRn$t&5PxiA}N+|>V_i;b~&;ShqG(ZD11b@%~4FUB39oqN(yO-a5
z_4yYcT~$@}?xEv2>+5UXt_H04#vbM?IL25Igw4&(dacT_Oe!fKohUgL>Kk^ed*FCD
z8jTTxBfLLR93dFXiHwpj0B$(wf%5kDHtOsaiv>c6&$5>7P@f6{rzmNG^KH~)DK+~2
z&VDx%Pw8#-<bUEhS;>O$VWEBB=Qu8S^Yy169-E$G#fWDk*R_4(Nzu3{ML3RkZG#d+
z;swhvT}%Z@_B;=J_`!3}fbU_?=z;Rpx8E4er4595j<JzpbX)juN;i19j@@lHU1X{C
zdZ(kYLX@FC!%)=k0Pfuh%)j;iJ8zb9iN@Xz$M}sZBYy}&Ze)xwETxQNIXgQwj-}0(
z-EOy)%upm@r!!fR5|)A6*O1V}(h;JzWo3r)J#F8y?7oS3F%nNC3Be4dv1E$lrSuTz
zV+Wb0$P1dTkB$rjZV2dLpAO~n#6>J8^t)PAjs{ED#n>mFYZFYSre`>w$JldhJ3uEs
zbsbdO-hZxEZqF^A2j9b<(bY<2Y;+hQgguX7Y##LGSX`9E{BXWdDl1A-lq5EI&c_V#
zBvDGHv;703JU(&b#tpy?v7^m?*LORPdB97NL~dBuItK^+?tTXooF3w%F}c~;rP#4d
z<olH4`NGukPEXHf(vvgC0XGD6d2;&pk890VtAA2gkB%3H$Bt<G`wlYK)jdfPB{|W)
zqaK|YCz!O`Eo50cwW=q|jm941`+ytb=$M|F=^-o1vs&Ny<l6Vu%}Twt)zNy`^K8@L
z8UJQwXJczSd!$%CHkZzi=*UK<sde>OA_2JJK6MODEZALbESIe}wF}R_vhv-v_0?Zp
z&wt|>=HxuTwo&byw#YKS|FQbpts2Ym%NL)}4HS(7bjVAk$1g04@s!$ZJ%8n;GfPXa
zzV`au>Bo9{fN8J%^h-{W8}*uYXKys0E#%X>u3!IQWp7Wty}1Rr;dZnriVo#1%N8YZ
zFv*XM-KweiZ0h{QONCOo+tZz%s<_7NWPizay!nUDE<g3Oq9}kH0-6xQ2gOrzOeO>m
zh8ycQB}t?Vd-=H+=H};v$?EE#)s@eD-=8cRS6+O1@yrs)hCVt5Hy+W5gbZ`ATwFR^
zI5Ki-VIfe)7(0%0>ePZQWs0RjOqQE>)WO{};D&(adA`+ZwYSzOWq!W?Eg>WrE`MKo
zvRs}l4W~Z-;5|VQf@gwZVQQ9Th+|oaq!KJ8Ndnw(XLKf$DbAn9(d@&IJUTG-JTDrH
zS9e>T{V!)19yoDgHW)S=yK+2PDvVV&*3O;3z_Kjh-g6%vCQ505NGa8IJr;`zf-pE+
zuD<&g((19ea(4N0u`~{{|A>WulTE^}-~bH)G(ZD11keBt0W?4ZGz8E94FNPj12hEC
y01W{&Km#-c&;ShqG(ZD11keBt0W?70$NdFR&PlLAbQQ(`0000<MNUMnLSTYSt6YZw

delta 1235
zcmV;^1T6dL3FirrB!8|+L_t(|+U?rOZyQw{!13Ab8QWvWv9r`mlQe0Yghm|b5{ksq
zR4GVY5Moiqa^S!fi3>L_{0j()10W7ikN~j=Di8t{6g42WNNt+Nj^iYr+GCGB&di(b
zy%`4iQmIH}4jd4_uY9n78ecvd{bWCz4uXJ!{{0vr0BC@Q0Dl^w0U82mfQA72zYa|Z
zp>FG&uRj0cqf3gS+&*+1XLa=|nEq|_LB4`xj5&_m+}y0!stiq~Q{s_{l4GI1VYj;b
zj)&uMi4YuP{fXiz!Pv8{;_OMljRrkX-rn9u?cHLrKnU?^+OnO%4>*pI<qXI8HtNwq
zVD$U#PB)fF>wl_p^8Dj~8v)w)eTHGeCtrX1;nC?SnvZ!la$Vaeo)Ay)LX2Tp*ERxT
z2rOqAri%kk5IxUR8}+3pUj*NS?&yK?rMKT0%Vi9NScbBZVRT#A^RVZJ57)7~YSTrQ
zQm?n$8qLM2z^AAn783yX_BiUFdjFj_OSxoYZ-=4$Mt_y!I4(CjPAEDED93Vkc4`bA
zG+VZ+s`AiqENN$kvV1^j3Qk`mLK90zD6lPSXgJ@~I*w)cO~mrCL^4GPrh-69r5RSp
z3^P7<kZJNPr|J6G=m_9OfL2v?IF~0bq8YB=)#742eCfIv`^0l?g2~kM48yV*dyZ{~
z=)@0P2Y=PJx2u(#bEnUN??HETwNe=$8$k$R&m$O{`+ZSL@B*J7$rnmxSx)hSK!?})
zm?ECQ3#m-Dzi*TePpq!40&avm+U$3Ix9ynwtPo4)Ms%&czu)h6+L++XFdLV|W@9(N
zj%6a>4;Yp$OdV_Y^z2Y(a^@J|Mu09)PT&0TdVjOks??PuhYKU)hqO+|LFT%$CkVVC
zCe>TYk%_|u6IE>?%i5_`Jzi`y_9)*6+z6{<dS<4FtT;<+edCkM-&Z#)_1acj>tWBc
zO@pQUYn7dit?lfgV)^J?CO@hp8=0oo)um(-aHD<d7@k<LyV`gzTW@MhPrR`5-R1SQ
zUw>TBV<_sbdG`87wQt%yP5t)!+OIciG{Y{Re^572JOR)V50xHRTILgJrP+G=;&W#f
z7hihi)wxsm_w*3cUb*^nP8J*Wns#e%ET1jpGrF!{`C(;mPr13d1-Q}fXrAYtfVC`}
z7x=*>KRSM+rsT8fbLTG<O66`(cY2EK8h^8sCEM}l?>W2t$fL3>18xLpLI@j{NQ;t4
z2p$YK)~^WyA5ipTPdzg?KOauk*8ZrjeCGT9WYM_z?DMD3EP`yb)e!{2;KU;y6OdsJ
zhNl<L77mS`SXc;^F~*MLoH(&y3q!?HK@!F0EhW4LAq2P)pgE3fwOZ=ddI<j0m49ys
z$N$S09xj(BOC#xzKX@;^fMwZmSeTlnDdJdGG9`yEB}oF@XggY#<>LG)9M7J-_r8It
z=Xr4{QQd8|J73N&+<pA`Y&dK-cEv=hR2Z*pTz}}?639kA_`h?R(DYyL(sf;uB#z?-
zyXDfmZy~MTX*FMd?R8+iGaCL)3QWI(12hEC01eO(Km#-c&;Sk45I_So1keBt&=5ca
xGz8E94bTuk12hEC01eO(Km#-c&;b2E?oXEmOzy=bU0VPE002ovPDHLkV1h1eTlD|{

diff --git a/tests/ref/box-clip-radius.png b/tests/ref/box-clip-radius.png
index 530d533099bc5dd821abc2432e95ad8943c36681..fb27bb74d68f8a0a4c33097c2e00814572462e6c 100644
GIT binary patch
delta 1235
zcmV;^1T6dF3FirrB!8|+L_t(|+U?rOPa9Vp!13Abv9ZSnn}iq>0%@y+fH<@Plu8Db
zh@@%{%^_+VbwO(H^`)pM_zO5!^wOTX9g3Pmg(}scRH9L<Zm5Y93C9?)@q+EK$FsgS
zuTQd6RXG5zlq!ecSN2GLdcVs@qZ!#AmJq@~Pd*L^02-hnfPV&PfQA4XprI!Ky}rIa
zGcywohuITEx6#dX1Y{qN9NFUHBJ-c3g9Q3lEPWq+E-Q*c)#m5tE0szvo8eeS3CP2P
zam&yfnpvtfEeCnMK8%rvcZUc2|4MJa^4d*RRa2?d^z<~G%I%JVrc4_f8_Ubf$z*b8
zXGgE>_4mgx#(yr$8m2{DA_!bC7!o+w)axuETBA`pta<!O=27nYjW-jC1YAQ-1Whlv
z^?JQltA#?L@4x-}+4DoJ=y6QlwoMm1lGiUv9**N}QzKZDc)`$GHX?!~6PCL)IZLPL
zED#@mGo;G&NWH%N^yAZ!kf!TA$C$dN)k?^5kYm%AZGV}ya?#d}LM~USR9V5x5Et2I
zdmMcKNnnoai_boZN4oO+yBy=@GmIbzkyCw`VF_U@!`j`=ax5v9%yPLL4EK1t%uu*n
zBp75nhQ@}f>%=sSa8I;eJ+ut7(b9R*<L?S!j2J?E0fpnGP!H!KOK-JAUZ|=n$aW0f
z6NzG5XMZ`NQLB1oFa2oS2)Wp?O^oo+`DZwuN64{ElcHmn*p{B%*#X&(zp(V3?$vc2
zISxjs)ojQ<zbJ{(-e@d75DW%HNn+_H7ctn8L@5yJZZx%lvx6Yp@foexD^{z?OP;Ps
zuUf4%n~mCG1z{BG;k`b&nBODFGFrOp5{~C%Lx0az>S}j51hO4N*DK{>skEId44;kl
z_MNF79$I=UUD%f-QIfmL2ZiCmvl!uWxuhG$ZZ_kHaz4KgvYkWghL>ln4Q*>}WA??%
z0VT)_BI7!)W684b-u5mg%nK8fayW93-&55lBe>NX+zdO1?in02Yt_C;cdl5Sz4_ke
z`hQw_>sQ-xIEJ}2!ry<GX|zm{Wq$u->$eA4mgDEH&ZwFWvK`+Hr)TFxzfvfc-njM7
z<kVF1qos?N6Lpnhnwxiji3H_*E?Yg=KOOCkMMJ8p-uZEJf4=~-9iP#nC|ZO!3{#ZE
z_Db|r--B!++O52F^;#@GP^+s}y%4mu3xDV0rsa%0e`W6FS8uPS0Jk$}mSuUrBKu^F
zQG4ZK`ko|-gkf*I{?^5j5xTOq^=D@Dw(Gj*`n6kczdJEG1+pDnIuu1||75{&oYy1i
zTC2T2F?A(&=G5re7*$3HS(Y_AI%Z1Y{&>tM%f*8N9chn)?}?zt$H(b$Wo4!OD1S`|
z^Yfh_FvfIc?%MT%fphU*<(scQ7X*RldAb-Iy1+8nGK{W3aCLRHJr2Gnf?ir$qQ`}W
zg(~rnP0qak!G~>A$8o$qe`c?=nfflBzE7>`Vllrb`vaFoNALc$nM@|z<KPQ_W&PhV
z<hW9)R3ec$;RTm&qnqgn$UYVek4){ta~%K;0W?4ZGz8E94FNPj12hEC01W{&Km#-c
x&;ShqG(ZD11keBt0W?4ZGz8E94FUAi*x$W*!Z0}9c3S`d002ovPDHLkV1n3!V9Nji

delta 1230
zcmV;<1Tp*P3E~NmB!8(%L_t(|+U?rSYa?YG!0~xcCTTKBo3z_a)7Mqm)|Mi=ZCNob
zcIm2k@gT~gwxIX+B6w>4gI)zM_2k>Z;tEnk)3Ra}MOO>E*_DlHUYnODnPf8W&pbX5
z5ZOc92rC|bUy^}5Jip6_VTL3_V~i>2(Z>J*Km#-c&;Sk45Pv`eH1r6d_xARdmX?CS
zAbpO=HnN$Ffb7HJQ`_9!r2bW85JUfnChybFWl56a@%ZZMYPDL;q*Dw{Nj`C6G-_yS
zQ_;)ymSNd$w+A8H#X6%y17Cjg!}|KVEX#>RVsUX1PUTLgK@+C^{r#=2EdqCRbfi{u
zLqidSkVDg&Zhv40a~$LM2RO#j)dr2R(ri{w>MpPJ{p~;2*4ARN7+gcn1x+rvjYgwh
zuLlBwufO>0@k`@0@3M5&G<64Ag4@drE{0)EUBO5ZSWZ*grj0p4v@C1(xtGWknFZpr
zZ-zvf9EsN_+wWfp1r$|f8A?|brCzoz%eGANG7Y_6DSw%&R?K9o)f&yYDeO=b?u>))
z-*MDgef;4E(NIqzpJgbgkfJz_3k?h+ipH2SG$Wf$Gc+!h^-87U5B9lw^gyte#|UJ*
zhDMsKs#w>wU|+aVJ25o9*;ZNJ<?ZnyWK$S>d=kS7fj-8u4Yl3oS*|9_Alo%`Unq=B
zm1ekRy?^Ew-Q=Tb+O~r%Q%5!$zw{WxvbJp*x=zrMgH1zCA02^g*I!r$FZ8RbYFiev
z?RKjvdc3^Ahx@~k=&;}K;{|~xn;e@$mcR?XKyS0943CV0Y}aSB+Nc`s7Av@VLj7{B
z+G;iHCsiBSfj-vl5le*}whgVVIu2%7HZuN1wSOV^1_L15HFTp|DV56)GR29JNdMr)
z+R2Hbwv)xYAn=0NQ#me9jE*21RVrmw)3WK5#fybP9%Q?RRy8+E*P6=V?*8(#SA3G6
z<#@`m9Lo?z&z%QZgsErd=EY#>xR8_O7R5QWI@}DqhwdAl(d)IrP;aJGTYmNJgT3A4
z;eRitWib@><P>}NeyZ8ld78TY+u^VG(lo=aTw9VA6=b`<87?lb@Ls7{D!+c?t@(w8
zjrZb{S7HsBVCn}y{v7g)g-p73oWBt6jf4ZTEZ_R>AfGRSY}aQr&+`UmHBILQzOxb@
z7`&G*hI^&wuU(HshwBa5XcYaXa(OJO8-Lc+(^pqseEH^X0&u&7rfHh>N}@+Z$nLD%
zPu>v(9#ixyue~ujHAPkq4}VV`+;kjgY)HBB=IY%10?2l8>5wF;^OFU`Fm9KiD(%kt
z+``q!#ewOW8KP|4wqY34(=)md9EwIfqF6dEl9A3h_?`=Tc6OE=x3{+|e<m@eet)|4
zEkcN_tXzL#cz7(@FMa;$M;ynoEK3$6<Ckd)8JgDP^Y85JbjHE=T+s1&oE$ecHn{$Y
zvB{_2S%0@<YFU=s<4xtt2Z^te$-BgwES3s6(d&yw2D7<58R?9JFZ`ADUq|7yN+c4o
zSnQk^T(XU9CL<vGP&7QY3(s``G)Dx`01eO(Km#-c&;Sk45I_So1keBt&=5caGz8E9
s4bTuk12hEC01eO(Km#-c(ErE&0w2@Bdp{aqTmS$707*qoM6N<$f+M74P5=M^

diff --git a/tests/ref/box-clip-rect.png b/tests/ref/box-clip-rect.png
index fd62bbec8d791cd4e2cc71147615aab6e07e0980..8f307f754f7c2e82451aa2f845db97aec057ddb9 100644
GIT binary patch
delta 1675
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
Vj9O{1!T<mO07*qoL<FuvV1l$XQ~&?~

delta 1663
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
JPDHLkV1j+1Ngn_J

diff --git a/tests/ref/closure-path-resolve-in-layout-phase.png b/tests/ref/closure-path-resolve-in-layout-phase.png
index a3d6999813b88ef0eb23b49054b8793d1dc6a4d2..ca22e458c26c3cdba361bb9aa10b7469f4033277 100644
GIT binary patch
delta 2251
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
ZzXRF7RM$iAlvDr!002ovPDHLkV1jmfYYqSa

delta 2244
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
SUN(mS0000<MNUMnLSTYg4`BoV

diff --git a/tests/ref/hide-image.png b/tests/ref/hide-image.png
index d671a07347093b34257f8038ef8108df9acade88..75975d249680c5f43326af63940ef0790e31c072 100644
GIT binary patch
delta 8527
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
JPDHLkV1i7=kkkMG

delta 8280
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
WUL@?$>W|R?0000<MNUMnLSTYbMJUJs

diff --git a/tests/ref/image-baseline-with-box.png b/tests/ref/image-baseline-with-box.png
index ade90e2f559608c317f3b99b442ebd6b63b12ae1..37403c80979ec1677cb109330cf42669bc257b0e 100644
GIT binary patch
literal 6613
zcmV;`87k(9P)<h;3K|Lk000e1NJLTq004LZ001xu0ssI2RShYG000@BNkl<Zc-rmT
zS&SU_o!IezRsHKe`o5-Trsp0Ghr^qqL`kG5lA<M9k{xR$XIIb$Le`6o;Efgt5I8S3
z{E&ym20>O2iy&~kLG0*&td*>bvPn?~Me!zwGvwSe-80j7S9N#Y_df#xHWtWB;8ntX
zm~TB4>h*&k{`D_Z6^0N3+x@=}-zM0G-iF?88+sdh8+yBK=xyljwxR#IhW)`$h8xYB
z=coUs)m?%N7bgcbvy#q?sA{9*bU7xMPv&WcDOKk>-Ev$gK+0e_=mb2^3MpY^w)z%@
z=Q)N;F(YfA%-;TVQEs<u9rr){@THjw`uWfQn*cq<MkIy+LXRDL@QITT`IT$u&VTvm
zFFZH&^k1D_{+Wkqx?I1#@lm07cp&$XZaF;UELS7RsOie>u0}!5^UPYcMM1JwSAbs=
zr7VU?s#=Zk>8=yDbSLmE%fu`T!-3E8zzGQygd~akAtFPIhLqJcX+a|SP>e9IeE+|W
z^&J3zXb}9N1s>*Wlw;*}!y-Aat#i6n27qX`b=8__W!sR#JF4p1&5kIO48$;vqX(i=
zR8g9`4q3*aJzl$OoOyFCAXF0LXNr}ECo=Ku{)s`{tXyAJ@1KZPyC^;N$nj@h_}l-u
zcD=<fZq#o6^<N$P?&)*wPePiW8vA1px9eRwB97FpqM_FZav20*D$^4e2OOt3**_?-
zxpie)qz-aKRyI~pFdR6(;e^2R*6N!y!FU+9TB{2j=Q}=45FYX%#jAQ55*C@{I9?Ru
zEDaDx5deUD0Bzddm$#NytL<2V%O^XEZjq#Dy9P&N935RMR&B?TBE4ZqsE$QaJ+4h6
zv?_{_rr5ZU3p5e9{Ysa0p(W95f(akoKlbahm!r|_=-#9M>wo@TRth_Q{JDSi(nizz
z?>~F(+?QYVBuFOKcjfLE581iHec%6w*`HAylsk<85hT1xU_?U7%Zkj9Nfi3BTk(L7
ziRq55;C##tY?h%!vX8_?-!|i+mlS%(CqrblBGS-e^R}uKV|1DbV{6@INcg^+s&|SF
zrH;W!;C3{t9r*UWfesK@T&o$DZJTDJZWj8pOABR$lPo7i8CmI+b3;P_GD;(A2hntj
zhR}_3I~#J7<To{qBMmCqn`)?a#RwCz?8O^jjO@IRf>ccK=jYcb+{X|eVz`gkrNvun
zoJ~gPC->&h-!4CT@;fa+PL6&ne)WShGnaTOMlm?c(gYDSWy5x0jIQtuY5Ls&IUHY%
zP*N<Brb({SD8?i<^eY6!B5ckL#g4Ja0u*{oLM-q|>x&=ue3OsiJ_!`Pm>_ymT#uAU
z@-%H}GRKPd2AUwkhYn4crl)J}bn#Mu|EQ(=-Ii8aP!$RH0&J<gM3Gg?(UR#jgeJ@S
z5Yz+D!5oqnJ&5CW0K)(ym}u|FWT$ewrD_CfVo28Nn-R)oNLp!DuHX1nHTA*%y<`|(
zxN<${Ki#GK7QVVL`QQ@|@BH?enH#cW(+&=OBEqx2p}QUkU4VmRjES1A$$3Ixm{q$;
zQ!L?j0!{KjKq6#u#d6RxbUP`gOXW{wU5-n<WnZ%#g}`HLwG~a<ynph^B*W|W2F-wU
ze1c)PdjrifRJ;(5z+S_2dPeV0NVssQhwv#6$7W`m)mi{L>uT4^r*rvSm`_l0*TW&A
zIh|t$c`1wsS=^&F%Wo;2*@d;S$%Ctl)46nhZrw`aPG5=x1e_=g&6ib*gZ0wwR1`aM
z@Vo5T@s3MX);9n^sr>HA=;&Hofv(6Q+o)L$-AVT6<hI;t%ZWq;B7-4qjG}SXWnnWR
zCAz9pHkJj3p$&;5Hc2*mSE-~UTi3AO>FTbLh~*n*M>9~Co48$GD7WuMDKV8u;N)gL
z^Q_3-3up?$&_V66m`jf1JdR`SuHNF4$-r(Nye}uqRWVl3RZiFa{yu?)(zTn{`|@K^
zF{c{_q%hvhkOqwcqoXwDftyYrjHXBBwQCU+GxW|_e=3#E*IIg(i;VS3cdviE=dnMz
zwCSY6wN^vkd+;#w9g3Akf^4|9*_&ofI{-N41lY&#FYTM`vqQ^M^v@QSVkt6Si1qj8
zA)c7sEQ|c0xt!YFpINrb6*eTm1`AQA69Iw9&~&ZscqlLo1JXS;TNNOcl6IBr>!u?M
z5PG}ado$5t7%FmA^UJc@>1t-+=?oTMDqR>E?`fJP91?(J0-}QPI3=?4t9SD0R8opG
zj8#X4mV;%XPlxv4(7=w-!NSPk<ENiIf98F;x{lm>Up9&p3{5k+1hCYSvR>>N7&Ecx
z<KKB;bEEd*uiyQX?>`kHMA5Vm69iH<9jqrI+CJfh^h-zMCD~L>0vg!Azwg+)H<s*f
zXxBPwjKkwB+YTz%)ua$<Hq%6!SPrLgpIvXrs=6+S{77Hc(&lUJaxB`zvT(7aFbpIh
z?}scBB!C$3Pl))*PksXapvsNax6b`-SMvx$kF&XSG}&y)s_s-a%Z;||8iLZT6D}Jg
zdrU`ZH5=)4#=|zN^-^2aGtrz#_j)R@Eo=Y2-7~lE=$4rjSwdTtc$%V^NF<8k6a#Sz
zGn1LY*wB#!haQ;Pz5k8Z-Wcdh?%TZ=k|fD;Ygaz1ZLIGoWbTyeF_8%{veeW@`!W%M
z{P@-?1L3nrcY%QDHXO5JMop1(!z^c*2;5xv|LwO=>n*ItmiO%+NW|P+kGE@l$Eic7
zDVE_Qgx<9w4FQA<7ON|r)%Eg&d!I-r^7r7$&<{vWONN^0SUkn^mAYkmxa-o58a)_0
z7Mj!}JD!2Ti07xYMlAIEEtgefs#)eNGj(%r<=WjVx~0y{%(T1e@#7~pH<U(sJu0xe
z<&z`@0Ey$ItXXl1&xo+w?WE$utN-b547>a2sndYK5%O^YwiPADVvFm|zGSQ->$YhO
zq@$m15p%J>eD0C0;r#iTX~Tz!OfC{(*|6p7MT%iA-0hyYZ|ckW<qzH~jv2f64vf-b
z*ptkQtXFB?*-_}380a4#jvP6#XWx$AV@LM(<cNvBB*&2VX6ew4aBi8*XLG>@<<^}m
zD;rXjAI@b*`i1p+$Pmn}S!Jc!jZ4rpe8Z#Url(sj4zdvWw(iyaje-69Qi;TstJek#
z!^4Avt<9AfDdaK)AQ%t%97%*A&>XBko_Tcqfj8dyP1|UnJb64Giwf~X5QJgibC75`
zZA!?S9>!91F2-J6txt{gzWVNkJ;VJ^A3OB^m$$ySF*nwi;YqhxX%ZwI^{E%0J=th?
z-uU&k2M>-uIyQOx>MaC_M0&K@nRfs%Q9B}zM<SA;tx9CZweKV-Bb^-OXzJcTlO)7w
zcC%qCbYL_qvT9ON=yVYS^-aAgMxrF$@{j>a-3Xg-0v7t3<#j`nf<#CYl3`h8Mc&sp
z;+XBt^+kdfvRiyEpGc11y;F=u8AZlZ(Sl)>4Jv)@^BbyK|G}UCMMLS9*ViBchIZXw
zxpN&_n+Syr1gnj%3xMsRNA?c>^{-~0edN&V=Pu5zR-Zh&r`Xg*2K)TdSBQu{`_$?C
zrbd2qY5KPproVmvXrWK~A0M3Gs0R=HQJ(`=yQU@Ei-H>Agm$@Aq=0c`*HeuSxj5U%
z@7<4w#Jz#W2qf^hVYrDXi6O+q(g1j=EX~p^-bobeiVz8-Jg+)|*4cD%5eG;T(zc75
zss@o8_}=3BB3i5N-ZdWOY2C*<?G797&5iAIJbL!R*}+HuxKK#9R<4<d6O!!s?j5C-
z6{S_<Ark0u5_#RtJG@_yNpx9mMum*&;fpnG$1ps4Xy~o;(|`KJ(X*FlfA-F&dnP7Z
zxT!nDw;tX#JTm-u?|zB7?!W%tLs##tz5T_-2v3jo^~9~@Qt3+Ix-@Oi&Q(P^4%u!t
z->=&x%YwUi9c-C3FL3V-bl|xR<q0$|NMSaY$8a*l(9wPO-CnrXH<BE!^>zJfT%v$M
z=^ohZ$P5(rjK!2rd%ek9j?~e-7>7vJ{p`ZU#}1D#HJn;~bFCNvmZby+4eZDj;%Zlo
z=O@=1ZIUE$08G6jaQxw8CnX98S`*hdaY!d6yrF8Ep|PCAvDC-c7EV2U;PTw&+h?y#
zj^yLXyhBQtFP_;qK1K?{FWx&p*gvvoXYS{(y`PiBzkL3od@hNT#GU1uypH$mNFdM^
zB4N2wFJv=@6DpdWPK@5ImhQ|=pE#lC?+G*ssR+wKiq584&uc?m6Zq6Z@viSU0@E2D
zhy+jo(1@V86`)A7!;)A&>+TpVOd7#rsS5>6tl(3z^xvP|SlOs11WqEnkO*UmzG}Te
z5V20BvVU^w%GEi~s`aM%a?x;X=Yh!~V)F}A+mJ?2+O@j~BT(q|MChgiH@ZeXl|Fl8
z{eYtF9Uu7h*-MEESm_Esc=^TEwFMK1>unH^#3;i3_}rC~`^JZQ#m$<$QB?wjLc~VA
zc&)V3wW)*{9nEvHZMEk8$+7;DQgj1#Xt<wY>3cKL2*Z?)N-^!O1sMvDQ@}ASfEkuc
zh9TQ&mec(_-mSnmo=&A`BIbv<Y5OFp^rw3x0=wF%*GjUHfJb-toxibqc<<QWi9y#7
zSOS~cF|u#x;LfST$z-ZsTWf3@s-nkv`oYn3FJ6*oKBMA85<wEki-=;!3UJI#ig2l6
zvMgK3MK0VfJ#*^dZ!b;XT-sz<{)6}4*tzpyX?<OmTO{UoY8F9q(@X8Mmo%D$3`CCQ
zvMl6qIG!uaqq^^N2=8ZoC6VP^kLaqMYEu?)&hf%~18qBQtF6-<@B1Oo;7u%`Y0vXr
z4EM+y=DX@psEZ(?)O9IIID`%YFB0o(s-|KsAk6VYKJ<fH+a4b2ZFZg8OI3X5NIny<
zu3Rx(Oq3#Rx$Yar%KR;Yr1y^(_V!DpFUwuflEJ~f`+#diBAHHofgma5A%KA6I=AN5
z9y+}5jdRnbit=y1cl<xUb~YYMZ?4_aoC!s4hQ1vasF*-w7>J47k-l6QIwHqKIns8V
zn8fS48mKiU2lc>p0D=MN%9}I+MJl5=jlcu<XrevORUKUmd7d|eF!TZo8ZJq5(D4|K
zqVih3+w^sorrf64KiuQFO2=r~dZ^hbo8^G7^v04atD2D1_wO3BW=jj}?T$^1_xHqb
z(ABKz8#gv9jhHAred-|Z)-+w#Y@o~alZW?nNHvx|iP3n|wZf3He9A`w!;+izHi6?T
z1Lup4@11`5`%j)ecVo4X>%Db*W_)mn#@%XdGjJfo0Emz!K-0A5R_h6#J$Y=ZxLK+!
zSH}7WrYq|PvM`bf1KGpq`DzREXo*gQ2){S4vTz&+1W6LmXsC{9r$iQ+TktvpwBsU*
ziD6U@3y@*pdMCJbeWkqGk!!lEk!sZ|Er*WA4x}P6fw_365>I6h?Aie_Z*_J3)?$6V
z(UsfXxuu$iut$#{@5}ewxNvd4)2P;u?dpyArP9T>muD^!gl{;0;5w=knm&<|Bt<uE
z*O3JN?(*svvm3o56G7nh4(%ryac*hOu)R~qPyCCgP9ECRx1$hsJ=byELle0GIKTSn
zlB_t%barxJBGQe;{XC}Nrd&sQBNCDNdWMDvrdWo*N839LvJ4&gp&uZ#s<kLU3K*?>
zzz00-*@mnHK1s$zR^Ujl+G*>qgn&qfop?OCTyG|XEP=uUJA3DUbL+F2jqjX3g>dHD
zt?8B3HPg<~M3Bq(ObqvOg7Er>pR0|v?>#)WCx^S;mGzLky|Quo_%X{g-2mwx!U@(5
zoTh3MBp;6@d$Mk&+4<=Fg;P`#5$NWP8w2Be=PrMIZF+j6T<h!YN1=&_&eUKw5n*Om
zYJ<J01WzoK<W5L4oAoG!WQG|LV~QJsAQTXmW_im~FwDO<&?F=Tic)kdl}&Sqb5O^#
zFyD8O6_6O-P^y7XPz+@xS>M!<Pt^=7l^|&dOvA+p#_akaLqW{?!M}Xw@87@tF8uO|
zV+W%VDfsRAa=qA>?;RfK8yy+>?8_UpqrC9MQRp|WENrx7Rnv_pCL<Km=87u-BW#Q|
z1H9HU*A++LC0>Z_*^@i-)eK9E8#S2{6H9mIkBxli&t817zPVW3tPNx+-^EOizO_`J
z80tAZHE`o@DKb*%$wqw_)@7Z>`9`^k4dT8jXVMu6NYiYX9Xs&t{~t?7tJV5Hp)(17
z-{i0)u~l^=A&ChgMud1^Xyv<2wSo*g>}po2Tw5=8H&$Cltx?`=H>;Xl?>J__+VIn>
ziyMj;<%vIg{^@3E<;{0KU|8XiqsNfvI*y-+rREnmCJH@I9X}M<jrHR4?Bd$;Ms*~^
zcp>)Tmsg@ZQ|RlfYgmYrG|dqNt$U#frDSe^6_UE`nLfa&NHmfxRyJPy)vx-qi3fJ4
z7fUsUB90%(f9pv9=htT|jZQkww!13uF)>EU9W9qmW<11nTnr{PP3_HaQc^{98Q>21
zx>~JP`MPg@q7gzzj~;#Jop;8@#=!3i5w5#L2lD~~Ff?CL!ek;Ik6|Q26mCG90}O7v
zx^G#rSULz?9M=ip<A?$wfxF=7U{5q3Idge#sn{GF89Kas?Al!U!_TfxjSZeYe!4f8
zo-9PtOe6wYtw!-$@j8S2qvLF?3pC4^F8cWhDe<taxv~WYqoTm^%bj{hZZ-@g<T#3x
zXrJNZnT_RHPKtBT_i5~x?|fXyi4X4|I&<Mhy(x?j#%R*7H(P?pQUpOW)Jmzfvyc)P
z*U&VKi`y)kTj`iVGn=wQ7X1ERc=__>mtK15%{SkC_0?B<dU}5N!ykTQ&>wv8!OJhd
z{EJ`w;-^3TDfnH6ZCA7q*L;x@6KScfD~99v7-sk`C2{~aA<1Awz_T1qkt_nPN8=db
zxqg6%of3VlARRjS;^4&fx8M74VR2<@Jb3Ituhvlx^m^lcdB$rZYo2vo+vxbsa*lTm
zkE*p)*+4deaVc6g%ujFKjU@&`L}q$NZO@6x_-wIxV`gP!?=jOyHUft2DNXs{o&!N=
zxqo~(5y7tBUi{?J9iE0wMXxs78ICt?t=ZOgj1JAMH?ur9ITpWgV@~RQpbNm<+=WtG
zRb>~aJlFTT-wnanJ@d>n>2&(Ui4(hb?|$yN=e|kk`T6-*UU}unkt6>YIt&7<Ba;m4
z2fF4X<ok+edWf)HMc|?c1);0bBt;MeM?v2XJi`sQ@^H&D`jdEEr0-78>T317$95oB
zqi~}qx{l)5+WOTGZkxdG1g<gBC!}K{FGhQy2_a$IL{UcbO-u_|&joqP%CkJAaGy=2
z^YQR*T~#}kYQ5ajo2_Ol)?+xft}B+Z@#N9_0;~Pr`Ol-gAkg5q*NScsq&TcML$wt{
z62($O9qH|T>`?#m##$A{h<N|%%q0#o@kG3(`4qyHw(WQb{4T>V-g@h;t@-=$kAM7)
zEgcIB3txTp6~}Q1p^FzUZgGRJ!w^PzKIS(oKB7n(0}jKc%yyRs4od+S2aahoVE}Pb
zR}ITBkneb|O<)vD;sb?USJ(Yo`Lob9aGbz!pCQ6xwb2(PNAlThB6{vx=gP8X1WcjZ
z?oH4V&rqxs09WLFB!@m=M*6d?Lz`aE(!;f;IkNZR!7<f-@1tleC2Ix+@O+^VOEOQL
zc+l<0*QV!3`ZK)={@hok9pn4|^p%%q?#!kVk=xT>sFit=V#g=4eIx15?#$huFA5V6
z-dy~LsX`A;N_GQ~6eNKvawJ2Mzc<;^c>M9lMN$0GkA8IK%$Z0e@(n=0{`%{`{N*nh
zhMAh0+FCt+4^3hyMH8w*dP<i{6O;h`&`D*Y$YC7cp-7Tor~siLaB<HgA?|wA7COy<
zhxR>|>6vWQr+t6}k^#UE5d|r(rgy^7HLcS4(BQE>W2Khcazsq?Fx+P-j7B)ar`)z;
z`?e%<5+@Ldjj>E58^2p?4%bbZa{k>5-%ccH+?fB1KYF;-T=xRIjRh`?88~@%t!!Jt
z=>8pS;h`47??3VM(%P-`$Rx$3r5^ldtMbX_Esh{)3Eo)wC;-mIs+XWb&p=(f>$@rr
zDBlnN(bg8@dH(e2(;t2G(H8Xc&p-c9g<e@%sZ=Uk$^d{Z;up6zN%eXrlK}v5JRBO2
z(3sh*!~zoNz8&C1=o=l=a-6`US(*Sr;8Qe%=n#fDBtpGw2x4LP#4!u0k?|AQ#*Eym
zCVPi#3m2UbCkavmF_=CIBW>TUL=q{2#7x9=5#iHuoKFx;%BwB_s*4fCoo1~+Ay{m@
z!?(-L${X+gmuw<A5Kq*qbFJcKniVfDE;kGZupv%wB_I+bNs+?+gmLb|mF4>noNjfi
zUEP%irMrzqkr8ay-BcQm;YCH#N4ADV0wKXeA_!bf^C?ILzjNLKX*QdNVaT#vtJMx2
zI`j>Ed-wL+Z##~2>eQ)ZGI{mt)h%~X6rX(ZNdSQ9bl0o1D8y|Cxi<2B6ow&=;~2ys
ziD3vsh`<Pd0u=fP!wG~Czz_<2nq(<Rku*nb*$1H=U^Ec~j_KJ3&+|Ay1QrNlOn0Fq
z3YP7*S{p1+gedSs-$$h51PFu(4{#h11SBDe06;+)1U>-x7DpK3AaMO4Kp`LrJisu7
z!VuwGXN<stFeC^_;Ardcf&h{vKwwJ~2LK~*2+089p&x`G2tz<%#MbF+ConlQ5fMZH
zz<ck#x222_DijI_4jiCq`u_@g`}eo)&vv(=x7&u^hTewWZX0?Vdb@4tf3E#+a{4&L
ToMCYR00000NkvXXu0mjfZx<5@

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

diff --git a/tests/ref/issue-5499-text-fill-in-clip-block.png b/tests/ref/issue-5499-text-fill-in-clip-block.png
index 5f7962d3b1b38af687b2996873bbbcaa201246ff..ac81fe8efdd55f9d02a0c8b7b711a1b77defc888 100644
GIT binary patch
delta 1500
zcmV<21ta?23+@Y$B!9I@L_t(|+U?rOPa9Vp2k`tAy;kj|{SPYj(t8h;T2(z%YX5>9
z5;ak}s8QOqq$o=RDcPC@LKY|??8IOe2Ld)`31G1CU>h6Tc=vcb+nbp;@AVg4xem)E
zB}oszuSTQqn*m$;FnYX^-XV^8Ejfe)2#wGfghptD#vn98V}ITR^h`{DmLxJ^g8`+a
z+x%st8#K68HmRL2lSo$K{~;+mC(sz>_L`N**=7FHu}zlrGBv}roRyq-h0ymF%J0@i
zI+kSUvvK`{#@IK#S^6So-Du%QM_$tH4==^mvIgHPnn54UChtve78L`A6KlC9XLuv4
z?D&~0qv5h<MSpW@^F);IlMMAgRFBV?kD!Yzd&juYZeCZp%xmJK!OQAj0DVIq_LA`4
zhMc#=65j@VA*~EUuaY_vcRW=$cug!$ud0t$XsEzSC)IPW_KAL{E>i8EH7DWW<u7I^
zsGfA>p?q~eCFD%LPnKe(F@Ltw6=L0RZSY-b^TcJ{GJh<)Wirb5Pp^7XVPd6^T3z$>
zDSt5%ldq^9P#pUFEQ#=a5>>VOP_Q~Yni$;UyNJtALr~7?O|KUEz50k^u*&gibJCYG
z;Npm&wmmC1Oo}$!1G;HS{L@ov+`e0lFD{L)W&sfnQ88|ALo>$aBI2{C7|tlWq2cL<
zXWttxZhvG|UXwoUCy8ZDP7F?*R_7vh!^Jd9%}~#n<<hvm8``UFI?Iv%VnnsA>gQ}~
zIzSWKCXB*yY-^x$-9rSg5%icV(EE&WKV5$gO&Z}$Ox`x7I+pdZHFChvZ~qd$GbdFJ
zm^uI&#6P;cIUdqJxs~W!Rdzu4`<42!0t^BAH-9KK&~5JcVoZbs>?+W+k)kV*4P}&z
zj`iKpFxBV=WsF@LizvjZg<dj;eAdJwoxE=}R-msKzYBJ-)9iMbV>_U;RK8kp!_co4
zE+u@m&?f@ECt`X+N>0j~N49$4;<}Z-sSK}Ku^;3nmFxY+NPr4({Q|iN=hhK<b<>1W
z*MD1HPM8M?{eJyMwSUpN1<<ar_T{~;q-4cQ7C7vH{@Izo<&|JK9o4^nkgA1t1#*?H
z5~~8;;Z3ZkWl1x^cQ<syPzaQv!2BLBXtmH9lPZ1O>H%nttLMqDC0;7AlEIA~(DVA{
zU2y@1gwYdWPc8J>uuvVINcY0IUz-~y^M4|fi`!o@U=9cD;5PJmIG=7QCi4`^LytPJ
zs2><KwfS48Le=5NHxllsUM4ooCz5Uxi{%vBy&@m)%fj8yTars##3`syY{sv-OE7^{
ze|LUE9QI`@T~rMCzX!#=UKm-)Kmltww?2&(6+<QT=93K=wtM36XMoZ&86&0*rGJtx
z^*f1WDt*XmpP?=&XUXY2%R>>FlxM{T^#Sx=ZDyJXd8(Ys41=<ui?>s2)z1-R_4In6
zIy{_ir`!%$@jujum5JWwcDLELOnopsLry*S9hJK$6etZn<!F{37&J`8hr2SJ%m1u8
zj`n0>S^)h4zjCZEdv{)9jGq}Te1AWfn~Upk<@&ZPtn)5BDK^i--G5gU<NmDEm#M5e
zW<rI*#T2YMEXv?9pA6=cMJ+EIj^#8=EGu#8@lq-y5yP^lggi_yTcTdO>X;_Yi>9Np
z>Huh`)unPd&SG6==al6(xZ$xDJ9KB1rn@wEuexA!7BLHbC1Io#Bh0R@I)AznncMMb
zNRwbVtHoQ((=&zu-DS@88KVIzC|v2c`bVtch#l%OAFK+5F+So^AG_5B!N3<5d^1F7
z3_>F`2B8rep)m-J&=`b9XoSWfG(uw#8le#ygU|?#L1=_VXbeIlGzRxa<Nj#eAC3E?
zaewsxa({F<XW{<n*Rem^9aS=LfAs6vADtHMH?Ti?9`{G%IvQVC5E_Hf2#rB#ghpr#
zLL)Q=p%EIPF$j&&7=%V>gvKB=LSqmbp%EH$kog;RGC{OOp90+g0000<MNUMnLSTY>
CF4mL)

delta 1484
zcmV;-1vC2Y3*HNmB!8tzL_t(|+U?p|Pa9Vl2H^aP-d62R`wuGhruV(5)T-)5rS=!(
zB2g2iiyEa(ONz2Ikdm!gAY_3O!eSr>vp5j2F-ri0jR)J<*v9)Zp6$%cnREJysa%KU
zCMB&@eXmBN_soDTJ&X=#q;rI0{*@d-0)$3r3_>F`LSqmbp?@*|1@vrOdyyg%VM9T=
zqFMY^qv<rXT{WmxsFG+-=KmmRD=*ME<<`2H%v)9d%CQWV@-ZdL)V!IRe2vf#7OQVJ
zM7x$H=yM6}z2^8={W<zFX2V$VduKt^toN_P*K<1GFRD(T%%vX8Y?WjkhLh|07FT35
zC-3^1Yh#hBYJbM^O6z2dACN2!JXTK58c(2?S?->GsnfWraEaH&PeWIgKLGlcG~y$X
z{S7&9izmMh`on4!hCVrcEa7~vZ1TF8oL*O+tkQ6iRZc4xUhfnARztMbKWR<D!^>aJ
za7a1rEI|3<VOq!={D3USE8~Hj-DP6la&PiI>F_2b&41KQt8FUA4^F>wT4rUtkC{CS
z^f`YyB9pEuT~M6b!W@b60}@lz#&D=MJf0ld=evkIK*LZjXf3Z7`klt8tTX%gxHaWZ
z>u_;YP&!^zo2JSZ+XuR3y8OGh(!6uG7Jot<Tgw3=9A#O*y#vh{n~#=X#LAJZycZgt
zZg}>6k$=)=PT_TNs6U7-YjC1-;xfCJs0S`)SbCOv$4$4&wY|_jb<0(a4wRybW!64t
zOVt3HSQcRvjuYF1_H{22e0s=htU`C_69Kxx0h%<!nHaodT5+yu<Ll&*q2K%|a&KO=
z512Xt8pJ=ix-}72Kf052tjW8e2Lf{AcoBvG{eKITI_M5hVkusR1MF<*xoF89%!RY^
zW#`6TXqaj=oifI5j7Mc+)<Z8F!+vveiB3J#n{DW8`mcf&>Na|v#`rGi9F?vYJunQY
z#VbjFJ@l!d|5-URDW;~Rtz+ALaB;)T+?Gey&G>gxi^8=5eKbe~xPFOThI9L<w6<kH
zX@BUit|X1agnqYiv(`Ur-v(%RME(51c1ko86%!nGLI3C~-0_JpoQY{)K1$a^yMuYV
zE5x*+yL`!wj3lZC`0j;n8V-Xp6qw%=MYSGUWuo0D%szltxpI;GT;Y`ptLR+c1-+nc
z-7hb~kT7~G;;n~19}#N9Q<;7^52*7aWPhQ|q|(k;3>qUrE3^ZB5zc4ZN~r>c^4O~k
zE@_7bO)dV$nQ(3R;jN@6rd5dr^NFZg#AJDy_O41N9XYuBX<KS}o45o8ipBU1PX#8B
z+V3uGmPh<qyTjB0|M#GHHj1OGStwu)=l19ElB_F)-hQ?T!%lAk{tQssrsBk~pnuru
zQN9sb*6zb*=PY$YIZw_OSOH3zi3L__QXWC?S7&F4P@wXe><B0eTKR5zz4keRq@3Ld
z)`mwjos?TaGx3}9*q-PuZuJ_D73zoKIdX=B@0ip(DMM-MtHyHl(4b)=KH8J*UioX)
zal9`F(*o!Z2ILct-2DZSF@A2W_<!wCem<eWm76=Vu+F>mtkgOOcmG~dOayW+f7V`g
z%!Z3YOKDhjn3Ta|J{2mYN@_vUohuobSXL9_)8%wlB)Vx$3k8^7w#!=ms$+(<E*VaH
z)dA2hvq#}lg2j7`?rGDbbKPq$b!n~`&Ge|Aer3_(ENT=T6=AdzC(Np?I)8eS*}I8Y
zSQTM7rzYB~Gqbt?-EGV}^syinWG)Yw1Ec0h)C%_)kJbdj7$5a2Pd&<_pyLY*z8NAk
z2B8regU|?#&=`b9XbeIlG(uw#8lf==jnD{<L1=`=AT&ZFGzOs&8iV_zaep-KkH-Dc
zxIY^AN8|oz+#mfv-5<Sx`$eO19gQz62#rB#gvKB=LL)Q=p%EH`&<Kst7=%V>3_>F`
mLSqmbp)m-J&<Kq=%=`&%&_Q!yO+@ej0000<MNUMnLSTYhx6;A@

diff --git a/tests/ref/issue-6267-clip-anti-alias.png b/tests/ref/issue-6267-clip-anti-alias.png
new file mode 100644
index 0000000000000000000000000000000000000000..00a61bc2d83fb72de33fd0060c9a6e4838d39efe
GIT binary patch
literal 251
zcmV<X00jSuP)<h;3K|Lk000e1NJLTq004LZ001xu00000{{-O=0002ONkl<Zc-rmP
zAr8YZ429v||0s`yG^E5lq@*JuMI|OhAt4!=R&A@<UM8*nFYrmWl*mK-QG>${JM8c`
z;gUswD6@8jRq!m_y1`ZOQq(^19`WAV1KtBZTljE|IBTQBg404J!wREBh6PrI3Ky7V
zDx6_9QDK4If5NyNJYH_cGt5RRyumC{;TB+}TzG+zu)oF8fRzoawP7~gR%6ga*j}^L
z9&p=&F=sa1N&=2VJDxBlPmlL1sb7l@JM6H-M|b}(n^{TyPj~<T002ovPDHLkV1lvd
BYBT@<

literal 0
HcmV?d00001

diff --git a/tests/ref/transform-rotate-relative-sizing.png b/tests/ref/transform-rotate-relative-sizing.png
index 5951ff8ab55c150a7694cd5325a9d1464432af18..9b1d365dfafa6a9687c4f12823df45d88ce400c0 100644
GIT binary patch
delta 2481
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

delta 2403
zcmaKrYdjMQ1IEYPbD5cGscbXm5+cg$ZkycMP`QLySnikHDu#x2#O9K7V!hMo$imzs
zEF_lX7E$i^q;eYN<ofnIpU$WE`SkxiU!Lc~^R&u+1=CSv16!P>Tf&FWA0kMK0mnuE
zTK(D57!ziDb_E}~LLwM<s%l7%-Yb)5uugde*`M=PWb0YFclBgIbS*)n(yoy#>ELG%
zbuy~&#Bn3BoHXLXD3L1Hx3mJyTE7?(QlzyXPuoVfpf$&59tCC5KJOw2H#MzaXWkrH
z-Cj!Lu~x_v;`vH;1R04kz7;sk+;T;>;UnlRs*So{C}x`uDh3^!p-l;#!}Mca1mru7
zQ1a0sBF^sc<Uj<*XFfYC7#1Xl#2K<n#%n}mf0I9j?Jnsel}r497l1FtgL3`EvO#eO
zUrzUFiYg38a<yY_dOJi=U8b_85I*<QVKX4|8h8<@o)aeK?N1F5%N`v#OUZceWB=&~
zf^tiisClPOT-LC_`R-a0?z*NBXLe&74he#REvhMQq*h!U0?D^KFDqGpWIos3?QaD|
zy`TG!&1{)*Vs~~U@LC#IOG>#CX!$o^vkmYYpuAHVD3e0^H81+2W7TAn`P0T0>=QD}
zQERfmKSriS*W8*7$WhN9A1Cfnu+$V3Q9H^~llSz(c2KCr0QV5m)69SKVu!Qt0|dx?
zF}Dg-l|EgP13NeK5ri?}rcqY$T@rlB9_ECnXMTu)G;GWna8Eh#!HJZEa`rc9IUN<9
z>0dG9PQmi*E8($6dqXX4<N!(JL#HXhZE*fAkCaiPOuCRpx27lNm~Qgm$tA0lBMs4=
z%15LTZN9{27PyuY`tomTm`%~e@PzC0aDA|nGr!4b$@J)9%^dw&F$g_=yd&}@VhO+L
z-DsRwkKu;Q7n)5Z)@?ym&Xa^*Npvkv-cjbchrI9XzaN)i5+;!wk0FxzPi2Bjz68J0
zl6W|upvhB8Xiu_P-#p)Ugsw1WupG;{jdnyl7-DNzZcR4_Ht364%61xF@z_va9P(FM
zn7wlK+DYUok67;$#(-q~REDol9N~%i%Y=vu`a*-3C9m&6PT@P~#DjLD=x>9j0Bc9M
zaU?N$u|-O!bpf!@L>VP>=Y^0QA!Xk`EIvifXPg6ysbEY9raq8mVSAf>0W?TpuKu}>
z%%MSn8M$-G6gevqh8xsQImm+}O=&1^aewh^MhilGgvH?TUEb*wJyN3R+-Bn8I2aTm
zo@gH_xCZ>l0Ae%{7P|}eDwb6IRP29@5uR8lpxdBuB47$eW<8S9SQ>%rBQe!v8UCpb
zcvW9#xpe**AXD5?3BZh4WM0gCs+;^fsYUd;$szP*R+p1ARbL7KJg+NR<5_%55+7?f
z>9I~G_}m2SP>bZ<TZyi*&3wgJzP!&FBeGa+_#$nlHhe-F6%#4m@ocLs=lPT%fWzKR
ztL!iQ@`Ze;Ru{~4ksK2+xn-;R-mu4hH-<uwk;2Qi;s&a`quNGG!#kFWsyz@izqVPC
zGSRK6iVKPsgW4DBXh4<Z@8Ru2o<6W{&%UjuhKFqn+_5*<N6hzc22$%W&#wIBoQ2B~
zThx)xmtT{{8bAN7f4?t#xxwyWe?5Pv?o|N#Y9bj~oPVZo%ys+>&bd&jV0E~s)NvYk
z2K<B}j~TeTcgbAODo{7|Xp6W9$%f8^sWLx}K-0f-A}O#8cZxR^bVS&{9k~eFk<>-$
zO3mlWGQ0ICShYXqRJzcUximj9+T}Lgc$JCtZbBM#c<yl7PpwxQ7p;<Y;WNg@#A1~|
zer^^XD2quuY>4MP47(R~ymxQ|rCJf<U`$|ZHoarXg}g=BRW)B^G>ufNKWkyJplHe5
zssSnC&SwgGpx(5B+KNXr8ge?*m0HtRoH~s%&((xebmK{vuB|oARE9mheDFFE18oZQ
zb}nWZ$Q*7IXPP5)%;-yr(PHSqo@y3ZpBk&CDL<?Hy(RkiqKwUEQg>;yolf;>d4%I{
zg+=AF?X%Z?hpHF8svDFGmXW;{118Nv1-ltXyFeMIDF{hFG3+nA1J74xeRIpC%zQxJ
zh%tPL=ydddH9d?5;+_ytDWn;sRjvSwx|Gt)%oRX}=gbuXkcChWcsD46j1sML0`urd
zQJiL;04vGug>}JCk*L;yl!8yz1;;(il8Y0tSAT`%xqxUw^vfL8-dHUf3v$mkYG<rz
zMa{*c%fLo3_haQ)$L>E>{?+Q=*ssW&n0bpb;%_qG*h`SQi1f*fY23jWIbfW)7K#YC
z0Ta|KjI^1ovu3k@zf{P9yv+!Zzc+SoS%zz^@FO0pT0^6@$pGbJ4hW7V6Ln{X>Hl5n
z6}TE6q2L<iYL>EVzQ)R$6xn;sk-H!KJrwb1KKi;18vh5Ls+NHMOW0~%kWs4N2rbFq
z3MVKPZx-*n!cD({JO%d1R>OPHDW|C5EDV(Rl`aj}5vQ-F%GJI~&nv?o2-)QU*Rma9
z%{pszSBo!uX?F*tG4~Uu9eAzF<1_BNQ6F9CKYmN+k!y)(={JW$PhNf8H;if5d92dA
zh}nz%>+|9ErZGNd#IOvSnFp-!Of>U?@F8dA2yi8t?({aw>J~Ym1dt^nh5a;4Jhr4@
z|L#7o)DR-dr%fl@_1{cs%s>>6o%yr9!Q}CV@xv3Qbx=|^u;K+4B{2n<EFst|V)TxH
z`z`bvwWP}cPt-;<=449g?<O5??@2U>4mjn|vUBbZx!DY*maC7v?l@UWzpe78WgI}s
zsh%bYpt+P)S&*L)cpV|XOd!Vrh(Oz^k3cPoVW{XV{}V_((GlS(2ty=Vf$;)$13Zw(
zS3X1od_(Ixt8`LdvOnNzxguP2doe*JE@>_dyzF;7iigvK+o$eBs+5{@wzzI%4N7W^
z2wMf&B)~1J8`|G}lEkN_dgCEqy_T{ELD3eF46*~%_lu+cQs{=U20kGH?{Ij6BUDp;
z6UpyYerLc;T)%95=U{u9&9={Rr0krnU_VMsq3*E#d}p!Two0a?65&HC1BX4P^+Q-Y
z=);Bg{u)n>M!eUg*KZ^xJO`vCwQy}KYyb3Kbg1Xv81;9K*Q$AM6Y+a*fLB5Lj{cj<
zq02qe!;1U*MOESY-!=MP%}VcHE82U${kDJoKWh9nXOo`oTUY+yuK)QURq_GQR3N6+
T7#wK{_$6B_CtNk=O4|Pbcz0U|

diff --git a/tests/ref/transform-scale-relative-sizing.png b/tests/ref/transform-scale-relative-sizing.png
index c53243c4b17180620f74b10ac540cd97cc5e6737..01f0878b308d10c5d505efa9aa0e635849e3891c 100644
GIT binary patch
delta 1885
zcmV-j2cr1r5AqL?B!9U{L_t(|+U?qVa8%_P$MOBWNw_3wE|iOdB9~fVEK0aoq}nDH
zl@=;WiM1ovO$i7HLP!Jxg=Aom0bwSk)3H>eu`<$9kOd?o_g&=b1ZOGNObl$NB`hH(
zO9&>!ko<byB)duAbSE>ri_v+$|2#8$nVrwP=gfJ}nYHjcl7B@Y0uhKn1oEwcoU37D
z*NVTzkYj1T>ZP`lb<18F7XEmLgg8=OnK|p#8L4xrTb(j>#;ob7)(_dX<5MDm-6S)H
zD>arOD7pJbfkDo#P6E(%Q7(1cmiGeiqm_qvd#jal=;?`36BzsofRTYg$eMw`JM?xG
zh`ho(+p5$N>VF2PNeq4)fapLWoCrAStyW<mP0IH|28RTa5A+QfG8OnQeZ^q(Hvl;S
zj0zYs4Y)*Kad<2!klHH$-C*mk0LdK_((uXp_3Jkm6s$MeRZwui7~2b4x37Y&i^1a1
zLAIq188!dF|Am~I_HbO%sxvf)IGmOQ8qKxX^zg*G*ng(;ZnkbX-VYVz<}2ZUDmj*{
zlCPRWmZ(whAAj>cHM_<fLaW881$~ofl$}GrkmqqE7?5e{zPflJv(@V)tM5}2O(82V
z;cJq`_hU%4Im8odCFzQ@*h$Y&lJ>cIIY~CsWlgZBCAWplfh!o0;iG*;G(*lt#NW`<
z3U$&1;(z{LcnNhIfh=<fvn?(%$sU_TT5V)rtcP@3vPruo(X*>9<PB95qC@MqNGI!R
zs+IsdO(3(8$i{AVL*#XHh+dMMZ01?)F8$$tjo(PLXo&6hL+hP5h6vIFog!3I+e{z{
z_zjzy1pLbsqL;*;NV0E|)k!k8`Q+CS`|XfzKYt7n<P`9M>tb<H;kh$s>+gg#MB!yN
zl?LR~9O8+!XhELE%EpmLdiu>ZU6CV?h6wUDkmu(*a<%0Gwid9NK=wI}{=CMidvR~$
z_{Y>`?=5`Kcy-Q;bC&HdXX{F)g$S|*$npbeh{O|YY8_C-JFB_ozw0z91P~`M$Pa`=
z@qhhlHuif&)_06M#Fv0C=&K8c>rvYW*uj=;fW3Je|BN2Xfw$S%gGgn^fQ$h?rMGh6
z9_n&|__H)B9e<i+p7%`XrheK89fbJfG;-jc3I^P*=lgsZAf&<82}trDv0qOC)SLAr
z>&F4nD-LeS>YYvU#v{PbZ<2ghsm=#!RDbvgVsonKPKesUz}v0VfWROhghQu(K-~ld
zU05c`x~!hcXxI*tuPGR*tl~~e7fqvEYlnx$KiXsL1qPwAXk`ry@>NM`d8Mb!?WV5G
zUFNB*xO({-b+u00?n~5p+-29UmANZ#m6TRgmY0@ze|~#G4TDp;qd^|f2}B?Q5tE|_
zAb+{*kP^q5@t={radPAIv<?ZWI9qhVb+NecJare(6c)RR3(s6;+t$G-pRDT&U<^Z$
zeN|atkWJmgl~L44>L$l1UHo$1R{7Jwev&nt!!Vw~uQUpi1A~zENTr^sV{_?-BbRsf
zPv8)BeK3*1?<1gRpb$O<9HzGlpf^qW7=JiI-9SuY@Y@V@4;b<?P)uK4F@h%Ldm)2E
z0{Ije5`zD0-F-+A@YHt#QX7sLA%vX&+vZX~kircs@~at~`XeV~kW+&Or%mcM;wa4_
z#lKKPl6!R>SIA)WH1dN1IdR!nj2E&e>Y-}#aHp_$O(D*nF?&faS5a><2&JksL4Sa>
zsTorHfci|&G3f3wgN(!u>SjS5WZ*4UUj_rR^^mXVX2=>OQI`$uF@bEv{SDN8p)jn0
z0k^I*Lv)S|!`Mah=gppxpww0q$Qb;ZP5lJ8$mXgqwe1Sq+u!dE5u_qaO`J7z`n0K2
zQc{XcAou$AMyY`B*gBY*GBdZRD1UcmO2+o0qM}vvOWDr$C4>lK1Gf0Nj$BvD3&~b$
z6Pr6xl^EwC>9km>OLnuJoqQrhkX+!8ejqoL8po#AD|Ms=Vz*?|=vj;Q<g9Err2a&R
zAa)?x4}^WxLu@J&s<H*b#wGFe)gI5#&)s+P4sj~*ANq<>qxEoyqjM=++JEWYA`fah
z%O^mc@NS+TWGjeW6P~kM4NrF7`MU~vR;kbF?WR%>c=yB;8mK!^Msg$Y33a{kq#ma`
z;g@wZ`Z7xGX${d!Vw+2sCEJt8_Ct=X3-~&6y}wfH=xv`;U0pQ#cNFkK1zEXp@D-Ao
zz$zM*bVk1#8oi+~v8wTn-+!?+#2};%^^n%M=j`o=TnJNR1A{mhj8IBNOkYdghO{`P
zRR4_KB#-t0qJKO<{p=F?@v9L)mpS_?G9LzzltrVxeG#9z<+X^6>b4MCEq0Qw*hID;
za!9EmfkBSVo4;u39~Ne0QTLbh1&fz1UXX61(N}++{MeIedug;OV=>{9B@5GcT%9+6
z@zO=Fr&CwEKlAYyRyx_L(|a8b$IiDLy4;-($F3^2vlZhH%X2N0aR*+Lt_Kwu@!$Ud
XQ#OI1#c6W300000NkvXXu0mjf$IPlR

delta 1907
zcmV-(2aNdg59be%B!8|+L_t(|+U?qFaFo>@$MOB0BwUg-7s|y!kxMO5ixMstDYjV)
zN(%)|iM3O#O9><>AR*i-WJd-a5XO|gXszJH%0P#LETWl~n;Yalp|g~0CI+_C5|$8?
zB_t-qko@{QyV*?wPj@o2`)G9j-#2IW^5!$=oH=KoSqr}*S$_l~5P=9pAYU8E#d`X>
zS^71GoXGxpAGMooeD#G9(NA<rNa2jkm*&1aCu0Hi*3XzVXKq%8Z5!Kna%L>BkL03}
zN=>8*rT2V4JjliMRsh{sY@yzsHGKel|MerhyY)&HQp=m5rZVys0i(l%koALs%?xxL
zh`r8x+pW|w>VFMV(-`@-0`cKOm<G5Qs6k;c4JrsghMEE?0Q!dwnFaip!4fd`D}bB^
z#)J)-4P0fgB#es)q@gBswQSpUAiZ-!nh#}WW^O1d%GBCcRP=#1yj9e;gH>!>0#=#_
z*^@DB%#x4)FXZg(N0Y4U&eIrD=(40xYk|c<EpMWm?SH!DVcSOHU9%v!Go$}db|PJ+
z-!O)(Qe)md`NjikUcE7dHj7Ia^tV#Wp2v`o=Wr|%kl8uGx&<Kf)MAo#52!Rl$XZPO
zf@JA~7*=Nt@g~|xx|1wU(mR}_b3uNd)j_&#DbDQgwTHX{cO)Pq#|DdOfn115uBDa@
z>Wl%z^M9@AGU{yya*ZLhTim48nP??#4l+N{OS&v}(rHQc?rslxP1T#Uw0?ygva!Bq
z74VS(WFAuK>vj*s-ZF;hQ<7(AzQyTIB{?9KTB#Nt;<$ThZBC*|kY4B#qx|hLfTZA;
z^fwLomobEPi!+sEf2++!GSR>JeGuo}kUifu34d}Hc+Y*Mw50gr`3p_=LYm|7BK>6p
z1vG|u6D_(R-(sV0$S1u678uURvByn<yba`sI7e=@9$*^*hXLfEOY7CeF1=9&zG1U9
z>&;)ksl7X8)Re44m26wtY?C0nfZPy}=2$#Qf17|3-dp|6&>8G2Qy?y2NC*gr<J)!g
z^?zH$Hg%3)h%W%2GFUf^q*g;eU@u#90M3?c{1j@f0p6yshmpa~0T~Z`!a$Y4ebn0m
zBwwIb`Q&pX^8-7fhx(BZIt0llsa1&ksu*^6p6j<QOh~h%3t$bb*e_-R>WwCnO_PB5
zwTE}*_O+9&eGK@?ZIbUO)%7s7iXTH_UVjZeDRFxle*2Uf6dvTgXy~c$P;aV&Uet1u
zjk&#*)`-0%=PPKb+|n*eFP>U=Hja!+e!SPj%Zxx3@yZq+<nyxf%4%<g$3wjePldO-
z>c+L3)N61#_Fbi(*HdxxW`(EvPFZ<Xb!B-O{Z)KWRL{s%S=cNO=ma7Vfe1t(0+YE1
z9e;f3kg~!JlTVSXJ+nP4yHi4{E|gq$UnwoVM7=BLi%Z?5#pkcFeVd?FKsI&<FrFsl
zTvrhuWJk|vr4=`tdeak>Uh*2=RprybA(HhwqcE9~uRIRZ!-J5{Sf!>kvZWl&v4!{c
zH{b~M`XP;x?|q<mxDY-C9A%&?pf3&j5PvvEy}_8q$hQ;d88+lapp?P7V-yW42tbCK
z0{H|OM)UuPZ9b#~c<LJgX^6%g6Cs!Wva>t{q<HJvf;vW~fygrra(2kj>}fql9j7s*
z^rvcAdY|r-iW!NXMnNPXr>_M|2tfA7JyJ&=?Gp8lA;i@?;Q+}sD(;VrKpE<M1b-my
z^FtaQQm3dj9zDHAkkQyny}3|_8Gb9(XOV#HJ`yax1+oEF>e+$)29WJ|u$g+FDvW4m
z*lp@cllI66OkA;K;k-F1O6@j)jK?qN?}xw@wp4eueb?F1{(8Sjkg6z^Hut5h*|TQO
zm{DQ?xj%R}$^e3E>-h9B6V{cKtbdy@CT(j;Ny+?i<?LVwQ%r(5fL$TZky}ayAa<p8
zu%**AsYzavE{o0oWe+>pnI}zxYyo~B0#d8gB>H<xsbj4Wr^QaKXDqrWZ*GSnO{YzQ
zIDzyK5cX4#(BE>X>Q)GSQ{wHfd%VL>d1y+;kXgWg7%V}JrIsfeUCY_pM}L7U@(}+n
zp9*z4aCv^1Z6Hpa@T}9OdF=U@zEsFFO8t|8ZY%Xr;7&ZXnR*{rklYUZoqBySfm-Lf
z;Af50`YcZEZwt|<#Ib;Gi`|>bjzdmt3i}+nHBhNd40KSb?rv)RI}UihimYBX^tx{W
zVI8%~x?(^*wO&(5tMPsC8-KQiXoT$HUecEIth3{g%Ta1#co5gpQA(+ptc}#$nw_M*
z8n|d5$>Y6%_#X^XKfX$S_;L);?UjR7%O3?`&860X{zzWFYkth4y7my-EKZW{#8h@1
zazv?N;XzI;T(V;I@0KmfrQV-%mabgAa%ql(TA%-U`nU<%2dK4U(JHc4tCr>Ly|Hk~
z%GE0t=TNWV(DEmqf8E74ojXw2u7A|9gRPx>RGw=IlfefWlg|eWlg|eWlg|eWlg|eW
tlg|eWlg|eWlg|eWlg|eW84*b6{s)Vfd})l49_s)A002ovPDHLkV1jHjtrh?P

diff --git a/tests/ref/transform-skew-relative-sizing.png b/tests/ref/transform-skew-relative-sizing.png
index af44fee98ebe4ec0ab502ad9b08c5c293bcf19bd..4453a4811cdbbadf2778ec26d94a057f2769dd15 100644
GIT binary patch
delta 811
zcmV+`1JwMy2EqoAB!3A>L_t(|+U?eFNE2Zk2XNoi3t!c{gh0z63hH`Q3fgHZA(g)H
z4~2@uvZi6POfwW$iJGWrC`&NC$ZWOJk;+7ZP7yW7+>??m!*(L6%gSqvl_K-ov0eJc
zp=S|6_l4)UA3wOy{dw;0@xfn+kBrEOjBFm6dN}>{*@##SbbqZKUNX{5#ZRC!INIc{
zJ_Nj)3vCoz2}*^bMRB^-a8FTe_?4C`8A=z}Q<4ybJOz+cAy$z_sP2pVea#dBVi`cs
zVl|Xrht|W=kmCjb=QV)i#U~)jh-?AjI_v;S$7urIpMX;Xq=yqWgm7$F>8vSHB67B(
zq9RBGTY@#FOMgV3WW9@N1K!sXL7)Xm1&-#`*<k3{RHSNaZ8;K=HmB2>ra_V7PTVyS
z*);>xZUBw1iEwP;S_C8jU=&cR0FG)jS8nchMLY)JL0nrFVfO{_tq_D(5kjkZsH)x1
zhvETse!++|B(xPkN)<Aa06UKMA)_8a1`J05Ku0(9+kaRPe-=E&f}_EtLfC!OENu$!
zi4~?Wb<AXoiZ8Kr?@cuxIWaSpQkH9Vw+kL<^Ru<uYGE)+r9!E_z5h%#6HNIn{J}Tg
zF|c+<<!_ga$cT*mZwUVbPWx)biJAR9q&X*l0-aa$Oz!IC_Wrkl4J%ExGPArqGxJ7O
z{usQbY=3H91P7Y{#1x5Dm=PD5mEM~=iUm(IaAm=30-sA*tza1|s}(GHnwlY+xc`Z4
z8@wfqYyhdZSS*PexN;j5oQPPGYtpO$Fn5di6R3r8;WNA>Wqt$5b)8NZsli>9F<m7h
zA>-%>a(7#M2+iyD6uGQ{mlQ}?t(>eJ?4R@?u79mdnDh0tRW3s78DW%od-m-cK%zPU
zoU21zApk@S;ZhU)EtuTrY4_=%Kcohs^KNc_3Y&JM&%<&cW_r+1(>OT3v*=@RvZFnG
zFs~Dyl=hAmhmVfx!fU*oa`e!;h{ZfS5370DhA*rQlV;P5dDwyPy*7whsA~|@zl^mq
pwj?NjAZ0{GWJE?}L`MD*<R?WwU^!LOv^D?$002ovPDHLkV1n#pd4vD}

delta 805
zcmV+=1KRw;2D}E4B!2@*L_t(|+U?eFNE2}!$8n$310U6cs3_1fh#u7Ss1&r*oP_;x
z4`x15Q!GP~nrND#IWqhMDjLcZ{BzL+Yo#L{6A3y+{5R%)DcLm46G>fGUSq5jnV*jB
z%qI>#iwL?m{9s>xu-CTR9X~((h5TehMr35?$ZX5p*B7JWFn`dsdAwvqN5xLT7!qyq
zOdkS=7Q>pvtvIE^#3(}ardmaoX+0)hndSz2MG}J0=K$i%#Ytg?`Z2uqF%$um3}9ff
z5vA9o?Tj?!f(gJ)E#Q3h35YTyQ$V;*2Y`|Znt%@=;4}c~;Q&Gi$A*_ISmGoi*UQVx
zgSD_<osQ`ek$-2mCSuxw_ccTiXhBkgqj^mx7+RTxBwdX?TO!i#a=B8pC`^8&x+@|_
z=3zMspy>?}-dp%C0ul%?$<U|)j%u=2?Cj@?d<wvexOc6<;Sb<j0SK)ogx2s-S9z`v
z#RHnWf>CKmSQ~)EN~FgF4xH;ldOd<o7>NRa&Tbg?uzw%{EO?3qM}tX%@UlfG3DF%>
zPQgf>x7ed%i*4P<lgwu?&Ce#5=1hCG^PjY)U2APE6IP>2by3xN-;XY9+_(SG@*lk8
zodcUUCO^AmL`G!fe?#~ma5*+6PHf@#5M6fO6pVLrEuQK1-u`z%4OmZ8T<NWF96l?Z
z-4em6W`6)Nh2j)$Mh1iR-d0g8c$$Gb(>D_IQo?BkYxs3q!74myhiC#`kl1#gNI2OB
zQg5@_;<Rw*G$eB(VoRt_nFfHxA`(EL5mwP>Ur6H8HjsOIy<VY3o!XqL7Lm|NbOw8N
z+j<Di8w?c5sPl#7OE|4ut{Ci}@gnZst621hCx5k@&;~|WS-!4)$2O2CBY+#VP!#|`
z<S=eGBfy546XID_55s8<2%Y<2=YL_#fz&0~PR7g)9@I7sP984&7?R-Zh#1T@!dpr2
z*u#jiF?~d}kB=NZyd`3@jx1r?I%3Bc){YsgW!^gC#P?o1#FlFt#QN8;S>r4615!q0
jL>@+DL`G!fA3=TsZv0-svFpJf00000NkvXXu0mjfcnNnS

diff --git a/tests/suite/layout/container.typ b/tests/suite/layout/container.typ
index f15ddfe4a..489c88925 100644
--- a/tests/suite/layout/container.typ
+++ b/tests/suite/layout/container.typ
@@ -325,3 +325,10 @@ b
 a
 #block(height: -25pt)[b]
 c
+
+--- issue-6267-clip-anti-alias ---
+#block(
+  clip: true,
+  radius: 100%,
+  rect(fill: gray, height: 1cm, width: 1cm),
+)

From 4534167656f34ea2a459fcc526ba41c6a89a5314 Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Wed, 9 Jul 2025 14:02:50 +0200
Subject: [PATCH 064/101] Use "displayed" instead of "repeated" to avoid
 ambiguity in numbering docs (#6565)

---
 crates/typst-library/src/model/numbering.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/typst-library/src/model/numbering.rs b/crates/typst-library/src/model/numbering.rs
index 236ced361..449dfdb33 100644
--- a/crates/typst-library/src/model/numbering.rs
+++ b/crates/typst-library/src/model/numbering.rs
@@ -18,7 +18,7 @@ use crate::foundations::{cast, func, Context, Func, Str, Value};
 ///
 /// A numbering pattern consists of counting symbols, for which the actual
 /// number is substituted, their prefixes, and one suffix. The prefixes and the
-/// suffix are repeated as-is.
+/// suffix are displayed as-is.
 ///
 /// # Example
 /// ```example
@@ -66,10 +66,10 @@ pub fn numbering(
     /// items, the number is represented using repeated symbols.
     ///
     /// **Suffixes** are all characters after the last counting symbol. They are
-    /// repeated as-is at the end of any rendered number.
+    /// displayed as-is at the end of any rendered number.
     ///
     /// **Prefixes** are all characters that are neither counting symbols nor
-    /// suffixes. They are repeated as-is at in front of their rendered
+    /// suffixes. They are displayed as-is at in front of their rendered
     /// equivalent of their counting symbol.
     ///
     /// This parameter can also be an arbitrary function that gets each number

From 9e6adb6f4577a7bfdd119163168e8c6902bd1b21 Mon Sep 17 00:00:00 2001
From: frozolotl <44589151+frozolotl@users.noreply.github.com>
Date: Wed, 9 Jul 2025 14:04:22 +0200
Subject: [PATCH 065/101] Ignore spans when checking for RawElem equality
 (#6560)

---
 crates/typst-library/src/text/raw.rs | 22 +++++++++++++++++++++-
 tests/suite/text/raw.typ             |  5 +++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/crates/typst-library/src/text/raw.rs b/crates/typst-library/src/text/raw.rs
index 8cddfbfb5..0e61a8ef1 100644
--- a/crates/typst-library/src/text/raw.rs
+++ b/crates/typst-library/src/text/raw.rs
@@ -456,7 +456,11 @@ impl PlainText for Packed<RawElem> {
 }
 
 /// The content of the raw text.
-#[derive(Debug, Clone, Hash, PartialEq)]
+#[derive(Debug, Clone, Hash)]
+#[allow(
+    clippy::derived_hash_with_manual_eq,
+    reason = "https://github.com/typst/typst/pull/6560#issuecomment-3045393640"
+)]
 pub enum RawContent {
     /// From a string.
     Text(EcoString),
@@ -481,6 +485,22 @@ impl RawContent {
     }
 }
 
+impl PartialEq for RawContent {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (RawContent::Text(a), RawContent::Text(b)) => a == b,
+            (lines @ RawContent::Lines(_), RawContent::Text(text))
+            | (RawContent::Text(text), lines @ RawContent::Lines(_)) => {
+                *text == lines.get()
+            }
+            (RawContent::Lines(a), RawContent::Lines(b)) => Iterator::eq(
+                a.iter().map(|(line, _)| line),
+                b.iter().map(|(line, _)| line),
+            ),
+        }
+    }
+}
+
 cast! {
     RawContent,
     self => self.get().into_value(),
diff --git a/tests/suite/text/raw.typ b/tests/suite/text/raw.typ
index a7f58a8d0..827edaf8c 100644
--- a/tests/suite/text/raw.typ
+++ b/tests/suite/text/raw.typ
@@ -687,6 +687,11 @@ a b c --------------------
 #let hi = "你好world"
 ```
 
+--- issue-6559-equality-between-raws ---
+
+#test(`foo`, `foo`)
+#assert.ne(`foo`, `bar`)
+
 --- raw-theme-set-to-auto ---
 ```typ
 #let hi = "Hello World"

From 1dc4c248d1022dc9f3b6e3e899857404f6c680a1 Mon Sep 17 00:00:00 2001
From: Malo <57839069+MDLC01@users.noreply.github.com>
Date: Wed, 9 Jul 2025 13:10:24 +0100
Subject: [PATCH 066/101] Add `default` argument for `str.first` and `str.last`
 (#6554)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-library/src/foundations/str.rs | 24 +++++++++++++++++----
 tests/suite/foundations/str.typ             |  4 ++++
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/crates/typst-library/src/foundations/str.rs b/crates/typst-library/src/foundations/str.rs
index 23a1bd4cf..e500b1a4d 100644
--- a/crates/typst-library/src/foundations/str.rs
+++ b/crates/typst-library/src/foundations/str.rs
@@ -179,24 +179,40 @@ impl Str {
     }
 
     /// Extracts the first grapheme cluster of the string.
-    /// Fails with an error if the string is empty.
+    ///
+    /// Returns the provided default value if the string is empty or fails with
+    /// an error if no default value was specified.
     #[func]
-    pub fn first(&self) -> StrResult<Str> {
+    pub fn first(
+        &self,
+        /// A default value to return if the string is empty.
+        #[named]
+        default: Option<Str>,
+    ) -> StrResult<Str> {
         self.0
             .graphemes(true)
             .next()
             .map(Into::into)
+            .or(default)
             .ok_or_else(string_is_empty)
     }
 
     /// Extracts the last grapheme cluster of the string.
-    /// Fails with an error if the string is empty.
+    ///
+    /// Returns the provided default value if the string is empty or fails with
+    /// an error if no default value was specified.
     #[func]
-    pub fn last(&self) -> StrResult<Str> {
+    pub fn last(
+        &self,
+        /// A default value to return if the string is empty.
+        #[named]
+        default: Option<Str>,
+    ) -> StrResult<Str> {
         self.0
             .graphemes(true)
             .next_back()
             .map(Into::into)
+            .or(default)
             .ok_or_else(string_is_empty)
     }
 
diff --git a/tests/suite/foundations/str.typ b/tests/suite/foundations/str.typ
index 66fb912c0..aeaa0a0af 100644
--- a/tests/suite/foundations/str.typ
+++ b/tests/suite/foundations/str.typ
@@ -103,6 +103,10 @@
 #test("Hello".last(), "o")
 #test("🏳️‍🌈A🏳️‍⚧️".first(), "🏳️‍🌈")
 #test("🏳️‍🌈A🏳️‍⚧️".last(), "🏳️‍⚧️")
+#test("hey".first(default: "d"), "h")
+#test("".first(default: "d"), "d")
+#test("hey".last(default: "d"), "y")
+#test("".last(default: "d"), "d")
 
 --- string-first-empty ---
 // Error: 2-12 string is empty

From 1bbb58c43f6f5d94be4b2609728039a9922c75f8 Mon Sep 17 00:00:00 2001
From: Jassiel Ovando <jassielovando@protonmail.com>
Date: Wed, 9 Jul 2025 08:41:40 -0400
Subject: [PATCH 067/101] Add completions subcommand (#6568)

---
 crates/typst-cli/Cargo.toml         |  1 +
 crates/typst-cli/src/args.rs        | 12 ++++++++++++
 crates/typst-cli/src/completions.rs | 13 +++++++++++++
 crates/typst-cli/src/main.rs        |  2 ++
 4 files changed, 28 insertions(+)
 create mode 100644 crates/typst-cli/src/completions.rs

diff --git a/crates/typst-cli/Cargo.toml b/crates/typst-cli/Cargo.toml
index 7e9b93f93..792cabae1 100644
--- a/crates/typst-cli/Cargo.toml
+++ b/crates/typst-cli/Cargo.toml
@@ -29,6 +29,7 @@ typst-svg = { workspace = true }
 typst-timing = { workspace = true }
 chrono = { workspace = true }
 clap = { workspace = true }
+clap_complete = { workspace = true }
 codespan-reporting = { workspace = true }
 color-print = { workspace = true }
 comemo = { workspace = true }
diff --git a/crates/typst-cli/src/args.rs b/crates/typst-cli/src/args.rs
index c3fd541ad..7459be0f2 100644
--- a/crates/typst-cli/src/args.rs
+++ b/crates/typst-cli/src/args.rs
@@ -7,6 +7,7 @@ use std::str::FromStr;
 use chrono::{DateTime, Utc};
 use clap::builder::{TypedValueParser, ValueParser};
 use clap::{ArgAction, Args, ColorChoice, Parser, Subcommand, ValueEnum, ValueHint};
+use clap_complete::Shell;
 use semver::Version;
 
 /// The character typically used to separate path components
@@ -81,6 +82,9 @@ pub enum Command {
     /// Self update the Typst CLI.
     #[cfg_attr(not(feature = "self-update"), clap(hide = true))]
     Update(UpdateCommand),
+
+    /// Generates shell completion scripts.
+    Completions(CompletionsCommand),
 }
 
 /// Compiles an input file into a supported output format.
@@ -198,6 +202,14 @@ pub struct UpdateCommand {
     pub backup_path: Option<PathBuf>,
 }
 
+/// Generates shell completion scripts.
+#[derive(Debug, Clone, Parser)]
+pub struct CompletionsCommand {
+    /// The shell to generate completions for.
+    #[arg(value_enum)]
+    pub shell: Shell,
+}
+
 /// Arguments for compilation and watching.
 #[derive(Debug, Clone, Args)]
 pub struct CompileArgs {
diff --git a/crates/typst-cli/src/completions.rs b/crates/typst-cli/src/completions.rs
new file mode 100644
index 000000000..51e7db103
--- /dev/null
+++ b/crates/typst-cli/src/completions.rs
@@ -0,0 +1,13 @@
+use std::io::stdout;
+
+use clap::CommandFactory;
+use clap_complete::generate;
+
+use crate::args::{CliArguments, CompletionsCommand};
+
+/// Execute the completions command.
+pub fn completions(command: &CompletionsCommand) {
+    let mut cmd = CliArguments::command();
+    let bin_name = cmd.get_name().to_string();
+    generate(command.shell, &mut cmd, bin_name, &mut stdout());
+}
diff --git a/crates/typst-cli/src/main.rs b/crates/typst-cli/src/main.rs
index 14f8a665d..6a3b337d8 100644
--- a/crates/typst-cli/src/main.rs
+++ b/crates/typst-cli/src/main.rs
@@ -1,5 +1,6 @@
 mod args;
 mod compile;
+mod completions;
 mod download;
 mod fonts;
 mod greet;
@@ -71,6 +72,7 @@ fn dispatch() -> HintedStrResult<()> {
         Command::Query(command) => crate::query::query(command)?,
         Command::Fonts(command) => crate::fonts::fonts(command),
         Command::Update(command) => crate::update::update(command)?,
+        Command::Completions(command) => crate::completions::completions(command),
     }
 
     Ok(())

From eed34070513e6060f86f86b56ba7071507fe811b Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Wed, 9 Jul 2025 14:44:42 +0200
Subject: [PATCH 068/101] Update Swedish translations based on defaults used
 for LaTeX and cleveref (#6519)

---
 crates/typst-library/translations/sv.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/typst-library/translations/sv.txt b/crates/typst-library/translations/sv.txt
index 20cea6f96..538f466b0 100644
--- a/crates/typst-library/translations/sv.txt
+++ b/crates/typst-library/translations/sv.txt
@@ -1,8 +1,8 @@
 figure = Figur
 table = Tabell
 equation = Ekvation
-bibliography = Bibliografi
-heading = Kapitel
+bibliography = Referenser
+heading = Avsnitt
 outline = Innehåll
-raw = Listing
+raw = Kodlistning
 page = sida

From f9b01f595dba96044c725a97ecb4972bec7d57ed Mon Sep 17 00:00:00 2001
From: Max <max@mkor.je>
Date: Wed, 9 Jul 2025 13:08:49 +0000
Subject: [PATCH 069/101] Move math styling to codex and add `math.scr` (#6309)

---
 Cargo.lock                                 |   5 +-
 Cargo.toml                                 |   4 +-
 crates/typst-layout/Cargo.toml             |   1 +
 crates/typst-layout/src/math/text.rs       | 254 +++------------------
 crates/typst-library/src/math/equation.rs  |   7 +-
 crates/typst-library/src/math/mod.rs       |   1 +
 crates/typst-library/src/math/style.rs     |  68 +++---
 docs/reference/groups.yml                  |   2 +-
 tests/ref/math-style-fallback.png          | Bin 0 -> 935 bytes
 tests/ref/math-style-hebrew-exceptions.png | Bin 296 -> 489 bytes
 tests/ref/math-style-script.png            | Bin 0 -> 585 bytes
 tests/suite/math/style.typ                 |  21 +-
 12 files changed, 94 insertions(+), 269 deletions(-)
 create mode 100644 tests/ref/math-style-fallback.png
 create mode 100644 tests/ref/math-style-script.png

diff --git a/Cargo.lock b/Cargo.lock
index 5526da48c..1893f89fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -413,7 +413,7 @@ dependencies = [
 [[package]]
 name = "codex"
 version = "0.1.1"
-source = "git+https://github.com/typst/codex?rev=a5428cb#a5428cb9c81a41354d44b44dbd5a16a710bbd928"
+source = "git+https://github.com/typst/codex?rev=9ac86f9#9ac86f96af5b89fce555e6bba8b6d1ac7b44ef00"
 
 [[package]]
 name = "color-print"
@@ -2861,7 +2861,7 @@ dependencies = [
 [[package]]
 name = "typst-assets"
 version = "0.13.1"
-source = "git+https://github.com/typst/typst-assets?rev=c1089b4#c1089b46c461bdde579c55caa941a3cc7dec3e8a"
+source = "git+https://github.com/typst/typst-assets?rev=edf0d64#edf0d648376e29738a05a933af9ea99bb81557b1"
 
 [[package]]
 name = "typst-cli"
@@ -3032,6 +3032,7 @@ version = "0.13.1"
 dependencies = [
  "az",
  "bumpalo",
+ "codex",
  "comemo",
  "ecow",
  "hypher",
diff --git a/Cargo.toml b/Cargo.toml
index 6cc59ee89..9657f207f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ typst-svg = { path = "crates/typst-svg", version = "0.13.1" }
 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-assets = { git = "https://github.com/typst/typst-assets", rev = "edf0d64" }
 typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "bfa947f" }
 arrayvec = "0.7.4"
 az = "1.2"
@@ -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 = "a5428cb" }
+codex = { git = "https://github.com/typst/codex", rev = "9ac86f9" }
 color-print = "0.3.6"
 comemo = "0.4"
 csv = "1"
diff --git a/crates/typst-layout/Cargo.toml b/crates/typst-layout/Cargo.toml
index cc355a3db..2c314e5c5 100644
--- a/crates/typst-layout/Cargo.toml
+++ b/crates/typst-layout/Cargo.toml
@@ -21,6 +21,7 @@ typst-timing = { workspace = true }
 typst-utils = { workspace = true }
 az = { workspace = true }
 bumpalo = { workspace = true }
+codex = { workspace = true }
 comemo = { workspace = true }
 ecow = { workspace = true }
 hypher = { workspace = true }
diff --git a/crates/typst-layout/src/math/text.rs b/crates/typst-layout/src/math/text.rs
index 53f88f2b6..634969cd4 100644
--- a/crates/typst-layout/src/math/text.rs
+++ b/crates/typst-layout/src/math/text.rs
@@ -1,10 +1,11 @@
 use std::f64::consts::SQRT_2;
 
+use codex::styling::{to_style, MathStyle};
 use ecow::EcoString;
 use typst_library::diag::SourceResult;
 use typst_library::foundations::{Packed, StyleChain, SymbolElem};
 use typst_library::layout::{Abs, Size};
-use typst_library::math::{EquationElem, MathSize, MathVariant};
+use typst_library::math::{EquationElem, MathSize};
 use typst_library::text::{
     BottomEdge, BottomEdgeMetric, TextElem, TopEdge, TopEdgeMetric,
 };
@@ -64,12 +65,21 @@ fn layout_inline_text(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<FrameFragment> {
+    let variant = styles.get(EquationElem::variant);
+    let bold = styles.get(EquationElem::bold);
+    // Disable auto-italic.
+    let italic = styles.get(EquationElem::italic).or(Some(false));
+
     if text.chars().all(|c| c.is_ascii_digit() || c == '.') {
         // Small optimization for numbers. Note that this lays out slightly
         // differently to normal text and is worth re-evaluating in the future.
         let mut fragments = vec![];
         for unstyled_c in text.chars() {
-            let c = styled_char(styles, unstyled_c, false);
+            // This is fine as ascii digits and '.' can never end up as more
+            // than a single char after styling.
+            let style = MathStyle::select(unstyled_c, variant, bold, italic);
+            let c = to_style(unstyled_c, style).next().unwrap();
+
             let glyph = GlyphFragment::new_char(ctx.font, styles, c, span)?;
             fragments.push(glyph.into());
         }
@@ -83,8 +93,10 @@ fn layout_inline_text(
         .map(|p| p.wrap());
 
         let styles = styles.chain(&local);
-        let styled_text: EcoString =
-            text.chars().map(|c| styled_char(styles, c, false)).collect();
+        let styled_text: EcoString = text
+            .chars()
+            .flat_map(|c| to_style(c, MathStyle::select(c, variant, bold, italic)))
+            .collect();
 
         let spaced = styled_text.graphemes(true).nth(1).is_some();
         let elem = TextElem::packed(styled_text).spanned(span);
@@ -124,9 +136,16 @@ pub fn layout_symbol(
         Some(c) if has_dtls_feat(ctx.font) => (c, styles.chain(&dtls)),
         _ => (elem.text, styles),
     };
-    let c = styled_char(styles, unstyled_c, true);
+
+    let variant = styles.get(EquationElem::variant);
+    let bold = styles.get(EquationElem::bold);
+    let italic = styles.get(EquationElem::italic);
+
+    let style = MathStyle::select(unstyled_c, variant, bold, italic);
+    let text: EcoString = to_style(unstyled_c, style).collect();
+
     let fragment: MathFragment =
-        match GlyphFragment::new_char(ctx.font, symbol_styles, c, elem.span()) {
+        match GlyphFragment::new(ctx.font, symbol_styles, &text, elem.span()) {
             Ok(mut glyph) => {
                 adjust_glyph_layout(&mut glyph, ctx, styles);
                 glyph.into()
@@ -134,8 +153,7 @@ pub fn layout_symbol(
             Err(_) => {
                 // Not in the math font, fallback to normal inline text layout.
                 // TODO: Should replace this with proper fallback in [`GlyphFragment::new`].
-                layout_inline_text(c.encode_utf8(&mut [0; 4]), elem.span(), ctx, styles)?
-                    .into()
+                layout_inline_text(&text, elem.span(), ctx, styles)?.into()
             }
         };
     ctx.push(fragment);
@@ -161,226 +179,6 @@ fn adjust_glyph_layout(
     }
 }
 
-/// Style the character by selecting the unicode codepoint for italic, bold,
-/// caligraphic, etc.
-///
-/// <https://www.w3.org/TR/mathml-core/#new-text-transform-mappings>
-/// <https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols>
-fn styled_char(styles: StyleChain, c: char, auto_italic: bool) -> char {
-    use MathVariant::*;
-
-    let variant = styles.get(EquationElem::variant);
-    let bold = styles.get(EquationElem::bold);
-    let italic = styles.get(EquationElem::italic).unwrap_or(
-        auto_italic
-            && matches!(
-                c,
-                'a'..='z' | 'ħ' | 'ı' | 'ȷ' | 'A'..='Z' |
-                'α'..='ω' | '∂' | 'ϵ' | 'ϑ' | 'ϰ' | 'ϕ' | 'ϱ' | 'ϖ'
-            )
-            && matches!(variant, Sans | Serif),
-    );
-
-    if let Some(c) = basic_exception(c) {
-        return c;
-    }
-
-    if let Some(c) = latin_exception(c, variant, bold, italic) {
-        return c;
-    }
-
-    if let Some(c) = greek_exception(c, variant, bold, italic) {
-        return c;
-    }
-
-    let base = match c {
-        'A'..='Z' => 'A',
-        'a'..='z' => 'a',
-        'Α'..='Ω' => 'Α',
-        'α'..='ω' => 'α',
-        '0'..='9' => '0',
-        // Hebrew Alef -> Dalet.
-        '\u{05D0}'..='\u{05D3}' => '\u{05D0}',
-        _ => return c,
-    };
-
-    let tuple = (variant, bold, italic);
-    let start = match c {
-        // Latin upper.
-        'A'..='Z' => match tuple {
-            (Serif, false, false) => 0x0041,
-            (Serif, true, false) => 0x1D400,
-            (Serif, false, true) => 0x1D434,
-            (Serif, true, true) => 0x1D468,
-            (Sans, false, false) => 0x1D5A0,
-            (Sans, true, false) => 0x1D5D4,
-            (Sans, false, true) => 0x1D608,
-            (Sans, true, true) => 0x1D63C,
-            (Cal, false, _) => 0x1D49C,
-            (Cal, true, _) => 0x1D4D0,
-            (Frak, false, _) => 0x1D504,
-            (Frak, true, _) => 0x1D56C,
-            (Mono, _, _) => 0x1D670,
-            (Bb, _, _) => 0x1D538,
-        },
-
-        // Latin lower.
-        'a'..='z' => match tuple {
-            (Serif, false, false) => 0x0061,
-            (Serif, true, false) => 0x1D41A,
-            (Serif, false, true) => 0x1D44E,
-            (Serif, true, true) => 0x1D482,
-            (Sans, false, false) => 0x1D5BA,
-            (Sans, true, false) => 0x1D5EE,
-            (Sans, false, true) => 0x1D622,
-            (Sans, true, true) => 0x1D656,
-            (Cal, false, _) => 0x1D4B6,
-            (Cal, true, _) => 0x1D4EA,
-            (Frak, false, _) => 0x1D51E,
-            (Frak, true, _) => 0x1D586,
-            (Mono, _, _) => 0x1D68A,
-            (Bb, _, _) => 0x1D552,
-        },
-
-        // Greek upper.
-        'Α'..='Ω' => match tuple {
-            (Serif, false, false) => 0x0391,
-            (Serif, true, false) => 0x1D6A8,
-            (Serif, false, true) => 0x1D6E2,
-            (Serif, true, true) => 0x1D71C,
-            (Sans, _, false) => 0x1D756,
-            (Sans, _, true) => 0x1D790,
-            (Cal | Frak | Mono | Bb, _, _) => return c,
-        },
-
-        // Greek lower.
-        'α'..='ω' => match tuple {
-            (Serif, false, false) => 0x03B1,
-            (Serif, true, false) => 0x1D6C2,
-            (Serif, false, true) => 0x1D6FC,
-            (Serif, true, true) => 0x1D736,
-            (Sans, _, false) => 0x1D770,
-            (Sans, _, true) => 0x1D7AA,
-            (Cal | Frak | Mono | Bb, _, _) => return c,
-        },
-
-        // Hebrew Alef -> Dalet.
-        '\u{05D0}'..='\u{05D3}' => 0x2135,
-
-        // Numbers.
-        '0'..='9' => match tuple {
-            (Serif, false, _) => 0x0030,
-            (Serif, true, _) => 0x1D7CE,
-            (Bb, _, _) => 0x1D7D8,
-            (Sans, false, _) => 0x1D7E2,
-            (Sans, true, _) => 0x1D7EC,
-            (Mono, _, _) => 0x1D7F6,
-            (Cal | Frak, _, _) => return c,
-        },
-
-        _ => unreachable!(),
-    };
-
-    std::char::from_u32(start + (c as u32 - base as u32)).unwrap()
-}
-
-fn basic_exception(c: char) -> Option<char> {
-    Some(match c {
-        '〈' => '⟨',
-        '〉' => '⟩',
-        '《' => '⟪',
-        '》' => '⟫',
-        _ => return None,
-    })
-}
-
-fn latin_exception(
-    c: char,
-    variant: MathVariant,
-    bold: bool,
-    italic: bool,
-) -> Option<char> {
-    use MathVariant::*;
-    Some(match (c, variant, bold, italic) {
-        ('B', Cal, false, _) => 'ℬ',
-        ('E', Cal, false, _) => 'ℰ',
-        ('F', Cal, false, _) => 'ℱ',
-        ('H', Cal, false, _) => 'ℋ',
-        ('I', Cal, false, _) => 'ℐ',
-        ('L', Cal, false, _) => 'ℒ',
-        ('M', Cal, false, _) => 'ℳ',
-        ('R', Cal, false, _) => 'ℛ',
-        ('C', Frak, false, _) => 'ℭ',
-        ('H', Frak, false, _) => 'ℌ',
-        ('I', Frak, false, _) => 'ℑ',
-        ('R', Frak, false, _) => 'ℜ',
-        ('Z', Frak, false, _) => 'ℨ',
-        ('C', Bb, ..) => 'ℂ',
-        ('H', Bb, ..) => 'ℍ',
-        ('N', Bb, ..) => 'ℕ',
-        ('P', Bb, ..) => 'ℙ',
-        ('Q', Bb, ..) => 'ℚ',
-        ('R', Bb, ..) => 'ℝ',
-        ('Z', Bb, ..) => 'ℤ',
-        ('D', Bb, _, true) => 'ⅅ',
-        ('d', Bb, _, true) => 'ⅆ',
-        ('e', Bb, _, true) => 'ⅇ',
-        ('i', Bb, _, true) => 'ⅈ',
-        ('j', Bb, _, true) => 'ⅉ',
-        ('h', Serif, false, true) => 'ℎ',
-        ('e', Cal, false, _) => 'ℯ',
-        ('g', Cal, false, _) => 'ℊ',
-        ('o', Cal, false, _) => 'ℴ',
-        ('ħ', Serif, .., true) => 'ℏ',
-        ('ı', Serif, .., true) => '𝚤',
-        ('ȷ', Serif, .., true) => '𝚥',
-        _ => return None,
-    })
-}
-
-fn greek_exception(
-    c: char,
-    variant: MathVariant,
-    bold: bool,
-    italic: bool,
-) -> Option<char> {
-    use MathVariant::*;
-    if c == 'Ϝ' && variant == Serif && bold {
-        return Some('𝟊');
-    }
-    if c == 'ϝ' && variant == Serif && bold {
-        return Some('𝟋');
-    }
-
-    let list = match c {
-        'ϴ' => ['𝚹', '𝛳', '𝜭', '𝝧', '𝞡', 'ϴ'],
-        '∇' => ['𝛁', '𝛻', '𝜵', '𝝯', '𝞩', '∇'],
-        '∂' => ['𝛛', '𝜕', '𝝏', '𝞉', '𝟃', '∂'],
-        'ϵ' => ['𝛜', '𝜖', '𝝐', '𝞊', '𝟄', 'ϵ'],
-        'ϑ' => ['𝛝', '𝜗', '𝝑', '𝞋', '𝟅', 'ϑ'],
-        'ϰ' => ['𝛞', '𝜘', '𝝒', '𝞌', '𝟆', 'ϰ'],
-        'ϕ' => ['𝛟', '𝜙', '𝝓', '𝞍', '𝟇', 'ϕ'],
-        'ϱ' => ['𝛠', '𝜚', '𝝔', '𝞎', '𝟈', 'ϱ'],
-        'ϖ' => ['𝛡', '𝜛', '𝝕', '𝞏', '𝟉', 'ϖ'],
-        'Γ' => ['𝚪', '𝛤', '𝜞', '𝝘', '𝞒', 'ℾ'],
-        'γ' => ['𝛄', '𝛾', '𝜸', '𝝲', '𝞬', 'ℽ'],
-        'Π' => ['𝚷', '𝛱', '𝜫', '𝝥', '𝞟', 'ℿ'],
-        'π' => ['𝛑', '𝜋', '𝝅', '𝝿', '𝞹', 'ℼ'],
-        '∑' => ['∑', '∑', '∑', '∑', '∑', '⅀'],
-        _ => return None,
-    };
-
-    Some(match (variant, bold, italic) {
-        (Serif, true, false) => list[0],
-        (Serif, false, true) => list[1],
-        (Serif, true, true) => list[2],
-        (Sans, _, false) => list[3],
-        (Sans, _, true) => list[4],
-        (Bb, ..) => list[5],
-        _ => return None,
-    })
-}
-
 /// The non-dotless version of a dotless character that can be used with the
 /// `dtls` OpenType feature.
 pub fn try_dotless(c: char) -> Option<char> {
diff --git a/crates/typst-library/src/math/equation.rs b/crates/typst-library/src/math/equation.rs
index 0c9ba11df..a2ae54471 100644
--- a/crates/typst-library/src/math/equation.rs
+++ b/crates/typst-library/src/math/equation.rs
@@ -1,5 +1,6 @@
 use std::num::NonZeroUsize;
 
+use codex::styling::MathVariant;
 use typst_utils::NonZeroExt;
 use unicode_math_class::MathClass;
 
@@ -12,7 +13,7 @@ use crate::introspection::{Count, Counter, CounterUpdate, Locatable};
 use crate::layout::{
     AlignElem, Alignment, BlockElem, OuterHAlignment, SpecificAlignment, VAlignment,
 };
-use crate::math::{MathSize, MathVariant};
+use crate::math::MathSize;
 use crate::model::{Numbering, Outlinable, ParLine, Refable, Supplement};
 use crate::text::{FontFamily, FontList, FontWeight, LocalName, TextElem};
 
@@ -111,7 +112,7 @@ pub struct EquationElem {
     /// The style variant to select.
     #[internal]
     #[ghost]
-    pub variant: MathVariant,
+    pub variant: Option<MathVariant>,
 
     /// Affects the height of exponents.
     #[internal]
@@ -128,7 +129,7 @@ pub struct EquationElem {
     /// Whether to use italic glyphs.
     #[internal]
     #[ghost]
-    pub italic: Smart<bool>,
+    pub italic: Option<bool>,
 
     /// A forced class to use for all fragment.
     #[internal]
diff --git a/crates/typst-library/src/math/mod.rs b/crates/typst-library/src/math/mod.rs
index 2e6d42b13..3d39e2fd2 100644
--- a/crates/typst-library/src/math/mod.rs
+++ b/crates/typst-library/src/math/mod.rs
@@ -80,6 +80,7 @@ pub fn module() -> Module {
     math.define_func::<italic>();
     math.define_func::<serif>();
     math.define_func::<sans>();
+    math.define_func::<scr>();
     math.define_func::<cal>();
     math.define_func::<frak>();
     math.define_func::<mono>();
diff --git a/crates/typst-library/src/math/style.rs b/crates/typst-library/src/math/style.rs
index 53242e6e0..6a85fd123 100644
--- a/crates/typst-library/src/math/style.rs
+++ b/crates/typst-library/src/math/style.rs
@@ -1,4 +1,6 @@
-use crate::foundations::{func, Cast, Content, Smart};
+use codex::styling::MathVariant;
+
+use crate::foundations::{func, Cast, Content};
 use crate::math::EquationElem;
 
 /// Bold font style in math.
@@ -24,7 +26,7 @@ pub fn upright(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::italic, Smart::Custom(false))
+    body.set(EquationElem::italic, Some(false))
 }
 
 /// Italic font style in math.
@@ -35,7 +37,7 @@ pub fn italic(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::italic, Smart::Custom(true))
+    body.set(EquationElem::italic, Some(true))
 }
 
 /// Serif (roman) font style in math.
@@ -46,7 +48,7 @@ pub fn serif(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::variant, MathVariant::Serif)
+    body.set(EquationElem::variant, Some(MathVariant::Plain))
 }
 
 /// Sans-serif font style in math.
@@ -59,23 +61,39 @@ pub fn sans(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::variant, MathVariant::Sans)
+    body.set(EquationElem::variant, Some(MathVariant::SansSerif))
 }
 
-/// Calligraphic font style in math.
+/// Calligraphic (chancery) font style in math.
 ///
 /// ```example
 /// Let $cal(P)$ be the set of ...
 /// ```
 ///
-/// This corresponds both to LaTeX's `\mathcal` and `\mathscr` as both of these
-/// styles share the same Unicode codepoints. Switching between the styles is
-/// thus only possible if supported by the font via
-/// [font features]($text.features).
+/// This is the default calligraphic/script style for most math fonts. See
+/// [`scr`]($math.scr) for more on how to get the other style (roundhand).
+#[func(title = "Calligraphic", keywords = ["mathcal", "chancery"])]
+pub fn cal(
+    /// The content to style.
+    body: Content,
+) -> Content {
+    body.set(EquationElem::variant, Some(MathVariant::Chancery))
+}
+
+/// Script (roundhand) font style in math.
 ///
-/// For the default math font, the roundhand style is available through the
-/// `ss01` feature. Therefore, you could define your own version of `\mathscr`
-/// like this:
+/// ```example
+/// $ scr(S) $
+/// ```
+///
+/// There are two ways that fonts can support differentiating `cal` and `scr`.
+/// The first is using Unicode variation sequences. This works out of the box
+/// in Typst, however only a few math fonts currently support this.
+///
+/// The other way is using [font features]($text.features). For example, the
+/// roundhand style might be available in a font through the `ss01` feature.
+/// To use it in Typst, you could then define your own version of `scr` like
+/// this:
 ///
 /// ```example
 /// #let scr(it) = text(
@@ -88,12 +106,12 @@ pub fn sans(
 ///
 /// (The box is not conceptually necessary, but unfortunately currently needed
 /// due to limitations in Typst's text style handling in math.)
-#[func(title = "Calligraphic", keywords = ["mathcal", "mathscr"])]
-pub fn cal(
+#[func(title = "Script Style", keywords = ["mathscr", "roundhand"])]
+pub fn scr(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::variant, MathVariant::Cal)
+    body.set(EquationElem::variant, Some(MathVariant::Roundhand))
 }
 
 /// Fraktur font style in math.
@@ -106,7 +124,7 @@ pub fn frak(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::variant, MathVariant::Frak)
+    body.set(EquationElem::variant, Some(MathVariant::Fraktur))
 }
 
 /// Monospace font style in math.
@@ -119,7 +137,7 @@ pub fn mono(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::variant, MathVariant::Mono)
+    body.set(EquationElem::variant, Some(MathVariant::Monospace))
 }
 
 /// Blackboard bold (double-struck) font style in math.
@@ -137,7 +155,7 @@ pub fn bb(
     /// The content to style.
     body: Content,
 ) -> Content {
-    body.set(EquationElem::variant, MathVariant::Bb)
+    body.set(EquationElem::variant, Some(MathVariant::DoubleStruck))
 }
 
 /// Forced display style in math.
@@ -240,15 +258,3 @@ pub enum MathSize {
     /// Math on its own line.
     Display,
 }
-
-/// A mathematical style variant, as defined by Unicode.
-#[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Cast, Hash)]
-pub enum MathVariant {
-    #[default]
-    Serif,
-    Sans,
-    Cal,
-    Frak,
-    Mono,
-    Bb,
-}
diff --git a/docs/reference/groups.yml b/docs/reference/groups.yml
index 1aaa8f229..b187443e4 100644
--- a/docs/reference/groups.yml
+++ b/docs/reference/groups.yml
@@ -5,7 +5,7 @@
   title: Variants
   category: math
   path: ["math"]
-  filter: ["serif", "sans", "frak", "mono", "bb", "cal"]
+  filter: ["serif", "sans", "frak", "mono", "bb", "cal", "scr"]
   details: |
     Alternate typefaces within formulas.
 
diff --git a/tests/ref/math-style-fallback.png b/tests/ref/math-style-fallback.png
new file mode 100644
index 0000000000000000000000000000000000000000..de0283762d8208eb46d0d34b6d1727c5692ef64f
GIT binary patch
literal 935
zcmV;Y16cftP)<h;3K|Lk000e1NJLTq004LZ003YJ00000^NQ*C000ASNkl<Zc-rmN
zU2Icj9LI5FF;OoxCPovK3kez$l7&RGN}?n2LZYG}0YybjhFmOB%-jN6B(N<-sNGy$
zWipn6o5aTMFqbitDOEXfE0(=c6*i94ZD$jFDHuK7*5TGKDN8R-dd171hVXo^{&%08
zi}QQtkfY`(_@;vYX|6Q^dsa*BX<>Nmq2JB?V><vEJ?Xv%;){$wAJr>G;e89BdSM5)
zTJ8q_!hk6J!-Ei;d)EHN(R(1CcTyC_UDxa>Ti1)N-CnI~%S)Z2Fr*;6l=_bqd;`Og
z_67rc=Z`cuq@-c*hjrV#0n>A-^8l~-YqtF_4Hungv#@8ak9-Hx@H$WN5cV&&p4_%o
z9$rsYRtd<%E6Hj^9){%oWYzRG@^IWuR_#aBaw%BBR|2Q@y}Z110PIbD^up85F;RH=
zihr%DJ36p+Vae;0@pta*7lgmP#Q-)IVC&Oc6Tr&Vf^cKrmk!4hHS>TOEtt*#To3ph
zj@6})3BvVxeJ<Bd@9h9%X1Z};>-><*Raf?~Ags^r0-i4bW@<d?`hWwsorWpLDnS^}
z0(bMWXGXENY0<}@J+k(kBuxB^YJ;rKG}ex)<x;SMFAHw-0Ga$#036zlJlvmu5;Bzo
zz~GC4lsNoXVLX|+f6)L)ZK|3?9HyYYTuW=gKw$0uz#uUEtmi<3JiK@&S^{7W#Y%^U
z5&(s%o_FQpW&FGmNY(kA8+^WgVDL>UzE4QQ<4Y#>qUrRJa9W8(`q~p@RcA~Z?mF1r
zde8)za5LLa<MbW9jsp@H%+YckR$HxL1z$V(=&w0~E4i-lROU#!nQeLodH8JMuFcax
zkFM|9qZ<I9yjJ|9JX~4cyEh0#!{H6#@NdBJ8gI8#9^UB=h5i7((E_h(S`Sd(&>k}7
zVgCw35n$AKuiG&G2CB<w8kUFI`@RMM+nLR(*bzk(ws$I!qXFrdP+P5F1z$bfHk!F2
zXUNnl5BJ_%pZy}Y<;%m*c}tjW;sY|5|2}cJskZYefDyy+9Wu@V!2aaC3&OCq)a;)R
z@Rg>m(X=Q4F~7Ok6oxmy;dI{hAJ7**{8l(T0)Q_RT6#<tKD7pTJOV`Y;tpMp0W=Ok
zQL8N6G7Nlv-1Z`OZ3#0_Q8g(C+dC1=(Q*ZoYO58jU<E5UtBbGw3zTH5h86$-002ov
JPDHLkV1ixa#QgvO

literal 0
HcmV?d00001

diff --git a/tests/ref/math-style-hebrew-exceptions.png b/tests/ref/math-style-hebrew-exceptions.png
index 723466e8a36f109e890fd77b08b8c78d4ba30caf..a6f511e0e2ce7dbcf6ead15b06bb3429f90bcd12 100644
GIT binary patch
delta 476
zcmV<20VDpX0_g*g7k?-S000005P@O&00057Nkl<Zc-rlhyGue*9LIY=ThLGu)X-yV
z3d(41YY8Hvt+sHC8hSvGK|>T05xoO@L6}K_GzgZIkclJ_g%~Cwrua%t)9Y2g;XU_W
z|AJ!=?pc1H-}ek3&TzgZ_@PrGi6yZl{%_(O86GiU{Q`xkiGS5r1SSX`);F|UIQo<+
z;v}1?tE=v$A`bRM(QgvAmmxAEs$B@@QAb6L**<nvFK&|psKm&3N=3{LT#RfL)&&7J
z#mKWwMeH5Mn!K<o`N<54(enxwF=Ve8Gr-6DmJv+?$S4n-Lbk7=^kNedI&^&i!yO%M
zZS3AWplx1CO@Bdt1pt_f&@2#J4u})90vQg%t|By-StMsr%%rZC#D7!#4!Af7J}`WA
z$KQCr7>eS><3x=*50@3?vTz=fRsE!~%1X=4^u+F3qxOj-mN95Jh%3ldnwihi6YtoX
zHUy5G@fmot0`$akqp8uuv%|rSSoa&*z2g+c>%BNxx>X+q)UB;8)80Ygrt<d4Fbe?w
z8H!?02#96Rfq>m^4?qh<-C)x?0ANzI|8eqKAUzooOR)<i#}BD8C9x#_?c#59gk+da
S{@2|A0000<MNUMnLSTYa3fPJO

delta 282
zcmV+#0p<Sb1E>O!7k?WF00000l5Z6H0002*Nkl<Zc-mw5KR|$C)Z$T#M=c(17XO1#
zPvHW;U%^;!X=d@NGyh+gLzqjXWsFaOS)WZCzd*!lB_u@5Xkzgj&yW9ukHC1h;~?~h
z1#{slE^nbtP&Wkrp0W$htAH^Uz=d9{rHRGAL${^PLU21_jDMMMp{KKHV)66%|I;!M
z+&(D%GY&3vZ4zyQ+VtN4qP_oLK<%6G|KoQc{ikp7U6|OSH8k?^k^f(}{I_`j|9`xR
ziGjiIg{}YpuT$#zQTab(KUhW62U->&=Ye?{nuE>&Jq%{NyHAIb>ja#2_YGWZw5%Sr
gc+}!ii!lKJM-vcqv*9Pp#{d8T07*qoM6N<$g4#KY5&!@I

diff --git a/tests/ref/math-style-script.png b/tests/ref/math-style-script.png
new file mode 100644
index 0000000000000000000000000000000000000000..379d270e70b7f94412429b785f9285a7de95939a
GIT binary patch
literal 585
zcmV-P0=E5$P)<h;3K|Lk000e1NJLTq004LZ001rs00000#@K@70006INkl<Zc-rmM
z!Ap~I9LI49qCkScLkIEDC8RPU%fbjDqk{*bpd>L5)nX8u2gyWP4vBPv1TNb`$uLK;
z&0uC_gEEz^xmeR$#x}P$iqegACS!Z{tapc<`U8F>@q90z@8|Toee(E6m#4rAtib;v
zEX#k@@P}L`Qexr6P-#wJ{3MLc-F;Hh4p=JGohFg6eD!?;08F;)7;EYtq;D6r?tFPs
z6A=k_d5l)@>J57P{$H7*dFwcxhjDIkHz$jI0^va8?{hJ@g<NO2#`7Y8)7QCtlm^Oz
z0^xeCb~m79Xr>^7{vhx(e~~>JKF9YW3U&pJZwc1KW%a@Zi@Ewc69p1n>W9)klC@r8
z@Icob*vn_-+Iv&4j}J;@ubk>_eFnTK*BbrGaw)I^E3g7@40zoUhm7C1@CCpV1d>3=
z4UiHCe=2oPtj^o-oSkmb6EJ^0KgHqziBXT?CP`gd9NeaV8g-1&-48@&M}0d+ejJn1
zwq?r+Rkr#g!r*k9&Kq8W8Yl27rminpJ92}`jJhX3*i?Zqc=^D)_&PxGutmaeN^Ezk
zHb;q>Lshr$Z!(F4H7zR-rh&vE00Jvk+rBeEJmh**S15^to2_<f26*uh)>z#-OmATr
zC{y9uW<wkt?QlE3fmB&p)#yU*a2jft0D7E{YupHgA(M-23IG`(_bHR9zzVFu8wvgc
Xv-kkgIPW+k00000NkvXXu0mjfPN@i6

literal 0
HcmV?d00001

diff --git a/tests/suite/math/style.typ b/tests/suite/math/style.typ
index 1fa2695e6..3ecf856b3 100644
--- a/tests/suite/math/style.typ
+++ b/tests/suite/math/style.typ
@@ -12,6 +12,15 @@ $A, italic(A), upright(A), bold(A), bold(upright(A)), \
  bb("hello") + bold(cal("world")), \
  mono("SQRT")(x) wreath mono(123 + 456)$
 
+--- math-style-fallback ---
+// Test how math styles fallback.
+$upright(frak(bold(alpha))) = upright(bold(alpha)) \
+bold(mono(ϝ)) = bold(ϝ) \
+sans(Theta) = bold(sans(Theta)) \
+bold(upright(planck)) != planck \
+bb(e) != italic(bb(e)) \
+serif(sans(A)) != serif(A)$
+
 --- math-style-dotless ---
 // Test styling dotless i and j.
 $ dotless.i dotless.j,
@@ -21,7 +30,7 @@ $ dotless.i dotless.j,
   bb(dotless.i) bb(dotless.j),
   cal(dotless.i) cal(dotless.j),
   frak(dotless.i) frak(dotless.j),
-  mono(dotless.i) mono(dotless.j), 
+  mono(dotless.i) mono(dotless.j),
   bold(frak(dotless.i)) upright(sans(dotless.j)),
   italic(bb(dotless.i)) frak(sans(dotless.j)) $
 
@@ -38,7 +47,15 @@ $bb(Gamma) , bb(gamma), bb(Pi), bb(pi), bb(sum)$
 
 --- math-style-hebrew-exceptions ---
 // Test hebrew exceptions.
-$aleph, beth, gimel, daleth$
+$aleph, beth, gimel, daleth$ \
+$upright(aleph), upright(beth), upright(gimel), upright(daleth)$
+
+--- math-style-script ---
+// Test variation selectors for scr and cal.
+$cal(A) scr(A) bold(cal(O)) scr(bold(O))$
+
+#show math.equation: set text(font: "Noto Sans Math")
+$scr(E) cal(E) bold(scr(Y)) cal(bold(Y))$
 
 --- issue-3650-italic-equation ---
 _abc $sin(x) "abc"$_ \

From a45c3388a642d6d7321b5c5b684d3582e91cff41 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 9 Jul 2025 15:40:22 +0200
Subject: [PATCH 070/101] More consistent `Packed<T>` to `Content` conversion
 methods (#6579)

---
 .../src/foundations/content/packed.rs              | 14 ++++++++++----
 .../typst-library/src/foundations/content/raw.rs   |  2 +-
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/crates/typst-library/src/foundations/content/packed.rs b/crates/typst-library/src/foundations/content/packed.rs
index 71bb66a94..e99162629 100644
--- a/crates/typst-library/src/foundations/content/packed.rs
+++ b/crates/typst-library/src/foundations/content/packed.rs
@@ -64,6 +64,16 @@ impl<T: NativeElement> Packed<T> {
         self.0
     }
 
+    /// Pack back into a reference to content.
+    pub fn pack_ref(&self) -> &Content {
+        &self.0
+    }
+
+    /// Pack back into a mutable reference to content.
+    pub fn pack_mut(&mut self) -> &mut Content {
+        &mut self.0
+    }
+
     /// Extract the raw underlying element.
     pub fn unpack(self) -> T {
         // This function doesn't yet need owned self, but might in the future.
@@ -94,10 +104,6 @@ impl<T: NativeElement> Packed<T> {
     pub fn set_location(&mut self, location: Location) {
         self.0.set_location(location);
     }
-
-    pub fn as_content(&self) -> &Content {
-        &self.0
-    }
 }
 
 impl<T: NativeElement> AsRef<T> for Packed<T> {
diff --git a/crates/typst-library/src/foundations/content/raw.rs b/crates/typst-library/src/foundations/content/raw.rs
index f5dfffd73..dde26bd79 100644
--- a/crates/typst-library/src/foundations/content/raw.rs
+++ b/crates/typst-library/src/foundations/content/raw.rs
@@ -141,7 +141,7 @@ impl RawContent {
 
     /// Clones a packed element into new raw content.
     pub(super) fn clone_impl<E: NativeElement>(elem: &Packed<E>) -> Self {
-        let raw = &elem.as_content().0;
+        let raw = &elem.pack_ref().0;
         let header = raw.header();
         RawContent::create(
             elem.as_ref().clone(),

From 3aa7e861e7ffe03193d94c2cfd249739ef746f09 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 9 Jul 2025 15:48:43 +0200
Subject: [PATCH 071/101] Support images in HTML export (#6578)

---
 crates/typst-html/src/css.rs                  | 65 +++++++++++++-
 crates/typst-html/src/rules.rs                | 45 +++++++++-
 crates/typst-layout/src/image.rs              | 85 ++-----------------
 crates/typst-library/src/html/dom.rs          |  5 ++
 .../typst-library/src/visualize/image/mod.rs  | 82 +++++++++++++++++-
 crates/typst-svg/src/image.rs                 | 26 +++---
 crates/typst-svg/src/lib.rs                   |  2 +
 tests/ref/html/image-jpg-html-base64.html     |  8 ++
 tests/ref/html/image-scaling-methods.html     | 10 +++
 tests/suite/visualize/image.typ               | 23 ++++-
 10 files changed, 250 insertions(+), 101 deletions(-)
 create mode 100644 tests/ref/html/image-jpg-html-base64.html
 create mode 100644 tests/ref/html/image-scaling-methods.html

diff --git a/crates/typst-html/src/css.rs b/crates/typst-html/src/css.rs
index 2b659188a..6c84cba0f 100644
--- a/crates/typst-html/src/css.rs
+++ b/crates/typst-html/src/css.rs
@@ -1,11 +1,72 @@
 //! Conversion from Typst data types into CSS data types.
 
-use std::fmt::{self, Display};
+use std::fmt::{self, Display, Write};
 
-use typst_library::layout::Length;
+use ecow::EcoString;
+use typst_library::html::{attr, HtmlElem};
+use typst_library::layout::{Length, Rel};
 use typst_library::visualize::{Color, Hsl, LinearRgb, Oklab, Oklch, Rgb};
 use typst_utils::Numeric;
 
+/// Additional methods for [`HtmlElem`].
+pub trait HtmlElemExt {
+    /// Adds the styles to an element if the property list is non-empty.
+    fn with_styles(self, properties: Properties) -> Self;
+}
+
+impl HtmlElemExt for HtmlElem {
+    /// Adds CSS styles to an element.
+    fn with_styles(self, properties: Properties) -> Self {
+        if let Some(value) = properties.into_inline_styles() {
+            self.with_attr(attr::style, value)
+        } else {
+            self
+        }
+    }
+}
+
+/// A list of CSS properties with values.
+#[derive(Debug, Default)]
+pub struct Properties(EcoString);
+
+impl Properties {
+    /// Creates an empty list.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Adds a new property to the list.
+    pub fn push(&mut self, property: &str, value: impl Display) {
+        if !self.0.is_empty() {
+            self.0.push_str("; ");
+        }
+        write!(&mut self.0, "{property}: {value}").unwrap();
+    }
+
+    /// Adds a new property in builder-style.
+    #[expect(unused)]
+    pub fn with(mut self, property: &str, value: impl Display) -> Self {
+        self.push(property, value);
+        self
+    }
+
+    /// Turns this into a string suitable for use as an inline `style`
+    /// attribute.
+    pub fn into_inline_styles(self) -> Option<EcoString> {
+        (!self.0.is_empty()).then_some(self.0)
+    }
+}
+
+pub fn rel(rel: Rel) -> impl Display {
+    typst_utils::display(move |f| match (rel.abs.is_zero(), rel.rel.is_zero()) {
+        (false, false) => {
+            write!(f, "calc({}% + {})", rel.rel.get(), length(rel.abs))
+        }
+        (true, false) => write!(f, "{}%", rel.rel.get()),
+        (_, true) => write!(f, "{}", length(rel.abs)),
+    })
+}
+
 pub fn length(length: Length) -> impl Display {
     typst_utils::display(move |f| match (length.abs.is_zero(), length.em.is_zero()) {
         (false, false) => {
diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index f361bfbb3..5bf25e79b 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -3,12 +3,12 @@ use std::num::NonZeroUsize;
 use ecow::{eco_format, EcoVec};
 use typst_library::diag::warning;
 use typst_library::foundations::{
-    Content, NativeElement, NativeRuleMap, ShowFn, StyleChain, Target,
+    Content, NativeElement, NativeRuleMap, ShowFn, Smart, StyleChain, Target,
 };
 use typst_library::html::{attr, tag, HtmlAttrs, HtmlElem, HtmlTag};
 use typst_library::introspection::{Counter, Locator};
 use typst_library::layout::resolve::{table_to_cellgrid, Cell, CellGrid, Entry};
-use typst_library::layout::OuterVAlignment;
+use typst_library::layout::{OuterVAlignment, Sizing};
 use typst_library::model::{
     Attribution, CiteElem, CiteGroup, Destination, EmphElem, EnumElem, FigureCaption,
     FigureElem, HeadingElem, LinkElem, LinkTarget, ListElem, ParbreakElem, QuoteElem,
@@ -18,6 +18,9 @@ use typst_library::text::{
     HighlightElem, LinebreakElem, OverlineElem, RawElem, RawLine, SpaceElem, StrikeElem,
     SubElem, SuperElem, UnderlineElem,
 };
+use typst_library::visualize::ImageElem;
+
+use crate::css::{self, HtmlElemExt};
 
 /// Register show rules for the [HTML target](Target::Html).
 pub fn register(rules: &mut NativeRuleMap) {
@@ -47,6 +50,9 @@ pub fn register(rules: &mut NativeRuleMap) {
     rules.register(Html, HIGHLIGHT_RULE);
     rules.register(Html, RAW_RULE);
     rules.register(Html, RAW_LINE_RULE);
+
+    // Visualize.
+    rules.register(Html, IMAGE_RULE);
 }
 
 const STRONG_RULE: ShowFn<StrongElem> = |elem, _, _| {
@@ -338,7 +344,7 @@ fn show_cellgrid(grid: CellGrid, styles: StyleChain) -> Content {
 fn show_cell(tag: HtmlTag, cell: &Cell, styles: StyleChain) -> Content {
     let cell = cell.body.clone();
     let Some(cell) = cell.to_packed::<TableCell>() else { return cell };
-    let mut attrs = HtmlAttrs::default();
+    let mut attrs = HtmlAttrs::new();
     let span = |n: NonZeroUsize| (n != NonZeroUsize::MIN).then(|| n.to_string());
     if let Some(colspan) = span(cell.colspan.get(styles)) {
         attrs.push(attr::colspan, colspan);
@@ -409,3 +415,36 @@ const RAW_RULE: ShowFn<RawElem> = |elem, _, styles| {
 };
 
 const RAW_LINE_RULE: ShowFn<RawLine> = |elem, _, _| Ok(elem.body.clone());
+
+const IMAGE_RULE: ShowFn<ImageElem> = |elem, engine, styles| {
+    let image = elem.decode(engine, styles)?;
+
+    let mut attrs = HtmlAttrs::new();
+    attrs.push(attr::src, typst_svg::convert_image_to_base64_url(&image));
+
+    if let Some(alt) = elem.alt.get_cloned(styles) {
+        attrs.push(attr::alt, alt);
+    }
+
+    let mut inline = css::Properties::new();
+
+    // TODO: Exclude in semantic profile.
+    if let Some(value) = typst_svg::convert_image_scaling(image.scaling()) {
+        inline.push("image-rendering", value);
+    }
+
+    // TODO: Exclude in semantic profile?
+    match elem.width.get(styles) {
+        Smart::Auto => {}
+        Smart::Custom(rel) => inline.push("width", css::rel(rel)),
+    }
+
+    // TODO: Exclude in semantic profile?
+    match elem.height.get(styles) {
+        Sizing::Auto => {}
+        Sizing::Rel(rel) => inline.push("height", css::rel(rel)),
+        Sizing::Fr(_) => {}
+    }
+
+    Ok(HtmlElem::new(tag::img).with_attrs(attrs).with_styles(inline).pack())
+};
diff --git a/crates/typst-layout/src/image.rs b/crates/typst-layout/src/image.rs
index 261a58fa3..d4fd121ec 100644
--- a/crates/typst-layout/src/image.rs
+++ b/crates/typst-layout/src/image.rs
@@ -1,18 +1,11 @@
-use std::ffi::OsStr;
-
-use typst_library::diag::{warning, At, LoadedWithin, SourceResult, StrResult};
+use typst_library::diag::SourceResult;
 use typst_library::engine::Engine;
-use typst_library::foundations::{Bytes, Derived, Packed, Smart, StyleChain};
+use typst_library::foundations::{Packed, StyleChain};
 use typst_library::introspection::Locator;
 use typst_library::layout::{
     Abs, Axes, FixedAlignment, Frame, FrameItem, Point, Region, Size,
 };
-use typst_library::loading::DataSource;
-use typst_library::text::families;
-use typst_library::visualize::{
-    Curve, ExchangeFormat, Image, ImageElem, ImageFit, ImageFormat, ImageKind,
-    RasterImage, SvgImage, VectorFormat,
-};
+use typst_library::visualize::{Curve, Image, ImageElem, ImageFit};
 
 /// Layout the image.
 #[typst_macros::time(span = elem.span())]
@@ -23,53 +16,7 @@ pub fn layout_image(
     styles: StyleChain,
     region: Region,
 ) -> SourceResult<Frame> {
-    let span = elem.span();
-
-    // Take the format that was explicitly defined, or parse the extension,
-    // or try to detect the format.
-    let Derived { source, derived: loaded } = &elem.source;
-    let format = match elem.format.get(styles) {
-        Smart::Custom(v) => v,
-        Smart::Auto => determine_format(source, &loaded.data).at(span)?,
-    };
-
-    // Warn the user if the image contains a foreign object. Not perfect
-    // because the svg could also be encoded, but that's an edge case.
-    if format == ImageFormat::Vector(VectorFormat::Svg) {
-        let has_foreign_object =
-            memchr::memmem::find(&loaded.data, b"<foreignObject").is_some();
-
-        if has_foreign_object {
-            engine.sink.warn(warning!(
-                span,
-                "image contains foreign object";
-                hint: "SVG images with foreign objects might render incorrectly in typst";
-                hint: "see https://github.com/typst/typst/issues/1421 for more information"
-            ));
-        }
-    }
-
-    // Construct the image itself.
-    let kind = match format {
-        ImageFormat::Raster(format) => ImageKind::Raster(
-            RasterImage::new(
-                loaded.data.clone(),
-                format,
-                elem.icc.get_ref(styles).as_ref().map(|icc| icc.derived.clone()),
-            )
-            .at(span)?,
-        ),
-        ImageFormat::Vector(VectorFormat::Svg) => ImageKind::Svg(
-            SvgImage::with_fonts(
-                loaded.data.clone(),
-                engine.world,
-                &families(styles).map(|f| f.as_str()).collect::<Vec<_>>(),
-            )
-            .within(loaded)?,
-        ),
-    };
-
-    let image = Image::new(kind, elem.alt.get_cloned(styles), elem.scaling.get(styles));
+    let image = elem.decode(engine, styles)?;
 
     // Determine the image's pixel aspect ratio.
     let pxw = image.width();
@@ -122,7 +69,7 @@ pub fn layout_image(
     // the frame to the target size, center aligning the image in the
     // process.
     let mut frame = Frame::soft(fitted);
-    frame.push(Point::zero(), FrameItem::Image(image, fitted, span));
+    frame.push(Point::zero(), FrameItem::Image(image, fitted, elem.span()));
     frame.resize(target, Axes::splat(FixedAlignment::Center));
 
     // Create a clipping group if only part of the image should be visible.
@@ -132,25 +79,3 @@ pub fn layout_image(
 
     Ok(frame)
 }
-
-/// Try to determine the image format based on the data.
-fn determine_format(source: &DataSource, data: &Bytes) -> StrResult<ImageFormat> {
-    if let DataSource::Path(path) = source {
-        let ext = std::path::Path::new(path.as_str())
-            .extension()
-            .and_then(OsStr::to_str)
-            .unwrap_or_default()
-            .to_lowercase();
-
-        match ext.as_str() {
-            "png" => return Ok(ExchangeFormat::Png.into()),
-            "jpg" | "jpeg" => return Ok(ExchangeFormat::Jpg.into()),
-            "gif" => return Ok(ExchangeFormat::Gif.into()),
-            "svg" | "svgz" => return Ok(VectorFormat::Svg.into()),
-            "webp" => return Ok(ExchangeFormat::Webp.into()),
-            _ => {}
-        }
-    }
-
-    Ok(ImageFormat::detect(data).ok_or("unknown image format")?)
-}
diff --git a/crates/typst-library/src/html/dom.rs b/crates/typst-library/src/html/dom.rs
index 47bcf9954..49ff37c45 100644
--- a/crates/typst-library/src/html/dom.rs
+++ b/crates/typst-library/src/html/dom.rs
@@ -165,6 +165,11 @@ cast! {
 pub struct HtmlAttrs(pub EcoVec<(HtmlAttr, EcoString)>);
 
 impl HtmlAttrs {
+    /// Creates an empty attribute list.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
     /// Add an attribute.
     pub fn push(&mut self, attr: HtmlAttr, value: impl Into<EcoString>) {
         self.0.push((attr, value.into()));
diff --git a/crates/typst-library/src/visualize/image/mod.rs b/crates/typst-library/src/visualize/image/mod.rs
index 95021b818..f1fa6381b 100644
--- a/crates/typst-library/src/visualize/image/mod.rs
+++ b/crates/typst-library/src/visualize/image/mod.rs
@@ -8,6 +8,7 @@ pub use self::raster::{
 };
 pub use self::svg::SvgImage;
 
+use std::ffi::OsStr;
 use std::fmt::{self, Debug, Formatter};
 use std::sync::Arc;
 
@@ -15,14 +16,16 @@ use ecow::EcoString;
 use typst_syntax::{Span, Spanned};
 use typst_utils::LazyHash;
 
-use crate::diag::StrResult;
+use crate::diag::{warning, At, LoadedWithin, SourceResult, StrResult};
+use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, func, scope, Bytes, Cast, Content, Derived, NativeElement, Packed, Smart,
+    StyleChain,
 };
 use crate::layout::{Length, Rel, Sizing};
 use crate::loading::{DataSource, Load, LoadSource, Loaded, Readable};
 use crate::model::Figurable;
-use crate::text::LocalName;
+use crate::text::{families, LocalName};
 
 /// A raster or vector graphic.
 ///
@@ -217,6 +220,81 @@ impl ImageElem {
     }
 }
 
+impl Packed<ImageElem> {
+    /// Decodes the image.
+    pub fn decode(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Image> {
+        let span = self.span();
+        let loaded = &self.source.derived;
+        let format = self.determine_format(styles).at(span)?;
+
+        // Warn the user if the image contains a foreign object. Not perfect
+        // because the svg could also be encoded, but that's an edge case.
+        if format == ImageFormat::Vector(VectorFormat::Svg) {
+            let has_foreign_object =
+                memchr::memmem::find(&loaded.data, b"<foreignObject").is_some();
+
+            if has_foreign_object {
+                engine.sink.warn(warning!(
+                span,
+                "image contains foreign object";
+                hint: "SVG images with foreign objects might render incorrectly in typst";
+                hint: "see https://github.com/typst/typst/issues/1421 for more information"
+            ));
+            }
+        }
+
+        // Construct the image itself.
+        let kind = match format {
+            ImageFormat::Raster(format) => ImageKind::Raster(
+                RasterImage::new(
+                    loaded.data.clone(),
+                    format,
+                    self.icc.get_ref(styles).as_ref().map(|icc| icc.derived.clone()),
+                )
+                .at(span)?,
+            ),
+            ImageFormat::Vector(VectorFormat::Svg) => ImageKind::Svg(
+                SvgImage::with_fonts(
+                    loaded.data.clone(),
+                    engine.world,
+                    &families(styles).map(|f| f.as_str()).collect::<Vec<_>>(),
+                )
+                .within(loaded)?,
+            ),
+        };
+
+        Ok(Image::new(kind, self.alt.get_cloned(styles), self.scaling.get(styles)))
+    }
+
+    /// Tries to determine the image format based on the format that was
+    /// explicitly defined, or else the extension, or else the data.
+    fn determine_format(&self, styles: StyleChain) -> StrResult<ImageFormat> {
+        if let Smart::Custom(v) = self.format.get(styles) {
+            return Ok(v);
+        };
+
+        let Derived { source, derived: loaded } = &self.source;
+        if let DataSource::Path(path) = source {
+            let ext = std::path::Path::new(path.as_str())
+                .extension()
+                .and_then(OsStr::to_str)
+                .unwrap_or_default()
+                .to_lowercase();
+
+            match ext.as_str() {
+                "png" => return Ok(ExchangeFormat::Png.into()),
+                "jpg" | "jpeg" => return Ok(ExchangeFormat::Jpg.into()),
+                "gif" => return Ok(ExchangeFormat::Gif.into()),
+                "svg" | "svgz" => return Ok(VectorFormat::Svg.into()),
+                "webp" => return Ok(ExchangeFormat::Webp.into()),
+                _ => {}
+            }
+        }
+
+        Ok(ImageFormat::detect(&loaded.data).ok_or("unknown image format")?)
+    }
+}
+
 impl LocalName for Packed<ImageElem> {
     const KEY: &'static str = "figure";
 }
diff --git a/crates/typst-svg/src/image.rs b/crates/typst-svg/src/image.rs
index 1868ca39b..e6dd579f3 100644
--- a/crates/typst-svg/src/image.rs
+++ b/crates/typst-svg/src/image.rs
@@ -18,21 +18,27 @@ impl SVGRenderer {
         self.xml.write_attribute("width", &size.x.to_pt());
         self.xml.write_attribute("height", &size.y.to_pt());
         self.xml.write_attribute("preserveAspectRatio", "none");
-        match image.scaling() {
-            Smart::Auto => {}
-            Smart::Custom(ImageScaling::Smooth) => {
-                // This is still experimental and not implemented in all major browsers.
-                // https://developer.mozilla.org/en-US/docs/Web/CSS/image-rendering#browser_compatibility
-                self.xml.write_attribute("style", "image-rendering: smooth")
-            }
-            Smart::Custom(ImageScaling::Pixelated) => {
-                self.xml.write_attribute("style", "image-rendering: pixelated")
-            }
+        if let Some(value) = convert_image_scaling(image.scaling()) {
+            self.xml
+                .write_attribute("style", &format_args!("image-rendering: {value}"))
         }
         self.xml.end_element();
     }
 }
 
+/// Converts an image scaling to a CSS `image-rendering` propery value.
+pub fn convert_image_scaling(scaling: Smart<ImageScaling>) -> Option<&'static str> {
+    match scaling {
+        Smart::Auto => None,
+        Smart::Custom(ImageScaling::Smooth) => {
+            // This is still experimental and not implemented in all major browsers.
+            // https://developer.mozilla.org/en-US/docs/Web/CSS/image-rendering#browser_compatibility
+            Some("smooth")
+        }
+        Smart::Custom(ImageScaling::Pixelated) => Some("pixelated"),
+    }
+}
+
 /// Encode an image into a data URL. The format of the URL is
 /// `data:image/{format};base64,`.
 #[comemo::memoize]
diff --git a/crates/typst-svg/src/lib.rs b/crates/typst-svg/src/lib.rs
index f4e81250f..3931b67f7 100644
--- a/crates/typst-svg/src/lib.rs
+++ b/crates/typst-svg/src/lib.rs
@@ -5,6 +5,8 @@ mod paint;
 mod shape;
 mod text;
 
+pub use image::{convert_image_scaling, convert_image_to_base64_url};
+
 use std::collections::HashMap;
 use std::fmt::{self, Display, Formatter, Write};
 
diff --git a/tests/ref/html/image-jpg-html-base64.html b/tests/ref/html/image-jpg-html-base64.html
new file mode 100644
index 000000000..89075323c
--- /dev/null
+++ b/tests/ref/html/image-jpg-html-base64.html
@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body><img src="data:image/jpeg;base64,/9j/4AAQSkZJRgABAgAA3ADcAAD/4QBiRXhpZgAATU0AKgAAAAgABQESAAMAAAABAAEAAAEaAAUAAAABAAAASgEbAAUAAAABAAAAUgEoAAMAAAABAAEAAAITAAMAAAABAAEAAAAAAAAAAADcAAAAAQAAANwAAAAB/8AACwgAUAAwAQERAP/bAEMACAYGBwYFCAcHBwkJCAoMFA0MCwsMGRITDxQdGh8eHRocHCAkLicgIiwjHBwoNyksMDE0NDQfJzk9ODI8LjM0Mv/EAB8AAAEFAQEBAQEBAAAAAAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFBBhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqio6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz9PX29/j5+v/aAAgBAQAAPwD5/ooooooooooooor7+ooor4Bor7+ooor4Booor7+or4Booor7+or4Bor7+ooor4Bor7+ooor4Bor7+ooor4Bor7+ooor/2Q==" alt="The letter F"></body>
+</html>
diff --git a/tests/ref/html/image-scaling-methods.html b/tests/ref/html/image-scaling-methods.html
new file mode 100644
index 000000000..a15664d51
--- /dev/null
+++ b/tests/ref/html/image-scaling-methods.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <div style="display: flex; flex-direction: row; gap: 4pt"><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAKUlEQVR4AQEeAOH/AP8AAAD/AAAA/wCAAAAAgAAAAIAAgIAAAICAgACAcFMHfiTGz0oAAAAASUVORK5CYII=" style="width: 28.346456692913385pt"><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAKUlEQVR4AQEeAOH/AP8AAAD/AAAA/wCAAAAAgAAAAIAAgIAAAICAgACAcFMHfiTGz0oAAAAASUVORK5CYII=" style="image-rendering: smooth; width: 28.346456692913385pt"><img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAADCAIAAADZSiLoAAAAKUlEQVR4AQEeAOH/AP8AAAD/AAAA/wCAAAAAgAAAAIAAgIAAAICAgACAcFMHfiTGz0oAAAAASUVORK5CYII=" style="image-rendering: pixelated; width: 28.346456692913385pt"></div>
+  </body>
+</html>
diff --git a/tests/suite/visualize/image.typ b/tests/suite/visualize/image.typ
index 45c70c4b8..36ec06cb1 100644
--- a/tests/suite/visualize/image.typ
+++ b/tests/suite/visualize/image.typ
@@ -9,6 +9,9 @@
 #set page(height: 60pt)
 #image("/assets/images/tiger.jpg")
 
+--- image-jpg-html-base64 html ---
+#image("/assets/images/f2t.jpg", alt: "The letter F")
+
 --- image-sizing ---
 // Test configuring the size and fitting behaviour of images.
 
@@ -128,7 +131,7 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
   width: 1cm,
 )
 
---- image-scaling-methods ---
+--- image-scaling-methods render html ---
 #let img(scaling) = image(
   bytes((
     0xFF, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, 0xFF,
@@ -144,14 +147,26 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
   scaling: scaling,
 )
 
-#stack(
-  dir: ltr,
-  spacing: 4pt,
+#let images = (
   img(auto),
   img("smooth"),
   img("pixelated"),
 )
 
+#context if target() == "html" {
+  // TODO: Remove this once `stack` is supported in HTML export.
+  html.div(
+    style: "display: flex; flex-direction: row; gap: 4pt",
+    images.join(),
+  )
+} else {
+  stack(
+    dir: ltr,
+    spacing: 4pt,
+    ..images,
+  )
+}
+
 --- image-natural-dpi-sizing ---
 // Test that images aren't upscaled.
 // Image is just 48x80 at 220dpi. It should not be scaled to fit the page

From ac77fdbb6ee9c4a33813a75e056cb5953d14b1db Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 9 Jul 2025 15:50:54 +0200
Subject: [PATCH 072/101] Fix tooltip for figure reference (#6580)

---
 crates/typst-ide/src/analyze.rs | 11 ++++++++---
 crates/typst-ide/src/tooltip.rs |  5 +++++
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/crates/typst-ide/src/analyze.rs b/crates/typst-ide/src/analyze.rs
index c493da81a..76739fec0 100644
--- a/crates/typst-ide/src/analyze.rs
+++ b/crates/typst-ide/src/analyze.rs
@@ -2,7 +2,7 @@ use comemo::Track;
 use ecow::{eco_vec, EcoString, EcoVec};
 use typst::foundations::{Label, Styles, Value};
 use typst::layout::PagedDocument;
-use typst::model::BibliographyElem;
+use typst::model::{BibliographyElem, FigureElem};
 use typst::syntax::{ast, LinkedNode, SyntaxKind};
 
 use crate::IdeWorld;
@@ -75,8 +75,13 @@ pub fn analyze_labels(
     for elem in document.introspector.all() {
         let Some(label) = elem.label() else { continue };
         let details = elem
-            .get_by_name("caption")
-            .or_else(|_| elem.get_by_name("body"))
+            .to_packed::<FigureElem>()
+            .and_then(|figure| match figure.caption.as_option() {
+                Some(Some(caption)) => Some(caption.pack_ref()),
+                _ => None,
+            })
+            .unwrap_or(elem)
+            .get_by_name("body")
             .ok()
             .and_then(|field| match field {
                 Value::Content(content) => Some(content),
diff --git a/crates/typst-ide/src/tooltip.rs b/crates/typst-ide/src/tooltip.rs
index 528f679cf..e0d66a89b 100644
--- a/crates/typst-ide/src/tooltip.rs
+++ b/crates/typst-ide/src/tooltip.rs
@@ -378,4 +378,9 @@ mod tests {
             .with_source("other.typ", "#let f = (x) => 1");
         test(&world, -4, Side::After).must_be_code("(..) => ..");
     }
+
+    #[test]
+    fn test_tooltip_reference() {
+        test("#figure(caption: [Hi])[]<f> @f", -1, Side::Before).must_be_text("Hi");
+    }
 }

From 98802dde7e3eab456bf4892b586076431e3bb386 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 10 Jul 2025 12:42:34 +0200
Subject: [PATCH 073/101] Complete movement of HTML export code to `typst-html`
 (#6584)

---
 crates/typst-cli/src/compile.rs               |   2 +-
 crates/typst-html/src/attr.rs                 | 195 +++++
 crates/typst-html/src/charsets.rs             |  81 ++
 crates/typst-html/src/convert.rs              | 125 +++
 crates/typst-html/src/css.rs                  |  18 -
 crates/typst-html/src/document.rs             | 219 +++++
 crates/typst-html/src/dom.rs                  | 281 ++++++
 crates/typst-html/src/encode.rs               |   5 +-
 crates/typst-html/src/fragment.rs             |  76 ++
 crates/typst-html/src/lib.rs                  | 421 ++-------
 crates/typst-html/src/rules.rs                |  12 +-
 crates/typst-html/src/tag.rs                  | 271 ++++++
 crates/typst-html/src/typed.rs                |   4 +-
 crates/typst-layout/src/flow/mod.rs           |   2 +-
 crates/typst-layout/src/pages/mod.rs          |  34 +-
 crates/typst-library/src/html/dom.rs          | 828 ------------------
 crates/typst-library/src/html/mod.rs          |  75 --
 .../src/introspection/introspector.rs         |  86 +-
 crates/typst-library/src/lib.rs               |   1 -
 crates/typst-library/src/routines.rs          |  29 +-
 crates/typst-realize/src/lib.rs               |  39 +-
 crates/typst/src/lib.rs                       |   2 +-
 tests/src/run.rs                              |   2 +-
 23 files changed, 1421 insertions(+), 1387 deletions(-)
 create mode 100644 crates/typst-html/src/attr.rs
 create mode 100644 crates/typst-html/src/charsets.rs
 create mode 100644 crates/typst-html/src/convert.rs
 create mode 100644 crates/typst-html/src/document.rs
 create mode 100644 crates/typst-html/src/dom.rs
 create mode 100644 crates/typst-html/src/fragment.rs
 create mode 100644 crates/typst-html/src/tag.rs
 delete mode 100644 crates/typst-library/src/html/dom.rs
 delete mode 100644 crates/typst-library/src/html/mod.rs

diff --git a/crates/typst-cli/src/compile.rs b/crates/typst-cli/src/compile.rs
index 207bb7d09..0db67b454 100644
--- a/crates/typst-cli/src/compile.rs
+++ b/crates/typst-cli/src/compile.rs
@@ -14,10 +14,10 @@ use typst::diag::{
     bail, At, Severity, SourceDiagnostic, SourceResult, StrResult, Warned,
 };
 use typst::foundations::{Datetime, Smart};
-use typst::html::HtmlDocument;
 use typst::layout::{Frame, Page, PageRanges, PagedDocument};
 use typst::syntax::{FileId, Lines, Span};
 use typst::WorldExt;
+use typst_html::HtmlDocument;
 use typst_pdf::{PdfOptions, PdfStandards, Timestamp};
 
 use crate::args::{
diff --git a/crates/typst-html/src/attr.rs b/crates/typst-html/src/attr.rs
new file mode 100644
index 000000000..0fec3955d
--- /dev/null
+++ b/crates/typst-html/src/attr.rs
@@ -0,0 +1,195 @@
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+#![allow(non_upper_case_globals)]
+#![allow(dead_code)]
+
+use crate::HtmlAttr;
+
+pub const abbr: HtmlAttr = HtmlAttr::constant("abbr");
+pub const accept: HtmlAttr = HtmlAttr::constant("accept");
+pub const accept_charset: HtmlAttr = HtmlAttr::constant("accept-charset");
+pub const accesskey: HtmlAttr = HtmlAttr::constant("accesskey");
+pub const action: HtmlAttr = HtmlAttr::constant("action");
+pub const allow: HtmlAttr = HtmlAttr::constant("allow");
+pub const allowfullscreen: HtmlAttr = HtmlAttr::constant("allowfullscreen");
+pub const alpha: HtmlAttr = HtmlAttr::constant("alpha");
+pub const alt: HtmlAttr = HtmlAttr::constant("alt");
+pub const aria_activedescendant: HtmlAttr = HtmlAttr::constant("aria-activedescendant");
+pub const aria_atomic: HtmlAttr = HtmlAttr::constant("aria-atomic");
+pub const aria_autocomplete: HtmlAttr = HtmlAttr::constant("aria-autocomplete");
+pub const aria_busy: HtmlAttr = HtmlAttr::constant("aria-busy");
+pub const aria_checked: HtmlAttr = HtmlAttr::constant("aria-checked");
+pub const aria_colcount: HtmlAttr = HtmlAttr::constant("aria-colcount");
+pub const aria_colindex: HtmlAttr = HtmlAttr::constant("aria-colindex");
+pub const aria_colspan: HtmlAttr = HtmlAttr::constant("aria-colspan");
+pub const aria_controls: HtmlAttr = HtmlAttr::constant("aria-controls");
+pub const aria_current: HtmlAttr = HtmlAttr::constant("aria-current");
+pub const aria_describedby: HtmlAttr = HtmlAttr::constant("aria-describedby");
+pub const aria_details: HtmlAttr = HtmlAttr::constant("aria-details");
+pub const aria_disabled: HtmlAttr = HtmlAttr::constant("aria-disabled");
+pub const aria_errormessage: HtmlAttr = HtmlAttr::constant("aria-errormessage");
+pub const aria_expanded: HtmlAttr = HtmlAttr::constant("aria-expanded");
+pub const aria_flowto: HtmlAttr = HtmlAttr::constant("aria-flowto");
+pub const aria_haspopup: HtmlAttr = HtmlAttr::constant("aria-haspopup");
+pub const aria_hidden: HtmlAttr = HtmlAttr::constant("aria-hidden");
+pub const aria_invalid: HtmlAttr = HtmlAttr::constant("aria-invalid");
+pub const aria_keyshortcuts: HtmlAttr = HtmlAttr::constant("aria-keyshortcuts");
+pub const aria_label: HtmlAttr = HtmlAttr::constant("aria-label");
+pub const aria_labelledby: HtmlAttr = HtmlAttr::constant("aria-labelledby");
+pub const aria_level: HtmlAttr = HtmlAttr::constant("aria-level");
+pub const aria_live: HtmlAttr = HtmlAttr::constant("aria-live");
+pub const aria_modal: HtmlAttr = HtmlAttr::constant("aria-modal");
+pub const aria_multiline: HtmlAttr = HtmlAttr::constant("aria-multiline");
+pub const aria_multiselectable: HtmlAttr = HtmlAttr::constant("aria-multiselectable");
+pub const aria_orientation: HtmlAttr = HtmlAttr::constant("aria-orientation");
+pub const aria_owns: HtmlAttr = HtmlAttr::constant("aria-owns");
+pub const aria_placeholder: HtmlAttr = HtmlAttr::constant("aria-placeholder");
+pub const aria_posinset: HtmlAttr = HtmlAttr::constant("aria-posinset");
+pub const aria_pressed: HtmlAttr = HtmlAttr::constant("aria-pressed");
+pub const aria_readonly: HtmlAttr = HtmlAttr::constant("aria-readonly");
+pub const aria_relevant: HtmlAttr = HtmlAttr::constant("aria-relevant");
+pub const aria_required: HtmlAttr = HtmlAttr::constant("aria-required");
+pub const aria_roledescription: HtmlAttr = HtmlAttr::constant("aria-roledescription");
+pub const aria_rowcount: HtmlAttr = HtmlAttr::constant("aria-rowcount");
+pub const aria_rowindex: HtmlAttr = HtmlAttr::constant("aria-rowindex");
+pub const aria_rowspan: HtmlAttr = HtmlAttr::constant("aria-rowspan");
+pub const aria_selected: HtmlAttr = HtmlAttr::constant("aria-selected");
+pub const aria_setsize: HtmlAttr = HtmlAttr::constant("aria-setsize");
+pub const aria_sort: HtmlAttr = HtmlAttr::constant("aria-sort");
+pub const aria_valuemax: HtmlAttr = HtmlAttr::constant("aria-valuemax");
+pub const aria_valuemin: HtmlAttr = HtmlAttr::constant("aria-valuemin");
+pub const aria_valuenow: HtmlAttr = HtmlAttr::constant("aria-valuenow");
+pub const aria_valuetext: HtmlAttr = HtmlAttr::constant("aria-valuetext");
+pub const r#as: HtmlAttr = HtmlAttr::constant("as");
+pub const r#async: HtmlAttr = HtmlAttr::constant("async");
+pub const autocapitalize: HtmlAttr = HtmlAttr::constant("autocapitalize");
+pub const autocomplete: HtmlAttr = HtmlAttr::constant("autocomplete");
+pub const autocorrect: HtmlAttr = HtmlAttr::constant("autocorrect");
+pub const autofocus: HtmlAttr = HtmlAttr::constant("autofocus");
+pub const autoplay: HtmlAttr = HtmlAttr::constant("autoplay");
+pub const blocking: HtmlAttr = HtmlAttr::constant("blocking");
+pub const charset: HtmlAttr = HtmlAttr::constant("charset");
+pub const checked: HtmlAttr = HtmlAttr::constant("checked");
+pub const cite: HtmlAttr = HtmlAttr::constant("cite");
+pub const class: HtmlAttr = HtmlAttr::constant("class");
+pub const closedby: HtmlAttr = HtmlAttr::constant("closedby");
+pub const color: HtmlAttr = HtmlAttr::constant("color");
+pub const colorspace: HtmlAttr = HtmlAttr::constant("colorspace");
+pub const cols: HtmlAttr = HtmlAttr::constant("cols");
+pub const colspan: HtmlAttr = HtmlAttr::constant("colspan");
+pub const command: HtmlAttr = HtmlAttr::constant("command");
+pub const commandfor: HtmlAttr = HtmlAttr::constant("commandfor");
+pub const content: HtmlAttr = HtmlAttr::constant("content");
+pub const contenteditable: HtmlAttr = HtmlAttr::constant("contenteditable");
+pub const controls: HtmlAttr = HtmlAttr::constant("controls");
+pub const coords: HtmlAttr = HtmlAttr::constant("coords");
+pub const crossorigin: HtmlAttr = HtmlAttr::constant("crossorigin");
+pub const data: HtmlAttr = HtmlAttr::constant("data");
+pub const datetime: HtmlAttr = HtmlAttr::constant("datetime");
+pub const decoding: HtmlAttr = HtmlAttr::constant("decoding");
+pub const default: HtmlAttr = HtmlAttr::constant("default");
+pub const defer: HtmlAttr = HtmlAttr::constant("defer");
+pub const dir: HtmlAttr = HtmlAttr::constant("dir");
+pub const dirname: HtmlAttr = HtmlAttr::constant("dirname");
+pub const disabled: HtmlAttr = HtmlAttr::constant("disabled");
+pub const download: HtmlAttr = HtmlAttr::constant("download");
+pub const draggable: HtmlAttr = HtmlAttr::constant("draggable");
+pub const enctype: HtmlAttr = HtmlAttr::constant("enctype");
+pub const enterkeyhint: HtmlAttr = HtmlAttr::constant("enterkeyhint");
+pub const fetchpriority: HtmlAttr = HtmlAttr::constant("fetchpriority");
+pub const r#for: HtmlAttr = HtmlAttr::constant("for");
+pub const form: HtmlAttr = HtmlAttr::constant("form");
+pub const formaction: HtmlAttr = HtmlAttr::constant("formaction");
+pub const formenctype: HtmlAttr = HtmlAttr::constant("formenctype");
+pub const formmethod: HtmlAttr = HtmlAttr::constant("formmethod");
+pub const formnovalidate: HtmlAttr = HtmlAttr::constant("formnovalidate");
+pub const formtarget: HtmlAttr = HtmlAttr::constant("formtarget");
+pub const headers: HtmlAttr = HtmlAttr::constant("headers");
+pub const height: HtmlAttr = HtmlAttr::constant("height");
+pub const hidden: HtmlAttr = HtmlAttr::constant("hidden");
+pub const high: HtmlAttr = HtmlAttr::constant("high");
+pub const href: HtmlAttr = HtmlAttr::constant("href");
+pub const hreflang: HtmlAttr = HtmlAttr::constant("hreflang");
+pub const http_equiv: HtmlAttr = HtmlAttr::constant("http-equiv");
+pub const id: HtmlAttr = HtmlAttr::constant("id");
+pub const imagesizes: HtmlAttr = HtmlAttr::constant("imagesizes");
+pub const imagesrcset: HtmlAttr = HtmlAttr::constant("imagesrcset");
+pub const inert: HtmlAttr = HtmlAttr::constant("inert");
+pub const inputmode: HtmlAttr = HtmlAttr::constant("inputmode");
+pub const integrity: HtmlAttr = HtmlAttr::constant("integrity");
+pub const is: HtmlAttr = HtmlAttr::constant("is");
+pub const ismap: HtmlAttr = HtmlAttr::constant("ismap");
+pub const itemid: HtmlAttr = HtmlAttr::constant("itemid");
+pub const itemprop: HtmlAttr = HtmlAttr::constant("itemprop");
+pub const itemref: HtmlAttr = HtmlAttr::constant("itemref");
+pub const itemscope: HtmlAttr = HtmlAttr::constant("itemscope");
+pub const itemtype: HtmlAttr = HtmlAttr::constant("itemtype");
+pub const kind: HtmlAttr = HtmlAttr::constant("kind");
+pub const label: HtmlAttr = HtmlAttr::constant("label");
+pub const lang: HtmlAttr = HtmlAttr::constant("lang");
+pub const list: HtmlAttr = HtmlAttr::constant("list");
+pub const loading: HtmlAttr = HtmlAttr::constant("loading");
+pub const r#loop: HtmlAttr = HtmlAttr::constant("loop");
+pub const low: HtmlAttr = HtmlAttr::constant("low");
+pub const max: HtmlAttr = HtmlAttr::constant("max");
+pub const maxlength: HtmlAttr = HtmlAttr::constant("maxlength");
+pub const media: HtmlAttr = HtmlAttr::constant("media");
+pub const method: HtmlAttr = HtmlAttr::constant("method");
+pub const min: HtmlAttr = HtmlAttr::constant("min");
+pub const minlength: HtmlAttr = HtmlAttr::constant("minlength");
+pub const multiple: HtmlAttr = HtmlAttr::constant("multiple");
+pub const muted: HtmlAttr = HtmlAttr::constant("muted");
+pub const name: HtmlAttr = HtmlAttr::constant("name");
+pub const nomodule: HtmlAttr = HtmlAttr::constant("nomodule");
+pub const nonce: HtmlAttr = HtmlAttr::constant("nonce");
+pub const novalidate: HtmlAttr = HtmlAttr::constant("novalidate");
+pub const open: HtmlAttr = HtmlAttr::constant("open");
+pub const optimum: HtmlAttr = HtmlAttr::constant("optimum");
+pub const pattern: HtmlAttr = HtmlAttr::constant("pattern");
+pub const ping: HtmlAttr = HtmlAttr::constant("ping");
+pub const placeholder: HtmlAttr = HtmlAttr::constant("placeholder");
+pub const playsinline: HtmlAttr = HtmlAttr::constant("playsinline");
+pub const popover: HtmlAttr = HtmlAttr::constant("popover");
+pub const popovertarget: HtmlAttr = HtmlAttr::constant("popovertarget");
+pub const popovertargetaction: HtmlAttr = HtmlAttr::constant("popovertargetaction");
+pub const poster: HtmlAttr = HtmlAttr::constant("poster");
+pub const preload: HtmlAttr = HtmlAttr::constant("preload");
+pub const readonly: HtmlAttr = HtmlAttr::constant("readonly");
+pub const referrerpolicy: HtmlAttr = HtmlAttr::constant("referrerpolicy");
+pub const rel: HtmlAttr = HtmlAttr::constant("rel");
+pub const required: HtmlAttr = HtmlAttr::constant("required");
+pub const reversed: HtmlAttr = HtmlAttr::constant("reversed");
+pub const role: HtmlAttr = HtmlAttr::constant("role");
+pub const rows: HtmlAttr = HtmlAttr::constant("rows");
+pub const rowspan: HtmlAttr = HtmlAttr::constant("rowspan");
+pub const sandbox: HtmlAttr = HtmlAttr::constant("sandbox");
+pub const scope: HtmlAttr = HtmlAttr::constant("scope");
+pub const selected: HtmlAttr = HtmlAttr::constant("selected");
+pub const shadowrootclonable: HtmlAttr = HtmlAttr::constant("shadowrootclonable");
+pub const shadowrootcustomelementregistry: HtmlAttr = HtmlAttr::constant("shadowrootcustomelementregistry");
+pub const shadowrootdelegatesfocus: HtmlAttr = HtmlAttr::constant("shadowrootdelegatesfocus");
+pub const shadowrootmode: HtmlAttr = HtmlAttr::constant("shadowrootmode");
+pub const shadowrootserializable: HtmlAttr = HtmlAttr::constant("shadowrootserializable");
+pub const shape: HtmlAttr = HtmlAttr::constant("shape");
+pub const size: HtmlAttr = HtmlAttr::constant("size");
+pub const sizes: HtmlAttr = HtmlAttr::constant("sizes");
+pub const slot: HtmlAttr = HtmlAttr::constant("slot");
+pub const span: HtmlAttr = HtmlAttr::constant("span");
+pub const spellcheck: HtmlAttr = HtmlAttr::constant("spellcheck");
+pub const src: HtmlAttr = HtmlAttr::constant("src");
+pub const srcdoc: HtmlAttr = HtmlAttr::constant("srcdoc");
+pub const srclang: HtmlAttr = HtmlAttr::constant("srclang");
+pub const srcset: HtmlAttr = HtmlAttr::constant("srcset");
+pub const start: HtmlAttr = HtmlAttr::constant("start");
+pub const step: HtmlAttr = HtmlAttr::constant("step");
+pub const style: HtmlAttr = HtmlAttr::constant("style");
+pub const tabindex: HtmlAttr = HtmlAttr::constant("tabindex");
+pub const target: HtmlAttr = HtmlAttr::constant("target");
+pub const title: HtmlAttr = HtmlAttr::constant("title");
+pub const translate: HtmlAttr = HtmlAttr::constant("translate");
+pub const r#type: HtmlAttr = HtmlAttr::constant("type");
+pub const usemap: HtmlAttr = HtmlAttr::constant("usemap");
+pub const value: HtmlAttr = HtmlAttr::constant("value");
+pub const width: HtmlAttr = HtmlAttr::constant("width");
+pub const wrap: HtmlAttr = HtmlAttr::constant("wrap");
+pub const writingsuggestions: HtmlAttr = HtmlAttr::constant("writingsuggestions");
diff --git a/crates/typst-html/src/charsets.rs b/crates/typst-html/src/charsets.rs
new file mode 100644
index 000000000..251ff15c9
--- /dev/null
+++ b/crates/typst-html/src/charsets.rs
@@ -0,0 +1,81 @@
+//! Defines syntactical properties of HTML tags, attributes, and text.
+
+/// Check whether a character is in a tag name.
+pub const fn is_valid_in_tag_name(c: char) -> bool {
+    c.is_ascii_alphanumeric()
+}
+
+/// Check whether a character is valid in an attribute name.
+pub const fn is_valid_in_attribute_name(c: char) -> bool {
+    match c {
+        // These are forbidden.
+        '\0' | ' ' | '"' | '\'' | '>' | '/' | '=' => false,
+        c if is_whatwg_control_char(c) => false,
+        c if is_whatwg_non_char(c) => false,
+        // _Everything_ else is allowed, including U+2029 paragraph
+        // separator. Go wild.
+        _ => true,
+    }
+}
+
+/// Check whether a character can be an used in an attribute value without
+/// escaping.
+///
+/// See <https://html.spec.whatwg.org/multipage/syntax.html#attributes-2>
+pub const fn is_valid_in_attribute_value(c: char) -> bool {
+    match c {
+        // Ampersands are sometimes legal (i.e. when they are not _ambiguous
+        // ampersands_) but it is not worth the trouble to check for that.
+        '&' => false,
+        // Quotation marks are not allowed in double-quote-delimited attribute
+        // values.
+        '"' => false,
+        // All other text characters are allowed.
+        c => is_w3c_text_char(c),
+    }
+}
+
+/// Check whether a character can be an used in normal text without
+/// escaping.
+pub const fn is_valid_in_normal_element_text(c: char) -> bool {
+    match c {
+        // Ampersands are sometimes legal (i.e. when they are not _ambiguous
+        // ampersands_) but it is not worth the trouble to check for that.
+        '&' => false,
+        // Less-than signs are not allowed in text.
+        '<' => false,
+        // All other text characters are allowed.
+        c => is_w3c_text_char(c),
+    }
+}
+
+/// Check if something is valid text in HTML.
+pub const fn is_w3c_text_char(c: char) -> bool {
+    match c {
+        // Non-characters are obviously not text characters.
+        c if is_whatwg_non_char(c) => false,
+        // Control characters are disallowed, except for whitespace.
+        c if is_whatwg_control_char(c) => c.is_ascii_whitespace(),
+        // Everything else is allowed.
+        _ => true,
+    }
+}
+
+const fn is_whatwg_non_char(c: char) -> bool {
+    match c {
+        '\u{fdd0}'..='\u{fdef}' => true,
+        // Non-characters matching xxFFFE or xxFFFF up to x10FFFF (inclusive).
+        c if c as u32 & 0xfffe == 0xfffe && c as u32 <= 0x10ffff => true,
+        _ => false,
+    }
+}
+
+const fn is_whatwg_control_char(c: char) -> bool {
+    match c {
+        // C0 control characters.
+        '\u{00}'..='\u{1f}' => true,
+        // Other control characters.
+        '\u{7f}'..='\u{9f}' => true,
+        _ => false,
+    }
+}
diff --git a/crates/typst-html/src/convert.rs b/crates/typst-html/src/convert.rs
new file mode 100644
index 000000000..49995e0aa
--- /dev/null
+++ b/crates/typst-html/src/convert.rs
@@ -0,0 +1,125 @@
+use typst_library::diag::{warning, SourceResult};
+use typst_library::engine::Engine;
+use typst_library::foundations::{Content, StyleChain, Target, TargetElem};
+use typst_library::introspection::{SplitLocator, TagElem};
+use typst_library::layout::{Abs, Axes, BlockBody, BlockElem, BoxElem, Region, Size};
+use typst_library::model::ParElem;
+use typst_library::routines::Pair;
+use typst_library::text::{LinebreakElem, SmartQuoteElem, SpaceElem, TextElem};
+
+use crate::fragment::html_fragment;
+use crate::{attr, tag, FrameElem, HtmlElem, HtmlElement, HtmlFrame, HtmlNode};
+
+/// Converts realized content into HTML nodes.
+pub fn convert_to_nodes<'a>(
+    engine: &mut Engine,
+    locator: &mut SplitLocator,
+    children: impl IntoIterator<Item = Pair<'a>>,
+) -> SourceResult<Vec<HtmlNode>> {
+    let mut output = Vec::new();
+    for (child, styles) in children {
+        handle(engine, child, locator, styles, &mut output)?;
+    }
+    Ok(output)
+}
+
+/// Convert one element into HTML node(s).
+fn handle(
+    engine: &mut Engine,
+    child: &Content,
+    locator: &mut SplitLocator,
+    styles: StyleChain,
+    output: &mut Vec<HtmlNode>,
+) -> SourceResult<()> {
+    if let Some(elem) = child.to_packed::<TagElem>() {
+        output.push(HtmlNode::Tag(elem.tag.clone()));
+    } else if let Some(elem) = child.to_packed::<HtmlElem>() {
+        let mut children = vec![];
+        if let Some(body) = elem.body.get_ref(styles) {
+            children = html_fragment(engine, body, locator.next(&elem.span()), styles)?;
+        }
+        let element = HtmlElement {
+            tag: elem.tag,
+            attrs: elem.attrs.get_cloned(styles),
+            children,
+            span: elem.span(),
+        };
+        output.push(element.into());
+    } else if let Some(elem) = child.to_packed::<ParElem>() {
+        let children =
+            html_fragment(engine, &elem.body, locator.next(&elem.span()), styles)?;
+        output.push(
+            HtmlElement::new(tag::p)
+                .with_children(children)
+                .spanned(elem.span())
+                .into(),
+        );
+    } else if let Some(elem) = child.to_packed::<BoxElem>() {
+        // TODO: This is rather incomplete.
+        if let Some(body) = elem.body.get_ref(styles) {
+            let children =
+                html_fragment(engine, body, locator.next(&elem.span()), styles)?;
+            output.push(
+                HtmlElement::new(tag::span)
+                    .with_attr(attr::style, "display: inline-block;")
+                    .with_children(children)
+                    .spanned(elem.span())
+                    .into(),
+            )
+        }
+    } else if let Some((elem, body)) =
+        child
+            .to_packed::<BlockElem>()
+            .and_then(|elem| match elem.body.get_ref(styles) {
+                Some(BlockBody::Content(body)) => Some((elem, body)),
+                _ => None,
+            })
+    {
+        // TODO: This is rather incomplete.
+        let children = html_fragment(engine, body, locator.next(&elem.span()), styles)?;
+        output.push(
+            HtmlElement::new(tag::div)
+                .with_children(children)
+                .spanned(elem.span())
+                .into(),
+        );
+    } else if child.is::<SpaceElem>() {
+        output.push(HtmlNode::text(' ', child.span()));
+    } else if let Some(elem) = child.to_packed::<TextElem>() {
+        output.push(HtmlNode::text(elem.text.clone(), elem.span()));
+    } else if let Some(elem) = child.to_packed::<LinebreakElem>() {
+        output.push(HtmlElement::new(tag::br).spanned(elem.span()).into());
+    } else if let Some(elem) = child.to_packed::<SmartQuoteElem>() {
+        output.push(HtmlNode::text(
+            if elem.double.get(styles) { '"' } else { '\'' },
+            child.span(),
+        ));
+    } else if let Some(elem) = child.to_packed::<FrameElem>() {
+        let locator = locator.next(&elem.span());
+        let style = TargetElem::target.set(Target::Paged).wrap();
+        let frame = (engine.routines.layout_frame)(
+            engine,
+            &elem.body,
+            locator,
+            styles.chain(&style),
+            Region::new(Size::splat(Abs::inf()), Axes::splat(false)),
+        )?;
+        output.push(HtmlNode::Frame(HtmlFrame {
+            inner: frame,
+            text_size: styles.resolve(TextElem::size),
+        }));
+    } else {
+        engine.sink.warn(warning!(
+            child.span(),
+            "{} was ignored during HTML export",
+            child.elem().name()
+        ));
+    }
+    Ok(())
+}
+
+/// Checks whether the given element is an inline-level HTML element.
+pub fn is_inline(elem: &Content) -> bool {
+    elem.to_packed::<HtmlElem>()
+        .is_some_and(|elem| tag::is_inline_by_default(elem.tag))
+}
diff --git a/crates/typst-html/src/css.rs b/crates/typst-html/src/css.rs
index 6c84cba0f..5916d3147 100644
--- a/crates/typst-html/src/css.rs
+++ b/crates/typst-html/src/css.rs
@@ -3,28 +3,10 @@
 use std::fmt::{self, Display, Write};
 
 use ecow::EcoString;
-use typst_library::html::{attr, HtmlElem};
 use typst_library::layout::{Length, Rel};
 use typst_library::visualize::{Color, Hsl, LinearRgb, Oklab, Oklch, Rgb};
 use typst_utils::Numeric;
 
-/// Additional methods for [`HtmlElem`].
-pub trait HtmlElemExt {
-    /// Adds the styles to an element if the property list is non-empty.
-    fn with_styles(self, properties: Properties) -> Self;
-}
-
-impl HtmlElemExt for HtmlElem {
-    /// Adds CSS styles to an element.
-    fn with_styles(self, properties: Properties) -> Self {
-        if let Some(value) = properties.into_inline_styles() {
-            self.with_attr(attr::style, value)
-        } else {
-            self
-        }
-    }
-}
-
 /// A list of CSS properties with values.
 #[derive(Debug, Default)]
 pub struct Properties(EcoString);
diff --git a/crates/typst-html/src/document.rs b/crates/typst-html/src/document.rs
new file mode 100644
index 000000000..9f0124e57
--- /dev/null
+++ b/crates/typst-html/src/document.rs
@@ -0,0 +1,219 @@
+use std::num::NonZeroUsize;
+
+use comemo::{Tracked, TrackedMut};
+use typst_library::diag::{bail, SourceResult};
+use typst_library::engine::{Engine, Route, Sink, Traced};
+use typst_library::foundations::{Content, StyleChain};
+use typst_library::introspection::{Introspector, IntrospectorBuilder, Locator};
+use typst_library::layout::{Point, Position, Transform};
+use typst_library::model::DocumentInfo;
+use typst_library::routines::{Arenas, RealizationKind, Routines};
+use typst_library::World;
+use typst_syntax::Span;
+use typst_utils::NonZeroExt;
+
+use crate::{attr, tag, HtmlDocument, HtmlElement, HtmlNode};
+
+/// Produce an HTML document from content.
+///
+/// This first performs root-level realization and then turns the resulting
+/// elements into HTML.
+#[typst_macros::time(name = "html document")]
+pub fn html_document(
+    engine: &mut Engine,
+    content: &Content,
+    styles: StyleChain,
+) -> SourceResult<HtmlDocument> {
+    html_document_impl(
+        engine.routines,
+        engine.world,
+        engine.introspector,
+        engine.traced,
+        TrackedMut::reborrow_mut(&mut engine.sink),
+        engine.route.track(),
+        content,
+        styles,
+    )
+}
+
+/// The internal implementation of `html_document`.
+#[comemo::memoize]
+#[allow(clippy::too_many_arguments)]
+fn html_document_impl(
+    routines: &Routines,
+    world: Tracked<dyn World + '_>,
+    introspector: Tracked<Introspector>,
+    traced: Tracked<Traced>,
+    sink: TrackedMut<Sink>,
+    route: Tracked<Route>,
+    content: &Content,
+    styles: StyleChain,
+) -> SourceResult<HtmlDocument> {
+    let mut locator = Locator::root().split();
+    let mut engine = Engine {
+        routines,
+        world,
+        introspector,
+        traced,
+        sink,
+        route: Route::extend(route).unnested(),
+    };
+
+    // Mark the external styles as "outside" so that they are valid at the page
+    // level.
+    let styles = styles.to_map().outside();
+    let styles = StyleChain::new(&styles);
+
+    let arenas = Arenas::default();
+    let mut info = DocumentInfo::default();
+    let children = (engine.routines.realize)(
+        RealizationKind::HtmlDocument {
+            info: &mut info,
+            is_inline: crate::convert::is_inline,
+        },
+        &mut engine,
+        &mut locator,
+        &arenas,
+        content,
+        styles,
+    )?;
+
+    let output = crate::convert::convert_to_nodes(
+        &mut engine,
+        &mut locator,
+        children.iter().copied(),
+    )?;
+    let introspector = introspect_html(&output);
+    let root = root_element(output, &info)?;
+
+    Ok(HtmlDocument { info, root, introspector })
+}
+
+/// Introspects HTML nodes.
+#[typst_macros::time(name = "introspect html")]
+fn introspect_html(output: &[HtmlNode]) -> Introspector {
+    fn discover(
+        builder: &mut IntrospectorBuilder,
+        sink: &mut Vec<(Content, Position)>,
+        nodes: &[HtmlNode],
+    ) {
+        for node in nodes {
+            match node {
+                HtmlNode::Tag(tag) => builder.discover_in_tag(
+                    sink,
+                    tag,
+                    Position { page: NonZeroUsize::ONE, point: Point::zero() },
+                ),
+                HtmlNode::Text(_, _) => {}
+                HtmlNode::Element(elem) => discover(builder, sink, &elem.children),
+                HtmlNode::Frame(frame) => builder.discover_in_frame(
+                    sink,
+                    &frame.inner,
+                    NonZeroUsize::ONE,
+                    Transform::identity(),
+                ),
+            }
+        }
+    }
+
+    let mut elems = Vec::new();
+    let mut builder = IntrospectorBuilder::new();
+    discover(&mut builder, &mut elems, output);
+    builder.finalize(elems)
+}
+
+/// Wrap the nodes in `<html>` and `<body>` if they are not yet rooted,
+/// supplying a suitable `<head>`.
+fn root_element(output: Vec<HtmlNode>, info: &DocumentInfo) -> SourceResult<HtmlElement> {
+    let head = head_element(info);
+    let body = match classify_output(output)? {
+        OutputKind::Html(element) => return Ok(element),
+        OutputKind::Body(body) => body,
+        OutputKind::Leafs(leafs) => HtmlElement::new(tag::body).with_children(leafs),
+    };
+    Ok(HtmlElement::new(tag::html).with_children(vec![head.into(), body.into()]))
+}
+
+/// Generate a `<head>` element.
+fn head_element(info: &DocumentInfo) -> HtmlElement {
+    let mut children = vec![];
+
+    children.push(HtmlElement::new(tag::meta).with_attr(attr::charset, "utf-8").into());
+
+    children.push(
+        HtmlElement::new(tag::meta)
+            .with_attr(attr::name, "viewport")
+            .with_attr(attr::content, "width=device-width, initial-scale=1")
+            .into(),
+    );
+
+    if let Some(title) = &info.title {
+        children.push(
+            HtmlElement::new(tag::title)
+                .with_children(vec![HtmlNode::Text(title.clone(), Span::detached())])
+                .into(),
+        );
+    }
+
+    if let Some(description) = &info.description {
+        children.push(
+            HtmlElement::new(tag::meta)
+                .with_attr(attr::name, "description")
+                .with_attr(attr::content, description.clone())
+                .into(),
+        );
+    }
+
+    if !info.author.is_empty() {
+        children.push(
+            HtmlElement::new(tag::meta)
+                .with_attr(attr::name, "authors")
+                .with_attr(attr::content, info.author.join(", "))
+                .into(),
+        )
+    }
+
+    if !info.keywords.is_empty() {
+        children.push(
+            HtmlElement::new(tag::meta)
+                .with_attr(attr::name, "keywords")
+                .with_attr(attr::content, info.keywords.join(", "))
+                .into(),
+        )
+    }
+
+    HtmlElement::new(tag::head).with_children(children)
+}
+
+/// Determine which kind of output the user generated.
+fn classify_output(mut output: Vec<HtmlNode>) -> SourceResult<OutputKind> {
+    let count = output.iter().filter(|node| !matches!(node, HtmlNode::Tag(_))).count();
+    for node in &mut output {
+        let HtmlNode::Element(elem) = node else { continue };
+        let tag = elem.tag;
+        let mut take = || std::mem::replace(elem, HtmlElement::new(tag::html));
+        match (tag, count) {
+            (tag::html, 1) => return Ok(OutputKind::Html(take())),
+            (tag::body, 1) => return Ok(OutputKind::Body(take())),
+            (tag::html | tag::body, _) => bail!(
+                elem.span,
+                "`{}` element must be the only element in the document",
+                elem.tag,
+            ),
+            _ => {}
+        }
+    }
+    Ok(OutputKind::Leafs(output))
+}
+
+/// What kinds of output the user generated.
+enum OutputKind {
+    /// The user generated their own `<html>` element. We do not need to supply
+    /// one.
+    Html(HtmlElement),
+    /// The user generate their own `<body>` element. We do not need to supply
+    /// one, but need supply the `<html>` element.
+    Body(HtmlElement),
+    /// The user generated leafs which we wrap in a `<body>` and `<html>`.
+    Leafs(Vec<HtmlNode>),
+}
diff --git a/crates/typst-html/src/dom.rs b/crates/typst-html/src/dom.rs
new file mode 100644
index 000000000..cf74e1bfc
--- /dev/null
+++ b/crates/typst-html/src/dom.rs
@@ -0,0 +1,281 @@
+use std::fmt::{self, Debug, Display, Formatter};
+
+use ecow::{EcoString, EcoVec};
+use typst_library::diag::{bail, HintedStrResult, StrResult};
+use typst_library::foundations::{cast, Dict, Repr, Str};
+use typst_library::introspection::{Introspector, Tag};
+use typst_library::layout::{Abs, Frame};
+use typst_library::model::DocumentInfo;
+use typst_syntax::Span;
+use typst_utils::{PicoStr, ResolvedPicoStr};
+
+use crate::charsets;
+
+/// An HTML document.
+#[derive(Debug, Clone)]
+pub struct HtmlDocument {
+    /// The document's root HTML element.
+    pub root: HtmlElement,
+    /// Details about the document.
+    pub info: DocumentInfo,
+    /// Provides the ability to execute queries on the document.
+    pub introspector: Introspector,
+}
+
+/// A child of an HTML element.
+#[derive(Debug, Clone, Hash)]
+pub enum HtmlNode {
+    /// An introspectable element that produced something within this node.
+    Tag(Tag),
+    /// Plain text.
+    Text(EcoString, Span),
+    /// Another element.
+    Element(HtmlElement),
+    /// Layouted content that will be embedded into HTML as an SVG.
+    Frame(HtmlFrame),
+}
+
+impl HtmlNode {
+    /// Create a plain text node.
+    pub fn text(text: impl Into<EcoString>, span: Span) -> Self {
+        Self::Text(text.into(), span)
+    }
+}
+
+impl From<HtmlElement> for HtmlNode {
+    fn from(element: HtmlElement) -> Self {
+        Self::Element(element)
+    }
+}
+
+/// An HTML element.
+#[derive(Debug, Clone, Hash)]
+pub struct HtmlElement {
+    /// The HTML tag.
+    pub tag: HtmlTag,
+    /// The element's attributes.
+    pub attrs: HtmlAttrs,
+    /// The element's children.
+    pub children: Vec<HtmlNode>,
+    /// The span from which the element originated, if any.
+    pub span: Span,
+}
+
+impl HtmlElement {
+    /// Create a new, blank element without attributes or children.
+    pub fn new(tag: HtmlTag) -> Self {
+        Self {
+            tag,
+            attrs: HtmlAttrs::default(),
+            children: vec![],
+            span: Span::detached(),
+        }
+    }
+
+    /// Attach children to the element.
+    ///
+    /// Note: This overwrites potential previous children.
+    pub fn with_children(mut self, children: Vec<HtmlNode>) -> Self {
+        self.children = children;
+        self
+    }
+
+    /// Add an atribute to the element.
+    pub fn with_attr(mut self, key: HtmlAttr, value: impl Into<EcoString>) -> Self {
+        self.attrs.push(key, value);
+        self
+    }
+
+    /// Attach a span to the element.
+    pub fn spanned(mut self, span: Span) -> Self {
+        self.span = span;
+        self
+    }
+}
+
+/// The tag of an HTML element.
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+pub struct HtmlTag(PicoStr);
+
+impl HtmlTag {
+    /// Intern an HTML tag string at runtime.
+    pub fn intern(string: &str) -> StrResult<Self> {
+        if string.is_empty() {
+            bail!("tag name must not be empty");
+        }
+
+        if let Some(c) = string.chars().find(|&c| !charsets::is_valid_in_tag_name(c)) {
+            bail!("the character {} is not valid in a tag name", c.repr());
+        }
+
+        Ok(Self(PicoStr::intern(string)))
+    }
+
+    /// Creates a compile-time constant `HtmlTag`.
+    ///
+    /// Should only be used in const contexts because it can panic.
+    #[track_caller]
+    pub const fn constant(string: &'static str) -> Self {
+        if string.is_empty() {
+            panic!("tag name must not be empty");
+        }
+
+        let bytes = string.as_bytes();
+        let mut i = 0;
+        while i < bytes.len() {
+            if !bytes[i].is_ascii() || !charsets::is_valid_in_tag_name(bytes[i] as char) {
+                panic!("not all characters are valid in a tag name");
+            }
+            i += 1;
+        }
+
+        Self(PicoStr::constant(string))
+    }
+
+    /// Resolves the tag to a string.
+    pub fn resolve(self) -> ResolvedPicoStr {
+        self.0.resolve()
+    }
+
+    /// Turns the tag into its inner interned string.
+    pub const fn into_inner(self) -> PicoStr {
+        self.0
+    }
+}
+
+impl Debug for HtmlTag {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(self, f)
+    }
+}
+
+impl Display for HtmlTag {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "<{}>", self.resolve())
+    }
+}
+
+cast! {
+    HtmlTag,
+    self => self.0.resolve().as_str().into_value(),
+    v: Str => Self::intern(&v)?,
+}
+
+/// Attributes of an HTML element.
+#[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
+pub struct HtmlAttrs(pub EcoVec<(HtmlAttr, EcoString)>);
+
+impl HtmlAttrs {
+    /// Creates an empty attribute list.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Add an attribute.
+    pub fn push(&mut self, attr: HtmlAttr, value: impl Into<EcoString>) {
+        self.0.push((attr, value.into()));
+    }
+}
+
+cast! {
+    HtmlAttrs,
+    self => self.0
+        .into_iter()
+        .map(|(key, value)| (key.resolve().as_str().into(), value.into_value()))
+        .collect::<Dict>()
+        .into_value(),
+    values: Dict => Self(values
+        .into_iter()
+        .map(|(k, v)| {
+            let attr = HtmlAttr::intern(&k)?;
+            let value = v.cast::<EcoString>()?;
+            Ok((attr, value))
+        })
+        .collect::<HintedStrResult<_>>()?),
+}
+
+/// An attribute of an HTML element.
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
+pub struct HtmlAttr(PicoStr);
+
+impl HtmlAttr {
+    /// Intern an HTML attribute string at runtime.
+    pub fn intern(string: &str) -> StrResult<Self> {
+        if string.is_empty() {
+            bail!("attribute name must not be empty");
+        }
+
+        if let Some(c) =
+            string.chars().find(|&c| !charsets::is_valid_in_attribute_name(c))
+        {
+            bail!("the character {} is not valid in an attribute name", c.repr());
+        }
+
+        Ok(Self(PicoStr::intern(string)))
+    }
+
+    /// Creates a compile-time constant `HtmlAttr`.
+    ///
+    /// Must only be used in const contexts (in a constant definition or
+    /// explicit `const { .. }` block) because otherwise a panic for a malformed
+    /// attribute or not auto-internible constant will only be caught at
+    /// runtime.
+    #[track_caller]
+    pub const fn constant(string: &'static str) -> Self {
+        if string.is_empty() {
+            panic!("attribute name must not be empty");
+        }
+
+        let bytes = string.as_bytes();
+        let mut i = 0;
+        while i < bytes.len() {
+            if !bytes[i].is_ascii()
+                || !charsets::is_valid_in_attribute_name(bytes[i] as char)
+            {
+                panic!("not all characters are valid in an attribute name");
+            }
+            i += 1;
+        }
+
+        Self(PicoStr::constant(string))
+    }
+
+    /// Resolves the attribute to a string.
+    pub fn resolve(self) -> ResolvedPicoStr {
+        self.0.resolve()
+    }
+
+    /// Turns the attribute into its inner interned string.
+    pub const fn into_inner(self) -> PicoStr {
+        self.0
+    }
+}
+
+impl Debug for HtmlAttr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        Display::fmt(self, f)
+    }
+}
+
+impl Display for HtmlAttr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.resolve())
+    }
+}
+
+cast! {
+    HtmlAttr,
+    self => self.0.resolve().as_str().into_value(),
+    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,
+}
diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 84860dbe9..be8137399 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -2,10 +2,11 @@ use std::fmt::Write;
 
 use typst_library::diag::{bail, At, SourceResult, StrResult};
 use typst_library::foundations::Repr;
-use typst_library::html::{
+use typst_syntax::Span;
+
+use crate::{
     attr, charsets, tag, HtmlDocument, HtmlElement, HtmlFrame, HtmlNode, HtmlTag,
 };
-use typst_syntax::Span;
 
 /// Encodes an HTML document into a string.
 pub fn html(document: &HtmlDocument) -> SourceResult<String> {
diff --git a/crates/typst-html/src/fragment.rs b/crates/typst-html/src/fragment.rs
new file mode 100644
index 000000000..78ae7dee0
--- /dev/null
+++ b/crates/typst-html/src/fragment.rs
@@ -0,0 +1,76 @@
+use comemo::{Track, Tracked, TrackedMut};
+use typst_library::diag::{At, SourceResult};
+use typst_library::engine::{Engine, Route, Sink, Traced};
+use typst_library::foundations::{Content, StyleChain};
+use typst_library::introspection::{Introspector, Locator, LocatorLink};
+
+use typst_library::routines::{Arenas, FragmentKind, RealizationKind, Routines};
+use typst_library::World;
+
+use crate::HtmlNode;
+
+/// Produce HTML nodes from content.
+#[typst_macros::time(name = "html fragment")]
+pub fn html_fragment(
+    engine: &mut Engine,
+    content: &Content,
+    locator: Locator,
+    styles: StyleChain,
+) -> SourceResult<Vec<HtmlNode>> {
+    html_fragment_impl(
+        engine.routines,
+        engine.world,
+        engine.introspector,
+        engine.traced,
+        TrackedMut::reborrow_mut(&mut engine.sink),
+        engine.route.track(),
+        content,
+        locator.track(),
+        styles,
+    )
+}
+
+/// The cached, internal implementation of [`html_fragment`].
+#[comemo::memoize]
+#[allow(clippy::too_many_arguments)]
+fn html_fragment_impl(
+    routines: &Routines,
+    world: Tracked<dyn World + '_>,
+    introspector: Tracked<Introspector>,
+    traced: Tracked<Traced>,
+    sink: TrackedMut<Sink>,
+    route: Tracked<Route>,
+    content: &Content,
+    locator: Tracked<Locator>,
+    styles: StyleChain,
+) -> SourceResult<Vec<HtmlNode>> {
+    let link = LocatorLink::new(locator);
+    let mut locator = Locator::link(&link).split();
+    let mut engine = Engine {
+        routines,
+        world,
+        introspector,
+        traced,
+        sink,
+        route: Route::extend(route),
+    };
+
+    engine.route.check_html_depth().at(content.span())?;
+
+    let arenas = Arenas::default();
+    let children = (engine.routines.realize)(
+        // No need to know about the `FragmentKind` because we handle both
+        // uniformly.
+        RealizationKind::HtmlFragment {
+            kind: &mut FragmentKind::Block,
+            is_inline: crate::convert::is_inline,
+        },
+        &mut engine,
+        &mut locator,
+        &arenas,
+        content,
+        styles,
+    )?;
+
+    crate::convert::convert_to_nodes(&mut engine, &mut locator, children.iter().copied())
+}
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index 7063931b7..d7b29dbbc 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -1,33 +1,28 @@
 //! Typst's HTML exporter.
 
+mod attr;
+mod charsets;
+mod convert;
 mod css;
+mod document;
+mod dom;
 mod encode;
+mod fragment;
 mod rules;
+mod tag;
 mod typed;
 
+pub use self::document::html_document;
+pub use self::dom::*;
 pub use self::encode::html;
 pub use self::rules::register;
 
-use comemo::{Track, Tracked, TrackedMut};
-use typst_library::diag::{bail, warning, At, SourceResult};
-use typst_library::engine::{Engine, Route, Sink, Traced};
-use typst_library::foundations::{
-    Content, Module, Scope, StyleChain, Target, TargetElem,
-};
-use typst_library::html::{
-    attr, tag, FrameElem, HtmlDocument, HtmlElem, HtmlElement, HtmlFrame, HtmlNode,
-};
-use typst_library::introspection::{
-    Introspector, Locator, LocatorLink, SplitLocator, TagElem,
-};
-use typst_library::layout::{Abs, Axes, BlockBody, BlockElem, BoxElem, Region, Size};
-use typst_library::model::{DocumentInfo, ParElem};
-use typst_library::routines::{Arenas, FragmentKind, Pair, RealizationKind, Routines};
-use typst_library::text::{LinebreakElem, SmartQuoteElem, SpaceElem, TextElem};
-use typst_library::{Category, World};
-use typst_syntax::Span;
+use ecow::EcoString;
+use typst_library::foundations::{Content, Module, Scope};
+use typst_library::Category;
+use typst_macros::elem;
 
-/// Create a module with all HTML definitions.
+/// Creates the module with all HTML definitions.
 pub fn module() -> Module {
     let mut html = Scope::deduplicating();
     html.start_category(Category::Html);
@@ -37,337 +32,77 @@ pub fn module() -> Module {
     Module::new("html", html)
 }
 
-/// Produce an HTML document from content.
+/// An HTML element that can contain Typst content.
 ///
-/// This first performs root-level realization and then turns the resulting
-/// elements into HTML.
-#[typst_macros::time(name = "html document")]
-pub fn html_document(
-    engine: &mut Engine,
-    content: &Content,
-    styles: StyleChain,
-) -> SourceResult<HtmlDocument> {
-    html_document_impl(
-        engine.routines,
-        engine.world,
-        engine.introspector,
-        engine.traced,
-        TrackedMut::reborrow_mut(&mut engine.sink),
-        engine.route.track(),
-        content,
-        styles,
-    )
+/// Typst's HTML export automatically generates the appropriate tags for most
+/// elements. However, sometimes, it is desirable to retain more control. For
+/// example, when using Typst to generate your blog, you could use this function
+/// to wrap each article in an `<article>` tag.
+///
+/// Typst is aware of what is valid HTML. A tag and its attributes must form
+/// syntactically valid HTML. Some tags, like `meta` do not accept content.
+/// Hence, you must not provide a body for them. We may add more checks in the
+/// future, so be sure that you are generating valid HTML when using this
+/// function.
+///
+/// Normally, Typst will generate `html`, `head`, and `body` tags for you. If
+/// you instead create them with this function, Typst will omit its own tags.
+///
+/// ```typ
+/// #html.elem("div", attrs: (style: "background: aqua"))[
+///   A div with _Typst content_ inside!
+/// ]
+/// ```
+#[elem(name = "elem")]
+pub struct HtmlElem {
+    /// The element's tag.
+    #[required]
+    pub tag: HtmlTag,
+
+    /// The element's HTML attributes.
+    pub attrs: HtmlAttrs,
+
+    /// The contents of the HTML element.
+    ///
+    /// The body can be arbitrary Typst content.
+    #[positional]
+    pub body: Option<Content>,
 }
 
-/// The internal implementation of `html_document`.
-#[comemo::memoize]
-#[allow(clippy::too_many_arguments)]
-fn html_document_impl(
-    routines: &Routines,
-    world: Tracked<dyn World + '_>,
-    introspector: Tracked<Introspector>,
-    traced: Tracked<Traced>,
-    sink: TrackedMut<Sink>,
-    route: Tracked<Route>,
-    content: &Content,
-    styles: StyleChain,
-) -> SourceResult<HtmlDocument> {
-    let mut locator = Locator::root().split();
-    let mut engine = Engine {
-        routines,
-        world,
-        introspector,
-        traced,
-        sink,
-        route: Route::extend(route).unnested(),
-    };
-
-    // Mark the external styles as "outside" so that they are valid at the page
-    // level.
-    let styles = styles.to_map().outside();
-    let styles = StyleChain::new(&styles);
-
-    let arenas = Arenas::default();
-    let mut info = DocumentInfo::default();
-    let children = (engine.routines.realize)(
-        RealizationKind::HtmlDocument(&mut info),
-        &mut engine,
-        &mut locator,
-        &arenas,
-        content,
-        styles,
-    )?;
-
-    let output = handle_list(&mut engine, &mut locator, children.iter().copied())?;
-    let introspector = Introspector::html(&output);
-    let root = root_element(output, &info)?;
-
-    Ok(HtmlDocument { info, root, introspector })
-}
-
-/// Produce HTML nodes from content.
-#[typst_macros::time(name = "html fragment")]
-pub fn html_fragment(
-    engine: &mut Engine,
-    content: &Content,
-    locator: Locator,
-    styles: StyleChain,
-) -> SourceResult<Vec<HtmlNode>> {
-    html_fragment_impl(
-        engine.routines,
-        engine.world,
-        engine.introspector,
-        engine.traced,
-        TrackedMut::reborrow_mut(&mut engine.sink),
-        engine.route.track(),
-        content,
-        locator.track(),
-        styles,
-    )
-}
-
-/// The cached, internal implementation of [`html_fragment`].
-#[comemo::memoize]
-#[allow(clippy::too_many_arguments)]
-fn html_fragment_impl(
-    routines: &Routines,
-    world: Tracked<dyn World + '_>,
-    introspector: Tracked<Introspector>,
-    traced: Tracked<Traced>,
-    sink: TrackedMut<Sink>,
-    route: Tracked<Route>,
-    content: &Content,
-    locator: Tracked<Locator>,
-    styles: StyleChain,
-) -> SourceResult<Vec<HtmlNode>> {
-    let link = LocatorLink::new(locator);
-    let mut locator = Locator::link(&link).split();
-    let mut engine = Engine {
-        routines,
-        world,
-        introspector,
-        traced,
-        sink,
-        route: Route::extend(route),
-    };
-
-    engine.route.check_html_depth().at(content.span())?;
-
-    let arenas = Arenas::default();
-    let children = (engine.routines.realize)(
-        // No need to know about the `FragmentKind` because we handle both
-        // uniformly.
-        RealizationKind::HtmlFragment(&mut FragmentKind::Block),
-        &mut engine,
-        &mut locator,
-        &arenas,
-        content,
-        styles,
-    )?;
-
-    handle_list(&mut engine, &mut locator, children.iter().copied())
-}
-
-/// Convert children into HTML nodes.
-fn handle_list<'a>(
-    engine: &mut Engine,
-    locator: &mut SplitLocator,
-    children: impl IntoIterator<Item = Pair<'a>>,
-) -> SourceResult<Vec<HtmlNode>> {
-    let mut output = Vec::new();
-    for (child, styles) in children {
-        handle(engine, child, locator, styles, &mut output)?;
-    }
-    Ok(output)
-}
-
-/// Convert a child into HTML node(s).
-fn handle(
-    engine: &mut Engine,
-    child: &Content,
-    locator: &mut SplitLocator,
-    styles: StyleChain,
-    output: &mut Vec<HtmlNode>,
-) -> SourceResult<()> {
-    if let Some(elem) = child.to_packed::<TagElem>() {
-        output.push(HtmlNode::Tag(elem.tag.clone()));
-    } else if let Some(elem) = child.to_packed::<HtmlElem>() {
-        let mut children = vec![];
-        if let Some(body) = elem.body.get_ref(styles) {
-            children = html_fragment(engine, body, locator.next(&elem.span()), styles)?;
-        }
-        let element = HtmlElement {
-            tag: elem.tag,
-            attrs: elem.attrs.get_cloned(styles),
-            children,
-            span: elem.span(),
-        };
-        output.push(element.into());
-    } else if let Some(elem) = child.to_packed::<ParElem>() {
-        let children =
-            html_fragment(engine, &elem.body, locator.next(&elem.span()), styles)?;
-        output.push(
-            HtmlElement::new(tag::p)
-                .with_children(children)
-                .spanned(elem.span())
-                .into(),
-        );
-    } else if let Some(elem) = child.to_packed::<BoxElem>() {
-        // TODO: This is rather incomplete.
-        if let Some(body) = elem.body.get_ref(styles) {
-            let children =
-                html_fragment(engine, body, locator.next(&elem.span()), styles)?;
-            output.push(
-                HtmlElement::new(tag::span)
-                    .with_attr(attr::style, "display: inline-block;")
-                    .with_children(children)
-                    .spanned(elem.span())
-                    .into(),
-            )
-        }
-    } else if let Some((elem, body)) =
-        child
-            .to_packed::<BlockElem>()
-            .and_then(|elem| match elem.body.get_ref(styles) {
-                Some(BlockBody::Content(body)) => Some((elem, body)),
-                _ => None,
-            })
-    {
-        // TODO: This is rather incomplete.
-        let children = html_fragment(engine, body, locator.next(&elem.span()), styles)?;
-        output.push(
-            HtmlElement::new(tag::div)
-                .with_children(children)
-                .spanned(elem.span())
-                .into(),
-        );
-    } else if child.is::<SpaceElem>() {
-        output.push(HtmlNode::text(' ', child.span()));
-    } else if let Some(elem) = child.to_packed::<TextElem>() {
-        output.push(HtmlNode::text(elem.text.clone(), elem.span()));
-    } else if let Some(elem) = child.to_packed::<LinebreakElem>() {
-        output.push(HtmlElement::new(tag::br).spanned(elem.span()).into());
-    } else if let Some(elem) = child.to_packed::<SmartQuoteElem>() {
-        output.push(HtmlNode::text(
-            if elem.double.get(styles) { '"' } else { '\'' },
-            child.span(),
-        ));
-    } else if let Some(elem) = child.to_packed::<FrameElem>() {
-        let locator = locator.next(&elem.span());
-        let style = TargetElem::target.set(Target::Paged).wrap();
-        let frame = (engine.routines.layout_frame)(
-            engine,
-            &elem.body,
-            locator,
-            styles.chain(&style),
-            Region::new(Size::splat(Abs::inf()), Axes::splat(false)),
-        )?;
-        output.push(HtmlNode::Frame(HtmlFrame {
-            inner: frame,
-            text_size: styles.resolve(TextElem::size),
-        }));
-    } else {
-        engine.sink.warn(warning!(
-            child.span(),
-            "{} was ignored during HTML export",
-            child.elem().name()
-        ));
-    }
-    Ok(())
-}
-
-/// Wrap the nodes in `<html>` and `<body>` if they are not yet rooted,
-/// supplying a suitable `<head>`.
-fn root_element(output: Vec<HtmlNode>, info: &DocumentInfo) -> SourceResult<HtmlElement> {
-    let head = head_element(info);
-    let body = match classify_output(output)? {
-        OutputKind::Html(element) => return Ok(element),
-        OutputKind::Body(body) => body,
-        OutputKind::Leafs(leafs) => HtmlElement::new(tag::body).with_children(leafs),
-    };
-    Ok(HtmlElement::new(tag::html).with_children(vec![head.into(), body.into()]))
-}
-
-/// Generate a `<head>` element.
-fn head_element(info: &DocumentInfo) -> HtmlElement {
-    let mut children = vec![];
-
-    children.push(HtmlElement::new(tag::meta).with_attr(attr::charset, "utf-8").into());
-
-    children.push(
-        HtmlElement::new(tag::meta)
-            .with_attr(attr::name, "viewport")
-            .with_attr(attr::content, "width=device-width, initial-scale=1")
-            .into(),
-    );
-
-    if let Some(title) = &info.title {
-        children.push(
-            HtmlElement::new(tag::title)
-                .with_children(vec![HtmlNode::Text(title.clone(), Span::detached())])
-                .into(),
-        );
+impl HtmlElem {
+    /// Add an attribute to the element.
+    pub fn with_attr(mut self, attr: HtmlAttr, value: impl Into<EcoString>) -> Self {
+        self.attrs
+            .as_option_mut()
+            .get_or_insert_with(Default::default)
+            .push(attr, value);
+        self
     }
 
-    if let Some(description) = &info.description {
-        children.push(
-            HtmlElement::new(tag::meta)
-                .with_attr(attr::name, "description")
-                .with_attr(attr::content, description.clone())
-                .into(),
-        );
-    }
-
-    if !info.author.is_empty() {
-        children.push(
-            HtmlElement::new(tag::meta)
-                .with_attr(attr::name, "authors")
-                .with_attr(attr::content, info.author.join(", "))
-                .into(),
-        )
-    }
-
-    if !info.keywords.is_empty() {
-        children.push(
-            HtmlElement::new(tag::meta)
-                .with_attr(attr::name, "keywords")
-                .with_attr(attr::content, info.keywords.join(", "))
-                .into(),
-        )
-    }
-
-    HtmlElement::new(tag::head).with_children(children)
-}
-
-/// Determine which kind of output the user generated.
-fn classify_output(mut output: Vec<HtmlNode>) -> SourceResult<OutputKind> {
-    let count = output.iter().filter(|node| !matches!(node, HtmlNode::Tag(_))).count();
-    for node in &mut output {
-        let HtmlNode::Element(elem) = node else { continue };
-        let tag = elem.tag;
-        let mut take = || std::mem::replace(elem, HtmlElement::new(tag::html));
-        match (tag, count) {
-            (tag::html, 1) => return Ok(OutputKind::Html(take())),
-            (tag::body, 1) => return Ok(OutputKind::Body(take())),
-            (tag::html | tag::body, _) => bail!(
-                elem.span,
-                "`{}` element must be the only element in the document",
-                elem.tag,
-            ),
-            _ => {}
+    /// Adds CSS styles to an element.
+    fn with_styles(self, properties: css::Properties) -> Self {
+        if let Some(value) = properties.into_inline_styles() {
+            self.with_attr(attr::style, value)
+        } else {
+            self
         }
     }
-    Ok(OutputKind::Leafs(output))
 }
 
-/// What kinds of output the user generated.
-enum OutputKind {
-    /// The user generated their own `<html>` element. We do not need to supply
-    /// one.
-    Html(HtmlElement),
-    /// The user generate their own `<body>` element. We do not need to supply
-    /// one, but need supply the `<html>` element.
-    Body(HtmlElement),
-    /// The user generated leafs which we wrap in a `<body>` and `<html>`.
-    Leafs(Vec<HtmlNode>),
+/// An element that lays out its content as an inline SVG.
+///
+/// Sometimes, converting Typst content to HTML is not desirable. This can be
+/// the case for plots and other content that relies on positioning and styling
+/// to convey its message.
+///
+/// This function allows you to use the Typst layout engine that would also be
+/// used for PDF, SVG, and PNG export to render a part of your document exactly
+/// how it would appear when exported in one of these formats. It embeds the
+/// content as an inline SVG.
+#[elem]
+pub struct FrameElem {
+    /// The content that shall be laid out.
+    #[positional]
+    #[required]
+    pub body: Content,
 }
diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index 5bf25e79b..04a58ca47 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -5,7 +5,6 @@ use typst_library::diag::warning;
 use typst_library::foundations::{
     Content, NativeElement, NativeRuleMap, ShowFn, Smart, StyleChain, Target,
 };
-use typst_library::html::{attr, tag, HtmlAttrs, HtmlElem, HtmlTag};
 use typst_library::introspection::{Counter, Locator};
 use typst_library::layout::resolve::{table_to_cellgrid, Cell, CellGrid, Entry};
 use typst_library::layout::{OuterVAlignment, Sizing};
@@ -20,11 +19,11 @@ use typst_library::text::{
 };
 use typst_library::visualize::ImageElem;
 
-use crate::css::{self, HtmlElemExt};
+use crate::{attr, css, tag, FrameElem, HtmlAttrs, HtmlElem, HtmlTag};
 
-/// Register show rules for the [HTML target](Target::Html).
+/// Registers show rules for the [HTML target](Target::Html).
 pub fn register(rules: &mut NativeRuleMap) {
-    use Target::Html;
+    use Target::{Html, Paged};
 
     // Model.
     rules.register(Html, STRONG_RULE);
@@ -53,6 +52,11 @@ pub fn register(rules: &mut NativeRuleMap) {
 
     // Visualize.
     rules.register(Html, IMAGE_RULE);
+
+    // For the HTML target, `html.frame` is a primitive. In the laid-out target,
+    // it should be a no-op so that nested frames don't break (things like `show
+    // math.equation: html.frame` can result in nested ones).
+    rules.register::<FrameElem>(Paged, |elem, _, _| Ok(elem.body.clone()));
 }
 
 const STRONG_RULE: ShowFn<StrongElem> = |elem, _, _| {
diff --git a/crates/typst-html/src/tag.rs b/crates/typst-html/src/tag.rs
new file mode 100644
index 000000000..89c50e1a8
--- /dev/null
+++ b/crates/typst-html/src/tag.rs
@@ -0,0 +1,271 @@
+//! Predefined constants for HTML tags.
+
+#![allow(non_upper_case_globals)]
+#![allow(dead_code)]
+
+use crate::HtmlTag;
+
+pub const a: HtmlTag = HtmlTag::constant("a");
+pub const abbr: HtmlTag = HtmlTag::constant("abbr");
+pub const address: HtmlTag = HtmlTag::constant("address");
+pub const area: HtmlTag = HtmlTag::constant("area");
+pub const article: HtmlTag = HtmlTag::constant("article");
+pub const aside: HtmlTag = HtmlTag::constant("aside");
+pub const audio: HtmlTag = HtmlTag::constant("audio");
+pub const b: HtmlTag = HtmlTag::constant("b");
+pub const base: HtmlTag = HtmlTag::constant("base");
+pub const bdi: HtmlTag = HtmlTag::constant("bdi");
+pub const bdo: HtmlTag = HtmlTag::constant("bdo");
+pub const blockquote: HtmlTag = HtmlTag::constant("blockquote");
+pub const body: HtmlTag = HtmlTag::constant("body");
+pub const br: HtmlTag = HtmlTag::constant("br");
+pub const button: HtmlTag = HtmlTag::constant("button");
+pub const canvas: HtmlTag = HtmlTag::constant("canvas");
+pub const caption: HtmlTag = HtmlTag::constant("caption");
+pub const cite: HtmlTag = HtmlTag::constant("cite");
+pub const code: HtmlTag = HtmlTag::constant("code");
+pub const col: HtmlTag = HtmlTag::constant("col");
+pub const colgroup: HtmlTag = HtmlTag::constant("colgroup");
+pub const data: HtmlTag = HtmlTag::constant("data");
+pub const datalist: HtmlTag = HtmlTag::constant("datalist");
+pub const dd: HtmlTag = HtmlTag::constant("dd");
+pub const del: HtmlTag = HtmlTag::constant("del");
+pub const details: HtmlTag = HtmlTag::constant("details");
+pub const dfn: HtmlTag = HtmlTag::constant("dfn");
+pub const dialog: HtmlTag = HtmlTag::constant("dialog");
+pub const div: HtmlTag = HtmlTag::constant("div");
+pub const dl: HtmlTag = HtmlTag::constant("dl");
+pub const dt: HtmlTag = HtmlTag::constant("dt");
+pub const em: HtmlTag = HtmlTag::constant("em");
+pub const embed: HtmlTag = HtmlTag::constant("embed");
+pub const fieldset: HtmlTag = HtmlTag::constant("fieldset");
+pub const figcaption: HtmlTag = HtmlTag::constant("figcaption");
+pub const figure: HtmlTag = HtmlTag::constant("figure");
+pub const footer: HtmlTag = HtmlTag::constant("footer");
+pub const form: HtmlTag = HtmlTag::constant("form");
+pub const h1: HtmlTag = HtmlTag::constant("h1");
+pub const h2: HtmlTag = HtmlTag::constant("h2");
+pub const h3: HtmlTag = HtmlTag::constant("h3");
+pub const h4: HtmlTag = HtmlTag::constant("h4");
+pub const h5: HtmlTag = HtmlTag::constant("h5");
+pub const h6: HtmlTag = HtmlTag::constant("h6");
+pub const head: HtmlTag = HtmlTag::constant("head");
+pub const header: HtmlTag = HtmlTag::constant("header");
+pub const hgroup: HtmlTag = HtmlTag::constant("hgroup");
+pub const hr: HtmlTag = HtmlTag::constant("hr");
+pub const html: HtmlTag = HtmlTag::constant("html");
+pub const i: HtmlTag = HtmlTag::constant("i");
+pub const iframe: HtmlTag = HtmlTag::constant("iframe");
+pub const img: HtmlTag = HtmlTag::constant("img");
+pub const input: HtmlTag = HtmlTag::constant("input");
+pub const ins: HtmlTag = HtmlTag::constant("ins");
+pub const kbd: HtmlTag = HtmlTag::constant("kbd");
+pub const label: HtmlTag = HtmlTag::constant("label");
+pub const legend: HtmlTag = HtmlTag::constant("legend");
+pub const li: HtmlTag = HtmlTag::constant("li");
+pub const link: HtmlTag = HtmlTag::constant("link");
+pub const main: HtmlTag = HtmlTag::constant("main");
+pub const map: HtmlTag = HtmlTag::constant("map");
+pub const mark: HtmlTag = HtmlTag::constant("mark");
+pub const menu: HtmlTag = HtmlTag::constant("menu");
+pub const meta: HtmlTag = HtmlTag::constant("meta");
+pub const meter: HtmlTag = HtmlTag::constant("meter");
+pub const nav: HtmlTag = HtmlTag::constant("nav");
+pub const noscript: HtmlTag = HtmlTag::constant("noscript");
+pub const object: HtmlTag = HtmlTag::constant("object");
+pub const ol: HtmlTag = HtmlTag::constant("ol");
+pub const optgroup: HtmlTag = HtmlTag::constant("optgroup");
+pub const option: HtmlTag = HtmlTag::constant("option");
+pub const output: HtmlTag = HtmlTag::constant("output");
+pub const p: HtmlTag = HtmlTag::constant("p");
+pub const picture: HtmlTag = HtmlTag::constant("picture");
+pub const pre: HtmlTag = HtmlTag::constant("pre");
+pub const progress: HtmlTag = HtmlTag::constant("progress");
+pub const q: HtmlTag = HtmlTag::constant("q");
+pub const rp: HtmlTag = HtmlTag::constant("rp");
+pub const rt: HtmlTag = HtmlTag::constant("rt");
+pub const ruby: HtmlTag = HtmlTag::constant("ruby");
+pub const s: HtmlTag = HtmlTag::constant("s");
+pub const samp: HtmlTag = HtmlTag::constant("samp");
+pub const script: HtmlTag = HtmlTag::constant("script");
+pub const search: HtmlTag = HtmlTag::constant("search");
+pub const section: HtmlTag = HtmlTag::constant("section");
+pub const select: HtmlTag = HtmlTag::constant("select");
+pub const slot: HtmlTag = HtmlTag::constant("slot");
+pub const small: HtmlTag = HtmlTag::constant("small");
+pub const source: HtmlTag = HtmlTag::constant("source");
+pub const span: HtmlTag = HtmlTag::constant("span");
+pub const strong: HtmlTag = HtmlTag::constant("strong");
+pub const style: HtmlTag = HtmlTag::constant("style");
+pub const sub: HtmlTag = HtmlTag::constant("sub");
+pub const summary: HtmlTag = HtmlTag::constant("summary");
+pub const sup: HtmlTag = HtmlTag::constant("sup");
+pub const table: HtmlTag = HtmlTag::constant("table");
+pub const tbody: HtmlTag = HtmlTag::constant("tbody");
+pub const td: HtmlTag = HtmlTag::constant("td");
+pub const template: HtmlTag = HtmlTag::constant("template");
+pub const textarea: HtmlTag = HtmlTag::constant("textarea");
+pub const tfoot: HtmlTag = HtmlTag::constant("tfoot");
+pub const th: HtmlTag = HtmlTag::constant("th");
+pub const thead: HtmlTag = HtmlTag::constant("thead");
+pub const time: HtmlTag = HtmlTag::constant("time");
+pub const title: HtmlTag = HtmlTag::constant("title");
+pub const tr: HtmlTag = HtmlTag::constant("tr");
+pub const track: HtmlTag = HtmlTag::constant("track");
+pub const u: HtmlTag = HtmlTag::constant("u");
+pub const ul: HtmlTag = HtmlTag::constant("ul");
+pub const var: HtmlTag = HtmlTag::constant("var");
+pub const video: HtmlTag = HtmlTag::constant("video");
+pub const wbr: HtmlTag = HtmlTag::constant("wbr");
+
+/// Whether this is a void tag whose associated element may not have
+/// children.
+pub fn is_void(tag: HtmlTag) -> bool {
+    matches!(
+        tag,
+        self::area
+            | self::base
+            | self::br
+            | self::col
+            | self::embed
+            | self::hr
+            | self::img
+            | self::input
+            | self::link
+            | self::meta
+            | self::source
+            | self::track
+            | self::wbr
+    )
+}
+
+/// Whether this is a tag containing raw text.
+pub fn is_raw(tag: HtmlTag) -> bool {
+    matches!(tag, self::script | self::style)
+}
+
+/// Whether this is a tag containing escapable raw text.
+pub fn is_escapable_raw(tag: HtmlTag) -> bool {
+    matches!(tag, self::textarea | self::title)
+}
+
+/// Whether an element is considered metadata.
+pub fn is_metadata(tag: HtmlTag) -> bool {
+    matches!(
+        tag,
+        self::base
+            | self::link
+            | self::meta
+            | self::noscript
+            | self::script
+            | self::style
+            | self::template
+            | self::title
+    )
+}
+
+/// Whether nodes with the tag have the CSS property `display: block` by
+/// default.
+pub fn is_block_by_default(tag: HtmlTag) -> bool {
+    matches!(
+        tag,
+        self::html
+            | self::head
+            | self::body
+            | self::article
+            | self::aside
+            | self::h1
+            | self::h2
+            | self::h3
+            | self::h4
+            | self::h5
+            | self::h6
+            | self::hgroup
+            | self::nav
+            | self::section
+            | self::dd
+            | self::dl
+            | self::dt
+            | self::menu
+            | self::ol
+            | self::ul
+            | self::address
+            | self::blockquote
+            | self::dialog
+            | self::div
+            | self::fieldset
+            | self::figure
+            | self::figcaption
+            | self::footer
+            | self::form
+            | self::header
+            | self::hr
+            | self::legend
+            | self::main
+            | self::p
+            | self::pre
+            | self::search
+    )
+}
+
+/// Whether the element is inline-level as opposed to being block-level.
+///
+/// Not sure whether this distinction really makes sense. But we somehow
+/// need to decide what to put into automatic paragraphs. A `<strong>`
+/// should merged into a paragraph created by realization, but a `<div>`
+/// shouldn't.
+///
+/// <https://www.w3.org/TR/html401/struct/global.html#block-inline>
+/// <https://developer.mozilla.org/en-US/docs/Glossary/Inline-level_content>
+/// <https://github.com/orgs/mdn/discussions/353>
+pub fn is_inline_by_default(tag: HtmlTag) -> bool {
+    matches!(
+        tag,
+        self::abbr
+            | self::a
+            | self::bdi
+            | self::b
+            | self::br
+            | self::bdo
+            | self::code
+            | self::cite
+            | self::dfn
+            | self::data
+            | self::i
+            | self::em
+            | self::mark
+            | self::kbd
+            | self::rp
+            | self::q
+            | self::ruby
+            | self::rt
+            | self::samp
+            | self::s
+            | self::span
+            | self::small
+            | self::sub
+            | self::strong
+            | self::time
+            | self::sup
+            | self::var
+            | self::u
+    )
+}
+
+/// Whether nodes with the tag have the CSS property `display: table(-.*)?`
+/// by default.
+pub fn is_tabular_by_default(tag: HtmlTag) -> bool {
+    matches!(
+        tag,
+        self::table
+            | self::thead
+            | self::tbody
+            | self::tfoot
+            | self::tr
+            | self::th
+            | self::td
+            | self::caption
+            | self::col
+            | self::colgroup
+    )
+}
diff --git a/crates/typst-html/src/typed.rs b/crates/typst-html/src/typed.rs
index 4b794bbba..190ff4f16 100644
--- a/crates/typst-html/src/typed.rs
+++ b/crates/typst-html/src/typed.rs
@@ -18,13 +18,11 @@ use typst_library::foundations::{
     FromValue, IntoValue, NativeFuncData, NativeFuncPtr, NoneValue, ParamInfo,
     PositiveF64, Reflect, Scope, Str, Type, Value,
 };
-use typst_library::html::tag;
-use typst_library::html::{HtmlAttr, HtmlAttrs, HtmlElem, HtmlTag};
 use typst_library::layout::{Axes, Axis, Dir, Length};
 use typst_library::visualize::Color;
 use typst_macros::cast;
 
-use crate::css;
+use crate::{css, tag, HtmlAttr, HtmlAttrs, HtmlElem, HtmlTag};
 
 /// Hook up all typed HTML definitions.
 pub(super) fn define(html: &mut Scope) {
diff --git a/crates/typst-layout/src/flow/mod.rs b/crates/typst-layout/src/flow/mod.rs
index f4f1c0915..cb029dce8 100644
--- a/crates/typst-layout/src/flow/mod.rs
+++ b/crates/typst-layout/src/flow/mod.rs
@@ -143,7 +143,7 @@ fn layout_fragment_impl(
     let mut kind = FragmentKind::Block;
     let arenas = Arenas::default();
     let children = (engine.routines.realize)(
-        RealizationKind::LayoutFragment(&mut kind),
+        RealizationKind::LayoutFragment { kind: &mut kind },
         &mut engine,
         &mut locator,
         &arenas,
diff --git a/crates/typst-layout/src/pages/mod.rs b/crates/typst-layout/src/pages/mod.rs
index 14dc0f3fb..ec0dc2c05 100644
--- a/crates/typst-layout/src/pages/mod.rs
+++ b/crates/typst-layout/src/pages/mod.rs
@@ -4,14 +4,16 @@ mod collect;
 mod finalize;
 mod run;
 
+use std::num::NonZeroUsize;
+
 use comemo::{Tracked, TrackedMut};
 use typst_library::diag::SourceResult;
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Content, StyleChain};
 use typst_library::introspection::{
-    Introspector, Locator, ManualPageCounter, SplitLocator, TagElem,
+    Introspector, IntrospectorBuilder, Locator, ManualPageCounter, SplitLocator, TagElem,
 };
-use typst_library::layout::{FrameItem, Page, PagedDocument, Point};
+use typst_library::layout::{FrameItem, Page, PagedDocument, Point, Transform};
 use typst_library::model::DocumentInfo;
 use typst_library::routines::{Arenas, Pair, RealizationKind, Routines};
 use typst_library::World;
@@ -75,7 +77,7 @@ fn layout_document_impl(
     let arenas = Arenas::default();
     let mut info = DocumentInfo::default();
     let mut children = (engine.routines.realize)(
-        RealizationKind::LayoutDocument(&mut info),
+        RealizationKind::LayoutDocument { info: &mut info },
         &mut engine,
         &mut locator,
         &arenas,
@@ -84,7 +86,7 @@ fn layout_document_impl(
     )?;
 
     let pages = layout_pages(&mut engine, &mut children, &mut locator, styles)?;
-    let introspector = Introspector::paged(&pages);
+    let introspector = introspect_pages(&pages);
 
     Ok(PagedDocument { pages, info, introspector })
 }
@@ -157,3 +159,27 @@ fn layout_pages<'a>(
 
     Ok(pages)
 }
+
+/// Introspects pages.
+#[typst_macros::time(name = "introspect pages")]
+fn introspect_pages(pages: &[Page]) -> Introspector {
+    let mut builder = IntrospectorBuilder::new();
+    builder.pages = pages.len();
+    builder.page_numberings.reserve(pages.len());
+    builder.page_supplements.reserve(pages.len());
+
+    // Discover all elements.
+    let mut elems = Vec::new();
+    for (i, page) in pages.iter().enumerate() {
+        builder.page_numberings.push(page.numbering.clone());
+        builder.page_supplements.push(page.supplement.clone());
+        builder.discover_in_frame(
+            &mut elems,
+            &page.frame,
+            NonZeroUsize::new(1 + i).unwrap(),
+            Transform::identity(),
+        );
+    }
+
+    builder.finalize(elems)
+}
diff --git a/crates/typst-library/src/html/dom.rs b/crates/typst-library/src/html/dom.rs
deleted file mode 100644
index 49ff37c45..000000000
--- a/crates/typst-library/src/html/dom.rs
+++ /dev/null
@@ -1,828 +0,0 @@
-use std::fmt::{self, Debug, Display, Formatter};
-
-use ecow::{EcoString, EcoVec};
-use typst_syntax::Span;
-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::{Abs, Frame};
-use crate::model::DocumentInfo;
-
-/// An HTML document.
-#[derive(Debug, Clone)]
-pub struct HtmlDocument {
-    /// The document's root HTML element.
-    pub root: HtmlElement,
-    /// Details about the document.
-    pub info: DocumentInfo,
-    /// Provides the ability to execute queries on the document.
-    pub introspector: Introspector,
-}
-
-/// A child of an HTML element.
-#[derive(Debug, Clone, Hash)]
-pub enum HtmlNode {
-    /// An introspectable element that produced something within this node.
-    Tag(Tag),
-    /// Plain text.
-    Text(EcoString, Span),
-    /// Another element.
-    Element(HtmlElement),
-    /// Layouted content that will be embedded into HTML as an SVG.
-    Frame(HtmlFrame),
-}
-
-impl HtmlNode {
-    /// Create a plain text node.
-    pub fn text(text: impl Into<EcoString>, span: Span) -> Self {
-        Self::Text(text.into(), span)
-    }
-}
-
-impl From<HtmlElement> for HtmlNode {
-    fn from(element: HtmlElement) -> Self {
-        Self::Element(element)
-    }
-}
-
-/// An HTML element.
-#[derive(Debug, Clone, Hash)]
-pub struct HtmlElement {
-    /// The HTML tag.
-    pub tag: HtmlTag,
-    /// The element's attributes.
-    pub attrs: HtmlAttrs,
-    /// The element's children.
-    pub children: Vec<HtmlNode>,
-    /// The span from which the element originated, if any.
-    pub span: Span,
-}
-
-impl HtmlElement {
-    /// Create a new, blank element without attributes or children.
-    pub fn new(tag: HtmlTag) -> Self {
-        Self {
-            tag,
-            attrs: HtmlAttrs::default(),
-            children: vec![],
-            span: Span::detached(),
-        }
-    }
-
-    /// Attach children to the element.
-    ///
-    /// Note: This overwrites potential previous children.
-    pub fn with_children(mut self, children: Vec<HtmlNode>) -> Self {
-        self.children = children;
-        self
-    }
-
-    /// Add an atribute to the element.
-    pub fn with_attr(mut self, key: HtmlAttr, value: impl Into<EcoString>) -> Self {
-        self.attrs.push(key, value);
-        self
-    }
-
-    /// Attach a span to the element.
-    pub fn spanned(mut self, span: Span) -> Self {
-        self.span = span;
-        self
-    }
-}
-
-/// The tag of an HTML element.
-#[derive(Copy, Clone, Eq, PartialEq, Hash)]
-pub struct HtmlTag(PicoStr);
-
-impl HtmlTag {
-    /// Intern an HTML tag string at runtime.
-    pub fn intern(string: &str) -> StrResult<Self> {
-        if string.is_empty() {
-            bail!("tag name must not be empty");
-        }
-
-        if let Some(c) = string.chars().find(|&c| !charsets::is_valid_in_tag_name(c)) {
-            bail!("the character {} is not valid in a tag name", c.repr());
-        }
-
-        Ok(Self(PicoStr::intern(string)))
-    }
-
-    /// Creates a compile-time constant `HtmlTag`.
-    ///
-    /// Should only be used in const contexts because it can panic.
-    #[track_caller]
-    pub const fn constant(string: &'static str) -> Self {
-        if string.is_empty() {
-            panic!("tag name must not be empty");
-        }
-
-        let bytes = string.as_bytes();
-        let mut i = 0;
-        while i < bytes.len() {
-            if !bytes[i].is_ascii() || !charsets::is_valid_in_tag_name(bytes[i] as char) {
-                panic!("not all characters are valid in a tag name");
-            }
-            i += 1;
-        }
-
-        Self(PicoStr::constant(string))
-    }
-
-    /// Resolves the tag to a string.
-    pub fn resolve(self) -> ResolvedPicoStr {
-        self.0.resolve()
-    }
-
-    /// Turns the tag into its inner interned string.
-    pub const fn into_inner(self) -> PicoStr {
-        self.0
-    }
-}
-
-impl Debug for HtmlTag {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
-    }
-}
-
-impl Display for HtmlTag {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "<{}>", self.resolve())
-    }
-}
-
-cast! {
-    HtmlTag,
-    self => self.0.resolve().as_str().into_value(),
-    v: Str => Self::intern(&v)?,
-}
-
-/// Attributes of an HTML element.
-#[derive(Debug, Default, Clone, Eq, PartialEq, Hash)]
-pub struct HtmlAttrs(pub EcoVec<(HtmlAttr, EcoString)>);
-
-impl HtmlAttrs {
-    /// Creates an empty attribute list.
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Add an attribute.
-    pub fn push(&mut self, attr: HtmlAttr, value: impl Into<EcoString>) {
-        self.0.push((attr, value.into()));
-    }
-}
-
-cast! {
-    HtmlAttrs,
-    self => self.0
-        .into_iter()
-        .map(|(key, value)| (key.resolve().as_str().into(), value.into_value()))
-        .collect::<Dict>()
-        .into_value(),
-    values: Dict => Self(values
-        .into_iter()
-        .map(|(k, v)| {
-            let attr = HtmlAttr::intern(&k)?;
-            let value = v.cast::<EcoString>()?;
-            Ok((attr, value))
-        })
-        .collect::<HintedStrResult<_>>()?),
-}
-
-/// An attribute of an HTML element.
-#[derive(Copy, Clone, Eq, PartialEq, Hash)]
-pub struct HtmlAttr(PicoStr);
-
-impl HtmlAttr {
-    /// Intern an HTML attribute string at runtime.
-    pub fn intern(string: &str) -> StrResult<Self> {
-        if string.is_empty() {
-            bail!("attribute name must not be empty");
-        }
-
-        if let Some(c) =
-            string.chars().find(|&c| !charsets::is_valid_in_attribute_name(c))
-        {
-            bail!("the character {} is not valid in an attribute name", c.repr());
-        }
-
-        Ok(Self(PicoStr::intern(string)))
-    }
-
-    /// Creates a compile-time constant `HtmlAttr`.
-    ///
-    /// Must only be used in const contexts (in a constant definition or
-    /// explicit `const { .. }` block) because otherwise a panic for a malformed
-    /// attribute or not auto-internible constant will only be caught at
-    /// runtime.
-    #[track_caller]
-    pub const fn constant(string: &'static str) -> Self {
-        if string.is_empty() {
-            panic!("attribute name must not be empty");
-        }
-
-        let bytes = string.as_bytes();
-        let mut i = 0;
-        while i < bytes.len() {
-            if !bytes[i].is_ascii()
-                || !charsets::is_valid_in_attribute_name(bytes[i] as char)
-            {
-                panic!("not all characters are valid in an attribute name");
-            }
-            i += 1;
-        }
-
-        Self(PicoStr::constant(string))
-    }
-
-    /// Resolves the attribute to a string.
-    pub fn resolve(self) -> ResolvedPicoStr {
-        self.0.resolve()
-    }
-
-    /// Turns the attribute into its inner interned string.
-    pub const fn into_inner(self) -> PicoStr {
-        self.0
-    }
-}
-
-impl Debug for HtmlAttr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        Display::fmt(self, f)
-    }
-}
-
-impl Display for HtmlAttr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.resolve())
-    }
-}
-
-cast! {
-    HtmlAttr,
-    self => self.0.resolve().as_str().into_value(),
-    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.
-    pub const fn is_valid_in_tag_name(c: char) -> bool {
-        c.is_ascii_alphanumeric()
-    }
-
-    /// Check whether a character is valid in an attribute name.
-    pub const fn is_valid_in_attribute_name(c: char) -> bool {
-        match c {
-            // These are forbidden.
-            '\0' | ' ' | '"' | '\'' | '>' | '/' | '=' => false,
-            c if is_whatwg_control_char(c) => false,
-            c if is_whatwg_non_char(c) => false,
-            // _Everything_ else is allowed, including U+2029 paragraph
-            // separator. Go wild.
-            _ => true,
-        }
-    }
-
-    /// Check whether a character can be an used in an attribute value without
-    /// escaping.
-    ///
-    /// See <https://html.spec.whatwg.org/multipage/syntax.html#attributes-2>
-    pub const fn is_valid_in_attribute_value(c: char) -> bool {
-        match c {
-            // Ampersands are sometimes legal (i.e. when they are not _ambiguous
-            // ampersands_) but it is not worth the trouble to check for that.
-            '&' => false,
-            // Quotation marks are not allowed in double-quote-delimited attribute
-            // values.
-            '"' => false,
-            // All other text characters are allowed.
-            c => is_w3c_text_char(c),
-        }
-    }
-
-    /// Check whether a character can be an used in normal text without
-    /// escaping.
-    pub const fn is_valid_in_normal_element_text(c: char) -> bool {
-        match c {
-            // Ampersands are sometimes legal (i.e. when they are not _ambiguous
-            // ampersands_) but it is not worth the trouble to check for that.
-            '&' => false,
-            // Less-than signs are not allowed in text.
-            '<' => false,
-            // All other text characters are allowed.
-            c => is_w3c_text_char(c),
-        }
-    }
-
-    /// Check if something is valid text in HTML.
-    pub const fn is_w3c_text_char(c: char) -> bool {
-        match c {
-            // Non-characters are obviously not text characters.
-            c if is_whatwg_non_char(c) => false,
-            // Control characters are disallowed, except for whitespace.
-            c if is_whatwg_control_char(c) => c.is_ascii_whitespace(),
-            // Everything else is allowed.
-            _ => true,
-        }
-    }
-
-    const fn is_whatwg_non_char(c: char) -> bool {
-        match c {
-            '\u{fdd0}'..='\u{fdef}' => true,
-            // Non-characters matching xxFFFE or xxFFFF up to x10FFFF (inclusive).
-            c if c as u32 & 0xfffe == 0xfffe && c as u32 <= 0x10ffff => true,
-            _ => false,
-        }
-    }
-
-    const fn is_whatwg_control_char(c: char) -> bool {
-        match c {
-            // C0 control characters.
-            '\u{00}'..='\u{1f}' => true,
-            // Other control characters.
-            '\u{7f}'..='\u{9f}' => true,
-            _ => false,
-        }
-    }
-}
-
-/// Predefined constants for HTML tags.
-#[allow(non_upper_case_globals)]
-pub mod tag {
-    use super::HtmlTag;
-
-    pub const a: HtmlTag = HtmlTag::constant("a");
-    pub const abbr: HtmlTag = HtmlTag::constant("abbr");
-    pub const address: HtmlTag = HtmlTag::constant("address");
-    pub const area: HtmlTag = HtmlTag::constant("area");
-    pub const article: HtmlTag = HtmlTag::constant("article");
-    pub const aside: HtmlTag = HtmlTag::constant("aside");
-    pub const audio: HtmlTag = HtmlTag::constant("audio");
-    pub const b: HtmlTag = HtmlTag::constant("b");
-    pub const base: HtmlTag = HtmlTag::constant("base");
-    pub const bdi: HtmlTag = HtmlTag::constant("bdi");
-    pub const bdo: HtmlTag = HtmlTag::constant("bdo");
-    pub const blockquote: HtmlTag = HtmlTag::constant("blockquote");
-    pub const body: HtmlTag = HtmlTag::constant("body");
-    pub const br: HtmlTag = HtmlTag::constant("br");
-    pub const button: HtmlTag = HtmlTag::constant("button");
-    pub const canvas: HtmlTag = HtmlTag::constant("canvas");
-    pub const caption: HtmlTag = HtmlTag::constant("caption");
-    pub const cite: HtmlTag = HtmlTag::constant("cite");
-    pub const code: HtmlTag = HtmlTag::constant("code");
-    pub const col: HtmlTag = HtmlTag::constant("col");
-    pub const colgroup: HtmlTag = HtmlTag::constant("colgroup");
-    pub const data: HtmlTag = HtmlTag::constant("data");
-    pub const datalist: HtmlTag = HtmlTag::constant("datalist");
-    pub const dd: HtmlTag = HtmlTag::constant("dd");
-    pub const del: HtmlTag = HtmlTag::constant("del");
-    pub const details: HtmlTag = HtmlTag::constant("details");
-    pub const dfn: HtmlTag = HtmlTag::constant("dfn");
-    pub const dialog: HtmlTag = HtmlTag::constant("dialog");
-    pub const div: HtmlTag = HtmlTag::constant("div");
-    pub const dl: HtmlTag = HtmlTag::constant("dl");
-    pub const dt: HtmlTag = HtmlTag::constant("dt");
-    pub const em: HtmlTag = HtmlTag::constant("em");
-    pub const embed: HtmlTag = HtmlTag::constant("embed");
-    pub const fieldset: HtmlTag = HtmlTag::constant("fieldset");
-    pub const figcaption: HtmlTag = HtmlTag::constant("figcaption");
-    pub const figure: HtmlTag = HtmlTag::constant("figure");
-    pub const footer: HtmlTag = HtmlTag::constant("footer");
-    pub const form: HtmlTag = HtmlTag::constant("form");
-    pub const h1: HtmlTag = HtmlTag::constant("h1");
-    pub const h2: HtmlTag = HtmlTag::constant("h2");
-    pub const h3: HtmlTag = HtmlTag::constant("h3");
-    pub const h4: HtmlTag = HtmlTag::constant("h4");
-    pub const h5: HtmlTag = HtmlTag::constant("h5");
-    pub const h6: HtmlTag = HtmlTag::constant("h6");
-    pub const head: HtmlTag = HtmlTag::constant("head");
-    pub const header: HtmlTag = HtmlTag::constant("header");
-    pub const hgroup: HtmlTag = HtmlTag::constant("hgroup");
-    pub const hr: HtmlTag = HtmlTag::constant("hr");
-    pub const html: HtmlTag = HtmlTag::constant("html");
-    pub const i: HtmlTag = HtmlTag::constant("i");
-    pub const iframe: HtmlTag = HtmlTag::constant("iframe");
-    pub const img: HtmlTag = HtmlTag::constant("img");
-    pub const input: HtmlTag = HtmlTag::constant("input");
-    pub const ins: HtmlTag = HtmlTag::constant("ins");
-    pub const kbd: HtmlTag = HtmlTag::constant("kbd");
-    pub const label: HtmlTag = HtmlTag::constant("label");
-    pub const legend: HtmlTag = HtmlTag::constant("legend");
-    pub const li: HtmlTag = HtmlTag::constant("li");
-    pub const link: HtmlTag = HtmlTag::constant("link");
-    pub const main: HtmlTag = HtmlTag::constant("main");
-    pub const map: HtmlTag = HtmlTag::constant("map");
-    pub const mark: HtmlTag = HtmlTag::constant("mark");
-    pub const menu: HtmlTag = HtmlTag::constant("menu");
-    pub const meta: HtmlTag = HtmlTag::constant("meta");
-    pub const meter: HtmlTag = HtmlTag::constant("meter");
-    pub const nav: HtmlTag = HtmlTag::constant("nav");
-    pub const noscript: HtmlTag = HtmlTag::constant("noscript");
-    pub const object: HtmlTag = HtmlTag::constant("object");
-    pub const ol: HtmlTag = HtmlTag::constant("ol");
-    pub const optgroup: HtmlTag = HtmlTag::constant("optgroup");
-    pub const option: HtmlTag = HtmlTag::constant("option");
-    pub const output: HtmlTag = HtmlTag::constant("output");
-    pub const p: HtmlTag = HtmlTag::constant("p");
-    pub const picture: HtmlTag = HtmlTag::constant("picture");
-    pub const pre: HtmlTag = HtmlTag::constant("pre");
-    pub const progress: HtmlTag = HtmlTag::constant("progress");
-    pub const q: HtmlTag = HtmlTag::constant("q");
-    pub const rp: HtmlTag = HtmlTag::constant("rp");
-    pub const rt: HtmlTag = HtmlTag::constant("rt");
-    pub const ruby: HtmlTag = HtmlTag::constant("ruby");
-    pub const s: HtmlTag = HtmlTag::constant("s");
-    pub const samp: HtmlTag = HtmlTag::constant("samp");
-    pub const script: HtmlTag = HtmlTag::constant("script");
-    pub const search: HtmlTag = HtmlTag::constant("search");
-    pub const section: HtmlTag = HtmlTag::constant("section");
-    pub const select: HtmlTag = HtmlTag::constant("select");
-    pub const slot: HtmlTag = HtmlTag::constant("slot");
-    pub const small: HtmlTag = HtmlTag::constant("small");
-    pub const source: HtmlTag = HtmlTag::constant("source");
-    pub const span: HtmlTag = HtmlTag::constant("span");
-    pub const strong: HtmlTag = HtmlTag::constant("strong");
-    pub const style: HtmlTag = HtmlTag::constant("style");
-    pub const sub: HtmlTag = HtmlTag::constant("sub");
-    pub const summary: HtmlTag = HtmlTag::constant("summary");
-    pub const sup: HtmlTag = HtmlTag::constant("sup");
-    pub const table: HtmlTag = HtmlTag::constant("table");
-    pub const tbody: HtmlTag = HtmlTag::constant("tbody");
-    pub const td: HtmlTag = HtmlTag::constant("td");
-    pub const template: HtmlTag = HtmlTag::constant("template");
-    pub const textarea: HtmlTag = HtmlTag::constant("textarea");
-    pub const tfoot: HtmlTag = HtmlTag::constant("tfoot");
-    pub const th: HtmlTag = HtmlTag::constant("th");
-    pub const thead: HtmlTag = HtmlTag::constant("thead");
-    pub const time: HtmlTag = HtmlTag::constant("time");
-    pub const title: HtmlTag = HtmlTag::constant("title");
-    pub const tr: HtmlTag = HtmlTag::constant("tr");
-    pub const track: HtmlTag = HtmlTag::constant("track");
-    pub const u: HtmlTag = HtmlTag::constant("u");
-    pub const ul: HtmlTag = HtmlTag::constant("ul");
-    pub const var: HtmlTag = HtmlTag::constant("var");
-    pub const video: HtmlTag = HtmlTag::constant("video");
-    pub const wbr: HtmlTag = HtmlTag::constant("wbr");
-
-    /// Whether this is a void tag whose associated element may not have
-    /// children.
-    pub fn is_void(tag: HtmlTag) -> bool {
-        matches!(
-            tag,
-            self::area
-                | self::base
-                | self::br
-                | self::col
-                | self::embed
-                | self::hr
-                | self::img
-                | self::input
-                | self::link
-                | self::meta
-                | self::source
-                | self::track
-                | self::wbr
-        )
-    }
-
-    /// Whether this is a tag containing raw text.
-    pub fn is_raw(tag: HtmlTag) -> bool {
-        matches!(tag, self::script | self::style)
-    }
-
-    /// Whether this is a tag containing escapable raw text.
-    pub fn is_escapable_raw(tag: HtmlTag) -> bool {
-        matches!(tag, self::textarea | self::title)
-    }
-
-    /// Whether an element is considered metadata.
-    pub fn is_metadata(tag: HtmlTag) -> bool {
-        matches!(
-            tag,
-            self::base
-                | self::link
-                | self::meta
-                | self::noscript
-                | self::script
-                | self::style
-                | self::template
-                | self::title
-        )
-    }
-
-    /// Whether nodes with the tag have the CSS property `display: block` by
-    /// default.
-    pub fn is_block_by_default(tag: HtmlTag) -> bool {
-        matches!(
-            tag,
-            self::html
-                | self::head
-                | self::body
-                | self::article
-                | self::aside
-                | self::h1
-                | self::h2
-                | self::h3
-                | self::h4
-                | self::h5
-                | self::h6
-                | self::hgroup
-                | self::nav
-                | self::section
-                | self::dd
-                | self::dl
-                | self::dt
-                | self::menu
-                | self::ol
-                | self::ul
-                | self::address
-                | self::blockquote
-                | self::dialog
-                | self::div
-                | self::fieldset
-                | self::figure
-                | self::figcaption
-                | self::footer
-                | self::form
-                | self::header
-                | self::hr
-                | self::legend
-                | self::main
-                | self::p
-                | self::pre
-                | self::search
-        )
-    }
-
-    /// Whether the element is inline-level as opposed to being block-level.
-    ///
-    /// Not sure whether this distinction really makes sense. But we somehow
-    /// need to decide what to put into automatic paragraphs. A `<strong>`
-    /// should merged into a paragraph created by realization, but a `<div>`
-    /// shouldn't.
-    ///
-    /// <https://www.w3.org/TR/html401/struct/global.html#block-inline>
-    /// <https://developer.mozilla.org/en-US/docs/Glossary/Inline-level_content>
-    /// <https://github.com/orgs/mdn/discussions/353>
-    pub fn is_inline_by_default(tag: HtmlTag) -> bool {
-        matches!(
-            tag,
-            self::abbr
-                | self::a
-                | self::bdi
-                | self::b
-                | self::br
-                | self::bdo
-                | self::code
-                | self::cite
-                | self::dfn
-                | self::data
-                | self::i
-                | self::em
-                | self::mark
-                | self::kbd
-                | self::rp
-                | self::q
-                | self::ruby
-                | self::rt
-                | self::samp
-                | self::s
-                | self::span
-                | self::small
-                | self::sub
-                | self::strong
-                | self::time
-                | self::sup
-                | self::var
-                | self::u
-        )
-    }
-
-    /// Whether nodes with the tag have the CSS property `display: table(-.*)?`
-    /// by default.
-    pub fn is_tabular_by_default(tag: HtmlTag) -> bool {
-        matches!(
-            tag,
-            self::table
-                | self::thead
-                | self::tbody
-                | self::tfoot
-                | self::tr
-                | self::th
-                | self::td
-                | self::caption
-                | self::col
-                | self::colgroup
-        )
-    }
-}
-
-#[allow(non_upper_case_globals)]
-#[rustfmt::skip]
-pub mod attr {
-    use crate::html::HtmlAttr;
-    pub const abbr: HtmlAttr = HtmlAttr::constant("abbr");
-    pub const accept: HtmlAttr = HtmlAttr::constant("accept");
-    pub const accept_charset: HtmlAttr = HtmlAttr::constant("accept-charset");
-    pub const accesskey: HtmlAttr = HtmlAttr::constant("accesskey");
-    pub const action: HtmlAttr = HtmlAttr::constant("action");
-    pub const allow: HtmlAttr = HtmlAttr::constant("allow");
-    pub const allowfullscreen: HtmlAttr = HtmlAttr::constant("allowfullscreen");
-    pub const alpha: HtmlAttr = HtmlAttr::constant("alpha");
-    pub const alt: HtmlAttr = HtmlAttr::constant("alt");
-    pub const aria_activedescendant: HtmlAttr = HtmlAttr::constant("aria-activedescendant");
-    pub const aria_atomic: HtmlAttr = HtmlAttr::constant("aria-atomic");
-    pub const aria_autocomplete: HtmlAttr = HtmlAttr::constant("aria-autocomplete");
-    pub const aria_busy: HtmlAttr = HtmlAttr::constant("aria-busy");
-    pub const aria_checked: HtmlAttr = HtmlAttr::constant("aria-checked");
-    pub const aria_colcount: HtmlAttr = HtmlAttr::constant("aria-colcount");
-    pub const aria_colindex: HtmlAttr = HtmlAttr::constant("aria-colindex");
-    pub const aria_colspan: HtmlAttr = HtmlAttr::constant("aria-colspan");
-    pub const aria_controls: HtmlAttr = HtmlAttr::constant("aria-controls");
-    pub const aria_current: HtmlAttr = HtmlAttr::constant("aria-current");
-    pub const aria_describedby: HtmlAttr = HtmlAttr::constant("aria-describedby");
-    pub const aria_details: HtmlAttr = HtmlAttr::constant("aria-details");
-    pub const aria_disabled: HtmlAttr = HtmlAttr::constant("aria-disabled");
-    pub const aria_errormessage: HtmlAttr = HtmlAttr::constant("aria-errormessage");
-    pub const aria_expanded: HtmlAttr = HtmlAttr::constant("aria-expanded");
-    pub const aria_flowto: HtmlAttr = HtmlAttr::constant("aria-flowto");
-    pub const aria_haspopup: HtmlAttr = HtmlAttr::constant("aria-haspopup");
-    pub const aria_hidden: HtmlAttr = HtmlAttr::constant("aria-hidden");
-    pub const aria_invalid: HtmlAttr = HtmlAttr::constant("aria-invalid");
-    pub const aria_keyshortcuts: HtmlAttr = HtmlAttr::constant("aria-keyshortcuts");
-    pub const aria_label: HtmlAttr = HtmlAttr::constant("aria-label");
-    pub const aria_labelledby: HtmlAttr = HtmlAttr::constant("aria-labelledby");
-    pub const aria_level: HtmlAttr = HtmlAttr::constant("aria-level");
-    pub const aria_live: HtmlAttr = HtmlAttr::constant("aria-live");
-    pub const aria_modal: HtmlAttr = HtmlAttr::constant("aria-modal");
-    pub const aria_multiline: HtmlAttr = HtmlAttr::constant("aria-multiline");
-    pub const aria_multiselectable: HtmlAttr = HtmlAttr::constant("aria-multiselectable");
-    pub const aria_orientation: HtmlAttr = HtmlAttr::constant("aria-orientation");
-    pub const aria_owns: HtmlAttr = HtmlAttr::constant("aria-owns");
-    pub const aria_placeholder: HtmlAttr = HtmlAttr::constant("aria-placeholder");
-    pub const aria_posinset: HtmlAttr = HtmlAttr::constant("aria-posinset");
-    pub const aria_pressed: HtmlAttr = HtmlAttr::constant("aria-pressed");
-    pub const aria_readonly: HtmlAttr = HtmlAttr::constant("aria-readonly");
-    pub const aria_relevant: HtmlAttr = HtmlAttr::constant("aria-relevant");
-    pub const aria_required: HtmlAttr = HtmlAttr::constant("aria-required");
-    pub const aria_roledescription: HtmlAttr = HtmlAttr::constant("aria-roledescription");
-    pub const aria_rowcount: HtmlAttr = HtmlAttr::constant("aria-rowcount");
-    pub const aria_rowindex: HtmlAttr = HtmlAttr::constant("aria-rowindex");
-    pub const aria_rowspan: HtmlAttr = HtmlAttr::constant("aria-rowspan");
-    pub const aria_selected: HtmlAttr = HtmlAttr::constant("aria-selected");
-    pub const aria_setsize: HtmlAttr = HtmlAttr::constant("aria-setsize");
-    pub const aria_sort: HtmlAttr = HtmlAttr::constant("aria-sort");
-    pub const aria_valuemax: HtmlAttr = HtmlAttr::constant("aria-valuemax");
-    pub const aria_valuemin: HtmlAttr = HtmlAttr::constant("aria-valuemin");
-    pub const aria_valuenow: HtmlAttr = HtmlAttr::constant("aria-valuenow");
-    pub const aria_valuetext: HtmlAttr = HtmlAttr::constant("aria-valuetext");
-    pub const r#as: HtmlAttr = HtmlAttr::constant("as");
-    pub const r#async: HtmlAttr = HtmlAttr::constant("async");
-    pub const autocapitalize: HtmlAttr = HtmlAttr::constant("autocapitalize");
-    pub const autocomplete: HtmlAttr = HtmlAttr::constant("autocomplete");
-    pub const autocorrect: HtmlAttr = HtmlAttr::constant("autocorrect");
-    pub const autofocus: HtmlAttr = HtmlAttr::constant("autofocus");
-    pub const autoplay: HtmlAttr = HtmlAttr::constant("autoplay");
-    pub const blocking: HtmlAttr = HtmlAttr::constant("blocking");
-    pub const charset: HtmlAttr = HtmlAttr::constant("charset");
-    pub const checked: HtmlAttr = HtmlAttr::constant("checked");
-    pub const cite: HtmlAttr = HtmlAttr::constant("cite");
-    pub const class: HtmlAttr = HtmlAttr::constant("class");
-    pub const closedby: HtmlAttr = HtmlAttr::constant("closedby");
-    pub const color: HtmlAttr = HtmlAttr::constant("color");
-    pub const colorspace: HtmlAttr = HtmlAttr::constant("colorspace");
-    pub const cols: HtmlAttr = HtmlAttr::constant("cols");
-    pub const colspan: HtmlAttr = HtmlAttr::constant("colspan");
-    pub const command: HtmlAttr = HtmlAttr::constant("command");
-    pub const commandfor: HtmlAttr = HtmlAttr::constant("commandfor");
-    pub const content: HtmlAttr = HtmlAttr::constant("content");
-    pub const contenteditable: HtmlAttr = HtmlAttr::constant("contenteditable");
-    pub const controls: HtmlAttr = HtmlAttr::constant("controls");
-    pub const coords: HtmlAttr = HtmlAttr::constant("coords");
-    pub const crossorigin: HtmlAttr = HtmlAttr::constant("crossorigin");
-    pub const data: HtmlAttr = HtmlAttr::constant("data");
-    pub const datetime: HtmlAttr = HtmlAttr::constant("datetime");
-    pub const decoding: HtmlAttr = HtmlAttr::constant("decoding");
-    pub const default: HtmlAttr = HtmlAttr::constant("default");
-    pub const defer: HtmlAttr = HtmlAttr::constant("defer");
-    pub const dir: HtmlAttr = HtmlAttr::constant("dir");
-    pub const dirname: HtmlAttr = HtmlAttr::constant("dirname");
-    pub const disabled: HtmlAttr = HtmlAttr::constant("disabled");
-    pub const download: HtmlAttr = HtmlAttr::constant("download");
-    pub const draggable: HtmlAttr = HtmlAttr::constant("draggable");
-    pub const enctype: HtmlAttr = HtmlAttr::constant("enctype");
-    pub const enterkeyhint: HtmlAttr = HtmlAttr::constant("enterkeyhint");
-    pub const fetchpriority: HtmlAttr = HtmlAttr::constant("fetchpriority");
-    pub const r#for: HtmlAttr = HtmlAttr::constant("for");
-    pub const form: HtmlAttr = HtmlAttr::constant("form");
-    pub const formaction: HtmlAttr = HtmlAttr::constant("formaction");
-    pub const formenctype: HtmlAttr = HtmlAttr::constant("formenctype");
-    pub const formmethod: HtmlAttr = HtmlAttr::constant("formmethod");
-    pub const formnovalidate: HtmlAttr = HtmlAttr::constant("formnovalidate");
-    pub const formtarget: HtmlAttr = HtmlAttr::constant("formtarget");
-    pub const headers: HtmlAttr = HtmlAttr::constant("headers");
-    pub const height: HtmlAttr = HtmlAttr::constant("height");
-    pub const hidden: HtmlAttr = HtmlAttr::constant("hidden");
-    pub const high: HtmlAttr = HtmlAttr::constant("high");
-    pub const href: HtmlAttr = HtmlAttr::constant("href");
-    pub const hreflang: HtmlAttr = HtmlAttr::constant("hreflang");
-    pub const http_equiv: HtmlAttr = HtmlAttr::constant("http-equiv");
-    pub const id: HtmlAttr = HtmlAttr::constant("id");
-    pub const imagesizes: HtmlAttr = HtmlAttr::constant("imagesizes");
-    pub const imagesrcset: HtmlAttr = HtmlAttr::constant("imagesrcset");
-    pub const inert: HtmlAttr = HtmlAttr::constant("inert");
-    pub const inputmode: HtmlAttr = HtmlAttr::constant("inputmode");
-    pub const integrity: HtmlAttr = HtmlAttr::constant("integrity");
-    pub const is: HtmlAttr = HtmlAttr::constant("is");
-    pub const ismap: HtmlAttr = HtmlAttr::constant("ismap");
-    pub const itemid: HtmlAttr = HtmlAttr::constant("itemid");
-    pub const itemprop: HtmlAttr = HtmlAttr::constant("itemprop");
-    pub const itemref: HtmlAttr = HtmlAttr::constant("itemref");
-    pub const itemscope: HtmlAttr = HtmlAttr::constant("itemscope");
-    pub const itemtype: HtmlAttr = HtmlAttr::constant("itemtype");
-    pub const kind: HtmlAttr = HtmlAttr::constant("kind");
-    pub const label: HtmlAttr = HtmlAttr::constant("label");
-    pub const lang: HtmlAttr = HtmlAttr::constant("lang");
-    pub const list: HtmlAttr = HtmlAttr::constant("list");
-    pub const loading: HtmlAttr = HtmlAttr::constant("loading");
-    pub const r#loop: HtmlAttr = HtmlAttr::constant("loop");
-    pub const low: HtmlAttr = HtmlAttr::constant("low");
-    pub const max: HtmlAttr = HtmlAttr::constant("max");
-    pub const maxlength: HtmlAttr = HtmlAttr::constant("maxlength");
-    pub const media: HtmlAttr = HtmlAttr::constant("media");
-    pub const method: HtmlAttr = HtmlAttr::constant("method");
-    pub const min: HtmlAttr = HtmlAttr::constant("min");
-    pub const minlength: HtmlAttr = HtmlAttr::constant("minlength");
-    pub const multiple: HtmlAttr = HtmlAttr::constant("multiple");
-    pub const muted: HtmlAttr = HtmlAttr::constant("muted");
-    pub const name: HtmlAttr = HtmlAttr::constant("name");
-    pub const nomodule: HtmlAttr = HtmlAttr::constant("nomodule");
-    pub const nonce: HtmlAttr = HtmlAttr::constant("nonce");
-    pub const novalidate: HtmlAttr = HtmlAttr::constant("novalidate");
-    pub const open: HtmlAttr = HtmlAttr::constant("open");
-    pub const optimum: HtmlAttr = HtmlAttr::constant("optimum");
-    pub const pattern: HtmlAttr = HtmlAttr::constant("pattern");
-    pub const ping: HtmlAttr = HtmlAttr::constant("ping");
-    pub const placeholder: HtmlAttr = HtmlAttr::constant("placeholder");
-    pub const playsinline: HtmlAttr = HtmlAttr::constant("playsinline");
-    pub const popover: HtmlAttr = HtmlAttr::constant("popover");
-    pub const popovertarget: HtmlAttr = HtmlAttr::constant("popovertarget");
-    pub const popovertargetaction: HtmlAttr = HtmlAttr::constant("popovertargetaction");
-    pub const poster: HtmlAttr = HtmlAttr::constant("poster");
-    pub const preload: HtmlAttr = HtmlAttr::constant("preload");
-    pub const readonly: HtmlAttr = HtmlAttr::constant("readonly");
-    pub const referrerpolicy: HtmlAttr = HtmlAttr::constant("referrerpolicy");
-    pub const rel: HtmlAttr = HtmlAttr::constant("rel");
-    pub const required: HtmlAttr = HtmlAttr::constant("required");
-    pub const reversed: HtmlAttr = HtmlAttr::constant("reversed");
-    pub const role: HtmlAttr = HtmlAttr::constant("role");
-    pub const rows: HtmlAttr = HtmlAttr::constant("rows");
-    pub const rowspan: HtmlAttr = HtmlAttr::constant("rowspan");
-    pub const sandbox: HtmlAttr = HtmlAttr::constant("sandbox");
-    pub const scope: HtmlAttr = HtmlAttr::constant("scope");
-    pub const selected: HtmlAttr = HtmlAttr::constant("selected");
-    pub const shadowrootclonable: HtmlAttr = HtmlAttr::constant("shadowrootclonable");
-    pub const shadowrootcustomelementregistry: HtmlAttr = HtmlAttr::constant("shadowrootcustomelementregistry");
-    pub const shadowrootdelegatesfocus: HtmlAttr = HtmlAttr::constant("shadowrootdelegatesfocus");
-    pub const shadowrootmode: HtmlAttr = HtmlAttr::constant("shadowrootmode");
-    pub const shadowrootserializable: HtmlAttr = HtmlAttr::constant("shadowrootserializable");
-    pub const shape: HtmlAttr = HtmlAttr::constant("shape");
-    pub const size: HtmlAttr = HtmlAttr::constant("size");
-    pub const sizes: HtmlAttr = HtmlAttr::constant("sizes");
-    pub const slot: HtmlAttr = HtmlAttr::constant("slot");
-    pub const span: HtmlAttr = HtmlAttr::constant("span");
-    pub const spellcheck: HtmlAttr = HtmlAttr::constant("spellcheck");
-    pub const src: HtmlAttr = HtmlAttr::constant("src");
-    pub const srcdoc: HtmlAttr = HtmlAttr::constant("srcdoc");
-    pub const srclang: HtmlAttr = HtmlAttr::constant("srclang");
-    pub const srcset: HtmlAttr = HtmlAttr::constant("srcset");
-    pub const start: HtmlAttr = HtmlAttr::constant("start");
-    pub const step: HtmlAttr = HtmlAttr::constant("step");
-    pub const style: HtmlAttr = HtmlAttr::constant("style");
-    pub const tabindex: HtmlAttr = HtmlAttr::constant("tabindex");
-    pub const target: HtmlAttr = HtmlAttr::constant("target");
-    pub const title: HtmlAttr = HtmlAttr::constant("title");
-    pub const translate: HtmlAttr = HtmlAttr::constant("translate");
-    pub const r#type: HtmlAttr = HtmlAttr::constant("type");
-    pub const usemap: HtmlAttr = HtmlAttr::constant("usemap");
-    pub const value: HtmlAttr = HtmlAttr::constant("value");
-    pub const width: HtmlAttr = HtmlAttr::constant("width");
-    pub const wrap: HtmlAttr = HtmlAttr::constant("wrap");
-    pub const writingsuggestions: HtmlAttr = HtmlAttr::constant("writingsuggestions");
-}
diff --git a/crates/typst-library/src/html/mod.rs b/crates/typst-library/src/html/mod.rs
deleted file mode 100644
index ca2cc0311..000000000
--- a/crates/typst-library/src/html/mod.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-//! HTML output.
-
-mod dom;
-
-pub use self::dom::*;
-
-use ecow::EcoString;
-
-use crate::foundations::{elem, Content};
-
-/// An HTML element that can contain Typst content.
-///
-/// Typst's HTML export automatically generates the appropriate tags for most
-/// elements. However, sometimes, it is desirable to retain more control. For
-/// example, when using Typst to generate your blog, you could use this function
-/// to wrap each article in an `<article>` tag.
-///
-/// Typst is aware of what is valid HTML. A tag and its attributes must form
-/// syntactically valid HTML. Some tags, like `meta` do not accept content.
-/// Hence, you must not provide a body for them. We may add more checks in the
-/// future, so be sure that you are generating valid HTML when using this
-/// function.
-///
-/// Normally, Typst will generate `html`, `head`, and `body` tags for you. If
-/// you instead create them with this function, Typst will omit its own tags.
-///
-/// ```typ
-/// #html.elem("div", attrs: (style: "background: aqua"))[
-///   A div with _Typst content_ inside!
-/// ]
-/// ```
-#[elem(name = "elem")]
-pub struct HtmlElem {
-    /// The element's tag.
-    #[required]
-    pub tag: HtmlTag,
-
-    /// The element's HTML attributes.
-    pub attrs: HtmlAttrs,
-
-    /// The contents of the HTML element.
-    ///
-    /// The body can be arbitrary Typst content.
-    #[positional]
-    pub body: Option<Content>,
-}
-
-impl HtmlElem {
-    /// Add an attribute to the element.
-    pub fn with_attr(mut self, attr: HtmlAttr, value: impl Into<EcoString>) -> Self {
-        self.attrs
-            .as_option_mut()
-            .get_or_insert_with(Default::default)
-            .push(attr, value);
-        self
-    }
-}
-
-/// An element that lays out its content as an inline SVG.
-///
-/// Sometimes, converting Typst content to HTML is not desirable. This can be
-/// the case for plots and other content that relies on positioning and styling
-/// to convey its message.
-///
-/// This function allows you to use the Typst layout engine that would also be
-/// used for PDF, SVG, and PNG export to render a part of your document exactly
-/// how it would appear when exported in one of these formats. It embeds the
-/// content as an inline SVG.
-#[elem]
-pub struct FrameElem {
-    /// The content that shall be laid out.
-    #[positional]
-    #[required]
-    pub body: Content,
-}
diff --git a/crates/typst-library/src/introspection/introspector.rs b/crates/typst-library/src/introspection/introspector.rs
index d2ad0525b..de74c55f5 100644
--- a/crates/typst-library/src/introspection/introspector.rs
+++ b/crates/typst-library/src/introspection/introspector.rs
@@ -10,9 +10,8 @@ use typst_utils::NonZeroExt;
 
 use crate::diag::{bail, StrResult};
 use crate::foundations::{Content, Label, Repr, Selector};
-use crate::html::HtmlNode;
 use crate::introspection::{Location, Tag};
-use crate::layout::{Frame, FrameItem, Page, Point, Position, Transform};
+use crate::layout::{Frame, FrameItem, Point, Position, Transform};
 use crate::model::Numbering;
 
 /// Can be queried for elements and their positions.
@@ -47,18 +46,6 @@ pub struct Introspector {
 type Pair = (Content, Position);
 
 impl Introspector {
-    /// Creates an introspector for a page list.
-    #[typst_macros::time(name = "introspect pages")]
-    pub fn paged(pages: &[Page]) -> Self {
-        IntrospectorBuilder::new().build_paged(pages)
-    }
-
-    /// Creates an introspector for HTML.
-    #[typst_macros::time(name = "introspect html")]
-    pub fn html(output: &[HtmlNode]) -> Self {
-        IntrospectorBuilder::new().build_html(output)
-    }
-
     /// Iterates over all locatable elements.
     pub fn all(&self) -> impl Iterator<Item = &Content> + '_ {
         self.elems.iter().map(|(c, _)| c)
@@ -352,10 +339,10 @@ impl Clone for QueryCache {
 
 /// Builds the introspector.
 #[derive(Default)]
-struct IntrospectorBuilder {
-    pages: usize,
-    page_numberings: Vec<Option<Numbering>>,
-    page_supplements: Vec<Content>,
+pub struct IntrospectorBuilder {
+    pub pages: usize,
+    pub page_numberings: Vec<Option<Numbering>>,
+    pub page_supplements: Vec<Content>,
     seen: HashSet<Location>,
     insertions: MultiMap<Location, Vec<Pair>>,
     keys: MultiMap<u128, Location>,
@@ -365,41 +352,12 @@ struct IntrospectorBuilder {
 
 impl IntrospectorBuilder {
     /// Create an empty builder.
-    fn new() -> Self {
+    pub fn new() -> Self {
         Self::default()
     }
 
-    /// Build an introspector for a page list.
-    fn build_paged(mut self, pages: &[Page]) -> Introspector {
-        self.pages = pages.len();
-        self.page_numberings.reserve(pages.len());
-        self.page_supplements.reserve(pages.len());
-
-        // Discover all elements.
-        let mut elems = Vec::new();
-        for (i, page) in pages.iter().enumerate() {
-            self.page_numberings.push(page.numbering.clone());
-            self.page_supplements.push(page.supplement.clone());
-            self.discover_in_frame(
-                &mut elems,
-                &page.frame,
-                NonZeroUsize::new(1 + i).unwrap(),
-                Transform::identity(),
-            );
-        }
-
-        self.finalize(elems)
-    }
-
-    /// Build an introspector for an HTML document.
-    fn build_html(mut self, output: &[HtmlNode]) -> Introspector {
-        let mut elems = Vec::new();
-        self.discover_in_html(&mut elems, output);
-        self.finalize(elems)
-    }
-
     /// Processes the tags in the frame.
-    fn discover_in_frame(
+    pub fn discover_in_frame(
         &mut self,
         sink: &mut Vec<Pair>,
         frame: &Frame,
@@ -433,29 +391,13 @@ impl IntrospectorBuilder {
         }
     }
 
-    /// Processes the tags in the HTML element.
-    fn discover_in_html(&mut self, sink: &mut Vec<Pair>, nodes: &[HtmlNode]) {
-        for node in nodes {
-            match node {
-                HtmlNode::Tag(tag) => self.discover_in_tag(
-                    sink,
-                    tag,
-                    Position { page: NonZeroUsize::ONE, point: Point::zero() },
-                ),
-                HtmlNode::Text(_, _) => {}
-                HtmlNode::Element(elem) => self.discover_in_html(sink, &elem.children),
-                HtmlNode::Frame(frame) => self.discover_in_frame(
-                    sink,
-                    &frame.inner,
-                    NonZeroUsize::ONE,
-                    Transform::identity(),
-                ),
-            }
-        }
-    }
-
     /// Handle a tag.
-    fn discover_in_tag(&mut self, sink: &mut Vec<Pair>, tag: &Tag, position: Position) {
+    pub fn discover_in_tag(
+        &mut self,
+        sink: &mut Vec<Pair>,
+        tag: &Tag,
+        position: Position,
+    ) {
         match tag {
             Tag::Start(elem) => {
                 let loc = elem.location().unwrap();
@@ -471,7 +413,7 @@ impl IntrospectorBuilder {
 
     /// Build a complete introspector with all acceleration structures from a
     /// list of top-level pairs.
-    fn finalize(mut self, root: Vec<Pair>) -> Introspector {
+    pub fn finalize(mut self, root: Vec<Pair>) -> Introspector {
         self.locations.reserve(self.seen.len());
 
         // Save all pairs and their descendants in the correct order.
diff --git a/crates/typst-library/src/lib.rs b/crates/typst-library/src/lib.rs
index 5d047570b..025e997c6 100644
--- a/crates/typst-library/src/lib.rs
+++ b/crates/typst-library/src/lib.rs
@@ -15,7 +15,6 @@ extern crate self as typst_library;
 pub mod diag;
 pub mod engine;
 pub mod foundations;
-pub mod html;
 pub mod introspection;
 pub mod layout;
 pub mod loading;
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs
index a81806fd5..01964800f 100644
--- a/crates/typst-library/src/routines.rs
+++ b/crates/typst-library/src/routines.rs
@@ -101,20 +101,25 @@ routines! {
 pub enum RealizationKind<'a> {
     /// This the root realization for layout. Requires a mutable reference
     /// to document metadata that will be filled from `set document` rules.
-    LayoutDocument(&'a mut DocumentInfo),
+    LayoutDocument { info: &'a mut DocumentInfo },
     /// A nested realization in a container (e.g. a `block`). Requires a mutable
     /// reference to an enum that will be set to `FragmentKind::Inline` if the
     /// fragment's content was fully inline.
-    LayoutFragment(&'a mut FragmentKind),
+    LayoutFragment { kind: &'a mut FragmentKind },
     /// A nested realization in a paragraph (i.e. a `par`)
     LayoutPar,
-    /// This the root realization for HTML. Requires a mutable reference
-    /// to document metadata that will be filled from `set document` rules.
-    HtmlDocument(&'a mut DocumentInfo),
+    /// This the root realization for HTML. Requires a mutable reference to
+    /// document metadata that will be filled from `set document` rules.
+    ///
+    /// The `is_inline` function checks whether content consists of an inline
+    /// HTML element. It's used by the `PAR` grouping rules. This is slightly
+    /// hacky and might be replaced by a mechanism to supply the grouping rules
+    /// as a realization user.
+    HtmlDocument { info: &'a mut DocumentInfo, is_inline: fn(&Content) -> bool },
     /// A nested realization in a container (e.g. a `block`). Requires a mutable
     /// reference to an enum that will be set to `FragmentKind::Inline` if the
     /// fragment's content was fully inline.
-    HtmlFragment(&'a mut FragmentKind),
+    HtmlFragment { kind: &'a mut FragmentKind, is_inline: fn(&Content) -> bool },
     /// A realization within math.
     Math,
 }
@@ -122,18 +127,20 @@ pub enum RealizationKind<'a> {
 impl RealizationKind<'_> {
     /// It this a realization for HTML export?
     pub fn is_html(&self) -> bool {
-        matches!(self, Self::HtmlDocument(_) | Self::HtmlFragment(_))
+        matches!(self, Self::HtmlDocument { .. } | Self::HtmlFragment { .. })
     }
 
     /// It this a realization for a container?
     pub fn is_fragment(&self) -> bool {
-        matches!(self, Self::LayoutFragment(_) | Self::HtmlFragment(_))
+        matches!(self, Self::LayoutFragment { .. } | Self::HtmlFragment { .. })
     }
 
     /// If this is a document-level realization, accesses the document info.
     pub fn as_document_mut(&mut self) -> Option<&mut DocumentInfo> {
         match self {
-            Self::LayoutDocument(info) | Self::HtmlDocument(info) => Some(*info),
+            Self::LayoutDocument { info } | Self::HtmlDocument { info, .. } => {
+                Some(*info)
+            }
             _ => None,
         }
     }
@@ -141,7 +148,9 @@ impl RealizationKind<'_> {
     /// If this is a container-level realization, accesses the fragment kind.
     pub fn as_fragment_mut(&mut self) -> Option<&mut FragmentKind> {
         match self {
-            Self::LayoutFragment(kind) | Self::HtmlFragment(kind) => Some(*kind),
+            Self::LayoutFragment { kind } | Self::HtmlFragment { kind, .. } => {
+                Some(*kind)
+            }
             _ => None,
         }
     }
diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index 6af249cc3..5d9e0a23a 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -18,7 +18,6 @@ use typst_library::foundations::{
     RecipeIndex, Selector, SequenceElem, ShowSet, Style, StyleChain, StyledElem, Styles,
     SymbolElem, Synthesize, TargetElem, Transformation,
 };
-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,
@@ -48,16 +47,16 @@ pub fn realize<'a>(
         locator,
         arenas,
         rules: match kind {
-            RealizationKind::LayoutDocument(_) => LAYOUT_RULES,
-            RealizationKind::LayoutFragment(_) => LAYOUT_RULES,
+            RealizationKind::LayoutDocument { .. } => LAYOUT_RULES,
+            RealizationKind::LayoutFragment { .. } => LAYOUT_RULES,
             RealizationKind::LayoutPar => LAYOUT_PAR_RULES,
-            RealizationKind::HtmlDocument(_) => HTML_DOCUMENT_RULES,
-            RealizationKind::HtmlFragment(_) => HTML_FRAGMENT_RULES,
+            RealizationKind::HtmlDocument { .. } => HTML_DOCUMENT_RULES,
+            RealizationKind::HtmlFragment { .. } => HTML_FRAGMENT_RULES,
             RealizationKind::Math => MATH_RULES,
         },
         sink: vec![],
         groupings: ArrayVec::new(),
-        outside: matches!(kind, RealizationKind::LayoutDocument(_)),
+        outside: matches!(kind, RealizationKind::LayoutDocument { .. }),
         may_attach: false,
         saw_parbreak: false,
         kind,
@@ -113,7 +112,7 @@ struct GroupingRule {
     /// be visible to `finish`.
     tags: bool,
     /// Defines which kinds of elements start and make up this kind of grouping.
-    trigger: fn(&Content, &RealizationKind) -> bool,
+    trigger: fn(&Content, &State) -> bool,
     /// Defines elements that may appear in the interior of the grouping, but
     /// not at the edges.
     inner: fn(&Content) -> bool,
@@ -334,13 +333,6 @@ fn visit_kind_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)
 }
 
@@ -601,7 +593,7 @@ fn visit_styled<'a>(
                 );
             }
         } else if elem == PageElem::ELEM {
-            if !matches!(s.kind, RealizationKind::LayoutDocument(_)) {
+            if !matches!(s.kind, RealizationKind::LayoutDocument { .. }) {
                 bail!(
                     style.span(),
                     "page configuration is not allowed inside of containers"
@@ -659,7 +651,7 @@ fn visit_grouping_rules<'a>(
     content: &'a Content,
     styles: StyleChain<'a>,
 ) -> SourceResult<bool> {
-    let matching = s.rules.iter().find(|&rule| (rule.trigger)(content, &s.kind));
+    let matching = s.rules.iter().find(|&rule| (rule.trigger)(content, s));
 
     // Try to continue or finish an existing grouping.
     let mut i = 0;
@@ -671,7 +663,7 @@ fn visit_grouping_rules<'a>(
 
         // If the element can be added to the active grouping, do it.
         if !active.interrupted
-            && ((active.rule.trigger)(content, &s.kind) || (active.rule.inner)(content))
+            && ((active.rule.trigger)(content, s) || (active.rule.inner)(content))
         {
             s.sink.push((content, styles));
             return Ok(true);
@@ -806,7 +798,7 @@ fn finish_innermost_grouping(s: &mut State) -> SourceResult<()> {
     let Grouping { start, rule, .. } = s.groupings.pop().unwrap();
 
     // Trim trailing non-trigger elements.
-    let trimmed = s.sink[start..].trim_end_matches(|(c, _)| !(rule.trigger)(c, &s.kind));
+    let trimmed = s.sink[start..].trim_end_matches(|(c, _)| !(rule.trigger)(c, s));
     let end = start + trimmed.len();
     let tail = s.store_slice(&s.sink[end..]);
     s.sink.truncate(end);
@@ -885,7 +877,7 @@ static TEXTUAL: GroupingRule = GroupingRule {
 static PAR: GroupingRule = GroupingRule {
     priority: 1,
     tags: true,
-    trigger: |content, kind| {
+    trigger: |content, state| {
         let elem = content.elem();
         elem == TextElem::ELEM
             || elem == HElem::ELEM
@@ -893,10 +885,11 @@ static PAR: GroupingRule = GroupingRule {
             || elem == SmartQuoteElem::ELEM
             || elem == InlineElem::ELEM
             || elem == BoxElem::ELEM
-            || (kind.is_html()
-                && content
-                    .to_packed::<HtmlElem>()
-                    .is_some_and(|elem| tag::is_inline_by_default(elem.tag)))
+            || match state.kind {
+                RealizationKind::HtmlDocument { is_inline, .. }
+                | RealizationKind::HtmlFragment { is_inline, .. } => is_inline(content),
+                _ => false,
+            }
     },
     inner: |content| content.elem() == SpaceElem::ELEM,
     interrupt: |elem| elem == ParElem::ELEM || elem == AlignElem::ELEM,
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index 591e5a9b9..8b4e60eee 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -43,12 +43,12 @@ use std::sync::LazyLock;
 
 use comemo::{Track, Tracked, Validate};
 use ecow::{eco_format, eco_vec, EcoString, EcoVec};
+use typst_html::HtmlDocument;
 use typst_library::diag::{
     bail, warning, FileError, SourceDiagnostic, SourceResult, Warned,
 };
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{NativeRuleMap, StyleChain, Styles, Value};
-use typst_library::html::HtmlDocument;
 use typst_library::introspection::Introspector;
 use typst_library::layout::PagedDocument;
 use typst_library::routines::Routines;
diff --git a/tests/src/run.rs b/tests/src/run.rs
index 1d93ba392..9af5c7899 100644
--- a/tests/src/run.rs
+++ b/tests/src/run.rs
@@ -5,10 +5,10 @@ use std::path::PathBuf;
 use ecow::eco_vec;
 use tiny_skia as sk;
 use typst::diag::{SourceDiagnostic, SourceResult, Warned};
-use typst::html::HtmlDocument;
 use typst::layout::{Abs, Frame, FrameItem, PagedDocument, Transform};
 use typst::visualize::Color;
 use typst::{Document, WorldExt};
+use typst_html::HtmlDocument;
 use typst_pdf::PdfOptions;
 use typst_syntax::{FileId, Lines};
 

From 275012d7c624be85173315286752888e20996072 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Thu, 10 Jul 2025 12:54:06 +0200
Subject: [PATCH 074/101] Handle `lower` and `upper` in HTML export (#6585)

---
 crates/typst-html/src/convert.rs       |  7 ++++++-
 tests/ref/html/cases-content-html.html | 10 ++++++++++
 tests/suite/text/case.typ              |  4 ++++
 3 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 tests/ref/html/cases-content-html.html

diff --git a/crates/typst-html/src/convert.rs b/crates/typst-html/src/convert.rs
index 49995e0aa..171b4cb7e 100644
--- a/crates/typst-html/src/convert.rs
+++ b/crates/typst-html/src/convert.rs
@@ -86,7 +86,12 @@ fn handle(
     } else if child.is::<SpaceElem>() {
         output.push(HtmlNode::text(' ', child.span()));
     } else if let Some(elem) = child.to_packed::<TextElem>() {
-        output.push(HtmlNode::text(elem.text.clone(), elem.span()));
+        let text = if let Some(case) = styles.get(TextElem::case) {
+            case.apply(&elem.text).into()
+        } else {
+            elem.text.clone()
+        };
+        output.push(HtmlNode::text(text, elem.span()));
     } else if let Some(elem) = child.to_packed::<LinebreakElem>() {
         output.push(HtmlElement::new(tag::br).spanned(elem.span()).into());
     } else if let Some(elem) = child.to_packed::<SmartQuoteElem>() {
diff --git a/tests/ref/html/cases-content-html.html b/tests/ref/html/cases-content-html.html
new file mode 100644
index 000000000..0890f061a
--- /dev/null
+++ b/tests/ref/html/cases-content-html.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <p>my <strong>lower</strong> a<br>MY <strong>UPPER</strong> A<br></p>
+  </body>
+</html>
diff --git a/tests/suite/text/case.typ b/tests/suite/text/case.typ
index 964ff28b6..c045ce7a6 100644
--- a/tests/suite/text/case.typ
+++ b/tests/suite/text/case.typ
@@ -14,6 +14,10 @@
 // Check that cases are applied to symbols nested in content
 #lower($H I !$.body)
 
+--- cases-content-html html ---
+#lower[MY #html.strong[Lower] #symbol("A")] \
+#upper[my #html.strong[Upper] #symbol("a")] \
+
 --- upper-bad-type ---
 // Error: 8-9 expected string or content, found integer
 #upper(1)

From 70710deb2b813eacc79d57436f5bd4c15c215f2e Mon Sep 17 00:00:00 2001
From: "Said A." <47973576+Daaiid@users.noreply.github.com>
Date: Thu, 10 Jul 2025 15:15:19 +0200
Subject: [PATCH 075/101] Deduplicate labels for code completion (#6516)

---
 crates/typst-ide/src/analyze.rs  | 10 ++++++++++
 crates/typst-ide/src/complete.rs | 19 +++++++++++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/crates/typst-ide/src/analyze.rs b/crates/typst-ide/src/analyze.rs
index 76739fec0..e9fb8a7d7 100644
--- a/crates/typst-ide/src/analyze.rs
+++ b/crates/typst-ide/src/analyze.rs
@@ -1,3 +1,5 @@
+use std::collections::HashSet;
+
 use comemo::Track;
 use ecow::{eco_vec, EcoString, EcoVec};
 use typst::foundations::{Label, Styles, Value};
@@ -66,14 +68,22 @@ pub fn analyze_import(world: &dyn IdeWorld, source: &LinkedNode) -> Option<Value
 /// - All labels and descriptions for them, if available
 /// - A split offset: All labels before this offset belong to nodes, all after
 ///   belong to a bibliography.
+///
+/// Note: When multiple labels in the document have the same identifier,
+/// this only returns the first one.
 pub fn analyze_labels(
     document: &PagedDocument,
 ) -> (Vec<(Label, Option<EcoString>)>, usize) {
     let mut output = vec![];
+    let mut seen_labels = HashSet::new();
 
     // Labels in the document.
     for elem in document.introspector.all() {
         let Some(label) = elem.label() else { continue };
+        if !seen_labels.insert(label) {
+            continue;
+        }
+
         let details = elem
             .to_packed::<FigureElem>()
             .and_then(|figure| match figure.caption.as_option() {
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index bc5b3e10e..0a560eb53 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -76,7 +76,7 @@ pub struct Completion {
 }
 
 /// A kind of item that can be completed.
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub enum CompletionKind {
     /// A syntactical structure.
@@ -1564,7 +1564,7 @@ mod tests {
 
     use typst::layout::PagedDocument;
 
-    use super::{autocomplete, Completion};
+    use super::{autocomplete, Completion, CompletionKind};
     use crate::tests::{FilePos, TestWorld, WorldLike};
 
     /// Quote a string.
@@ -1709,6 +1709,21 @@ mod tests {
             .must_exclude(["bib"]);
     }
 
+    #[test]
+    fn test_autocomplete_ref_identical_labels_returns_single_completion() {
+        let mut world = TestWorld::new("x<test> y<test>");
+        let doc = typst::compile(&world).output.ok();
+
+        let end = world.main.text().len();
+        world.main.edit(end..end, " @t");
+
+        let result = test_with_doc(&world, -1, doc.as_ref());
+        let completions = result.completions();
+        let label_count =
+            completions.iter().filter(|c| c.kind == CompletionKind::Label).count();
+        assert_eq!(label_count, 1);
+    }
+
     /// Test what kind of brackets we autocomplete for function calls depending
     /// on the function and existing parens.
     #[test]

From 0264534928864c7aed0466d670824ac0ce5ca1a8 Mon Sep 17 00:00:00 2001
From: "Said A." <47973576+Daaiid@users.noreply.github.com>
Date: Thu, 10 Jul 2025 17:02:23 +0200
Subject: [PATCH 076/101] Fix regression in reference autocomplete (#6586)

---
 crates/typst-ide/src/complete.rs | 45 ++++++++++++++++++++++++++------
 1 file changed, 37 insertions(+), 8 deletions(-)

diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index 0a560eb53..5b6d6fd97 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -130,7 +130,14 @@ fn complete_markup(ctx: &mut CompletionContext) -> bool {
         return true;
     }
 
-    // Start of a reference: "@|" or "@he|".
+    // Start of a reference: "@|".
+    if ctx.leaf.kind() == SyntaxKind::Text && ctx.before.ends_with("@") {
+        ctx.from = ctx.cursor;
+        ctx.label_completions();
+        return true;
+    }
+
+    // An existing reference: "@he|".
     if ctx.leaf.kind() == SyntaxKind::RefMarker {
         ctx.from = ctx.leaf.offset() + 1;
         ctx.label_completions();
@@ -1644,6 +1651,19 @@ mod tests {
         test_with_doc(world, pos, doc.as_ref())
     }
 
+    #[track_caller]
+    fn test_with_addition(
+        initial_text: &str,
+        addition: &str,
+        pos: impl FilePos,
+    ) -> Response {
+        let mut world = TestWorld::new(initial_text);
+        let doc = typst::compile(&world).output.ok();
+        let end = world.main.text().len();
+        world.main.edit(end..end, addition);
+        test_with_doc(&world, pos, doc.as_ref())
+    }
+
     #[track_caller]
     fn test_with_doc(
         world: impl WorldLike,
@@ -1709,15 +1729,24 @@ mod tests {
             .must_exclude(["bib"]);
     }
 
+    #[test]
+    fn test_autocomplete_ref_function() {
+        test_with_addition("x<test>", " #ref(<)", -2).must_include(["test"]);
+    }
+
+    #[test]
+    fn test_autocomplete_ref_shorthand() {
+        test_with_addition("x<test>", " @", -1).must_include(["test"]);
+    }
+
+    #[test]
+    fn test_autocomplete_ref_shorthand_with_partial_identifier() {
+        test_with_addition("x<test>", " @te", -1).must_include(["test"]);
+    }
+
     #[test]
     fn test_autocomplete_ref_identical_labels_returns_single_completion() {
-        let mut world = TestWorld::new("x<test> y<test>");
-        let doc = typst::compile(&world).output.ok();
-
-        let end = world.main.text().len();
-        world.main.edit(end..end, " @t");
-
-        let result = test_with_doc(&world, -1, doc.as_ref());
+        let result = test_with_addition("x<test> y<test>", " @t", -1);
         let completions = result.completions();
         let label_count =
             completions.iter().filter(|c| c.kind == CompletionKind::Label).count();

From b1a091a236a1dbb16f61748828fabd8ec5210d0f Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Mon, 14 Jul 2025 15:26:10 +0200
Subject: [PATCH 077/101] Use "whitespace" instead of "space" to denote
 block-level equation in docs (#6591)

---
 crates/typst-library/src/math/equation.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/typst-library/src/math/equation.rs b/crates/typst-library/src/math/equation.rs
index a2ae54471..db5253834 100644
--- a/crates/typst-library/src/math/equation.rs
+++ b/crates/typst-library/src/math/equation.rs
@@ -20,8 +20,8 @@ use crate::text::{FontFamily, FontList, FontWeight, LocalName, TextElem};
 /// A mathematical equation.
 ///
 /// Can be displayed inline with text or as a separate block. An equation
-/// becomes block-level through the presence of at least one space after the
-/// opening dollar sign and one space before the closing dollar sign.
+/// becomes block-level through the presence of whitespace after the opening
+/// dollar sign and whitespace before the closing dollar sign.
 ///
 /// # Example
 /// ```example
@@ -41,9 +41,9 @@ use crate::text::{FontFamily, FontList, FontWeight, LocalName, TextElem};
 ///
 /// # Syntax
 /// This function also has dedicated syntax: Write mathematical markup within
-/// dollar signs to create an equation. Starting and ending the equation with at
-/// least one space lifts it into a separate block that is centered
-/// horizontally. For more details about math syntax, see the
+/// dollar signs to create an equation. Starting and ending the equation with
+/// whitespace lifts it into a separate block that is centered horizontally.
+/// For more details about math syntax, see the
 /// [main math page]($category/math).
 #[elem(Locatable, Synthesize, ShowSet, Count, LocalName, Refable, Outlinable)]
 pub struct EquationElem {

From 0c12828c9a9bdb1a344b38e08fffcf2e47c0cfc0 Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Mon, 14 Jul 2025 15:26:25 +0200
Subject: [PATCH 078/101] Fix minor typo in text docs (#6589)

---
 crates/typst-library/src/text/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index 51663633f..c2efe210b 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -92,7 +92,7 @@ pub(super) fn define(global: &mut Scope) {
 /// ```
 #[elem(Debug, Construct, PlainText, Repr)]
 pub struct TextElem {
-    /// A font family descriptor or priority list of font family descriptor.
+    /// A font family descriptor or priority list of font family descriptors.
     ///
     /// A font family descriptor can be a plain string representing the family
     /// name or a dictionary with the following keys:

From f51cb4b03e9712b8eb404f8184a17ee4a63aaab2 Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Mon, 14 Jul 2025 15:31:27 +0200
Subject: [PATCH 079/101] Rephrase docs for truncation of float/decimal to
 integer (#6543)

---
 crates/typst-library/src/foundations/int.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-library/src/foundations/int.rs b/crates/typst-library/src/foundations/int.rs
index f65641ff1..13f457a11 100644
--- a/crates/typst-library/src/foundations/int.rs
+++ b/crates/typst-library/src/foundations/int.rs
@@ -46,7 +46,7 @@ impl i64 {
     /// or smaller than the minimum 64-bit signed integer.
     ///
     /// - Booleans are converted to `0` or `1`.
-    /// - Floats and decimals are truncated to the next 64-bit integer.
+    /// - Floats and decimals are rounded to the next 64-bit integer towards zero.
     /// - Strings are parsed in base 10.
     ///
     /// ```example

From 9a6268050fb769e18c4889fa5f59d4150e8878d6 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 15 Jul 2025 16:48:31 +0200
Subject: [PATCH 080/101] HTML frame improvements (#6605)

---
 crates/typst-html/src/convert.rs |  5 +---
 crates/typst-html/src/dom.rs     | 10 ++++++-
 crates/typst-html/src/encode.rs  | 11 ++------
 crates/typst-svg/src/lib.rs      | 48 +++++++++++++++++++++++++++++---
 tests/ref/html/html-frame.html   | 11 ++++++++
 tests/suite/html/frame.typ       |  5 ++--
 6 files changed, 70 insertions(+), 20 deletions(-)
 create mode 100644 tests/ref/html/html-frame.html

diff --git a/crates/typst-html/src/convert.rs b/crates/typst-html/src/convert.rs
index 171b4cb7e..817b0f025 100644
--- a/crates/typst-html/src/convert.rs
+++ b/crates/typst-html/src/convert.rs
@@ -109,10 +109,7 @@ fn handle(
             styles.chain(&style),
             Region::new(Size::splat(Abs::inf()), Axes::splat(false)),
         )?;
-        output.push(HtmlNode::Frame(HtmlFrame {
-            inner: frame,
-            text_size: styles.resolve(TextElem::size),
-        }));
+        output.push(HtmlNode::Frame(HtmlFrame::new(frame, styles)));
     } else {
         engine.sink.warn(warning!(
             child.span(),
diff --git a/crates/typst-html/src/dom.rs b/crates/typst-html/src/dom.rs
index cf74e1bfc..d7287d42d 100644
--- a/crates/typst-html/src/dom.rs
+++ b/crates/typst-html/src/dom.rs
@@ -2,10 +2,11 @@ use std::fmt::{self, Debug, Display, Formatter};
 
 use ecow::{EcoString, EcoVec};
 use typst_library::diag::{bail, HintedStrResult, StrResult};
-use typst_library::foundations::{cast, Dict, Repr, Str};
+use typst_library::foundations::{cast, Dict, Repr, Str, StyleChain};
 use typst_library::introspection::{Introspector, Tag};
 use typst_library::layout::{Abs, Frame};
 use typst_library::model::DocumentInfo;
+use typst_library::text::TextElem;
 use typst_syntax::Span;
 use typst_utils::{PicoStr, ResolvedPicoStr};
 
@@ -279,3 +280,10 @@ pub struct HtmlFrame {
     /// consistently.
     pub text_size: Abs,
 }
+
+impl HtmlFrame {
+    /// Wraps a laid-out frame.
+    pub fn new(inner: Frame, styles: StyleChain) -> Self {
+        Self { inner, text_size: styles.resolve(TextElem::size) }
+    }
+}
diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index be8137399..4447186b8 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -121,6 +121,7 @@ fn write_children(w: &mut Writer, element: &HtmlElement) -> SourceResult<()> {
     let pretty_inside = allows_pretty_inside(element.tag)
         && element.children.iter().any(|node| match node {
             HtmlNode::Element(child) => wants_pretty_around(child.tag),
+            HtmlNode::Frame(_) => true,
             _ => false,
         });
 
@@ -305,14 +306,6 @@ fn write_escape(w: &mut Writer, c: char) -> StrResult<()> {
 
 /// Encode a laid out frame into the writer.
 fn write_frame(w: &mut Writer, frame: &HtmlFrame) {
-    // FIXME: This string replacement is obviously a hack.
-    let svg = typst_svg::svg_frame(&frame.inner).replace(
-        "<svg class",
-        &format!(
-            "<svg style=\"overflow: visible; width: {}em; height: {}em;\" class",
-            frame.inner.width() / frame.text_size,
-            frame.inner.height() / frame.text_size,
-        ),
-    );
+    let svg = typst_svg::svg_html_frame(&frame.inner, frame.text_size);
     w.buf.push_str(&svg);
 }
diff --git a/crates/typst-svg/src/lib.rs b/crates/typst-svg/src/lib.rs
index 3931b67f7..cac31ebd2 100644
--- a/crates/typst-svg/src/lib.rs
+++ b/crates/typst-svg/src/lib.rs
@@ -45,6 +45,30 @@ pub fn svg_frame(frame: &Frame) -> String {
     renderer.finalize()
 }
 
+/// Export a frame into an SVG suitable for embedding into HTML.
+#[typst_macros::time(name = "svg html frame")]
+pub fn svg_html_frame(frame: &Frame, text_size: Abs) -> String {
+    let mut renderer = SVGRenderer::with_options(xmlwriter::Options {
+        indent: xmlwriter::Indent::None,
+        ..Default::default()
+    });
+    renderer.write_header_with_custom_attrs(frame.size(), |xml| {
+        xml.write_attribute("class", "typst-frame");
+        xml.write_attribute_fmt(
+            "style",
+            format_args!(
+                "overflow: visible; width: {}em; height: {}em;",
+                frame.width() / text_size,
+                frame.height() / text_size,
+            ),
+        );
+    });
+
+    let state = State::new(frame.size(), Transform::identity());
+    renderer.render_frame(state, Transform::identity(), frame);
+    renderer.finalize()
+}
+
 /// Export a document with potentially multiple pages into a single SVG file.
 ///
 /// The padding will be added around and between the individual frames.
@@ -158,8 +182,13 @@ impl State {
 impl SVGRenderer {
     /// Create a new SVG renderer with empty glyph and clip path.
     fn new() -> Self {
+        Self::with_options(Default::default())
+    }
+
+    /// Create a new SVG renderer with the given configuration.
+    fn with_options(options: xmlwriter::Options) -> Self {
         SVGRenderer {
-            xml: XmlWriter::new(xmlwriter::Options::default()),
+            xml: XmlWriter::new(options),
             glyphs: Deduplicator::new('g'),
             clip_paths: Deduplicator::new('c'),
             gradient_refs: Deduplicator::new('g'),
@@ -170,11 +199,22 @@ impl SVGRenderer {
         }
     }
 
-    /// Write the SVG header, including the `viewBox` and `width` and `height`
-    /// attributes.
+    /// Write the default SVG header, including a `typst-doc` class, the
+    /// `viewBox` and `width` and `height` attributes.
     fn write_header(&mut self, size: Size) {
+        self.write_header_with_custom_attrs(size, |xml| {
+            xml.write_attribute("class", "typst-doc");
+        });
+    }
+
+    /// Write the SVG header with additional attributes and standard attributes.
+    fn write_header_with_custom_attrs(
+        &mut self,
+        size: Size,
+        write_custom_attrs: impl FnOnce(&mut XmlWriter),
+    ) {
         self.xml.start_element("svg");
-        self.xml.write_attribute("class", "typst-doc");
+        write_custom_attrs(&mut self.xml);
         self.xml.write_attribute_fmt(
             "viewBox",
             format_args!("0 0 {} {}", size.x.to_pt(), size.y.to_pt()),
diff --git a/tests/ref/html/html-frame.html b/tests/ref/html/html-frame.html
new file mode 100644
index 000000000..f19ef4b88
--- /dev/null
+++ b/tests/ref/html/html-frame.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>A rectangle:</p>
+    <svg class="typst-frame" style="overflow: visible; width: 4.5em; height: 3em;" viewBox="0 0 45 30" width="45pt" height="30pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml"><g><g transform="translate(-0 -0)"><path class="typst-shape" fill="none" stroke="#000000" stroke-width="1" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" d="M 0 0 L 0 30 L 45 30 L 45 0 Z "/></g></g></svg>
+  </body>
+</html>
diff --git a/tests/suite/html/frame.typ b/tests/suite/html/frame.typ
index 711933d76..e389dc5d6 100644
--- a/tests/suite/html/frame.typ
+++ b/tests/suite/html/frame.typ
@@ -1,5 +1,6 @@
-// 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 html ---
+A rectangle:
+#html.frame(rect())
 
 --- html-frame-in-layout ---
 // Ensure that HTML frames are transparent in layout. This is less important for

From cdbf60e883413d6ffbd1575d18439b02046e0069 Mon Sep 17 00:00:00 2001
From: Malo <57839069+MDLC01@users.noreply.github.com>
Date: Wed, 16 Jul 2025 09:05:52 +0100
Subject: [PATCH 081/101] Change `enum.item.number` to `Smart` instead of
 `Option` (#6609)

---
 crates/typst-eval/src/markup.rs         |   2 +-
 crates/typst-html/src/rules.rs          |   2 +-
 crates/typst-library/src/model/enum.rs  |   2 +-
 tests/ref/enum-item-number-optional.png | Bin 0 -> 474 bytes
 tests/suite/model/enum.typ              |   6 +++++-
 5 files changed, 8 insertions(+), 4 deletions(-)
 create mode 100644 tests/ref/enum-item-number-optional.png

diff --git a/crates/typst-eval/src/markup.rs b/crates/typst-eval/src/markup.rs
index cc9606269..baa548459 100644
--- a/crates/typst-eval/src/markup.rs
+++ b/crates/typst-eval/src/markup.rs
@@ -251,7 +251,7 @@ impl Eval for ast::EnumItem<'_> {
         let body = self.body().eval(vm)?;
         let mut elem = EnumItem::new(body);
         if let Some(number) = self.number() {
-            elem.number.set(Some(number));
+            elem.number.set(Smart::Custom(number));
         }
         Ok(elem.pack())
     }
diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index 04a58ca47..0fe5bd087 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -103,7 +103,7 @@ const ENUM_RULE: ShowFn<EnumElem> = |elem, _, styles| {
 
     let body = Content::sequence(elem.children.iter().map(|item| {
         let mut li = HtmlElem::new(tag::li);
-        if let Some(nr) = item.number.get(styles) {
+        if let Smart::Custom(nr) = item.number.get(styles) {
             li = li.with_attr(attr::value, eco_format!("{nr}"));
         }
         // Text in wide enums shall always turn into paragraphs.
diff --git a/crates/typst-library/src/model/enum.rs b/crates/typst-library/src/model/enum.rs
index 388fb9eda..93a2c1dc6 100644
--- a/crates/typst-library/src/model/enum.rs
+++ b/crates/typst-library/src/model/enum.rs
@@ -220,7 +220,7 @@ impl EnumElem {
 pub struct EnumItem {
     /// The item's number.
     #[positional]
-    pub number: Option<u64>,
+    pub number: Smart<u64>,
 
     /// The item's body.
     #[required]
diff --git a/tests/ref/enum-item-number-optional.png b/tests/ref/enum-item-number-optional.png
new file mode 100644
index 0000000000000000000000000000000000000000..2f30566caa355d9ed711ba504ba3136695892727
GIT binary patch
literal 474
zcmV<00VV#4P)<h;3K|Lk000e1NJLTq004LZ001Zm000005P@O&0004@Nkl<Zc-rmM
z+be@{9LI70igF{T9B&Zfg4`*@Qqs7PLrtj37TTm(PLtZWz?>(<LRM=lxmeqx7F)Ay
zX0lnEcF;~Awd}dt<?~GO`&_;6Uj2R--wgcHG6+my0uz`PSV`4Hv6wA+kRv%4lW=S{
zlWKc4phS#v8<>4@1y#<f&@KckuJ(O4mPF?#1)J%DbGABg#zVI>WNHcCxf_u#xCU`t
z^3baTL?uka@hm_aOr*IK!0|9THBh)!liu0@lkjHWDVFSsTo_OTLau&f28LOw2cui$
zfDria!V#T^cKGG+EtwzU#eSrmulj~=_;K1_o@{{*$4I@wTe@Md3x$!Nme<>W(7NOq
zs<k=T=9bNYAtjd&$kvN#hk+w0m3ujSa87rc-dWfV)P;R{aXvR%|0!Psn|@fm0Z@zP
znsc>=r=t-doDEbugePEG`mPxGYR5Qaep5Kn9H9NRO#%0PQP>sCx1lV?KR~ll#6#-^
z-SBlAs|x~aqF1LjG_dr{8zJl8gLO=-_YMl3-I6bkaAuKQE&>yn!2cBf2AgM3x~{-?
QrT_o{07*qoM6N<$f?)dEJ^%m!

literal 0
HcmV?d00001

diff --git a/tests/suite/model/enum.typ b/tests/suite/model/enum.typ
index 7ee4dc20c..f7e097bda 100644
--- a/tests/suite/model/enum.typ
+++ b/tests/suite/model/enum.typ
@@ -56,6 +56,10 @@ a + 0.
    enum.item(5)[Fifth]
 )
 
+--- enum-item-number-optional ---
+#enum.item[First]
+#enum.item[Second]
+
 --- enum-numbering-pattern ---
 // Test numbering pattern.
 #set enum(numbering: "(1.a.*)")
@@ -217,7 +221,7 @@ a + 0.
 
 --- issue-2530-enum-item-panic ---
 // Enum item (pre-emptive)
-#enum.item(none)[Hello]
+#enum.item(auto)[Hello]
 #enum.item(17)[Hello]
 
 --- issue-5503-enum-in-align ---

From ea5272bb2b6461757f25c6b59d3ea9eb02e92dbc Mon Sep 17 00:00:00 2001
From: "Y.D.X." <73375426+YDX-2147483647@users.noreply.github.com>
Date: Wed, 16 Jul 2025 16:10:21 +0800
Subject: [PATCH 082/101] Support setting fonts repeatedly with different
 `covers` (#6604)

---
 crates/typst-layout/src/inline/shaping.rs |   9 ++++++-
 tests/ref/text-font-covers-repeat.png     | Bin 0 -> 467 bytes
 tests/ref/text-font-covers-riffle.png     | Bin 0 -> 1603 bytes
 tests/suite/text/font.typ                 |  28 ++++++++++++++++++++++
 4 files changed, 36 insertions(+), 1 deletion(-)
 create mode 100644 tests/ref/text-font-covers-repeat.png
 create mode 100644 tests/ref/text-font-covers-riffle.png

diff --git a/crates/typst-layout/src/inline/shaping.rs b/crates/typst-layout/src/inline/shaping.rs
index d1e748da8..a8f2bcaba 100644
--- a/crates/typst-layout/src/inline/shaping.rs
+++ b/crates/typst-layout/src/inline/shaping.rs
@@ -719,6 +719,10 @@ fn glyphs_width(glyphs: &[ShapedGlyph]) -> Abs {
 struct ShapingContext<'a, 'v> {
     engine: &'a Engine<'v>,
     glyphs: Vec<ShapedGlyph>,
+    /// Font families that have been used with unlimited coverage.
+    ///
+    /// These font families are considered exhausted and will not be used again,
+    /// even if they are declared again (e.g., during fallback after normal selection).
     used: Vec<Font>,
     styles: StyleChain<'a>,
     size: Abs,
@@ -777,7 +781,10 @@ fn shape_segment<'a>(
         return;
     };
 
-    ctx.used.push(font.clone());
+    // This font has been exhausted and will not be used again.
+    if covers.is_none() {
+        ctx.used.push(font.clone());
+    }
 
     // Fill the buffer with our text.
     let mut buffer = UnicodeBuffer::new();
diff --git a/tests/ref/text-font-covers-repeat.png b/tests/ref/text-font-covers-repeat.png
new file mode 100644
index 0000000000000000000000000000000000000000..aceb8d007934e2747f6d2282a9f73d90d56098db
GIT binary patch
literal 467
zcmV;^0WAKBP)<h;3K|Lk000e1NJLTq004LZ000{Z00000l5Z6H0004+Nkl<Zc-rmM
z-7BjB0Dy6S#<@IoI_LgeojS)U$^|###z)L&N)7X|(U|W@v=+(72xY8xL2sn+G8(0c
zCSnL>-q_@$7+zzKD;I8dF-qxu{(;}!6Tv4Hp}-2Pz+VsETqab`^^b=Wn^I#N;%sSz
zs;!c@-8kWVOazz37bZN%umSsC2B8uSyy-Bt406bH4cfP}!-T<F4|^$XDmRW%(<2-t
z%;xt|DtOZmCv_uPGp3@Tn9$w=gO;(YjL}Sh6)kuv6`$lf;eGJG+i_zc(w=MuVix&N
zUpMJH@^`<bgtQ}3hk9YWc>Wujj{8@bBMmI%)x8f^F|S{Xmpl(Z+!cQq>LJS={EN^`
z-lk}v%Um>kBB6Eg3ZK<K1Hm71xUg9Z8%a!+$UiS0y+G6{zYwbA=vn`7Y_+IXMLju^
zH5U)+X#l44L3O@uJNEk`aXy3vdul4S=-2r=^_ODV&=c$w3#;m-yQVI)Z9?NVR!ijr
zu9nUf0<8@WsiHXmTsM~Q-lz);_P30^XP8cvb1AR_EASVFUjVm!Hj|U2C9MDe002ov
JPDHLkV1g0-(BJ?7

literal 0
HcmV?d00001

diff --git a/tests/ref/text-font-covers-riffle.png b/tests/ref/text-font-covers-riffle.png
new file mode 100644
index 0000000000000000000000000000000000000000..577e4f23d9026718ec603a5be7b2585bc08d4f33
GIT binary patch
literal 1603
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
B7Ki`<

literal 0
HcmV?d00001

diff --git a/tests/suite/text/font.typ b/tests/suite/text/font.typ
index 6e21dfd23..dd61bfc86 100644
--- a/tests/suite/text/font.typ
+++ b/tests/suite/text/font.typ
@@ -135,6 +135,34 @@ I
 
 The number 123.
 
+--- text-font-covers-repeat ---
+// Repeatedly use the same font.
+#set text(font: (
+  (name: "Libertinus Serif", covers: regex("[0-9]")),
+  "Libertinus Serif"
+))
+
+The number 123.
+
+--- text-font-covers-riffle ---
+// Repeatedly use two fonts alternately.
+#set text(font: (
+  (name: "Noto Color Emoji", covers: regex("[🔗⛓‍💥]")),
+  (name: "Twitter Color Emoji", covers: regex("[^🖥️]")),
+  "Noto Color Emoji",
+))
+
+🔗⛓‍💥🖥️🔑
+
+// The above should be the same as:
+#{
+  text(font: "Noto Color Emoji", "🔗⛓‍💥🖥️")
+  text(font: "Twitter Color Emoji", "🔑")
+}
+
+// but not:
+#text(font: "Twitter Color Emoji", "🔗⛓‍💥🖥️🔑")
+
 --- text-font-covers-bad-1 ---
 // Error: 17-59 coverage regex may only use dot, letters, and character classes
 // Hint: 17-59 the regex is applied to each letter individually

From c58766440cf8daafb9596ae623eaba83ee583640 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 16 Jul 2025 10:17:42 +0200
Subject: [PATCH 083/101] Support intra-doc links in HTML (#6602)

---
 crates/typst-html/src/document.rs             |  51 ++-
 crates/typst-html/src/dom.rs                  |  25 +-
 crates/typst-html/src/encode.rs               |  24 +-
 crates/typst-html/src/lib.rs                  |  14 +
 crates/typst-html/src/link.rs                 | 290 ++++++++++++++++++
 crates/typst-html/src/rules.rs                |  43 ++-
 crates/typst-layout/src/rules.rs              |  14 +-
 .../src/introspection/introspector.rs         |  25 +-
 crates/typst-library/src/model/link.rs        |  71 ++++-
 crates/typst-library/src/model/reference.rs   |  14 +-
 crates/typst-svg/src/image.rs                 |   2 +-
 crates/typst-svg/src/lib.rs                   |  95 +++++-
 crates/typst-svg/src/paint.rs                 |   2 +-
 crates/typst-svg/src/shape.rs                 |   2 +-
 crates/typst-svg/src/text.rs                  |   2 +-
 crates/typst-utils/src/pico.rs                |  17 +
 tests/ref/html/link-html-frame-ref.html       |  11 +
 tests/ref/html/link-html-frame.html           |  15 +
 tests/ref/html/link-html-here.html            |  10 +
 tests/ref/html/link-html-id-attach.html       |  29 ++
 tests/ref/html/link-html-id-existing.html     |  11 +
 .../html/link-html-label-disambiguation.html  |  31 ++
 tests/ref/html/link-html-nested-empty.html    |  12 +
 tests/ref/html/ref-basic.html                 |  13 +
 tests/suite/model/link.typ                    | 111 +++++++
 tests/suite/model/ref.typ                     |   2 +-
 26 files changed, 861 insertions(+), 75 deletions(-)
 create mode 100644 crates/typst-html/src/link.rs
 create mode 100644 tests/ref/html/link-html-frame-ref.html
 create mode 100644 tests/ref/html/link-html-frame.html
 create mode 100644 tests/ref/html/link-html-here.html
 create mode 100644 tests/ref/html/link-html-id-attach.html
 create mode 100644 tests/ref/html/link-html-id-existing.html
 create mode 100644 tests/ref/html/link-html-label-disambiguation.html
 create mode 100644 tests/ref/html/link-html-nested-empty.html
 create mode 100644 tests/ref/html/ref-basic.html

diff --git a/crates/typst-html/src/document.rs b/crates/typst-html/src/document.rs
index 9f0124e57..c581df05f 100644
--- a/crates/typst-html/src/document.rs
+++ b/crates/typst-html/src/document.rs
@@ -1,10 +1,13 @@
+use std::collections::HashSet;
 use std::num::NonZeroUsize;
 
 use comemo::{Tracked, TrackedMut};
 use typst_library::diag::{bail, SourceResult};
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Content, StyleChain};
-use typst_library::introspection::{Introspector, IntrospectorBuilder, Locator};
+use typst_library::introspection::{
+    Introspector, IntrospectorBuilder, Location, Locator,
+};
 use typst_library::layout::{Point, Position, Transform};
 use typst_library::model::DocumentInfo;
 use typst_library::routines::{Arenas, RealizationKind, Routines};
@@ -83,42 +86,56 @@ fn html_document_impl(
         &mut locator,
         children.iter().copied(),
     )?;
-    let introspector = introspect_html(&output);
-    let root = root_element(output, &info)?;
+
+    let mut link_targets = HashSet::new();
+    let mut introspector = introspect_html(&output, &mut link_targets);
+    let mut root = root_element(output, &info)?;
+    crate::link::identify_link_targets(&mut root, &mut introspector, link_targets);
 
     Ok(HtmlDocument { info, root, introspector })
 }
 
 /// Introspects HTML nodes.
 #[typst_macros::time(name = "introspect html")]
-fn introspect_html(output: &[HtmlNode]) -> Introspector {
+fn introspect_html(
+    output: &[HtmlNode],
+    link_targets: &mut HashSet<Location>,
+) -> Introspector {
     fn discover(
         builder: &mut IntrospectorBuilder,
         sink: &mut Vec<(Content, Position)>,
+        link_targets: &mut HashSet<Location>,
         nodes: &[HtmlNode],
     ) {
         for node in nodes {
             match node {
-                HtmlNode::Tag(tag) => builder.discover_in_tag(
-                    sink,
-                    tag,
-                    Position { page: NonZeroUsize::ONE, point: Point::zero() },
-                ),
+                HtmlNode::Tag(tag) => {
+                    builder.discover_in_tag(
+                        sink,
+                        tag,
+                        Position { page: NonZeroUsize::ONE, point: Point::zero() },
+                    );
+                }
                 HtmlNode::Text(_, _) => {}
-                HtmlNode::Element(elem) => discover(builder, sink, &elem.children),
-                HtmlNode::Frame(frame) => builder.discover_in_frame(
-                    sink,
-                    &frame.inner,
-                    NonZeroUsize::ONE,
-                    Transform::identity(),
-                ),
+                HtmlNode::Element(elem) => {
+                    discover(builder, sink, link_targets, &elem.children)
+                }
+                HtmlNode::Frame(frame) => {
+                    builder.discover_in_frame(
+                        sink,
+                        &frame.inner,
+                        NonZeroUsize::ONE,
+                        Transform::identity(),
+                    );
+                    crate::link::introspect_frame_links(&frame.inner, link_targets);
+                }
             }
         }
     }
 
     let mut elems = Vec::new();
     let mut builder = IntrospectorBuilder::new();
-    discover(&mut builder, &mut elems, output);
+    discover(&mut builder, &mut elems, link_targets, output);
     builder.finalize(elems)
 }
 
diff --git a/crates/typst-html/src/dom.rs b/crates/typst-html/src/dom.rs
index d7287d42d..e7f5fcbcd 100644
--- a/crates/typst-html/src/dom.rs
+++ b/crates/typst-html/src/dom.rs
@@ -4,7 +4,7 @@ use ecow::{EcoString, EcoVec};
 use typst_library::diag::{bail, HintedStrResult, StrResult};
 use typst_library::foundations::{cast, Dict, Repr, Str, StyleChain};
 use typst_library::introspection::{Introspector, Tag};
-use typst_library::layout::{Abs, Frame};
+use typst_library::layout::{Abs, Frame, Point};
 use typst_library::model::DocumentInfo;
 use typst_library::text::TextElem;
 use typst_syntax::Span;
@@ -172,10 +172,20 @@ impl HtmlAttrs {
         Self::default()
     }
 
-    /// Add an attribute.
+    /// Adds an attribute.
     pub fn push(&mut self, attr: HtmlAttr, value: impl Into<EcoString>) {
         self.0.push((attr, value.into()));
     }
+
+    /// Adds an attribute to the start of the list.
+    pub fn push_front(&mut self, attr: HtmlAttr, value: impl Into<EcoString>) {
+        self.0.insert(0, (attr, value.into()));
+    }
+
+    /// Finds an attribute value.
+    pub fn get(&self, attr: HtmlAttr) -> Option<&EcoString> {
+        self.0.iter().find(|&&(k, _)| k == attr).map(|(_, v)| v)
+    }
 }
 
 cast! {
@@ -279,11 +289,20 @@ pub struct HtmlFrame {
     /// frame with em units to make text in and outside of the frame sized
     /// consistently.
     pub text_size: Abs,
+    /// An ID to assign to the SVG itself.
+    pub id: Option<EcoString>,
+    /// IDs to assign to destination jump points within the SVG.
+    pub link_points: Vec<(Point, EcoString)>,
 }
 
 impl HtmlFrame {
     /// Wraps a laid-out frame.
     pub fn new(inner: Frame, styles: StyleChain) -> Self {
-        Self { inner, text_size: styles.resolve(TextElem::size) }
+        Self {
+            inner,
+            text_size: styles.resolve(TextElem::size),
+            id: None,
+            link_points: vec![],
+        }
     }
 }
diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 4447186b8..02c3f16de 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -2,6 +2,7 @@ use std::fmt::Write;
 
 use typst_library::diag::{bail, At, SourceResult, StrResult};
 use typst_library::foundations::Repr;
+use typst_library::introspection::Introspector;
 use typst_syntax::Span;
 
 use crate::{
@@ -10,7 +11,7 @@ use crate::{
 
 /// Encodes an HTML document into a string.
 pub fn html(document: &HtmlDocument) -> SourceResult<String> {
-    let mut w = Writer { pretty: true, ..Writer::default() };
+    let mut w = Writer::new(&document.introspector, true);
     w.buf.push_str("<!DOCTYPE html>");
     write_indent(&mut w);
     write_element(&mut w, &document.root)?;
@@ -20,16 +21,25 @@ pub fn html(document: &HtmlDocument) -> SourceResult<String> {
     Ok(w.buf)
 }
 
-#[derive(Default)]
-struct Writer {
+/// Encodes HTML.
+struct Writer<'a> {
     /// The output buffer.
     buf: String,
     /// The current indentation level
     level: usize,
+    /// The document's introspector.
+    introspector: &'a Introspector,
     /// Whether pretty printing is enabled.
     pretty: bool,
 }
 
+impl<'a> Writer<'a> {
+    /// Creates a new writer.
+    fn new(introspector: &'a Introspector, pretty: bool) -> Self {
+        Self { buf: String::new(), level: 0, introspector, pretty }
+    }
+}
+
 /// Writes a newline and indent, if pretty printing is enabled.
 fn write_indent(w: &mut Writer) {
     if w.pretty {
@@ -306,6 +316,12 @@ fn write_escape(w: &mut Writer, c: char) -> StrResult<()> {
 
 /// Encode a laid out frame into the writer.
 fn write_frame(w: &mut Writer, frame: &HtmlFrame) {
-    let svg = typst_svg::svg_html_frame(&frame.inner, frame.text_size);
+    let svg = typst_svg::svg_html_frame(
+        &frame.inner,
+        frame.text_size,
+        frame.id.as_deref(),
+        &frame.link_points,
+        w.introspector,
+    );
     w.buf.push_str(&svg);
 }
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index d7b29dbbc..42b3c5d6f 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -8,6 +8,7 @@ mod document;
 mod dom;
 mod encode;
 mod fragment;
+mod link;
 mod rules;
 mod tag;
 mod typed;
@@ -79,6 +80,19 @@ impl HtmlElem {
         self
     }
 
+    /// Adds the attribute to the element if value is not `None`.
+    pub fn with_optional_attr(
+        self,
+        attr: HtmlAttr,
+        value: Option<impl Into<EcoString>>,
+    ) -> Self {
+        if let Some(value) = value {
+            self.with_attr(attr, value)
+        } else {
+            self
+        }
+    }
+
     /// Adds CSS styles to an element.
     fn with_styles(self, properties: css::Properties) -> Self {
         if let Some(value) = properties.into_inline_styles() {
diff --git a/crates/typst-html/src/link.rs b/crates/typst-html/src/link.rs
new file mode 100644
index 000000000..0fcbe906a
--- /dev/null
+++ b/crates/typst-html/src/link.rs
@@ -0,0 +1,290 @@
+use std::collections::{HashMap, HashSet, VecDeque};
+
+use comemo::Track;
+use ecow::{eco_format, EcoString};
+use typst_library::foundations::{Label, NativeElement};
+use typst_library::introspection::{Introspector, Location, Tag};
+use typst_library::layout::{Frame, FrameItem, Point};
+use typst_library::model::{Destination, LinkElem};
+use typst_utils::PicoStr;
+
+use crate::{attr, tag, HtmlElement, HtmlNode};
+
+/// Searches for links within a frame.
+///
+/// If all links are created via `LinkElem` in the future, this can be removed
+/// in favor of the query in `identify_link_targets`. For the time being, some
+/// links are created without existence of a `LinkElem`, so this is
+/// unfortunately necessary.
+pub fn introspect_frame_links(frame: &Frame, targets: &mut HashSet<Location>) {
+    for (_, item) in frame.items() {
+        match item {
+            FrameItem::Link(Destination::Location(loc), _) => {
+                targets.insert(*loc);
+            }
+            FrameItem::Group(group) => introspect_frame_links(&group.frame, targets),
+            _ => {}
+        }
+    }
+}
+
+/// Attaches IDs to nodes produced by link targets to make them linkable.
+///
+/// May produce `<span>`s for link targets that turned into text nodes or no
+/// nodes at all. See the [`LinkElem`] documentation for more details.
+pub fn identify_link_targets(
+    root: &mut HtmlElement,
+    introspector: &mut Introspector,
+    mut targets: HashSet<Location>,
+) {
+    // Query for all links with an intra-doc (i.e. `Location`) destination to
+    // know what needs IDs.
+    targets.extend(
+        introspector
+            .query(&LinkElem::ELEM.select())
+            .iter()
+            .map(|elem| elem.to_packed::<LinkElem>().unwrap())
+            .filter_map(|elem| match elem.dest.resolve(introspector.track()) {
+                Ok(Destination::Location(loc)) => Some(loc),
+                _ => None,
+            }),
+    );
+
+    if targets.is_empty() {
+        // Nothing to do.
+        return;
+    }
+
+    // Assign IDs to all link targets.
+    let mut work = Work::new();
+    traverse(
+        &mut work,
+        &targets,
+        &mut Identificator::new(introspector),
+        &mut root.children,
+    );
+
+    // Add the mapping from locations to IDs to the introspector to make it
+    // available to links in the next iteration.
+    introspector.set_html_ids(work.ids);
+}
+
+/// Traverses a list of nodes.
+fn traverse(
+    work: &mut Work,
+    targets: &HashSet<Location>,
+    identificator: &mut Identificator<'_>,
+    nodes: &mut Vec<HtmlNode>,
+) {
+    let mut i = 0;
+    while i < nodes.len() {
+        let node = &mut nodes[i];
+        match node {
+            // When visiting a start tag, we check whether the element needs an
+            // ID and if so, add it to the queue, so that its first child node
+            // receives an ID.
+            HtmlNode::Tag(Tag::Start(elem)) => {
+                let loc = elem.location().unwrap();
+                if targets.contains(&loc) {
+                    work.enqueue(loc, elem.label());
+                }
+            }
+
+            // When we reach an end tag, we check whether it closes an element
+            // that is still in our queue. If so, that means the element
+            // produced no nodes and we need to insert an empty span.
+            HtmlNode::Tag(Tag::End(loc, _)) => {
+                work.remove(*loc, |label| {
+                    let mut element = HtmlElement::new(tag::span);
+                    let id = identificator.assign(&mut element, label);
+                    nodes.insert(i + 1, HtmlNode::Element(element));
+                    id
+                });
+            }
+
+            // When visiting an element and the queue is non-empty, we assign an
+            // ID. Then, we traverse its children.
+            HtmlNode::Element(element) => {
+                work.drain(|label| identificator.assign(element, label));
+                traverse(work, targets, identificator, &mut element.children);
+            }
+
+            // When visiting text and the queue is non-empty, we generate a span
+            // and assign an ID.
+            HtmlNode::Text(..) => {
+                work.drain(|label| {
+                    let mut element =
+                        HtmlElement::new(tag::span).with_children(vec![node.clone()]);
+                    let id = identificator.assign(&mut element, label);
+                    *node = HtmlNode::Element(element);
+                    id
+                });
+            }
+
+            // When visiting a frame and the queue is non-empty, we assign an
+            // ID to it (will be added to the resulting SVG element).
+            HtmlNode::Frame(frame) => {
+                work.drain(|label| {
+                    frame.id.get_or_insert_with(|| identificator.identify(label)).clone()
+                });
+                traverse_frame(
+                    work,
+                    targets,
+                    identificator,
+                    &frame.inner,
+                    &mut frame.link_points,
+                );
+            }
+        }
+
+        i += 1;
+    }
+}
+
+/// Traverses a frame embedded in HTML.
+fn traverse_frame(
+    work: &mut Work,
+    targets: &HashSet<Location>,
+    identificator: &mut Identificator<'_>,
+    frame: &Frame,
+    link_points: &mut Vec<(Point, EcoString)>,
+) {
+    for (_, item) in frame.items() {
+        match item {
+            FrameItem::Tag(Tag::Start(elem)) => {
+                let loc = elem.location().unwrap();
+                if targets.contains(&loc) {
+                    let pos = identificator.introspector.position(loc).point;
+                    let id = identificator.identify(elem.label());
+                    work.ids.insert(loc, id.clone());
+                    link_points.push((pos, id));
+                }
+            }
+            FrameItem::Group(group) => {
+                traverse_frame(work, targets, identificator, &group.frame, link_points);
+            }
+            _ => {}
+        }
+    }
+}
+
+/// Keeps track of the work to be done during ID generation.
+struct Work {
+    /// The locations and labels of elements we need to assign an ID to right
+    /// now.
+    queue: VecDeque<(Location, Option<Label>)>,
+    /// The resulting mapping from element location's to HTML IDs.
+    ids: HashMap<Location, EcoString>,
+}
+
+impl Work {
+    /// Sets up.
+    fn new() -> Self {
+        Self { queue: VecDeque::new(), ids: HashMap::new() }
+    }
+
+    /// Marks the element with the given location and label as in need of an
+    /// ID. A subsequent call to `drain` will call `f`.
+    fn enqueue(&mut self, loc: Location, label: Option<Label>) {
+        self.queue.push_back((loc, label))
+    }
+
+    /// If one or multiple elements are in need of an ID, calls `f` to generate
+    /// an ID and apply it to the current node with `f`, and then establishes a
+    /// mapping from the elements' locations to that ID.
+    fn drain(&mut self, f: impl FnOnce(Option<Label>) -> EcoString) {
+        if let Some(&(_, label)) = self.queue.front() {
+            let id = f(label);
+            for (loc, _) in self.queue.drain(..) {
+                self.ids.insert(loc, id.clone());
+            }
+        }
+    }
+
+    /// Similar to `drain`, but only for a specific given location.
+    fn remove(&mut self, loc: Location, f: impl FnOnce(Option<Label>) -> EcoString) {
+        if let Some(i) = self.queue.iter().position(|&(l, _)| l == loc) {
+            let (_, label) = self.queue.remove(i).unwrap();
+            let id = f(label);
+            self.ids.insert(loc, id.clone());
+        }
+    }
+}
+
+/// Creates unique IDs for elements.
+struct Identificator<'a> {
+    introspector: &'a Introspector,
+    loc_counter: usize,
+    label_counter: HashMap<Label, usize>,
+}
+
+impl<'a> Identificator<'a> {
+    /// Creates a new identificator.
+    fn new(introspector: &'a Introspector) -> Self {
+        Self {
+            introspector,
+            loc_counter: 0,
+            label_counter: HashMap::new(),
+        }
+    }
+
+    /// Assigns an ID to an element or reuses an existing ID.
+    fn assign(&mut self, element: &mut HtmlElement, label: Option<Label>) -> EcoString {
+        element.attrs.get(attr::id).cloned().unwrap_or_else(|| {
+            let id = self.identify(label);
+            element.attrs.push_front(attr::id, id.clone());
+            id
+        })
+    }
+
+    /// Generates an ID, potentially based on a label.
+    fn identify(&mut self, label: Option<Label>) -> EcoString {
+        if let Some(label) = label {
+            let resolved = label.resolve();
+            let text = resolved.as_str();
+            if can_use_label_as_id(text) {
+                if self.introspector.label_count(label) == 1 {
+                    return text.into();
+                }
+
+                let counter = self.label_counter.entry(label).or_insert(0);
+                *counter += 1;
+                return disambiguate(self.introspector, text, counter);
+            }
+        }
+
+        self.loc_counter += 1;
+        disambiguate(self.introspector, "loc", &mut self.loc_counter)
+    }
+}
+
+/// Whether the label is both a valid CSS identifier and a valid URL fragment
+/// for linking.
+///
+/// This is slightly more restrictive than HTML and CSS, but easier to
+/// understand and explain.
+fn can_use_label_as_id(label: &str) -> bool {
+    !label.is_empty()
+        && label.chars().all(|c| c.is_alphanumeric() || matches!(c, '-' | '_'))
+        && !label.starts_with(|c: char| c.is_numeric() || c == '-')
+}
+
+/// Disambiguates `text` with the suffix `-{counter}`, while ensuring that this
+/// does not result in a collision with an existing label.
+fn disambiguate(
+    introspector: &Introspector,
+    text: &str,
+    counter: &mut usize,
+) -> EcoString {
+    loop {
+        let disambiguated = eco_format!("{text}-{counter}");
+        if PicoStr::get(&disambiguated)
+            .and_then(Label::new)
+            .is_some_and(|label| introspector.label_count(label) > 0)
+        {
+            *counter += 1;
+        } else {
+            break disambiguated;
+        }
+    }
+}
diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index 0fe5bd087..846cb5eb5 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -1,7 +1,7 @@
 use std::num::NonZeroUsize;
 
 use ecow::{eco_format, EcoVec};
-use typst_library::diag::warning;
+use typst_library::diag::{warning, At};
 use typst_library::foundations::{
     Content, NativeElement, NativeRuleMap, ShowFn, Smart, StyleChain, Target,
 };
@@ -141,20 +141,33 @@ const TERMS_RULE: ShowFn<TermsElem> = |elem, _, styles| {
 };
 
 const LINK_RULE: ShowFn<LinkElem> = |elem, engine, _| {
-    let body = elem.body.clone();
-    Ok(if let LinkTarget::Dest(Destination::Url(url)) = &elem.dest {
-        HtmlElem::new(tag::a)
-            .with_attr(attr::href, url.clone().into_inner())
-            .with_body(Some(body))
-            .pack()
-            .spanned(elem.span())
-    } else {
-        engine.sink.warn(warning!(
-            elem.span(),
-            "non-URL links are not yet supported by HTML export"
-        ));
-        body
-    })
+    let dest = elem.dest.resolve(engine.introspector).at(elem.span())?;
+
+    let href = match dest {
+        Destination::Url(url) => Some(url.clone().into_inner()),
+        Destination::Location(location) => {
+            let id = engine
+                .introspector
+                .html_id(location)
+                .cloned()
+                .ok_or("failed to determine link anchor")
+                .at(elem.span())?;
+            Some(eco_format!("#{id}"))
+        }
+        Destination::Position(_) => {
+            engine.sink.warn(warning!(
+                elem.span(),
+                "positional link was ignored during HTML export"
+            ));
+            None
+        }
+    };
+
+    Ok(HtmlElem::new(tag::a)
+        .with_optional_attr(attr::href, href)
+        .with_body(Some(elem.body.clone()))
+        .pack()
+        .spanned(elem.span()))
 };
 
 const HEADING_RULE: ShowFn<HeadingElem> = |elem, engine, styles| {
diff --git a/crates/typst-layout/src/rules.rs b/crates/typst-layout/src/rules.rs
index ebccd92e8..c78f94d55 100644
--- a/crates/typst-layout/src/rules.rs
+++ b/crates/typst-layout/src/rules.rs
@@ -20,8 +20,8 @@ use typst_library::math::EquationElem;
 use typst_library::model::{
     Attribution, BibliographyElem, CiteElem, CiteGroup, CslSource, Destination, EmphElem,
     EnumElem, FigureCaption, FigureElem, FootnoteElem, FootnoteEntry, HeadingElem,
-    LinkElem, LinkTarget, ListElem, Outlinable, OutlineElem, OutlineEntry, ParElem,
-    ParbreakElem, QuoteElem, RefElem, StrongElem, TableCell, TableElem, TermsElem, Works,
+    LinkElem, ListElem, Outlinable, OutlineElem, OutlineEntry, ParElem, ParbreakElem,
+    QuoteElem, RefElem, StrongElem, TableCell, TableElem, TermsElem, Works,
 };
 use typst_library::pdf::EmbedElem;
 use typst_library::text::{
@@ -216,14 +216,8 @@ const TERMS_RULE: ShowFn<TermsElem> = |elem, _, styles| {
 
 const LINK_RULE: ShowFn<LinkElem> = |elem, engine, _| {
     let body = elem.body.clone();
-    Ok(match &elem.dest {
-        LinkTarget::Dest(dest) => body.linked(dest.clone()),
-        LinkTarget::Label(label) => {
-            let elem = engine.introspector.query_label(*label).at(elem.span())?;
-            let dest = Destination::Location(elem.location().unwrap());
-            body.linked(dest)
-        }
-    })
+    let dest = elem.dest.resolve(engine.introspector).at(elem.span())?;
+    Ok(body.linked(dest))
 };
 
 const HEADING_RULE: ShowFn<HeadingElem> = |elem, engine, styles| {
diff --git a/crates/typst-library/src/introspection/introspector.rs b/crates/typst-library/src/introspection/introspector.rs
index de74c55f5..000fbd202 100644
--- a/crates/typst-library/src/introspection/introspector.rs
+++ b/crates/typst-library/src/introspection/introspector.rs
@@ -4,7 +4,7 @@ use std::hash::Hash;
 use std::num::NonZeroUsize;
 use std::sync::RwLock;
 
-use ecow::EcoVec;
+use ecow::{EcoString, EcoVec};
 use smallvec::SmallVec;
 use typst_utils::NonZeroExt;
 
@@ -35,6 +35,11 @@ pub struct Introspector {
     /// Accelerates lookup of elements by label.
     labels: MultiMap<Label, usize>,
 
+    /// Maps from element locations to assigned HTML IDs. This used to support
+    /// intra-doc links in HTML export. In paged export, is is simply left
+    /// empty and [`Self::html_id`] is not used.
+    html_ids: HashMap<Location, EcoString>,
+
     /// Caches queries done on the introspector. This is important because
     /// even if all top-level queries are distinct, they often have shared
     /// subqueries. Example: Individual counter queries with `before` that
@@ -51,6 +56,17 @@ impl Introspector {
         self.elems.iter().map(|(c, _)| c)
     }
 
+    /// Checks how many times a label exists.
+    pub fn label_count(&self, label: Label) -> usize {
+        self.labels.get(&label).len()
+    }
+
+    /// Enriches an existing introspector with HTML IDs, which were assigned
+    /// to the DOM in a post-processing step.
+    pub fn set_html_ids(&mut self, html_ids: HashMap<Location, EcoString>) {
+        self.html_ids = html_ids;
+    }
+
     /// Retrieves the element with the given index.
     #[track_caller]
     fn get_by_idx(&self, idx: usize) -> &Content {
@@ -268,6 +284,11 @@ impl Introspector {
         self.page_supplements.get(page.get() - 1).cloned().unwrap_or_default()
     }
 
+    /// Retrieves the ID to link to for this location in HTML export.
+    pub fn html_id(&self, location: Location) -> Option<&EcoString> {
+        self.html_ids.get(&location)
+    }
+
     /// Try to find a location for an element with the given `key` hash
     /// that is closest after the `anchor`.
     ///
@@ -343,6 +364,7 @@ pub struct IntrospectorBuilder {
     pub pages: usize,
     pub page_numberings: Vec<Option<Numbering>>,
     pub page_supplements: Vec<Content>,
+    pub html_ids: HashMap<Location, EcoString>,
     seen: HashSet<Location>,
     insertions: MultiMap<Location, Vec<Pair>>,
     keys: MultiMap<u128, Location>,
@@ -426,6 +448,7 @@ impl IntrospectorBuilder {
             pages: self.pages,
             page_numberings: self.page_numberings,
             page_supplements: self.page_supplements,
+            html_ids: self.html_ids,
             elems,
             keys: self.keys,
             locations: self.locations,
diff --git a/crates/typst-library/src/model/link.rs b/crates/typst-library/src/model/link.rs
index c630835e0..7e8f58756 100644
--- a/crates/typst-library/src/model/link.rs
+++ b/crates/typst-library/src/model/link.rs
@@ -1,12 +1,13 @@
 use std::ops::Deref;
 
+use comemo::Tracked;
 use ecow::{eco_format, EcoString};
 
 use crate::diag::{bail, StrResult};
 use crate::foundations::{
     cast, elem, Content, Label, Packed, Repr, ShowSet, Smart, StyleChain, Styles,
 };
-use crate::introspection::Location;
+use crate::introspection::{Introspector, Locatable, Location};
 use crate::layout::Position;
 use crate::text::TextElem;
 
@@ -27,15 +28,62 @@ use crate::text::TextElem;
 /// ]
 /// ```
 ///
+/// # Syntax
+/// This function also has dedicated syntax: Text that starts with `http://` or
+/// `https://` is automatically turned into a link.
+///
 /// # Hyphenation
 /// If you enable hyphenation or justification, by default, it will not apply to
 /// links to prevent unwanted hyphenation in URLs. You can opt out of this
 /// default via `{show link: set text(hyphenate: true)}`.
 ///
-/// # Syntax
-/// This function also has dedicated syntax: Text that starts with `http://` or
-/// `https://` is automatically turned into a link.
-#[elem]
+/// # Links in HTML export
+/// In HTML export, a link to a [label] or [location] will be turned into a
+/// fragment link to a named anchor point. To support this, targets without an
+/// existing ID will automatically receive an ID in the DOM. How this works
+/// varies by which kind of HTML node(s) the link target turned into:
+///
+/// - If the link target turned into a single HTML element, that element will
+///   receive the ID. This is, for instance, typically the case when linking to
+///   a top-level heading (which turns into a single `<h2>` element).
+///
+/// - If the link target turned into a single text node, the node will be
+///   wrapped in a `<span>`, which will then receive the ID.
+///
+/// - If the link target turned into multiple nodes, the first node will receive
+///   the ID.
+///
+/// - If the link target turned into no nodes at all, an empty span will be
+///   generated to serve as a link target.
+///
+/// If you rely on a specific DOM structure, you should ensure that the link
+/// target turns into one or multiple elements, as the compiler makes no
+/// guarantees on the precise segmentation of text into text nodes.
+///
+/// If present, the automatic ID generation tries to reuse the link target's
+/// label to create a human-readable ID. A label can be reused if:
+///
+/// - All characters are alphabetic or numeric according to Unicode, or a
+///   hyphen, or an underscore.
+///
+/// - The label does not start with a digit or hyphen.
+///
+/// These rules ensure that the label is both a valid CSS identifier and a valid
+/// URL fragment for linking.
+///
+/// As IDs must be unique in the DOM, duplicate labels might need disambiguation
+/// when reusing them as IDs. The precise rules for this are as follows:
+///
+/// - If a label can be reused and is unique in the document, it will directly
+///   be used as the ID.
+///
+/// - If it's reusable, but not unique, a suffix consisting of a hyphen and an
+///   integer will be added. For instance, if the label `<mylabel>` exists
+///   twice, it would turn into `mylabel-1` and `mylabel-2`.
+///
+/// - Otherwise, a unique ID of the form `loc-` followed by an integer will be
+///   generated.
+#[elem(Locatable)]
 pub struct LinkElem {
     /// The destination the link points to.
     ///
@@ -124,6 +172,19 @@ pub enum LinkTarget {
     Label(Label),
 }
 
+impl LinkTarget {
+    /// Resolves the destination.
+    pub fn resolve(&self, introspector: Tracked<Introspector>) -> StrResult<Destination> {
+        Ok(match self {
+            LinkTarget::Dest(dest) => dest.clone(),
+            LinkTarget::Label(label) => {
+                let elem = introspector.query_label(*label)?;
+                Destination::Location(elem.location().unwrap())
+            }
+        })
+    }
+}
+
 cast! {
     LinkTarget,
     self => match self {
diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index 4877409fa..f7922ef3e 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -5,12 +5,13 @@ use crate::diag::{bail, At, Hint, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     cast, elem, Cast, Content, Context, Func, IntoValue, Label, NativeElement, Packed,
-    Repr, Smart, StyleChain, Synthesize,
+    Repr, Smart, StyleChain, Synthesize, TargetElem,
 };
 use crate::introspection::{Counter, CounterKey, Locatable};
 use crate::math::EquationElem;
 use crate::model::{
-    BibliographyElem, CiteElem, Destination, Figurable, FootnoteElem, Numbering,
+    BibliographyElem, CiteElem, Destination, Figurable, FootnoteElem, LinkElem,
+    LinkTarget, Numbering,
 };
 use crate::text::TextElem;
 
@@ -346,7 +347,14 @@ fn realize_reference(
         content = supplement + TextElem::packed("\u{a0}") + content;
     }
 
-    Ok(content.linked(Destination::Location(loc)))
+    Ok(if styles.get(TargetElem::target).is_html() {
+        LinkElem::new(LinkTarget::Dest(Destination::Location(loc)), content).pack()
+    } else {
+        // TODO: We should probably also use `LinkElem` in the paged target, but
+        // it's a bit breaking and it becomes hard to style links without
+        // affecting references, so this change should be well-considered.
+        content.linked(Destination::Location(loc))
+    })
 }
 
 /// Turn a reference into a citation.
diff --git a/crates/typst-svg/src/image.rs b/crates/typst-svg/src/image.rs
index e6dd579f3..fd4aecd4f 100644
--- a/crates/typst-svg/src/image.rs
+++ b/crates/typst-svg/src/image.rs
@@ -9,7 +9,7 @@ use typst_library::visualize::{
 
 use crate::SVGRenderer;
 
-impl SVGRenderer {
+impl SVGRenderer<'_> {
     /// Render an image element.
     pub(super) fn render_image(&mut self, image: &Image, size: &Axes<Abs>) {
         let url = convert_image_to_base64_url(image);
diff --git a/crates/typst-svg/src/lib.rs b/crates/typst-svg/src/lib.rs
index cac31ebd2..5b6db69da 100644
--- a/crates/typst-svg/src/lib.rs
+++ b/crates/typst-svg/src/lib.rs
@@ -6,6 +6,8 @@ mod shape;
 mod text;
 
 pub use image::{convert_image_scaling, convert_image_to_base64_url};
+use typst_library::introspection::Introspector;
+use typst_library::model::Destination;
 
 use std::collections::HashMap;
 use std::fmt::{self, Display, Formatter, Write};
@@ -47,12 +49,24 @@ pub fn svg_frame(frame: &Frame) -> String {
 
 /// Export a frame into an SVG suitable for embedding into HTML.
 #[typst_macros::time(name = "svg html frame")]
-pub fn svg_html_frame(frame: &Frame, text_size: Abs) -> String {
-    let mut renderer = SVGRenderer::with_options(xmlwriter::Options {
-        indent: xmlwriter::Indent::None,
-        ..Default::default()
-    });
+pub fn svg_html_frame(
+    frame: &Frame,
+    text_size: Abs,
+    id: Option<&str>,
+    link_points: &[(Point, EcoString)],
+    introspector: &Introspector,
+) -> String {
+    let mut renderer = SVGRenderer::with_options(
+        xmlwriter::Options {
+            indent: xmlwriter::Indent::None,
+            ..Default::default()
+        },
+        Some(introspector),
+    );
     renderer.write_header_with_custom_attrs(frame.size(), |xml| {
+        if let Some(id) = id {
+            xml.write_attribute("id", id);
+        }
         xml.write_attribute("class", "typst-frame");
         xml.write_attribute_fmt(
             "style",
@@ -66,6 +80,11 @@ pub fn svg_html_frame(frame: &Frame, text_size: Abs) -> String {
 
     let state = State::new(frame.size(), Transform::identity());
     renderer.render_frame(state, Transform::identity(), frame);
+
+    for (pos, id) in link_points {
+        renderer.render_link_point(*pos, id);
+    }
+
     renderer.finalize()
 }
 
@@ -102,9 +121,11 @@ pub fn svg_merged(document: &PagedDocument, padding: Abs) -> String {
 }
 
 /// Renders one or multiple frames to an SVG file.
-struct SVGRenderer {
+struct SVGRenderer<'a> {
     /// The internal XML writer.
     xml: XmlWriter,
+    /// The document's introspector, if we're writing an HTML frame.
+    introspector: Option<&'a Introspector>,
     /// Prepared glyphs.
     glyphs: Deduplicator<RenderedGlyph>,
     /// Clip paths are used to clip a group. A clip path is a path that defines
@@ -179,16 +200,20 @@ impl State {
     }
 }
 
-impl SVGRenderer {
+impl<'a> SVGRenderer<'a> {
     /// Create a new SVG renderer with empty glyph and clip path.
     fn new() -> Self {
-        Self::with_options(Default::default())
+        Self::with_options(Default::default(), None)
     }
 
     /// Create a new SVG renderer with the given configuration.
-    fn with_options(options: xmlwriter::Options) -> Self {
+    fn with_options(
+        options: xmlwriter::Options,
+        introspector: Option<&'a Introspector>,
+    ) -> Self {
         SVGRenderer {
             xml: XmlWriter::new(options),
+            introspector,
             glyphs: Deduplicator::new('g'),
             clip_paths: Deduplicator::new('c'),
             gradient_refs: Deduplicator::new('g'),
@@ -248,8 +273,7 @@ impl SVGRenderer {
 
         for (pos, item) in frame.items() {
             // File size optimization.
-            // TODO: SVGs could contain links, couldn't they?
-            if matches!(item, FrameItem::Link(_, _) | FrameItem::Tag(_)) {
+            if matches!(item, FrameItem::Tag(_)) {
                 continue;
             }
 
@@ -270,7 +294,7 @@ impl SVGRenderer {
                     self.render_shape(state.pre_translate(*pos), shape)
                 }
                 FrameItem::Image(image, size, _) => self.render_image(image, size),
-                FrameItem::Link(_, _) => unreachable!(),
+                FrameItem::Link(dest, size) => self.render_link(dest, *size),
                 FrameItem::Tag(_) => unreachable!(),
             };
 
@@ -308,6 +332,53 @@ impl SVGRenderer {
         self.xml.end_element();
     }
 
+    /// Render a link element.
+    fn render_link(&mut self, dest: &Destination, size: Size) {
+        self.xml.start_element("a");
+
+        match dest {
+            Destination::Location(loc) => {
+                // TODO: Location links on the same page could also be supported
+                // outside of HTML.
+                if let Some(introspector) = self.introspector {
+                    if let Some(id) = introspector.html_id(*loc) {
+                        self.xml.write_attribute_fmt("href", format_args!("#{id}"));
+                        self.xml.write_attribute_fmt("xlink:href", format_args!("#{id}"));
+                    }
+                }
+            }
+            Destination::Position(_) => {
+                // TODO: Links on the same page could be supported.
+            }
+            Destination::Url(url) => {
+                self.xml.write_attribute("href", url.as_str());
+                self.xml.write_attribute("xlink:href", url.as_str());
+            }
+        }
+
+        self.xml.start_element("rect");
+        self.xml
+            .write_attribute_fmt("width", format_args!("{}", size.x.to_pt()));
+        self.xml
+            .write_attribute_fmt("height", format_args!("{}", size.y.to_pt()));
+        self.xml.write_attribute("fill", "transparent");
+        self.xml.write_attribute("stroke", "none");
+        self.xml.end_element();
+
+        self.xml.end_element();
+    }
+
+    /// Renders a linkable point that can be used to link into an HTML frame.
+    fn render_link_point(&mut self, pos: Point, id: &str) {
+        self.xml.start_element("g");
+        self.xml.write_attribute("id", id);
+        self.xml.write_attribute_fmt(
+            "transform",
+            format_args!("translate({} {})", pos.x.to_pt(), pos.y.to_pt()),
+        );
+        self.xml.end_element();
+    }
+
     /// Finalize the SVG file. This must be called after all rendering is done.
     fn finalize(mut self) -> String {
         self.write_glyph_defs();
diff --git a/crates/typst-svg/src/paint.rs b/crates/typst-svg/src/paint.rs
index 75ab41cdf..1a9acaecf 100644
--- a/crates/typst-svg/src/paint.rs
+++ b/crates/typst-svg/src/paint.rs
@@ -15,7 +15,7 @@ use crate::{Id, SVGRenderer, State, SvgMatrix, SvgPathBuilder};
 /// Smaller values could be interesting for optimization.
 const CONIC_SEGMENT: usize = 360;
 
-impl SVGRenderer {
+impl SVGRenderer<'_> {
     /// Render a frame to a string.
     pub(super) fn render_tiling_frame(
         &mut self,
diff --git a/crates/typst-svg/src/shape.rs b/crates/typst-svg/src/shape.rs
index 981f86a39..bcd099c49 100644
--- a/crates/typst-svg/src/shape.rs
+++ b/crates/typst-svg/src/shape.rs
@@ -8,7 +8,7 @@ use typst_library::visualize::{
 use crate::paint::ColorEncode;
 use crate::{SVGRenderer, State, SvgPathBuilder};
 
-impl SVGRenderer {
+impl SVGRenderer<'_> {
     /// Render a shape element.
     pub(super) fn render_shape(&mut self, state: State, shape: &Shape) {
         self.xml.start_element("path");
diff --git a/crates/typst-svg/src/text.rs b/crates/typst-svg/src/text.rs
index 7099a9d72..fdc3497e9 100644
--- a/crates/typst-svg/src/text.rs
+++ b/crates/typst-svg/src/text.rs
@@ -13,7 +13,7 @@ use typst_utils::hash128;
 
 use crate::{SVGRenderer, State, SvgMatrix, SvgPathBuilder};
 
-impl SVGRenderer {
+impl SVGRenderer<'_> {
     /// Render a text item. The text is rendered as a group of glyphs. We will
     /// try to render the text as SVG first, then bitmap, then outline. If none
     /// of them works, we will skip the text.
diff --git a/crates/typst-utils/src/pico.rs b/crates/typst-utils/src/pico.rs
index 9f4a2fde7..5f17a2672 100644
--- a/crates/typst-utils/src/pico.rs
+++ b/crates/typst-utils/src/pico.rs
@@ -65,6 +65,23 @@ impl PicoStr {
         id
     }
 
+    /// Try to create a `PicoStr`, but don't intern it if it does not exist yet.
+    ///
+    /// This is useful to try to compare against one or multiple `PicoStr`
+    /// without interning needlessly.
+    ///
+    /// Will always return `Some(_)` if the string can be represented inline.
+    pub fn get(string: &str) -> Option<PicoStr> {
+        // Try to use bitcode or exception representations.
+        if let Ok(value) = PicoStr::try_constant(string) {
+            return Some(value);
+        }
+
+        // Try to find an existing entry that we can reuse.
+        let interner = INTERNER.read().unwrap();
+        interner.seen.get(string).copied()
+    }
+
     /// Creates a compile-time constant `PicoStr`.
     ///
     /// Should only be used in const contexts because it can panic.
diff --git a/tests/ref/html/link-html-frame-ref.html b/tests/ref/html/link-html-frame-ref.html
new file mode 100644
index 000000000..32f2cf4d4
--- /dev/null
+++ b/tests/ref/html/link-html-frame-ref.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>
+    <svg class="typst-frame" style="overflow: visible; width: 4.5em; height: 3em;" viewBox="0 0 45 30" width="45pt" height="30pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml"><g><g transform="translate(-0 -0)"><path class="typst-shape" fill="none" stroke="#000000" stroke-width="1" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" d="M 0 0 L 0 30 L 45 30 L 45 0 Z "/></g><g transform="translate(0 0)"><a href="#intro" xlink:href="#intro"><rect width="45" height="30" fill="transparent" stroke="none"/></a></g></g></svg>
+    <h2 id="intro">1 Introduction</h2>
+  </body>
+</html>
diff --git a/tests/ref/html/link-html-frame.html b/tests/ref/html/link-html-frame.html
new file mode 100644
index 000000000..60cca836d
--- /dev/null
+++ b/tests/ref/html/link-html-frame.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <h2>Frame 1</h2>
+    <svg class="typst-frame" style="overflow: visible; width: 20em; height: 50em;" viewBox="0 0 200 500" width="200pt" height="500pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml"><g><g transform="translate(0 0)"><g class="typst-group"><g><g transform="translate(-0 -0)"><path class="typst-shape" fill="none" stroke="#000000" stroke-width="1" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" d="M 0 0 L 0 500 L 200 500 L 200 0 Z "/></g><g transform="translate(75 100)"><g class="typst-group"><g><g transform="translate(-0 -0)"><path class="typst-shape" fill="#39cccc" fill-rule="nonzero" d="M 0 0 L 0 10 L 10 10 L 10 0 Z "/></g><g transform="translate(0 0)"><a href="#f1" xlink:href="#f1"><rect width="10" height="10" fill="transparent" stroke="none"/></a></g><g transform="translate(20 0)"><path class="typst-shape" fill="#000000" fill-rule="nonzero" d="M 0 0 L 0 10 L 10 10 L 10 0 Z "/></g><g transform="translate(20 0)"><a href="#text" xlink:href="#text"><rect width="10" height="10" fill="transparent" stroke="none"/></a></g><g transform="translate(40 0)"><path class="typst-shape" fill="#ffdc00" fill-rule="nonzero" d="M 0 0 L 0 10 L 10 10 L 10 0 Z "/></g><g transform="translate(40 0)"><a href="#f2" xlink:href="#f2"><rect width="10" height="10" fill="transparent" stroke="none"/></a></g></g></g></g><g transform="translate(95 200)"><path class="typst-shape" fill="#39cccc" fill-rule="nonzero" d="M 0 0 L 0 10 L 10 10 L 10 0 Z "/></g></g></g></g></g><g id="f1" transform="translate(95 200)"/></svg>
+    <h2 id="text">Text</h2>
+    <p><a href="#f1">Go to teal square</a></p>
+    <h2>Frame 2</h2>
+    <svg class="typst-frame" style="overflow: visible; width: 20em; height: 50em;" viewBox="0 0 200 500" width="200pt" height="500pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:h5="http://www.w3.org/1999/xhtml"><g><g transform="translate(0 0)"><g class="typst-group"><g><g transform="translate(-0 -0)"><path class="typst-shape" fill="none" stroke="#000000" stroke-width="1" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="4" d="M 0 0 L 0 500 L 200 500 L 200 0 Z "/></g><g transform="translate(95 100)"><path class="typst-shape" fill="#ffdc00" fill-rule="nonzero" d="M 0 0 L 0 10 L 10 10 L 10 0 Z "/></g></g></g></g></g><g id="f2" transform="translate(95 100)"/></svg>
+  </body>
+</html>
diff --git a/tests/ref/html/link-html-here.html b/tests/ref/html/link-html-here.html
new file mode 100644
index 000000000..783c050bd
--- /dev/null
+++ b/tests/ref/html/link-html-here.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <p id="loc-1"><a href="#loc-1">Go</a></p>
+  </body>
+</html>
diff --git a/tests/ref/html/link-html-id-attach.html b/tests/ref/html/link-html-id-attach.html
new file mode 100644
index 000000000..d1e7cbf9b
--- /dev/null
+++ b/tests/ref/html/link-html-id-attach.html
@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <ul>
+      <li><a href="#t1">Go</a></li>
+      <li><a href="#t2">Go</a></li>
+      <li><a href="#t3">Go</a></li>
+      <li><a href="#t4">Go</a></li>
+      <li><a href="#t5">Go</a></li>
+      <li><a href="#t6">Go</a></li>
+      <li><a href="#t7">Go</a></li>
+      <li><a href="#t8">Go</a></li>
+    </ul>
+    <p id="t1">Hi</p>
+    <p id="t2">Hi there</p>
+    <p>See <span id="t4">it</span></p>
+    <p>See <span id="t5">it</span> here</p>
+    <p>See <span id="t6">a</span> <strong>b</strong></p>
+    <p>See <strong id="t3">a <em>b</em></strong></p>
+    <p>See</p>
+    <span id="t7"></span>
+    <p>See</p>
+    <span id="t8"></span>
+  </body>
+</html>
diff --git a/tests/ref/html/link-html-id-existing.html b/tests/ref/html/link-html-id-existing.html
new file mode 100644
index 000000000..7686fc9ac
--- /dev/null
+++ b/tests/ref/html/link-html-id-existing.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>
+    <div><span id="this">This</span></div>
+    <p><a href="#this">Go</a></p>
+  </body>
+</html>
diff --git a/tests/ref/html/link-html-label-disambiguation.html b/tests/ref/html/link-html-label-disambiguation.html
new file mode 100644
index 000000000..41f1d33a9
--- /dev/null
+++ b/tests/ref/html/link-html-label-disambiguation.html
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <h2 id="loc-1">A</h2>
+    <h2 id="loc-3">B</h2>
+    <h2 id="loc">C</h2>
+    <h2 id="loc-2">D</h2>
+    <h2 id="lib-1">E</h2>
+    <h2 id="lib-3">F</h2>
+    <h2 id="lib-2">G</h2>
+    <h2 id="hi">H</h2>
+    <h2 id="hi-2-1">I</h2>
+    <h2 id="hi-2-2">J</h2>
+    <ul>
+      <li><a href="#loc-1">A</a></li>
+      <li><a href="#loc-3">B</a></li>
+      <li><a href="#loc">C</a></li>
+      <li><a href="#loc-2">D</a></li>
+      <li><a href="#lib-1">E</a></li>
+      <li><a href="#lib-3">F</a></li>
+      <li><a href="#lib-2">G</a></li>
+      <li><a href="#hi">H</a></li>
+      <li><a href="#hi-2-1">I</a></li>
+      <li><a href="#hi-2-2">J</a></li>
+    </ul>
+  </body>
+</html>
diff --git a/tests/ref/html/link-html-nested-empty.html b/tests/ref/html/link-html-nested-empty.html
new file mode 100644
index 000000000..e197d54e1
--- /dev/null
+++ b/tests/ref/html/link-html-nested-empty.html
@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <span id="a"></span><span id="b"></span>
+    <p>Hi</p>
+    <p><a href="#a">A</a> <a href="#b">B</a> <a href="#a">C</a></p>
+  </body>
+</html>
diff --git a/tests/ref/html/ref-basic.html b/tests/ref/html/ref-basic.html
new file mode 100644
index 000000000..4e0e01b7d
--- /dev/null
+++ b/tests/ref/html/ref-basic.html
@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <h2 id="intro">1. Introduction</h2>
+    <p>See <a href="#setup">Section 1.1</a>.</p>
+    <h3 id="setup">1.1. Setup</h3>
+    <p>As seen in <a href="#intro">Section 1</a>, we proceed.</p>
+  </body>
+</html>
diff --git a/tests/suite/model/link.typ b/tests/suite/model/link.typ
index bd6c8a307..1394638f5 100644
--- a/tests/suite/model/link.typ
+++ b/tests/suite/model/link.typ
@@ -66,6 +66,117 @@ My cool #box(move(dx: 0.7cm, dy: 0.7cm, rotate(10deg, scale(200%, mylink))))
 Text <hey>
 #link(<hey>)[Go to text.]
 
+--- link-html-id-attach html ---
+// Tests how IDs and, if necessary, spans, are added to the DOM to support
+// links.
+
+#for i in range(1, 9) {
+  list.item(link(label("t" + str(i)), [Go]))
+}
+
+// Text at start of paragraph
+Hi <t1>
+
+// Text at start of paragraph + more text
+Hi <t2> there
+
+// Text in the middle of paragraph
+See #[it <t4>]
+
+// Text in the middle of paragraph + more text
+See #[it <t5>] here
+
+// Text + more elements
+See #[a *b*] <t6>
+
+// Element
+See *a _b_* <t3>
+
+// Nothing
+See #[] <t7>
+
+// Nothing 2
+See #metadata(none) <t8>
+
+--- link-html-label-disambiguation html ---
+// Tests automatic ID generation for labelled elements.
+
+#[= A] #label("%") // not reusable => loc-1
+= B <1>            // not reusable => loc-3 (loc-2 exists)
+= C <loc>          // reusable, unique => loc
+= D <loc-2>        // reusable, unique => loc-2
+= E <lib>          // reusable, not unique => lib-1
+= F <lib>          // reusable, not unique => lib-3 (lib-2 exists)
+= G <lib-2>        // reusable, unique => lib-2
+= H <hi>           // reusable, unique => hi
+= I <hi-2>         // reusable, not unique => hi-2-1
+= J <hi-2>         // reusable, not unique => hi-2-2
+
+#context for it in query(heading) {
+  list.item(link(it.location(), it.body))
+}
+
+--- link-html-id-existing html ---
+// Test that linking reuses the existing ID, if any.
+#html.div[
+  #html.span(id: "this")[This] <other>
+]
+
+#link(<other>)[Go]
+
+--- link-html-here html ---
+#context link(here())[Go]
+
+--- link-html-nested-empty html ---
+#[#metadata(none) <a> #metadata(none) <b> Hi] <c>
+
+#link(<a>)[A] // creates empty span
+#link(<b>)[B] // creates second empty span
+#link(<c>)[C] // links to #a because the generated span is contained in it
+
+--- link-html-frame html ---
+= Frame 1
+#html.frame(block(
+  stroke: 1pt,
+  width: 200pt,
+  height: 500pt,
+)[
+  #place(center, dy: 100pt, stack(
+    dir: ltr,
+    spacing: 10pt,
+    link(<f1>, square(size: 10pt, fill: teal)),
+    link(<text>, square(size: 10pt, fill: black)),
+    link(<f2>, square(size: 10pt, fill: yellow)),
+  ))
+  #place(center, dy: 200pt)[
+    #square(size: 10pt, fill: teal) <f1>
+  ]
+])
+
+= Text <text>
+#link(<f1>)[Go to teal square]
+
+= Frame 2
+#html.frame(block(
+  stroke: 1pt,
+  width: 200pt,
+  height: 500pt,
+)[
+  #place(center, dy: 100pt)[
+    #square(size: 10pt, fill: yellow) <f2>
+  ]
+])
+
+--- link-html-frame-ref html ---
+// Test that reference links work in `html.frame`. Currently, references (and a
+// few other elements) do not internally use `LinkElem`s, so they trigger a
+// slightly different code path; see `typst-html/src/link.rs`. The text show
+// rule is only there to keep the output small.
+#set heading(numbering: "1")
+#show "Section" + sym.space.nobreak + "1": rect()
+#html.frame[@intro]
+= Introduction <intro>
+
 --- link-to-label-missing ---
 // Error: 2-20 label `<hey>` does not exist in the document
 #link(<hey>)[Nope.]
diff --git a/tests/suite/model/ref.typ b/tests/suite/model/ref.typ
index d48072edb..1e07a3e9b 100644
--- a/tests/suite/model/ref.typ
+++ b/tests/suite/model/ref.typ
@@ -1,6 +1,6 @@
 // Test references.
 
---- ref-basic ---
+--- ref-basic render html ---
 #set heading(numbering: "1.")
 
 = Introduction <intro>

From 0a4b72f8f6405bb847bf7659bf43ba9e6da2e581 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 16 Jul 2025 10:55:06 +0200
Subject: [PATCH 084/101] Partially automate span assignment in native show
 rule (#6613)

---
 crates/typst-html/src/rules.rs   | 54 ++++++--------------
 crates/typst-layout/src/rules.rs | 86 +++++++++-----------------------
 crates/typst-realize/src/lib.rs  |  4 +-
 3 files changed, 42 insertions(+), 102 deletions(-)

diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index 846cb5eb5..d861249f5 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -59,19 +59,11 @@ pub fn register(rules: &mut NativeRuleMap) {
     rules.register::<FrameElem>(Paged, |elem, _, _| Ok(elem.body.clone()));
 }
 
-const STRONG_RULE: ShowFn<StrongElem> = |elem, _, _| {
-    Ok(HtmlElem::new(tag::strong)
-        .with_body(Some(elem.body.clone()))
-        .pack()
-        .spanned(elem.span()))
-};
+const STRONG_RULE: ShowFn<StrongElem> =
+    |elem, _, _| Ok(HtmlElem::new(tag::strong).with_body(Some(elem.body.clone())).pack());
 
-const EMPH_RULE: ShowFn<EmphElem> = |elem, _, _| {
-    Ok(HtmlElem::new(tag::em)
-        .with_body(Some(elem.body.clone()))
-        .pack()
-        .spanned(elem.span()))
-};
+const EMPH_RULE: ShowFn<EmphElem> =
+    |elem, _, _| Ok(HtmlElem::new(tag::em).with_body(Some(elem.body.clone())).pack());
 
 const LIST_RULE: ShowFn<ListElem> = |elem, _, styles| {
     Ok(HtmlElem::new(tag::ul)
@@ -86,8 +78,7 @@ const LIST_RULE: ShowFn<ListElem> = |elem, _, styles| {
                 .pack()
                 .spanned(item.span())
         }))))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const ENUM_RULE: ShowFn<EnumElem> = |elem, _, styles| {
@@ -114,7 +105,7 @@ const ENUM_RULE: ShowFn<EnumElem> = |elem, _, styles| {
         li.with_body(Some(body)).pack().spanned(item.span())
     }));
 
-    Ok(ol.with_body(Some(body)).pack().spanned(elem.span()))
+    Ok(ol.with_body(Some(body)).pack())
 };
 
 const TERMS_RULE: ShowFn<TermsElem> = |elem, _, styles| {
@@ -166,8 +157,7 @@ const LINK_RULE: ShowFn<LinkElem> = |elem, engine, _| {
     Ok(HtmlElem::new(tag::a)
         .with_optional_attr(attr::href, href)
         .with_body(Some(elem.body.clone()))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const HEADING_RULE: ShowFn<HeadingElem> = |elem, engine, styles| {
@@ -203,10 +193,9 @@ const HEADING_RULE: ShowFn<HeadingElem> = |elem, engine, styles| {
             .with_attr(attr::role, "heading")
             .with_attr(attr::aria_level, eco_format!("{}", level + 1))
             .pack()
-            .spanned(span)
     } else {
         let t = [tag::h2, tag::h3, tag::h4, tag::h5, tag::h6][level - 1];
-        HtmlElem::new(t).with_body(Some(realized)).pack().spanned(span)
+        HtmlElem::new(t).with_body(Some(realized)).pack()
     })
 };
 
@@ -225,17 +214,13 @@ const FIGURE_RULE: ShowFn<FigureElem> = |elem, _, styles| {
     // Ensure that the body is considered a paragraph.
     realized += ParbreakElem::shared().clone().spanned(span);
 
-    Ok(HtmlElem::new(tag::figure)
-        .with_body(Some(realized))
-        .pack()
-        .spanned(span))
+    Ok(HtmlElem::new(tag::figure).with_body(Some(realized)).pack())
 };
 
 const FIGURE_CAPTION_RULE: ShowFn<FigureCaption> = |elem, engine, styles| {
     Ok(HtmlElem::new(tag::figcaption)
         .with_body(Some(elem.realize(engine, styles)?))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const QUOTE_RULE: ShowFn<QuoteElem> = |elem, _, styles| {
@@ -376,19 +361,11 @@ fn show_cell(tag: HtmlTag, cell: &Cell, styles: StyleChain) -> Content {
         .spanned(cell.span())
 }
 
-const SUB_RULE: ShowFn<SubElem> = |elem, _, _| {
-    Ok(HtmlElem::new(tag::sub)
-        .with_body(Some(elem.body.clone()))
-        .pack()
-        .spanned(elem.span()))
-};
+const SUB_RULE: ShowFn<SubElem> =
+    |elem, _, _| Ok(HtmlElem::new(tag::sub).with_body(Some(elem.body.clone())).pack());
 
-const SUPER_RULE: ShowFn<SuperElem> = |elem, _, _| {
-    Ok(HtmlElem::new(tag::sup)
-        .with_body(Some(elem.body.clone()))
-        .pack()
-        .spanned(elem.span()))
-};
+const SUPER_RULE: ShowFn<SuperElem> =
+    |elem, _, _| Ok(HtmlElem::new(tag::sup).with_body(Some(elem.body.clone())).pack());
 
 const UNDERLINE_RULE: ShowFn<UnderlineElem> = |elem, _, _| {
     // Note: In modern HTML, `<u>` is not the underline element, but
@@ -427,8 +404,7 @@ const RAW_RULE: ShowFn<RawElem> = |elem, _, styles| {
 
     Ok(HtmlElem::new(if elem.block.get(styles) { tag::pre } else { tag::code })
         .with_body(Some(Content::sequence(seq)))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const RAW_LINE_RULE: ShowFn<RawLine> = |elem, _, _| Ok(elem.body.clone());
diff --git a/crates/typst-layout/src/rules.rs b/crates/typst-layout/src/rules.rs
index c78f94d55..f21cd17ab 100644
--- a/crates/typst-layout/src/rules.rs
+++ b/crates/typst-layout/src/rules.rs
@@ -272,7 +272,7 @@ const HEADING_RULE: ShowFn<HeadingElem> = |elem, engine, styles| {
         BlockElem::new().with_body(Some(BlockBody::Content(realized)))
     };
 
-    Ok(block.pack().spanned(span))
+    Ok(block.pack())
 };
 
 const FIGURE_RULE: ShowFn<FigureElem> = |elem, _, styles| {
@@ -326,8 +326,7 @@ const FIGURE_RULE: ShowFn<FigureElem> = |elem, _, styles| {
 const FIGURE_CAPTION_RULE: ShowFn<FigureCaption> = |elem, engine, styles| {
     Ok(BlockElem::new()
         .with_body(Some(BlockBody::Content(elem.realize(engine, styles)?)))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const QUOTE_RULE: ShowFn<QuoteElem> = |elem, _, styles| {
@@ -550,9 +549,7 @@ const BIBLIOGRAPHY_RULE: ShowFn<BibliographyElem> = |elem, engine, styles| {
 };
 
 const TABLE_RULE: ShowFn<TableElem> = |elem, _, _| {
-    Ok(BlockElem::multi_layouter(elem.clone(), crate::grid::layout_table)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::grid::layout_table).pack())
 };
 
 const TABLE_CELL_RULE: ShowFn<TableCell> = |elem, _, styles| {
@@ -703,27 +700,19 @@ const ALIGN_RULE: ShowFn<AlignElem> =
     |elem, _, styles| Ok(elem.body.clone().aligned(elem.alignment.get(styles)));
 
 const PAD_RULE: ShowFn<PadElem> = |elem, _, _| {
-    Ok(BlockElem::multi_layouter(elem.clone(), crate::pad::layout_pad)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::pad::layout_pad).pack())
 };
 
 const COLUMNS_RULE: ShowFn<ColumnsElem> = |elem, _, _| {
-    Ok(BlockElem::multi_layouter(elem.clone(), crate::flow::layout_columns)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::flow::layout_columns).pack())
 };
 
 const STACK_RULE: ShowFn<StackElem> = |elem, _, _| {
-    Ok(BlockElem::multi_layouter(elem.clone(), crate::stack::layout_stack)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::stack::layout_stack).pack())
 };
 
 const GRID_RULE: ShowFn<GridElem> = |elem, _, _| {
-    Ok(BlockElem::multi_layouter(elem.clone(), crate::grid::layout_grid)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::multi_layouter(elem.clone(), crate::grid::layout_grid).pack())
 };
 
 const GRID_CELL_RULE: ShowFn<GridCell> = |elem, _, styles| {
@@ -753,33 +742,23 @@ fn show_cell(
 }
 
 const MOVE_RULE: ShowFn<MoveElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_move)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_move).pack())
 };
 
 const SCALE_RULE: ShowFn<ScaleElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_scale)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_scale).pack())
 };
 
 const ROTATE_RULE: ShowFn<RotateElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_rotate)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_rotate).pack())
 };
 
 const SKEW_RULE: ShowFn<SkewElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_skew)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::transforms::layout_skew).pack())
 };
 
 const REPEAT_RULE: ShowFn<RepeatElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::repeat::layout_repeat)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::repeat::layout_repeat).pack())
 };
 
 const HIDE_RULE: ShowFn<HideElem> =
@@ -801,83 +780,66 @@ const LAYOUT_RULE: ShowFn<LayoutElem> = |elem, _, _| {
             crate::flow::layout_fragment(engine, &result, locator, styles, regions)
         },
     )
-    .pack()
-    .spanned(elem.span()))
+    .pack())
 };
 
 const IMAGE_RULE: ShowFn<ImageElem> = |elem, _, styles| {
     Ok(BlockElem::single_layouter(elem.clone(), crate::image::layout_image)
         .with_width(elem.width.get(styles))
         .with_height(elem.height.get(styles))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const LINE_RULE: ShowFn<LineElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_line)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_line).pack())
 };
 
 const RECT_RULE: ShowFn<RectElem> = |elem, _, styles| {
     Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_rect)
         .with_width(elem.width.get(styles))
         .with_height(elem.height.get(styles))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const SQUARE_RULE: ShowFn<SquareElem> = |elem, _, styles| {
     Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_square)
         .with_width(elem.width.get(styles))
         .with_height(elem.height.get(styles))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const ELLIPSE_RULE: ShowFn<EllipseElem> = |elem, _, styles| {
     Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_ellipse)
         .with_width(elem.width.get(styles))
         .with_height(elem.height.get(styles))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const CIRCLE_RULE: ShowFn<CircleElem> = |elem, _, styles| {
     Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_circle)
         .with_width(elem.width.get(styles))
         .with_height(elem.height.get(styles))
-        .pack()
-        .spanned(elem.span()))
+        .pack())
 };
 
 const POLYGON_RULE: ShowFn<PolygonElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_polygon)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_polygon).pack())
 };
 
 const CURVE_RULE: ShowFn<CurveElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_curve)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_curve).pack())
 };
 
 const PATH_RULE: ShowFn<PathElem> = |elem, _, _| {
-    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_path)
-        .pack()
-        .spanned(elem.span()))
+    Ok(BlockElem::single_layouter(elem.clone(), crate::shapes::layout_path).pack())
 };
 
 const EQUATION_RULE: ShowFn<EquationElem> = |elem, _, styles| {
     if elem.block.get(styles) {
         Ok(BlockElem::multi_layouter(elem.clone(), crate::math::layout_equation_block)
-            .pack()
-            .spanned(elem.span()))
+            .pack())
     } else {
-        Ok(InlineElem::layouter(elem.clone(), crate::math::layout_equation_inline)
-            .pack()
-            .spanned(elem.span()))
+        Ok(InlineElem::layouter(elem.clone(), crate::math::layout_equation_inline).pack())
     }
 };
 
diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index 5d9e0a23a..87df940e4 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -374,7 +374,9 @@ fn visit_show_rules<'a>(
             }
 
             // Apply a built-in show rule.
-            ShowStep::Builtin(rule) => rule.apply(&output, s.engine, chained),
+            ShowStep::Builtin(rule) => rule
+                .apply(&output, s.engine, chained)
+                .map(|content| content.spanned(output.span())),
         };
 
         // Errors in show rules don't terminate compilation immediately. We just

From 8e0e0f1a3ba471c5246a2357a1f3826c09881d03 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 16 Jul 2025 11:12:38 +0200
Subject: [PATCH 085/101] Bump `zip` dependency (#6615)

---
 Cargo.lock | 17 ++++++++---------
 Cargo.toml |  2 +-
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1893f89fe..dcd154367 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -748,9 +748,9 @@ dependencies = [
 
 [[package]]
 name = "flate2"
-version = "1.1.0"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11faaf5a5236997af9848be0bef4db95824b1d534ebc64d0f0c6cf3e67bd38dc"
+checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"
 dependencies = [
  "crc32fast",
  "libz-rs-sys",
@@ -1469,9 +1469,9 @@ dependencies = [
 
 [[package]]
 name = "libz-rs-sys"
-version = "0.4.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "902bc563b5d65ad9bba616b490842ef0651066a1a1dc3ce1087113ffcb873c8d"
+checksum = "172a788537a2221661b480fee8dc5f96c580eb34fa88764d3205dc356c7e4221"
 dependencies = [
  "zlib-rs",
 ]
@@ -3932,13 +3932,12 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "2.5.0"
+version = "4.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27c03817464f64e23f6f37574b4fdc8cf65925b5bfd2b0f2aedf959791941f88"
+checksum = "9aed4ac33e8eb078c89e6cbb1d5c4c7703ec6d299fc3e7c3695af8f8b423468b"
 dependencies = [
  "arbitrary",
  "crc32fast",
- "crossbeam-utils",
  "flate2",
  "indexmap 2.7.1",
  "memchr",
@@ -3947,9 +3946,9 @@ dependencies = [
 
 [[package]]
 name = "zlib-rs"
-version = "0.4.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b20717f0917c908dc63de2e44e97f1e6b126ca58d0e391cee86d504eb8fbd05"
+checksum = "626bd9fa9734751fc50d6060752170984d7053f5a39061f524cda68023d4db8a"
 
 [[package]]
 name = "zopfli"
diff --git a/Cargo.toml b/Cargo.toml
index 9657f207f..63ea32b94 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -143,7 +143,7 @@ xmlparser = "0.13.5"
 xmlwriter = "0.1.0"
 xz2 = { version = "0.1", features = ["static"] }
 yaml-front-matter = "0.1"
-zip = { version = "2.5", default-features = false, features = ["deflate"] }
+zip = { version = "4.3", default-features = false, features = ["deflate"] }
 
 [profile.dev.package."*"]
 opt-level = 2

From 7897e86bccc1e6f510b28bc40ea1700029f41b5d Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Wed, 16 Jul 2025 11:54:43 +0200
Subject: [PATCH 086/101] Restore timing scopes for native show rules (#6616)

---
 crates/typst-realize/src/lib.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index 87df940e4..f3f071505 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -374,9 +374,11 @@ fn visit_show_rules<'a>(
             }
 
             // Apply a built-in show rule.
-            ShowStep::Builtin(rule) => rule
-                .apply(&output, s.engine, chained)
-                .map(|content| content.spanned(output.span())),
+            ShowStep::Builtin(rule) => {
+                let _scope = typst_timing::TimingScope::new(output.elem().name());
+                rule.apply(&output, s.engine, chained)
+                    .map(|content| content.spanned(output.span()))
+            }
         };
 
         // Errors in show rules don't terminate compilation immediately. We just

From 5661c20580584d86897d139cdeffd6fb1a9a6d5c Mon Sep 17 00:00:00 2001
From: Robin <mewmew@users.noreply.github.com>
Date: Wed, 16 Jul 2025 18:15:49 +0200
Subject: [PATCH 087/101] Slightly improve selector docs (#6544)

---
 crates/typst-library/src/foundations/selector.rs | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/crates/typst-library/src/foundations/selector.rs b/crates/typst-library/src/foundations/selector.rs
index 8f264a813..b8e34eb95 100644
--- a/crates/typst-library/src/foundations/selector.rs
+++ b/crates/typst-library/src/foundations/selector.rs
@@ -37,13 +37,12 @@ pub use crate::__select_where as select_where;
 
 /// A filter for selecting elements within the document.
 ///
-/// You can construct a selector in the following ways:
-/// - you can use an element [function]
-/// - you can filter for an element function with
-///   [specific fields]($function.where)
-/// - you can use a [string]($str) or [regular expression]($regex)
-/// - you can use a [`{<label>}`]($label)
-/// - you can use a [`location`]
+/// To construct a selector you can:
+/// - use an element [function]
+/// - filter for an element function with [specific fields]($function.where)
+/// - use a [string]($str) or [regular expression]($regex)
+/// - use a [`{<label>}`]($label)
+/// - use a [`location`]
 /// - call the [`selector`] constructor to convert any of the above types into a
 ///   selector value and use the methods below to refine it
 ///
@@ -148,7 +147,9 @@ impl Selector {
 impl Selector {
     /// Turns a value into a selector. The following values are accepted:
     /// - An element function like a `heading` or `figure`.
+    /// - A [string]($str) or [regular expression]($regex).
     /// - A `{<label>}`.
+    /// - A [`location`].
     /// - A more complex selector like `{heading.where(level: 1)}`.
     #[func(constructor)]
     pub fn construct(

From 627f5b9d4f39f91affc529f276bb500d42887dae Mon Sep 17 00:00:00 2001
From: Lachlan Kermode <lachiekermode@gmail.com>
Date: Thu, 17 Jul 2025 18:09:13 +0200
Subject: [PATCH 088/101] Add show rule for smallcaps in HTML (#6600)

---
 crates/typst-html/src/rules.rs    | 19 +++++++++++++++++--
 tests/ref/html/smallcaps-all.html | 10 ++++++++++
 tests/suite/text/smallcaps.typ    |  2 +-
 3 files changed, 28 insertions(+), 3 deletions(-)
 create mode 100644 tests/ref/html/smallcaps-all.html

diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index d861249f5..3d215d56e 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -14,8 +14,8 @@ use typst_library::model::{
     RefElem, StrongElem, TableCell, TableElem, TermsElem,
 };
 use typst_library::text::{
-    HighlightElem, LinebreakElem, OverlineElem, RawElem, RawLine, SpaceElem, StrikeElem,
-    SubElem, SuperElem, UnderlineElem,
+    HighlightElem, LinebreakElem, OverlineElem, RawElem, RawLine, SmallcapsElem,
+    SpaceElem, StrikeElem, SubElem, SuperElem, UnderlineElem,
 };
 use typst_library::visualize::ImageElem;
 
@@ -47,6 +47,7 @@ pub fn register(rules: &mut NativeRuleMap) {
     rules.register(Html, OVERLINE_RULE);
     rules.register(Html, STRIKE_RULE);
     rules.register(Html, HIGHLIGHT_RULE);
+    rules.register(Html, SMALLCAPS_RULE);
     rules.register(Html, RAW_RULE);
     rules.register(Html, RAW_LINE_RULE);
 
@@ -390,6 +391,20 @@ const STRIKE_RULE: ShowFn<StrikeElem> =
 const HIGHLIGHT_RULE: ShowFn<HighlightElem> =
     |elem, _, _| Ok(HtmlElem::new(tag::mark).with_body(Some(elem.body.clone())).pack());
 
+const SMALLCAPS_RULE: ShowFn<SmallcapsElem> = |elem, _, styles| {
+    Ok(HtmlElem::new(tag::span)
+        .with_attr(
+            attr::style,
+            if elem.all.get(styles) {
+                "font-variant-caps: all-small-caps"
+            } else {
+                "font-variant-caps: small-caps"
+            },
+        )
+        .with_body(Some(elem.body.clone()))
+        .pack())
+};
+
 const RAW_RULE: ShowFn<RawElem> = |elem, _, styles| {
     let lines = elem.lines.as_deref().unwrap_or_default();
 
diff --git a/tests/ref/html/smallcaps-all.html b/tests/ref/html/smallcaps-all.html
new file mode 100644
index 000000000..47b799415
--- /dev/null
+++ b/tests/ref/html/smallcaps-all.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+  </head>
+  <body>
+    <p><span style="font-variant-caps: small-caps">Test 012</span><br><span style="font-variant-caps: all-small-caps">Test 012</span></p>
+  </body>
+</html>
diff --git a/tests/suite/text/smallcaps.typ b/tests/suite/text/smallcaps.typ
index 981e41c4c..4b2f85aef 100644
--- a/tests/suite/text/smallcaps.typ
+++ b/tests/suite/text/smallcaps.typ
@@ -11,6 +11,6 @@
 #show smallcaps: set text(fill: red)
 #smallcaps[Smallcaps]
 
---- smallcaps-all ---
+--- smallcaps-all render html ---
 #smallcaps(all: false)[Test 012] \
 #smallcaps(all: true)[Test 012]

From 4629ede0209949d86557cb8593bc7b803debcf5b Mon Sep 17 00:00:00 2001
From: Patrick Massot <patrickmassot@free.fr>
Date: Fri, 18 Jul 2025 15:21:36 +0200
Subject: [PATCH 089/101] Mention Tinymist in README.md (#6601)

---
 README.md | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 9dee102b6..675c7bdca 100644
--- a/README.md
+++ b/README.md
@@ -173,8 +173,11 @@ typst help
 typst help watch
 ```
 
-If you prefer an integrated IDE-like experience with autocompletion and instant
-preview, you can also check out [Typst's free web app][app].
+If you prefer an integrated IDE-like experience with autocompletion and instant 
+preview, you can also check out our [free web app][app]. Alternatively, there is 
+a community-created language server called 
+[Tinymist](https://myriad-dreamin.github.io/tinymist/) which is integrated into 
+various editor extensions.
 
 ## Community
 The main places where the community gathers are our [Forum][forum] and our

From b1c79b50d4253e7acb839a93450311c1fca12ac8 Mon Sep 17 00:00:00 2001
From: Malo <57839069+MDLC01@users.noreply.github.com>
Date: Fri, 18 Jul 2025 14:25:17 +0100
Subject: [PATCH 090/101] Fix documentation oneliners (#6608)

---
 crates/typst-library/src/visualize/color.rs |  4 ++-
 docs/src/lib.rs                             | 28 ++++++++++++++++-----
 docs/src/model.rs                           |  4 +--
 3 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/crates/typst-library/src/visualize/color.rs b/crates/typst-library/src/visualize/color.rs
index 5c657b4e2..dd0287d4b 100644
--- a/crates/typst-library/src/visualize/color.rs
+++ b/crates/typst-library/src/visualize/color.rs
@@ -797,7 +797,9 @@ impl Color {
         components
     }
 
-    /// Returns the constructor function for this color's space:
+    /// Returns the constructor function for this color's space.
+    ///
+    /// Returns one of:
     /// - [`luma`]($color.luma)
     /// - [`oklab`]($color.oklab)
     /// - [`oklch`]($color.oklch)
diff --git a/docs/src/lib.rs b/docs/src/lib.rs
index e3eb21f98..155ffb827 100644
--- a/docs/src/lib.rs
+++ b/docs/src/lib.rs
@@ -242,7 +242,7 @@ fn category_page(resolver: &dyn Resolver, category: Category) -> PageModel {
             items.push(CategoryItem {
                 name: group.name.clone(),
                 route: subpage.route.clone(),
-                oneliner: oneliner(docs).into(),
+                oneliner: oneliner(docs),
                 code: true,
             });
             children.push(subpage);
@@ -296,7 +296,7 @@ fn category_page(resolver: &dyn Resolver, category: Category) -> PageModel {
                 items.push(CategoryItem {
                     name: name.into(),
                     route: subpage.route.clone(),
-                    oneliner: oneliner(func.docs().unwrap_or_default()).into(),
+                    oneliner: oneliner(func.docs().unwrap_or_default()),
                     code: true,
                 });
                 children.push(subpage);
@@ -306,7 +306,7 @@ fn category_page(resolver: &dyn Resolver, category: Category) -> PageModel {
                 items.push(CategoryItem {
                     name: ty.short_name().into(),
                     route: subpage.route.clone(),
-                    oneliner: oneliner(ty.docs()).into(),
+                    oneliner: oneliner(ty.docs()),
                     code: true,
                 });
                 children.push(subpage);
@@ -637,7 +637,7 @@ fn group_page(
     let item = CategoryItem {
         name: group.name.clone(),
         route: model.route.clone(),
-        oneliner: oneliner(&group.details).into(),
+        oneliner: oneliner(&group.details),
         code: false,
     };
 
@@ -772,8 +772,24 @@ pub fn urlify(title: &str) -> EcoString {
 }
 
 /// Extract the first line of documentation.
-fn oneliner(docs: &str) -> &str {
-    docs.lines().next().unwrap_or_default()
+fn oneliner(docs: &str) -> EcoString {
+    let paragraph = docs.split("\n\n").next().unwrap_or_default();
+    let mut depth = 0;
+    let mut period = false;
+    let mut end = paragraph.len();
+    for (i, c) in paragraph.char_indices() {
+        match c {
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth -= 1,
+            '.' if depth == 0 => period = true,
+            c if period && c.is_whitespace() && !docs[..i].ends_with("e.g.") => {
+                end = i;
+                break;
+            }
+            _ => period = false,
+        }
+    }
+    EcoString::from(&docs[..end]).replace("\r\n", " ").replace("\n", " ")
 }
 
 /// The order of types in the documentation.
diff --git a/docs/src/model.rs b/docs/src/model.rs
index 801c60c7f..e3b15e377 100644
--- a/docs/src/model.rs
+++ b/docs/src/model.rs
@@ -86,7 +86,7 @@ pub struct FuncModel {
     pub name: EcoString,
     pub title: &'static str,
     pub keywords: &'static [&'static str],
-    pub oneliner: &'static str,
+    pub oneliner: EcoString,
     pub element: bool,
     pub contextual: bool,
     pub deprecation: Option<&'static str>,
@@ -139,7 +139,7 @@ pub struct TypeModel {
     pub name: &'static str,
     pub title: &'static str,
     pub keywords: &'static [&'static str],
-    pub oneliner: &'static str,
+    pub oneliner: EcoString,
     pub details: Html,
     pub constructor: Option<FuncModel>,
     pub scope: Vec<FuncModel>,

From b790c6d59ceaf7a809cc24b60c1f1509807470e2 Mon Sep 17 00:00:00 2001
From: Erik <tinger@tinger.dev>
Date: Fri, 18 Jul 2025 16:36:10 +0200
Subject: [PATCH 091/101] Add rust-analyzer to flake devShell (#6618)

---
 flake.nix | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/flake.nix b/flake.nix
index 1b2b3abc8..cc5f96273 100644
--- a/flake.nix
+++ b/flake.nix
@@ -127,6 +127,10 @@
           checks = self'.checks;
           inputsFrom = [ typst ];
 
+          buildInputs = with pkgs; [
+            rust-analyzer
+          ];
+
           packages = [
             # A script for quickly running tests.
             # See https://github.com/typst/typst/blob/main/tests/README.md#making-an-alias

From 55dad028870329a5d78d7d62fe45844acc10f943 Mon Sep 17 00:00:00 2001
From: pog102 <85764555+pog102@users.noreply.github.com>
Date: Mon, 21 Jul 2025 13:57:40 +0300
Subject: [PATCH 092/101] Add Lithuanian translations (#6587)

---
 crates/typst-library/src/text/lang.rs    | 2 ++
 crates/typst-library/translations/lt.txt | 8 ++++++++
 2 files changed, 10 insertions(+)
 create mode 100644 crates/typst-library/translations/lt.txt

diff --git a/crates/typst-library/src/text/lang.rs b/crates/typst-library/src/text/lang.rs
index 530b1f004..4f8d1e93f 100644
--- a/crates/typst-library/src/text/lang.rs
+++ b/crates/typst-library/src/text/lang.rs
@@ -37,6 +37,7 @@ const TRANSLATIONS: &[(&str, &str)] = &[
     translation!("it"),
     translation!("ja"),
     translation!("la"),
+    translation!("lt"),
     translation!("lv"),
     translation!("nb"),
     translation!("nl"),
@@ -90,6 +91,7 @@ impl Lang {
     pub const JAPANESE: Self = Self(*b"ja ", 2);
     pub const LATIN: Self = Self(*b"la ", 2);
     pub const LATVIAN: Self = Self(*b"lv ", 2);
+    pub const LITHUANIAN: Self = Self(*b"lt ", 2);
     pub const LOWER_SORBIAN: Self = Self(*b"dsb", 3);
     pub const NYNORSK: Self = Self(*b"nn ", 2);
     pub const POLISH: Self = Self(*b"pl ", 2);
diff --git a/crates/typst-library/translations/lt.txt b/crates/typst-library/translations/lt.txt
new file mode 100644
index 000000000..1df3ca91b
--- /dev/null
+++ b/crates/typst-library/translations/lt.txt
@@ -0,0 +1,8 @@
+figure = Pav.
+table = Lent.
+equation = Lygt.
+bibliography = Literatūra
+heading = Skyrius
+outline = Turinys
+raw = Kodo fragmentas
+page = Psl.

From a43b7e785c3df87e8d2116d911923a9b6a000378 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 21 Jul 2025 13:48:48 +0200
Subject: [PATCH 093/101] Bump CI Rust to 1.88

---
 .github/workflows/ci.yml      | 4 ++--
 .github/workflows/release.yml | 2 +-
 flake.lock                    | 6 +++---
 flake.nix                     | 2 +-
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 70518860e..369a2d5ee 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -40,7 +40,7 @@ jobs:
           sudo dpkg --add-architecture i386
           sudo apt update
           sudo apt install -y gcc-multilib libssl-dev:i386 pkg-config:i386
-      - uses: dtolnay/rust-toolchain@1.87.0
+      - uses: dtolnay/rust-toolchain@1.88.0
         with:
           targets: ${{ matrix.bits == 32 && 'i686-unknown-linux-gnu' || '' }}
       - uses: Swatinem/rust-cache@v2
@@ -73,7 +73,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.87.0
+      - uses: dtolnay/rust-toolchain@1.88.0
         with:
           components: clippy, rustfmt
       - uses: Swatinem/rust-cache@v2
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index ca317abd0..566fc5808 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -44,7 +44,7 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - uses: dtolnay/rust-toolchain@1.87.0
+    - uses: dtolnay/rust-toolchain@1.88.0
       with:
         target: ${{ matrix.target }}
 
diff --git a/flake.lock b/flake.lock
index dedfbb4e0..df8b752ba 100644
--- a/flake.lock
+++ b/flake.lock
@@ -112,13 +112,13 @@
     "rust-manifest": {
       "flake": false,
       "locked": {
-        "narHash": "sha256-BwfxWd/E8gpnXoKsucFXhMbevMlVgw3l0becLkIcWCU=",
+        "narHash": "sha256-YZfjbpqCYQFG1qLl2zMyFq2nFwmB2aFo5DSOCaBtGLY=",
         "type": "file",
-        "url": "https://static.rust-lang.org/dist/channel-rust-1.87.0.toml"
+        "url": "https://static.rust-lang.org/dist/channel-rust-1.88.0.toml"
       },
       "original": {
         "type": "file",
-        "url": "https://static.rust-lang.org/dist/channel-rust-1.87.0.toml"
+        "url": "https://static.rust-lang.org/dist/channel-rust-1.88.0.toml"
       }
     },
     "systems": {
diff --git a/flake.nix b/flake.nix
index cc5f96273..5afb5a846 100644
--- a/flake.nix
+++ b/flake.nix
@@ -10,7 +10,7 @@
       inputs.nixpkgs.follows = "nixpkgs";
     };
     rust-manifest = {
-      url = "https://static.rust-lang.org/dist/channel-rust-1.87.0.toml";
+      url = "https://static.rust-lang.org/dist/channel-rust-1.88.0.toml";
       flake = false;
     };
   };

From eed75ca4d6d547d2a5844dfb8ce3e7df5e065a58 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 21 Jul 2025 13:49:01 +0200
Subject: [PATCH 094/101] Bump MSRV to 1.88

---
 .github/workflows/ci.yml | 6 +++---
 Cargo.toml               | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 369a2d5ee..7180dcad9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -88,7 +88,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.83.0
+      - uses: dtolnay/rust-toolchain@1.88.0
       - uses: Swatinem/rust-cache@v2
       - run: cargo check --workspace
 
@@ -99,7 +99,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2024-10-29
+          toolchain: nightly-2025-05-10
       - uses: Swatinem/rust-cache@v2
       - run: cargo install --locked cargo-fuzz@0.12.0
       - run: cd tests/fuzz && cargo fuzz build --dev
@@ -112,6 +112,6 @@ jobs:
       - uses: dtolnay/rust-toolchain@master
         with:
           components: miri
-          toolchain: nightly-2024-10-29
+          toolchain: nightly-2025-05-10
       - uses: Swatinem/rust-cache@v2
       - run: cargo miri test -p typst-library test_miri
diff --git a/Cargo.toml b/Cargo.toml
index 63ea32b94..0a6678a6a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ resolver = "2"
 
 [workspace.package]
 version = "0.13.1"
-rust-version = "1.83" # also change in ci.yml
+rust-version = "1.88" # also change in ci.yml
 authors = ["The Typst Project Developers"]
 edition = "2021"
 homepage = "https://typst.app"

From 4bbd4e195bf9e6672c0d53205adebca884a98e77 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 21 Jul 2025 14:19:24 +0200
Subject: [PATCH 095/101] Migrate to 2024 edition

---
 Cargo.toml                                           |  2 +-
 crates/typst-ide/src/jump.rs                         |  4 ++--
 crates/typst-layout/src/grid/layouter.rs             |  2 +-
 crates/typst-layout/src/math/lr.rs                   |  4 ++--
 crates/typst-layout/src/math/stretch.rs              |  2 +-
 crates/typst-library/src/engine.rs                   |  2 +-
 .../typst-library/src/introspection/introspector.rs  |  2 +-
 crates/typst-pdf/src/metadata.rs                     |  2 +-
 crates/typst-utils/src/fat.rs                        | 12 ++++++------
 9 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0a6678a6a..43a077ddb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@ resolver = "2"
 version = "0.13.1"
 rust-version = "1.88" # also change in ci.yml
 authors = ["The Typst Project Developers"]
-edition = "2021"
+edition = "2024"
 homepage = "https://typst.app"
 repository = "https://github.com/typst/typst"
 license = "Apache-2.0"
diff --git a/crates/typst-ide/src/jump.rs b/crates/typst-ide/src/jump.rs
index b29bc4a48..c9a53547a 100644
--- a/crates/typst-ide/src/jump.rs
+++ b/crates/typst-ide/src/jump.rs
@@ -50,7 +50,7 @@ pub fn jump_from_click(
     }
 
     // If there's no link, search for a jump target.
-    for (mut pos, item) in frame.items().rev() {
+    for &(mut pos, ref item) in frame.items().rev() {
         match item {
             FrameItem::Group(group) => {
                 let pos = click - pos;
@@ -177,7 +177,7 @@ pub fn jump_from_cursor(
 
 /// Find the position of a span in a frame.
 fn find_in_frame(frame: &Frame, span: Span) -> Option<Point> {
-    for (mut pos, item) in frame.items() {
+    for &(mut pos, ref item) in frame.items() {
         if let FrameItem::Group(group) = item {
             if let Some(point) = find_in_frame(&group.frame, span) {
                 return Some(pos + point.transform(group.transform));
diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index d4f11f470..a5803f830 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -1228,7 +1228,7 @@ impl<'a> GridLayouter<'a> {
                     .skip(parent.y)
                     .take(rowspan)
                     .rev()
-                    .find(|(_, &row)| row == Sizing::Auto)
+                    .find(|&(_, &row)| row == Sizing::Auto)
                     .map(|(y, _)| y);
 
                 if last_spanned_auto_row != Some(y) {
diff --git a/crates/typst-layout/src/math/lr.rs b/crates/typst-layout/src/math/lr.rs
index 2348025e8..cba794935 100644
--- a/crates/typst-layout/src/math/lr.rs
+++ b/crates/typst-layout/src/math/lr.rs
@@ -55,7 +55,7 @@ pub fn layout_lr(
 
     // Handle MathFragment::Glyph fragments that should be scaled up.
     for fragment in inner_fragments.iter_mut() {
-        if let MathFragment::Glyph(ref mut glyph) = fragment {
+        if let MathFragment::Glyph(glyph) = fragment {
             if glyph.mid_stretched == Some(false) {
                 glyph.mid_stretched = Some(true);
                 scale(ctx, fragment, relative_to, height);
@@ -95,7 +95,7 @@ pub fn layout_mid(
     let mut fragments = ctx.layout_into_fragments(&elem.body, styles)?;
 
     for fragment in &mut fragments {
-        if let MathFragment::Glyph(ref mut glyph) = fragment {
+        if let MathFragment::Glyph(glyph) = fragment {
             glyph.mid_stretched = Some(false);
             glyph.class = MathClass::Relation;
         }
diff --git a/crates/typst-layout/src/math/stretch.rs b/crates/typst-layout/src/math/stretch.rs
index f1a22a814..b9a6b15ae 100644
--- a/crates/typst-layout/src/math/stretch.rs
+++ b/crates/typst-layout/src/math/stretch.rs
@@ -37,7 +37,7 @@ pub fn stretch_fragment(
 ) {
     let size = fragment.size();
 
-    let MathFragment::Glyph(ref mut glyph) = fragment else { return };
+    let MathFragment::Glyph(glyph) = fragment else { return };
 
     // Return if we attempt to stretch along an axis which isn't stretchable,
     // so that the original fragment isn't modified.
diff --git a/crates/typst-library/src/engine.rs b/crates/typst-library/src/engine.rs
index 43a7b4671..a85fc8ca2 100644
--- a/crates/typst-library/src/engine.rs
+++ b/crates/typst-library/src/engine.rs
@@ -47,7 +47,7 @@ impl Engine<'_> {
     }
 
     /// Runs tasks on the engine in parallel.
-    pub fn parallelize<P, I, T, U, F>(&mut self, iter: P, f: F) -> impl Iterator<Item = U>
+    pub fn parallelize<P, I, T, U, F>(&mut self, iter: P, f: F) -> impl Iterator<Item = U> + use<P, I, T, U, F>
     where
         P: IntoIterator<IntoIter = I>,
         I: Iterator<Item = T>,
diff --git a/crates/typst-library/src/introspection/introspector.rs b/crates/typst-library/src/introspection/introspector.rs
index 000fbd202..76a0faa35 100644
--- a/crates/typst-library/src/introspection/introspector.rs
+++ b/crates/typst-library/src/introspection/introspector.rs
@@ -327,7 +327,7 @@ where
         self.0.entry(key).or_default().push(value);
     }
 
-    fn take(&mut self, key: &K) -> Option<impl Iterator<Item = V>> {
+    fn take(&mut self, key: &K) -> Option<impl Iterator<Item = V> + use<K, V>> {
         self.0.remove(key).map(|vec| vec.into_iter())
     }
 }
diff --git a/crates/typst-pdf/src/metadata.rs b/crates/typst-pdf/src/metadata.rs
index 7c546b237..d51cb5335 100644
--- a/crates/typst-pdf/src/metadata.rs
+++ b/crates/typst-pdf/src/metadata.rs
@@ -9,7 +9,7 @@ use crate::convert::GlobalContext;
 pub(crate) fn build_metadata(gc: &GlobalContext) -> Metadata {
     let creator = format!("Typst {}", env!("CARGO_PKG_VERSION"));
 
-    let lang = gc.languages.iter().max_by_key(|(_, &count)| count).map(|(&l, _)| l);
+    let lang = gc.languages.iter().max_by_key(|&(_, &count)| count).map(|(&l, _)| l);
 
     let dir = if lang.map(Lang::dir) == Some(Dir::RTL) {
         TextDirection::RightToLeft
diff --git a/crates/typst-utils/src/fat.rs b/crates/typst-utils/src/fat.rs
index b31a2bb1e..40751532b 100644
--- a/crates/typst-utils/src/fat.rs
+++ b/crates/typst-utils/src/fat.rs
@@ -16,11 +16,11 @@ use std::ptr::NonNull;
 /// to a value whose type implements the trait of `T` and the `vtable` must have
 /// been extracted with [`vtable`].
 #[track_caller]
-pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *const T {
+pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *const T { unsafe {
     let fat = FatPointer { data, vtable };
     debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
     mem::transmute_copy::<FatPointer, *const T>(&fat)
-}
+}}
 
 /// Create a mutable fat pointer from a data address and a vtable address.
 ///
@@ -29,23 +29,23 @@ pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *
 /// to a value whose type implements the trait of `T` and the `vtable` must have
 /// been extracted with [`vtable`].
 #[track_caller]
-pub unsafe fn from_raw_parts_mut<T: ?Sized>(data: *mut (), vtable: *const ()) -> *mut T {
+pub unsafe fn from_raw_parts_mut<T: ?Sized>(data: *mut (), vtable: *const ()) -> *mut T { unsafe {
     let fat = FatPointer { data, vtable };
     debug_assert_eq!(Layout::new::<*mut T>(), Layout::new::<FatPointer>());
     mem::transmute_copy::<FatPointer, *mut T>(&fat)
-}
+}}
 
 /// Extract the address to a trait object's vtable.
 ///
 /// # Safety
 /// Must only be called when `T` is a `dyn Trait`.
 #[track_caller]
-pub unsafe fn vtable<T: ?Sized>(ptr: *const T) -> NonNull<()> {
+pub unsafe fn vtable<T: ?Sized>(ptr: *const T) -> NonNull<()> { unsafe {
     debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
     NonNull::new_unchecked(
         mem::transmute_copy::<*const T, FatPointer>(&ptr).vtable as *mut (),
     )
-}
+}}
 
 /// The memory representation of a trait object pointer.
 ///

From c9c2315ad3a5fb7253a6abd8f4efbcb55f16b642 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 21 Jul 2025 14:55:27 +0200
Subject: [PATCH 096/101] Fix 2024 clippy warnings

---
 crates/typst-cli/src/server.rs                |  2 +-
 crates/typst-cli/src/world.rs                 | 10 +++---
 crates/typst-eval/src/access.rs               |  5 ++-
 crates/typst-eval/src/import.rs               | 10 +++---
 crates/typst-eval/src/ops.rs                  |  5 ++-
 crates/typst-eval/src/rules.rs                |  5 ++-
 crates/typst-html/src/rules.rs                |  8 ++---
 crates/typst-ide/src/analyze.rs               | 10 +++---
 crates/typst-ide/src/complete.rs              |  5 ++-
 crates/typst-ide/src/jump.rs                  | 15 ++++-----
 crates/typst-ide/src/matchers.rs              | 17 +++++-----
 crates/typst-ide/src/tooltip.rs               | 10 +++---
 crates/typst-layout/src/flow/block.rs         |  5 ++-
 crates/typst-layout/src/flow/collect.rs       |  5 ++-
 crates/typst-layout/src/grid/layouter.rs      | 28 ++++++-----------
 crates/typst-layout/src/grid/lines.rs         | 10 +++---
 crates/typst-layout/src/grid/repeated.rs      |  5 ++-
 crates/typst-layout/src/grid/rowspans.rs      | 10 +++---
 crates/typst-layout/src/inline/collect.rs     |  5 ++-
 crates/typst-layout/src/inline/line.rs        | 31 +++++++------------
 crates/typst-layout/src/inline/linebreak.rs   |  5 ++-
 crates/typst-layout/src/math/fragment.rs      |  4 +--
 crates/typst-layout/src/math/lr.rs            | 10 +++---
 crates/typst-layout/src/math/mod.rs           |  5 ++-
 crates/typst-layout/src/math/run.rs           | 15 ++++-----
 crates/typst-library/src/diag.rs              |  5 ++-
 crates/typst-library/src/foundations/cast.rs  |  5 ++-
 .../src/foundations/content/mod.rs            |  5 ++-
 crates/typst-library/src/layout/corners.rs    |  5 ++-
 .../typst-library/src/layout/grid/resolve.rs  |  5 ++-
 crates/typst-library/src/layout/page.rs       |  5 ++-
 crates/typst-library/src/layout/sides.rs      |  5 ++-
 .../typst-library/src/model/bibliography.rs   |  5 ++-
 crates/typst-library/src/model/reference.rs   |  5 ++-
 crates/typst-library/src/text/font/book.rs    |  9 ++----
 crates/typst-library/src/text/lang.rs         |  8 ++---
 crates/typst-library/src/text/mod.rs          |  5 ++-
 crates/typst-library/src/text/raw.rs          |  5 ++-
 crates/typst-library/src/visualize/color.rs   |  5 ++-
 crates/typst-macros/src/scope.rs              |  8 ++---
 crates/typst-macros/src/util.rs               | 11 +++----
 crates/typst-pdf/src/outline.rs               |  5 ++-
 crates/typst-realize/src/lib.rs               | 10 +++---
 crates/typst-render/src/lib.rs                |  5 ++-
 crates/typst-render/src/text.rs               |  4 +--
 crates/typst-svg/src/lib.rs                   |  5 ++-
 crates/typst-syntax/src/highlight.rs          | 10 +++---
 crates/typst-syntax/src/lexer.rs              |  5 ++-
 crates/typst-syntax/src/node.rs               |  4 +--
 crates/typst-syntax/src/parser.rs             | 15 ++++-----
 crates/typst-syntax/src/reparser.rs           |  5 ++-
 docs/src/link.rs                              |  5 ++-
 tests/fuzz/src/compile.rs                     |  5 ++-
 53 files changed, 162 insertions(+), 252 deletions(-)

diff --git a/crates/typst-cli/src/server.rs b/crates/typst-cli/src/server.rs
index 8910e0323..11c564e8d 100644
--- a/crates/typst-cli/src/server.rs
+++ b/crates/typst-cli/src/server.rs
@@ -162,7 +162,7 @@ impl<T> Bucket<T> {
     }
 
     /// Retrieves the current data in the bucket.
-    fn get(&self) -> MutexGuard<T> {
+    fn get(&self) -> MutexGuard<'_, T> {
         self.mutex.lock()
     }
 
diff --git a/crates/typst-cli/src/world.rs b/crates/typst-cli/src/world.rs
index 8ad766b14..900199354 100644
--- a/crates/typst-cli/src/world.rs
+++ b/crates/typst-cli/src/world.rs
@@ -361,22 +361,20 @@ impl<T: Clone> SlotCell<T> {
         f: impl FnOnce(Vec<u8>, Option<T>) -> FileResult<T>,
     ) -> FileResult<T> {
         // If we accessed the file already in this compilation, retrieve it.
-        if mem::replace(&mut self.accessed, true) {
-            if let Some(data) = &self.data {
+        if mem::replace(&mut self.accessed, true)
+            && let Some(data) = &self.data {
                 return data.clone();
             }
-        }
 
         // Read and hash the file.
         let result = timed!("loading file", load());
         let fingerprint = timed!("hashing file", typst::utils::hash128(&result));
 
         // If the file contents didn't change, yield the old processed data.
-        if mem::replace(&mut self.fingerprint, fingerprint) == fingerprint {
-            if let Some(data) = &self.data {
+        if mem::replace(&mut self.fingerprint, fingerprint) == fingerprint
+            && let Some(data) = &self.data {
                 return data.clone();
             }
-        }
 
         let prev = self.data.take().and_then(Result::ok);
         let value = result.and_then(|data| f(data, prev));
diff --git a/crates/typst-eval/src/access.rs b/crates/typst-eval/src/access.rs
index 22a6b7f3d..ddcc8b98b 100644
--- a/crates/typst-eval/src/access.rs
+++ b/crates/typst-eval/src/access.rs
@@ -29,11 +29,10 @@ impl Access for ast::Expr<'_> {
 impl Access for ast::Ident<'_> {
     fn access<'a>(self, vm: &'a mut Vm) -> SourceResult<&'a mut Value> {
         let span = self.span();
-        if vm.inspected == Some(span) {
-            if let Ok(binding) = vm.scopes.get(&self) {
+        if vm.inspected == Some(span)
+            && let Ok(binding) = vm.scopes.get(&self) {
                 vm.trace(binding.read().clone());
             }
-        }
         vm.scopes
             .get_mut(&self)
             .and_then(|b| b.write().map_err(Into::into))
diff --git a/crates/typst-eval/src/import.rs b/crates/typst-eval/src/import.rs
index 1b1641487..138d7ccfe 100644
--- a/crates/typst-eval/src/import.rs
+++ b/crates/typst-eval/src/import.rs
@@ -46,15 +46,14 @@ impl Eval for ast::ModuleImport<'_> {
         // If there is a rename, import the source itself under that name.
         let new_name = self.new_name();
         if let Some(new_name) = new_name {
-            if let ast::Expr::Ident(ident) = self.source() {
-                if ident.as_str() == new_name.as_str() {
+            if let ast::Expr::Ident(ident) = self.source()
+                && ident.as_str() == new_name.as_str() {
                     // Warn on `import x as x`
                     vm.engine.sink.warn(warning!(
                         new_name.span(),
                         "unnecessary import rename to same name",
                     ));
                 }
-            }
 
             // Define renamed module on the scope.
             vm.define(new_name, source.clone());
@@ -142,8 +141,8 @@ impl Eval for ast::ModuleImport<'_> {
                             // it.
 
                             // Warn on `import ...: x as x`
-                            if let ast::ImportItem::Renamed(renamed_item) = &item {
-                                if renamed_item.original_name().as_str()
+                            if let ast::ImportItem::Renamed(renamed_item) = &item
+                                && renamed_item.original_name().as_str()
                                     == renamed_item.new_name().as_str()
                                 {
                                     vm.engine.sink.warn(warning!(
@@ -151,7 +150,6 @@ impl Eval for ast::ModuleImport<'_> {
                                         "unnecessary import rename to same name",
                                     ));
                                 }
-                            }
 
                             vm.bind(item.bound_name(), binding.clone());
                         }
diff --git a/crates/typst-eval/src/ops.rs b/crates/typst-eval/src/ops.rs
index ebbd67430..9a8eb5239 100644
--- a/crates/typst-eval/src/ops.rs
+++ b/crates/typst-eval/src/ops.rs
@@ -76,13 +76,12 @@ fn apply_assignment(
 
     // An assignment to a dictionary field is different from a normal access
     // since it can create the field instead of just modifying it.
-    if binary.op() == ast::BinOp::Assign {
-        if let ast::Expr::FieldAccess(access) = lhs {
+    if binary.op() == ast::BinOp::Assign
+        && let ast::Expr::FieldAccess(access) = lhs {
             let dict = access_dict(vm, access)?;
             dict.insert(access.field().get().clone().into(), rhs);
             return Ok(Value::None);
         }
-    }
 
     let location = binary.lhs().access(vm)?;
     let lhs = std::mem::take(&mut *location);
diff --git a/crates/typst-eval/src/rules.rs b/crates/typst-eval/src/rules.rs
index eb6a1e6da..36fde561c 100644
--- a/crates/typst-eval/src/rules.rs
+++ b/crates/typst-eval/src/rules.rs
@@ -12,11 +12,10 @@ impl Eval for ast::SetRule<'_> {
     type Output = Styles;
 
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
-        if let Some(condition) = self.condition() {
-            if !condition.eval(vm)?.cast::<bool>().at(condition.span())? {
+        if let Some(condition) = self.condition()
+            && !condition.eval(vm)?.cast::<bool>().at(condition.span())? {
                 return Ok(Styles::new());
             }
-        }
 
         let target = self.target();
         let target = target
diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index 3d215d56e..14885bd36 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -238,14 +238,12 @@ const QUOTE_RULE: ShowFn<QuoteElem> = |elem, _, styles| {
 
     if block {
         let mut blockquote = HtmlElem::new(tag::blockquote).with_body(Some(realized));
-        if let Some(Attribution::Content(attribution)) = attribution {
-            if let Some(link) = attribution.to_packed::<LinkElem>() {
-                if let LinkTarget::Dest(Destination::Url(url)) = &link.dest {
+        if let Some(Attribution::Content(attribution)) = attribution
+            && let Some(link) = attribution.to_packed::<LinkElem>()
+                && let LinkTarget::Dest(Destination::Url(url)) = &link.dest {
                     blockquote =
                         blockquote.with_attr(attr::cite, url.clone().into_inner());
                 }
-            }
-        }
 
         realized = blockquote.pack().spanned(span);
 
diff --git a/crates/typst-ide/src/analyze.rs b/crates/typst-ide/src/analyze.rs
index e9fb8a7d7..e7fd8af8e 100644
--- a/crates/typst-ide/src/analyze.rs
+++ b/crates/typst-ide/src/analyze.rs
@@ -27,17 +27,15 @@ pub fn analyze_expr(
         ast::Expr::Numeric(v) => Value::numeric(v.get()),
         ast::Expr::Str(v) => Value::Str(v.get().into()),
         _ => {
-            if node.kind() == SyntaxKind::Contextual {
-                if let Some(child) = node.children().next_back() {
+            if node.kind() == SyntaxKind::Contextual
+                && let Some(child) = node.children().next_back() {
                     return analyze_expr(world, &child);
                 }
-            }
 
-            if let Some(parent) = node.parent() {
-                if parent.kind() == SyntaxKind::FieldAccess && node.index() > 0 {
+            if let Some(parent) = node.parent()
+                && parent.kind() == SyntaxKind::FieldAccess && node.index() > 0 {
                     return analyze_expr(world, parent);
                 }
-            }
 
             return typst::trace::<PagedDocument>(world.upcast(), node.span());
         }
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index 5b6d6fd97..6cde69f3c 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -1382,11 +1382,10 @@ impl<'a> CompletionContext<'a> {
             }
         } else if at {
             apply = Some(eco_format!("at(\"{label}\")"));
-        } else if label.starts_with('"') && self.after.starts_with('"') {
-            if let Some(trimmed) = label.strip_suffix('"') {
+        } else if label.starts_with('"') && self.after.starts_with('"')
+            && let Some(trimmed) = label.strip_suffix('"') {
                 apply = Some(trimmed.into());
             }
-        }
 
         self.completions.push(Completion {
             kind: kind.unwrap_or_else(|| match value {
diff --git a/crates/typst-ide/src/jump.rs b/crates/typst-ide/src/jump.rs
index c9a53547a..f0035163b 100644
--- a/crates/typst-ide/src/jump.rs
+++ b/crates/typst-ide/src/jump.rs
@@ -36,8 +36,8 @@ pub fn jump_from_click(
 ) -> Option<Jump> {
     // Try to find a link first.
     for (pos, item) in frame.items() {
-        if let FrameItem::Link(dest, size) = item {
-            if is_in_rect(*pos, *size, click) {
+        if let FrameItem::Link(dest, size) = item
+            && is_in_rect(*pos, *size, click) {
                 return Some(match dest {
                     Destination::Url(url) => Jump::Url(url.clone()),
                     Destination::Position(pos) => Jump::Position(*pos),
@@ -46,7 +46,6 @@ pub fn jump_from_click(
                     }
                 });
             }
-        }
     }
 
     // If there's no link, search for a jump target.
@@ -54,11 +53,10 @@ pub fn jump_from_click(
         match item {
             FrameItem::Group(group) => {
                 let pos = click - pos;
-                if let Some(clip) = &group.clip {
-                    if !clip.contains(FillRule::NonZero, pos) {
+                if let Some(clip) = &group.clip
+                    && !clip.contains(FillRule::NonZero, pos) {
                         continue;
                     }
-                }
                 // Realistic transforms should always be invertible.
                 // An example of one that isn't is a scale of 0, which would
                 // not be clickable anyway.
@@ -178,11 +176,10 @@ pub fn jump_from_cursor(
 /// Find the position of a span in a frame.
 fn find_in_frame(frame: &Frame, span: Span) -> Option<Point> {
     for &(mut pos, ref item) in frame.items() {
-        if let FrameItem::Group(group) = item {
-            if let Some(point) = find_in_frame(&group.frame, span) {
+        if let FrameItem::Group(group) = item
+            && let Some(point) = find_in_frame(&group.frame, span) {
                 return Some(pos + point.transform(group.transform));
             }
-        }
 
         if let FrameItem::Text(text) = item {
             for glyph in &text.glyphs {
diff --git a/crates/typst-ide/src/matchers.rs b/crates/typst-ide/src/matchers.rs
index 93fdc5dd5..709d1d156 100644
--- a/crates/typst-ide/src/matchers.rs
+++ b/crates/typst-ide/src/matchers.rs
@@ -59,11 +59,10 @@ pub fn named_items<T>(
                 };
 
                 // Seeing the module itself.
-                if let Some((name, span)) = name_and_span {
-                    if let Some(res) = recv(NamedItem::Module(&name, span, module)) {
+                if let Some((name, span)) = name_and_span
+                    && let Some(res) = recv(NamedItem::Module(&name, span, module)) {
                         return Some(res);
                     }
-                }
 
                 // Seeing the imported items.
                 match imports {
@@ -124,8 +123,8 @@ pub fn named_items<T>(
         }
 
         if let Some(parent) = node.parent() {
-            if let Some(v) = parent.cast::<ast::ForLoop>() {
-                if node.prev_sibling_kind() != Some(SyntaxKind::In) {
+            if let Some(v) = parent.cast::<ast::ForLoop>()
+                && node.prev_sibling_kind() != Some(SyntaxKind::In) {
                     let pattern = v.pattern();
                     for ident in pattern.bindings() {
                         if let Some(res) = recv(NamedItem::Var(ident)) {
@@ -133,7 +132,6 @@ pub fn named_items<T>(
                         }
                     }
                 }
-            }
 
             if let Some(v) = parent.cast::<ast::Closure>().filter(|v| {
                 // Check if the node is in the body of the closure.
@@ -155,11 +153,10 @@ pub fn named_items<T>(
                             }
                         }
                         ast::Param::Spread(s) => {
-                            if let Some(sink_ident) = s.sink_ident() {
-                                if let Some(t) = recv(NamedItem::Var(sink_ident)) {
+                            if let Some(sink_ident) = s.sink_ident()
+                                && let Some(t) = recv(NamedItem::Var(sink_ident)) {
                                     return Some(t);
                                 }
-                            }
                         }
                     }
                 }
@@ -216,7 +213,7 @@ impl<'a> NamedItem<'a> {
 
 /// Categorize an expression into common classes IDE functionality can operate
 /// on.
-pub fn deref_target(node: LinkedNode) -> Option<DerefTarget<'_>> {
+pub fn deref_target(node: LinkedNode<'_>) -> Option<DerefTarget<'_>> {
     // Move to the first ancestor that is an expression.
     let mut ancestor = node;
     while !ancestor.is::<ast::Expr>() {
diff --git a/crates/typst-ide/src/tooltip.rs b/crates/typst-ide/src/tooltip.rs
index e0d66a89b..700414637 100644
--- a/crates/typst-ide/src/tooltip.rs
+++ b/crates/typst-ide/src/tooltip.rs
@@ -66,11 +66,10 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
             return Some(Tooltip::Text(plain_docs_sentence(docs)));
         }
 
-        if let &Value::Length(length) = value {
-            if let Some(tooltip) = length_tooltip(length) {
+        if let &Value::Length(length) = value
+            && let Some(tooltip) = length_tooltip(length) {
                 return Some(tooltip);
             }
-        }
     }
 
     if expr.is_literal() {
@@ -93,11 +92,10 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
         last = Some((value, 1));
     }
 
-    if let Some((_, count)) = last {
-        if count > 1 {
+    if let Some((_, count)) = last
+        && count > 1 {
             write!(pieces.last_mut().unwrap(), " (×{count})").unwrap();
         }
-    }
 
     if iter.next().is_some() {
         pieces.push("...".into());
diff --git a/crates/typst-layout/src/flow/block.rs b/crates/typst-layout/src/flow/block.rs
index d6cfe3a9e..11096dc7a 100644
--- a/crates/typst-layout/src/flow/block.rs
+++ b/crates/typst-layout/src/flow/block.rs
@@ -407,11 +407,10 @@ fn distribute<'a>(
     // If there is still something remaining, apply it to the
     // last region (it will overflow, but there's nothing else
     // we can do).
-    if !remaining.approx_empty() {
-        if let Some(last) = buf.last_mut() {
+    if !remaining.approx_empty()
+        && let Some(last) = buf.last_mut() {
             *last += remaining;
         }
-    }
 
     // Distribute the heights to the first region and the
     // backlog. There is no last region, since the height is
diff --git a/crates/typst-layout/src/flow/collect.rs b/crates/typst-layout/src/flow/collect.rs
index 76268b590..561b578bb 100644
--- a/crates/typst-layout/src/flow/collect.rs
+++ b/crates/typst-layout/src/flow/collect.rs
@@ -684,11 +684,10 @@ impl<T> CachedCell<T> {
         let input_hash = typst_utils::hash128(&input);
 
         let mut slot = self.0.borrow_mut();
-        if let Some((hash, output)) = &*slot {
-            if *hash == input_hash {
+        if let Some((hash, output)) = &*slot
+            && *hash == input_hash {
                 return output.clone();
             }
-        }
 
         let output = f(input);
         *slot = Some((input_hash, output.clone()));
diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index a5803f830..ee613f8f2 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -274,32 +274,29 @@ impl<'a> GridLayouter<'a> {
     pub fn layout(mut self, engine: &mut Engine) -> SourceResult<Fragment> {
         self.measure_columns(engine)?;
 
-        if let Some(footer) = &self.grid.footer {
-            if footer.repeated {
+        if let Some(footer) = &self.grid.footer
+            && footer.repeated {
                 // Ensure rows in the first region will be aware of the
                 // possible presence of the footer.
                 self.prepare_footer(footer, engine, 0)?;
                 self.regions.size.y -= self.current.footer_height;
                 self.current.initial_after_repeats = self.regions.size.y;
             }
-        }
 
         let mut y = 0;
         let mut consecutive_header_count = 0;
         while y < self.grid.rows.len() {
             if let Some(next_header) = self.upcoming_headers.get(consecutive_header_count)
-            {
-                if next_header.range.contains(&y) {
+                && next_header.range.contains(&y) {
                     self.place_new_headers(&mut consecutive_header_count, engine)?;
                     y = next_header.range.end;
 
                     // Skip header rows during normal layout.
                     continue;
                 }
-            }
 
-            if let Some(footer) = &self.grid.footer {
-                if footer.repeated && y >= footer.start {
+            if let Some(footer) = &self.grid.footer
+                && footer.repeated && y >= footer.start {
                     if y == footer.start {
                         self.layout_footer(footer, engine, self.finished.len())?;
                         self.flush_orphans();
@@ -307,7 +304,6 @@ impl<'a> GridLayouter<'a> {
                     y = footer.end;
                     continue;
                 }
-            }
 
             self.layout_row(y, engine, 0)?;
 
@@ -1283,15 +1279,13 @@ impl<'a> GridLayouter<'a> {
             // remeasure.
             if let Some([first, rest @ ..]) =
                 frames.get(measurement_data.frames_in_previous_regions..)
-            {
-                if can_skip
+                && can_skip
                     && breakable
                     && first.is_empty()
                     && rest.iter().any(|frame| !frame.is_empty())
                 {
                     return Ok(None);
                 }
-            }
 
             // Skip frames from previous regions if applicable.
             let mut sizes = frames
@@ -1529,8 +1523,8 @@ impl<'a> GridLayouter<'a> {
         // The latest rows have orphan prevention (headers) and no other rows
         // were placed, so remove those rows and try again in a new region,
         // unless this is the last region.
-        if let Some(orphan_snapshot) = self.current.lrows_orphan_snapshot.take() {
-            if !last {
+        if let Some(orphan_snapshot) = self.current.lrows_orphan_snapshot.take()
+            && !last {
                 self.current.lrows.truncate(orphan_snapshot);
                 self.current.repeated_header_rows =
                     self.current.repeated_header_rows.min(orphan_snapshot);
@@ -1540,7 +1534,6 @@ impl<'a> GridLayouter<'a> {
                     self.current.last_repeated_header_end = 0;
                 }
             }
-        }
 
         if self
             .current
@@ -1571,8 +1564,8 @@ impl<'a> GridLayouter<'a> {
             && self.current.could_progress_at_top;
 
         let mut laid_out_footer_start = None;
-        if !footer_would_be_widow {
-            if let Some(footer) = &self.grid.footer {
+        if !footer_would_be_widow
+            && let Some(footer) = &self.grid.footer {
                 // Don't layout the footer if it would be alone with the header
                 // in the page (hence the widow check), and don't layout it
                 // twice (check below).
@@ -1587,7 +1580,6 @@ impl<'a> GridLayouter<'a> {
                     self.layout_footer(footer, engine, self.finished.len())?;
                 }
             }
-        }
 
         // Determine the height of existing rows in the region.
         let mut used = Abs::zero();
diff --git a/crates/typst-layout/src/grid/lines.rs b/crates/typst-layout/src/grid/lines.rs
index d5da7e263..0b823c07d 100644
--- a/crates/typst-layout/src/grid/lines.rs
+++ b/crates/typst-layout/src/grid/lines.rs
@@ -291,13 +291,12 @@ pub fn vline_stroke_at_row(
         // We would then analyze the cell one column after (if at a gutter
         // column), and/or one row below (if at a gutter row), in order to
         // check if it would be merged with a cell before the vline.
-        if let Some(parent) = grid.effective_parent_cell_position(x, y) {
-            if parent.x < x {
+        if let Some(parent) = grid.effective_parent_cell_position(x, y)
+            && parent.x < x {
                 // There is a colspan cell going through this vline's position,
                 // so don't draw it here.
                 return None;
             }
-        }
     }
 
     let (left_cell_stroke, left_cell_prioritized) = x
@@ -416,8 +415,8 @@ pub fn hline_stroke_at_column(
         // We would then analyze the cell one column after (if at a gutter
         // column), and/or one row below (if at a gutter row), in order to
         // check if it would be merged with a cell before the hline.
-        if let Some(parent) = grid.effective_parent_cell_position(x, y) {
-            if parent.y < y {
+        if let Some(parent) = grid.effective_parent_cell_position(x, y)
+            && parent.y < y {
                 // Get the first 'y' spanned by the possible rowspan in this region.
                 // The 'parent.y' row and any other spanned rows above 'y' could be
                 // missing from this region, which could have lead the check above
@@ -437,7 +436,6 @@ pub fn hline_stroke_at_column(
                     return None;
                 }
             }
-        }
     }
 
     // When the hline is at the top of the region and this isn't the first
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 8db33df5e..573ef1a47 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -240,8 +240,8 @@ impl<'a> GridLayouter<'a> {
             self.current.initial_after_repeats = self.regions.size.y;
         }
 
-        if let Some(footer) = &self.grid.footer {
-            if footer.repeated && skipped_region {
+        if let Some(footer) = &self.grid.footer
+            && footer.repeated && skipped_region {
                 // Simulate the footer again; the region's 'full' might have
                 // changed.
                 self.regions.size.y += self.current.footer_height;
@@ -250,7 +250,6 @@ impl<'a> GridLayouter<'a> {
                     .height;
                 self.regions.size.y -= self.current.footer_height;
             }
-        }
 
         let repeating_header_rows =
             total_header_row_count(self.repeating_headers.iter().copied());
diff --git a/crates/typst-layout/src/grid/rowspans.rs b/crates/typst-layout/src/grid/rowspans.rs
index 02ea14813..c31bfcb28 100644
--- a/crates/typst-layout/src/grid/rowspans.rs
+++ b/crates/typst-layout/src/grid/rowspans.rs
@@ -238,8 +238,8 @@ impl GridLayouter<'_> {
             // current row is dynamic and depends on the amount of upcoming
             // unbreakable cells (with or without a rowspan setting).
             let mut amount_unbreakable_rows = None;
-            if let Some(footer) = &self.grid.footer {
-                if !footer.repeated && current_row >= footer.start {
+            if let Some(footer) = &self.grid.footer
+                && !footer.repeated && current_row >= footer.start {
                     // Non-repeated footer, so keep it unbreakable.
                     //
                     // TODO(subfooters): This will become unnecessary
@@ -247,7 +247,6 @@ impl GridLayouter<'_> {
                     // have widow prevention.
                     amount_unbreakable_rows = Some(self.grid.rows.len() - footer.start);
                 }
-            }
 
             let row_group = self.simulate_unbreakable_row_group(
                 current_row,
@@ -1268,9 +1267,8 @@ fn subtract_end_sizes(sizes: &mut Vec<Abs>, mut subtract: Abs) {
     while subtract > Abs::zero() && sizes.last().is_some_and(|&size| size <= subtract) {
         subtract -= sizes.pop().unwrap();
     }
-    if subtract > Abs::zero() {
-        if let Some(last_size) = sizes.last_mut() {
+    if subtract > Abs::zero()
+        && let Some(last_size) = sizes.last_mut() {
             *last_size -= subtract;
         }
-    }
 }
diff --git a/crates/typst-layout/src/inline/collect.rs b/crates/typst-layout/src/inline/collect.rs
index 2744b31e0..1856cb13d 100644
--- a/crates/typst-layout/src/inline/collect.rs
+++ b/crates/typst-layout/src/inline/collect.rs
@@ -274,12 +274,11 @@ impl<'a> Collector<'a> {
         let segment_len = self.full.len() - prev;
 
         // Merge adjacent text segments with the same styles.
-        if let Some(Segment::Text(last_len, last_styles)) = self.segments.last_mut() {
-            if *last_styles == styles {
+        if let Some(Segment::Text(last_len, last_styles)) = self.segments.last_mut()
+            && *last_styles == styles {
                 *last_len += segment_len;
                 return;
             }
-        }
 
         self.segments.push(Segment::Text(segment_len, styles));
     }
diff --git a/crates/typst-layout/src/inline/line.rs b/crates/typst-layout/src/inline/line.rs
index 58162d12b..2d921b394 100644
--- a/crates/typst-layout/src/inline/line.rs
+++ b/crates/typst-layout/src/inline/line.rs
@@ -155,18 +155,16 @@ pub fn line<'a>(
     let mut items = collect_items(engine, p, range, trim);
 
     // Add a hyphen at the line start, if a previous dash should be repeated.
-    if pred.is_some_and(|pred| should_repeat_hyphen(pred, full)) {
-        if let Some(shaped) = items.first_text_mut() {
+    if pred.is_some_and(|pred| should_repeat_hyphen(pred, full))
+        && let Some(shaped) = items.first_text_mut() {
             shaped.prepend_hyphen(engine, p.config.fallback);
         }
-    }
 
     // Add a hyphen at the line end, if we ended on a soft hyphen.
-    if dash == Some(Dash::Soft) {
-        if let Some(shaped) = items.last_text_mut() {
+    if dash == Some(Dash::Soft)
+        && let Some(shaped) = items.last_text_mut() {
             shaped.push_hyphen(engine, p.config.fallback);
         }
-    }
 
     // Deal with CJ characters at line boundaries.
     adjust_cj_at_line_boundaries(p, full, &mut items);
@@ -218,11 +216,10 @@ 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 {
+    if !items.iter().any(|item| matches!(item, Item::Text(_)))
+        && let Some(fallback) = fallback {
             items.push(fallback, usize::MAX);
         }
-    }
 
     items
 }
@@ -461,9 +458,9 @@ pub fn commit(
     }
 
     // Handle hanging punctuation to the left.
-    if let Some(Item::Text(text)) = line.items.first() {
-        if let Some(glyph) = text.glyphs.first() {
-            if !text.dir.is_positive()
+    if let Some(Item::Text(text)) = line.items.first()
+        && let Some(glyph) = text.glyphs.first()
+            && !text.dir.is_positive()
                 && text.styles.get(TextElem::overhang)
                 && (line.items.len() > 1 || text.glyphs.len() > 1)
             {
@@ -471,21 +468,17 @@ pub fn commit(
                 offset -= amount;
                 remaining += amount;
             }
-        }
-    }
 
     // Handle hanging punctuation to the right.
-    if let Some(Item::Text(text)) = line.items.last() {
-        if let Some(glyph) = text.glyphs.last() {
-            if text.dir.is_positive()
+    if let Some(Item::Text(text)) = line.items.last()
+        && let Some(glyph) = text.glyphs.last()
+            && text.dir.is_positive()
                 && text.styles.get(TextElem::overhang)
                 && (line.items.len() > 1 || text.glyphs.len() > 1)
             {
                 let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
                 remaining += amount;
             }
-        }
-    }
 
     // Determine how much additional space is needed. The justification_ratio is
     // for the first step justification, extra_justification is for the last
diff --git a/crates/typst-layout/src/inline/linebreak.rs b/crates/typst-layout/src/inline/linebreak.rs
index 955360df1..e40027edb 100644
--- a/crates/typst-layout/src/inline/linebreak.rs
+++ b/crates/typst-layout/src/inline/linebreak.rs
@@ -136,13 +136,12 @@ fn linebreak_simple<'a>(
         // If the line doesn't fit anymore, we push the last fitting attempt
         // into the stack and rebuild the line from the attempt's end. The
         // resulting line cannot be broken up further.
-        if !width.fits(attempt.width) {
-            if let Some((last_attempt, last_end)) = last.take() {
+        if !width.fits(attempt.width)
+            && let Some((last_attempt, last_end)) = last.take() {
                 lines.push(last_attempt);
                 start = last_end;
                 attempt = line(engine, p, start..end, breakpoint, lines.last());
             }
-        }
 
         // Finish the current line if there is a mandatory line break (i.e. due
         // to "\n") or if the line doesn't fit horizontally already since then
diff --git a/crates/typst-layout/src/math/fragment.rs b/crates/typst-layout/src/math/fragment.rs
index 758dd401f..877158100 100644
--- a/crates/typst-layout/src/math/fragment.rs
+++ b/crates/typst-layout/src/math/fragment.rs
@@ -681,7 +681,7 @@ fn min_connector_overlap(font: &Font) -> Option<Em> {
         .map(|variants| font.to_em(variants.min_connector_overlap))
 }
 
-fn glyph_construction(font: &Font, id: GlyphId, axis: Axis) -> Option<GlyphConstruction> {
+fn glyph_construction(font: &Font, id: GlyphId, axis: Axis) -> Option<GlyphConstruction<'_>> {
     font.ttf()
         .tables()
         .math?
@@ -810,7 +810,7 @@ fn assemble(
 
 /// Return an iterator over the assembly's parts with extenders repeated the
 /// specified number of times.
-fn parts(assembly: GlyphAssembly, repeat: usize) -> impl Iterator<Item = GlyphPart> + '_ {
+fn parts(assembly: GlyphAssembly<'_>, repeat: usize) -> impl Iterator<Item = GlyphPart> + '_ {
     assembly.parts.into_iter().flat_map(move |part| {
         let count = if part.part_flags.extender() { repeat } else { 1 };
         std::iter::repeat_n(part, count)
diff --git a/crates/typst-layout/src/math/lr.rs b/crates/typst-layout/src/math/lr.rs
index cba794935..59dac03af 100644
--- a/crates/typst-layout/src/math/lr.rs
+++ b/crates/typst-layout/src/math/lr.rs
@@ -21,11 +21,10 @@ pub fn layout_lr(
     }
 
     // Extract implicit LrElem.
-    if let Some(lr) = body.to_packed::<LrElem>() {
-        if lr.size.get(styles).is_one() {
+    if let Some(lr) = body.to_packed::<LrElem>()
+        && lr.size.get(styles).is_one() {
             body = &lr.body;
         }
-    }
 
     let mut fragments = ctx.layout_into_fragments(body, styles)?;
 
@@ -55,12 +54,11 @@ pub fn layout_lr(
 
     // Handle MathFragment::Glyph fragments that should be scaled up.
     for fragment in inner_fragments.iter_mut() {
-        if let MathFragment::Glyph(glyph) = fragment {
-            if glyph.mid_stretched == Some(false) {
+        if let MathFragment::Glyph(glyph) = fragment
+            && glyph.mid_stretched == Some(false) {
                 glyph.mid_stretched = Some(true);
                 scale(ctx, fragment, relative_to, height);
             }
-        }
     }
 
     // Remove weak SpacingFragment immediately after the opening or immediately
diff --git a/crates/typst-layout/src/math/mod.rs b/crates/typst-layout/src/math/mod.rs
index 390835067..5ee3e14a8 100644
--- a/crates/typst-layout/src/math/mod.rs
+++ b/crates/typst-layout/src/math/mod.rs
@@ -603,14 +603,13 @@ fn layout_h(
     ctx: &mut MathContext,
     styles: StyleChain,
 ) -> SourceResult<()> {
-    if let Spacing::Rel(rel) = elem.amount {
-        if rel.rel.is_zero() {
+    if let Spacing::Rel(rel) = elem.amount
+        && rel.rel.is_zero() {
             ctx.push(MathFragment::Spacing(
                 rel.abs.resolve(styles),
                 elem.weak.get(styles),
             ));
         }
-    }
     Ok(())
 }
 
diff --git a/crates/typst-layout/src/math/run.rs b/crates/typst-layout/src/math/run.rs
index 161fa1062..fb206dc2e 100644
--- a/crates/typst-layout/src/math/run.rs
+++ b/crates/typst-layout/src/math/run.rs
@@ -87,11 +87,10 @@ impl MathRun {
 
             // Insert spacing between the last and this non-ignorant item.
             if !fragment.is_ignorant() {
-                if let Some(i) = last {
-                    if let Some(s) = spacing(&resolved[i], space.take(), &fragment) {
+                if let Some(i) = last
+                    && let Some(s) = spacing(&resolved[i], space.take(), &fragment) {
                         resolved.insert(i + 1, s);
                     }
-                }
 
                 last = Some(resolved.len());
             }
@@ -123,11 +122,10 @@ impl MathRun {
             1 + self.0.iter().filter(|f| matches!(f, MathFragment::Linebreak)).count();
 
         // A linebreak at the very end does not introduce an extra row.
-        if let Some(f) = self.0.last() {
-            if matches!(f, MathFragment::Linebreak) {
+        if let Some(f) = self.0.last()
+            && matches!(f, MathFragment::Linebreak) {
                 count -= 1
             }
-        }
         count
     }
 
@@ -344,11 +342,10 @@ impl MathRun {
                 descent = Abs::zero();
 
                 space_is_visible = true;
-                if let Some(f_next) = iter.peek() {
-                    if !is_space(f_next) {
+                if let Some(f_next) = iter.peek()
+                    && !is_space(f_next) {
                         items.push(InlineItem::Space(Abs::zero(), true));
                     }
-                }
             } else {
                 space_is_visible = false;
             }
diff --git a/crates/typst-library/src/diag.rs b/crates/typst-library/src/diag.rs
index 41b92ed65..611ec6338 100644
--- a/crates/typst-library/src/diag.rs
+++ b/crates/typst-library/src/diag.rs
@@ -296,14 +296,13 @@ impl<T> Trace<T> for SourceResult<T> {
             let Some(trace_range) = world.range(span) else { return errors };
             for error in errors.make_mut().iter_mut() {
                 // Skip traces that surround the error.
-                if let Some(error_range) = world.range(error.span) {
-                    if error.span.id() == span.id()
+                if let Some(error_range) = world.range(error.span)
+                    && error.span.id() == span.id()
                         && trace_range.start <= error_range.start
                         && trace_range.end >= error_range.end
                     {
                         continue;
                     }
-                }
 
                 error.trace.push(Spanned::new(make_point(), span));
             }
diff --git a/crates/typst-library/src/foundations/cast.rs b/crates/typst-library/src/foundations/cast.rs
index 5e0ba688e..17d194e1a 100644
--- a/crates/typst-library/src/foundations/cast.rs
+++ b/crates/typst-library/src/foundations/cast.rs
@@ -347,14 +347,13 @@ impl CastInfo {
                     msg.hint(eco_format!("use `label({})` to create a label", s.repr()));
                 }
             }
-        } else if let Value::Decimal(_) = found {
-            if !matching_type && parts.iter().any(|p| p == "float") {
+        } else if let Value::Decimal(_) = found
+            && !matching_type && parts.iter().any(|p| p == "float") {
                 msg.hint(eco_format!(
                     "if loss of precision is acceptable, explicitly cast the \
                      decimal to a float with `float(value)`"
                 ));
             }
-        }
 
         msg
     }
diff --git a/crates/typst-library/src/foundations/content/mod.rs b/crates/typst-library/src/foundations/content/mod.rs
index 7ba790d88..f5e8314d8 100644
--- a/crates/typst-library/src/foundations/content/mod.rs
+++ b/crates/typst-library/src/foundations/content/mod.rs
@@ -174,11 +174,10 @@ impl Content {
         id: u8,
         styles: Option<StyleChain>,
     ) -> Result<Value, FieldAccessError> {
-        if id == 255 {
-            if let Some(label) = self.label() {
+        if id == 255
+            && let Some(label) = self.label() {
                 return Ok(label.into_value());
             }
-        }
 
         match self.0.handle().field(id) {
             Some(handle) => match styles {
diff --git a/crates/typst-library/src/layout/corners.rs b/crates/typst-library/src/layout/corners.rs
index fe69126a4..e47fee1e7 100644
--- a/crates/typst-library/src/layout/corners.rs
+++ b/crates/typst-library/src/layout/corners.rs
@@ -150,11 +150,10 @@ where
     T: PartialEq + IntoValue,
 {
     fn into_value(self) -> Value {
-        if self.is_uniform() {
-            if let Some(top_left) = self.top_left {
+        if self.is_uniform()
+            && let Some(top_left) = self.top_left {
                 return top_left.into_value();
             }
-        }
 
         let mut dict = Dict::new();
         let mut handle = |key: &str, component: Option<T>| {
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index f3004088e..edf50cdd2 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -2098,14 +2098,13 @@ fn check_for_conflicting_cell_row(
         );
     }
 
-    if let Some((_, _, footer)) = footer {
-        if cell_y < footer.end && cell_y + rowspan > footer.start {
+    if let Some((_, _, footer)) = footer
+        && cell_y < footer.end && cell_y + rowspan > footer.start {
             bail!(
                 "cell would conflict with footer spanning the same position";
                 hint: "try reducing the cell's rowspan or moving the footer"
             );
         }
-    }
 
     Ok(())
 }
diff --git a/crates/typst-library/src/layout/page.rs b/crates/typst-library/src/layout/page.rs
index a0b1c6fec..ab8cc8ea4 100644
--- a/crates/typst-library/src/layout/page.rs
+++ b/crates/typst-library/src/layout/page.rs
@@ -530,11 +530,10 @@ cast! {
     Margin,
     self => {
         let two_sided = self.two_sided.unwrap_or(false);
-        if !two_sided && self.sides.is_uniform() {
-            if let Some(left) = self.sides.left {
+        if !two_sided && self.sides.is_uniform()
+            && let Some(left) = self.sides.left {
                 return left.into_value();
             }
-        }
 
         let mut dict = Dict::new();
         let mut handle = |key: &str, component: Option<Smart<Rel<Length>>>| {
diff --git a/crates/typst-library/src/layout/sides.rs b/crates/typst-library/src/layout/sides.rs
index e04b63d98..1147eeb77 100644
--- a/crates/typst-library/src/layout/sides.rs
+++ b/crates/typst-library/src/layout/sides.rs
@@ -184,11 +184,10 @@ where
     T: PartialEq + IntoValue,
 {
     fn into_value(self) -> Value {
-        if self.is_uniform() {
-            if let Some(left) = self.left {
+        if self.is_uniform()
+            && let Some(left) = self.left {
                 return left.into_value();
             }
-        }
 
         let mut dict = Dict::new();
         let mut handle = |key: &str, component: Option<T>| {
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index 188af4da1..ef7e69273 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -927,12 +927,11 @@ impl ElemRenderer<'_> {
             _ => {}
         }
 
-        if let Some(hayagriva::ElemMeta::Entry(i)) = elem.meta {
-            if let Some(location) = (self.link)(i) {
+        if let Some(hayagriva::ElemMeta::Entry(i)) = elem.meta
+            && let Some(location) = (self.link)(i) {
                 let dest = Destination::Location(location);
                 content = content.linked(dest);
             }
-        }
 
         Ok(content)
     }
diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index f7922ef3e..cf1b43da0 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -210,12 +210,11 @@ impl Synthesize for Packed<RefElem> {
         elem.citation = Some(Some(citation));
         elem.element = Some(None);
 
-        if !BibliographyElem::has(engine, elem.target) {
-            if let Ok(found) = engine.introspector.query_label(elem.target).cloned() {
+        if !BibliographyElem::has(engine, elem.target)
+            && let Ok(found) = engine.introspector.query_label(elem.target).cloned() {
                 elem.element = Some(Some(found));
                 return Ok(());
             }
-        }
 
         Ok(())
     }
diff --git a/crates/typst-library/src/text/font/book.rs b/crates/typst-library/src/text/font/book.rs
index d0c821b39..374b83908 100644
--- a/crates/typst-library/src/text/font/book.rs
+++ b/crates/typst-library/src/text/font/book.rs
@@ -284,11 +284,9 @@ impl FontInfo {
             .raw_face()
             .table(Tag::from_bytes(b"OS/2"))
             .and_then(|os2| os2.get(32..45))
-        {
-            if matches!(panose, [2, 2..=10, ..]) {
+            && matches!(panose, [2, 2..=10, ..]) {
                 flags.insert(FontFlags::SERIF);
             }
-        }
 
         Some(FontInfo {
             family,
@@ -397,11 +395,10 @@ fn typographic_family(mut family: &str) -> &str {
 
         // Also allow an extra modifier, but apply it only if it is separated it
         // from the text before it (to prevent false positives).
-        if let Some(t) = MODIFIERS.iter().find_map(|s| t.strip_suffix(s)) {
-            if let Some(stripped) = t.strip_suffix(SEPARATORS) {
+        if let Some(t) = MODIFIERS.iter().find_map(|s| t.strip_suffix(s))
+            && let Some(stripped) = t.strip_suffix(SEPARATORS) {
                 trimmed = stripped;
             }
-        }
     }
 
     // Apply style suffix trimming.
diff --git a/crates/typst-library/src/text/lang.rs b/crates/typst-library/src/text/lang.rs
index 4f8d1e93f..d396eef8b 100644
--- a/crates/typst-library/src/text/lang.rs
+++ b/crates/typst-library/src/text/lang.rs
@@ -144,17 +144,15 @@ cast! {
     self => self.as_str().into_value(),
     string: EcoString => {
         let result = Self::from_str(&string);
-        if result.is_err() {
-            if let Some((lang, region)) = string.split_once('-') {
-                if Lang::from_str(lang).is_ok() && Region::from_str(region).is_ok() {
+        if result.is_err()
+            && let Some((lang, region)) = string.split_once('-')
+                && Lang::from_str(lang).is_ok() && Region::from_str(region).is_ok() {
                     return result
                         .hint(eco_format!(
                             "you should leave only \"{}\" in the `lang` parameter and specify \"{}\" in the `region` parameter",
                             lang, region,
                         ));
                 }
-            }
-        }
 
         result?
     }
diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index c2efe210b..5f2330cbd 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -270,15 +270,14 @@ pub struct TextElem {
     /// ```
     #[parse({
         let paint: Option<Spanned<Paint>> = args.named_or_find("fill")?;
-        if let Some(paint) = &paint {
-            if paint.v.relative() == Smart::Custom(RelativeTo::Self_) {
+        if let Some(paint) = &paint
+            && paint.v.relative() == Smart::Custom(RelativeTo::Self_) {
                 bail!(
                     paint.span,
                     "gradients and tilings on text must be relative to the parent";
                     hint: "make sure to set `relative: auto` on your text fill"
                 );
             }
-        }
         paint.map(|paint| paint.v)
     })]
     #[default(Color::BLACK.into())]
diff --git a/crates/typst-library/src/text/raw.rs b/crates/typst-library/src/text/raw.rs
index 0e61a8ef1..1677d3d07 100644
--- a/crates/typst-library/src/text/raw.rs
+++ b/crates/typst-library/src/text/raw.rs
@@ -750,11 +750,10 @@ fn preprocess(
     styles: StyleChain,
     span: Span,
 ) -> EcoVec<(EcoString, Span)> {
-    if let RawContent::Lines(lines) = text {
-        if lines.iter().all(|(s, _)| !s.contains('\t')) {
+    if let RawContent::Lines(lines) = text
+        && lines.iter().all(|(s, _)| !s.contains('\t')) {
             return lines.clone();
         }
-    }
 
     let mut text = text.get();
     if text.contains('\t') {
diff --git a/crates/typst-library/src/visualize/color.rs b/crates/typst-library/src/visualize/color.rs
index dd0287d4b..9c8eacaf5 100644
--- a/crates/typst-library/src/visualize/color.rs
+++ b/crates/typst-library/src/visualize/color.rs
@@ -1123,8 +1123,8 @@ impl Color {
             }
 
             // Ensure that the hue circle is traversed in the short direction.
-            if let Some(index) = space.hue_index() {
-                if (c0[index] - c1[index]).abs() > 180.0 {
+            if let Some(index) = space.hue_index()
+                && (c0[index] - c1[index]).abs() > 180.0 {
                     let (h0, h1) = if c0[index] < c1[index] {
                         (c0[index] + 360.0, c1[index])
                     } else {
@@ -1132,7 +1132,6 @@ impl Color {
                     };
                     m[index] = (w0 * h0 + w1 * h1) / (w0 + w1);
                 }
-            }
 
             m
         } else {
diff --git a/crates/typst-macros/src/scope.rs b/crates/typst-macros/src/scope.rs
index 392ab1a53..2eac76b53 100644
--- a/crates/typst-macros/src/scope.rs
+++ b/crates/typst-macros/src/scope.rs
@@ -14,14 +14,12 @@ pub fn scope(_: TokenStream, item: syn::Item) -> Result<TokenStream> {
     let self_ty = &item.self_ty;
 
     let mut primitive_ident_ext = None;
-    if let syn::Type::Path(syn::TypePath { path, .. }) = self_ty.as_ref() {
-        if let Some(ident) = path.get_ident() {
-            if is_primitive(ident) {
+    if let syn::Type::Path(syn::TypePath { path, .. }) = self_ty.as_ref()
+        && let Some(ident) = path.get_ident()
+            && is_primitive(ident) {
                 let ident_ext = quote::format_ident!("{ident}Ext");
                 primitive_ident_ext = Some(ident_ext);
             }
-        }
-    }
 
     let self_ty_expr = match &primitive_ident_ext {
         None => quote! { #self_ty },
diff --git a/crates/typst-macros/src/util.rs b/crates/typst-macros/src/util.rs
index e8c0910b6..87e398c97 100644
--- a/crates/typst-macros/src/util.rs
+++ b/crates/typst-macros/src/util.rs
@@ -27,18 +27,15 @@ pub fn documentation(attrs: &[syn::Attribute]) -> String {
 
     // Parse doc comments.
     for attr in attrs {
-        if let syn::Meta::NameValue(meta) = &attr.meta {
-            if meta.path.is_ident("doc") {
-                if let syn::Expr::Lit(lit) = &meta.value {
-                    if let syn::Lit::Str(string) = &lit.lit {
+        if let syn::Meta::NameValue(meta) = &attr.meta
+            && meta.path.is_ident("doc")
+                && let syn::Expr::Lit(lit) = &meta.value
+                    && let syn::Lit::Str(string) = &lit.lit {
                         let full = string.value();
                         let line = full.strip_prefix(' ').unwrap_or(&full);
                         doc.push_str(line);
                         doc.push('\n');
                     }
-                }
-            }
-        }
     }
 
     doc.trim().into()
diff --git a/crates/typst-pdf/src/outline.rs b/crates/typst-pdf/src/outline.rs
index f73822c4b..e95bf67fb 100644
--- a/crates/typst-pdf/src/outline.rs
+++ b/crates/typst-pdf/src/outline.rs
@@ -21,14 +21,13 @@ pub(crate) fn build_outline(gc: &GlobalContext) -> Outline {
     let elements = &gc.document.introspector.query(&HeadingElem::ELEM.select());
 
     for elem in elements.iter() {
-        if let Some(page_ranges) = &gc.options.page_ranges {
-            if !page_ranges
+        if let Some(page_ranges) = &gc.options.page_ranges
+            && !page_ranges
                 .includes_page(gc.document.introspector.page(elem.location().unwrap()))
             {
                 // Don't bookmark headings in non-exported pages.
                 continue;
             }
-        }
 
         let heading = elem.to_packed::<HeadingElem>().unwrap();
         let leaf = HeadingNode::leaf(heading);
diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index f3f071505..cbb3ac21d 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -307,12 +307,11 @@ fn visit_kind_rules<'a>(
                 visit_regex_match(s, &[(content, styles)], m)?;
                 return Ok(true);
             }
-        } else if let Some(elem) = content.to_packed::<TextElem>() {
-            if let Some(m) = find_regex_match_in_str(&elem.text, styles) {
+        } else if let Some(elem) = content.to_packed::<TextElem>()
+            && let Some(m) = find_regex_match_in_str(&elem.text, styles) {
                 visit_regex_match(s, &[(content, styles)], m)?;
                 return Ok(true);
             }
-        }
     } else {
         // Transparently wrap mathy content into equations.
         if content.can::<dyn Mathy>() && !content.is::<EquationElem>() {
@@ -1092,11 +1091,10 @@ fn find_regex_match_in_elems<'a>(
         }
 
         let linebreak = content.is::<LinebreakElem>();
-        if linebreak {
-            if let SpaceState::Space(_) = space {
+        if linebreak
+            && let SpaceState::Space(_) = space {
                 buf.pop();
             }
-        }
 
         if styles != current && !buf.is_empty() {
             leftmost = find_regex_match_in_str(&buf, current);
diff --git a/crates/typst-render/src/lib.rs b/crates/typst-render/src/lib.rs
index 2c57fe2db..5a993dbb9 100644
--- a/crates/typst-render/src/lib.rs
+++ b/crates/typst-render/src/lib.rs
@@ -193,8 +193,8 @@ fn render_group(canvas: &mut sk::Pixmap, state: State, pos: Point, group: &Group
 
     let mut mask = state.mask;
     let storage;
-    if let Some(clip_curve) = group.clip.as_ref() {
-        if let Some(path) = shape::convert_curve(clip_curve)
+    if let Some(clip_curve) = group.clip.as_ref()
+        && let Some(path) = shape::convert_curve(clip_curve)
             .and_then(|path| path.transform(state.transform))
         {
             if let Some(mask) = mask {
@@ -226,7 +226,6 @@ fn render_group(canvas: &mut sk::Pixmap, state: State, pos: Point, group: &Group
 
             mask = Some(&storage);
         }
-    }
 
     render_frame(canvas, state.with_mask(mask), &group.frame);
 }
diff --git a/crates/typst-render/src/text.rs b/crates/typst-render/src/text.rs
index 55fe04b51..a56528220 100644
--- a/crates/typst-render/src/text.rs
+++ b/crates/typst-render/src/text.rs
@@ -87,8 +87,7 @@ fn render_outline_glyph(
 
         if let Some(FixedStroke { paint, thickness, cap, join, dash, miter_limit }) =
             &text.stroke
-        {
-            if thickness.to_f32() > 0.0 {
+            && thickness.to_f32() > 0.0 {
                 let dash = dash.as_ref().and_then(shape::to_sk_dash_pattern);
 
                 let paint = paint::to_sk_paint(
@@ -110,7 +109,6 @@ fn render_outline_glyph(
 
                 canvas.stroke_path(&path, &paint, &stroke, ts, state.mask);
             }
-        }
         return Some(());
     }
 
diff --git a/crates/typst-svg/src/lib.rs b/crates/typst-svg/src/lib.rs
index 5b6db69da..85bd5d7cb 100644
--- a/crates/typst-svg/src/lib.rs
+++ b/crates/typst-svg/src/lib.rs
@@ -340,12 +340,11 @@ impl<'a> SVGRenderer<'a> {
             Destination::Location(loc) => {
                 // TODO: Location links on the same page could also be supported
                 // outside of HTML.
-                if let Some(introspector) = self.introspector {
-                    if let Some(id) = introspector.html_id(*loc) {
+                if let Some(introspector) = self.introspector
+                    && let Some(id) = introspector.html_id(*loc) {
                         self.xml.write_attribute_fmt("href", format_args!("#{id}"));
                         self.xml.write_attribute_fmt("xlink:href", format_args!("#{id}"));
                     }
-                }
             }
             Destination::Position(_) => {
                 // TODO: Links on the same page could be supported.
diff --git a/crates/typst-syntax/src/highlight.rs b/crates/typst-syntax/src/highlight.rs
index cd815694d..9754312b3 100644
--- a/crates/typst-syntax/src/highlight.rs
+++ b/crates/typst-syntax/src/highlight.rs
@@ -300,8 +300,8 @@ pub fn highlight(node: &LinkedNode) -> Option<Tag> {
 fn highlight_ident(node: &LinkedNode) -> Option<Tag> {
     // Are we directly before an argument list?
     let next_leaf = node.next_leaf();
-    if let Some(next) = &next_leaf {
-        if node.range().end == next.offset()
+    if let Some(next) = &next_leaf
+        && node.range().end == next.offset()
             && ((next.kind() == SyntaxKind::LeftParen
                 && matches!(
                     next.parent_kind(),
@@ -312,7 +312,6 @@ fn highlight_ident(node: &LinkedNode) -> Option<Tag> {
         {
             return Some(Tag::Function);
         }
-    }
 
     // Are we in math?
     if node.kind() == SyntaxKind::MathIdent {
@@ -379,14 +378,13 @@ pub fn highlight_html(root: &SyntaxNode) -> String {
 /// Highlight one source node, emitting HTML.
 fn highlight_html_impl(html: &mut String, node: &LinkedNode) {
     let mut span = false;
-    if let Some(tag) = highlight(node) {
-        if tag != Tag::Error {
+    if let Some(tag) = highlight(node)
+        && tag != Tag::Error {
             span = true;
             html.push_str("<span class=\"");
             html.push_str(tag.css_class());
             html.push_str("\">");
         }
-    }
 
     let text = node.text();
     if !text.is_empty() {
diff --git a/crates/typst-syntax/src/lexer.rs b/crates/typst-syntax/src/lexer.rs
index 82f65cd36..9da45958f 100644
--- a/crates/typst-syntax/src/lexer.rs
+++ b/crates/typst-syntax/src/lexer.rs
@@ -783,11 +783,10 @@ impl Lexer<'_> {
         let ident = self.s.from(start);
 
         let prev = self.s.get(0..start);
-        if !prev.ends_with(['.', '@']) || prev.ends_with("..") {
-            if let Some(keyword) = keyword(ident) {
+        if (!prev.ends_with(['.', '@']) || prev.ends_with(".."))
+            && let Some(keyword) = keyword(ident) {
                 return keyword;
             }
-        }
 
         if ident == "_" {
             SyntaxKind::Underscore
diff --git a/crates/typst-syntax/src/node.rs b/crates/typst-syntax/src/node.rs
index 948657ca4..15c96b08f 100644
--- a/crates/typst-syntax/src/node.rs
+++ b/crates/typst-syntax/src/node.rs
@@ -733,11 +733,9 @@ impl<'a> LinkedNode<'a> {
                 if children
                     .peek()
                     .is_none_or(|next| next.span().number() > span.number())
-                {
-                    if let Some(found) = child.find(span) {
+                    && let Some(found) = child.find(span) {
                         return Some(found);
                     }
-                }
             }
         }
 
diff --git a/crates/typst-syntax/src/parser.rs b/crates/typst-syntax/src/parser.rs
index b452c2c09..22f073601 100644
--- a/crates/typst-syntax/src/parser.rs
+++ b/crates/typst-syntax/src/parser.rs
@@ -442,14 +442,13 @@ fn math_unparen(p: &mut Parser, m: Marker) {
         return;
     }
 
-    if let [first, .., last] = node.children_mut() {
-        if first.text() == "(" && last.text() == ")" {
+    if let [first, .., last] = node.children_mut()
+        && first.text() == "(" && last.text() == ")" {
             first.convert_to_kind(SyntaxKind::LeftParen);
             last.convert_to_kind(SyntaxKind::RightParen);
             // Only convert if we did have regular parens.
             node.convert_to_kind(SyntaxKind::Math);
         }
-    }
 }
 
 /// The unicode math class of a string. Only returns `Some` if `text` has
@@ -1199,11 +1198,10 @@ fn array_or_dict_item(p: &mut Parser, state: &mut GroupState) {
             Some(ast::Expr::Ident(ident)) => Some(ident.get().clone()),
             Some(ast::Expr::Str(s)) => Some(s.get()),
             _ => None,
-        } {
-            if !state.seen.insert(key.clone()) {
+        }
+            && !state.seen.insert(key.clone()) {
                 node.convert_to_error(eco_format!("duplicate key: {key}"));
             }
-        }
 
         p.wrap(m, pair_kind);
         state.maybe_just_parens = false;
@@ -1855,8 +1853,8 @@ impl<'s> Parser<'s> {
         self.nl_mode = mode;
         func(self);
         self.nl_mode = previous;
-        if let Some(newline) = self.token.newline {
-            if mode != previous {
+        if let Some(newline) = self.token.newline
+            && mode != previous {
                 // Restore our actual token's kind or insert a fake end.
                 let actual_kind = self.token.node.kind();
                 if self.nl_mode.stop_at(newline, actual_kind) {
@@ -1865,7 +1863,6 @@ impl<'s> Parser<'s> {
                     self.token.kind = actual_kind;
                 }
             }
-        }
     }
 
     /// Move the lexer forward and prepare the current token. In Code, this
diff --git a/crates/typst-syntax/src/reparser.rs b/crates/typst-syntax/src/reparser.rs
index 55555c96e..2df606310 100644
--- a/crates/typst-syntax/src/reparser.rs
+++ b/crates/typst-syntax/src/reparser.rs
@@ -70,14 +70,13 @@ fn try_reparse(
             }
 
             // If the child is a block, try to reparse the block.
-            if child.kind().is_block() {
-                if let Some(newborn) = reparse_block(text, new_range.clone()) {
+            if child.kind().is_block()
+                && let Some(newborn) = reparse_block(text, new_range.clone()) {
                     return node
                         .replace_children(i..i + 1, vec![newborn])
                         .is_ok()
                         .then_some(new_range);
                 }
-            }
         }
 
         // Does the child overlap with the edit?
diff --git a/docs/src/link.rs b/docs/src/link.rs
index 2e836b6ce..b883399e5 100644
--- a/docs/src/link.rs
+++ b/docs/src/link.rs
@@ -96,12 +96,11 @@ fn resolve_definition(head: &str, base: &str) -> StrResult<String> {
         if let Ok(field) = value.field(next, ()) {
             route.push_str("/#definitions-");
             route.push_str(next);
-            if let Some(next) = parts.next() {
-                if field.cast::<Func>().is_ok_and(|func| func.param(next).is_some()) {
+            if let Some(next) = parts.next()
+                && field.cast::<Func>().is_ok_and(|func| func.param(next).is_some()) {
                     route.push('-');
                     route.push_str(next);
                 }
-            }
         } else if value
             .clone()
             .cast::<Func>()
diff --git a/tests/fuzz/src/compile.rs b/tests/fuzz/src/compile.rs
index 945e9fce8..1bc85fd62 100644
--- a/tests/fuzz/src/compile.rs
+++ b/tests/fuzz/src/compile.rs
@@ -66,10 +66,9 @@ impl World for FuzzWorld {
 
 fuzz_target!(|text: &str| {
     let world = FuzzWorld::new(text);
-    if let Ok(document) = typst::compile::<PagedDocument>(&world).output {
-        if let Some(page) = document.pages.first() {
+    if let Ok(document) = typst::compile::<PagedDocument>(&world).output
+        && let Some(page) = document.pages.first() {
             std::hint::black_box(typst_render::render(page, 1.0));
         }
-    }
     comemo::evict(10);
 });

From e81a5a6ef205403c4271d2a9503a1f0b70e1cc2d Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 21 Jul 2025 15:11:36 +0200
Subject: [PATCH 097/101] Yeet `if_chain` macro

---
 Cargo.lock                       |   8 --
 Cargo.toml                       |   1 -
 crates/typst-eval/Cargo.toml     |   1 -
 crates/typst-eval/src/code.rs    |  15 ++-
 crates/typst-eval/src/rules.rs   |  12 +--
 crates/typst-ide/Cargo.toml      |   1 -
 crates/typst-ide/src/complete.rs | 169 +++++++++++++------------------
 crates/typst-ide/src/tooltip.rs  |  82 +++++++--------
 8 files changed, 118 insertions(+), 171 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index dcd154367..49a7c2b63 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1198,12 +1198,6 @@ dependencies = [
  "icu_properties",
 ]
 
-[[package]]
-name = "if_chain"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
-
 [[package]]
 name = "image"
 version = "0.25.5"
@@ -2943,7 +2937,6 @@ version = "0.13.1"
 dependencies = [
  "comemo",
  "ecow",
- "if_chain",
  "indexmap 2.7.1",
  "stacker",
  "toml",
@@ -2991,7 +2984,6 @@ version = "0.13.1"
 dependencies = [
  "comemo",
  "ecow",
- "if_chain",
  "once_cell",
  "pathdiff",
  "serde",
diff --git a/Cargo.toml b/Cargo.toml
index 43a077ddb..08c6a8c8b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -68,7 +68,6 @@ icu_provider = { version = "1.4", features = ["sync"] }
 icu_provider_adapters = "1.4"
 icu_provider_blob = "1.4"
 icu_segmenter = { version = "1.4", features = ["serde"] }
-if_chain = "1"
 image = { version = "0.25.5", default-features = false, features = ["png", "jpeg", "gif", "webp"] }
 indexmap = { version = "2", features = ["serde"] }
 infer = { version = "0.19.0", default-features = false }
diff --git a/crates/typst-eval/Cargo.toml b/crates/typst-eval/Cargo.toml
index 12a6a6a46..b39382ffe 100644
--- a/crates/typst-eval/Cargo.toml
+++ b/crates/typst-eval/Cargo.toml
@@ -20,7 +20,6 @@ typst-timing = { workspace = true }
 typst-utils = { workspace = true }
 comemo = { workspace = true }
 ecow = { workspace = true }
-if_chain = { workspace = true }
 indexmap = { workspace = true }
 toml = { workspace = true }
 unicode-segmentation = { workspace = true }
diff --git a/crates/typst-eval/src/code.rs b/crates/typst-eval/src/code.rs
index 9078418e4..1930ebc48 100644
--- a/crates/typst-eval/src/code.rs
+++ b/crates/typst-eval/src/code.rs
@@ -324,22 +324,19 @@ impl Eval for ast::FieldAccess<'_> {
         };
 
         // Check whether this is a get rule field access.
-        if_chain::if_chain! {
-            if let Value::Func(func) = &value;
-            if let Some(element) = func.element();
-            if let Some(id) = element.field_id(&field);
-            let styles = vm.context.styles().at(field.span());
-            if let Ok(value) = element.field_from_styles(
+            if let Value::Func(func) = &value &&
+               let Some(element) = func.element() &&
+               let Some(id) = element.field_id(&field) &&
+               let styles = vm.context.styles().at(field.span()) &&
+               let Ok(value) = element.field_from_styles(
                 id,
                 styles.as_ref().map(|&s| s).unwrap_or_default(),
-            );
-            then {
+            ) {
                 // Only validate the context once we know that this is indeed
                 // a field from the style chain.
                 let _ = styles?;
                 return Ok(value);
             }
-        }
 
         Err(err)
     }
diff --git a/crates/typst-eval/src/rules.rs b/crates/typst-eval/src/rules.rs
index 36fde561c..bf4a80780 100644
--- a/crates/typst-eval/src/rules.rs
+++ b/crates/typst-eval/src/rules.rs
@@ -57,12 +57,11 @@ impl Eval for ast::ShowRule<'_> {
 
 /// Migration hint for `show par: set block(spacing: ..)`.
 fn check_show_par_set_block(vm: &mut Vm, recipe: &Recipe) {
-    if_chain::if_chain! {
-        if let Some(Selector::Elem(elem, _)) = recipe.selector();
-        if *elem == Element::of::<ParElem>();
-        if let Transformation::Style(styles) = recipe.transform();
-        if styles.has(BlockElem::above) || styles.has(BlockElem::below);
-        then {
+        if let Some(Selector::Elem(elem, _)) = recipe.selector() &&
+           *elem == Element::of::<ParElem>() &&
+           let Transformation::Style(styles) = recipe.transform() &&
+           (styles.has(BlockElem::above) || styles.has(BlockElem::below)) 
+        {
             vm.engine.sink.warn(warning!(
                 recipe.span(),
                 "`show par: set block(spacing: ..)` has no effect anymore";
@@ -70,5 +69,4 @@ fn check_show_par_set_block(vm: &mut Vm, recipe: &Recipe) {
                 hint: "this is specific to paragraphs as they are not considered blocks anymore"
             ))
         }
-    }
 }
diff --git a/crates/typst-ide/Cargo.toml b/crates/typst-ide/Cargo.toml
index 20162e836..e7918e634 100644
--- a/crates/typst-ide/Cargo.toml
+++ b/crates/typst-ide/Cargo.toml
@@ -17,7 +17,6 @@ typst = { workspace = true }
 typst-eval = { workspace = true }
 comemo = { workspace = true }
 ecow = { workspace = true }
-if_chain = { workspace = true }
 pathdiff = { workspace = true }
 serde = { workspace = true }
 unscanny = { workspace = true }
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index 6cde69f3c..a974eb313 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -3,7 +3,6 @@ use std::collections::{BTreeMap, HashSet};
 use std::ffi::OsStr;
 
 use ecow::{eco_format, EcoString};
-use if_chain::if_chain;
 use serde::{Deserialize, Serialize};
 use typst::foundations::{
     fields_on, repr, AutoValue, CastInfo, Func, Label, NoneValue, ParamInfo, Repr,
@@ -145,27 +144,23 @@ fn complete_markup(ctx: &mut CompletionContext) -> bool {
     }
 
     // Behind a half-completed binding: "#let x = |".
-    if_chain! {
-        if let Some(prev) = ctx.leaf.prev_leaf();
-        if prev.kind() == SyntaxKind::Eq;
-        if prev.parent_kind() == Some(SyntaxKind::LetBinding);
-        then {
+        if let Some(prev) = ctx.leaf.prev_leaf()
+        && prev.kind() == SyntaxKind::Eq
+        && prev.parent_kind() == Some(SyntaxKind::LetBinding)
+        {
             ctx.from = ctx.cursor;
             code_completions(ctx, false);
             return true;
         }
-    }
 
     // Behind a half-completed context block: "#context |".
-    if_chain! {
-        if let Some(prev) = ctx.leaf.prev_leaf();
-        if prev.kind() == SyntaxKind::Context;
-        then {
+        if let Some(prev) = ctx.leaf.prev_leaf()
+        && prev.kind() == SyntaxKind::Context
+         {
             ctx.from = ctx.cursor;
             code_completions(ctx, false);
             return true;
         }
-    }
 
     // Directly after a raw block.
     let mut s = Scanner::new(ctx.text);
@@ -373,38 +368,34 @@ fn complete_field_accesses(ctx: &mut CompletionContext) -> bool {
     );
 
     // Behind an expression plus dot: "emoji.|".
-    if_chain! {
-        if ctx.leaf.kind() == SyntaxKind::Dot
+        if (ctx.leaf.kind() == SyntaxKind::Dot
             || (matches!(ctx.leaf.kind(), SyntaxKind::Text | SyntaxKind::MathText)
-                && ctx.leaf.text() == ".");
-        if ctx.leaf.range().end == ctx.cursor;
-        if let Some(prev) = ctx.leaf.prev_sibling();
-        if !in_markup || prev.range().end == ctx.leaf.range().start;
-        if prev.is::<ast::Expr>();
-        if prev.parent_kind() != Some(SyntaxKind::Markup) ||
-           prev.prev_sibling_kind() == Some(SyntaxKind::Hash);
-        if let Some((value, styles)) = analyze_expr(ctx.world, &prev).into_iter().next();
-        then {
+                && ctx.leaf.text() == "."))
+        && ctx.leaf.range().end == ctx.cursor
+        && let Some(prev) = ctx.leaf.prev_sibling()
+        && (!in_markup || prev.range().end == ctx.leaf.range().start)
+        && prev.is::<ast::Expr>()
+        && (prev.parent_kind() != Some(SyntaxKind::Markup) ||
+           prev.prev_sibling_kind() == Some(SyntaxKind::Hash))
+        && let Some((value, styles)) = analyze_expr(ctx.world, &prev).into_iter().next()
+         {
             ctx.from = ctx.cursor;
             field_access_completions(ctx, &value, &styles);
             return true;
         }
-    }
 
     // Behind a started field access: "emoji.fa|".
-    if_chain! {
-        if ctx.leaf.kind() == SyntaxKind::Ident;
-        if let Some(prev) = ctx.leaf.prev_sibling();
-        if prev.kind() == SyntaxKind::Dot;
-        if let Some(prev_prev) = prev.prev_sibling();
-        if prev_prev.is::<ast::Expr>();
-        if let Some((value, styles)) = analyze_expr(ctx.world, &prev_prev).into_iter().next();
-        then {
+        if ctx.leaf.kind() == SyntaxKind::Ident
+        && let Some(prev) = ctx.leaf.prev_sibling()
+        && prev.kind() == SyntaxKind::Dot
+        && let Some(prev_prev) = prev.prev_sibling()
+        && prev_prev.is::<ast::Expr>()
+        && let Some((value, styles)) = analyze_expr(ctx.world, &prev_prev).into_iter().next()
+         {
             ctx.from = ctx.leaf.offset();
             field_access_completions(ctx, &value, &styles);
             return true;
         }
-    }
 
     false
 }
@@ -507,14 +498,10 @@ fn complete_open_labels(ctx: &mut CompletionContext) -> bool {
 fn complete_imports(ctx: &mut CompletionContext) -> bool {
     // In an import path for a file or package:
     // "#import "|",
-    if_chain! {
-        if matches!(
-            ctx.leaf.parent_kind(),
-            Some(SyntaxKind::ModuleImport | SyntaxKind::ModuleInclude)
-        );
-        if let Some(ast::Expr::Str(str)) = ctx.leaf.cast();
-        let value = str.get();
-        then {
+        if let Some(SyntaxKind::ModuleImport | SyntaxKind::ModuleInclude) = ctx.leaf.parent_kind()
+        && let Some(ast::Expr::Str(str)) = ctx.leaf.cast()
+         {
+            let value = str.get();
             ctx.from = ctx.leaf.offset();
             if value.starts_with('@') {
                 let all_versions = value.contains(':');
@@ -524,41 +511,36 @@ fn complete_imports(ctx: &mut CompletionContext) -> bool {
             }
             return true;
         }
-    }
 
     // Behind an import list:
     // "#import "path.typ": |",
     // "#import "path.typ": a, b, |".
-    if_chain! {
-        if let Some(prev) = ctx.leaf.prev_sibling();
-        if let Some(ast::Expr::ModuleImport(import)) = prev.get().cast();
-        if let Some(ast::Imports::Items(items)) = import.imports();
-        if let Some(source) = prev.children().find(|child| child.is::<ast::Expr>());
-        then {
+        if let Some(prev) = ctx.leaf.prev_sibling()
+        && let Some(ast::Expr::ModuleImport(import)) = prev.get().cast()
+        && let Some(ast::Imports::Items(items)) = import.imports()
+        && let Some(source) = prev.children().find(|child| child.is::<ast::Expr>())
+         {
             ctx.from = ctx.cursor;
             import_item_completions(ctx, items, &source);
             return true;
         }
-    }
 
     // Behind a half-started identifier in an import list:
     // "#import "path.typ": thi|",
-    if_chain! {
-        if ctx.leaf.kind() == SyntaxKind::Ident;
-        if let Some(parent) = ctx.leaf.parent();
-        if parent.kind() == SyntaxKind::ImportItemPath;
-        if let Some(grand) = parent.parent();
-        if grand.kind() == SyntaxKind::ImportItems;
-        if let Some(great) = grand.parent();
-        if let Some(ast::Expr::ModuleImport(import)) = great.get().cast();
-        if let Some(ast::Imports::Items(items)) = import.imports();
-        if let Some(source) = great.children().find(|child| child.is::<ast::Expr>());
-        then {
+        if ctx.leaf.kind() == SyntaxKind::Ident
+        && let Some(parent) = ctx.leaf.parent()
+        && parent.kind() == SyntaxKind::ImportItemPath
+        && let Some(grand) = parent.parent()
+        && grand.kind() == SyntaxKind::ImportItems
+        && let Some(great) = grand.parent()
+        && let Some(ast::Expr::ModuleImport(import)) = great.get().cast()
+        && let Some(ast::Imports::Items(items)) = import.imports()
+        && let Some(source) = great.children().find(|child| child.is::<ast::Expr>())
+         {
             ctx.from = ctx.leaf.offset();
             import_item_completions(ctx, items, &source);
             return true;
         }
-    }
 
     false
 }
@@ -607,16 +589,14 @@ fn complete_rules(ctx: &mut CompletionContext) -> bool {
     }
 
     // Behind a half-completed show rule: "show strong: |".
-    if_chain! {
-        if let Some(prev) = ctx.leaf.prev_leaf();
-        if matches!(prev.kind(), SyntaxKind::Colon);
-        if matches!(prev.parent_kind(), Some(SyntaxKind::ShowRule));
-        then {
+        if let Some(prev) = ctx.leaf.prev_leaf()
+        && matches!(prev.kind(), SyntaxKind::Colon)
+        && matches!(prev.parent_kind(), Some(SyntaxKind::ShowRule))
+         {
             ctx.from = ctx.cursor;
             show_rule_recipe_completions(ctx);
             return true;
         }
-    }
 
     false
 }
@@ -682,27 +662,26 @@ fn show_rule_recipe_completions(ctx: &mut CompletionContext) {
 /// Complete call and set rule parameters.
 fn complete_params(ctx: &mut CompletionContext) -> bool {
     // Ensure that we are in a function call or set rule's argument list.
-    let (callee, set, args, args_linked) = if_chain! {
-        if let Some(parent) = ctx.leaf.parent();
-        if let Some(parent) = match parent.kind() {
+    let (callee, set, args, args_linked) = 
+        if let Some(parent) = ctx.leaf.parent()
+        && let Some(parent) = match parent.kind() {
             SyntaxKind::Named => parent.parent(),
             _ => Some(parent),
-        };
-        if let Some(args) = parent.get().cast::<ast::Args>();
-        if let Some(grand) = parent.parent();
-        if let Some(expr) = grand.get().cast::<ast::Expr>();
-        let set = matches!(expr, ast::Expr::SetRule(_));
-        if let Some(callee) = match expr {
+        }
+        && let Some(args) = parent.get().cast::<ast::Args>()
+        && let Some(grand) = parent.parent()
+        && let Some(expr) = grand.get().cast::<ast::Expr>()
+        && let set = matches!(expr, ast::Expr::SetRule(_))
+        && let Some(callee) = match expr {
             ast::Expr::FuncCall(call) => Some(call.callee()),
             ast::Expr::SetRule(set) => Some(set.target()),
             _ => None,
-        };
-        then {
+        }
+        {
             (callee, set, args, parent)
         } else {
             return false;
-        }
-    };
+        };
 
     // Find the piece of syntax that decides what we're completing.
     let mut deciding = ctx.leaf.clone();
@@ -718,11 +697,10 @@ fn complete_params(ctx: &mut CompletionContext) -> bool {
     }
 
     // Parameter values: "func(param:|)", "func(param: |)".
-    if_chain! {
-        if deciding.kind() == SyntaxKind::Colon;
-        if let Some(prev) = deciding.prev_leaf();
-        if let Some(param) = prev.get().cast::<ast::Ident>();
-        then {
+        if let SyntaxKind::Colon = deciding.kind()
+        && let Some(prev) = deciding.prev_leaf()
+        && let Some(param) = prev.get().cast::<ast::Ident>()
+         {
             if let Some(next) = deciding.next_leaf() {
                 ctx.from = ctx.cursor.min(next.offset());
             }
@@ -730,13 +708,11 @@ fn complete_params(ctx: &mut CompletionContext) -> bool {
             named_param_value_completions(ctx, callee, &param);
             return true;
         }
-    }
 
     // Parameters: "func(|)", "func(hi|)", "func(12,|)".
-    if_chain! {
-        if matches!(deciding.kind(), SyntaxKind::LeftParen | SyntaxKind::Comma);
-        if deciding.kind() != SyntaxKind::Comma || deciding.range().end < ctx.cursor;
-        then {
+        if let SyntaxKind::LeftParen | SyntaxKind::Comma = deciding.kind()
+        && (deciding.kind() != SyntaxKind::Comma || deciding.range().end < ctx.cursor)
+         {
             if let Some(next) = deciding.next_leaf() {
                 ctx.from = ctx.cursor.min(next.offset());
             }
@@ -744,7 +720,6 @@ fn complete_params(ctx: &mut CompletionContext) -> bool {
             param_completions(ctx, callee, set, args, args_linked);
             return true;
         }
-    }
 
     false
 }
@@ -1104,15 +1079,13 @@ fn code_completions(ctx: &mut CompletionContext, hash: bool) {
 fn is_in_equation_show_rule(leaf: &LinkedNode<'_>) -> bool {
     let mut node = leaf;
     while let Some(parent) = node.parent() {
-        if_chain! {
-            if let Some(expr) = parent.get().cast::<ast::Expr>();
-            if let ast::Expr::ShowRule(show) = expr;
-            if let Some(ast::Expr::FieldAccess(field)) = show.selector();
-            if field.field().as_str() == "equation";
-            then {
+            if let Some(expr) = parent.get().cast::<ast::Expr>()
+            && let ast::Expr::ShowRule(show) = expr
+            && let Some(ast::Expr::FieldAccess(field)) = show.selector()
+            && field.field().as_str() == "equation"
+            {
                 return true;
             }
-        }
         node = parent;
     }
     false
diff --git a/crates/typst-ide/src/tooltip.rs b/crates/typst-ide/src/tooltip.rs
index 700414637..078465206 100644
--- a/crates/typst-ide/src/tooltip.rs
+++ b/crates/typst-ide/src/tooltip.rs
@@ -1,7 +1,6 @@
 use std::fmt::Write;
 
 use ecow::{eco_format, EcoString};
-use if_chain::if_chain;
 use typst::engine::Sink;
 use typst::foundations::{repr, Binding, Capturer, CastInfo, Repr, Value};
 use typst::layout::{Length, PagedDocument};
@@ -107,20 +106,18 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
 
 /// Tooltips for imports.
 fn import_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
-    if_chain! {
-        if leaf.kind() == SyntaxKind::Star;
-        if let Some(parent) = leaf.parent();
-        if let Some(import) = parent.cast::<ast::ModuleImport>();
-        if let Some(node) = parent.find(import.source().span());
-        if let Some(value) = analyze_import(world, &node);
-        if let Some(scope) = value.scope();
-        then {
+        if leaf.kind() == SyntaxKind::Star
+        && let Some(parent) = leaf.parent()
+        && let Some(import) = parent.cast::<ast::ModuleImport>()
+        && let Some(node) = parent.find(import.source().span())
+        && let Some(value) = analyze_import(world, &node)
+        && let Some(scope) = value.scope()
+         {
             let names: Vec<_> =
                 scope.iter().map(|(name, ..)| eco_format!("`{name}`")).collect();
             let list = repr::separated_list(&names, "and");
             return Some(Tooltip::Text(eco_format!("This star imports {list}")));
         }
-    }
 
     None
 }
@@ -188,51 +185,46 @@ fn label_tooltip(document: &PagedDocument, leaf: &LinkedNode) -> Option<Tooltip>
 
 /// Tooltips for components of a named parameter.
 fn named_param_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
-    let (func, named) = if_chain! {
+    let (func, named) =
         // Ensure that we are in a named pair in the arguments to a function
         // call or set rule.
-        if let Some(parent) = leaf.parent();
-        if let Some(named) = parent.cast::<ast::Named>();
-        if let Some(grand) = parent.parent();
-        if matches!(grand.kind(), SyntaxKind::Args);
-        if let Some(grand_grand) = grand.parent();
-        if let Some(expr) = grand_grand.cast::<ast::Expr>();
-        if let Some(ast::Expr::Ident(callee)) = match expr {
+        if let Some(parent) = leaf.parent()
+        && let Some(named) = parent.cast::<ast::Named>()
+        && let Some(grand) = parent.parent()
+        && matches!(grand.kind(), SyntaxKind::Args)
+        && let Some(grand_grand) = grand.parent()
+        && let Some(expr) = grand_grand.cast::<ast::Expr>()
+        && let Some(ast::Expr::Ident(callee)) = match expr {
             ast::Expr::FuncCall(call) => Some(call.callee()),
             ast::Expr::SetRule(set) => Some(set.target()),
             _ => None,
-        };
+        }
 
         // Find metadata about the function.
-        if let Some(Value::Func(func)) = world
+        && let Some(Value::Func(func)) = world
             .library()
             .global
             .scope()
             .get(&callee)
-            .map(Binding::read);
-        then { (func, named) }
-        else { return None; }
-    };
+            .map(Binding::read)
+         { (func, named) }
+        else { return None; };
 
     // Hovering over the parameter name.
-    if_chain! {
-        if leaf.index() == 0;
-        if let Some(ident) = leaf.cast::<ast::Ident>();
-        if let Some(param) = func.param(&ident);
-        then {
+        if leaf.index() == 0
+        && let Some(ident) = leaf.cast::<ast::Ident>()
+        && let Some(param) = func.param(&ident)
+         {
             return Some(Tooltip::Text(plain_docs_sentence(param.docs)));
         }
-    }
 
     // Hovering over a string parameter value.
-    if_chain! {
-        if let Some(string) = leaf.cast::<ast::Str>();
-        if let Some(param) = func.param(&named.name());
-        if let Some(docs) = find_string_doc(&param.input, &string.get());
-        then {
+        if let Some(string) = leaf.cast::<ast::Str>()
+        && let Some(param) = func.param(&named.name())
+        && let Some(docs) = find_string_doc(&param.input, &string.get())
+         {
             return Some(Tooltip::Text(docs.into()));
         }
-    }
 
     None
 }
@@ -250,27 +242,25 @@ fn find_string_doc(info: &CastInfo, string: &str) -> Option<&'static str> {
 
 /// Tooltip for font.
 fn font_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
-    if_chain! {
         // Ensure that we are on top of a string.
-        if let Some(string) = leaf.cast::<ast::Str>();
-        let lower = string.get().to_lowercase();
+        if let Some(string) = leaf.cast::<ast::Str>()
+        && let lower = string.get().to_lowercase()
 
         // Ensure that we are in the arguments to the text function.
-        if let Some(parent) = leaf.parent();
-        if let Some(named) = parent.cast::<ast::Named>();
-        if named.name().as_str() == "font";
+        && let Some(parent) = leaf.parent()
+        && let Some(named) = parent.cast::<ast::Named>()
+        && named.name().as_str() == "font"
 
         // Find the font family.
-        if let Some((_, iter)) = world
+        && let Some((_, iter)) = world
             .book()
             .families()
-            .find(|&(family, _)| family.to_lowercase().as_str() == lower.as_str());
+            .find(|&(family, _)| family.to_lowercase().as_str() == lower.as_str())
 
-        then {
+         {
             let detail = summarize_font_family(iter.collect());
             return Some(Tooltip::Text(detail));
         }
-    };
 
     None
 }

From b036fd97ab2c1cdc003b50eea7850279a1a7601f Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 21 Jul 2025 15:13:34 +0200
Subject: [PATCH 098/101] Reformat with 2024 edition

---
 crates/typst-cli/build.rs                     |   4 +-
 crates/typst-cli/src/compile.rs               |   8 +-
 crates/typst-cli/src/download.rs              |   2 +-
 crates/typst-cli/src/init.rs                  |   2 +-
 crates/typst-cli/src/main.rs                  |   4 +-
 crates/typst-cli/src/query.rs                 |   6 +-
 crates/typst-cli/src/server.rs                |   2 +-
 crates/typst-cli/src/timings.rs               |   4 +-
 crates/typst-cli/src/update.rs                |   2 +-
 crates/typst-cli/src/watch.rs                 |   4 +-
 crates/typst-cli/src/world.rs                 |  16 +-
 crates/typst-eval/src/access.rs               |  11 +-
 crates/typst-eval/src/binding.rs              |   2 +-
 crates/typst-eval/src/call.rs                 |  10 +-
 crates/typst-eval/src/code.rs                 |  33 ++-
 crates/typst-eval/src/flow.rs                 |   6 +-
 crates/typst-eval/src/import.rs               |  35 ++--
 crates/typst-eval/src/lib.rs                  |   8 +-
 crates/typst-eval/src/markup.rs               |   2 +-
 crates/typst-eval/src/ops.rs                  |  15 +-
 crates/typst-eval/src/rules.rs                |  23 +-
 crates/typst-eval/src/vm.rs                   |   4 +-
 crates/typst-html/src/convert.rs              |   4 +-
 crates/typst-html/src/document.rs             |   6 +-
 crates/typst-html/src/dom.rs                  |   4 +-
 crates/typst-html/src/encode.rs               |  10 +-
 crates/typst-html/src/fragment.rs             |   2 +-
 crates/typst-html/src/lib.rs                  |   8 +-
 crates/typst-html/src/link.rs                 |   4 +-
 crates/typst-html/src/rules.rs                |  16 +-
 crates/typst-html/src/typed.rs                |   6 +-
 crates/typst-ide/src/analyze.rs               |  19 +-
 crates/typst-ide/src/complete.rs              | 198 +++++++++---------
 crates/typst-ide/src/definition.rs            |  10 +-
 crates/typst-ide/src/jump.rs                  |  37 ++--
 crates/typst-ide/src/lib.rs                   |  14 +-
 crates/typst-ide/src/matchers.rs              |  31 +--
 crates/typst-ide/src/tests.rs                 |   2 +-
 crates/typst-ide/src/tooltip.rs               |  69 +++---
 crates/typst-ide/src/utils.rs                 |   8 +-
 crates/typst-kit/src/package.rs               |   4 +-
 crates/typst-layout/src/flow/block.rs         |   7 +-
 crates/typst-layout/src/flow/collect.rs       |  15 +-
 crates/typst-layout/src/flow/compose.rs       |   8 +-
 crates/typst-layout/src/flow/mod.rs           |   8 +-
 crates/typst-layout/src/grid/layouter.rs      | 108 +++++-----
 crates/typst-layout/src/grid/lines.rs         |  50 ++---
 crates/typst-layout/src/grid/mod.rs           |   4 +-
 crates/typst-layout/src/grid/repeated.rs      |  20 +-
 crates/typst-layout/src/grid/rowspans.rs      |  29 +--
 crates/typst-layout/src/inline/collect.rs     |  15 +-
 crates/typst-layout/src/inline/line.rs        |  53 ++---
 crates/typst-layout/src/inline/linebreak.rs   |  21 +-
 crates/typst-layout/src/inline/mod.rs         |  20 +-
 crates/typst-layout/src/inline/shaping.rs     |  16 +-
 crates/typst-layout/src/lists.rs              |  23 +-
 crates/typst-layout/src/math/accent.rs        |   4 +-
 crates/typst-layout/src/math/attach.rs        |   4 +-
 crates/typst-layout/src/math/frac.rs          |   4 +-
 crates/typst-layout/src/math/fragment.rs      |  19 +-
 crates/typst-layout/src/math/lr.rs            |  18 +-
 crates/typst-layout/src/math/mat.rs           |   6 +-
 crates/typst-layout/src/math/mod.rs           |  18 +-
 crates/typst-layout/src/math/root.rs          |   2 +-
 crates/typst-layout/src/math/run.rs           |  25 ++-
 crates/typst-layout/src/math/shared.rs        |   2 +-
 crates/typst-layout/src/math/stretch.rs       |   4 +-
 crates/typst-layout/src/math/text.rs          |   8 +-
 crates/typst-layout/src/math/underover.rs     |   4 +-
 crates/typst-layout/src/pages/mod.rs          |   6 +-
 crates/typst-layout/src/pages/run.rs          |   4 +-
 crates/typst-layout/src/repeat.rs             |   2 +-
 crates/typst-layout/src/rules.rs              |  14 +-
 crates/typst-layout/src/shapes.rs             |   2 +-
 crates/typst-layout/src/stack.rs              |   2 +-
 crates/typst-layout/src/transforms.rs         |   2 +-
 crates/typst-library/src/diag.rs              |  16 +-
 crates/typst-library/src/engine.rs            |  16 +-
 crates/typst-library/src/foundations/args.rs  |   6 +-
 crates/typst-library/src/foundations/array.rs |   8 +-
 crates/typst-library/src/foundations/auto.rs  |   4 +-
 crates/typst-library/src/foundations/bool.rs  |   2 +-
 crates/typst-library/src/foundations/bytes.rs |   6 +-
 crates/typst-library/src/foundations/calc.rs  |   4 +-
 crates/typst-library/src/foundations/cast.rs  |  14 +-
 .../src/foundations/content/element.rs        |   6 +-
 .../src/foundations/content/field.rs          |   2 +-
 .../src/foundations/content/mod.rs            |  13 +-
 .../src/foundations/content/raw.rs            |   2 +-
 .../typst-library/src/foundations/context.rs  |   4 +-
 .../typst-library/src/foundations/datetime.rs |  10 +-
 .../typst-library/src/foundations/decimal.rs  |  10 +-
 crates/typst-library/src/foundations/dict.rs  |   4 +-
 .../typst-library/src/foundations/duration.rs |   4 +-
 .../typst-library/src/foundations/fields.rs   |   2 +-
 crates/typst-library/src/foundations/float.rs |   6 +-
 crates/typst-library/src/foundations/func.rs  |  12 +-
 crates/typst-library/src/foundations/int.rs   |   6 +-
 crates/typst-library/src/foundations/label.rs |   4 +-
 crates/typst-library/src/foundations/mod.rs   |   2 +-
 .../typst-library/src/foundations/module.rs   |   6 +-
 crates/typst-library/src/foundations/none.rs  |   2 +-
 crates/typst-library/src/foundations/ops.rs   |   4 +-
 .../typst-library/src/foundations/plugin.rs   |   6 +-
 crates/typst-library/src/foundations/repr.rs  |   4 +-
 crates/typst-library/src/foundations/scope.rs |   6 +-
 .../typst-library/src/foundations/selector.rs |   8 +-
 crates/typst-library/src/foundations/str.rs   |  12 +-
 .../typst-library/src/foundations/styles.rs   |  12 +-
 .../typst-library/src/foundations/symbol.rs   |  10 +-
 .../typst-library/src/foundations/target.rs   |   2 +-
 crates/typst-library/src/foundations/ty.rs    |   6 +-
 crates/typst-library/src/foundations/value.rs |  12 +-
 .../typst-library/src/foundations/version.rs  |   6 +-
 .../src/introspection/counter.rs              |  14 +-
 .../typst-library/src/introspection/here.rs   |   2 +-
 .../src/introspection/introspector.rs         |   2 +-
 .../typst-library/src/introspection/locate.rs |   2 +-
 .../src/introspection/location.rs             |   2 +-
 .../src/introspection/metadata.rs             |   2 +-
 .../typst-library/src/introspection/query.rs  |   2 +-
 .../typst-library/src/introspection/state.rs  |  10 +-
 crates/typst-library/src/introspection/tag.rs |   4 +-
 crates/typst-library/src/layout/abs.rs        |   2 +-
 crates/typst-library/src/layout/align.rs      |   8 +-
 crates/typst-library/src/layout/angle.rs      |   2 +-
 crates/typst-library/src/layout/axes.rs       |   6 +-
 crates/typst-library/src/layout/columns.rs    |   2 +-
 crates/typst-library/src/layout/container.rs  |   6 +-
 crates/typst-library/src/layout/corners.rs    |   7 +-
 crates/typst-library/src/layout/dir.rs        |   2 +-
 crates/typst-library/src/layout/em.rs         |  20 +-
 crates/typst-library/src/layout/fr.rs         |   2 +-
 crates/typst-library/src/layout/frame.rs      |   2 +-
 crates/typst-library/src/layout/grid/mod.rs   |   8 +-
 .../typst-library/src/layout/grid/resolve.rs  |  36 ++--
 crates/typst-library/src/layout/hide.rs       |   2 +-
 crates/typst-library/src/layout/layout.rs     |   2 +-
 crates/typst-library/src/layout/length.rs     |   6 +-
 crates/typst-library/src/layout/measure.rs    |   2 +-
 crates/typst-library/src/layout/pad.rs        |   2 +-
 crates/typst-library/src/layout/page.rs       |   8 +-
 crates/typst-library/src/layout/place.rs      |   2 +-
 crates/typst-library/src/layout/ratio.rs      |   8 +-
 crates/typst-library/src/layout/rel.rs        |   4 +-
 crates/typst-library/src/layout/repeat.rs     |   2 +-
 crates/typst-library/src/layout/sides.rs      |  13 +-
 crates/typst-library/src/layout/spacing.rs    |   2 +-
 crates/typst-library/src/layout/stack.rs      |   2 +-
 crates/typst-library/src/layout/transform.rs  |   2 +-
 crates/typst-library/src/loading/cbor.rs      |   2 +-
 crates/typst-library/src/loading/csv.rs       |   4 +-
 crates/typst-library/src/loading/json.rs      |   2 +-
 crates/typst-library/src/loading/mod.rs       |   4 +-
 crates/typst-library/src/loading/read.rs      |   2 +-
 crates/typst-library/src/loading/toml.rs      |   2 +-
 crates/typst-library/src/loading/xml.rs       |   4 +-
 crates/typst-library/src/loading/yaml.rs      |   2 +-
 crates/typst-library/src/math/accent.rs       |   4 +-
 crates/typst-library/src/math/attach.rs       |   2 +-
 crates/typst-library/src/math/cancel.rs       |   2 +-
 crates/typst-library/src/math/equation.rs     |   2 +-
 crates/typst-library/src/math/frac.rs         |   2 +-
 crates/typst-library/src/math/lr.rs           |   2 +-
 crates/typst-library/src/math/matrix.rs       |  10 +-
 crates/typst-library/src/math/mod.rs          |   2 +-
 crates/typst-library/src/math/op.rs           |   4 +-
 crates/typst-library/src/math/root.rs         |   2 +-
 crates/typst-library/src/math/style.rs        |   2 +-
 crates/typst-library/src/math/underover.rs    |   2 +-
 .../typst-library/src/model/bibliography.rs   |  29 +--
 crates/typst-library/src/model/cite.rs        |   4 +-
 crates/typst-library/src/model/document.rs    |   6 +-
 crates/typst-library/src/model/emph.rs        |   2 +-
 crates/typst-library/src/model/enum.rs        |   2 +-
 crates/typst-library/src/model/figure.rs      |   6 +-
 crates/typst-library/src/model/footnote.rs    |   6 +-
 crates/typst-library/src/model/heading.rs     |   2 +-
 crates/typst-library/src/model/link.rs        |   6 +-
 crates/typst-library/src/model/list.rs        |   6 +-
 crates/typst-library/src/model/numbering.rs   |   6 +-
 crates/typst-library/src/model/outline.rs     |   7 +-
 crates/typst-library/src/model/par.rs         |   6 +-
 crates/typst-library/src/model/quote.rs       |   4 +-
 crates/typst-library/src/model/reference.rs   |  15 +-
 crates/typst-library/src/model/strong.rs      |   2 +-
 crates/typst-library/src/model/table.rs       |   4 +-
 crates/typst-library/src/model/terms.rs       |   2 +-
 crates/typst-library/src/pdf/embed.rs         |   6 +-
 crates/typst-library/src/routines.rs          |   2 +-
 crates/typst-library/src/text/case.rs         |   2 +-
 crates/typst-library/src/text/deco.rs         |   2 +-
 crates/typst-library/src/text/font/book.rs    |  22 +-
 crates/typst-library/src/text/font/variant.rs |   2 +-
 crates/typst-library/src/text/item.rs         |   2 +-
 crates/typst-library/src/text/lang.rs         |   4 +-
 crates/typst-library/src/text/linebreak.rs    |   2 +-
 crates/typst-library/src/text/lorem.rs        |   2 +-
 crates/typst-library/src/text/mod.rs          |  12 +-
 crates/typst-library/src/text/raw.rs          |  15 +-
 crates/typst-library/src/text/shift.rs        |   2 +-
 crates/typst-library/src/text/smallcaps.rs    |   2 +-
 crates/typst-library/src/text/smartquote.rs   |  18 +-
 crates/typst-library/src/text/space.rs        |   2 +-
 crates/typst-library/src/visualize/color.rs   |  25 +--
 crates/typst-library/src/visualize/curve.rs   |   6 +-
 .../typst-library/src/visualize/gradient.rs   |  10 +-
 .../typst-library/src/visualize/image/mod.rs  |   8 +-
 .../src/visualize/image/raster.rs             |   8 +-
 .../typst-library/src/visualize/image/svg.rs  |   4 +-
 crates/typst-library/src/visualize/paint.rs   |   2 +-
 crates/typst-library/src/visualize/path.rs    |   2 +-
 crates/typst-library/src/visualize/polygon.rs |   2 +-
 crates/typst-library/src/visualize/shape.rs   |   2 +-
 crates/typst-library/src/visualize/stroke.rs  |   4 +-
 crates/typst-library/src/visualize/tiling.rs  |  14 +-
 crates/typst-macros/src/elem.rs               |   4 +-
 crates/typst-macros/src/func.rs               |   2 +-
 crates/typst-macros/src/scope.rs              |  13 +-
 crates/typst-macros/src/time.rs               |   4 +-
 crates/typst-macros/src/ty.rs                 |   4 +-
 crates/typst-macros/src/util.rs               |  17 +-
 crates/typst-pdf/src/convert.rs               |   8 +-
 crates/typst-pdf/src/embed.rs                 |   4 +-
 crates/typst-pdf/src/image.rs                 |   2 +-
 crates/typst-pdf/src/lib.rs                   |   2 +-
 crates/typst-pdf/src/outline.rs               |   8 +-
 crates/typst-pdf/src/paint.rs                 |   2 +-
 crates/typst-pdf/src/shape.rs                 |   8 +-
 crates/typst-pdf/src/text.rs                  |   4 +-
 crates/typst-realize/src/lib.rs               |  18 +-
 crates/typst-render/src/lib.rs                |  62 +++---
 crates/typst-render/src/shape.rs              |   2 +-
 crates/typst-render/src/text.rs               |  43 ++--
 crates/typst-svg/src/image.rs                 |   4 +-
 crates/typst-svg/src/lib.rs                   |   9 +-
 crates/typst-svg/src/paint.rs                 |   2 +-
 crates/typst-syntax/src/ast.rs                |   2 +-
 crates/typst-syntax/src/file.rs               |   2 +-
 crates/typst-syntax/src/highlight.rs          |  32 ++-
 crates/typst-syntax/src/lexer.rs              |  21 +-
 crates/typst-syntax/src/lib.rs                |   2 +-
 crates/typst-syntax/src/node.rs               |  21 +-
 crates/typst-syntax/src/package.rs            |  12 +-
 crates/typst-syntax/src/parser.rs             |  43 ++--
 crates/typst-syntax/src/reparser.rs           |  17 +-
 crates/typst-syntax/src/source.rs             |   2 +-
 crates/typst-syntax/src/span.rs               |   6 +-
 crates/typst-utils/src/fat.rs                 |  38 ++--
 crates/typst-utils/src/pico.rs                |   6 +-
 crates/typst/src/lib.rs                       |   6 +-
 docs/src/html.rs                              |  20 +-
 docs/src/lib.rs                               |   6 +-
 docs/src/link.rs                              |  13 +-
 docs/src/main.rs                              |   2 +-
 tests/fuzz/src/compile.rs                     |   7 +-
 tests/src/collect.rs                          |  10 +-
 tests/src/custom.rs                           |   2 +-
 tests/src/run.rs                              |  18 +-
 tests/src/world.rs                            |   6 +-
 260 files changed, 1245 insertions(+), 1289 deletions(-)

diff --git a/crates/typst-cli/build.rs b/crates/typst-cli/build.rs
index bd6a563db..23bc2d183 100644
--- a/crates/typst-cli/build.rs
+++ b/crates/typst-cli/build.rs
@@ -1,10 +1,10 @@
 use std::env;
-use std::fs::{create_dir_all, File};
+use std::fs::{File, create_dir_all};
 use std::path::Path;
 use std::process::Command;
 
 use clap::{CommandFactory, ValueEnum};
-use clap_complete::{generate_to, Shell};
+use clap_complete::{Shell, generate_to};
 use clap_mangen::Man;
 
 #[path = "src/args.rs"]
diff --git a/crates/typst-cli/src/compile.rs b/crates/typst-cli/src/compile.rs
index 0db67b454..30cf1473e 100644
--- a/crates/typst-cli/src/compile.rs
+++ b/crates/typst-cli/src/compile.rs
@@ -10,13 +10,13 @@ use ecow::eco_format;
 use parking_lot::RwLock;
 use pathdiff::diff_paths;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+use typst::WorldExt;
 use typst::diag::{
-    bail, At, Severity, SourceDiagnostic, SourceResult, StrResult, Warned,
+    At, Severity, SourceDiagnostic, SourceResult, StrResult, Warned, bail,
 };
 use typst::foundations::{Datetime, Smart};
 use typst::layout::{Frame, Page, PageRanges, PagedDocument};
 use typst::syntax::{FileId, Lines, Span};
-use typst::WorldExt;
 use typst_html::HtmlDocument;
 use typst_pdf::{PdfOptions, PdfStandards, Timestamp};
 
@@ -513,7 +513,9 @@ fn write_make_deps(
         })
         .collect::<Result<Vec<_>, _>>()
     else {
-        bail!("failed to create make dependencies file because output path was not valid unicode")
+        bail!(
+            "failed to create make dependencies file because output path was not valid unicode"
+        )
     };
     if output_paths.is_empty() {
         bail!("failed to create make dependencies file because output was stdout")
diff --git a/crates/typst-cli/src/download.rs b/crates/typst-cli/src/download.rs
index ca1e539d4..28317ff72 100644
--- a/crates/typst-cli/src/download.rs
+++ b/crates/typst-cli/src/download.rs
@@ -8,8 +8,8 @@ use codespan_reporting::term::termcolor::WriteColor;
 use typst::utils::format_duration;
 use typst_kit::download::{DownloadState, Downloader, Progress};
 
-use crate::terminal::{self, TermOut};
 use crate::ARGS;
+use crate::terminal::{self, TermOut};
 
 /// Prints download progress by writing `downloading {0}` followed by repeatedly
 /// updating the last terminal line.
diff --git a/crates/typst-cli/src/init.rs b/crates/typst-cli/src/init.rs
index 9a77fb470..845a564f4 100644
--- a/crates/typst-cli/src/init.rs
+++ b/crates/typst-cli/src/init.rs
@@ -4,7 +4,7 @@ use std::path::Path;
 use codespan_reporting::term::termcolor::{Color, ColorSpec, WriteColor};
 use ecow::eco_format;
 use fs_extra::dir::CopyOptions;
-use typst::diag::{bail, FileError, StrResult};
+use typst::diag::{FileError, StrResult, bail};
 use typst::syntax::package::{
     PackageManifest, PackageSpec, TemplateInfo, VersionlessPackageSpec,
 };
diff --git a/crates/typst-cli/src/main.rs b/crates/typst-cli/src/main.rs
index 6a3b337d8..4774dd43b 100644
--- a/crates/typst-cli/src/main.rs
+++ b/crates/typst-cli/src/main.rs
@@ -21,8 +21,8 @@ use std::io::{self, Write};
 use std::process::ExitCode;
 use std::sync::LazyLock;
 
-use clap::error::ErrorKind;
 use clap::Parser;
+use clap::error::ErrorKind;
 use codespan_reporting::term;
 use codespan_reporting::term::termcolor::WriteColor;
 use typst::diag::HintedStrResult;
@@ -102,7 +102,7 @@ fn print_error(msg: &str) -> io::Result<()> {
 
 #[cfg(not(feature = "self-update"))]
 mod update {
-    use typst::diag::{bail, StrResult};
+    use typst::diag::{StrResult, bail};
 
     use crate::args::UpdateCommand;
 
diff --git a/crates/typst-cli/src/query.rs b/crates/typst-cli/src/query.rs
index b1a446203..30688b3b6 100644
--- a/crates/typst-cli/src/query.rs
+++ b/crates/typst-cli/src/query.rs
@@ -1,12 +1,12 @@
 use comemo::Track;
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use serde::Serialize;
-use typst::diag::{bail, HintedStrResult, StrResult, Warned};
+use typst::World;
+use typst::diag::{HintedStrResult, StrResult, Warned, bail};
 use typst::engine::Sink;
 use typst::foundations::{Content, IntoValue, LocatableSelector, Scope};
 use typst::layout::PagedDocument;
 use typst::syntax::{Span, SyntaxMode};
-use typst::World;
 use typst_eval::eval_string;
 
 use crate::args::{QueryCommand, SerializationFormat};
diff --git a/crates/typst-cli/src/server.rs b/crates/typst-cli/src/server.rs
index 11c564e8d..0dde19f7f 100644
--- a/crates/typst-cli/src/server.rs
+++ b/crates/typst-cli/src/server.rs
@@ -5,7 +5,7 @@ use std::sync::Arc;
 use ecow::eco_format;
 use parking_lot::{Condvar, Mutex, MutexGuard};
 use tiny_http::{Header, Request, Response, StatusCode};
-use typst::diag::{bail, StrResult};
+use typst::diag::{StrResult, bail};
 
 use crate::args::{Input, ServerArgs};
 
diff --git a/crates/typst-cli/src/timings.rs b/crates/typst-cli/src/timings.rs
index 3d10bbc67..89b9523bf 100644
--- a/crates/typst-cli/src/timings.rs
+++ b/crates/typst-cli/src/timings.rs
@@ -2,9 +2,9 @@ use std::fs::File;
 use std::io::BufWriter;
 use std::path::{Path, PathBuf};
 
-use typst::diag::{bail, StrResult};
-use typst::syntax::Span;
 use typst::World;
+use typst::diag::{StrResult, bail};
+use typst::syntax::Span;
 
 use crate::args::{CliArguments, Command};
 use crate::world::SystemWorld;
diff --git a/crates/typst-cli/src/update.rs b/crates/typst-cli/src/update.rs
index ec8ca71e8..ec074c6c4 100644
--- a/crates/typst-cli/src/update.rs
+++ b/crates/typst-cli/src/update.rs
@@ -6,7 +6,7 @@ use ecow::eco_format;
 use semver::Version;
 use serde::Deserialize;
 use tempfile::NamedTempFile;
-use typst::diag::{bail, StrResult};
+use typst::diag::{StrResult, bail};
 use typst_kit::download::Downloader;
 use xz2::bufread::XzDecoder;
 use zip::ZipArchive;
diff --git a/crates/typst-cli/src/watch.rs b/crates/typst-cli/src/watch.rs
index 630d340b2..765f86808 100644
--- a/crates/typst-cli/src/watch.rs
+++ b/crates/typst-cli/src/watch.rs
@@ -10,12 +10,12 @@ use codespan_reporting::term::{self, termcolor};
 use ecow::eco_format;
 use notify::{Event, RecommendedWatcher, RecursiveMode, Watcher as _};
 use same_file::is_same_file;
-use typst::diag::{bail, warning, StrResult};
+use typst::diag::{StrResult, bail, warning};
 use typst::syntax::Span;
 use typst::utils::format_duration;
 
 use crate::args::{Input, Output, WatchCommand};
-use crate::compile::{compile_once, print_diagnostics, CompileConfig};
+use crate::compile::{CompileConfig, compile_once, print_diagnostics};
 use crate::timings::Timer;
 use crate::world::{SystemWorld, WorldCreationError};
 use crate::{print_error, terminal};
diff --git a/crates/typst-cli/src/world.rs b/crates/typst-cli/src/world.rs
index 900199354..42083ef20 100644
--- a/crates/typst-cli/src/world.rs
+++ b/crates/typst-cli/src/world.rs
@@ -5,7 +5,7 @@ use std::sync::{LazyLock, OnceLock};
 use std::{fmt, fs, io, mem};
 
 use chrono::{DateTime, Datelike, FixedOffset, Local, Utc};
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use parking_lot::Mutex;
 use typst::diag::{FileError, FileResult};
 use typst::foundations::{Bytes, Datetime, Dict, IntoValue};
@@ -362,9 +362,10 @@ impl<T: Clone> SlotCell<T> {
     ) -> FileResult<T> {
         // If we accessed the file already in this compilation, retrieve it.
         if mem::replace(&mut self.accessed, true)
-            && let Some(data) = &self.data {
-                return data.clone();
-            }
+            && let Some(data) = &self.data
+        {
+            return data.clone();
+        }
 
         // Read and hash the file.
         let result = timed!("loading file", load());
@@ -372,9 +373,10 @@ impl<T: Clone> SlotCell<T> {
 
         // If the file contents didn't change, yield the old processed data.
         if mem::replace(&mut self.fingerprint, fingerprint) == fingerprint
-            && let Some(data) = &self.data {
-                return data.clone();
-            }
+            && let Some(data) = &self.data
+        {
+            return data.clone();
+        }
 
         let prev = self.data.take().and_then(Result::ok);
         let value = result.and_then(|data| f(data, prev));
diff --git a/crates/typst-eval/src/access.rs b/crates/typst-eval/src/access.rs
index ddcc8b98b..c82b9339a 100644
--- a/crates/typst-eval/src/access.rs
+++ b/crates/typst-eval/src/access.rs
@@ -1,9 +1,9 @@
 use ecow::eco_format;
-use typst_library::diag::{bail, At, Hint, SourceResult, Trace, Tracepoint};
+use typst_library::diag::{At, Hint, SourceResult, Trace, Tracepoint, bail};
 use typst_library::foundations::{Dict, Value};
 use typst_syntax::ast::{self, AstNode};
 
-use crate::{call_method_access, is_accessor_method, Eval, Vm};
+use crate::{Eval, Vm, call_method_access, is_accessor_method};
 
 /// Access an expression mutably.
 pub(crate) trait Access {
@@ -30,9 +30,10 @@ impl Access for ast::Ident<'_> {
     fn access<'a>(self, vm: &'a mut Vm) -> SourceResult<&'a mut Value> {
         let span = self.span();
         if vm.inspected == Some(span)
-            && let Ok(binding) = vm.scopes.get(&self) {
-                vm.trace(binding.read().clone());
-            }
+            && let Ok(binding) = vm.scopes.get(&self)
+        {
+            vm.trace(binding.read().clone());
+        }
         vm.scopes
             .get_mut(&self)
             .and_then(|b| b.write().map_err(Into::into))
diff --git a/crates/typst-eval/src/binding.rs b/crates/typst-eval/src/binding.rs
index f3802f079..9a53ac069 100644
--- a/crates/typst-eval/src/binding.rs
+++ b/crates/typst-eval/src/binding.rs
@@ -1,7 +1,7 @@
 use std::collections::HashSet;
 
 use ecow::eco_format;
-use typst_library::diag::{bail, error, At, SourceDiagnostic, SourceResult};
+use typst_library::diag::{At, SourceDiagnostic, SourceResult, bail, error};
 use typst_library::foundations::{Array, Dict, Value};
 use typst_syntax::ast::{self, AstNode};
 
diff --git a/crates/typst-eval/src/call.rs b/crates/typst-eval/src/call.rs
index eaeabbab3..c4087f6bb 100644
--- a/crates/typst-eval/src/call.rs
+++ b/crates/typst-eval/src/call.rs
@@ -1,8 +1,9 @@
 use comemo::{Tracked, TrackedMut};
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
+use typst_library::World;
 use typst_library::diag::{
-    bail, error, At, HintedStrResult, HintedString, SourceDiagnostic, SourceResult,
-    Trace, Tracepoint,
+    At, HintedStrResult, HintedString, SourceDiagnostic, SourceResult, Trace, Tracepoint,
+    bail, error,
 };
 use typst_library::engine::{Engine, Sink, Traced};
 use typst_library::foundations::{
@@ -12,12 +13,11 @@ use typst_library::foundations::{
 use typst_library::introspection::Introspector;
 use typst_library::math::LrElem;
 use typst_library::routines::Routines;
-use typst_library::World;
 use typst_syntax::ast::{self, AstNode, Ident};
 use typst_syntax::{Span, Spanned, SyntaxNode};
 use typst_utils::LazyHash;
 
-use crate::{call_method_mut, is_mutating_method, Access, Eval, FlowEvent, Route, Vm};
+use crate::{Access, Eval, FlowEvent, Route, Vm, call_method_mut, is_mutating_method};
 
 impl Eval for ast::FuncCall<'_> {
     type Output = Value;
diff --git a/crates/typst-eval/src/code.rs b/crates/typst-eval/src/code.rs
index 1930ebc48..d3e0c937f 100644
--- a/crates/typst-eval/src/code.rs
+++ b/crates/typst-eval/src/code.rs
@@ -1,9 +1,9 @@
-use ecow::{eco_vec, EcoVec};
-use typst_library::diag::{bail, error, warning, At, SourceResult};
+use ecow::{EcoVec, eco_vec};
+use typst_library::diag::{At, SourceResult, bail, error, warning};
 use typst_library::engine::Engine;
 use typst_library::foundations::{
-    ops, Array, Capturer, Closure, Content, ContextElem, Dict, Func, NativeElement,
-    Selector, Str, Value,
+    Array, Capturer, Closure, Content, ContextElem, Dict, Func, NativeElement, Selector,
+    Str, Value, ops,
 };
 use typst_library::introspection::{Counter, State};
 use typst_syntax::ast::{self, AstNode};
@@ -324,19 +324,18 @@ impl Eval for ast::FieldAccess<'_> {
         };
 
         // Check whether this is a get rule field access.
-            if let Value::Func(func) = &value &&
-               let Some(element) = func.element() &&
-               let Some(id) = element.field_id(&field) &&
-               let styles = vm.context.styles().at(field.span()) &&
-               let Ok(value) = element.field_from_styles(
-                id,
-                styles.as_ref().map(|&s| s).unwrap_or_default(),
-            ) {
-                // Only validate the context once we know that this is indeed
-                // a field from the style chain.
-                let _ = styles?;
-                return Ok(value);
-            }
+        if let Value::Func(func) = &value
+            && let Some(element) = func.element()
+            && let Some(id) = element.field_id(&field)
+            && let styles = vm.context.styles().at(field.span())
+            && let Ok(value) = element
+                .field_from_styles(id, styles.as_ref().map(|&s| s).unwrap_or_default())
+        {
+            // Only validate the context once we know that this is indeed
+            // a field from the style chain.
+            let _ = styles?;
+            return Ok(value);
+        }
 
         Err(err)
     }
diff --git a/crates/typst-eval/src/flow.rs b/crates/typst-eval/src/flow.rs
index b5ba487f5..dcc2073bd 100644
--- a/crates/typst-eval/src/flow.rs
+++ b/crates/typst-eval/src/flow.rs
@@ -1,10 +1,10 @@
-use typst_library::diag::{bail, error, At, SourceDiagnostic, SourceResult};
-use typst_library::foundations::{ops, IntoValue, Value};
+use typst_library::diag::{At, SourceDiagnostic, SourceResult, bail, error};
+use typst_library::foundations::{IntoValue, Value, ops};
 use typst_syntax::ast::{self, AstNode};
 use typst_syntax::{Span, SyntaxKind, SyntaxNode};
 use unicode_segmentation::UnicodeSegmentation;
 
-use crate::{destructure, Eval, Vm};
+use crate::{Eval, Vm, destructure};
 
 /// The maximum number of loop iterations.
 const MAX_ITERATIONS: usize = 10_000;
diff --git a/crates/typst-eval/src/import.rs b/crates/typst-eval/src/import.rs
index 138d7ccfe..1e091a9cf 100644
--- a/crates/typst-eval/src/import.rs
+++ b/crates/typst-eval/src/import.rs
@@ -1,16 +1,16 @@
 use comemo::TrackedMut;
-use ecow::{eco_format, eco_vec, EcoString};
+use ecow::{EcoString, eco_format, eco_vec};
+use typst_library::World;
 use typst_library::diag::{
-    bail, error, warning, At, FileError, SourceResult, Trace, Tracepoint,
+    At, FileError, SourceResult, Trace, Tracepoint, bail, error, warning,
 };
 use typst_library::engine::Engine;
 use typst_library::foundations::{Binding, Content, Module, Value};
-use typst_library::World;
 use typst_syntax::ast::{self, AstNode, BareImportError};
 use typst_syntax::package::{PackageManifest, PackageSpec};
 use typst_syntax::{FileId, Span, VirtualPath};
 
-use crate::{eval, Eval, Vm};
+use crate::{Eval, Vm, eval};
 
 impl Eval for ast::ModuleImport<'_> {
     type Output = Value;
@@ -47,13 +47,14 @@ impl Eval for ast::ModuleImport<'_> {
         let new_name = self.new_name();
         if let Some(new_name) = new_name {
             if let ast::Expr::Ident(ident) = self.source()
-                && ident.as_str() == new_name.as_str() {
-                    // Warn on `import x as x`
-                    vm.engine.sink.warn(warning!(
-                        new_name.span(),
-                        "unnecessary import rename to same name",
-                    ));
-                }
+                && ident.as_str() == new_name.as_str()
+            {
+                // Warn on `import x as x`
+                vm.engine.sink.warn(warning!(
+                    new_name.span(),
+                    "unnecessary import rename to same name",
+                ));
+            }
 
             // Define renamed module on the scope.
             vm.define(new_name, source.clone());
@@ -144,12 +145,12 @@ impl Eval for ast::ModuleImport<'_> {
                             if let ast::ImportItem::Renamed(renamed_item) = &item
                                 && renamed_item.original_name().as_str()
                                     == renamed_item.new_name().as_str()
-                                {
-                                    vm.engine.sink.warn(warning!(
-                                        renamed_item.new_name().span(),
-                                        "unnecessary import rename to same name",
-                                    ));
-                                }
+                            {
+                                vm.engine.sink.warn(warning!(
+                                    renamed_item.new_name().span(),
+                                    "unnecessary import rename to same name",
+                                ));
+                            }
 
                             vm.bind(item.bound_name(), binding.clone());
                         }
diff --git a/crates/typst-eval/src/lib.rs b/crates/typst-eval/src/lib.rs
index e4bbe4f0f..965b37c96 100644
--- a/crates/typst-eval/src/lib.rs
+++ b/crates/typst-eval/src/lib.rs
@@ -14,7 +14,7 @@ mod methods;
 mod rules;
 mod vm;
 
-pub use self::call::{eval_closure, CapturesVisitor};
+pub use self::call::{CapturesVisitor, eval_closure};
 pub use self::flow::FlowEvent;
 pub use self::import::import;
 pub use self::vm::Vm;
@@ -24,14 +24,14 @@ use self::binding::*;
 use self::methods::*;
 
 use comemo::{Track, Tracked, TrackedMut};
-use typst_library::diag::{bail, SourceResult};
+use typst_library::World;
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Context, Module, NativeElement, Scope, Scopes, Value};
 use typst_library::introspection::Introspector;
 use typst_library::math::EquationElem;
 use typst_library::routines::Routines;
-use typst_library::World;
-use typst_syntax::{ast, parse, parse_code, parse_math, Source, Span, SyntaxMode};
+use typst_syntax::{Source, Span, SyntaxMode, ast, parse, parse_code, parse_math};
 
 /// Evaluate a source file and return the resulting module.
 #[comemo::memoize]
diff --git a/crates/typst-eval/src/markup.rs b/crates/typst-eval/src/markup.rs
index baa548459..772494b61 100644
--- a/crates/typst-eval/src/markup.rs
+++ b/crates/typst-eval/src/markup.rs
@@ -1,4 +1,4 @@
-use typst_library::diag::{warning, At, SourceResult};
+use typst_library::diag::{At, SourceResult, warning};
 use typst_library::foundations::{
     Content, Label, NativeElement, Repr, Smart, Symbol, Unlabellable, Value,
 };
diff --git a/crates/typst-eval/src/ops.rs b/crates/typst-eval/src/ops.rs
index 9a8eb5239..af129411c 100644
--- a/crates/typst-eval/src/ops.rs
+++ b/crates/typst-eval/src/ops.rs
@@ -1,8 +1,8 @@
 use typst_library::diag::{At, HintedStrResult, SourceResult};
-use typst_library::foundations::{ops, IntoValue, Value};
+use typst_library::foundations::{IntoValue, Value, ops};
 use typst_syntax::ast::{self, AstNode};
 
-use crate::{access_dict, Access, Eval, Vm};
+use crate::{Access, Eval, Vm, access_dict};
 
 impl Eval for ast::Unary<'_> {
     type Output = Value;
@@ -77,11 +77,12 @@ fn apply_assignment(
     // An assignment to a dictionary field is different from a normal access
     // since it can create the field instead of just modifying it.
     if binary.op() == ast::BinOp::Assign
-        && let ast::Expr::FieldAccess(access) = lhs {
-            let dict = access_dict(vm, access)?;
-            dict.insert(access.field().get().clone().into(), rhs);
-            return Ok(Value::None);
-        }
+        && let ast::Expr::FieldAccess(access) = lhs
+    {
+        let dict = access_dict(vm, access)?;
+        dict.insert(access.field().get().clone().into(), rhs);
+        return Ok(Value::None);
+    }
 
     let location = binary.lhs().access(vm)?;
     let lhs = std::mem::take(&mut *location);
diff --git a/crates/typst-eval/src/rules.rs b/crates/typst-eval/src/rules.rs
index bf4a80780..011478a1e 100644
--- a/crates/typst-eval/src/rules.rs
+++ b/crates/typst-eval/src/rules.rs
@@ -1,4 +1,4 @@
-use typst_library::diag::{warning, At, SourceResult};
+use typst_library::diag::{At, SourceResult, warning};
 use typst_library::foundations::{
     Element, Func, Recipe, Selector, ShowableSelector, Styles, Transformation,
 };
@@ -13,9 +13,10 @@ impl Eval for ast::SetRule<'_> {
 
     fn eval(self, vm: &mut Vm) -> SourceResult<Self::Output> {
         if let Some(condition) = self.condition()
-            && !condition.eval(vm)?.cast::<bool>().at(condition.span())? {
-                return Ok(Styles::new());
-            }
+            && !condition.eval(vm)?.cast::<bool>().at(condition.span())?
+        {
+            return Ok(Styles::new());
+        }
 
         let target = self.target();
         let target = target
@@ -57,16 +58,16 @@ impl Eval for ast::ShowRule<'_> {
 
 /// Migration hint for `show par: set block(spacing: ..)`.
 fn check_show_par_set_block(vm: &mut Vm, recipe: &Recipe) {
-        if let Some(Selector::Elem(elem, _)) = recipe.selector() &&
-           *elem == Element::of::<ParElem>() &&
-           let Transformation::Style(styles) = recipe.transform() &&
-           (styles.has(BlockElem::above) || styles.has(BlockElem::below)) 
-        {
-            vm.engine.sink.warn(warning!(
+    if let Some(Selector::Elem(elem, _)) = recipe.selector()
+        && *elem == Element::of::<ParElem>()
+        && let Transformation::Style(styles) = recipe.transform()
+        && (styles.has(BlockElem::above) || styles.has(BlockElem::below))
+    {
+        vm.engine.sink.warn(warning!(
                 recipe.span(),
                 "`show par: set block(spacing: ..)` has no effect anymore";
                 hint: "write `set par(spacing: ..)` instead";
                 hint: "this is specific to paragraphs as they are not considered blocks anymore"
             ))
-        }
+    }
 }
diff --git a/crates/typst-eval/src/vm.rs b/crates/typst-eval/src/vm.rs
index 52cfb4b5b..2c62c8b40 100644
--- a/crates/typst-eval/src/vm.rs
+++ b/crates/typst-eval/src/vm.rs
@@ -1,10 +1,10 @@
 use comemo::Tracked;
+use typst_library::World;
 use typst_library::diag::warning;
 use typst_library::engine::Engine;
 use typst_library::foundations::{Binding, Context, IntoValue, Scopes, Value};
-use typst_library::World;
-use typst_syntax::ast::{self, AstNode};
 use typst_syntax::Span;
+use typst_syntax::ast::{self, AstNode};
 
 use crate::FlowEvent;
 
diff --git a/crates/typst-html/src/convert.rs b/crates/typst-html/src/convert.rs
index 817b0f025..09d89313c 100644
--- a/crates/typst-html/src/convert.rs
+++ b/crates/typst-html/src/convert.rs
@@ -1,4 +1,4 @@
-use typst_library::diag::{warning, SourceResult};
+use typst_library::diag::{SourceResult, warning};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Content, StyleChain, Target, TargetElem};
 use typst_library::introspection::{SplitLocator, TagElem};
@@ -8,7 +8,7 @@ use typst_library::routines::Pair;
 use typst_library::text::{LinebreakElem, SmartQuoteElem, SpaceElem, TextElem};
 
 use crate::fragment::html_fragment;
-use crate::{attr, tag, FrameElem, HtmlElem, HtmlElement, HtmlFrame, HtmlNode};
+use crate::{FrameElem, HtmlElem, HtmlElement, HtmlFrame, HtmlNode, attr, tag};
 
 /// Converts realized content into HTML nodes.
 pub fn convert_to_nodes<'a>(
diff --git a/crates/typst-html/src/document.rs b/crates/typst-html/src/document.rs
index c581df05f..ca84d3354 100644
--- a/crates/typst-html/src/document.rs
+++ b/crates/typst-html/src/document.rs
@@ -2,7 +2,8 @@ use std::collections::HashSet;
 use std::num::NonZeroUsize;
 
 use comemo::{Tracked, TrackedMut};
-use typst_library::diag::{bail, SourceResult};
+use typst_library::World;
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Content, StyleChain};
 use typst_library::introspection::{
@@ -11,11 +12,10 @@ use typst_library::introspection::{
 use typst_library::layout::{Point, Position, Transform};
 use typst_library::model::DocumentInfo;
 use typst_library::routines::{Arenas, RealizationKind, Routines};
-use typst_library::World;
 use typst_syntax::Span;
 use typst_utils::NonZeroExt;
 
-use crate::{attr, tag, HtmlDocument, HtmlElement, HtmlNode};
+use crate::{HtmlDocument, HtmlElement, HtmlNode, attr, tag};
 
 /// Produce an HTML document from content.
 ///
diff --git a/crates/typst-html/src/dom.rs b/crates/typst-html/src/dom.rs
index e7f5fcbcd..2c9a2e640 100644
--- a/crates/typst-html/src/dom.rs
+++ b/crates/typst-html/src/dom.rs
@@ -1,8 +1,8 @@
 use std::fmt::{self, Debug, Display, Formatter};
 
 use ecow::{EcoString, EcoVec};
-use typst_library::diag::{bail, HintedStrResult, StrResult};
-use typst_library::foundations::{cast, Dict, Repr, Str, StyleChain};
+use typst_library::diag::{HintedStrResult, StrResult, bail};
+use typst_library::foundations::{Dict, Repr, Str, StyleChain, cast};
 use typst_library::introspection::{Introspector, Tag};
 use typst_library::layout::{Abs, Frame, Point};
 use typst_library::model::DocumentInfo;
diff --git a/crates/typst-html/src/encode.rs b/crates/typst-html/src/encode.rs
index 02c3f16de..2d21109c1 100644
--- a/crates/typst-html/src/encode.rs
+++ b/crates/typst-html/src/encode.rs
@@ -1,12 +1,12 @@
 use std::fmt::Write;
 
-use typst_library::diag::{bail, At, SourceResult, StrResult};
+use typst_library::diag::{At, SourceResult, StrResult, bail};
 use typst_library::foundations::Repr;
 use typst_library::introspection::Introspector;
 use typst_syntax::Span;
 
 use crate::{
-    attr, charsets, tag, HtmlDocument, HtmlElement, HtmlFrame, HtmlNode, HtmlTag,
+    HtmlDocument, HtmlElement, HtmlFrame, HtmlNode, HtmlTag, attr, charsets, tag,
 };
 
 /// Encodes an HTML document into a string.
@@ -262,11 +262,7 @@ impl RawMode {
             {
                 // Template literals can be multi-line, so indent may change
                 // the semantics of the JavaScript.
-                if text.contains('`') {
-                    Self::Wrap
-                } else {
-                    Self::Indent
-                }
+                if text.contains('`') { Self::Wrap } else { Self::Indent }
             }
             tag::style => Self::Indent,
             _ => Self::Keep,
diff --git a/crates/typst-html/src/fragment.rs b/crates/typst-html/src/fragment.rs
index 78ae7dee0..66a59b678 100644
--- a/crates/typst-html/src/fragment.rs
+++ b/crates/typst-html/src/fragment.rs
@@ -4,8 +4,8 @@ use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Content, StyleChain};
 use typst_library::introspection::{Introspector, Locator, LocatorLink};
 
-use typst_library::routines::{Arenas, FragmentKind, RealizationKind, Routines};
 use typst_library::World;
+use typst_library::routines::{Arenas, FragmentKind, RealizationKind, Routines};
 
 use crate::HtmlNode;
 
diff --git a/crates/typst-html/src/lib.rs b/crates/typst-html/src/lib.rs
index 42b3c5d6f..373da607f 100644
--- a/crates/typst-html/src/lib.rs
+++ b/crates/typst-html/src/lib.rs
@@ -19,8 +19,8 @@ pub use self::encode::html;
 pub use self::rules::register;
 
 use ecow::EcoString;
-use typst_library::foundations::{Content, Module, Scope};
 use typst_library::Category;
+use typst_library::foundations::{Content, Module, Scope};
 use typst_macros::elem;
 
 /// Creates the module with all HTML definitions.
@@ -86,11 +86,7 @@ impl HtmlElem {
         attr: HtmlAttr,
         value: Option<impl Into<EcoString>>,
     ) -> Self {
-        if let Some(value) = value {
-            self.with_attr(attr, value)
-        } else {
-            self
-        }
+        if let Some(value) = value { self.with_attr(attr, value) } else { self }
     }
 
     /// Adds CSS styles to an element.
diff --git a/crates/typst-html/src/link.rs b/crates/typst-html/src/link.rs
index 0fcbe906a..ad70f06fe 100644
--- a/crates/typst-html/src/link.rs
+++ b/crates/typst-html/src/link.rs
@@ -1,14 +1,14 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 
 use comemo::Track;
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_library::foundations::{Label, NativeElement};
 use typst_library::introspection::{Introspector, Location, Tag};
 use typst_library::layout::{Frame, FrameItem, Point};
 use typst_library::model::{Destination, LinkElem};
 use typst_utils::PicoStr;
 
-use crate::{attr, tag, HtmlElement, HtmlNode};
+use crate::{HtmlElement, HtmlNode, attr, tag};
 
 /// Searches for links within a frame.
 ///
diff --git a/crates/typst-html/src/rules.rs b/crates/typst-html/src/rules.rs
index 14885bd36..c358a181e 100644
--- a/crates/typst-html/src/rules.rs
+++ b/crates/typst-html/src/rules.rs
@@ -1,12 +1,12 @@
 use std::num::NonZeroUsize;
 
-use ecow::{eco_format, EcoVec};
-use typst_library::diag::{warning, At};
+use ecow::{EcoVec, eco_format};
+use typst_library::diag::{At, warning};
 use typst_library::foundations::{
     Content, NativeElement, NativeRuleMap, ShowFn, Smart, StyleChain, Target,
 };
 use typst_library::introspection::{Counter, Locator};
-use typst_library::layout::resolve::{table_to_cellgrid, Cell, CellGrid, Entry};
+use typst_library::layout::resolve::{Cell, CellGrid, Entry, table_to_cellgrid};
 use typst_library::layout::{OuterVAlignment, Sizing};
 use typst_library::model::{
     Attribution, CiteElem, CiteGroup, Destination, EmphElem, EnumElem, FigureCaption,
@@ -19,7 +19,7 @@ use typst_library::text::{
 };
 use typst_library::visualize::ImageElem;
 
-use crate::{attr, css, tag, FrameElem, HtmlAttrs, HtmlElem, HtmlTag};
+use crate::{FrameElem, HtmlAttrs, HtmlElem, HtmlTag, attr, css, tag};
 
 /// Registers show rules for the [HTML target](Target::Html).
 pub fn register(rules: &mut NativeRuleMap) {
@@ -240,10 +240,10 @@ const QUOTE_RULE: ShowFn<QuoteElem> = |elem, _, styles| {
         let mut blockquote = HtmlElem::new(tag::blockquote).with_body(Some(realized));
         if let Some(Attribution::Content(attribution)) = attribution
             && let Some(link) = attribution.to_packed::<LinkElem>()
-                && let LinkTarget::Dest(Destination::Url(url)) = &link.dest {
-                    blockquote =
-                        blockquote.with_attr(attr::cite, url.clone().into_inner());
-                }
+            && let LinkTarget::Dest(Destination::Url(url)) = &link.dest
+        {
+            blockquote = blockquote.with_attr(attr::cite, url.clone().into_inner());
+        }
 
         realized = blockquote.pack().spanned(span);
 
diff --git a/crates/typst-html/src/typed.rs b/crates/typst-html/src/typed.rs
index 190ff4f16..56f090e91 100644
--- a/crates/typst-html/src/typed.rs
+++ b/crates/typst-html/src/typed.rs
@@ -9,9 +9,9 @@ use std::sync::LazyLock;
 
 use bumpalo::Bump;
 use comemo::Tracked;
-use ecow::{eco_format, eco_vec, EcoString};
+use ecow::{EcoString, eco_format, eco_vec};
 use typst_assets::html as data;
-use typst_library::diag::{bail, At, Hint, HintedStrResult, SourceResult};
+use typst_library::diag::{At, Hint, HintedStrResult, SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{
     Args, Array, AutoValue, CastInfo, Content, Context, Datetime, Dict, Duration,
@@ -22,7 +22,7 @@ use typst_library::layout::{Axes, Axis, Dir, Length};
 use typst_library::visualize::Color;
 use typst_macros::cast;
 
-use crate::{css, tag, HtmlAttr, HtmlAttrs, HtmlElem, HtmlTag};
+use crate::{HtmlAttr, HtmlAttrs, HtmlElem, HtmlTag, css, tag};
 
 /// Hook up all typed HTML definitions.
 pub(super) fn define(html: &mut Scope) {
diff --git a/crates/typst-ide/src/analyze.rs b/crates/typst-ide/src/analyze.rs
index e7fd8af8e..6f80c85d4 100644
--- a/crates/typst-ide/src/analyze.rs
+++ b/crates/typst-ide/src/analyze.rs
@@ -1,11 +1,11 @@
 use std::collections::HashSet;
 
 use comemo::Track;
-use ecow::{eco_vec, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_vec};
 use typst::foundations::{Label, Styles, Value};
 use typst::layout::PagedDocument;
 use typst::model::{BibliographyElem, FigureElem};
-use typst::syntax::{ast, LinkedNode, SyntaxKind};
+use typst::syntax::{LinkedNode, SyntaxKind, ast};
 
 use crate::IdeWorld;
 
@@ -28,14 +28,17 @@ pub fn analyze_expr(
         ast::Expr::Str(v) => Value::Str(v.get().into()),
         _ => {
             if node.kind() == SyntaxKind::Contextual
-                && let Some(child) = node.children().next_back() {
-                    return analyze_expr(world, &child);
-                }
+                && let Some(child) = node.children().next_back()
+            {
+                return analyze_expr(world, &child);
+            }
 
             if let Some(parent) = node.parent()
-                && parent.kind() == SyntaxKind::FieldAccess && node.index() > 0 {
-                    return analyze_expr(world, parent);
-                }
+                && parent.kind() == SyntaxKind::FieldAccess
+                && node.index() > 0
+            {
+                return analyze_expr(world, parent);
+            }
 
             return typst::trace::<PagedDocument>(world.upcast(), node.span());
         }
diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index a974eb313..87b592ec0 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -2,17 +2,17 @@ use std::cmp::Reverse;
 use std::collections::{BTreeMap, HashSet};
 use std::ffi::OsStr;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use serde::{Deserialize, Serialize};
 use typst::foundations::{
-    fields_on, repr, AutoValue, CastInfo, Func, Label, NoneValue, ParamInfo, Repr,
-    StyleChain, Styles, Type, Value,
+    AutoValue, CastInfo, Func, Label, NoneValue, ParamInfo, Repr, StyleChain, Styles,
+    Type, Value, fields_on, repr,
 };
 use typst::layout::{Alignment, Dir, PagedDocument};
 use typst::syntax::ast::AstNode;
 use typst::syntax::{
-    ast, is_id_continue, is_id_start, is_ident, FileId, LinkedNode, Side, Source,
-    SyntaxKind,
+    FileId, LinkedNode, Side, Source, SyntaxKind, ast, is_id_continue, is_id_start,
+    is_ident,
 };
 use typst::text::{FontFlags, RawElem};
 use typst::visualize::Color;
@@ -21,7 +21,7 @@ use unscanny::Scanner;
 use crate::utils::{
     check_value_recursively, globals, plain_docs_sentence, summarize_font_family,
 };
-use crate::{analyze_expr, analyze_import, analyze_labels, named_items, IdeWorld};
+use crate::{IdeWorld, analyze_expr, analyze_import, analyze_labels, named_items};
 
 /// Autocomplete a cursor position in a source file.
 ///
@@ -144,23 +144,23 @@ fn complete_markup(ctx: &mut CompletionContext) -> bool {
     }
 
     // Behind a half-completed binding: "#let x = |".
-        if let Some(prev) = ctx.leaf.prev_leaf()
+    if let Some(prev) = ctx.leaf.prev_leaf()
         && prev.kind() == SyntaxKind::Eq
         && prev.parent_kind() == Some(SyntaxKind::LetBinding)
-        {
-            ctx.from = ctx.cursor;
-            code_completions(ctx, false);
-            return true;
-        }
+    {
+        ctx.from = ctx.cursor;
+        code_completions(ctx, false);
+        return true;
+    }
 
     // Behind a half-completed context block: "#context |".
-        if let Some(prev) = ctx.leaf.prev_leaf()
+    if let Some(prev) = ctx.leaf.prev_leaf()
         && prev.kind() == SyntaxKind::Context
-         {
-            ctx.from = ctx.cursor;
-            code_completions(ctx, false);
-            return true;
-        }
+    {
+        ctx.from = ctx.cursor;
+        code_completions(ctx, false);
+        return true;
+    }
 
     // Directly after a raw block.
     let mut s = Scanner::new(ctx.text);
@@ -368,34 +368,35 @@ fn complete_field_accesses(ctx: &mut CompletionContext) -> bool {
     );
 
     // Behind an expression plus dot: "emoji.|".
-        if (ctx.leaf.kind() == SyntaxKind::Dot
-            || (matches!(ctx.leaf.kind(), SyntaxKind::Text | SyntaxKind::MathText)
-                && ctx.leaf.text() == "."))
+    if (ctx.leaf.kind() == SyntaxKind::Dot
+        || (matches!(ctx.leaf.kind(), SyntaxKind::Text | SyntaxKind::MathText)
+            && ctx.leaf.text() == "."))
         && ctx.leaf.range().end == ctx.cursor
         && let Some(prev) = ctx.leaf.prev_sibling()
         && (!in_markup || prev.range().end == ctx.leaf.range().start)
         && prev.is::<ast::Expr>()
-        && (prev.parent_kind() != Some(SyntaxKind::Markup) ||
-           prev.prev_sibling_kind() == Some(SyntaxKind::Hash))
+        && (prev.parent_kind() != Some(SyntaxKind::Markup)
+            || prev.prev_sibling_kind() == Some(SyntaxKind::Hash))
         && let Some((value, styles)) = analyze_expr(ctx.world, &prev).into_iter().next()
-         {
-            ctx.from = ctx.cursor;
-            field_access_completions(ctx, &value, &styles);
-            return true;
-        }
+    {
+        ctx.from = ctx.cursor;
+        field_access_completions(ctx, &value, &styles);
+        return true;
+    }
 
     // Behind a started field access: "emoji.fa|".
-        if ctx.leaf.kind() == SyntaxKind::Ident
+    if ctx.leaf.kind() == SyntaxKind::Ident
         && let Some(prev) = ctx.leaf.prev_sibling()
         && prev.kind() == SyntaxKind::Dot
         && let Some(prev_prev) = prev.prev_sibling()
         && prev_prev.is::<ast::Expr>()
-        && let Some((value, styles)) = analyze_expr(ctx.world, &prev_prev).into_iter().next()
-         {
-            ctx.from = ctx.leaf.offset();
-            field_access_completions(ctx, &value, &styles);
-            return true;
-        }
+        && let Some((value, styles)) =
+            analyze_expr(ctx.world, &prev_prev).into_iter().next()
+    {
+        ctx.from = ctx.leaf.offset();
+        field_access_completions(ctx, &value, &styles);
+        return true;
+    }
 
     false
 }
@@ -498,36 +499,37 @@ fn complete_open_labels(ctx: &mut CompletionContext) -> bool {
 fn complete_imports(ctx: &mut CompletionContext) -> bool {
     // In an import path for a file or package:
     // "#import "|",
-        if let Some(SyntaxKind::ModuleImport | SyntaxKind::ModuleInclude) = ctx.leaf.parent_kind()
+    if let Some(SyntaxKind::ModuleImport | SyntaxKind::ModuleInclude) =
+        ctx.leaf.parent_kind()
         && let Some(ast::Expr::Str(str)) = ctx.leaf.cast()
-         {
-            let value = str.get();
-            ctx.from = ctx.leaf.offset();
-            if value.starts_with('@') {
-                let all_versions = value.contains(':');
-                ctx.package_completions(all_versions);
-            } else {
-                ctx.file_completions_with_extensions(&["typ"]);
-            }
-            return true;
+    {
+        let value = str.get();
+        ctx.from = ctx.leaf.offset();
+        if value.starts_with('@') {
+            let all_versions = value.contains(':');
+            ctx.package_completions(all_versions);
+        } else {
+            ctx.file_completions_with_extensions(&["typ"]);
         }
+        return true;
+    }
 
     // Behind an import list:
     // "#import "path.typ": |",
     // "#import "path.typ": a, b, |".
-        if let Some(prev) = ctx.leaf.prev_sibling()
+    if let Some(prev) = ctx.leaf.prev_sibling()
         && let Some(ast::Expr::ModuleImport(import)) = prev.get().cast()
         && let Some(ast::Imports::Items(items)) = import.imports()
         && let Some(source) = prev.children().find(|child| child.is::<ast::Expr>())
-         {
-            ctx.from = ctx.cursor;
-            import_item_completions(ctx, items, &source);
-            return true;
-        }
+    {
+        ctx.from = ctx.cursor;
+        import_item_completions(ctx, items, &source);
+        return true;
+    }
 
     // Behind a half-started identifier in an import list:
     // "#import "path.typ": thi|",
-        if ctx.leaf.kind() == SyntaxKind::Ident
+    if ctx.leaf.kind() == SyntaxKind::Ident
         && let Some(parent) = ctx.leaf.parent()
         && parent.kind() == SyntaxKind::ImportItemPath
         && let Some(grand) = parent.parent()
@@ -536,11 +538,11 @@ fn complete_imports(ctx: &mut CompletionContext) -> bool {
         && let Some(ast::Expr::ModuleImport(import)) = great.get().cast()
         && let Some(ast::Imports::Items(items)) = import.imports()
         && let Some(source) = great.children().find(|child| child.is::<ast::Expr>())
-         {
-            ctx.from = ctx.leaf.offset();
-            import_item_completions(ctx, items, &source);
-            return true;
-        }
+    {
+        ctx.from = ctx.leaf.offset();
+        import_item_completions(ctx, items, &source);
+        return true;
+    }
 
     false
 }
@@ -589,14 +591,14 @@ fn complete_rules(ctx: &mut CompletionContext) -> bool {
     }
 
     // Behind a half-completed show rule: "show strong: |".
-        if let Some(prev) = ctx.leaf.prev_leaf()
+    if let Some(prev) = ctx.leaf.prev_leaf()
         && matches!(prev.kind(), SyntaxKind::Colon)
         && matches!(prev.parent_kind(), Some(SyntaxKind::ShowRule))
-         {
-            ctx.from = ctx.cursor;
-            show_rule_recipe_completions(ctx);
-            return true;
-        }
+    {
+        ctx.from = ctx.cursor;
+        show_rule_recipe_completions(ctx);
+        return true;
+    }
 
     false
 }
@@ -662,8 +664,7 @@ fn show_rule_recipe_completions(ctx: &mut CompletionContext) {
 /// Complete call and set rule parameters.
 fn complete_params(ctx: &mut CompletionContext) -> bool {
     // Ensure that we are in a function call or set rule's argument list.
-    let (callee, set, args, args_linked) = 
-        if let Some(parent) = ctx.leaf.parent()
+    let (callee, set, args, args_linked) = if let Some(parent) = ctx.leaf.parent()
         && let Some(parent) = match parent.kind() {
             SyntaxKind::Named => parent.parent(),
             _ => Some(parent),
@@ -676,12 +677,11 @@ fn complete_params(ctx: &mut CompletionContext) -> bool {
             ast::Expr::FuncCall(call) => Some(call.callee()),
             ast::Expr::SetRule(set) => Some(set.target()),
             _ => None,
-        }
-        {
-            (callee, set, args, parent)
-        } else {
-            return false;
-        };
+        } {
+        (callee, set, args, parent)
+    } else {
+        return false;
+    };
 
     // Find the piece of syntax that decides what we're completing.
     let mut deciding = ctx.leaf.clone();
@@ -697,30 +697,30 @@ fn complete_params(ctx: &mut CompletionContext) -> bool {
     }
 
     // Parameter values: "func(param:|)", "func(param: |)".
-        if let SyntaxKind::Colon = deciding.kind()
+    if let SyntaxKind::Colon = deciding.kind()
         && let Some(prev) = deciding.prev_leaf()
         && let Some(param) = prev.get().cast::<ast::Ident>()
-         {
-            if let Some(next) = deciding.next_leaf() {
-                ctx.from = ctx.cursor.min(next.offset());
-            }
-
-            named_param_value_completions(ctx, callee, &param);
-            return true;
+    {
+        if let Some(next) = deciding.next_leaf() {
+            ctx.from = ctx.cursor.min(next.offset());
         }
 
+        named_param_value_completions(ctx, callee, &param);
+        return true;
+    }
+
     // Parameters: "func(|)", "func(hi|)", "func(12,|)".
-        if let SyntaxKind::LeftParen | SyntaxKind::Comma = deciding.kind()
+    if let SyntaxKind::LeftParen | SyntaxKind::Comma = deciding.kind()
         && (deciding.kind() != SyntaxKind::Comma || deciding.range().end < ctx.cursor)
-         {
-            if let Some(next) = deciding.next_leaf() {
-                ctx.from = ctx.cursor.min(next.offset());
-            }
-
-            param_completions(ctx, callee, set, args, args_linked);
-            return true;
+    {
+        if let Some(next) = deciding.next_leaf() {
+            ctx.from = ctx.cursor.min(next.offset());
         }
 
+        param_completions(ctx, callee, set, args, args_linked);
+        return true;
+    }
+
     false
 }
 
@@ -1079,13 +1079,13 @@ fn code_completions(ctx: &mut CompletionContext, hash: bool) {
 fn is_in_equation_show_rule(leaf: &LinkedNode<'_>) -> bool {
     let mut node = leaf;
     while let Some(parent) = node.parent() {
-            if let Some(expr) = parent.get().cast::<ast::Expr>()
+        if let Some(expr) = parent.get().cast::<ast::Expr>()
             && let ast::Expr::ShowRule(show) = expr
             && let Some(ast::Expr::FieldAccess(field)) = show.selector()
             && field.field().as_str() == "equation"
-            {
-                return true;
-            }
+        {
+            return true;
+        }
         node = parent;
     }
     false
@@ -1355,10 +1355,12 @@ impl<'a> CompletionContext<'a> {
             }
         } else if at {
             apply = Some(eco_format!("at(\"{label}\")"));
-        } else if label.starts_with('"') && self.after.starts_with('"')
-            && let Some(trimmed) = label.strip_suffix('"') {
-                apply = Some(trimmed.into());
-            }
+        } else if label.starts_with('"')
+            && self.after.starts_with('"')
+            && let Some(trimmed) = label.strip_suffix('"')
+        {
+            apply = Some(trimmed.into());
+        }
 
         self.completions.push(Completion {
             kind: kind.unwrap_or_else(|| match value {
@@ -1543,7 +1545,7 @@ mod tests {
 
     use typst::layout::PagedDocument;
 
-    use super::{autocomplete, Completion, CompletionKind};
+    use super::{Completion, CompletionKind, autocomplete};
     use crate::tests::{FilePos, TestWorld, WorldLike};
 
     /// Quote a string.
@@ -1561,7 +1563,7 @@ mod tests {
         fn must_include<'a>(&self, includes: impl IntoIterator<Item = &'a str>) -> &Self;
         fn must_exclude<'a>(&self, excludes: impl IntoIterator<Item = &'a str>) -> &Self;
         fn must_apply<'a>(&self, label: &str, apply: impl Into<Option<&'a str>>)
-            -> &Self;
+        -> &Self;
     }
 
     impl ResponseExt for Response {
diff --git a/crates/typst-ide/src/definition.rs b/crates/typst-ide/src/definition.rs
index 4c2b80cd4..4986f2cbe 100644
--- a/crates/typst-ide/src/definition.rs
+++ b/crates/typst-ide/src/definition.rs
@@ -1,12 +1,12 @@
 use typst::foundations::{Label, Selector, Value};
 use typst::layout::PagedDocument;
-use typst::syntax::{ast, LinkedNode, Side, Source, Span};
+use typst::syntax::{LinkedNode, Side, Source, Span, ast};
 use typst::utils::PicoStr;
 
 use crate::utils::globals;
 use crate::{
-    analyze_expr, analyze_import, deref_target, named_items, DerefTarget, IdeWorld,
-    NamedItem,
+    DerefTarget, IdeWorld, NamedItem, analyze_expr, analyze_import, deref_target,
+    named_items,
 };
 
 /// A definition of some item.
@@ -90,11 +90,11 @@ mod tests {
     use std::borrow::Borrow;
     use std::ops::Range;
 
+    use typst::WorldExt;
     use typst::foundations::{IntoValue, NativeElement};
     use typst::syntax::Side;
-    use typst::WorldExt;
 
-    use super::{definition, Definition};
+    use super::{Definition, definition};
     use crate::tests::{FilePos, TestWorld, WorldLike};
 
     type Response = (TestWorld, Option<Definition>);
diff --git a/crates/typst-ide/src/jump.rs b/crates/typst-ide/src/jump.rs
index f0035163b..df252843d 100644
--- a/crates/typst-ide/src/jump.rs
+++ b/crates/typst-ide/src/jump.rs
@@ -1,10 +1,10 @@
 use std::num::NonZeroUsize;
 
+use typst::WorldExt;
 use typst::layout::{Frame, FrameItem, PagedDocument, Point, Position, Size};
 use typst::model::{Destination, Url};
 use typst::syntax::{FileId, LinkedNode, Side, Source, Span, SyntaxKind};
 use typst::visualize::{Curve, CurveItem, FillRule, Geometry};
-use typst::WorldExt;
 
 use crate::IdeWorld;
 
@@ -37,15 +37,16 @@ pub fn jump_from_click(
     // Try to find a link first.
     for (pos, item) in frame.items() {
         if let FrameItem::Link(dest, size) = item
-            && is_in_rect(*pos, *size, click) {
-                return Some(match dest {
-                    Destination::Url(url) => Jump::Url(url.clone()),
-                    Destination::Position(pos) => Jump::Position(*pos),
-                    Destination::Location(loc) => {
-                        Jump::Position(document.introspector.position(*loc))
-                    }
-                });
-            }
+            && is_in_rect(*pos, *size, click)
+        {
+            return Some(match dest {
+                Destination::Url(url) => Jump::Url(url.clone()),
+                Destination::Position(pos) => Jump::Position(*pos),
+                Destination::Location(loc) => {
+                    Jump::Position(document.introspector.position(*loc))
+                }
+            });
+        }
     }
 
     // If there's no link, search for a jump target.
@@ -54,9 +55,10 @@ pub fn jump_from_click(
             FrameItem::Group(group) => {
                 let pos = click - pos;
                 if let Some(clip) = &group.clip
-                    && !clip.contains(FillRule::NonZero, pos) {
-                        continue;
-                    }
+                    && !clip.contains(FillRule::NonZero, pos)
+                {
+                    continue;
+                }
                 // Realistic transforms should always be invertible.
                 // An example of one that isn't is a scale of 0, which would
                 // not be clickable anyway.
@@ -177,9 +179,10 @@ pub fn jump_from_cursor(
 fn find_in_frame(frame: &Frame, span: Span) -> Option<Point> {
     for &(mut pos, ref item) in frame.items() {
         if let FrameItem::Group(group) = item
-            && let Some(point) = find_in_frame(&group.frame, span) {
-                return Some(pos + point.transform(group.transform));
-            }
+            && let Some(point) = find_in_frame(&group.frame, span)
+        {
+            return Some(pos + point.transform(group.transform));
+        }
 
         if let FrameItem::Text(text) = item {
             for glyph in &text.glyphs {
@@ -219,7 +222,7 @@ mod tests {
 
     use typst::layout::{Abs, Point, Position};
 
-    use super::{jump_from_click, jump_from_cursor, Jump};
+    use super::{Jump, jump_from_click, jump_from_cursor};
     use crate::tests::{FilePos, TestWorld, WorldLike};
 
     fn point(x: f64, y: f64) -> Point {
diff --git a/crates/typst-ide/src/lib.rs b/crates/typst-ide/src/lib.rs
index c0edcce9f..9444718b4 100644
--- a/crates/typst-ide/src/lib.rs
+++ b/crates/typst-ide/src/lib.rs
@@ -9,16 +9,16 @@ mod tooltip;
 mod utils;
 
 pub use self::analyze::{analyze_expr, analyze_import, analyze_labels};
-pub use self::complete::{autocomplete, Completion, CompletionKind};
-pub use self::definition::{definition, Definition};
-pub use self::jump::{jump_from_click, jump_from_cursor, Jump};
-pub use self::matchers::{deref_target, named_items, DerefTarget, NamedItem};
-pub use self::tooltip::{tooltip, Tooltip};
+pub use self::complete::{Completion, CompletionKind, autocomplete};
+pub use self::definition::{Definition, definition};
+pub use self::jump::{Jump, jump_from_click, jump_from_cursor};
+pub use self::matchers::{DerefTarget, NamedItem, deref_target, named_items};
+pub use self::tooltip::{Tooltip, tooltip};
 
 use ecow::EcoString;
-use typst::syntax::package::PackageSpec;
-use typst::syntax::FileId;
 use typst::World;
+use typst::syntax::FileId;
+use typst::syntax::package::PackageSpec;
 
 /// Extends the `World` for IDE functionality.
 pub trait IdeWorld: World {
diff --git a/crates/typst-ide/src/matchers.rs b/crates/typst-ide/src/matchers.rs
index 709d1d156..f460af8ca 100644
--- a/crates/typst-ide/src/matchers.rs
+++ b/crates/typst-ide/src/matchers.rs
@@ -1,9 +1,9 @@
 use ecow::EcoString;
 use typst::foundations::{Module, Value};
 use typst::syntax::ast::AstNode;
-use typst::syntax::{ast, LinkedNode, Span, SyntaxKind};
+use typst::syntax::{LinkedNode, Span, SyntaxKind, ast};
 
-use crate::{analyze_import, IdeWorld};
+use crate::{IdeWorld, analyze_import};
 
 /// Find the named items starting from the given position.
 pub fn named_items<T>(
@@ -60,9 +60,10 @@ pub fn named_items<T>(
 
                 // Seeing the module itself.
                 if let Some((name, span)) = name_and_span
-                    && let Some(res) = recv(NamedItem::Module(&name, span, module)) {
-                        return Some(res);
-                    }
+                    && let Some(res) = recv(NamedItem::Module(&name, span, module))
+                {
+                    return Some(res);
+                }
 
                 // Seeing the imported items.
                 match imports {
@@ -124,14 +125,15 @@ pub fn named_items<T>(
 
         if let Some(parent) = node.parent() {
             if let Some(v) = parent.cast::<ast::ForLoop>()
-                && node.prev_sibling_kind() != Some(SyntaxKind::In) {
-                    let pattern = v.pattern();
-                    for ident in pattern.bindings() {
-                        if let Some(res) = recv(NamedItem::Var(ident)) {
-                            return Some(res);
-                        }
+                && node.prev_sibling_kind() != Some(SyntaxKind::In)
+            {
+                let pattern = v.pattern();
+                for ident in pattern.bindings() {
+                    if let Some(res) = recv(NamedItem::Var(ident)) {
+                        return Some(res);
                     }
                 }
+            }
 
             if let Some(v) = parent.cast::<ast::Closure>().filter(|v| {
                 // Check if the node is in the body of the closure.
@@ -154,9 +156,10 @@ pub fn named_items<T>(
                         }
                         ast::Param::Spread(s) => {
                             if let Some(sink_ident) = s.sink_ident()
-                                && let Some(t) = recv(NamedItem::Var(sink_ident)) {
-                                    return Some(t);
-                                }
+                                && let Some(t) = recv(NamedItem::Var(sink_ident))
+                            {
+                                return Some(t);
+                            }
                         }
                     }
                 }
diff --git a/crates/typst-ide/src/tests.rs b/crates/typst-ide/src/tests.rs
index 168dfc9f2..08fef6811 100644
--- a/crates/typst-ide/src/tests.rs
+++ b/crates/typst-ide/src/tests.rs
@@ -9,7 +9,7 @@ use typst::layout::{Abs, Margin, PageElem};
 use typst::syntax::package::{PackageSpec, PackageVersion};
 use typst::syntax::{FileId, Source, VirtualPath};
 use typst::text::{Font, FontBook, TextElem, TextSize};
-use typst::utils::{singleton, LazyHash};
+use typst::utils::{LazyHash, singleton};
 use typst::{Feature, Library, LibraryExt, World};
 
 use crate::IdeWorld;
diff --git a/crates/typst-ide/src/tooltip.rs b/crates/typst-ide/src/tooltip.rs
index 078465206..7c79eb170 100644
--- a/crates/typst-ide/src/tooltip.rs
+++ b/crates/typst-ide/src/tooltip.rs
@@ -1,16 +1,16 @@
 use std::fmt::Write;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst::engine::Sink;
-use typst::foundations::{repr, Binding, Capturer, CastInfo, Repr, Value};
+use typst::foundations::{Binding, Capturer, CastInfo, Repr, Value, repr};
 use typst::layout::{Length, PagedDocument};
 use typst::syntax::ast::AstNode;
-use typst::syntax::{ast, LinkedNode, Side, Source, SyntaxKind};
-use typst::utils::{round_with_precision, Numeric};
+use typst::syntax::{LinkedNode, Side, Source, SyntaxKind, ast};
+use typst::utils::{Numeric, round_with_precision};
 use typst_eval::CapturesVisitor;
 
 use crate::utils::{plain_docs_sentence, summarize_font_family};
-use crate::{analyze_expr, analyze_import, analyze_labels, IdeWorld};
+use crate::{IdeWorld, analyze_expr, analyze_import, analyze_labels};
 
 /// Describe the item under the cursor.
 ///
@@ -66,9 +66,10 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
         }
 
         if let &Value::Length(length) = value
-            && let Some(tooltip) = length_tooltip(length) {
-                return Some(tooltip);
-            }
+            && let Some(tooltip) = length_tooltip(length)
+        {
+            return Some(tooltip);
+        }
     }
 
     if expr.is_literal() {
@@ -92,9 +93,10 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
     }
 
     if let Some((_, count)) = last
-        && count > 1 {
-            write!(pieces.last_mut().unwrap(), " (×{count})").unwrap();
-        }
+        && count > 1
+    {
+        write!(pieces.last_mut().unwrap(), " (×{count})").unwrap();
+    }
 
     if iter.next().is_some() {
         pieces.push("...".into());
@@ -106,18 +108,18 @@ fn expr_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
 
 /// Tooltips for imports.
 fn import_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
-        if leaf.kind() == SyntaxKind::Star
+    if leaf.kind() == SyntaxKind::Star
         && let Some(parent) = leaf.parent()
         && let Some(import) = parent.cast::<ast::ModuleImport>()
         && let Some(node) = parent.find(import.source().span())
         && let Some(value) = analyze_import(world, &node)
         && let Some(scope) = value.scope()
-         {
-            let names: Vec<_> =
-                scope.iter().map(|(name, ..)| eco_format!("`{name}`")).collect();
-            let list = repr::separated_list(&names, "and");
-            return Some(Tooltip::Text(eco_format!("This star imports {list}")));
-        }
+    {
+        let names: Vec<_> =
+            scope.iter().map(|(name, ..)| eco_format!("`{name}`")).collect();
+        let list = repr::separated_list(&names, "and");
+        return Some(Tooltip::Text(eco_format!("This star imports {list}")));
+    }
 
     None
 }
@@ -211,20 +213,20 @@ fn named_param_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Toolti
         else { return None; };
 
     // Hovering over the parameter name.
-        if leaf.index() == 0
+    if leaf.index() == 0
         && let Some(ident) = leaf.cast::<ast::Ident>()
         && let Some(param) = func.param(&ident)
-         {
-            return Some(Tooltip::Text(plain_docs_sentence(param.docs)));
-        }
+    {
+        return Some(Tooltip::Text(plain_docs_sentence(param.docs)));
+    }
 
     // Hovering over a string parameter value.
-        if let Some(string) = leaf.cast::<ast::Str>()
+    if let Some(string) = leaf.cast::<ast::Str>()
         && let Some(param) = func.param(&named.name())
         && let Some(docs) = find_string_doc(&param.input, &string.get())
-         {
-            return Some(Tooltip::Text(docs.into()));
-        }
+    {
+        return Some(Tooltip::Text(docs.into()));
+    }
 
     None
 }
@@ -242,8 +244,8 @@ fn find_string_doc(info: &CastInfo, string: &str) -> Option<&'static str> {
 
 /// Tooltip for font.
 fn font_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
-        // Ensure that we are on top of a string.
-        if let Some(string) = leaf.cast::<ast::Str>()
+    // Ensure that we are on top of a string.
+    if let Some(string) = leaf.cast::<ast::Str>()
         && let lower = string.get().to_lowercase()
 
         // Ensure that we are in the arguments to the text function.
@@ -256,11 +258,10 @@ fn font_tooltip(world: &dyn IdeWorld, leaf: &LinkedNode) -> Option<Tooltip> {
             .book()
             .families()
             .find(|&(family, _)| family.to_lowercase().as_str() == lower.as_str())
-
-         {
-            let detail = summarize_font_family(iter.collect());
-            return Some(Tooltip::Text(detail));
-        }
+    {
+        let detail = summarize_font_family(iter.collect());
+        return Some(Tooltip::Text(detail));
+    }
 
     None
 }
@@ -271,7 +272,7 @@ mod tests {
 
     use typst::syntax::Side;
 
-    use super::{tooltip, Tooltip};
+    use super::{Tooltip, tooltip};
     use crate::tests::{FilePos, TestWorld, WorldLike};
 
     type Response = Option<Tooltip>;
diff --git a/crates/typst-ide/src/utils.rs b/crates/typst-ide/src/utils.rs
index 13de402ba..95b16808c 100644
--- a/crates/typst-ide/src/utils.rs
+++ b/crates/typst-ide/src/utils.rs
@@ -2,7 +2,7 @@ use std::fmt::Write;
 use std::ops::ControlFlow;
 
 use comemo::Track;
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst::engine::{Engine, Route, Sink, Traced};
 use typst::foundations::{Scope, Value};
 use typst::introspection::Introspector;
@@ -119,11 +119,7 @@ pub fn globals<'a>(world: &'a dyn IdeWorld, leaf: &LinkedNode) -> &'a Scope {
         .is_none_or(|prev| !matches!(prev.kind(), SyntaxKind::Hash));
 
     let library = world.library();
-    if in_math {
-        library.math.scope()
-    } else {
-        library.global.scope()
-    }
+    if in_math { library.math.scope() } else { library.global.scope() }
 }
 
 /// Checks whether the given value or any of its constituent parts satisfy the
diff --git a/crates/typst-kit/src/package.rs b/crates/typst-kit/src/package.rs
index e62e843cd..06e9f04d6 100644
--- a/crates/typst-kit/src/package.rs
+++ b/crates/typst-kit/src/package.rs
@@ -7,7 +7,7 @@ use std::path::{Path, PathBuf};
 use ecow::eco_format;
 use once_cell::sync::OnceCell;
 use serde::Deserialize;
-use typst_library::diag::{bail, PackageError, PackageResult, StrResult};
+use typst_library::diag::{PackageError, PackageResult, StrResult, bail};
 use typst_syntax::package::{PackageSpec, PackageVersion, VersionlessPackageSpec};
 
 use crate::download::{Downloader, Progress};
@@ -189,7 +189,7 @@ impl PackageStorage {
                 }
             }
             Err(err) => {
-                return Err(PackageError::NetworkFailed(Some(eco_format!("{err}"))))
+                return Err(PackageError::NetworkFailed(Some(eco_format!("{err}"))));
             }
         };
 
diff --git a/crates/typst-layout/src/flow/block.rs b/crates/typst-layout/src/flow/block.rs
index 11096dc7a..395d4335e 100644
--- a/crates/typst-layout/src/flow/block.rs
+++ b/crates/typst-layout/src/flow/block.rs
@@ -408,9 +408,10 @@ fn distribute<'a>(
     // last region (it will overflow, but there's nothing else
     // we can do).
     if !remaining.approx_empty()
-        && let Some(last) = buf.last_mut() {
-            *last += remaining;
-        }
+        && let Some(last) = buf.last_mut()
+    {
+        *last += remaining;
+    }
 
     // Distribute the heights to the first region and the
     // backlog. There is no last region, since the height is
diff --git a/crates/typst-layout/src/flow/collect.rs b/crates/typst-layout/src/flow/collect.rs
index 561b578bb..36c45af51 100644
--- a/crates/typst-layout/src/flow/collect.rs
+++ b/crates/typst-layout/src/flow/collect.rs
@@ -2,10 +2,11 @@ use std::cell::{LazyCell, RefCell};
 use std::fmt::{self, Debug, Formatter};
 use std::hash::Hash;
 
-use bumpalo::boxed::Box as BumpBox;
 use bumpalo::Bump;
+use bumpalo::boxed::Box as BumpBox;
 use comemo::{Track, Tracked, TrackedMut};
-use typst_library::diag::{bail, warning, SourceResult};
+use typst_library::World;
+use typst_library::diag::{SourceResult, bail, warning};
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Packed, Resolve, Smart, StyleChain};
 use typst_library::introspection::{
@@ -19,10 +20,9 @@ use typst_library::layout::{
 use typst_library::model::ParElem;
 use typst_library::routines::{Pair, Routines};
 use typst_library::text::TextElem;
-use typst_library::World;
 use typst_utils::SliceExt;
 
-use super::{layout_multi_block, layout_single_block, FlowMode};
+use super::{FlowMode, layout_multi_block, layout_single_block};
 use crate::inline::ParSituation;
 use crate::modifiers::layout_and_modify;
 
@@ -685,9 +685,10 @@ impl<T> CachedCell<T> {
 
         let mut slot = self.0.borrow_mut();
         if let Some((hash, output)) = &*slot
-            && *hash == input_hash {
-                return output.clone();
-            }
+            && *hash == input_hash
+        {
+            return output.clone();
+        }
 
         let output = f(input);
         *slot = Some((input_hash, output.clone()));
diff --git a/crates/typst-layout/src/flow/compose.rs b/crates/typst-layout/src/flow/compose.rs
index ed514a248..4d937193b 100644
--- a/crates/typst-layout/src/flow/compose.rs
+++ b/crates/typst-layout/src/flow/compose.rs
@@ -18,7 +18,7 @@ use typst_syntax::Span;
 use typst_utils::{NonZeroExt, Numeric};
 
 use super::{
-    distribute, Config, FlowMode, FlowResult, LineNumberConfig, PlacedChild, Stop, Work,
+    Config, FlowMode, FlowResult, LineNumberConfig, PlacedChild, Stop, Work, distribute,
 };
 
 /// Composes the contents of a single page/region. A region can have multiple
@@ -319,11 +319,7 @@ impl<'a, 'b> Composer<'a, 'b, '_, '_> {
             let used = base.y - remaining;
             let half = need / 2.0;
             let ratio = (used + half) / base.y;
-            if ratio <= 0.5 {
-                FixedAlignment::Start
-            } else {
-                FixedAlignment::End
-            }
+            if ratio <= 0.5 { FixedAlignment::Start } else { FixedAlignment::End }
         });
 
         // Select the insertion area where we'll put this float.
diff --git a/crates/typst-layout/src/flow/mod.rs b/crates/typst-layout/src/flow/mod.rs
index cb029dce8..b6ecc92f7 100644
--- a/crates/typst-layout/src/flow/mod.rs
+++ b/crates/typst-layout/src/flow/mod.rs
@@ -14,7 +14,8 @@ use std::rc::Rc;
 use bumpalo::Bump;
 use comemo::{Track, Tracked, TrackedMut};
 use ecow::EcoVec;
-use typst_library::diag::{bail, At, SourceDiagnostic, SourceResult};
+use typst_library::World;
+use typst_library::diag::{At, SourceDiagnostic, SourceResult, bail};
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Content, Packed, Resolve, StyleChain};
 use typst_library::introspection::{
@@ -27,14 +28,13 @@ use typst_library::layout::{
 use typst_library::model::{FootnoteElem, FootnoteEntry, LineNumberingScope, ParLine};
 use typst_library::routines::{Arenas, FragmentKind, Pair, RealizationKind, Routines};
 use typst_library::text::TextElem;
-use typst_library::World;
 use typst_utils::{NonZeroExt, Numeric};
 
 use self::block::{layout_multi_block, layout_single_block};
 use self::collect::{
-    collect, Child, LineChild, MultiChild, MultiSpill, PlacedChild, SingleChild,
+    Child, LineChild, MultiChild, MultiSpill, PlacedChild, SingleChild, collect,
 };
-use self::compose::{compose, Composer};
+use self::compose::{Composer, compose};
 use self::distribute::distribute;
 
 /// Lays out content into a single region, producing a single frame.
diff --git a/crates/typst-layout/src/grid/layouter.rs b/crates/typst-layout/src/grid/layouter.rs
index ee613f8f2..2e8cc9e55 100644
--- a/crates/typst-layout/src/grid/layouter.rs
+++ b/crates/typst-layout/src/grid/layouter.rs
@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Resolve, StyleChain};
 use typst_library::layout::grid::resolve::{
@@ -16,8 +16,8 @@ use typst_syntax::Span;
 use typst_utils::Numeric;
 
 use super::{
-    generate_line_segments, hline_stroke_at_column, layout_cell, vline_stroke_at_row,
-    LineSegment, Rowspan, UnbreakableRowGroup,
+    LineSegment, Rowspan, UnbreakableRowGroup, generate_line_segments,
+    hline_stroke_at_column, layout_cell, vline_stroke_at_row,
 };
 
 /// Performs grid layout.
@@ -275,35 +275,39 @@ impl<'a> GridLayouter<'a> {
         self.measure_columns(engine)?;
 
         if let Some(footer) = &self.grid.footer
-            && footer.repeated {
-                // Ensure rows in the first region will be aware of the
-                // possible presence of the footer.
-                self.prepare_footer(footer, engine, 0)?;
-                self.regions.size.y -= self.current.footer_height;
-                self.current.initial_after_repeats = self.regions.size.y;
-            }
+            && footer.repeated
+        {
+            // Ensure rows in the first region will be aware of the
+            // possible presence of the footer.
+            self.prepare_footer(footer, engine, 0)?;
+            self.regions.size.y -= self.current.footer_height;
+            self.current.initial_after_repeats = self.regions.size.y;
+        }
 
         let mut y = 0;
         let mut consecutive_header_count = 0;
         while y < self.grid.rows.len() {
             if let Some(next_header) = self.upcoming_headers.get(consecutive_header_count)
-                && next_header.range.contains(&y) {
-                    self.place_new_headers(&mut consecutive_header_count, engine)?;
-                    y = next_header.range.end;
+                && next_header.range.contains(&y)
+            {
+                self.place_new_headers(&mut consecutive_header_count, engine)?;
+                y = next_header.range.end;
 
-                    // Skip header rows during normal layout.
-                    continue;
-                }
+                // Skip header rows during normal layout.
+                continue;
+            }
 
             if let Some(footer) = &self.grid.footer
-                && footer.repeated && y >= footer.start {
-                    if y == footer.start {
-                        self.layout_footer(footer, engine, self.finished.len())?;
-                        self.flush_orphans();
-                    }
-                    y = footer.end;
-                    continue;
+                && footer.repeated
+                && y >= footer.start
+            {
+                if y == footer.start {
+                    self.layout_footer(footer, engine, self.finished.len())?;
+                    self.flush_orphans();
                 }
+                y = footer.end;
+                continue;
+            }
 
             self.layout_row(y, engine, 0)?;
 
@@ -1280,12 +1284,12 @@ impl<'a> GridLayouter<'a> {
             if let Some([first, rest @ ..]) =
                 frames.get(measurement_data.frames_in_previous_regions..)
                 && can_skip
-                    && breakable
-                    && first.is_empty()
-                    && rest.iter().any(|frame| !frame.is_empty())
-                {
-                    return Ok(None);
-                }
+                && breakable
+                && first.is_empty()
+                && rest.iter().any(|frame| !frame.is_empty())
+            {
+                return Ok(None);
+            }
 
             // Skip frames from previous regions if applicable.
             let mut sizes = frames
@@ -1524,16 +1528,17 @@ impl<'a> GridLayouter<'a> {
         // were placed, so remove those rows and try again in a new region,
         // unless this is the last region.
         if let Some(orphan_snapshot) = self.current.lrows_orphan_snapshot.take()
-            && !last {
-                self.current.lrows.truncate(orphan_snapshot);
-                self.current.repeated_header_rows =
-                    self.current.repeated_header_rows.min(orphan_snapshot);
+            && !last
+        {
+            self.current.lrows.truncate(orphan_snapshot);
+            self.current.repeated_header_rows =
+                self.current.repeated_header_rows.min(orphan_snapshot);
 
-                if orphan_snapshot == 0 {
-                    // Removed all repeated headers.
-                    self.current.last_repeated_header_end = 0;
-                }
+            if orphan_snapshot == 0 {
+                // Removed all repeated headers.
+                self.current.last_repeated_header_end = 0;
             }
+        }
 
         if self
             .current
@@ -1564,22 +1569,21 @@ impl<'a> GridLayouter<'a> {
             && self.current.could_progress_at_top;
 
         let mut laid_out_footer_start = None;
-        if !footer_would_be_widow
-            && let Some(footer) = &self.grid.footer {
-                // Don't layout the footer if it would be alone with the header
-                // in the page (hence the widow check), and don't layout it
-                // twice (check below).
-                //
-                // TODO(subfooters): this check can be replaced by a vector of
-                // repeating footers in the future, and/or some "pending
-                // footers" vector for footers we're about to place.
-                if footer.repeated
-                    && self.current.lrows.iter().all(|row| row.index() < footer.start)
-                {
-                    laid_out_footer_start = Some(footer.start);
-                    self.layout_footer(footer, engine, self.finished.len())?;
-                }
+        if !footer_would_be_widow && let Some(footer) = &self.grid.footer {
+            // Don't layout the footer if it would be alone with the header
+            // in the page (hence the widow check), and don't layout it
+            // twice (check below).
+            //
+            // TODO(subfooters): this check can be replaced by a vector of
+            // repeating footers in the future, and/or some "pending
+            // footers" vector for footers we're about to place.
+            if footer.repeated
+                && self.current.lrows.iter().all(|row| row.index() < footer.start)
+            {
+                laid_out_footer_start = Some(footer.start);
+                self.layout_footer(footer, engine, self.finished.len())?;
             }
+        }
 
         // Determine the height of existing rows in the region.
         let mut used = Abs::zero();
diff --git a/crates/typst-layout/src/grid/lines.rs b/crates/typst-layout/src/grid/lines.rs
index 0b823c07d..1c93fdb4d 100644
--- a/crates/typst-layout/src/grid/lines.rs
+++ b/crates/typst-layout/src/grid/lines.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use typst_library::foundations::{AlternativeFold, Fold};
-use typst_library::layout::grid::resolve::{CellGrid, Line, Repeatable};
 use typst_library::layout::Abs;
+use typst_library::layout::grid::resolve::{CellGrid, Line, Repeatable};
 use typst_library::visualize::Stroke;
 
 use super::RowPiece;
@@ -292,11 +292,12 @@ pub fn vline_stroke_at_row(
         // column), and/or one row below (if at a gutter row), in order to
         // check if it would be merged with a cell before the vline.
         if let Some(parent) = grid.effective_parent_cell_position(x, y)
-            && parent.x < x {
-                // There is a colspan cell going through this vline's position,
-                // so don't draw it here.
-                return None;
-            }
+            && parent.x < x
+        {
+            // There is a colspan cell going through this vline's position,
+            // so don't draw it here.
+            return None;
+        }
     }
 
     let (left_cell_stroke, left_cell_prioritized) = x
@@ -416,26 +417,27 @@ pub fn hline_stroke_at_column(
         // column), and/or one row below (if at a gutter row), in order to
         // check if it would be merged with a cell before the hline.
         if let Some(parent) = grid.effective_parent_cell_position(x, y)
-            && parent.y < y {
-                // Get the first 'y' spanned by the possible rowspan in this region.
-                // The 'parent.y' row and any other spanned rows above 'y' could be
-                // missing from this region, which could have lead the check above
-                // to be triggered, even though there is no spanned row above the
-                // hline in the final layout of this region, and thus no overlap
-                // with the hline, allowing it to be drawn regardless of the
-                // theoretical presence of a rowspan going across its position.
-                let local_parent_y = rows
-                    .iter()
-                    .find(|row| row.y >= parent.y)
-                    .map(|row| row.y)
-                    .unwrap_or(y);
+            && parent.y < y
+        {
+            // Get the first 'y' spanned by the possible rowspan in this region.
+            // The 'parent.y' row and any other spanned rows above 'y' could be
+            // missing from this region, which could have lead the check above
+            // to be triggered, even though there is no spanned row above the
+            // hline in the final layout of this region, and thus no overlap
+            // with the hline, allowing it to be drawn regardless of the
+            // theoretical presence of a rowspan going across its position.
+            let local_parent_y = rows
+                .iter()
+                .find(|row| row.y >= parent.y)
+                .map(|row| row.y)
+                .unwrap_or(y);
 
-                if local_parent_y < y {
-                    // There is a rowspan cell going through this hline's
-                    // position, so don't draw it here.
-                    return None;
-                }
+            if local_parent_y < y {
+                // There is a rowspan cell going through this hline's
+                // position, so don't draw it here.
+                return None;
             }
+        }
     }
 
     // When the hline is at the top of the region and this isn't the first
diff --git a/crates/typst-layout/src/grid/mod.rs b/crates/typst-layout/src/grid/mod.rs
index 1b4380f0a..2f78e090d 100644
--- a/crates/typst-layout/src/grid/mod.rs
+++ b/crates/typst-layout/src/grid/mod.rs
@@ -9,13 +9,13 @@ use typst_library::diag::SourceResult;
 use typst_library::engine::Engine;
 use typst_library::foundations::{Packed, StyleChain};
 use typst_library::introspection::Locator;
-use typst_library::layout::grid::resolve::{grid_to_cellgrid, table_to_cellgrid, Cell};
+use typst_library::layout::grid::resolve::{Cell, grid_to_cellgrid, table_to_cellgrid};
 use typst_library::layout::{Fragment, GridElem, Regions};
 use typst_library::model::TableElem;
 
 use self::layouter::RowPiece;
 use self::lines::{
-    generate_line_segments, hline_stroke_at_column, vline_stroke_at_row, LineSegment,
+    LineSegment, generate_line_segments, hline_stroke_at_column, vline_stroke_at_row,
 };
 use self::rowspans::{Rowspan, UnbreakableRowGroup};
 
diff --git a/crates/typst-layout/src/grid/repeated.rs b/crates/typst-layout/src/grid/repeated.rs
index 573ef1a47..62f82f56f 100644
--- a/crates/typst-layout/src/grid/repeated.rs
+++ b/crates/typst-layout/src/grid/repeated.rs
@@ -241,15 +241,17 @@ impl<'a> GridLayouter<'a> {
         }
 
         if let Some(footer) = &self.grid.footer
-            && footer.repeated && skipped_region {
-                // Simulate the footer again; the region's 'full' might have
-                // changed.
-                self.regions.size.y += self.current.footer_height;
-                self.current.footer_height = self
-                    .simulate_footer(footer, &self.regions, engine, disambiguator)?
-                    .height;
-                self.regions.size.y -= self.current.footer_height;
-            }
+            && footer.repeated
+            && skipped_region
+        {
+            // Simulate the footer again; the region's 'full' might have
+            // changed.
+            self.regions.size.y += self.current.footer_height;
+            self.current.footer_height = self
+                .simulate_footer(footer, &self.regions, engine, disambiguator)?
+                .height;
+            self.regions.size.y -= self.current.footer_height;
+        }
 
         let repeating_header_rows =
             total_header_row_count(self.repeating_headers.iter().copied());
diff --git a/crates/typst-layout/src/grid/rowspans.rs b/crates/typst-layout/src/grid/rowspans.rs
index c31bfcb28..66da9bd85 100644
--- a/crates/typst-layout/src/grid/rowspans.rs
+++ b/crates/typst-layout/src/grid/rowspans.rs
@@ -4,8 +4,8 @@ use typst_library::foundations::Resolve;
 use typst_library::layout::grid::resolve::Repeatable;
 use typst_library::layout::{Abs, Axes, Frame, Point, Region, Regions, Size, Sizing};
 
-use super::layouter::{points, Row};
-use super::{layout_cell, Cell, GridLayouter};
+use super::layouter::{Row, points};
+use super::{Cell, GridLayouter, layout_cell};
 
 /// All information needed to layout a single rowspan.
 pub struct Rowspan {
@@ -239,14 +239,16 @@ impl GridLayouter<'_> {
             // unbreakable cells (with or without a rowspan setting).
             let mut amount_unbreakable_rows = None;
             if let Some(footer) = &self.grid.footer
-                && !footer.repeated && current_row >= footer.start {
-                    // Non-repeated footer, so keep it unbreakable.
-                    //
-                    // TODO(subfooters): This will become unnecessary
-                    // once non-repeated footers are treated differently and
-                    // have widow prevention.
-                    amount_unbreakable_rows = Some(self.grid.rows.len() - footer.start);
-                }
+                && !footer.repeated
+                && current_row >= footer.start
+            {
+                // Non-repeated footer, so keep it unbreakable.
+                //
+                // TODO(subfooters): This will become unnecessary
+                // once non-repeated footers are treated differently and
+                // have widow prevention.
+                amount_unbreakable_rows = Some(self.grid.rows.len() - footer.start);
+            }
 
             let row_group = self.simulate_unbreakable_row_group(
                 current_row,
@@ -1268,7 +1270,8 @@ fn subtract_end_sizes(sizes: &mut Vec<Abs>, mut subtract: Abs) {
         subtract -= sizes.pop().unwrap();
     }
     if subtract > Abs::zero()
-        && let Some(last_size) = sizes.last_mut() {
-            *last_size -= subtract;
-        }
+        && let Some(last_size) = sizes.last_mut()
+    {
+        *last_size -= subtract;
+    }
 }
diff --git a/crates/typst-layout/src/inline/collect.rs b/crates/typst-layout/src/inline/collect.rs
index 1856cb13d..6b6b24579 100644
--- a/crates/typst-layout/src/inline/collect.rs
+++ b/crates/typst-layout/src/inline/collect.rs
@@ -6,14 +6,14 @@ use typst_library::layout::{
 };
 use typst_library::routines::Pair;
 use typst_library::text::{
-    is_default_ignorable, LinebreakElem, SmartQuoteElem, SmartQuoter, SmartQuotes,
-    SpaceElem, TextElem,
+    LinebreakElem, SmartQuoteElem, SmartQuoter, SmartQuotes, SpaceElem, TextElem,
+    is_default_ignorable,
 };
 use typst_syntax::Span;
 use typst_utils::Numeric;
 
 use super::*;
-use crate::modifiers::{layout_and_modify, FrameModifiers, FrameModify};
+use crate::modifiers::{FrameModifiers, FrameModify, layout_and_modify};
 
 // The characters by which spacing, inline content and pins are replaced in the
 // full text.
@@ -275,10 +275,11 @@ impl<'a> Collector<'a> {
 
         // Merge adjacent text segments with the same styles.
         if let Some(Segment::Text(last_len, last_styles)) = self.segments.last_mut()
-            && *last_styles == styles {
-                *last_len += segment_len;
-                return;
-            }
+            && *last_styles == styles
+        {
+            *last_len += segment_len;
+            return;
+        }
 
         self.segments.push(Segment::Text(segment_len, styles));
     }
diff --git a/crates/typst-layout/src/inline/line.rs b/crates/typst-layout/src/inline/line.rs
index 2d921b394..311dc7c69 100644
--- a/crates/typst-layout/src/inline/line.rs
+++ b/crates/typst-layout/src/inline/line.rs
@@ -6,7 +6,7 @@ use typst_library::foundations::Resolve;
 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, variant};
 use typst_utils::Numeric;
 
 use super::*;
@@ -156,15 +156,17 @@ pub fn line<'a>(
 
     // Add a hyphen at the line start, if a previous dash should be repeated.
     if pred.is_some_and(|pred| should_repeat_hyphen(pred, full))
-        && let Some(shaped) = items.first_text_mut() {
-            shaped.prepend_hyphen(engine, p.config.fallback);
-        }
+        && let Some(shaped) = items.first_text_mut()
+    {
+        shaped.prepend_hyphen(engine, p.config.fallback);
+    }
 
     // Add a hyphen at the line end, if we ended on a soft hyphen.
     if dash == Some(Dash::Soft)
-        && let Some(shaped) = items.last_text_mut() {
-            shaped.push_hyphen(engine, p.config.fallback);
-        }
+        && let Some(shaped) = items.last_text_mut()
+    {
+        shaped.push_hyphen(engine, p.config.fallback);
+    }
 
     // Deal with CJ characters at line boundaries.
     adjust_cj_at_line_boundaries(p, full, &mut items);
@@ -217,9 +219,10 @@ fn collect_items<'a>(
 
     // Add fallback text to expand the line height, if necessary.
     if !items.iter().any(|item| matches!(item, Item::Text(_)))
-        && let Some(fallback) = fallback {
-            items.push(fallback, usize::MAX);
-        }
+        && let Some(fallback) = fallback
+    {
+        items.push(fallback, usize::MAX);
+    }
 
     items
 }
@@ -460,25 +463,25 @@ pub fn commit(
     // Handle hanging punctuation to the left.
     if let Some(Item::Text(text)) = line.items.first()
         && let Some(glyph) = text.glyphs.first()
-            && !text.dir.is_positive()
-                && text.styles.get(TextElem::overhang)
-                && (line.items.len() > 1 || text.glyphs.len() > 1)
-            {
-                let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
-                offset -= amount;
-                remaining += amount;
-            }
+        && !text.dir.is_positive()
+        && text.styles.get(TextElem::overhang)
+        && (line.items.len() > 1 || text.glyphs.len() > 1)
+    {
+        let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
+        offset -= amount;
+        remaining += amount;
+    }
 
     // Handle hanging punctuation to the right.
     if let Some(Item::Text(text)) = line.items.last()
         && let Some(glyph) = text.glyphs.last()
-            && text.dir.is_positive()
-                && text.styles.get(TextElem::overhang)
-                && (line.items.len() > 1 || text.glyphs.len() > 1)
-            {
-                let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
-                remaining += amount;
-            }
+        && text.dir.is_positive()
+        && text.styles.get(TextElem::overhang)
+        && (line.items.len() > 1 || text.glyphs.len() > 1)
+    {
+        let amount = overhang(glyph.c) * glyph.x_advance.at(glyph.size);
+        remaining += amount;
+    }
 
     // Determine how much additional space is needed. The justification_ratio is
     // for the first step justification, extra_justification is for the last
diff --git a/crates/typst-layout/src/inline/linebreak.rs b/crates/typst-layout/src/inline/linebreak.rs
index e40027edb..94053cf68 100644
--- a/crates/typst-layout/src/inline/linebreak.rs
+++ b/crates/typst-layout/src/inline/linebreak.rs
@@ -2,8 +2,8 @@ use std::ops::{Add, Sub};
 use std::sync::LazyLock;
 
 use az::SaturatingAs;
-use icu_properties::maps::{CodePointMapData, CodePointMapDataBorrowed};
 use icu_properties::LineBreak;
+use icu_properties::maps::{CodePointMapData, CodePointMapDataBorrowed};
 use icu_provider::AsDeserializingBufferProvider;
 use icu_provider_adapters::fork::ForkByKeyProvider;
 use icu_provider_blob::BlobDataProvider;
@@ -11,7 +11,7 @@ use icu_segmenter::LineSegmenter;
 use typst_library::engine::Engine;
 use typst_library::layout::{Abs, Em};
 use typst_library::model::Linebreaks;
-use typst_library::text::{is_default_ignorable, Lang, TextElem};
+use typst_library::text::{Lang, TextElem, is_default_ignorable};
 use typst_syntax::link_prefix;
 use unicode_segmentation::UnicodeSegmentation;
 
@@ -137,11 +137,12 @@ fn linebreak_simple<'a>(
         // into the stack and rebuild the line from the attempt's end. The
         // resulting line cannot be broken up further.
         if !width.fits(attempt.width)
-            && let Some((last_attempt, last_end)) = last.take() {
-                lines.push(last_attempt);
-                start = last_end;
-                attempt = line(engine, p, start..end, breakpoint, lines.last());
-            }
+            && let Some((last_attempt, last_end)) = last.take()
+        {
+            lines.push(last_attempt);
+            start = last_end;
+            attempt = line(engine, p, start..end, breakpoint, lines.last());
+        }
 
         // Finish the current line if there is a mandatory line break (i.e. due
         // to "\n") or if the line doesn't fit horizontally already since then
@@ -893,11 +894,7 @@ impl CostMetrics {
     /// we allow less because otherwise we get an invalid layout fairly often,
     /// which makes our bound useless.
     fn min_ratio(&self, approx: bool) -> f64 {
-        if approx {
-            self.min_approx_ratio
-        } else {
-            self.min_ratio
-        }
+        if approx { self.min_approx_ratio } else { self.min_ratio }
     }
 }
 
diff --git a/crates/typst-layout/src/inline/mod.rs b/crates/typst-layout/src/inline/mod.rs
index 06223cebf..addda137b 100644
--- a/crates/typst-layout/src/inline/mod.rs
+++ b/crates/typst-layout/src/inline/mod.rs
@@ -12,6 +12,7 @@ pub use self::box_::layout_box;
 pub use self::shaping::create_shape_plan;
 
 use comemo::{Track, Tracked, TrackedMut};
+use typst_library::World;
 use typst_library::diag::SourceResult;
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Packed, Smart, StyleChain};
@@ -23,18 +24,17 @@ use typst_library::model::{
 };
 use typst_library::routines::{Arenas, Pair, RealizationKind, Routines};
 use typst_library::text::{Costs, Lang, TextElem};
-use typst_library::World;
 use typst_utils::{Numeric, SliceExt};
 
-use self::collect::{collect, Item, Segment, SpanMapper};
+use self::collect::{Item, Segment, SpanMapper, collect};
 use self::deco::decorate;
 use self::finalize::finalize;
-use self::line::{apply_shift, commit, line, Line};
-use self::linebreak::{linebreak, Breakpoint};
-use self::prepare::{prepare, Preparation};
+use self::line::{Line, apply_shift, commit, line};
+use self::linebreak::{Breakpoint, linebreak};
+use self::prepare::{Preparation, prepare};
 use self::shaping::{
-    cjk_punct_style, is_of_cj_script, shape_range, ShapedGlyph, ShapedText,
-    BEGIN_PUNCT_PAT, END_PUNCT_PAT,
+    BEGIN_PUNCT_PAT, END_PUNCT_PAT, ShapedGlyph, ShapedText, cjk_punct_style,
+    is_of_cj_script, shape_range,
 };
 
 /// Range of a substring of text.
@@ -190,11 +190,7 @@ fn configuration(
     Config {
         justify,
         linebreaks: base.linebreaks.unwrap_or_else(|| {
-            if justify {
-                Linebreaks::Optimized
-            } else {
-                Linebreaks::Simple
-            }
+            if justify { Linebreaks::Optimized } else { Linebreaks::Simple }
         }),
         first_line_indent: {
             let FirstLineIndent { amount, all } = base.first_line_indent;
diff --git a/crates/typst-layout/src/inline/shaping.rs b/crates/typst-layout/src/inline/shaping.rs
index a8f2bcaba..74996b5be 100644
--- a/crates/typst-layout/src/inline/shaping.rs
+++ b/crates/typst-layout/src/inline/shaping.rs
@@ -4,21 +4,21 @@ use std::sync::Arc;
 
 use az::SaturatingAs;
 use rustybuzz::{BufferFlags, Feature, ShapePlan, UnicodeBuffer};
-use ttf_parser::gsub::SubstitutionSubtable;
 use ttf_parser::Tag;
+use ttf_parser::gsub::SubstitutionSubtable;
+use typst_library::World;
 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,
+    Font, FontFamily, FontVariant, Glyph, Lang, Region, ShiftSettings, TextEdgeBounds,
+    TextElem, TextItem, families, features, is_default_ignorable, language, variant,
 };
-use typst_library::World;
 use typst_utils::SliceExt;
 use unicode_bidi::{BidiInfo, Level as BidiLevel};
 use unicode_script::{Script, UnicodeScript};
 
-use super::{decorate, Item, Range, SpanMapper};
+use super::{Item, Range, SpanMapper, decorate};
 use crate::modifiers::FrameModifyText;
 
 /// The result of shaping text.
@@ -539,11 +539,7 @@ impl<'a> ShapedText<'a> {
         // Find any glyph with the text index.
         let found = self.glyphs.binary_search_by(|g: &ShapedGlyph| {
             let ordering = g.range.start.cmp(&text_index);
-            if ltr {
-                ordering
-            } else {
-                ordering.reverse()
-            }
+            if ltr { ordering } else { ordering.reverse() }
         });
 
         let mut idx = match found {
diff --git a/crates/typst-layout/src/lists.rs b/crates/typst-layout/src/lists.rs
index adb793fb9..3a3ea8227 100644
--- a/crates/typst-layout/src/lists.rs
+++ b/crates/typst-layout/src/lists.rs
@@ -24,11 +24,7 @@ pub fn layout_list(
     let body_indent = elem.body_indent.get(styles);
     let tight = elem.tight.get(styles);
     let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
-        if tight {
-            styles.get(ParElem::leading)
-        } else {
-            styles.get(ParElem::spacing)
-        }
+        if tight { styles.get(ParElem::leading) } else { styles.get(ParElem::spacing) }
     });
 
     let Depth(depth) = styles.get(ListElem::depth);
@@ -88,22 +84,15 @@ pub fn layout_enum(
     let body_indent = elem.body_indent.get(styles);
     let tight = elem.tight.get(styles);
     let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
-        if tight {
-            styles.get(ParElem::leading)
-        } else {
-            styles.get(ParElem::spacing)
-        }
+        if tight { styles.get(ParElem::leading) } else { styles.get(ParElem::spacing) }
     });
 
     let mut cells = vec![];
     let mut locator = locator.split();
-    let mut number = elem.start.get(styles).unwrap_or_else(|| {
-        if reversed {
-            elem.children.len() as u64
-        } else {
-            1
-        }
-    });
+    let mut number = elem
+        .start
+        .get(styles)
+        .unwrap_or_else(|| if reversed { elem.children.len() as u64 } else { 1 });
     let mut parents = styles.get_cloned(EnumElem::parents);
 
     let full = elem.full.get(styles);
diff --git a/crates/typst-layout/src/math/accent.rs b/crates/typst-layout/src/math/accent.rs
index e7f051ace..b9ca0f6dd 100644
--- a/crates/typst-layout/src/math/accent.rs
+++ b/crates/typst-layout/src/math/accent.rs
@@ -4,8 +4,8 @@ use typst_library::layout::{Em, Frame, Point, Size};
 use typst_library::math::AccentElem;
 
 use super::{
-    style_cramped, style_dtls, style_flac, FrameFragment, GlyphFragment, MathContext,
-    MathFragment,
+    FrameFragment, GlyphFragment, MathContext, MathFragment, style_cramped, style_dtls,
+    style_flac,
 };
 
 /// How much the accent can be shorter than the base.
diff --git a/crates/typst-layout/src/math/attach.rs b/crates/typst-layout/src/math/attach.rs
index 78b6f5515..954f840f9 100644
--- a/crates/typst-layout/src/math/attach.rs
+++ b/crates/typst-layout/src/math/attach.rs
@@ -7,8 +7,8 @@ use typst_library::math::{
 use typst_utils::OptionExt;
 
 use super::{
-    stretch_fragment, style_for_subscript, style_for_superscript, FrameFragment, Limits,
-    MathContext, MathFragment,
+    FrameFragment, Limits, MathContext, MathFragment, stretch_fragment,
+    style_for_subscript, style_for_superscript,
 };
 
 macro_rules! measure {
diff --git a/crates/typst-layout/src/math/frac.rs b/crates/typst-layout/src/math/frac.rs
index 12a2c6fd1..50fd09851 100644
--- a/crates/typst-layout/src/math/frac.rs
+++ b/crates/typst-layout/src/math/frac.rs
@@ -7,8 +7,8 @@ use typst_library::visualize::{FixedStroke, Geometry};
 use typst_syntax::Span;
 
 use super::{
-    style_for_denominator, style_for_numerator, FrameFragment, GlyphFragment,
-    MathContext, DELIM_SHORT_FALL,
+    DELIM_SHORT_FALL, FrameFragment, GlyphFragment, MathContext, style_for_denominator,
+    style_for_numerator,
 };
 
 const FRAC_AROUND: Em = Em::new(0.1);
diff --git a/crates/typst-layout/src/math/fragment.rs b/crates/typst-layout/src/math/fragment.rs
index 877158100..3497587c0 100644
--- a/crates/typst-layout/src/math/fragment.rs
+++ b/crates/typst-layout/src/math/fragment.rs
@@ -2,18 +2,18 @@ use std::fmt::{self, Debug, Formatter};
 
 use az::SaturatingAs;
 use rustybuzz::{BufferFlags, UnicodeBuffer};
-use ttf_parser::math::{GlyphAssembly, GlyphConstruction, GlyphPart};
 use ttf_parser::GlyphId;
-use typst_library::diag::{bail, warning, SourceResult};
+use ttf_parser::math::{GlyphAssembly, GlyphConstruction, GlyphPart};
+use typst_library::diag::{SourceResult, bail, warning};
 use typst_library::foundations::StyleChain;
 use typst_library::introspection::Tag;
 use typst_library::layout::{
     Abs, Axes, Axis, Corner, Em, Frame, FrameItem, Point, Size, VAlignment,
 };
 use typst_library::math::{EquationElem, MathSize};
-use typst_library::text::{features, language, Font, Glyph, TextElem, TextItem};
+use typst_library::text::{Font, Glyph, TextElem, TextItem, features, language};
 use typst_syntax::Span;
-use typst_utils::{default_math_class, Get};
+use typst_utils::{Get, default_math_class};
 use unicode_math_class::MathClass;
 
 use super::MathContext;
@@ -681,7 +681,11 @@ fn min_connector_overlap(font: &Font) -> Option<Em> {
         .map(|variants| font.to_em(variants.min_connector_overlap))
 }
 
-fn glyph_construction(font: &Font, id: GlyphId, axis: Axis) -> Option<GlyphConstruction<'_>> {
+fn glyph_construction(
+    font: &Font,
+    id: GlyphId,
+    axis: Axis,
+) -> Option<GlyphConstruction<'_>> {
     font.ttf()
         .tables()
         .math?
@@ -810,7 +814,10 @@ fn assemble(
 
 /// Return an iterator over the assembly's parts with extenders repeated the
 /// specified number of times.
-fn parts(assembly: GlyphAssembly<'_>, repeat: usize) -> impl Iterator<Item = GlyphPart> + '_ {
+fn parts(
+    assembly: GlyphAssembly<'_>,
+    repeat: usize,
+) -> impl Iterator<Item = GlyphPart> + '_ {
     assembly.parts.into_iter().flat_map(move |part| {
         let count = if part.part_flags.extender() { repeat } else { 1 };
         std::iter::repeat_n(part, count)
diff --git a/crates/typst-layout/src/math/lr.rs b/crates/typst-layout/src/math/lr.rs
index 59dac03af..2a5dd79c9 100644
--- a/crates/typst-layout/src/math/lr.rs
+++ b/crates/typst-layout/src/math/lr.rs
@@ -5,7 +5,7 @@ use typst_library::math::{EquationElem, LrElem, MidElem};
 use typst_utils::SliceExt;
 use unicode_math_class::MathClass;
 
-use super::{stretch_fragment, MathContext, MathFragment, DELIM_SHORT_FALL};
+use super::{DELIM_SHORT_FALL, MathContext, MathFragment, stretch_fragment};
 
 /// Lays out an [`LrElem`].
 #[typst_macros::time(name = "math.lr", span = elem.span())]
@@ -22,9 +22,10 @@ pub fn layout_lr(
 
     // Extract implicit LrElem.
     if let Some(lr) = body.to_packed::<LrElem>()
-        && lr.size.get(styles).is_one() {
-            body = &lr.body;
-        }
+        && lr.size.get(styles).is_one()
+    {
+        body = &lr.body;
+    }
 
     let mut fragments = ctx.layout_into_fragments(body, styles)?;
 
@@ -55,10 +56,11 @@ pub fn layout_lr(
     // Handle MathFragment::Glyph fragments that should be scaled up.
     for fragment in inner_fragments.iter_mut() {
         if let MathFragment::Glyph(glyph) = fragment
-            && glyph.mid_stretched == Some(false) {
-                glyph.mid_stretched = Some(true);
-                scale(ctx, fragment, relative_to, height);
-            }
+            && glyph.mid_stretched == Some(false)
+        {
+            glyph.mid_stretched = Some(true);
+            scale(ctx, fragment, relative_to, height);
+        }
     }
 
     // Remove weak SpacingFragment immediately after the opening or immediately
diff --git a/crates/typst-layout/src/math/mat.rs b/crates/typst-layout/src/math/mat.rs
index 4a897a03e..1969dda57 100644
--- a/crates/typst-layout/src/math/mat.rs
+++ b/crates/typst-layout/src/math/mat.rs
@@ -1,4 +1,4 @@
-use typst_library::diag::{bail, warning, SourceResult};
+use typst_library::diag::{SourceResult, bail, warning};
 use typst_library::foundations::{Content, Packed, Resolve, StyleChain};
 use typst_library::layout::{
     Abs, Axes, Em, FixedAlignment, Frame, FrameItem, Point, Ratio, Rel, Size,
@@ -9,8 +9,8 @@ use typst_library::visualize::{FillRule, FixedStroke, Geometry, LineCap, Shape};
 use typst_syntax::Span;
 
 use super::{
-    alignments, style_for_denominator, AlignmentResult, FrameFragment, GlyphFragment,
-    LeftRightAlternator, MathContext, DELIM_SHORT_FALL,
+    AlignmentResult, DELIM_SHORT_FALL, FrameFragment, GlyphFragment, LeftRightAlternator,
+    MathContext, alignments, style_for_denominator,
 };
 
 const VERTICAL_PADDING: Ratio = Ratio::new(0.1);
diff --git a/crates/typst-layout/src/math/mod.rs b/crates/typst-layout/src/math/mod.rs
index 5ee3e14a8..c12af43f9 100644
--- a/crates/typst-layout/src/math/mod.rs
+++ b/crates/typst-layout/src/math/mod.rs
@@ -13,7 +13,8 @@ mod stretch;
 mod text;
 mod underover;
 
-use typst_library::diag::{bail, SourceResult};
+use typst_library::World;
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{
     Content, NativeElement, Packed, Resolve, StyleChain, SymbolElem,
@@ -28,15 +29,14 @@ use typst_library::math::*;
 use typst_library::model::ParElem;
 use typst_library::routines::{Arenas, RealizationKind};
 use typst_library::text::{
-    families, variant, Font, LinebreakElem, SpaceElem, TextEdgeBounds, TextElem,
+    Font, LinebreakElem, SpaceElem, TextEdgeBounds, TextElem, families, variant,
 };
-use typst_library::World;
 use typst_syntax::Span;
 use typst_utils::Numeric;
 use unicode_math_class::MathClass;
 
 use self::fragment::{
-    has_dtls_feat, stretch_axes, FrameFragment, GlyphFragment, Limits, MathFragment,
+    FrameFragment, GlyphFragment, Limits, MathFragment, has_dtls_feat, stretch_axes,
 };
 use self::run::{LeftRightAlternator, MathRun, MathRunFrameBuilder};
 use self::shared::*;
@@ -604,12 +604,10 @@ fn layout_h(
     styles: StyleChain,
 ) -> SourceResult<()> {
     if let Spacing::Rel(rel) = elem.amount
-        && rel.rel.is_zero() {
-            ctx.push(MathFragment::Spacing(
-                rel.abs.resolve(styles),
-                elem.weak.get(styles),
-            ));
-        }
+        && rel.rel.is_zero()
+    {
+        ctx.push(MathFragment::Spacing(rel.abs.resolve(styles), elem.weak.get(styles)));
+    }
     Ok(())
 }
 
diff --git a/crates/typst-layout/src/math/root.rs b/crates/typst-layout/src/math/root.rs
index 30948e08e..e66619ea9 100644
--- a/crates/typst-layout/src/math/root.rs
+++ b/crates/typst-layout/src/math/root.rs
@@ -5,7 +5,7 @@ use typst_library::math::{EquationElem, MathSize, RootElem};
 use typst_library::text::TextElem;
 use typst_library::visualize::{FixedStroke, Geometry};
 
-use super::{style_cramped, FrameFragment, GlyphFragment, MathContext};
+use super::{FrameFragment, GlyphFragment, MathContext, style_cramped};
 
 /// Lays out a [`RootElem`].
 ///
diff --git a/crates/typst-layout/src/math/run.rs b/crates/typst-layout/src/math/run.rs
index fb206dc2e..1ef2608cf 100644
--- a/crates/typst-layout/src/math/run.rs
+++ b/crates/typst-layout/src/math/run.rs
@@ -2,11 +2,11 @@ use std::iter::once;
 
 use typst_library::foundations::{Resolve, StyleChain};
 use typst_library::layout::{Abs, AlignElem, Em, Frame, InlineItem, Point, Size};
-use typst_library::math::{EquationElem, MathSize, MEDIUM, THICK, THIN};
+use typst_library::math::{EquationElem, MEDIUM, MathSize, THICK, THIN};
 use typst_library::model::ParElem;
 use unicode_math_class::MathClass;
 
-use super::{alignments, FrameFragment, MathFragment};
+use super::{FrameFragment, MathFragment, alignments};
 
 const TIGHT_LEADING: Em = Em::new(0.25);
 
@@ -88,9 +88,10 @@ impl MathRun {
             // Insert spacing between the last and this non-ignorant item.
             if !fragment.is_ignorant() {
                 if let Some(i) = last
-                    && let Some(s) = spacing(&resolved[i], space.take(), &fragment) {
-                        resolved.insert(i + 1, s);
-                    }
+                    && let Some(s) = spacing(&resolved[i], space.take(), &fragment)
+                {
+                    resolved.insert(i + 1, s);
+                }
 
                 last = Some(resolved.len());
             }
@@ -123,9 +124,10 @@ impl MathRun {
 
         // A linebreak at the very end does not introduce an extra row.
         if let Some(f) = self.0.last()
-            && matches!(f, MathFragment::Linebreak) {
-                count -= 1
-            }
+            && matches!(f, MathFragment::Linebreak)
+        {
+            count -= 1
+        }
         count
     }
 
@@ -343,9 +345,10 @@ impl MathRun {
 
                 space_is_visible = true;
                 if let Some(f_next) = iter.peek()
-                    && !is_space(f_next) {
-                        items.push(InlineItem::Space(Abs::zero(), true));
-                    }
+                    && !is_space(f_next)
+                {
+                    items.push(InlineItem::Space(Abs::zero(), true));
+                }
             } else {
                 space_is_visible = false;
             }
diff --git a/crates/typst-layout/src/math/shared.rs b/crates/typst-layout/src/math/shared.rs
index c9d20aa68..2763c1622 100644
--- a/crates/typst-layout/src/math/shared.rs
+++ b/crates/typst-layout/src/math/shared.rs
@@ -1,5 +1,5 @@
-use ttf_parser::math::MathValue;
 use ttf_parser::Tag;
+use ttf_parser::math::MathValue;
 use typst_library::foundations::{Style, StyleChain};
 use typst_library::layout::{Abs, Em, FixedAlignment, Frame, Point, Size};
 use typst_library::math::{EquationElem, MathSize};
diff --git a/crates/typst-layout/src/math/stretch.rs b/crates/typst-layout/src/math/stretch.rs
index b9a6b15ae..615d1e6bf 100644
--- a/crates/typst-layout/src/math/stretch.rs
+++ b/crates/typst-layout/src/math/stretch.rs
@@ -1,10 +1,10 @@
-use typst_library::diag::{warning, SourceResult};
+use typst_library::diag::{SourceResult, warning};
 use typst_library::foundations::{Packed, StyleChain};
 use typst_library::layout::{Abs, Axis, Rel};
 use typst_library::math::StretchElem;
 use typst_utils::Get;
 
-use super::{stretch_axes, MathContext, MathFragment};
+use super::{MathContext, MathFragment, stretch_axes};
 
 /// Lays out a [`StretchElem`].
 #[typst_macros::time(name = "math.stretch", span = elem.span())]
diff --git a/crates/typst-layout/src/math/text.rs b/crates/typst-layout/src/math/text.rs
index 634969cd4..fe9c7203a 100644
--- a/crates/typst-layout/src/math/text.rs
+++ b/crates/typst-layout/src/math/text.rs
@@ -1,6 +1,6 @@
 use std::f64::consts::SQRT_2;
 
-use codex::styling::{to_style, MathStyle};
+use codex::styling::{MathStyle, to_style};
 use ecow::EcoString;
 use typst_library::diag::SourceResult;
 use typst_library::foundations::{Packed, StyleChain, SymbolElem};
@@ -9,13 +9,13 @@ use typst_library::math::{EquationElem, MathSize};
 use typst_library::text::{
     BottomEdge, BottomEdgeMetric, TextElem, TopEdge, TopEdgeMetric,
 };
-use typst_syntax::{is_newline, Span};
+use typst_syntax::{Span, is_newline};
 use unicode_math_class::MathClass;
 use unicode_segmentation::UnicodeSegmentation;
 
 use super::{
-    has_dtls_feat, style_dtls, FrameFragment, GlyphFragment, MathContext, MathFragment,
-    MathRun,
+    FrameFragment, GlyphFragment, MathContext, MathFragment, MathRun, has_dtls_feat,
+    style_dtls,
 };
 
 /// Lays out a [`TextElem`].
diff --git a/crates/typst-layout/src/math/underover.rs b/crates/typst-layout/src/math/underover.rs
index 1e1aeb41d..e1ca657f8 100644
--- a/crates/typst-layout/src/math/underover.rs
+++ b/crates/typst-layout/src/math/underover.rs
@@ -10,8 +10,8 @@ use typst_library::visualize::{FixedStroke, Geometry};
 use typst_syntax::Span;
 
 use super::{
-    stack, style_cramped, style_for_subscript, style_for_superscript, FrameFragment,
-    GlyphFragment, LeftRightAlternator, MathContext, MathRun,
+    FrameFragment, GlyphFragment, LeftRightAlternator, MathContext, MathRun, stack,
+    style_cramped, style_for_subscript, style_for_superscript,
 };
 
 const BRACE_GAP: Em = Em::new(0.25);
diff --git a/crates/typst-layout/src/pages/mod.rs b/crates/typst-layout/src/pages/mod.rs
index ec0dc2c05..ea86e3f3d 100644
--- a/crates/typst-layout/src/pages/mod.rs
+++ b/crates/typst-layout/src/pages/mod.rs
@@ -7,6 +7,7 @@ mod run;
 use std::num::NonZeroUsize;
 
 use comemo::{Tracked, TrackedMut};
+use typst_library::World;
 use typst_library::diag::SourceResult;
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{Content, StyleChain};
@@ -16,11 +17,10 @@ use typst_library::introspection::{
 use typst_library::layout::{FrameItem, Page, PagedDocument, Point, Transform};
 use typst_library::model::DocumentInfo;
 use typst_library::routines::{Arenas, Pair, RealizationKind, Routines};
-use typst_library::World;
 
-use self::collect::{collect, Item};
+use self::collect::{Item, collect};
 use self::finalize::finalize;
-use self::run::{layout_blank_page, layout_page_run, LayoutedPage};
+use self::run::{LayoutedPage, layout_blank_page, layout_page_run};
 
 /// Layout content into a document.
 ///
diff --git a/crates/typst-layout/src/pages/run.rs b/crates/typst-layout/src/pages/run.rs
index 8c1a34ed5..c327adba2 100644
--- a/crates/typst-layout/src/pages/run.rs
+++ b/crates/typst-layout/src/pages/run.rs
@@ -1,4 +1,5 @@
 use comemo::{Track, Tracked, TrackedMut};
+use typst_library::World;
 use typst_library::diag::SourceResult;
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{
@@ -16,10 +17,9 @@ use typst_library::model::Numbering;
 use typst_library::routines::{Pair, Routines};
 use typst_library::text::{LocalName, TextElem};
 use typst_library::visualize::Paint;
-use typst_library::World;
 use typst_utils::Numeric;
 
-use crate::flow::{layout_flow, FlowMode};
+use crate::flow::{FlowMode, layout_flow};
 
 /// A mostly finished layout for one page. Needs only knowledge of its exact
 /// page number to be finalized into a `Page`. (Because the margins can depend
diff --git a/crates/typst-layout/src/repeat.rs b/crates/typst-layout/src/repeat.rs
index 40179c349..91c39fed9 100644
--- a/crates/typst-layout/src/repeat.rs
+++ b/crates/typst-layout/src/repeat.rs
@@ -1,4 +1,4 @@
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Packed, Resolve, StyleChain};
 use typst_library::introspection::Locator;
diff --git a/crates/typst-layout/src/rules.rs b/crates/typst-layout/src/rules.rs
index f21cd17ab..a3616f96e 100644
--- a/crates/typst-layout/src/rules.rs
+++ b/crates/typst-layout/src/rules.rs
@@ -1,12 +1,12 @@
 use std::num::NonZeroUsize;
 
 use comemo::Track;
-use ecow::{eco_format, EcoVec};
+use ecow::{EcoVec, eco_format};
 use smallvec::smallvec;
-use typst_library::diag::{bail, At, SourceResult};
+use typst_library::diag::{At, SourceResult, bail};
 use typst_library::foundations::{
-    dict, Content, Context, NativeElement, NativeRuleMap, Packed, Resolve, ShowFn, Smart,
-    StyleChain, Target,
+    Content, Context, NativeElement, NativeRuleMap, Packed, Resolve, ShowFn, Smart,
+    StyleChain, Target, dict,
 };
 use typst_library::introspection::{Counter, Locator, LocatorLink};
 use typst_library::layout::{
@@ -161,11 +161,7 @@ const TERMS_RULE: ShowFn<TermsElem> = |elem, _, styles| {
     let indent = elem.indent.get(styles);
     let hanging_indent = elem.hanging_indent.get(styles);
     let gutter = elem.spacing.get(styles).unwrap_or_else(|| {
-        if tight {
-            styles.get(ParElem::leading)
-        } else {
-            styles.get(ParElem::spacing)
-        }
+        if tight { styles.get(ParElem::leading) } else { styles.get(ParElem::spacing) }
     });
 
     let pad = hanging_indent + indent;
diff --git a/crates/typst-layout/src/shapes.rs b/crates/typst-layout/src/shapes.rs
index 1a9b38f25..d0d3a5e1d 100644
--- a/crates/typst-layout/src/shapes.rs
+++ b/crates/typst-layout/src/shapes.rs
@@ -1,7 +1,7 @@
 use std::f64::consts::SQRT_2;
 
 use kurbo::{CubicBez, ParamCurveExtrema};
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Content, Packed, Resolve, Smart, StyleChain};
 use typst_library::introspection::Locator;
diff --git a/crates/typst-layout/src/stack.rs b/crates/typst-layout/src/stack.rs
index 5df626fdf..892b08137 100644
--- a/crates/typst-layout/src/stack.rs
+++ b/crates/typst-layout/src/stack.rs
@@ -1,4 +1,4 @@
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Content, Packed, Resolve, StyleChain, StyledElem};
 use typst_library::introspection::{Locator, SplitLocator};
diff --git a/crates/typst-layout/src/transforms.rs b/crates/typst-layout/src/transforms.rs
index e545dd512..beeeea034 100644
--- a/crates/typst-layout/src/transforms.rs
+++ b/crates/typst-layout/src/transforms.rs
@@ -1,6 +1,6 @@
 use std::cell::LazyCell;
 
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{Content, Packed, Resolve, Smart, StyleChain};
 use typst_library::introspection::Locator;
diff --git a/crates/typst-library/src/diag.rs b/crates/typst-library/src/diag.rs
index 611ec6338..2b9ff6376 100644
--- a/crates/typst-library/src/diag.rs
+++ b/crates/typst-library/src/diag.rs
@@ -8,7 +8,7 @@ use std::string::FromUtf8Error;
 
 use az::SaturatingAs;
 use comemo::Tracked;
-use ecow::{eco_vec, EcoVec};
+use ecow::{EcoVec, eco_vec};
 use typst_syntax::package::{PackageSpec, PackageVersion};
 use typst_syntax::{Lines, Span, Spanned, SyntaxError};
 use utf8_iter::ErrorReportingUtf8Chars;
@@ -298,11 +298,11 @@ impl<T> Trace<T> for SourceResult<T> {
                 // Skip traces that surround the error.
                 if let Some(error_range) = world.range(error.span)
                     && error.span.id() == span.id()
-                        && trace_range.start <= error_range.start
-                        && trace_range.end >= error_range.end
-                    {
-                        continue;
-                    }
+                    && trace_range.start <= error_range.start
+                    && trace_range.end >= error_range.end
+                {
+                    continue;
+                }
 
                 error.trace.push(Spanned::new(make_point(), span));
             }
@@ -838,7 +838,9 @@ pub fn format_xml_like_error(format: &str, error: roxmltree::Error) -> LoadError
     let pos = LineCol::one_based(error.pos().row as usize, error.pos().col as usize);
     let message = match error {
         roxmltree::Error::UnexpectedCloseTag(expected, actual, _) => {
-            eco_format!("failed to parse {format} (found closing tag '{actual}' instead of '{expected}')")
+            eco_format!(
+                "failed to parse {format} (found closing tag '{actual}' instead of '{expected}')"
+            )
         }
         roxmltree::Error::UnknownEntityReference(entity, _) => {
             eco_format!("failed to parse {format} (unknown entity '{entity}')")
diff --git a/crates/typst-library/src/engine.rs b/crates/typst-library/src/engine.rs
index a85fc8ca2..cb98f4599 100644
--- a/crates/typst-library/src/engine.rs
+++ b/crates/typst-library/src/engine.rs
@@ -8,11 +8,11 @@ use ecow::EcoVec;
 use rayon::iter::{IndexedParallelIterator, IntoParallelIterator, ParallelIterator};
 use typst_syntax::{FileId, Span};
 
-use crate::diag::{bail, HintedStrResult, SourceDiagnostic, SourceResult, StrResult};
+use crate::World;
+use crate::diag::{HintedStrResult, SourceDiagnostic, SourceResult, StrResult, bail};
 use crate::foundations::{Styles, Value};
 use crate::introspection::Introspector;
 use crate::routines::Routines;
-use crate::World;
 
 /// Holds all data needed during compilation.
 pub struct Engine<'a> {
@@ -47,7 +47,11 @@ impl Engine<'_> {
     }
 
     /// Runs tasks on the engine in parallel.
-    pub fn parallelize<P, I, T, U, F>(&mut self, iter: P, f: F) -> impl Iterator<Item = U> + use<P, I, T, U, F>
+    pub fn parallelize<P, I, T, U, F>(
+        &mut self,
+        iter: P,
+        f: F,
+    ) -> impl Iterator<Item = U> + use<P, I, T, U, F>
     where
         P: IntoIterator<IntoIter = I>,
         I: Iterator<Item = T>,
@@ -111,11 +115,7 @@ impl Traced {
     /// We hide the span if it isn't in the given file so that only results for
     /// the file with the traced span are invalidated.
     pub fn get(&self, id: FileId) -> Option<Span> {
-        if self.0.and_then(Span::id) == Some(id) {
-            self.0
-        } else {
-            None
-        }
+        if self.0.and_then(Span::id) == Some(id) { self.0 } else { None }
     }
 }
 
diff --git a/crates/typst-library/src/foundations/args.rs b/crates/typst-library/src/foundations/args.rs
index 430c4e9ad..343d60456 100644
--- a/crates/typst-library/src/foundations/args.rs
+++ b/crates/typst-library/src/foundations/args.rs
@@ -1,12 +1,12 @@
 use std::fmt::{self, Debug, Formatter};
 use std::ops::Add;
 
-use ecow::{eco_format, eco_vec, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format, eco_vec};
 use typst_syntax::{Span, Spanned};
 
-use crate::diag::{bail, error, At, SourceDiagnostic, SourceResult, StrResult};
+use crate::diag::{At, SourceDiagnostic, SourceResult, StrResult, bail, error};
 use crate::foundations::{
-    cast, func, repr, scope, ty, Array, Dict, FromValue, IntoValue, Repr, Str, Value,
+    Array, Dict, FromValue, IntoValue, Repr, Str, Value, cast, func, repr, scope, ty,
 };
 
 /// Captured arguments to a function.
diff --git a/crates/typst-library/src/foundations/array.rs b/crates/typst-library/src/foundations/array.rs
index 87a301049..5e72ce889 100644
--- a/crates/typst-library/src/foundations/array.rs
+++ b/crates/typst-library/src/foundations/array.rs
@@ -4,16 +4,16 @@ use std::num::{NonZeroI64, NonZeroUsize};
 use std::ops::{Add, AddAssign};
 
 use comemo::Tracked;
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
 use serde::{Deserialize, Serialize};
 use smallvec::SmallVec;
 use typst_syntax::{Span, Spanned};
 
-use crate::diag::{bail, At, HintedStrResult, SourceDiagnostic, SourceResult, StrResult};
+use crate::diag::{At, HintedStrResult, SourceDiagnostic, SourceResult, StrResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, func, ops, repr, scope, ty, Args, Bytes, CastInfo, Context, Dict, FromValue,
-    Func, IntoValue, Reflect, Repr, Str, Value, Version,
+    Args, Bytes, CastInfo, Context, Dict, FromValue, Func, IntoValue, Reflect, Repr, Str,
+    Value, Version, cast, func, ops, repr, scope, ty,
 };
 
 /// Create a new [`Array`] from values.
diff --git a/crates/typst-library/src/foundations/auto.rs b/crates/typst-library/src/foundations/auto.rs
index 8237b4509..c8ae0706e 100644
--- a/crates/typst-library/src/foundations/auto.rs
+++ b/crates/typst-library/src/foundations/auto.rs
@@ -4,8 +4,8 @@ use ecow::EcoString;
 
 use crate::diag::HintedStrResult;
 use crate::foundations::{
-    ty, CastInfo, Fold, FromValue, IntoValue, Reflect, Repr, Resolve, StyleChain, Type,
-    Value,
+    CastInfo, Fold, FromValue, IntoValue, Reflect, Repr, Resolve, StyleChain, Type,
+    Value, ty,
 };
 
 /// A value that indicates a smart default.
diff --git a/crates/typst-library/src/foundations/bool.rs b/crates/typst-library/src/foundations/bool.rs
index e88c8c6ff..32f6845df 100644
--- a/crates/typst-library/src/foundations/bool.rs
+++ b/crates/typst-library/src/foundations/bool.rs
@@ -1,6 +1,6 @@
 use ecow::EcoString;
 
-use crate::foundations::{ty, Repr};
+use crate::foundations::{Repr, ty};
 
 /// A type with two states.
 ///
diff --git a/crates/typst-library/src/foundations/bytes.rs b/crates/typst-library/src/foundations/bytes.rs
index 180dcdad5..f4547439d 100644
--- a/crates/typst-library/src/foundations/bytes.rs
+++ b/crates/typst-library/src/foundations/bytes.rs
@@ -5,13 +5,13 @@ use std::ops::{Add, AddAssign, Deref};
 use std::str::Utf8Error;
 use std::sync::Arc;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use serde::{Serialize, Serializer};
 use typst_syntax::Lines;
 use typst_utils::LazyHash;
 
-use crate::diag::{bail, StrResult};
-use crate::foundations::{cast, func, scope, ty, Array, Reflect, Repr, Str, Value};
+use crate::diag::{StrResult, bail};
+use crate::foundations::{Array, Reflect, Repr, Str, Value, cast, func, scope, ty};
 
 /// A sequence of bytes.
 ///
diff --git a/crates/typst-library/src/foundations/calc.rs b/crates/typst-library/src/foundations/calc.rs
index 1fe1ff1fc..8aa6c6bcb 100644
--- a/crates/typst-library/src/foundations/calc.rs
+++ b/crates/typst-library/src/foundations/calc.rs
@@ -7,8 +7,8 @@ use az::SaturatingAs;
 use typst_syntax::{Span, Spanned};
 use typst_utils::{round_int_with_precision, round_with_precision};
 
-use crate::diag::{bail, At, HintedString, SourceResult, StrResult};
-use crate::foundations::{cast, func, ops, Decimal, IntoValue, Module, Scope, Value};
+use crate::diag::{At, HintedString, SourceResult, StrResult, bail};
+use crate::foundations::{Decimal, IntoValue, Module, Scope, Value, cast, func, ops};
 use crate::layout::{Angle, Fr, Length, Ratio};
 
 /// A module with calculation definitions.
diff --git a/crates/typst-library/src/foundations/cast.rs b/crates/typst-library/src/foundations/cast.rs
index 17d194e1a..95c29a40a 100644
--- a/crates/typst-library/src/foundations/cast.rs
+++ b/crates/typst-library/src/foundations/cast.rs
@@ -14,7 +14,7 @@ use unicode_math_class::MathClass;
 
 use crate::diag::{At, HintedStrResult, HintedString, SourceResult, StrResult};
 use crate::foundations::{
-    array, repr, Fold, NativeElement, Packed, Repr, Str, Type, Value,
+    Fold, NativeElement, Packed, Repr, Str, Type, Value, array, repr,
 };
 
 /// Determine details of a type.
@@ -348,12 +348,14 @@ impl CastInfo {
                 }
             }
         } else if let Value::Decimal(_) = found
-            && !matching_type && parts.iter().any(|p| p == "float") {
-                msg.hint(eco_format!(
-                    "if loss of precision is acceptable, explicitly cast the \
+            && !matching_type
+            && parts.iter().any(|p| p == "float")
+        {
+            msg.hint(eco_format!(
+                "if loss of precision is acceptable, explicitly cast the \
                      decimal to a float with `float(value)`"
-                ));
-            }
+            ));
+        }
 
         msg
     }
diff --git a/crates/typst-library/src/foundations/content/element.rs b/crates/typst-library/src/foundations/content/element.rs
index 65c2e28b5..6e3c6d889 100644
--- a/crates/typst-library/src/foundations/content/element.rs
+++ b/crates/typst-library/src/foundations/content/element.rs
@@ -11,8 +11,8 @@ use typst_utils::Static;
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, Args, Content, ContentVtable, FieldAccessError, Func, ParamInfo, Repr, Scope,
-    Selector, StyleChain, Styles, Value,
+    Args, Content, ContentVtable, FieldAccessError, Func, ParamInfo, Repr, Scope,
+    Selector, StyleChain, Styles, Value, cast,
 };
 use crate::text::{Lang, Region};
 
@@ -243,7 +243,7 @@ pub trait Set {
 pub trait Synthesize {
     /// Prepare the element for show rule application.
     fn synthesize(&mut self, engine: &mut Engine, styles: StyleChain)
-        -> SourceResult<()>;
+    -> SourceResult<()>;
 }
 
 /// Defines built-in show set rules for an element.
diff --git a/crates/typst-library/src/foundations/content/field.rs b/crates/typst-library/src/foundations/content/field.rs
index 8d0fe529c..a8e679441 100644
--- a/crates/typst-library/src/foundations/content/field.rs
+++ b/crates/typst-library/src/foundations/content/field.rs
@@ -3,7 +3,7 @@ use std::hash::Hash;
 use std::marker::PhantomData;
 use std::sync::OnceLock;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 
 use crate::foundations::{
     Container, Content, FieldVtable, Fold, FoldFn, IntoValue, NativeElement, Packed,
diff --git a/crates/typst-library/src/foundations/content/mod.rs b/crates/typst-library/src/foundations/content/mod.rs
index f5e8314d8..ca5c7b6d8 100644
--- a/crates/typst-library/src/foundations/content/mod.rs
+++ b/crates/typst-library/src/foundations/content/mod.rs
@@ -17,7 +17,7 @@ use std::iter::{self, Sum};
 use std::ops::{Add, AddAssign, ControlFlow};
 
 use comemo::Tracked;
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use serde::{Serialize, Serializer};
 
 use typst_syntax::Span;
@@ -26,8 +26,8 @@ use typst_utils::singleton;
 use crate::diag::{SourceResult, StrResult};
 use crate::engine::Engine;
 use crate::foundations::{
-    func, repr, scope, ty, Context, Dict, IntoValue, Label, Property, Recipe,
-    RecipeIndex, Repr, Selector, Str, Style, StyleChain, Styles, Value,
+    Context, Dict, IntoValue, Label, Property, Recipe, RecipeIndex, Repr, Selector, Str,
+    Style, StyleChain, Styles, Value, func, repr, scope, ty,
 };
 use crate::introspection::Location;
 use crate::layout::{AlignElem, Alignment, Axes, Length, MoveElem, PadElem, Rel, Sides};
@@ -175,9 +175,10 @@ impl Content {
         styles: Option<StyleChain>,
     ) -> Result<Value, FieldAccessError> {
         if id == 255
-            && let Some(label) = self.label() {
-                return Ok(label.into_value());
-            }
+            && let Some(label) = self.label()
+        {
+            return Ok(label.into_value());
+        }
 
         match self.0.handle().field(id) {
             Some(handle) => match styles {
diff --git a/crates/typst-library/src/foundations/content/raw.rs b/crates/typst-library/src/foundations/content/raw.rs
index dde26bd79..713700502 100644
--- a/crates/typst-library/src/foundations/content/raw.rs
+++ b/crates/typst-library/src/foundations/content/raw.rs
@@ -5,7 +5,7 @@ use std::ptr::NonNull;
 use std::sync::atomic::{self, AtomicUsize, Ordering};
 
 use typst_syntax::Span;
-use typst_utils::{fat, HashLock, SmallBitSet};
+use typst_utils::{HashLock, SmallBitSet, fat};
 
 use super::vtable;
 use crate::foundations::{Element, Label, NativeElement, Packed};
diff --git a/crates/typst-library/src/foundations/context.rs b/crates/typst-library/src/foundations/context.rs
index 56d87775e..d9b8a48f6 100644
--- a/crates/typst-library/src/foundations/context.rs
+++ b/crates/typst-library/src/foundations/context.rs
@@ -1,9 +1,9 @@
 use comemo::Track;
 
-use crate::diag::{bail, Hint, HintedStrResult, SourceResult};
+use crate::diag::{Hint, HintedStrResult, SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Args, Construct, Content, Func, ShowFn, StyleChain, Value,
+    Args, Construct, Content, Func, ShowFn, StyleChain, Value, elem,
 };
 use crate::introspection::{Locatable, Location};
 
diff --git a/crates/typst-library/src/foundations/datetime.rs b/crates/typst-library/src/foundations/datetime.rs
index 2fc48a521..ffc6aaafa 100644
--- a/crates/typst-library/src/foundations/datetime.rs
+++ b/crates/typst-library/src/foundations/datetime.rs
@@ -2,17 +2,17 @@ use std::cmp::Ordering;
 use std::hash::Hash;
 use std::ops::{Add, Sub};
 
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
 use time::error::{Format, InvalidFormatDescription};
 use time::macros::format_description;
-use time::{format_description, Month, PrimitiveDateTime};
+use time::{Month, PrimitiveDateTime, format_description};
 
-use crate::diag::{bail, StrResult};
+use crate::World;
+use crate::diag::{StrResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, func, repr, scope, ty, Dict, Duration, Repr, Smart, Str, Value,
+    Dict, Duration, Repr, Smart, Str, Value, cast, func, repr, scope, ty,
 };
-use crate::World;
 
 /// Represents a date, a time, or a combination of both.
 ///
diff --git a/crates/typst-library/src/foundations/decimal.rs b/crates/typst-library/src/foundations/decimal.rs
index d363a6a41..998de8e95 100644
--- a/crates/typst-library/src/foundations/decimal.rs
+++ b/crates/typst-library/src/foundations/decimal.rs
@@ -3,14 +3,14 @@ use std::hash::{Hash, Hasher};
 use std::ops::Neg;
 use std::str::FromStr;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use rust_decimal::MathematicalOps;
-use typst_syntax::{ast, Span, Spanned};
+use typst_syntax::{Span, Spanned, ast};
 
-use crate::diag::{warning, At, SourceResult};
-use crate::engine::Engine;
-use crate::foundations::{cast, func, repr, scope, ty, Repr, Str};
 use crate::World;
+use crate::diag::{At, SourceResult, warning};
+use crate::engine::Engine;
+use crate::foundations::{Repr, Str, cast, func, repr, scope, ty};
 
 /// A fixed-point decimal number type.
 ///
diff --git a/crates/typst-library/src/foundations/dict.rs b/crates/typst-library/src/foundations/dict.rs
index ba161f44c..d5dfc7aa4 100644
--- a/crates/typst-library/src/foundations/dict.rs
+++ b/crates/typst-library/src/foundations/dict.rs
@@ -3,7 +3,7 @@ use std::hash::{Hash, Hasher};
 use std::ops::{Add, AddAssign};
 use std::sync::Arc;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use indexmap::IndexMap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use typst_syntax::is_ident;
@@ -11,7 +11,7 @@ use typst_utils::ArcExt;
 
 use crate::diag::{Hint, HintedStrResult, StrResult};
 use crate::foundations::{
-    array, cast, func, repr, scope, ty, Array, Module, Repr, Str, Value,
+    Array, Module, Repr, Str, Value, array, cast, func, repr, scope, ty,
 };
 
 /// Create a new [`Dict`] from key-value pairs.
diff --git a/crates/typst-library/src/foundations/duration.rs b/crates/typst-library/src/foundations/duration.rs
index 90685fa34..2dcef0d85 100644
--- a/crates/typst-library/src/foundations/duration.rs
+++ b/crates/typst-library/src/foundations/duration.rs
@@ -1,10 +1,10 @@
 use std::fmt::{self, Debug, Formatter};
 use std::ops::{Add, Div, Mul, Neg, Sub};
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use time::ext::NumericalDuration;
 
-use crate::foundations::{func, repr, scope, ty, Repr};
+use crate::foundations::{Repr, func, repr, scope, ty};
 
 /// Represents a positive or negative span of time.
 #[ty(scope, cast)]
diff --git a/crates/typst-library/src/foundations/fields.rs b/crates/typst-library/src/foundations/fields.rs
index 422f30b88..83b5d073e 100644
--- a/crates/typst-library/src/foundations/fields.rs
+++ b/crates/typst-library/src/foundations/fields.rs
@@ -1,6 +1,6 @@
 //! Fields on values.
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 
 use crate::diag::StrResult;
 use crate::foundations::{IntoValue, Type, Value, Version};
diff --git a/crates/typst-library/src/foundations/float.rs b/crates/typst-library/src/foundations/float.rs
index 353e498d3..b9d5b97cc 100644
--- a/crates/typst-library/src/foundations/float.rs
+++ b/crates/typst-library/src/foundations/float.rs
@@ -1,10 +1,10 @@
 use std::num::ParseFloatError;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 
-use crate::diag::{bail, StrResult};
+use crate::diag::{StrResult, bail};
 use crate::foundations::{
-    cast, func, repr, scope, ty, Bytes, Decimal, Endianness, Repr, Str,
+    Bytes, Decimal, Endianness, Repr, Str, cast, func, repr, scope, ty,
 };
 use crate::layout::Ratio;
 
diff --git a/crates/typst-library/src/foundations/func.rs b/crates/typst-library/src/foundations/func.rs
index dd999ddc3..5b43ad37c 100644
--- a/crates/typst-library/src/foundations/func.rs
+++ b/crates/typst-library/src/foundations/func.rs
@@ -5,15 +5,15 @@ use std::fmt::{self, Debug, Formatter};
 use std::sync::{Arc, LazyLock};
 
 use comemo::{Tracked, TrackedMut};
-use ecow::{eco_format, EcoString};
-use typst_syntax::{ast, Span, SyntaxNode};
-use typst_utils::{singleton, LazyHash, Static};
+use ecow::{EcoString, eco_format};
+use typst_syntax::{Span, SyntaxNode, ast};
+use typst_utils::{LazyHash, Static, singleton};
 
-use crate::diag::{bail, At, DeprecationSink, SourceResult, StrResult};
+use crate::diag::{At, DeprecationSink, SourceResult, StrResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, repr, scope, ty, Args, Bytes, CastInfo, Content, Context, Element, IntoArgs,
-    PluginFunc, Scope, Selector, Type, Value,
+    Args, Bytes, CastInfo, Content, Context, Element, IntoArgs, PluginFunc, Scope,
+    Selector, Type, Value, cast, repr, scope, ty,
 };
 
 /// A mapping from argument values to a return value.
diff --git a/crates/typst-library/src/foundations/int.rs b/crates/typst-library/src/foundations/int.rs
index 13f457a11..aa8655889 100644
--- a/crates/typst-library/src/foundations/int.rs
+++ b/crates/typst-library/src/foundations/int.rs
@@ -2,12 +2,12 @@ use std::num::{
     NonZeroI64, NonZeroIsize, NonZeroU32, NonZeroU64, NonZeroUsize, ParseIntError,
 };
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use smallvec::SmallVec;
 
-use crate::diag::{bail, StrResult};
+use crate::diag::{StrResult, bail};
 use crate::foundations::{
-    cast, func, repr, scope, ty, Bytes, Cast, Decimal, Repr, Str, Value,
+    Bytes, Cast, Decimal, Repr, Str, Value, cast, func, repr, scope, ty,
 };
 
 /// A whole number.
diff --git a/crates/typst-library/src/foundations/label.rs b/crates/typst-library/src/foundations/label.rs
index b1ac58bf2..5a9e76538 100644
--- a/crates/typst-library/src/foundations/label.rs
+++ b/crates/typst-library/src/foundations/label.rs
@@ -1,8 +1,8 @@
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_utils::{PicoStr, ResolvedPicoStr};
 
 use crate::diag::StrResult;
-use crate::foundations::{bail, func, scope, ty, Repr, Str};
+use crate::foundations::{Repr, Str, bail, func, scope, ty};
 
 /// A label for an element.
 ///
diff --git a/crates/typst-library/src/foundations/mod.rs b/crates/typst-library/src/foundations/mod.rs
index 382beb2cd..8a94107c2 100644
--- a/crates/typst-library/src/foundations/mod.rs
+++ b/crates/typst-library/src/foundations/mod.rs
@@ -80,7 +80,7 @@ use comemo::TrackedMut;
 use ecow::EcoString;
 use typst_syntax::Spanned;
 
-use crate::diag::{bail, SourceResult, StrResult};
+use crate::diag::{SourceResult, StrResult, bail};
 use crate::engine::Engine;
 use crate::{Feature, Features};
 
diff --git a/crates/typst-library/src/foundations/module.rs b/crates/typst-library/src/foundations/module.rs
index 14eefca39..83c6d0492 100644
--- a/crates/typst-library/src/foundations/module.rs
+++ b/crates/typst-library/src/foundations/module.rs
@@ -1,11 +1,11 @@
 use std::fmt::{self, Debug, Formatter};
 use std::sync::Arc;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_syntax::FileId;
 
-use crate::diag::{bail, DeprecationSink, StrResult};
-use crate::foundations::{repr, ty, Content, Scope, Value};
+use crate::diag::{DeprecationSink, StrResult, bail};
+use crate::foundations::{Content, Scope, Value, repr, ty};
 
 /// A collection of variables and functions that are commonly related to
 /// a single theme.
diff --git a/crates/typst-library/src/foundations/none.rs b/crates/typst-library/src/foundations/none.rs
index d376c0c5b..b38ccaf3e 100644
--- a/crates/typst-library/src/foundations/none.rs
+++ b/crates/typst-library/src/foundations/none.rs
@@ -5,7 +5,7 @@ use serde::{Serialize, Serializer};
 
 use crate::diag::HintedStrResult;
 use crate::foundations::{
-    cast, ty, CastInfo, FromValue, IntoValue, Reflect, Repr, Type, Value,
+    CastInfo, FromValue, IntoValue, Reflect, Repr, Type, Value, cast, ty,
 };
 
 /// A value that indicates the absence of any other value.
diff --git a/crates/typst-library/src/foundations/ops.rs b/crates/typst-library/src/foundations/ops.rs
index 3c6a5e6cf..0aed5af4f 100644
--- a/crates/typst-library/src/foundations/ops.rs
+++ b/crates/typst-library/src/foundations/ops.rs
@@ -5,9 +5,9 @@ use std::cmp::Ordering;
 use ecow::eco_format;
 use typst_utils::Numeric;
 
-use crate::diag::{bail, HintedStrResult, StrResult};
+use crate::diag::{HintedStrResult, StrResult, bail};
 use crate::foundations::{
-    format_str, Datetime, IntoValue, Regex, Repr, SymbolElem, Value,
+    Datetime, IntoValue, Regex, Repr, SymbolElem, Value, format_str,
 };
 use crate::layout::{Alignment, Length, Rel};
 use crate::text::TextElem;
diff --git a/crates/typst-library/src/foundations/plugin.rs b/crates/typst-library/src/foundations/plugin.rs
index a04443bf4..7908407b3 100644
--- a/crates/typst-library/src/foundations/plugin.rs
+++ b/crates/typst-library/src/foundations/plugin.rs
@@ -2,13 +2,13 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::{Arc, Mutex};
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_syntax::Spanned;
 use wasmi::Memory;
 
-use crate::diag::{bail, At, SourceResult, StrResult};
+use crate::diag::{At, SourceResult, StrResult, bail};
 use crate::engine::Engine;
-use crate::foundations::{cast, func, scope, Binding, Bytes, Func, Module, Scope, Value};
+use crate::foundations::{Binding, Bytes, Func, Module, Scope, Value, cast, func, scope};
 use crate::loading::{DataSource, Load};
 
 /// Loads a WebAssembly module.
diff --git a/crates/typst-library/src/foundations/repr.rs b/crates/typst-library/src/foundations/repr.rs
index e219b0f1c..ea9ff4ce6 100644
--- a/crates/typst-library/src/foundations/repr.rs
+++ b/crates/typst-library/src/foundations/repr.rs
@@ -1,9 +1,9 @@
 //! Debug representation of values.
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_utils::round_with_precision;
 
-use crate::foundations::{func, Str, Value};
+use crate::foundations::{Str, Value, func};
 
 /// The Unicode minus sign.
 pub const MINUS_SIGN: &str = "\u{2212}";
diff --git a/crates/typst-library/src/foundations/scope.rs b/crates/typst-library/src/foundations/scope.rs
index 838584ccd..551e3dd78 100644
--- a/crates/typst-library/src/foundations/scope.rs
+++ b/crates/typst-library/src/foundations/scope.rs
@@ -1,12 +1,12 @@
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 
-use ecow::{eco_format, EcoString};
-use indexmap::map::Entry;
+use ecow::{EcoString, eco_format};
 use indexmap::IndexMap;
+use indexmap::map::Entry;
 use typst_syntax::Span;
 
-use crate::diag::{bail, DeprecationSink, HintedStrResult, HintedString, StrResult};
+use crate::diag::{DeprecationSink, HintedStrResult, HintedString, StrResult, bail};
 use crate::foundations::{
     Func, IntoValue, NativeElement, NativeFunc, NativeFuncData, NativeType, Value,
 };
diff --git a/crates/typst-library/src/foundations/selector.rs b/crates/typst-library/src/foundations/selector.rs
index b8e34eb95..7485a46ff 100644
--- a/crates/typst-library/src/foundations/selector.rs
+++ b/crates/typst-library/src/foundations/selector.rs
@@ -2,13 +2,13 @@ use std::any::{Any, TypeId};
 use std::sync::Arc;
 
 use comemo::Tracked;
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
 use smallvec::SmallVec;
 
-use crate::diag::{bail, HintedStrResult, StrResult};
+use crate::diag::{HintedStrResult, StrResult, bail};
 use crate::foundations::{
-    cast, func, repr, scope, ty, CastInfo, Content, Context, Dict, Element, FromValue,
-    Func, Label, Reflect, Regex, Repr, Str, StyleChain, Symbol, Type, Value,
+    CastInfo, Content, Context, Dict, Element, FromValue, Func, Label, Reflect, Regex,
+    Repr, Str, StyleChain, Symbol, Type, Value, cast, func, repr, scope, ty,
 };
 use crate::introspection::{Introspector, Locatable, Location, Unqueriable};
 
diff --git a/crates/typst-library/src/foundations/str.rs b/crates/typst-library/src/foundations/str.rs
index e500b1a4d..4299a9348 100644
--- a/crates/typst-library/src/foundations/str.rs
+++ b/crates/typst-library/src/foundations/str.rs
@@ -10,11 +10,11 @@ use typst_syntax::{Span, Spanned};
 use unicode_normalization::UnicodeNormalization;
 use unicode_segmentation::UnicodeSegmentation;
 
-use crate::diag::{bail, At, SourceResult, StrResult};
+use crate::diag::{At, SourceResult, StrResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, dict, func, repr, scope, ty, Array, Bytes, Cast, Context, Decimal, Dict, Func,
-    IntoValue, Label, Repr, Type, Value, Version,
+    Array, Bytes, Cast, Context, Decimal, Dict, Func, IntoValue, Label, Repr, Type,
+    Value, Version, cast, dict, func, repr, scope, ty,
 };
 use crate::layout::Alignment;
 
@@ -881,7 +881,11 @@ fn out_of_bounds(index: i64, len: usize) -> EcoString {
 /// The out of bounds access error message when no default value was given.
 #[cold]
 fn no_default_and_out_of_bounds(index: i64, len: usize) -> EcoString {
-    eco_format!("no default value was specified and string index out of bounds (index: {}, len: {})", index, len)
+    eco_format!(
+        "no default value was specified and string index out of bounds (index: {}, len: {})",
+        index,
+        len
+    )
 }
 
 /// The char boundary access error message.
diff --git a/crates/typst-library/src/foundations/styles.rs b/crates/typst-library/src/foundations/styles.rs
index 0da036f6f..74dd039de 100644
--- a/crates/typst-library/src/foundations/styles.rs
+++ b/crates/typst-library/src/foundations/styles.rs
@@ -5,7 +5,7 @@ use std::hash::{Hash, Hasher};
 use std::{mem, ptr};
 
 use comemo::Tracked;
-use ecow::{eco_vec, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_vec};
 use smallvec::SmallVec;
 use typst_syntax::Span;
 use typst_utils::LazyHash;
@@ -13,8 +13,8 @@ use typst_utils::LazyHash;
 use crate::diag::{SourceResult, Trace, Tracepoint};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, ty, Content, Context, Element, Field, Func, NativeElement, OneOrMultiple,
-    Packed, RefableProperty, Repr, Selector, SettableProperty, Target,
+    Content, Context, Element, Field, Func, NativeElement, OneOrMultiple, Packed,
+    RefableProperty, Repr, Selector, SettableProperty, Target, cast, ty,
 };
 use crate::text::{FontFamily, FontList, TextElem};
 
@@ -621,11 +621,7 @@ impl<'a> StyleChain<'a> {
             .properties(func, id)
             .map(|block| block.downcast::<T>(func, id).clone());
 
-        if let Some(folded) = iter.reduce(fold) {
-            fold(folded, default)
-        } else {
-            default
-        }
+        if let Some(folded) = iter.reduce(fold) { fold(folded, default) } else { default }
     }
 
     /// Iterate over all values for the given property in the chain.
diff --git a/crates/typst-library/src/foundations/symbol.rs b/crates/typst-library/src/foundations/symbol.rs
index f57bb0c2a..898068afb 100644
--- a/crates/typst-library/src/foundations/symbol.rs
+++ b/crates/typst-library/src/foundations/symbol.rs
@@ -3,15 +3,15 @@ use std::fmt::{self, Debug, Display, Formatter, Write};
 use std::sync::Arc;
 
 use codex::ModifierSet;
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use serde::{Serialize, Serializer};
-use typst_syntax::{is_ident, Span, Spanned};
+use typst_syntax::{Span, Spanned, is_ident};
 use typst_utils::hash128;
 
-use crate::diag::{bail, DeprecationSink, SourceResult, StrResult};
+use crate::diag::{DeprecationSink, SourceResult, StrResult, bail};
 use crate::foundations::{
-    cast, elem, func, scope, ty, Array, Content, Func, NativeElement, NativeFunc, Packed,
-    PlainText, Repr as _,
+    Array, Content, Func, NativeElement, NativeFunc, Packed, PlainText, Repr as _, cast,
+    elem, func, scope, ty,
 };
 
 /// A Unicode symbol.
diff --git a/crates/typst-library/src/foundations/target.rs b/crates/typst-library/src/foundations/target.rs
index ff90f1f7b..c020ac806 100644
--- a/crates/typst-library/src/foundations/target.rs
+++ b/crates/typst-library/src/foundations/target.rs
@@ -1,7 +1,7 @@
 use comemo::Tracked;
 
 use crate::diag::HintedStrResult;
-use crate::foundations::{elem, func, Cast, Context};
+use crate::foundations::{Cast, Context, elem, func};
 
 /// The export target.
 #[derive(Debug, Default, Copy, Clone, Eq, PartialEq, Hash, Cast)]
diff --git a/crates/typst-library/src/foundations/ty.rs b/crates/typst-library/src/foundations/ty.rs
index 9d7690283..2b59e2ce4 100644
--- a/crates/typst-library/src/foundations/ty.rs
+++ b/crates/typst-library/src/foundations/ty.rs
@@ -5,12 +5,12 @@ use std::cmp::Ordering;
 use std::fmt::{self, Debug, Display, Formatter};
 use std::sync::LazyLock;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_utils::Static;
 
-use crate::diag::{bail, DeprecationSink, StrResult};
+use crate::diag::{DeprecationSink, StrResult, bail};
 use crate::foundations::{
-    cast, func, AutoValue, Func, NativeFuncData, NoneValue, Repr, Scope, Value,
+    AutoValue, Func, NativeFuncData, NoneValue, Repr, Scope, Value, cast, func,
 };
 
 /// Describes a kind of value.
diff --git a/crates/typst-library/src/foundations/value.rs b/crates/typst-library/src/foundations/value.rs
index 4bcf2d4e3..f0acd5036 100644
--- a/crates/typst-library/src/foundations/value.rs
+++ b/crates/typst-library/src/foundations/value.rs
@@ -4,19 +4,19 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
 use serde::de::{Error, MapAccess, SeqAccess, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use typst_syntax::{ast, Span};
+use typst_syntax::{Span, ast};
 use typst_utils::ArcExt;
 
 use crate::diag::{DeprecationSink, HintedStrResult, HintedString, StrResult};
 use crate::foundations::{
-    fields, ops, repr, Args, Array, AutoValue, Bytes, CastInfo, Content, Datetime,
-    Decimal, Dict, Duration, Fold, FromValue, Func, IntoValue, Label, Module,
-    NativeElement, NativeType, NoneValue, Reflect, Repr, Resolve, Scope, Str, Styles,
-    Symbol, SymbolElem, Type, Version,
+    Args, Array, AutoValue, Bytes, CastInfo, Content, Datetime, Decimal, Dict, Duration,
+    Fold, FromValue, Func, IntoValue, Label, Module, NativeElement, NativeType,
+    NoneValue, Reflect, Repr, Resolve, Scope, Str, Styles, Symbol, SymbolElem, Type,
+    Version, fields, ops, repr,
 };
 use crate::layout::{Abs, Angle, Em, Fr, Length, Ratio, Rel};
 use crate::text::{RawContent, RawElem, TextElem};
diff --git a/crates/typst-library/src/foundations/version.rs b/crates/typst-library/src/foundations/version.rs
index 62c029179..71b0b7153 100644
--- a/crates/typst-library/src/foundations/version.rs
+++ b/crates/typst-library/src/foundations/version.rs
@@ -3,10 +3,10 @@ use std::fmt::{self, Display, Formatter, Write};
 use std::hash::Hash;
 use std::iter::repeat;
 
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
 
-use crate::diag::{bail, StrResult};
-use crate::foundations::{cast, func, repr, scope, ty, Repr};
+use crate::diag::{StrResult, bail};
+use crate::foundations::{Repr, cast, func, repr, scope, ty};
 
 /// A version with an arbitrary number of components.
 ///
diff --git a/crates/typst-library/src/introspection/counter.rs b/crates/typst-library/src/introspection/counter.rs
index b3c52de4e..f6083303d 100644
--- a/crates/typst-library/src/introspection/counter.rs
+++ b/crates/typst-library/src/introspection/counter.rs
@@ -2,24 +2,24 @@ use std::num::NonZeroUsize;
 use std::str::FromStr;
 
 use comemo::{Track, Tracked, TrackedMut};
-use ecow::{eco_format, eco_vec, EcoString, EcoVec};
-use smallvec::{smallvec, SmallVec};
+use ecow::{EcoString, EcoVec, eco_format, eco_vec};
+use smallvec::{SmallVec, smallvec};
 use typst_syntax::Span;
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, At, HintedStrResult, SourceResult};
+use crate::World;
+use crate::diag::{At, HintedStrResult, SourceResult, bail};
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
-    cast, elem, func, scope, select_where, ty, Args, Array, Construct, Content, Context,
-    Element, Func, IntoValue, Label, LocatableSelector, NativeElement, Packed, Repr,
-    Selector, ShowFn, Smart, Str, StyleChain, Value,
+    Args, Array, Construct, Content, Context, Element, Func, IntoValue, Label,
+    LocatableSelector, NativeElement, Packed, Repr, Selector, ShowFn, Smart, Str,
+    StyleChain, Value, cast, elem, func, scope, select_where, ty,
 };
 use crate::introspection::{Introspector, Locatable, Location, Tag};
 use crate::layout::{Frame, FrameItem, PageElem};
 use crate::math::EquationElem;
 use crate::model::{FigureElem, FootnoteElem, HeadingElem, Numbering, NumberingPattern};
 use crate::routines::Routines;
-use crate::World;
 
 /// Counts through pages, elements, and more.
 ///
diff --git a/crates/typst-library/src/introspection/here.rs b/crates/typst-library/src/introspection/here.rs
index 510093247..27cb56224 100644
--- a/crates/typst-library/src/introspection/here.rs
+++ b/crates/typst-library/src/introspection/here.rs
@@ -1,7 +1,7 @@
 use comemo::Tracked;
 
 use crate::diag::HintedStrResult;
-use crate::foundations::{func, Context};
+use crate::foundations::{Context, func};
 use crate::introspection::Location;
 
 /// Provides the current location in the document.
diff --git a/crates/typst-library/src/introspection/introspector.rs b/crates/typst-library/src/introspection/introspector.rs
index 76a0faa35..377b577fb 100644
--- a/crates/typst-library/src/introspection/introspector.rs
+++ b/crates/typst-library/src/introspection/introspector.rs
@@ -8,7 +8,7 @@ use ecow::{EcoString, EcoVec};
 use smallvec::SmallVec;
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, StrResult};
+use crate::diag::{StrResult, bail};
 use crate::foundations::{Content, Label, Repr, Selector};
 use crate::introspection::{Location, Tag};
 use crate::layout::{Frame, FrameItem, Point, Position, Transform};
diff --git a/crates/typst-library/src/introspection/locate.rs b/crates/typst-library/src/introspection/locate.rs
index 50f217851..4d386e033 100644
--- a/crates/typst-library/src/introspection/locate.rs
+++ b/crates/typst-library/src/introspection/locate.rs
@@ -2,7 +2,7 @@ use comemo::Tracked;
 
 use crate::diag::HintedStrResult;
 use crate::engine::Engine;
-use crate::foundations::{func, Context, LocatableSelector};
+use crate::foundations::{Context, LocatableSelector, func};
 use crate::introspection::Location;
 
 /// Determines the location of an element in the document.
diff --git a/crates/typst-library/src/introspection/location.rs b/crates/typst-library/src/introspection/location.rs
index 8f4caaec4..d0a6ec21c 100644
--- a/crates/typst-library/src/introspection/location.rs
+++ b/crates/typst-library/src/introspection/location.rs
@@ -4,7 +4,7 @@ use std::num::NonZeroUsize;
 use ecow::EcoString;
 
 use crate::engine::Engine;
-use crate::foundations::{func, scope, ty, Repr};
+use crate::foundations::{Repr, func, scope, ty};
 use crate::layout::Position;
 use crate::model::Numbering;
 
diff --git a/crates/typst-library/src/introspection/metadata.rs b/crates/typst-library/src/introspection/metadata.rs
index 8ad74b96b..5cc188ee2 100644
--- a/crates/typst-library/src/introspection/metadata.rs
+++ b/crates/typst-library/src/introspection/metadata.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Value};
+use crate::foundations::{Value, elem};
 use crate::introspection::Locatable;
 
 /// Exposes a value to the query system without producing visible content.
diff --git a/crates/typst-library/src/introspection/query.rs b/crates/typst-library/src/introspection/query.rs
index b742ac010..1691c0f0c 100644
--- a/crates/typst-library/src/introspection/query.rs
+++ b/crates/typst-library/src/introspection/query.rs
@@ -2,7 +2,7 @@ use comemo::Tracked;
 
 use crate::diag::HintedStrResult;
 use crate::engine::Engine;
-use crate::foundations::{func, Array, Context, LocatableSelector, Value};
+use crate::foundations::{Array, Context, LocatableSelector, Value, func};
 
 /// Finds elements in the document.
 ///
diff --git a/crates/typst-library/src/introspection/state.rs b/crates/typst-library/src/introspection/state.rs
index 2d15a5de0..c7d1a5be5 100644
--- a/crates/typst-library/src/introspection/state.rs
+++ b/crates/typst-library/src/introspection/state.rs
@@ -1,16 +1,16 @@
 use comemo::{Track, Tracked, TrackedMut};
-use ecow::{eco_format, eco_vec, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format, eco_vec};
 use typst_syntax::Span;
 
-use crate::diag::{bail, At, SourceResult};
+use crate::World;
+use crate::diag::{At, SourceResult, bail};
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
-    cast, elem, func, scope, select_where, ty, Args, Construct, Content, Context, Func,
-    LocatableSelector, NativeElement, Repr, Selector, Str, Value,
+    Args, Construct, Content, Context, Func, LocatableSelector, NativeElement, Repr,
+    Selector, Str, Value, cast, elem, func, scope, select_where, ty,
 };
 use crate::introspection::{Introspector, Locatable, Location};
 use crate::routines::Routines;
-use crate::World;
 
 /// Manages stateful parts of your document.
 ///
diff --git a/crates/typst-library/src/introspection/tag.rs b/crates/typst-library/src/introspection/tag.rs
index b2bae28e4..8df9e0176 100644
--- a/crates/typst-library/src/introspection/tag.rs
+++ b/crates/typst-library/src/introspection/tag.rs
@@ -1,9 +1,9 @@
 use std::fmt::{self, Debug, Formatter};
 
-use crate::diag::{bail, SourceResult};
+use crate::diag::{SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Args, Construct, Content, NativeElement, Packed, Unlabellable,
+    Args, Construct, Content, NativeElement, Packed, Unlabellable, elem,
 };
 use crate::introspection::Location;
 
diff --git a/crates/typst-library/src/layout/abs.rs b/crates/typst-library/src/layout/abs.rs
index e19b037aa..c9844ed4c 100644
--- a/crates/typst-library/src/layout/abs.rs
+++ b/crates/typst-library/src/layout/abs.rs
@@ -5,7 +5,7 @@ use std::ops::{Add, Div, Mul, Neg, Rem};
 use ecow::EcoString;
 use typst_utils::{Numeric, Scalar};
 
-use crate::foundations::{cast, repr, Fold, Repr, Value};
+use crate::foundations::{Fold, Repr, Value, cast, repr};
 
 /// An absolute length.
 #[derive(Default, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
diff --git a/crates/typst-library/src/layout/align.rs b/crates/typst-library/src/layout/align.rs
index 447648f01..4ce195f81 100644
--- a/crates/typst-library/src/layout/align.rs
+++ b/crates/typst-library/src/layout/align.rs
@@ -1,11 +1,11 @@
 use std::ops::Add;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 
-use crate::diag::{bail, HintedStrResult, StrResult};
+use crate::diag::{HintedStrResult, StrResult, bail};
 use crate::foundations::{
-    cast, elem, func, scope, ty, CastInfo, Content, Fold, FromValue, IntoValue, Reflect,
-    Repr, Resolve, StyleChain, Value,
+    CastInfo, Content, Fold, FromValue, IntoValue, Reflect, Repr, Resolve, StyleChain,
+    Value, cast, elem, func, scope, ty,
 };
 use crate::layout::{Abs, Axes, Axis, Dir, Side};
 use crate::text::TextElem;
diff --git a/crates/typst-library/src/layout/angle.rs b/crates/typst-library/src/layout/angle.rs
index d14107860..6ace7cf69 100644
--- a/crates/typst-library/src/layout/angle.rs
+++ b/crates/typst-library/src/layout/angle.rs
@@ -6,7 +6,7 @@ use std::ops::{Add, Div, Mul, Neg};
 use ecow::EcoString;
 use typst_utils::{Numeric, Scalar};
 
-use crate::foundations::{func, repr, scope, ty, Repr};
+use crate::foundations::{Repr, func, repr, scope, ty};
 
 /// An angle describing a rotation.
 ///
diff --git a/crates/typst-library/src/layout/axes.rs b/crates/typst-library/src/layout/axes.rs
index e4303f98b..ec2b16744 100644
--- a/crates/typst-library/src/layout/axes.rs
+++ b/crates/typst-library/src/layout/axes.rs
@@ -4,10 +4,10 @@ use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, Deref, Not};
 
 use typst_utils::Get;
 
-use crate::diag::{bail, HintedStrResult};
+use crate::diag::{HintedStrResult, bail};
 use crate::foundations::{
-    array, cast, Array, CastInfo, FromValue, IntoValue, Reflect, Resolve, Smart,
-    StyleChain, Value,
+    Array, CastInfo, FromValue, IntoValue, Reflect, Resolve, Smart, StyleChain, Value,
+    array, cast,
 };
 use crate::layout::{Abs, Dir, Rel, Size};
 
diff --git a/crates/typst-library/src/layout/columns.rs b/crates/typst-library/src/layout/columns.rs
index e7bce393b..3452f17d4 100644
--- a/crates/typst-library/src/layout/columns.rs
+++ b/crates/typst-library/src/layout/columns.rs
@@ -1,6 +1,6 @@
 use std::num::NonZeroUsize;
 
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 use crate::layout::{Length, Ratio, Rel};
 
 /// Separates a region into multiple equally sized columns.
diff --git a/crates/typst-library/src/layout/container.rs b/crates/typst-library/src/layout/container.rs
index cff66fe38..084d07bf4 100644
--- a/crates/typst-library/src/layout/container.rs
+++ b/crates/typst-library/src/layout/container.rs
@@ -1,8 +1,8 @@
-use crate::diag::{bail, SourceResult};
+use crate::diag::{SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Args, AutoValue, Construct, Content, NativeElement, Packed, Smart,
-    StyleChain, Value,
+    Args, AutoValue, Construct, Content, NativeElement, Packed, Smart, StyleChain, Value,
+    cast, elem,
 };
 use crate::introspection::Locator;
 use crate::layout::{
diff --git a/crates/typst-library/src/layout/corners.rs b/crates/typst-library/src/layout/corners.rs
index e47fee1e7..f822a45cb 100644
--- a/crates/typst-library/src/layout/corners.rs
+++ b/crates/typst-library/src/layout/corners.rs
@@ -151,9 +151,10 @@ where
 {
     fn into_value(self) -> Value {
         if self.is_uniform()
-            && let Some(top_left) = self.top_left {
-                return top_left.into_value();
-            }
+            && let Some(top_left) = self.top_left
+        {
+            return top_left.into_value();
+        }
 
         let mut dict = Dict::new();
         let mut handle = |key: &str, component: Option<T>| {
diff --git a/crates/typst-library/src/layout/dir.rs b/crates/typst-library/src/layout/dir.rs
index 699c8c481..c4559477b 100644
--- a/crates/typst-library/src/layout/dir.rs
+++ b/crates/typst-library/src/layout/dir.rs
@@ -1,6 +1,6 @@
 use ecow::EcoString;
 
-use crate::foundations::{func, scope, ty, Repr};
+use crate::foundations::{Repr, func, scope, ty};
 use crate::layout::{Axis, Side};
 
 /// The four directions into which content can be laid out.
diff --git a/crates/typst-library/src/layout/em.rs b/crates/typst-library/src/layout/em.rs
index 460bf5fa7..3dbda7550 100644
--- a/crates/typst-library/src/layout/em.rs
+++ b/crates/typst-library/src/layout/em.rs
@@ -5,7 +5,7 @@ use std::ops::{Add, Div, Mul, Neg};
 use ecow::EcoString;
 use typst_utils::{Numeric, Scalar};
 
-use crate::foundations::{cast, repr, Repr, Resolve, StyleChain, Value};
+use crate::foundations::{Repr, Resolve, StyleChain, Value, cast, repr};
 use crate::layout::{Abs, Length};
 use crate::text::TextElem;
 
@@ -39,11 +39,7 @@ impl Em {
     /// Creates an em length from an absolute length at the given font size.
     pub fn from_abs(length: Abs, font_size: Abs) -> Self {
         let result = length / font_size;
-        if result.is_finite() {
-            Self(Scalar::new(result))
-        } else {
-            Self::zero()
-        }
+        if result.is_finite() { Self(Scalar::new(result)) } else { Self::zero() }
     }
 
     /// Creates an em length from a length at the given font size.
@@ -64,11 +60,7 @@ impl Em {
     /// Converts 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() {
-            resolved
-        } else {
-            Abs::zero()
-        }
+        if resolved.is_finite() { resolved } else { Abs::zero() }
     }
 }
 
@@ -164,10 +156,6 @@ impl Resolve for Em {
     type Output = Abs;
 
     fn resolve(self, styles: StyleChain) -> Self::Output {
-        if self.is_zero() {
-            Abs::zero()
-        } else {
-            self.at(styles.resolve(TextElem::size))
-        }
+        if self.is_zero() { Abs::zero() } else { self.at(styles.resolve(TextElem::size)) }
     }
 }
diff --git a/crates/typst-library/src/layout/fr.rs b/crates/typst-library/src/layout/fr.rs
index ff8a6e6b1..f76d32f96 100644
--- a/crates/typst-library/src/layout/fr.rs
+++ b/crates/typst-library/src/layout/fr.rs
@@ -5,7 +5,7 @@ use std::ops::{Add, Div, Mul, Neg};
 use ecow::EcoString;
 use typst_utils::{Numeric, Scalar};
 
-use crate::foundations::{repr, ty, Repr};
+use crate::foundations::{Repr, repr, ty};
 use crate::layout::Abs;
 
 /// Defines how the remaining space in a layout is distributed.
diff --git a/crates/typst-library/src/layout/frame.rs b/crates/typst-library/src/layout/frame.rs
index a26a7d0ef..7dfeb6e49 100644
--- a/crates/typst-library/src/layout/frame.rs
+++ b/crates/typst-library/src/layout/frame.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use typst_syntax::Span;
 use typst_utils::{LazyHash, Numeric};
 
-use crate::foundations::{cast, dict, Dict, Label, Value};
+use crate::foundations::{Dict, Label, Value, cast, dict};
 use crate::introspection::{Location, Tag};
 use crate::layout::{Abs, Axes, FixedAlignment, Length, Point, Size, Transform};
 use crate::model::Destination;
diff --git a/crates/typst-library/src/layout/grid/mod.rs b/crates/typst-library/src/layout/grid/mod.rs
index 658523ec6..de540a578 100644
--- a/crates/typst-library/src/layout/grid/mod.rs
+++ b/crates/typst-library/src/layout/grid/mod.rs
@@ -4,14 +4,14 @@ use std::num::{NonZeroU32, NonZeroUsize};
 use std::sync::Arc;
 
 use comemo::Track;
-use smallvec::{smallvec, SmallVec};
+use smallvec::{SmallVec, smallvec};
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, At, HintedStrResult, HintedString, SourceResult};
+use crate::diag::{At, HintedStrResult, HintedString, SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, Array, CastInfo, Content, Context, Fold, FromValue, Func,
-    IntoValue, Packed, Reflect, Resolve, Smart, StyleChain, Value,
+    Array, CastInfo, Content, Context, Fold, FromValue, Func, IntoValue, Packed, Reflect,
+    Resolve, Smart, StyleChain, Value, cast, elem, scope,
 };
 use crate::layout::{
     Alignment, Length, OuterHAlignment, OuterVAlignment, Rel, Sides, Sizing,
diff --git a/crates/typst-library/src/layout/grid/resolve.rs b/crates/typst-library/src/layout/grid/resolve.rs
index edf50cdd2..b7d2ffa6c 100644
--- a/crates/typst-library/src/layout/grid/resolve.rs
+++ b/crates/typst-library/src/layout/grid/resolve.rs
@@ -3,8 +3,9 @@ use std::ops::{Deref, DerefMut, Range};
 use std::sync::Arc;
 
 use ecow::eco_format;
+use typst_library::Dir;
 use typst_library::diag::{
-    bail, At, Hint, HintedStrResult, HintedString, SourceResult, Trace, Tracepoint,
+    At, Hint, HintedStrResult, HintedString, SourceResult, Trace, Tracepoint, bail,
 };
 use typst_library::engine::Engine;
 use typst_library::foundations::{Content, Fold, Packed, Smart, StyleChain};
@@ -16,7 +17,6 @@ use typst_library::layout::{
 use typst_library::model::{TableCell, TableChild, TableElem, TableItem};
 use typst_library::text::TextElem;
 use typst_library::visualize::{Paint, Stroke};
-use typst_library::Dir;
 
 use typst_syntax::Span;
 use typst_utils::NonZeroExt;
@@ -495,11 +495,7 @@ impl<T> Repeatable<T> {
     /// Returns `Some` if the value is repeated, `None` otherwise.
     #[inline]
     pub fn as_repeated(&self) -> Option<&T> {
-        if self.repeated {
-            Some(&self.inner)
-        } else {
-            None
-        }
+        if self.repeated { Some(&self.inner) } else { None }
     }
 }
 
@@ -858,22 +854,14 @@ impl<'a> CellGrid<'a> {
     /// might span if the grid has gutters.
     #[inline]
     pub fn effective_colspan_of_cell(&self, cell: &Cell) -> usize {
-        if self.has_gutter {
-            2 * cell.colspan.get() - 1
-        } else {
-            cell.colspan.get()
-        }
+        if self.has_gutter { 2 * cell.colspan.get() - 1 } else { cell.colspan.get() }
     }
 
     /// Returns the effective rowspan of a cell, considering the gutters it
     /// might span if the grid has gutters.
     #[inline]
     pub fn effective_rowspan_of_cell(&self, cell: &Cell) -> usize {
-        if self.has_gutter {
-            2 * cell.rowspan.get() - 1
-        } else {
-            cell.rowspan.get()
-        }
+        if self.has_gutter { 2 * cell.rowspan.get() - 1 } else { cell.rowspan.get() }
     }
 
     #[inline]
@@ -2099,12 +2087,14 @@ fn check_for_conflicting_cell_row(
     }
 
     if let Some((_, _, footer)) = footer
-        && cell_y < footer.end && cell_y + rowspan > footer.start {
-            bail!(
-                "cell would conflict with footer spanning the same position";
-                hint: "try reducing the cell's rowspan or moving the footer"
-            );
-        }
+        && cell_y < footer.end
+        && cell_y + rowspan > footer.start
+    {
+        bail!(
+            "cell would conflict with footer spanning the same position";
+            hint: "try reducing the cell's rowspan or moving the footer"
+        );
+    }
 
     Ok(())
 }
diff --git a/crates/typst-library/src/layout/hide.rs b/crates/typst-library/src/layout/hide.rs
index bb40447d5..7e096eaa9 100644
--- a/crates/typst-library/src/layout/hide.rs
+++ b/crates/typst-library/src/layout/hide.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 
 /// Hides content without affecting layout.
 ///
diff --git a/crates/typst-library/src/layout/layout.rs b/crates/typst-library/src/layout/layout.rs
index 00897bcfe..8855813c1 100644
--- a/crates/typst-library/src/layout/layout.rs
+++ b/crates/typst-library/src/layout/layout.rs
@@ -1,6 +1,6 @@
 use typst_syntax::Span;
 
-use crate::foundations::{elem, func, Content, Func, NativeElement};
+use crate::foundations::{Content, Func, NativeElement, elem, func};
 use crate::introspection::Locatable;
 
 /// Provides access to the current outer container's (or page's, if none)
diff --git a/crates/typst-library/src/layout/length.rs b/crates/typst-library/src/layout/length.rs
index 800140c47..76ee2ce56 100644
--- a/crates/typst-library/src/layout/length.rs
+++ b/crates/typst-library/src/layout/length.rs
@@ -3,12 +3,12 @@ use std::fmt::{self, Debug, Formatter};
 use std::ops::{Add, Div, Mul, Neg};
 
 use comemo::Tracked;
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_syntax::Span;
 use typst_utils::Numeric;
 
-use crate::diag::{bail, HintedStrResult, SourceResult};
-use crate::foundations::{func, scope, ty, Context, Fold, Repr, Resolve, StyleChain};
+use crate::diag::{HintedStrResult, SourceResult, bail};
+use crate::foundations::{Context, Fold, Repr, Resolve, StyleChain, func, scope, ty};
 use crate::layout::{Abs, Em};
 
 /// A size or distance, possibly expressed with contextual units.
diff --git a/crates/typst-library/src/layout/measure.rs b/crates/typst-library/src/layout/measure.rs
index 93c48ad40..aa7f3c7c4 100644
--- a/crates/typst-library/src/layout/measure.rs
+++ b/crates/typst-library/src/layout/measure.rs
@@ -3,7 +3,7 @@ use typst_syntax::Span;
 
 use crate::diag::{At, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{dict, func, Content, Context, Dict, Resolve, Smart};
+use crate::foundations::{Content, Context, Dict, Resolve, Smart, dict, func};
 use crate::introspection::{Locator, LocatorLink};
 use crate::layout::{Abs, Axes, Length, Region, Size};
 
diff --git a/crates/typst-library/src/layout/pad.rs b/crates/typst-library/src/layout/pad.rs
index d533df35b..8279c4e2d 100644
--- a/crates/typst-library/src/layout/pad.rs
+++ b/crates/typst-library/src/layout/pad.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 use crate::layout::{Length, Rel};
 
 /// Adds spacing around content.
diff --git a/crates/typst-library/src/layout/page.rs b/crates/typst-library/src/layout/page.rs
index ab8cc8ea4..64ed99e34 100644
--- a/crates/typst-library/src/layout/page.rs
+++ b/crates/typst-library/src/layout/page.rs
@@ -2,13 +2,13 @@ use std::num::NonZeroUsize;
 use std::ops::RangeInclusive;
 use std::str::FromStr;
 
-use typst_utils::{singleton, NonZeroExt, Scalar};
+use typst_utils::{NonZeroExt, Scalar, singleton};
 
-use crate::diag::{bail, SourceResult};
+use crate::diag::{SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Args, AutoValue, Cast, Construct, Content, Dict, Fold, NativeElement,
-    Set, Smart, Value,
+    Args, AutoValue, Cast, Construct, Content, Dict, Fold, NativeElement, Set, Smart,
+    Value, cast, elem,
 };
 use crate::introspection::Introspector;
 use crate::layout::{
diff --git a/crates/typst-library/src/layout/place.rs b/crates/typst-library/src/layout/place.rs
index b6c4a0cc1..4c92a8d9f 100644
--- a/crates/typst-library/src/layout/place.rs
+++ b/crates/typst-library/src/layout/place.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, scope, Cast, Content, Packed, Smart};
+use crate::foundations::{Cast, Content, Packed, Smart, elem, scope};
 use crate::introspection::{Locatable, Unqueriable};
 use crate::layout::{Alignment, Em, Length, Rel};
 
diff --git a/crates/typst-library/src/layout/ratio.rs b/crates/typst-library/src/layout/ratio.rs
index cf826c2b5..bb36045a8 100644
--- a/crates/typst-library/src/layout/ratio.rs
+++ b/crates/typst-library/src/layout/ratio.rs
@@ -4,7 +4,7 @@ use std::ops::{Add, Div, Mul, Neg};
 use ecow::EcoString;
 use typst_utils::{Numeric, Scalar};
 
-use crate::foundations::{repr, ty, Repr};
+use crate::foundations::{Repr, repr, ty};
 
 /// A ratio of a whole.
 ///
@@ -80,11 +80,7 @@ impl Ratio {
     /// Return the ratio of the given `whole`.
     pub fn of<T: Numeric>(self, whole: T) -> T {
         let resolved = whole * self.get();
-        if resolved.is_finite() {
-            resolved
-        } else {
-            T::zero()
-        }
+        if resolved.is_finite() { resolved } else { T::zero() }
     }
 }
 
diff --git a/crates/typst-library/src/layout/rel.rs b/crates/typst-library/src/layout/rel.rs
index 7fe5d9c05..5569a762c 100644
--- a/crates/typst-library/src/layout/rel.rs
+++ b/crates/typst-library/src/layout/rel.rs
@@ -2,10 +2,10 @@ use std::cmp::Ordering;
 use std::fmt::{self, Debug, Formatter};
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_utils::Numeric;
 
-use crate::foundations::{cast, ty, Fold, Repr, Resolve, StyleChain};
+use crate::foundations::{Fold, Repr, Resolve, StyleChain, cast, ty};
 use crate::layout::{Abs, Em, Length, Ratio};
 
 /// A length in relation to some known length.
diff --git a/crates/typst-library/src/layout/repeat.rs b/crates/typst-library/src/layout/repeat.rs
index a38d5f896..ef7a5bb05 100644
--- a/crates/typst-library/src/layout/repeat.rs
+++ b/crates/typst-library/src/layout/repeat.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 use crate::layout::Length;
 
 /// Repeats content to the available space.
diff --git a/crates/typst-library/src/layout/sides.rs b/crates/typst-library/src/layout/sides.rs
index 1147eeb77..fc2f1114e 100644
--- a/crates/typst-library/src/layout/sides.rs
+++ b/crates/typst-library/src/layout/sides.rs
@@ -3,10 +3,10 @@ use std::ops::Add;
 
 use typst_utils::Get;
 
-use crate::diag::{bail, HintedStrResult};
+use crate::diag::{HintedStrResult, bail};
 use crate::foundations::{
-    cast, AlternativeFold, CastInfo, Dict, Fold, FromValue, IntoValue, Reflect, Resolve,
-    StyleChain, Value,
+    AlternativeFold, CastInfo, Dict, Fold, FromValue, IntoValue, Reflect, Resolve,
+    StyleChain, Value, cast,
 };
 use crate::layout::{Abs, Alignment, Axes, Axis, Corner, Rel, Size};
 
@@ -185,9 +185,10 @@ where
 {
     fn into_value(self) -> Value {
         if self.is_uniform()
-            && let Some(left) = self.left {
-                return left.into_value();
-            }
+            && let Some(left) = self.left
+        {
+            return left.into_value();
+        }
 
         let mut dict = Dict::new();
         let mut handle = |key: &str, component: Option<T>| {
diff --git a/crates/typst-library/src/layout/spacing.rs b/crates/typst-library/src/layout/spacing.rs
index b3ca1e812..8549c6b97 100644
--- a/crates/typst-library/src/layout/spacing.rs
+++ b/crates/typst-library/src/layout/spacing.rs
@@ -1,6 +1,6 @@
 use typst_utils::Numeric;
 
-use crate::foundations::{cast, elem, Content};
+use crate::foundations::{Content, cast, elem};
 use crate::layout::{Abs, Em, Fr, Length, Ratio, Rel};
 
 /// Inserts horizontal spacing into a paragraph.
diff --git a/crates/typst-library/src/layout/stack.rs b/crates/typst-library/src/layout/stack.rs
index fca1ecb86..90e55ca35 100644
--- a/crates/typst-library/src/layout/stack.rs
+++ b/crates/typst-library/src/layout/stack.rs
@@ -1,6 +1,6 @@
 use std::fmt::{self, Debug, Formatter};
 
-use crate::foundations::{cast, elem, Content};
+use crate::foundations::{Content, cast, elem};
 use crate::layout::{Dir, Spacing};
 
 /// Arranges content and spacing horizontally or vertically.
diff --git a/crates/typst-library/src/layout/transform.rs b/crates/typst-library/src/layout/transform.rs
index c2d9a21c7..8543e6146 100644
--- a/crates/typst-library/src/layout/transform.rs
+++ b/crates/typst-library/src/layout/transform.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{cast, elem, Content, Smart};
+use crate::foundations::{Content, Smart, cast, elem};
 use crate::layout::{Abs, Alignment, Angle, HAlignment, Length, Ratio, Rel, VAlignment};
 
 /// Moves content without affecting layout.
diff --git a/crates/typst-library/src/loading/cbor.rs b/crates/typst-library/src/loading/cbor.rs
index d95f73844..f6661395c 100644
--- a/crates/typst-library/src/loading/cbor.rs
+++ b/crates/typst-library/src/loading/cbor.rs
@@ -3,7 +3,7 @@ use typst_syntax::Spanned;
 
 use crate::diag::{At, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{func, scope, Bytes, Value};
+use crate::foundations::{Bytes, Value, func, scope};
 use crate::loading::{DataSource, Load};
 
 /// Reads structured data from a CBOR file.
diff --git a/crates/typst-library/src/loading/csv.rs b/crates/typst-library/src/loading/csv.rs
index d5b54a06c..a12eb9766 100644
--- a/crates/typst-library/src/loading/csv.rs
+++ b/crates/typst-library/src/loading/csv.rs
@@ -1,9 +1,9 @@
 use az::SaturatingAs;
 use typst_syntax::Spanned;
 
-use crate::diag::{bail, LineCol, LoadError, LoadedWithin, ReportPos, SourceResult};
+use crate::diag::{LineCol, LoadError, LoadedWithin, ReportPos, SourceResult, bail};
 use crate::engine::Engine;
-use crate::foundations::{cast, func, scope, Array, Dict, IntoValue, Type, Value};
+use crate::foundations::{Array, Dict, IntoValue, Type, Value, cast, func, scope};
 use crate::loading::{DataSource, Load, Readable};
 
 /// Reads structured data from a CSV file.
diff --git a/crates/typst-library/src/loading/json.rs b/crates/typst-library/src/loading/json.rs
index 7d0732ba0..a503825b4 100644
--- a/crates/typst-library/src/loading/json.rs
+++ b/crates/typst-library/src/loading/json.rs
@@ -3,7 +3,7 @@ use typst_syntax::Spanned;
 
 use crate::diag::{At, LineCol, LoadError, LoadedWithin, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{func, scope, Str, Value};
+use crate::foundations::{Str, Value, func, scope};
 use crate::loading::{DataSource, Load, Readable};
 
 /// Reads structured data from a JSON file.
diff --git a/crates/typst-library/src/loading/mod.rs b/crates/typst-library/src/loading/mod.rs
index 67f4be834..172248b74 100644
--- a/crates/typst-library/src/loading/mod.rs
+++ b/crates/typst-library/src/loading/mod.rs
@@ -27,10 +27,10 @@ pub use self::toml_::*;
 pub use self::xml_::*;
 pub use self::yaml_::*;
 
+use crate::World;
 use crate::diag::{At, SourceResult};
 use crate::foundations::OneOrMultiple;
-use crate::foundations::{cast, Bytes, Scope, Str};
-use crate::World;
+use crate::foundations::{Bytes, Scope, Str, cast};
 
 /// Hook up all `data-loading` definitions.
 pub(super) fn define(global: &mut Scope) {
diff --git a/crates/typst-library/src/loading/read.rs b/crates/typst-library/src/loading/read.rs
index 91e6e4366..d003f1d38 100644
--- a/crates/typst-library/src/loading/read.rs
+++ b/crates/typst-library/src/loading/read.rs
@@ -3,7 +3,7 @@ use typst_syntax::Spanned;
 
 use crate::diag::{LoadedWithin, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{func, Cast};
+use crate::foundations::{Cast, func};
 use crate::loading::{DataSource, Load, Readable};
 
 /// Reads plain text or data from a file.
diff --git a/crates/typst-library/src/loading/toml.rs b/crates/typst-library/src/loading/toml.rs
index a4252feca..a14162d6b 100644
--- a/crates/typst-library/src/loading/toml.rs
+++ b/crates/typst-library/src/loading/toml.rs
@@ -3,7 +3,7 @@ use typst_syntax::Spanned;
 
 use crate::diag::{At, LoadError, LoadedWithin, ReportPos, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{func, scope, Str, Value};
+use crate::foundations::{Str, Value, func, scope};
 use crate::loading::{DataSource, Load, Readable};
 
 /// Reads structured data from a TOML file.
diff --git a/crates/typst-library/src/loading/xml.rs b/crates/typst-library/src/loading/xml.rs
index 0023c5df5..9a6197df7 100644
--- a/crates/typst-library/src/loading/xml.rs
+++ b/crates/typst-library/src/loading/xml.rs
@@ -1,9 +1,9 @@
 use roxmltree::ParsingOptions;
 use typst_syntax::Spanned;
 
-use crate::diag::{format_xml_like_error, LoadError, LoadedWithin, SourceResult};
+use crate::diag::{LoadError, LoadedWithin, SourceResult, format_xml_like_error};
 use crate::engine::Engine;
-use crate::foundations::{dict, func, scope, Array, Dict, IntoValue, Str, Value};
+use crate::foundations::{Array, Dict, IntoValue, Str, Value, dict, func, scope};
 use crate::loading::{DataSource, Load, Readable};
 
 /// Reads structured data from an XML file.
diff --git a/crates/typst-library/src/loading/yaml.rs b/crates/typst-library/src/loading/yaml.rs
index 0edf1f901..e26438cf5 100644
--- a/crates/typst-library/src/loading/yaml.rs
+++ b/crates/typst-library/src/loading/yaml.rs
@@ -3,7 +3,7 @@ use typst_syntax::Spanned;
 
 use crate::diag::{At, LineCol, LoadError, LoadedWithin, ReportPos, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{func, scope, Str, Value};
+use crate::foundations::{Str, Value, func, scope};
 use crate::loading::{DataSource, Load, Readable};
 
 /// Reads structured data from a YAML file.
diff --git a/crates/typst-library/src/math/accent.rs b/crates/typst-library/src/math/accent.rs
index 5a9c47aea..79e223042 100644
--- a/crates/typst-library/src/math/accent.rs
+++ b/crates/typst-library/src/math/accent.rs
@@ -1,12 +1,12 @@
 use std::sync::LazyLock;
 
-use icu_properties::maps::CodePointMapData;
 use icu_properties::CanonicalCombiningClass;
+use icu_properties::maps::CodePointMapData;
 use icu_provider::AsDeserializingBufferProvider;
 use icu_provider_blob::BlobDataProvider;
 
 use crate::diag::bail;
-use crate::foundations::{cast, elem, func, Content, NativeElement, SymbolElem};
+use crate::foundations::{Content, NativeElement, SymbolElem, cast, elem, func};
 use crate::layout::{Length, Rel};
 use crate::math::Mathy;
 
diff --git a/crates/typst-library/src/math/attach.rs b/crates/typst-library/src/math/attach.rs
index 0dda1d33d..ddcd63d7f 100644
--- a/crates/typst-library/src/math/attach.rs
+++ b/crates/typst-library/src/math/attach.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content, Packed};
+use crate::foundations::{Content, Packed, elem};
 use crate::layout::{Length, Rel};
 use crate::math::{EquationElem, Mathy};
 
diff --git a/crates/typst-library/src/math/cancel.rs b/crates/typst-library/src/math/cancel.rs
index 886370954..415e7ee7e 100644
--- a/crates/typst-library/src/math/cancel.rs
+++ b/crates/typst-library/src/math/cancel.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{cast, elem, Content, Func, Smart};
+use crate::foundations::{Content, Func, Smart, cast, elem};
 use crate::layout::{Abs, Angle, Length, Ratio, Rel};
 use crate::math::Mathy;
 use crate::visualize::Stroke;
diff --git a/crates/typst-library/src/math/equation.rs b/crates/typst-library/src/math/equation.rs
index db5253834..45831f52c 100644
--- a/crates/typst-library/src/math/equation.rs
+++ b/crates/typst-library/src/math/equation.rs
@@ -7,7 +7,7 @@ use unicode_math_class::MathClass;
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles, Synthesize,
+    Content, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles, Synthesize, elem,
 };
 use crate::introspection::{Count, Counter, CounterUpdate, Locatable};
 use crate::layout::{
diff --git a/crates/typst-library/src/math/frac.rs b/crates/typst-library/src/math/frac.rs
index dd5986b5f..b10b5b183 100644
--- a/crates/typst-library/src/math/frac.rs
+++ b/crates/typst-library/src/math/frac.rs
@@ -1,7 +1,7 @@
 use typst_syntax::Spanned;
 
 use crate::diag::bail;
-use crate::foundations::{elem, Content, Value};
+use crate::foundations::{Content, Value, elem};
 use crate::math::Mathy;
 
 /// A mathematical fraction.
diff --git a/crates/typst-library/src/math/lr.rs b/crates/typst-library/src/math/lr.rs
index 5f5cb8616..19fe1efdc 100644
--- a/crates/typst-library/src/math/lr.rs
+++ b/crates/typst-library/src/math/lr.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, func, Content, NativeElement, SymbolElem};
+use crate::foundations::{Content, NativeElement, SymbolElem, elem, func};
 use crate::layout::{Length, Rel};
 use crate::math::Mathy;
 
diff --git a/crates/typst-library/src/math/matrix.rs b/crates/typst-library/src/math/matrix.rs
index 2a51caefd..440f62aa1 100644
--- a/crates/typst-library/src/math/matrix.rs
+++ b/crates/typst-library/src/math/matrix.rs
@@ -1,12 +1,12 @@
-use smallvec::{smallvec, SmallVec};
+use smallvec::{SmallVec, smallvec};
 use typst_syntax::Spanned;
-use typst_utils::{default_math_class, Numeric};
+use typst_utils::{Numeric, default_math_class};
 use unicode_math_class::MathClass;
 
-use crate::diag::{bail, At, HintedStrResult, StrResult};
+use crate::diag::{At, HintedStrResult, StrResult, bail};
 use crate::foundations::{
-    array, cast, dict, elem, Array, Content, Dict, Fold, NoneValue, Resolve, Smart,
-    StyleChain, Symbol, Value,
+    Array, Content, Dict, Fold, NoneValue, Resolve, Smart, StyleChain, Symbol, Value,
+    array, cast, dict, elem,
 };
 use crate::layout::{Abs, Em, HAlignment, Length, Rel};
 use crate::math::Mathy;
diff --git a/crates/typst-library/src/math/mod.rs b/crates/typst-library/src/math/mod.rs
index 3d39e2fd2..c560b81ec 100644
--- a/crates/typst-library/src/math/mod.rs
+++ b/crates/typst-library/src/math/mod.rs
@@ -27,7 +27,7 @@ pub use self::underover::*;
 use typst_utils::singleton;
 use unicode_math_class::MathClass;
 
-use crate::foundations::{elem, Content, Module, NativeElement, Scope};
+use crate::foundations::{Content, Module, NativeElement, Scope, elem};
 use crate::layout::{Em, HElem};
 use crate::text::TextElem;
 
diff --git a/crates/typst-library/src/math/op.rs b/crates/typst-library/src/math/op.rs
index 55696e534..06aa00673 100644
--- a/crates/typst-library/src/math/op.rs
+++ b/crates/typst-library/src/math/op.rs
@@ -1,8 +1,8 @@
 use ecow::EcoString;
 
-use crate::foundations::{elem, Content, NativeElement, Scope, SymbolElem};
+use crate::foundations::{Content, NativeElement, Scope, SymbolElem, elem};
 use crate::layout::HElem;
-use crate::math::{upright, Mathy, THIN};
+use crate::math::{Mathy, THIN, upright};
 use crate::text::TextElem;
 
 /// A text operator in an equation.
diff --git a/crates/typst-library/src/math/root.rs b/crates/typst-library/src/math/root.rs
index ad111700b..52629803a 100644
--- a/crates/typst-library/src/math/root.rs
+++ b/crates/typst-library/src/math/root.rs
@@ -1,6 +1,6 @@
 use typst_syntax::Span;
 
-use crate::foundations::{elem, func, Content, NativeElement};
+use crate::foundations::{Content, NativeElement, elem, func};
 use crate::math::Mathy;
 
 /// A square root.
diff --git a/crates/typst-library/src/math/style.rs b/crates/typst-library/src/math/style.rs
index 6a85fd123..f8ffb9b1f 100644
--- a/crates/typst-library/src/math/style.rs
+++ b/crates/typst-library/src/math/style.rs
@@ -1,6 +1,6 @@
 use codex::styling::MathVariant;
 
-use crate::foundations::{func, Cast, Content};
+use crate::foundations::{Cast, Content, func};
 use crate::math::EquationElem;
 
 /// Bold font style in math.
diff --git a/crates/typst-library/src/math/underover.rs b/crates/typst-library/src/math/underover.rs
index 302c51afe..6f002d432 100644
--- a/crates/typst-library/src/math/underover.rs
+++ b/crates/typst-library/src/math/underover.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 use crate::math::Mathy;
 
 /// A horizontal line under content.
diff --git a/crates/typst-library/src/model/bibliography.rs b/crates/typst-library/src/model/bibliography.rs
index ef7e69273..23e89f86b 100644
--- a/crates/typst-library/src/model/bibliography.rs
+++ b/crates/typst-library/src/model/bibliography.rs
@@ -6,34 +6,35 @@ use std::path::Path;
 use std::sync::{Arc, LazyLock};
 
 use comemo::{Track, Tracked};
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
 use hayagriva::archive::ArchivedStyle;
 use hayagriva::io::BibLaTeXError;
 use hayagriva::{
-    citationberg, BibliographyDriver, BibliographyRequest, CitationItem, CitationRequest,
-    Library, SpecificLocator,
+    BibliographyDriver, BibliographyRequest, CitationItem, CitationRequest, Library,
+    SpecificLocator, citationberg,
 };
 use indexmap::IndexMap;
-use smallvec::{smallvec, SmallVec};
+use smallvec::{SmallVec, smallvec};
 use typst_syntax::{Span, Spanned, SyntaxMode};
 use typst_utils::{ManuallyHash, PicoStr};
 
+use crate::World;
 use crate::diag::{
-    bail, error, At, HintedStrResult, LoadError, LoadResult, LoadedWithin, ReportPos,
-    SourceResult, StrResult,
+    At, HintedStrResult, LoadError, LoadResult, LoadedWithin, ReportPos, SourceResult,
+    StrResult, bail, error,
 };
 use crate::engine::{Engine, Sink};
 use crate::foundations::{
-    elem, Bytes, CastInfo, Content, Derived, FromValue, IntoValue, Label, NativeElement,
+    Bytes, CastInfo, Content, Derived, FromValue, IntoValue, Label, NativeElement,
     OneOrMultiple, Packed, Reflect, Scope, ShowSet, Smart, StyleChain, Styles,
-    Synthesize, Value,
+    Synthesize, Value, elem,
 };
 use crate::introspection::{Introspector, Locatable, Location};
 use crate::layout::{
     BlockBody, BlockElem, Em, GridCell, GridChild, GridElem, GridItem, HElem, PadElem,
     Sizing, TrackSizings,
 };
-use crate::loading::{format_yaml_error, DataSource, Load, LoadSource, Loaded};
+use crate::loading::{DataSource, Load, LoadSource, Loaded, format_yaml_error};
 use crate::model::{
     CitationForm, CiteGroup, Destination, FootnoteElem, HeadingElem, LinkElem, Url,
 };
@@ -42,7 +43,6 @@ use crate::text::{
     FontStyle, Lang, LocalName, Region, Smallcaps, SubElem, SuperElem, TextElem,
     WeightDelta,
 };
-use crate::World;
 
 /// A bibliography / reference listing.
 ///
@@ -928,10 +928,11 @@ impl ElemRenderer<'_> {
         }
 
         if let Some(hayagriva::ElemMeta::Entry(i)) = elem.meta
-            && let Some(location) = (self.link)(i) {
-                let dest = Destination::Location(location);
-                content = content.linked(dest);
-            }
+            && let Some(location) = (self.link)(i)
+        {
+            let dest = Destination::Location(location);
+            content = content.linked(dest);
+        }
 
         Ok(content)
     }
diff --git a/crates/typst-library/src/model/cite.rs b/crates/typst-library/src/model/cite.rs
index b3ae3e522..f30e7a9c4 100644
--- a/crates/typst-library/src/model/cite.rs
+++ b/crates/typst-library/src/model/cite.rs
@@ -1,9 +1,9 @@
 use typst_syntax::Spanned;
 
-use crate::diag::{error, At, HintedString, SourceResult};
+use crate::diag::{At, HintedString, SourceResult, error};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Cast, Content, Derived, Label, Packed, Smart, StyleChain, Synthesize,
+    Cast, Content, Derived, Label, Packed, Smart, StyleChain, Synthesize, cast, elem,
 };
 use crate::introspection::Locatable;
 use crate::model::bibliography::Works;
diff --git a/crates/typst-library/src/model/document.rs b/crates/typst-library/src/model/document.rs
index 47e999735..6d668ac3f 100644
--- a/crates/typst-library/src/model/document.rs
+++ b/crates/typst-library/src/model/document.rs
@@ -1,10 +1,10 @@
 use ecow::EcoString;
 
-use crate::diag::{bail, HintedStrResult, SourceResult};
+use crate::diag::{HintedStrResult, SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Args, Array, Construct, Content, Datetime, OneOrMultiple, Smart,
-    StyleChain, Styles, Value,
+    Args, Array, Construct, Content, Datetime, OneOrMultiple, Smart, StyleChain, Styles,
+    Value, cast, elem,
 };
 
 /// The root element of a document and its metadata.
diff --git a/crates/typst-library/src/model/emph.rs b/crates/typst-library/src/model/emph.rs
index 6267736b3..b9eb9ebdd 100644
--- a/crates/typst-library/src/model/emph.rs
+++ b/crates/typst-library/src/model/emph.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 
 /// Emphasizes content by toggling italics.
 ///
diff --git a/crates/typst-library/src/model/enum.rs b/crates/typst-library/src/model/enum.rs
index 93a2c1dc6..adb738879 100644
--- a/crates/typst-library/src/model/enum.rs
+++ b/crates/typst-library/src/model/enum.rs
@@ -3,7 +3,7 @@ use std::str::FromStr;
 use smallvec::SmallVec;
 
 use crate::diag::bail;
-use crate::foundations::{cast, elem, scope, Array, Content, Packed, Smart, Styles};
+use crate::foundations::{Array, Content, Packed, Smart, Styles, cast, elem, scope};
 use crate::layout::{Alignment, Em, HAlignment, Length, VAlignment};
 use crate::model::{ListItemLike, ListLike, Numbering, NumberingPattern};
 
diff --git a/crates/typst-library/src/model/figure.rs b/crates/typst-library/src/model/figure.rs
index ac3676eea..daab37e44 100644
--- a/crates/typst-library/src/model/figure.rs
+++ b/crates/typst-library/src/model/figure.rs
@@ -5,11 +5,11 @@ use std::str::FromStr;
 use ecow::EcoString;
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, SourceResult};
+use crate::diag::{SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, select_where, Content, Element, NativeElement, Packed, Selector,
-    ShowSet, Smart, StyleChain, Styles, Synthesize,
+    Content, Element, NativeElement, Packed, Selector, ShowSet, Smart, StyleChain,
+    Styles, Synthesize, cast, elem, scope, select_where,
 };
 use crate::introspection::{
     Count, Counter, CounterKey, CounterUpdate, Locatable, Location,
diff --git a/crates/typst-library/src/model/footnote.rs b/crates/typst-library/src/model/footnote.rs
index b920a8ae4..51b9f25fd 100644
--- a/crates/typst-library/src/model/footnote.rs
+++ b/crates/typst-library/src/model/footnote.rs
@@ -3,11 +3,11 @@ use std::str::FromStr;
 
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, StrResult};
+use crate::diag::{StrResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, Content, Label, NativeElement, Packed, ShowSet, Smart, StyleChain,
-    Styles,
+    Content, Label, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles, cast,
+    elem, scope,
 };
 use crate::introspection::{Count, CounterUpdate, Locatable, Location};
 use crate::layout::{Abs, Em, Length, Ratio};
diff --git a/crates/typst-library/src/model/heading.rs b/crates/typst-library/src/model/heading.rs
index 0f2a1d338..f5e7f4f37 100644
--- a/crates/typst-library/src/model/heading.rs
+++ b/crates/typst-library/src/model/heading.rs
@@ -5,7 +5,7 @@ use typst_utils::NonZeroExt;
 use crate::diag::SourceResult;
 use crate::engine::Engine;
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles, Synthesize,
+    Content, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles, Synthesize, elem,
 };
 use crate::introspection::{Count, Counter, CounterUpdate, Locatable};
 use crate::layout::{BlockElem, Em, Length};
diff --git a/crates/typst-library/src/model/link.rs b/crates/typst-library/src/model/link.rs
index 7e8f58756..16e1cc5a9 100644
--- a/crates/typst-library/src/model/link.rs
+++ b/crates/typst-library/src/model/link.rs
@@ -1,11 +1,11 @@
 use std::ops::Deref;
 
 use comemo::Tracked;
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 
-use crate::diag::{bail, StrResult};
+use crate::diag::{StrResult, bail};
 use crate::foundations::{
-    cast, elem, Content, Label, Packed, Repr, ShowSet, Smart, StyleChain, Styles,
+    Content, Label, Packed, Repr, ShowSet, Smart, StyleChain, Styles, cast, elem,
 };
 use crate::introspection::{Introspector, Locatable, Location};
 use crate::layout::Position;
diff --git a/crates/typst-library/src/model/list.rs b/crates/typst-library/src/model/list.rs
index 660716de7..5df37ad33 100644
--- a/crates/typst-library/src/model/list.rs
+++ b/crates/typst-library/src/model/list.rs
@@ -1,10 +1,10 @@
 use comemo::Track;
 
-use crate::diag::{bail, SourceResult};
+use crate::diag::{SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, Array, Content, Context, Depth, Func, NativeElement, Packed,
-    Smart, StyleChain, Styles, Value,
+    Array, Content, Context, Depth, Func, NativeElement, Packed, Smart, StyleChain,
+    Styles, Value, cast, elem, scope,
 };
 use crate::layout::{Em, Length};
 use crate::text::TextElem;
diff --git a/crates/typst-library/src/model/numbering.rs b/crates/typst-library/src/model/numbering.rs
index 449dfdb33..a53954a7c 100644
--- a/crates/typst-library/src/model/numbering.rs
+++ b/crates/typst-library/src/model/numbering.rs
@@ -1,14 +1,14 @@
 use std::str::FromStr;
 
 use chinese_number::{
-    from_u64_to_chinese_ten_thousand as u64_to_chinese, ChineseCase, ChineseVariant,
+    ChineseCase, ChineseVariant, from_u64_to_chinese_ten_thousand as u64_to_chinese,
 };
 use comemo::Tracked;
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
 
 use crate::diag::SourceResult;
 use crate::engine::Engine;
-use crate::foundations::{cast, func, Context, Func, Str, Value};
+use crate::foundations::{Context, Func, Str, Value, cast, func};
 
 /// Applies a numbering to a sequence of numbers.
 ///
diff --git a/crates/typst-library/src/model/outline.rs b/crates/typst-library/src/model/outline.rs
index 4bda02ba3..96c4eb2b4 100644
--- a/crates/typst-library/src/model/outline.rs
+++ b/crates/typst-library/src/model/outline.rs
@@ -6,12 +6,11 @@ use smallvec::SmallVec;
 use typst_syntax::Span;
 use typst_utils::{Get, NonZeroExt};
 
-use crate::diag::{bail, error, At, HintedStrResult, SourceResult, StrResult};
+use crate::diag::{At, HintedStrResult, SourceResult, StrResult, bail, error};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, func, scope, select_where, Args, Construct, Content, Context, Func,
-    LocatableSelector, NativeElement, Packed, Resolve, ShowSet, Smart, StyleChain,
-    Styles,
+    Args, Construct, Content, Context, Func, LocatableSelector, NativeElement, Packed,
+    Resolve, ShowSet, Smart, StyleChain, Styles, cast, elem, func, scope, select_where,
 };
 use crate::introspection::{
     Counter, CounterKey, Introspector, Locatable, Location, Locator, LocatorLink,
diff --git a/crates/typst-library/src/model/par.rs b/crates/typst-library/src/model/par.rs
index 8aceec2c7..372e63e00 100644
--- a/crates/typst-library/src/model/par.rs
+++ b/crates/typst-library/src/model/par.rs
@@ -1,10 +1,10 @@
 use typst_utils::singleton;
 
-use crate::diag::{bail, SourceResult};
+use crate::diag::{SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, dict, elem, scope, Args, Cast, Construct, Content, Dict, NativeElement, Packed,
-    Smart, Unlabellable, Value,
+    Args, Cast, Construct, Content, Dict, NativeElement, Packed, Smart, Unlabellable,
+    Value, cast, dict, elem, scope,
 };
 use crate::introspection::{Count, CounterUpdate, Locatable};
 use crate::layout::{Em, HAlignment, Length, OuterHAlignment};
diff --git a/crates/typst-library/src/model/quote.rs b/crates/typst-library/src/model/quote.rs
index 5ce4a92f5..5ffa1fdc9 100644
--- a/crates/typst-library/src/model/quote.rs
+++ b/crates/typst-library/src/model/quote.rs
@@ -1,8 +1,8 @@
 use typst_syntax::Span;
 
 use crate::foundations::{
-    cast, elem, Content, Depth, Label, NativeElement, Packed, ShowSet, Smart, StyleChain,
-    Styles,
+    Content, Depth, Label, NativeElement, Packed, ShowSet, Smart, StyleChain, Styles,
+    cast, elem,
 };
 use crate::introspection::Locatable;
 use crate::layout::{BlockElem, Em, PadElem};
diff --git a/crates/typst-library/src/model/reference.rs b/crates/typst-library/src/model/reference.rs
index cf1b43da0..ff695182f 100644
--- a/crates/typst-library/src/model/reference.rs
+++ b/crates/typst-library/src/model/reference.rs
@@ -1,11 +1,11 @@
 use comemo::Track;
 use ecow::eco_format;
 
-use crate::diag::{bail, At, Hint, SourceResult};
+use crate::diag::{At, Hint, SourceResult, bail};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, Cast, Content, Context, Func, IntoValue, Label, NativeElement, Packed,
-    Repr, Smart, StyleChain, Synthesize, TargetElem,
+    Cast, Content, Context, Func, IntoValue, Label, NativeElement, Packed, Repr, Smart,
+    StyleChain, Synthesize, TargetElem, cast, elem,
 };
 use crate::introspection::{Counter, CounterKey, Locatable};
 use crate::math::EquationElem;
@@ -211,10 +211,11 @@ impl Synthesize for Packed<RefElem> {
         elem.element = Some(None);
 
         if !BibliographyElem::has(engine, elem.target)
-            && let Ok(found) = engine.introspector.query_label(elem.target).cloned() {
-                elem.element = Some(Some(found));
-                return Ok(());
-            }
+            && let Ok(found) = engine.introspector.query_label(elem.target).cloned()
+        {
+            elem.element = Some(Some(found));
+            return Ok(());
+        }
 
         Ok(())
     }
diff --git a/crates/typst-library/src/model/strong.rs b/crates/typst-library/src/model/strong.rs
index 7751c95bc..a1cfb36ab 100644
--- a/crates/typst-library/src/model/strong.rs
+++ b/crates/typst-library/src/model/strong.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 
 /// Strongly emphasizes content by increasing the font weight.
 ///
diff --git a/crates/typst-library/src/model/table.rs b/crates/typst-library/src/model/table.rs
index e46efc818..412ca4229 100644
--- a/crates/typst-library/src/model/table.rs
+++ b/crates/typst-library/src/model/table.rs
@@ -3,8 +3,8 @@ use std::sync::Arc;
 
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, HintedStrResult, HintedString};
-use crate::foundations::{cast, elem, scope, Content, Packed, Smart};
+use crate::diag::{HintedStrResult, HintedString, bail};
+use crate::foundations::{Content, Packed, Smart, cast, elem, scope};
 use crate::layout::{
     Abs, Alignment, Celled, GridCell, GridFooter, GridHLine, GridHeader, GridVLine,
     Length, OuterHAlignment, OuterVAlignment, Rel, Sides, TrackSizings,
diff --git a/crates/typst-library/src/model/terms.rs b/crates/typst-library/src/model/terms.rs
index 71b1bad6d..47939b9b4 100644
--- a/crates/typst-library/src/model/terms.rs
+++ b/crates/typst-library/src/model/terms.rs
@@ -1,6 +1,6 @@
 use crate::diag::bail;
 use crate::foundations::{
-    cast, elem, scope, Array, Content, NativeElement, Packed, Smart, Styles,
+    Array, Content, NativeElement, Packed, Smart, Styles, cast, elem, scope,
 };
 use crate::layout::{Em, HElem, Length};
 use crate::model::{ListItemLike, ListLike};
diff --git a/crates/typst-library/src/pdf/embed.rs b/crates/typst-library/src/pdf/embed.rs
index 3aba85623..2b93a591a 100644
--- a/crates/typst-library/src/pdf/embed.rs
+++ b/crates/typst-library/src/pdf/embed.rs
@@ -1,10 +1,10 @@
 use ecow::EcoString;
 use typst_syntax::Spanned;
 
-use crate::diag::At;
-use crate::foundations::{elem, Bytes, Cast, Derived};
-use crate::introspection::Locatable;
 use crate::World;
+use crate::diag::At;
+use crate::foundations::{Bytes, Cast, Derived, elem};
+use crate::introspection::Locatable;
 
 /// A file that will be embedded into the output PDF.
 ///
diff --git a/crates/typst-library/src/routines.rs b/crates/typst-library/src/routines.rs
index 01964800f..6fa7d69c8 100644
--- a/crates/typst-library/src/routines.rs
+++ b/crates/typst-library/src/routines.rs
@@ -5,6 +5,7 @@ use comemo::{Tracked, TrackedMut};
 use typst_syntax::{Span, SyntaxMode};
 use typst_utils::LazyHash;
 
+use crate::World;
 use crate::diag::SourceResult;
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
@@ -14,7 +15,6 @@ use crate::foundations::{
 use crate::introspection::{Introspector, Locator, SplitLocator};
 use crate::layout::{Frame, Region};
 use crate::model::DocumentInfo;
-use crate::World;
 
 /// Defines the `Routines` struct.
 macro_rules! routines {
diff --git a/crates/typst-library/src/text/case.rs b/crates/typst-library/src/text/case.rs
index 3b2ae450a..6451df766 100644
--- a/crates/typst-library/src/text/case.rs
+++ b/crates/typst-library/src/text/case.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{cast, func, Cast, Content, Str};
+use crate::foundations::{Cast, Content, Str, cast, func};
 use crate::text::TextElem;
 
 /// Converts a string or content to lowercase.
diff --git a/crates/typst-library/src/text/deco.rs b/crates/typst-library/src/text/deco.rs
index f7d5c33be..d7383f0f1 100644
--- a/crates/typst-library/src/text/deco.rs
+++ b/crates/typst-library/src/text/deco.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content, Smart};
+use crate::foundations::{Content, Smart, elem};
 use crate::layout::{Abs, Corners, Length, Rel, Sides};
 use crate::text::{BottomEdge, BottomEdgeMetric, TopEdge, TopEdgeMetric};
 use crate::visualize::{Color, FixedStroke, Paint, Stroke};
diff --git a/crates/typst-library/src/text/font/book.rs b/crates/typst-library/src/text/font/book.rs
index 374b83908..db100d4f7 100644
--- a/crates/typst-library/src/text/font/book.rs
+++ b/crates/typst-library/src/text/font/book.rs
@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
 use std::fmt::{self, Debug, Formatter};
 
 use serde::{Deserialize, Serialize};
-use ttf_parser::{name_id, PlatformId, Tag};
+use ttf_parser::{PlatformId, Tag, name_id};
 use unicode_segmentation::UnicodeSegmentation;
 
 use super::exceptions::find_exception;
@@ -284,9 +284,10 @@ impl FontInfo {
             .raw_face()
             .table(Tag::from_bytes(b"OS/2"))
             .and_then(|os2| os2.get(32..45))
-            && matches!(panose, [2, 2..=10, ..]) {
-                flags.insert(FontFlags::SERIF);
-            }
+            && matches!(panose, [2, 2..=10, ..])
+        {
+            flags.insert(FontFlags::SERIF);
+        }
 
         Some(FontInfo {
             family,
@@ -335,11 +336,7 @@ fn decode_mac_roman(coded: &[u8]) -> String {
     ];
 
     fn char_from_mac_roman(code: u8) -> char {
-        if code < 128 {
-            code as char
-        } else {
-            TABLE[(code - 128) as usize]
-        }
+        if code < 128 { code as char } else { TABLE[(code - 128) as usize] }
     }
 
     coded.iter().copied().map(char_from_mac_roman).collect()
@@ -396,9 +393,10 @@ fn typographic_family(mut family: &str) -> &str {
         // Also allow an extra modifier, but apply it only if it is separated it
         // from the text before it (to prevent false positives).
         if let Some(t) = MODIFIERS.iter().find_map(|s| t.strip_suffix(s))
-            && let Some(stripped) = t.strip_suffix(SEPARATORS) {
-                trimmed = stripped;
-            }
+            && let Some(stripped) = t.strip_suffix(SEPARATORS)
+        {
+            trimmed = stripped;
+        }
     }
 
     // Apply style suffix trimming.
diff --git a/crates/typst-library/src/text/font/variant.rs b/crates/typst-library/src/text/font/variant.rs
index c7a00fb34..e2e6860c6 100644
--- a/crates/typst-library/src/text/font/variant.rs
+++ b/crates/typst-library/src/text/font/variant.rs
@@ -3,7 +3,7 @@ use std::fmt::{self, Debug, Formatter};
 use ecow::EcoString;
 use serde::{Deserialize, Serialize};
 
-use crate::foundations::{cast, Cast, IntoValue, Repr};
+use crate::foundations::{Cast, IntoValue, Repr, cast};
 use crate::layout::Ratio;
 
 /// Properties that distinguish a font from other fonts in the same family.
diff --git a/crates/typst-library/src/text/item.rs b/crates/typst-library/src/text/item.rs
index 518b082b9..2668aa54e 100644
--- a/crates/typst-library/src/text/item.rs
+++ b/crates/typst-library/src/text/item.rs
@@ -5,7 +5,7 @@ use ecow::EcoString;
 use typst_syntax::Span;
 
 use crate::layout::{Abs, Em};
-use crate::text::{is_default_ignorable, Font, Lang, Region};
+use crate::text::{Font, Lang, Region, is_default_ignorable};
 use crate::visualize::{FixedStroke, Paint};
 
 /// A run of shaped text.
diff --git a/crates/typst-library/src/text/lang.rs b/crates/typst-library/src/text/lang.rs
index d396eef8b..ed21ade17 100644
--- a/crates/typst-library/src/text/lang.rs
+++ b/crates/typst-library/src/text/lang.rs
@@ -1,10 +1,10 @@
 use std::collections::HashMap;
 use std::str::FromStr;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 
 use crate::diag::Hint;
-use crate::foundations::{cast, StyleChain};
+use crate::foundations::{StyleChain, cast};
 use crate::layout::Dir;
 use crate::text::TextElem;
 
diff --git a/crates/typst-library/src/text/linebreak.rs b/crates/typst-library/src/text/linebreak.rs
index 0519e1c4a..f4aeac7bb 100644
--- a/crates/typst-library/src/text/linebreak.rs
+++ b/crates/typst-library/src/text/linebreak.rs
@@ -1,6 +1,6 @@
 use typst_utils::singleton;
 
-use crate::foundations::{elem, Content, NativeElement};
+use crate::foundations::{Content, NativeElement, elem};
 
 /// Inserts a line break.
 ///
diff --git a/crates/typst-library/src/text/lorem.rs b/crates/typst-library/src/text/lorem.rs
index 5d01a550d..8fc5c9cc0 100644
--- a/crates/typst-library/src/text/lorem.rs
+++ b/crates/typst-library/src/text/lorem.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{func, Str};
+use crate::foundations::{Str, func};
 
 /// Creates blind text.
 ///
diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index 5f2330cbd..f2025f5b8 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -33,7 +33,7 @@ use std::hash::Hash;
 use std::str::FromStr;
 use std::sync::LazyLock;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use icu_properties::sets::CodePointSetData;
 use icu_provider::AsDeserializingBufferProvider;
 use icu_provider_blob::BlobDataProvider;
@@ -43,17 +43,17 @@ use ttf_parser::Tag;
 use typst_syntax::Spanned;
 use typst_utils::singleton;
 
-use crate::diag::{bail, warning, HintedStrResult, SourceResult, StrResult};
+use crate::World;
+use crate::diag::{HintedStrResult, SourceResult, StrResult, bail, warning};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, dict, elem, Args, Array, Cast, Construct, Content, Dict, Fold, IntoValue,
-    NativeElement, Never, NoneValue, Packed, PlainText, Regex, Repr, Resolve, Scope, Set,
-    Smart, StyleChain,
+    Args, Array, Cast, Construct, Content, Dict, Fold, IntoValue, NativeElement, Never,
+    NoneValue, Packed, PlainText, Regex, Repr, Resolve, Scope, Set, Smart, StyleChain,
+    cast, dict, elem,
 };
 use crate::layout::{Abs, Axis, Dir, Em, Length, Ratio, Rel};
 use crate::math::{EquationElem, MathSize};
 use crate::visualize::{Color, Paint, RelativeTo, Stroke};
-use crate::World;
 
 /// Hook up all `text` definitions.
 pub(super) fn define(global: &mut Scope) {
diff --git a/crates/typst-library/src/text/raw.rs b/crates/typst-library/src/text/raw.rs
index 1677d3d07..3d74ed0a6 100644
--- a/crates/typst-library/src/text/raw.rs
+++ b/crates/typst-library/src/text/raw.rs
@@ -6,25 +6,25 @@ use comemo::Tracked;
 use ecow::{EcoString, EcoVec};
 use syntect::highlighting::{self as synt};
 use syntect::parsing::{ParseSyntaxError, SyntaxDefinition, SyntaxSet, SyntaxSetBuilder};
-use typst_syntax::{split_newlines, LinkedNode, Span, Spanned};
+use typst_syntax::{LinkedNode, Span, Spanned, split_newlines};
 use typst_utils::ManuallyHash;
 use unicode_segmentation::UnicodeSegmentation;
 
 use super::Lang;
+use crate::World;
 use crate::diag::{
     LineCol, LoadError, LoadResult, LoadedWithin, ReportPos, SourceResult,
 };
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, scope, Bytes, Content, Derived, OneOrMultiple, Packed, PlainText,
-    ShowSet, Smart, StyleChain, Styles, Synthesize,
+    Bytes, Content, Derived, OneOrMultiple, Packed, PlainText, ShowSet, Smart,
+    StyleChain, Styles, Synthesize, cast, elem, scope,
 };
 use crate::layout::{Em, HAlignment};
 use crate::loading::{DataSource, Load};
 use crate::model::{Figurable, ParElem};
 use crate::text::{FontFamily, FontList, LocalName, TextElem, TextSize};
 use crate::visualize::Color;
-use crate::World;
 
 /// Raw text with optional syntax highlighting.
 ///
@@ -751,9 +751,10 @@ fn preprocess(
     span: Span,
 ) -> EcoVec<(EcoString, Span)> {
     if let RawContent::Lines(lines) = text
-        && lines.iter().all(|(s, _)| !s.contains('\t')) {
-            return lines.clone();
-        }
+        && lines.iter().all(|(s, _)| !s.contains('\t'))
+    {
+        return lines.clone();
+    }
 
     let mut text = text.get();
     if text.contains('\t') {
diff --git a/crates/typst-library/src/text/shift.rs b/crates/typst-library/src/text/shift.rs
index 87ccae635..eb4c89e18 100644
--- a/crates/typst-library/src/text/shift.rs
+++ b/crates/typst-library/src/text/shift.rs
@@ -1,6 +1,6 @@
 use ttf_parser::Tag;
 
-use crate::foundations::{elem, Content, Smart};
+use crate::foundations::{Content, Smart, elem};
 use crate::layout::{Em, Length};
 use crate::text::{FontMetrics, ScriptMetrics, TextSize};
 
diff --git a/crates/typst-library/src/text/smallcaps.rs b/crates/typst-library/src/text/smallcaps.rs
index 199222fed..9c4969eea 100644
--- a/crates/typst-library/src/text/smallcaps.rs
+++ b/crates/typst-library/src/text/smallcaps.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Content};
+use crate::foundations::{Content, elem};
 
 /// Displays text in small capitals.
 ///
diff --git a/crates/typst-library/src/text/smartquote.rs b/crates/typst-library/src/text/smartquote.rs
index 375b1cf09..d39703f6c 100644
--- a/crates/typst-library/src/text/smartquote.rs
+++ b/crates/typst-library/src/text/smartquote.rs
@@ -2,10 +2,10 @@ use ecow::EcoString;
 use typst_syntax::is_newline;
 use unicode_segmentation::UnicodeSegmentation;
 
-use crate::diag::{bail, HintedStrResult, StrResult};
+use crate::diag::{HintedStrResult, StrResult, bail};
 use crate::foundations::{
-    array, cast, dict, elem, Array, Dict, FromValue, Packed, PlainText, Smart, Str,
-    StyleChain,
+    Array, Dict, FromValue, Packed, PlainText, Smart, Str, StyleChain, array, cast, dict,
+    elem,
 };
 use crate::layout::Dir;
 use crate::text::{Lang, Region, TextElem};
@@ -297,20 +297,12 @@ impl<'s> SmartQuotes<'s> {
 
     /// The opening quote.
     pub fn open(&self, double: bool) -> &'s str {
-        if double {
-            self.double_open
-        } else {
-            self.single_open
-        }
+        if double { self.double_open } else { self.single_open }
     }
 
     /// The closing quote.
     pub fn close(&self, double: bool) -> &'s str {
-        if double {
-            self.double_close
-        } else {
-            self.single_close
-        }
+        if double { self.double_close } else { self.single_close }
     }
 }
 
diff --git a/crates/typst-library/src/text/space.rs b/crates/typst-library/src/text/space.rs
index 38a554823..143046fac 100644
--- a/crates/typst-library/src/text/space.rs
+++ b/crates/typst-library/src/text/space.rs
@@ -2,7 +2,7 @@ use ecow::EcoString;
 use typst_utils::singleton;
 
 use crate::foundations::{
-    elem, Content, NativeElement, Packed, PlainText, Repr, Unlabellable,
+    Content, NativeElement, Packed, PlainText, Repr, Unlabellable, elem,
 };
 
 /// A text space.
diff --git a/crates/typst-library/src/visualize/color.rs b/crates/typst-library/src/visualize/color.rs
index 9c8eacaf5..e57e74734 100644
--- a/crates/typst-library/src/visualize/color.rs
+++ b/crates/typst-library/src/visualize/color.rs
@@ -3,7 +3,7 @@ use std::hash::{Hash, Hasher};
 use std::str::FromStr;
 use std::sync::LazyLock;
 
-use ecow::{eco_format, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format};
 use palette::encoding::{self, Linear};
 use palette::{
     Alpha, Darken, Desaturate, FromColor, Lighten, OklabHue, RgbHue, Saturate, ShiftHue,
@@ -11,10 +11,10 @@ use palette::{
 use qcms::Profile;
 use typst_syntax::{Span, Spanned};
 
-use crate::diag::{bail, At, SourceResult, StrResult};
+use crate::diag::{At, SourceResult, StrResult, bail};
 use crate::foundations::{
-    array, cast, func, repr, scope, ty, Args, Array, IntoValue, Module, Repr, Scope, Str,
-    Value,
+    Args, Array, IntoValue, Module, Repr, Scope, Str, Value, array, cast, func, repr,
+    scope, ty,
 };
 use crate::layout::{Angle, Ratio};
 
@@ -1124,14 +1124,15 @@ impl Color {
 
             // Ensure that the hue circle is traversed in the short direction.
             if let Some(index) = space.hue_index()
-                && (c0[index] - c1[index]).abs() > 180.0 {
-                    let (h0, h1) = if c0[index] < c1[index] {
-                        (c0[index] + 360.0, c1[index])
-                    } else {
-                        (c0[index], c1[index] + 360.0)
-                    };
-                    m[index] = (w0 * h0 + w1 * h1) / (w0 + w1);
-                }
+                && (c0[index] - c1[index]).abs() > 180.0
+            {
+                let (h0, h1) = if c0[index] < c1[index] {
+                    (c0[index] + 360.0, c1[index])
+                } else {
+                    (c0[index], c1[index] + 360.0)
+                };
+                m[index] = (w0 * h0 + w1 * h1) / (w0 + w1);
+            }
 
             m
         } else {
diff --git a/crates/typst-library/src/visualize/curve.rs b/crates/typst-library/src/visualize/curve.rs
index 15ae48c61..4bc5b45fb 100644
--- a/crates/typst-library/src/visualize/curve.rs
+++ b/crates/typst-library/src/visualize/curve.rs
@@ -1,9 +1,9 @@
 use kurbo::ParamCurveExtrema;
-use typst_macros::{scope, Cast};
+use typst_macros::{Cast, scope};
 use typst_utils::Numeric;
 
-use crate::diag::{bail, HintedStrResult, HintedString};
-use crate::foundations::{cast, elem, Content, Packed, Smart};
+use crate::diag::{HintedStrResult, HintedString, bail};
+use crate::foundations::{Content, Packed, Smart, cast, elem};
 use crate::layout::{Abs, Axes, Length, Point, Rel, Size};
 use crate::visualize::{FillRule, Paint, Stroke};
 
diff --git a/crates/typst-library/src/visualize/gradient.rs b/crates/typst-library/src/visualize/gradient.rs
index 4917da68d..cb2ade2eb 100644
--- a/crates/typst-library/src/visualize/gradient.rs
+++ b/crates/typst-library/src/visualize/gradient.rs
@@ -7,9 +7,9 @@ use ecow::EcoString;
 use kurbo::Vec2;
 use typst_syntax::{Span, Spanned};
 
-use crate::diag::{bail, SourceResult};
+use crate::diag::{SourceResult, bail};
 use crate::foundations::{
-    array, cast, func, scope, ty, Args, Array, Cast, Func, IntoValue, Repr, Smart,
+    Args, Array, Cast, Func, IntoValue, Repr, Smart, array, cast, func, scope, ty,
 };
 use crate::layout::{Angle, Axes, Dir, Quadrant, Ratio};
 use crate::visualize::{Color, ColorSpace, WeightedColor};
@@ -893,11 +893,7 @@ impl Gradient {
     /// the special case of `auto`.
     pub fn unwrap_relative(&self, on_text: bool) -> RelativeTo {
         self.relative().unwrap_or_else(|| {
-            if on_text {
-                RelativeTo::Parent
-            } else {
-                RelativeTo::Self_
-            }
+            if on_text { RelativeTo::Parent } else { RelativeTo::Self_ }
         })
     }
 
diff --git a/crates/typst-library/src/visualize/image/mod.rs b/crates/typst-library/src/visualize/image/mod.rs
index f1fa6381b..d037145e7 100644
--- a/crates/typst-library/src/visualize/image/mod.rs
+++ b/crates/typst-library/src/visualize/image/mod.rs
@@ -16,16 +16,16 @@ use ecow::EcoString;
 use typst_syntax::{Span, Spanned};
 use typst_utils::LazyHash;
 
-use crate::diag::{warning, At, LoadedWithin, SourceResult, StrResult};
+use crate::diag::{At, LoadedWithin, SourceResult, StrResult, warning};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, func, scope, Bytes, Cast, Content, Derived, NativeElement, Packed, Smart,
-    StyleChain,
+    Bytes, Cast, Content, Derived, NativeElement, Packed, Smart, StyleChain, cast, elem,
+    func, scope,
 };
 use crate::layout::{Length, Rel, Sizing};
 use crate::loading::{DataSource, Load, LoadSource, Loaded, Readable};
 use crate::model::Figurable;
-use crate::text::{families, LocalName};
+use crate::text::{LocalName, families};
 
 /// A raster or vector graphic.
 ///
diff --git a/crates/typst-library/src/visualize/image/raster.rs b/crates/typst-library/src/visualize/image/raster.rs
index 54f832bae..63bbf0faa 100644
--- a/crates/typst-library/src/visualize/image/raster.rs
+++ b/crates/typst-library/src/visualize/image/raster.rs
@@ -3,15 +3,15 @@ use std::hash::{Hash, Hasher};
 use std::io;
 use std::sync::Arc;
 
-use crate::diag::{bail, StrResult};
-use crate::foundations::{cast, dict, Bytes, Cast, Dict, Smart, Value};
-use ecow::{eco_format, EcoString};
+use crate::diag::{StrResult, bail};
+use crate::foundations::{Bytes, Cast, Dict, Smart, Value, cast, dict};
+use ecow::{EcoString, eco_format};
 use image::codecs::gif::GifDecoder;
 use image::codecs::jpeg::JpegDecoder;
 use image::codecs::png::PngDecoder;
 use image::codecs::webp::WebPDecoder;
 use image::{
-    guess_format, DynamicImage, ImageBuffer, ImageDecoder, ImageResult, Limits, Pixel,
+    DynamicImage, ImageBuffer, ImageDecoder, ImageResult, Limits, Pixel, guess_format,
 };
 
 /// A decoded raster image.
diff --git a/crates/typst-library/src/visualize/image/svg.rs b/crates/typst-library/src/visualize/image/svg.rs
index 1a3f6d474..11253c85a 100644
--- a/crates/typst-library/src/visualize/image/svg.rs
+++ b/crates/typst-library/src/visualize/image/svg.rs
@@ -5,13 +5,13 @@ use std::sync::{Arc, Mutex};
 use comemo::Tracked;
 use siphasher::sip128::{Hasher128, SipHasher13};
 
-use crate::diag::{format_xml_like_error, LoadError, LoadResult, ReportPos};
+use crate::World;
+use crate::diag::{LoadError, LoadResult, ReportPos, format_xml_like_error};
 use crate::foundations::Bytes;
 use crate::layout::Axes;
 use crate::text::{
     Font, FontBook, FontFlags, FontStretch, FontStyle, FontVariant, FontWeight,
 };
-use crate::World;
 
 /// A decoded SVG.
 #[derive(Clone, Hash)]
diff --git a/crates/typst-library/src/visualize/paint.rs b/crates/typst-library/src/visualize/paint.rs
index a618e5154..5769e3aa6 100644
--- a/crates/typst-library/src/visualize/paint.rs
+++ b/crates/typst-library/src/visualize/paint.rs
@@ -2,7 +2,7 @@ use std::fmt::{self, Debug, Formatter};
 
 use ecow::EcoString;
 
-use crate::foundations::{cast, Repr, Smart};
+use crate::foundations::{Repr, Smart, cast};
 use crate::visualize::{Color, Gradient, RelativeTo, Tiling};
 
 /// How a fill or stroke should be painted.
diff --git a/crates/typst-library/src/visualize/path.rs b/crates/typst-library/src/visualize/path.rs
index bd8aea02d..46ea7ec32 100644
--- a/crates/typst-library/src/visualize/path.rs
+++ b/crates/typst-library/src/visualize/path.rs
@@ -1,6 +1,6 @@
 use self::PathVertex::{AllControlPoints, MirroredControlPoint, Vertex};
 use crate::diag::bail;
-use crate::foundations::{array, cast, elem, Array, Reflect, Smart};
+use crate::foundations::{Array, Reflect, Smart, array, cast, elem};
 use crate::layout::{Axes, Length, Rel};
 use crate::visualize::{FillRule, Paint, Stroke};
 
diff --git a/crates/typst-library/src/visualize/polygon.rs b/crates/typst-library/src/visualize/polygon.rs
index db75a2670..d9b88f345 100644
--- a/crates/typst-library/src/visualize/polygon.rs
+++ b/crates/typst-library/src/visualize/polygon.rs
@@ -2,7 +2,7 @@ use std::f64::consts::PI;
 
 use typst_syntax::Span;
 
-use crate::foundations::{elem, func, scope, Content, NativeElement, Smart};
+use crate::foundations::{Content, NativeElement, Smart, elem, func, scope};
 use crate::layout::{Axes, Em, Length, Rel};
 use crate::visualize::{FillRule, Paint, Stroke};
 
diff --git a/crates/typst-library/src/visualize/shape.rs b/crates/typst-library/src/visualize/shape.rs
index fc7b8748e..d4382e6f0 100644
--- a/crates/typst-library/src/visualize/shape.rs
+++ b/crates/typst-library/src/visualize/shape.rs
@@ -1,4 +1,4 @@
-use crate::foundations::{elem, Cast, Content, Smart};
+use crate::foundations::{Cast, Content, Smart, elem};
 use crate::layout::{Abs, Corners, Length, Point, Rel, Sides, Size, Sizing};
 use crate::visualize::{Curve, FixedStroke, Paint, Stroke};
 
diff --git a/crates/typst-library/src/visualize/stroke.rs b/crates/typst-library/src/visualize/stroke.rs
index a0830cf19..ca3d50f64 100644
--- a/crates/typst-library/src/visualize/stroke.rs
+++ b/crates/typst-library/src/visualize/stroke.rs
@@ -3,8 +3,8 @@ use typst_utils::{Numeric, Scalar};
 
 use crate::diag::{HintedStrResult, SourceResult};
 use crate::foundations::{
-    cast, dict, func, scope, ty, Args, Cast, Dict, Fold, FromValue, NoneValue, Repr,
-    Resolve, Smart, StyleChain, Value,
+    Args, Cast, Dict, Fold, FromValue, NoneValue, Repr, Resolve, Smart, StyleChain,
+    Value, cast, dict, func, scope, ty,
 };
 use crate::layout::{Abs, Length};
 use crate::visualize::{Color, Gradient, Paint, Tiling};
diff --git a/crates/typst-library/src/visualize/tiling.rs b/crates/typst-library/src/visualize/tiling.rs
index 98a71f927..dc4cf5859 100644
--- a/crates/typst-library/src/visualize/tiling.rs
+++ b/crates/typst-library/src/visualize/tiling.rs
@@ -1,17 +1,17 @@
 use std::hash::Hash;
 use std::sync::Arc;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_syntax::{Span, Spanned};
 use typst_utils::{LazyHash, Numeric};
 
-use crate::diag::{bail, SourceResult};
+use crate::World;
+use crate::diag::{SourceResult, bail};
 use crate::engine::Engine;
-use crate::foundations::{func, repr, scope, ty, Content, Smart, StyleChain};
+use crate::foundations::{Content, Smart, StyleChain, func, repr, scope, ty};
 use crate::introspection::Locator;
 use crate::layout::{Abs, Axes, Frame, Length, Region, Size};
 use crate::visualize::RelativeTo;
-use crate::World;
 
 /// A repeating tiling fill.
 ///
@@ -259,11 +259,7 @@ impl Tiling {
     /// Returns the relative placement of the tiling.
     pub fn unwrap_relative(&self, on_text: bool) -> RelativeTo {
         self.0.relative.unwrap_or_else(|| {
-            if on_text {
-                RelativeTo::Parent
-            } else {
-                RelativeTo::Self_
-            }
+            if on_text { RelativeTo::Parent } else { RelativeTo::Self_ }
         })
     }
 }
diff --git a/crates/typst-macros/src/elem.rs b/crates/typst-macros/src/elem.rs
index e1c901d8a..bc3def45f 100644
--- a/crates/typst-macros/src/elem.rs
+++ b/crates/typst-macros/src/elem.rs
@@ -6,8 +6,8 @@ use syn::punctuated::Punctuated;
 use syn::{Ident, Result, Token};
 
 use crate::util::{
-    determine_name_and_title, documentation, foundations, has_attr, kw, parse_attr,
-    parse_flag, parse_string, parse_string_array, validate_attrs, BlockWithReturn,
+    BlockWithReturn, determine_name_and_title, documentation, foundations, has_attr, kw,
+    parse_attr, parse_flag, parse_string, parse_string_array, validate_attrs,
 };
 
 /// Expand the `#[elem]` macro.
diff --git a/crates/typst-macros/src/func.rs b/crates/typst-macros/src/func.rs
index e953dc374..79bb7f58a 100644
--- a/crates/typst-macros/src/func.rs
+++ b/crates/typst-macros/src/func.rs
@@ -2,7 +2,7 @@ use heck::ToKebabCase;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::parse::{Parse, ParseStream};
-use syn::{parse_quote, Ident, Result};
+use syn::{Ident, Result, parse_quote};
 
 use crate::util::{
     determine_name_and_title, documentation, foundations, has_attr, kw, parse_attr,
diff --git a/crates/typst-macros/src/scope.rs b/crates/typst-macros/src/scope.rs
index 2eac76b53..4df4f2487 100644
--- a/crates/typst-macros/src/scope.rs
+++ b/crates/typst-macros/src/scope.rs
@@ -1,9 +1,9 @@
 use heck::ToKebabCase;
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{parse_quote, Result};
+use syn::{Result, parse_quote};
 
-use crate::util::{foundations, BareType};
+use crate::util::{BareType, foundations};
 
 /// Expand the `#[scope]` macro.
 pub fn scope(_: TokenStream, item: syn::Item) -> Result<TokenStream> {
@@ -16,10 +16,11 @@ pub fn scope(_: TokenStream, item: syn::Item) -> Result<TokenStream> {
     let mut primitive_ident_ext = None;
     if let syn::Type::Path(syn::TypePath { path, .. }) = self_ty.as_ref()
         && let Some(ident) = path.get_ident()
-            && is_primitive(ident) {
-                let ident_ext = quote::format_ident!("{ident}Ext");
-                primitive_ident_ext = Some(ident_ext);
-            }
+        && is_primitive(ident)
+    {
+        let ident_ext = quote::format_ident!("{ident}Ext");
+        primitive_ident_ext = Some(ident_ext);
+    }
 
     let self_ty_expr = match &primitive_ident_ext {
         None => quote! { #self_ty },
diff --git a/crates/typst-macros/src/time.rs b/crates/typst-macros/src/time.rs
index 94fa4e5be..abd548dd9 100644
--- a/crates/typst-macros/src/time.rs
+++ b/crates/typst-macros/src/time.rs
@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 use syn::parse::{Parse, ParseStream};
-use syn::{parse_quote, Result};
+use syn::{Result, parse_quote};
 
 use crate::util::{kw, parse_key_value, parse_string};
 
diff --git a/crates/typst-macros/src/ty.rs b/crates/typst-macros/src/ty.rs
index 662849044..fd0aec7f1 100644
--- a/crates/typst-macros/src/ty.rs
+++ b/crates/typst-macros/src/ty.rs
@@ -4,8 +4,8 @@ use syn::parse::{Parse, ParseStream};
 use syn::{Attribute, Ident, Result};
 
 use crate::util::{
-    determine_name_and_title, documentation, foundations, kw, parse_flag, parse_string,
-    parse_string_array, BareType,
+    BareType, determine_name_and_title, documentation, foundations, kw, parse_flag,
+    parse_string, parse_string_array,
 };
 
 /// Expand the `#[ty]` macro.
diff --git a/crates/typst-macros/src/util.rs b/crates/typst-macros/src/util.rs
index 87e398c97..108ee3828 100644
--- a/crates/typst-macros/src/util.rs
+++ b/crates/typst-macros/src/util.rs
@@ -1,6 +1,6 @@
 use heck::{ToKebabCase, ToTitleCase};
 use proc_macro2::TokenStream;
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 use syn::parse::{Parse, ParseStream};
 use syn::token::Token;
 use syn::{Attribute, Ident, Result, Token};
@@ -29,13 +29,14 @@ pub fn documentation(attrs: &[syn::Attribute]) -> String {
     for attr in attrs {
         if let syn::Meta::NameValue(meta) = &attr.meta
             && meta.path.is_ident("doc")
-                && let syn::Expr::Lit(lit) = &meta.value
-                    && let syn::Lit::Str(string) = &lit.lit {
-                        let full = string.value();
-                        let line = full.strip_prefix(' ').unwrap_or(&full);
-                        doc.push_str(line);
-                        doc.push('\n');
-                    }
+            && let syn::Expr::Lit(lit) = &meta.value
+            && let syn::Lit::Str(string) = &lit.lit
+        {
+            let full = string.value();
+            let line = full.strip_prefix(' ').unwrap_or(&full);
+            doc.push_str(line);
+            doc.push('\n');
+        }
     }
 
     doc.trim().into()
diff --git a/crates/typst-pdf/src/convert.rs b/crates/typst-pdf/src/convert.rs
index 9e2aa87b7..058658156 100644
--- a/crates/typst-pdf/src/convert.rs
+++ b/crates/typst-pdf/src/convert.rs
@@ -1,7 +1,7 @@
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::num::NonZeroU64;
 
-use ecow::{eco_format, EcoVec};
+use ecow::{EcoVec, eco_format};
 use krilla::annotation::Annotation;
 use krilla::configure::{Configuration, ValidationError, Validator};
 use krilla::destination::{NamedDestination, XyzDestination};
@@ -12,7 +12,7 @@ use krilla::page::{PageLabel, PageSettings};
 use krilla::surface::Surface;
 use krilla::{Document, SerializeSettings};
 use krilla_svg::render_svg_glyph;
-use typst_library::diag::{bail, error, SourceDiagnostic, SourceResult};
+use typst_library::diag::{SourceDiagnostic, SourceResult, bail, error};
 use typst_library::foundations::{NativeElement, Repr};
 use typst_library::introspection::Location;
 use typst_library::layout::{
@@ -23,6 +23,7 @@ use typst_library::text::{Font, Lang};
 use typst_library::visualize::{Geometry, Paint};
 use typst_syntax::Span;
 
+use crate::PdfOptions;
 use crate::embed::embed_files;
 use crate::image::handle_image;
 use crate::link::handle_link;
@@ -31,8 +32,7 @@ use crate::outline::build_outline;
 use crate::page::PageLabelExt;
 use crate::shape::handle_shape;
 use crate::text::handle_text;
-use crate::util::{convert_path, display_font, AbsExt, TransformExt};
-use crate::PdfOptions;
+use crate::util::{AbsExt, TransformExt, convert_path, display_font};
 
 #[typst_macros::time(name = "convert document")]
 pub fn convert(
diff --git a/crates/typst-pdf/src/embed.rs b/crates/typst-pdf/src/embed.rs
index c62178cf2..b50f4a56d 100644
--- a/crates/typst-pdf/src/embed.rs
+++ b/crates/typst-pdf/src/embed.rs
@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
-use krilla::embed::{AssociationKind, EmbeddedFile};
 use krilla::Document;
-use typst_library::diag::{bail, SourceResult};
+use krilla::embed::{AssociationKind, EmbeddedFile};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::foundations::{NativeElement, StyleChain};
 use typst_library::layout::PagedDocument;
 use typst_library::pdf::{EmbedElem, EmbeddedFileRelationship};
diff --git a/crates/typst-pdf/src/image.rs b/crates/typst-pdf/src/image.rs
index 93bdb1950..39a6e602c 100644
--- a/crates/typst-pdf/src/image.rs
+++ b/crates/typst-pdf/src/image.rs
@@ -5,7 +5,7 @@ use image::{DynamicImage, EncodableLayout, GenericImageView, Rgba};
 use krilla::image::{BitsPerComponent, CustomImage, ImageColorspace};
 use krilla::surface::Surface;
 use krilla_svg::{SurfaceExt, SvgSettings};
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::foundations::Smart;
 use typst_library::layout::{Abs, Angle, Ratio, Size, Transform};
 use typst_library::visualize::{
diff --git a/crates/typst-pdf/src/lib.rs b/crates/typst-pdf/src/lib.rs
index 88c6ee552..96bbac591 100644
--- a/crates/typst-pdf/src/lib.rs
+++ b/crates/typst-pdf/src/lib.rs
@@ -18,7 +18,7 @@ use std::fmt::{self, Debug, Formatter};
 
 use ecow::eco_format;
 use serde::{Deserialize, Serialize};
-use typst_library::diag::{bail, SourceResult, StrResult};
+use typst_library::diag::{SourceResult, StrResult, bail};
 use typst_library::foundations::Smart;
 use typst_library::layout::{PageRanges, PagedDocument};
 
diff --git a/crates/typst-pdf/src/outline.rs b/crates/typst-pdf/src/outline.rs
index e95bf67fb..7228f0f32 100644
--- a/crates/typst-pdf/src/outline.rs
+++ b/crates/typst-pdf/src/outline.rs
@@ -24,10 +24,10 @@ pub(crate) fn build_outline(gc: &GlobalContext) -> Outline {
         if let Some(page_ranges) = &gc.options.page_ranges
             && !page_ranges
                 .includes_page(gc.document.introspector.page(elem.location().unwrap()))
-            {
-                // Don't bookmark headings in non-exported pages.
-                continue;
-            }
+        {
+            // Don't bookmark headings in non-exported pages.
+            continue;
+        }
 
         let heading = elem.to_packed::<HeadingElem>().unwrap();
         let leaf = HeadingNode::leaf(heading);
diff --git a/crates/typst-pdf/src/paint.rs b/crates/typst-pdf/src/paint.rs
index 5224464ab..e03d0e945 100644
--- a/crates/typst-pdf/src/paint.rs
+++ b/crates/typst-pdf/src/paint.rs
@@ -15,7 +15,7 @@ use typst_library::visualize::{
 };
 use typst_utils::Numeric;
 
-use crate::convert::{handle_frame, FrameContext, GlobalContext, State};
+use crate::convert::{FrameContext, GlobalContext, State, handle_frame};
 use crate::util::{AbsExt, FillRuleExt, LineCapExt, LineJoinExt, TransformExt};
 
 pub(crate) fn convert_fill(
diff --git a/crates/typst-pdf/src/shape.rs b/crates/typst-pdf/src/shape.rs
index 5b9232dbe..5dc23563b 100644
--- a/crates/typst-pdf/src/shape.rs
+++ b/crates/typst-pdf/src/shape.rs
@@ -6,7 +6,7 @@ use typst_syntax::Span;
 
 use crate::convert::{FrameContext, GlobalContext};
 use crate::paint;
-use crate::util::{convert_path, AbsExt, TransformExt};
+use crate::util::{AbsExt, TransformExt, convert_path};
 
 #[typst_macros::time(name = "handle shape")]
 pub(crate) fn handle_shape(
@@ -35,11 +35,7 @@ pub(crate) fn handle_shape(
         };
 
         let stroke = shape.stroke.as_ref().and_then(|stroke| {
-            if stroke.thickness.to_f32() > 0.0 {
-                Some(stroke)
-            } else {
-                None
-            }
+            if stroke.thickness.to_f32() > 0.0 { Some(stroke) } else { None }
         });
 
         let stroke = if let Some(stroke) = &stroke {
diff --git a/crates/typst-pdf/src/text.rs b/crates/typst-pdf/src/text.rs
index 9876927d0..8bce738ce 100644
--- a/crates/typst-pdf/src/text.rs
+++ b/crates/typst-pdf/src/text.rs
@@ -4,7 +4,7 @@ use std::sync::Arc;
 use bytemuck::TransparentWrapper;
 use krilla::surface::{Location, Surface};
 use krilla::text::GlyphId;
-use typst_library::diag::{bail, SourceResult};
+use typst_library::diag::{SourceResult, bail};
 use typst_library::layout::Size;
 use typst_library::text::{Font, Glyph, TextItem};
 use typst_library::visualize::FillRule;
@@ -12,7 +12,7 @@ use typst_syntax::Span;
 
 use crate::convert::{FrameContext, GlobalContext};
 use crate::paint;
-use crate::util::{display_font, AbsExt, TransformExt};
+use crate::util::{AbsExt, TransformExt, display_font};
 
 #[typst_macros::time(name = "handle text")]
 pub(crate) fn handle_text(
diff --git a/crates/typst-realize/src/lib.rs b/crates/typst-realize/src/lib.rs
index cbb3ac21d..abdecb079 100644
--- a/crates/typst-realize/src/lib.rs
+++ b/crates/typst-realize/src/lib.rs
@@ -11,7 +11,7 @@ use arrayvec::ArrayVec;
 use bumpalo::collections::{String as BumpString, Vec as BumpVec};
 use comemo::Track;
 use ecow::EcoString;
-use typst_library::diag::{bail, At, SourceResult};
+use typst_library::diag::{At, SourceResult, bail};
 use typst_library::engine::Engine;
 use typst_library::foundations::{
     Content, Context, ContextElem, Element, NativeElement, NativeShowRule, Recipe,
@@ -308,10 +308,11 @@ fn visit_kind_rules<'a>(
                 return Ok(true);
             }
         } else if let Some(elem) = content.to_packed::<TextElem>()
-            && let Some(m) = find_regex_match_in_str(&elem.text, styles) {
-                visit_regex_match(s, &[(content, styles)], m)?;
-                return Ok(true);
-            }
+            && let Some(m) = find_regex_match_in_str(&elem.text, styles)
+        {
+            visit_regex_match(s, &[(content, styles)], m)?;
+            return Ok(true);
+        }
     } else {
         // Transparently wrap mathy content into equations.
         if content.can::<dyn Mathy>() && !content.is::<EquationElem>() {
@@ -1091,10 +1092,9 @@ fn find_regex_match_in_elems<'a>(
         }
 
         let linebreak = content.is::<LinebreakElem>();
-        if linebreak
-            && let SpaceState::Space(_) = space {
-                buf.pop();
-            }
+        if linebreak && let SpaceState::Space(_) = space {
+            buf.pop();
+        }
 
         if styles != current && !buf.is_empty() {
             leftmost = find_regex_match_in_str(&buf, current);
diff --git a/crates/typst-render/src/lib.rs b/crates/typst-render/src/lib.rs
index 5a993dbb9..2b717b3bc 100644
--- a/crates/typst-render/src/lib.rs
+++ b/crates/typst-render/src/lib.rs
@@ -130,11 +130,7 @@ impl State<'_> {
     /// Sets the current mask.
     fn with_mask(self, mask: Option<&sk::Mask>) -> State<'_> {
         // Ensure that we're using the parent's mask if we don't have one.
-        if mask.is_some() {
-            State { mask, ..self }
-        } else {
-            State { mask: None, ..self }
-        }
+        if mask.is_some() { State { mask, ..self } } else { State { mask: None, ..self } }
     }
 
     /// Sets the size of the first hard frame in the hierarchy.
@@ -196,36 +192,36 @@ fn render_group(canvas: &mut sk::Pixmap, state: State, pos: Point, group: &Group
     if let Some(clip_curve) = group.clip.as_ref()
         && let Some(path) = shape::convert_curve(clip_curve)
             .and_then(|path| path.transform(state.transform))
-        {
-            if let Some(mask) = mask {
-                let mut mask = mask.clone();
-                mask.intersect_path(
-                    &path,
-                    sk::FillRule::default(),
-                    true,
-                    sk::Transform::default(),
-                );
-                storage = mask;
-            } else {
-                let pxw = canvas.width();
-                let pxh = canvas.height();
-                let Some(mut mask) = sk::Mask::new(pxw, pxh) else {
-                    // Fails if clipping rect is empty. In that case we just
-                    // clip everything by returning.
-                    return;
-                };
-
-                mask.fill_path(
-                    &path,
-                    sk::FillRule::default(),
-                    true,
-                    sk::Transform::default(),
-                );
-                storage = mask;
+    {
+        if let Some(mask) = mask {
+            let mut mask = mask.clone();
+            mask.intersect_path(
+                &path,
+                sk::FillRule::default(),
+                true,
+                sk::Transform::default(),
+            );
+            storage = mask;
+        } else {
+            let pxw = canvas.width();
+            let pxh = canvas.height();
+            let Some(mut mask) = sk::Mask::new(pxw, pxh) else {
+                // Fails if clipping rect is empty. In that case we just
+                // clip everything by returning.
+                return;
             };
 
-            mask = Some(&storage);
-        }
+            mask.fill_path(
+                &path,
+                sk::FillRule::default(),
+                true,
+                sk::Transform::default(),
+            );
+            storage = mask;
+        };
+
+        mask = Some(&storage);
+    }
 
     render_frame(canvas, state.with_mask(mask), &group.frame);
 }
diff --git a/crates/typst-render/src/shape.rs b/crates/typst-render/src/shape.rs
index 9b50d5f1f..bf55c8b5e 100644
--- a/crates/typst-render/src/shape.rs
+++ b/crates/typst-render/src/shape.rs
@@ -5,7 +5,7 @@ use typst_library::visualize::{
     Shape,
 };
 
-use crate::{paint, AbsExt, State};
+use crate::{AbsExt, State, paint};
 
 /// Render a geometrical shape into the canvas.
 pub fn render_shape(canvas: &mut sk::Pixmap, state: State, shape: &Shape) -> Option<()> {
diff --git a/crates/typst-render/src/text.rs b/crates/typst-render/src/text.rs
index a56528220..c411d7ae7 100644
--- a/crates/typst-render/src/text.rs
+++ b/crates/typst-render/src/text.rs
@@ -9,7 +9,7 @@ use typst_library::text::{Font, TextItem};
 use typst_library::visualize::{FixedStroke, Paint};
 
 use crate::paint::{self, GradientSampler, PaintSampler, TilingSampler};
-use crate::{shape, AbsExt, State};
+use crate::{AbsExt, State, shape};
 
 /// Render a text run into the canvas.
 pub fn render_text(canvas: &mut sk::Pixmap, state: State, text: &TextItem) {
@@ -87,28 +87,29 @@ fn render_outline_glyph(
 
         if let Some(FixedStroke { paint, thickness, cap, join, dash, miter_limit }) =
             &text.stroke
-            && thickness.to_f32() > 0.0 {
-                let dash = dash.as_ref().and_then(shape::to_sk_dash_pattern);
+            && thickness.to_f32() > 0.0
+        {
+            let dash = dash.as_ref().and_then(shape::to_sk_dash_pattern);
 
-                let paint = paint::to_sk_paint(
-                    paint,
-                    state_ts,
-                    Size::zero(),
-                    true,
-                    None,
-                    &mut pixmap,
-                    None,
-                );
-                let stroke = sk::Stroke {
-                    width: thickness.to_f32() / scale, // When we scale the path, we need to scale the stroke width, too.
-                    line_cap: shape::to_sk_line_cap(*cap),
-                    line_join: shape::to_sk_line_join(*join),
-                    dash,
-                    miter_limit: miter_limit.get() as f32,
-                };
+            let paint = paint::to_sk_paint(
+                paint,
+                state_ts,
+                Size::zero(),
+                true,
+                None,
+                &mut pixmap,
+                None,
+            );
+            let stroke = sk::Stroke {
+                width: thickness.to_f32() / scale, // When we scale the path, we need to scale the stroke width, too.
+                line_cap: shape::to_sk_line_cap(*cap),
+                line_join: shape::to_sk_line_join(*join),
+                dash,
+                miter_limit: miter_limit.get() as f32,
+            };
 
-                canvas.stroke_path(&path, &paint, &stroke, ts, state.mask);
-            }
+            canvas.stroke_path(&path, &paint, &stroke, ts, state.mask);
+        }
         return Some(());
     }
 
diff --git a/crates/typst-svg/src/image.rs b/crates/typst-svg/src/image.rs
index fd4aecd4f..58f0227b6 100644
--- a/crates/typst-svg/src/image.rs
+++ b/crates/typst-svg/src/image.rs
@@ -1,6 +1,6 @@
 use base64::Engine;
-use ecow::{eco_format, EcoString};
-use image::{codecs::png::PngEncoder, ImageEncoder};
+use ecow::{EcoString, eco_format};
+use image::{ImageEncoder, codecs::png::PngEncoder};
 use typst_library::foundations::Smart;
 use typst_library::layout::{Abs, Axes};
 use typst_library::visualize::{
diff --git a/crates/typst-svg/src/lib.rs b/crates/typst-svg/src/lib.rs
index 85bd5d7cb..c33747b31 100644
--- a/crates/typst-svg/src/lib.rs
+++ b/crates/typst-svg/src/lib.rs
@@ -341,10 +341,11 @@ impl<'a> SVGRenderer<'a> {
                 // TODO: Location links on the same page could also be supported
                 // outside of HTML.
                 if let Some(introspector) = self.introspector
-                    && let Some(id) = introspector.html_id(*loc) {
-                        self.xml.write_attribute_fmt("href", format_args!("#{id}"));
-                        self.xml.write_attribute_fmt("xlink:href", format_args!("#{id}"));
-                    }
+                    && let Some(id) = introspector.html_id(*loc)
+                {
+                    self.xml.write_attribute_fmt("href", format_args!("#{id}"));
+                    self.xml.write_attribute_fmt("xlink:href", format_args!("#{id}"));
+                }
             }
             Destination::Position(_) => {
                 // TODO: Links on the same page could be supported.
diff --git a/crates/typst-svg/src/paint.rs b/crates/typst-svg/src/paint.rs
index 1a9acaecf..a955a4d16 100644
--- a/crates/typst-svg/src/paint.rs
+++ b/crates/typst-svg/src/paint.rs
@@ -1,6 +1,6 @@
 use std::f32::consts::TAU;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use ttf_parser::OutlineBuilder;
 use typst_library::foundations::Repr;
 use typst_library::layout::{Angle, Axes, Frame, Quadrant, Ratio, Size, Transform};
diff --git a/crates/typst-syntax/src/ast.rs b/crates/typst-syntax/src/ast.rs
index 547d53cd8..d629f24d7 100644
--- a/crates/typst-syntax/src/ast.rs
+++ b/crates/typst-syntax/src/ast.rs
@@ -86,7 +86,7 @@ use ecow::EcoString;
 use unscanny::Scanner;
 
 use crate::package::PackageSpec;
-use crate::{is_ident, is_newline, Span, SyntaxKind, SyntaxNode};
+use crate::{Span, SyntaxKind, SyntaxNode, is_ident, is_newline};
 
 /// A typed AST node.
 pub trait AstNode<'a>: Sized {
diff --git a/crates/typst-syntax/src/file.rs b/crates/typst-syntax/src/file.rs
index 380ca2346..0fcea91c2 100644
--- a/crates/typst-syntax/src/file.rs
+++ b/crates/typst-syntax/src/file.rs
@@ -5,8 +5,8 @@ use std::fmt::{self, Debug, Formatter};
 use std::num::NonZeroU16;
 use std::sync::{LazyLock, RwLock};
 
-use crate::package::PackageSpec;
 use crate::VirtualPath;
+use crate::package::PackageSpec;
 
 /// The global package-path interner.
 static INTERNER: LazyLock<RwLock<Interner>> = LazyLock::new(|| {
diff --git a/crates/typst-syntax/src/highlight.rs b/crates/typst-syntax/src/highlight.rs
index 9754312b3..0cd83105a 100644
--- a/crates/typst-syntax/src/highlight.rs
+++ b/crates/typst-syntax/src/highlight.rs
@@ -1,4 +1,4 @@
-use crate::{ast, LinkedNode, SyntaxKind, SyntaxNode};
+use crate::{LinkedNode, SyntaxKind, SyntaxNode, ast};
 
 /// A syntax highlighting tag.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
@@ -302,16 +302,13 @@ fn highlight_ident(node: &LinkedNode) -> Option<Tag> {
     let next_leaf = node.next_leaf();
     if let Some(next) = &next_leaf
         && node.range().end == next.offset()
-            && ((next.kind() == SyntaxKind::LeftParen
-                && matches!(
-                    next.parent_kind(),
-                    Some(SyntaxKind::Args | SyntaxKind::Params)
-                ))
-                || (next.kind() == SyntaxKind::LeftBracket
-                    && next.parent_kind() == Some(SyntaxKind::ContentBlock)))
-        {
-            return Some(Tag::Function);
-        }
+        && ((next.kind() == SyntaxKind::LeftParen
+            && matches!(next.parent_kind(), Some(SyntaxKind::Args | SyntaxKind::Params)))
+            || (next.kind() == SyntaxKind::LeftBracket
+                && next.parent_kind() == Some(SyntaxKind::ContentBlock)))
+    {
+        return Some(Tag::Function);
+    }
 
     // Are we in math?
     if node.kind() == SyntaxKind::MathIdent {
@@ -379,12 +376,13 @@ pub fn highlight_html(root: &SyntaxNode) -> String {
 fn highlight_html_impl(html: &mut String, node: &LinkedNode) {
     let mut span = false;
     if let Some(tag) = highlight(node)
-        && tag != Tag::Error {
-            span = true;
-            html.push_str("<span class=\"");
-            html.push_str(tag.css_class());
-            html.push_str("\">");
-        }
+        && tag != Tag::Error
+    {
+        span = true;
+        html.push_str("<span class=\"");
+        html.push_str(tag.css_class());
+        html.push_str("\">");
+    }
 
     let text = node.text();
     if !text.is_empty() {
diff --git a/crates/typst-syntax/src/lexer.rs b/crates/typst-syntax/src/lexer.rs
index 9da45958f..40b1e2994 100644
--- a/crates/typst-syntax/src/lexer.rs
+++ b/crates/typst-syntax/src/lexer.rs
@@ -1,4 +1,4 @@
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use unicode_ident::{is_xid_continue, is_xid_start};
 use unicode_script::{Script, UnicodeScript};
 use unicode_segmentation::UnicodeSegmentation;
@@ -205,11 +205,7 @@ impl Lexer<'_> {
             ':' => SyntaxKind::Colon,
             '=' => {
                 self.s.eat_while('=');
-                if self.space_or_end() {
-                    SyntaxKind::HeadingMarker
-                } else {
-                    self.text()
-                }
+                if self.space_or_end() { SyntaxKind::HeadingMarker } else { self.text() }
             }
             '-' if self.space_or_end() => SyntaxKind::ListMarker,
             '+' if self.space_or_end() => SyntaxKind::EnumMarker,
@@ -784,15 +780,12 @@ impl Lexer<'_> {
 
         let prev = self.s.get(0..start);
         if (!prev.ends_with(['.', '@']) || prev.ends_with(".."))
-            && let Some(keyword) = keyword(ident) {
-                return keyword;
-            }
-
-        if ident == "_" {
-            SyntaxKind::Underscore
-        } else {
-            SyntaxKind::Ident
+            && let Some(keyword) = keyword(ident)
+        {
+            return keyword;
         }
+
+        if ident == "_" { SyntaxKind::Underscore } else { SyntaxKind::Ident }
     }
 
     fn number(&mut self, start: usize, first_c: char) -> SyntaxKind {
diff --git a/crates/typst-syntax/src/lib.rs b/crates/typst-syntax/src/lib.rs
index 4741506c5..40e85bdad 100644
--- a/crates/typst-syntax/src/lib.rs
+++ b/crates/typst-syntax/src/lib.rs
@@ -17,7 +17,7 @@ mod source;
 mod span;
 
 pub use self::file::FileId;
-pub use self::highlight::{highlight, highlight_html, Tag};
+pub use self::highlight::{Tag, highlight, highlight_html};
 pub use self::kind::SyntaxKind;
 pub use self::lexer::{
     is_id_continue, is_id_start, is_ident, is_newline, is_valid_label_literal_id,
diff --git a/crates/typst-syntax/src/node.rs b/crates/typst-syntax/src/node.rs
index 15c96b08f..b983f1bdb 100644
--- a/crates/typst-syntax/src/node.rs
+++ b/crates/typst-syntax/src/node.rs
@@ -3,7 +3,7 @@ use std::ops::{Deref, Range};
 use std::rc::Rc;
 use std::sync::Arc;
 
-use ecow::{eco_format, eco_vec, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format, eco_vec};
 
 use crate::{FileId, Span, SyntaxKind};
 
@@ -733,9 +733,10 @@ impl<'a> LinkedNode<'a> {
                 if children
                     .peek()
                     .is_none_or(|next| next.span().number() > span.number())
-                    && let Some(found) = child.find(span) {
-                        return Some(found);
-                    }
+                    && let Some(found) = child.find(span)
+                {
+                    return Some(found);
+                }
             }
         }
 
@@ -757,11 +758,7 @@ impl LinkedNode<'_> {
         let node = parent.node.children().nth(index)?;
         let offset = self.offset - node.len();
         let prev = Self { node, parent: self.parent.clone(), index, offset };
-        if prev.kind().is_trivia() {
-            prev.prev_sibling()
-        } else {
-            Some(prev)
-        }
+        if prev.kind().is_trivia() { prev.prev_sibling() } else { Some(prev) }
     }
 
     /// Get the next non-trivia sibling node.
@@ -771,11 +768,7 @@ impl LinkedNode<'_> {
         let node = parent.node.children().nth(index)?;
         let offset = self.offset + self.node.len();
         let next = Self { node, parent: self.parent.clone(), index, offset };
-        if next.kind().is_trivia() {
-            next.next_sibling()
-        } else {
-            Some(next)
-        }
+        if next.kind().is_trivia() { next.next_sibling() } else { Some(next) }
     }
 
     /// Get the kind of this node's parent.
diff --git a/crates/typst-syntax/src/package.rs b/crates/typst-syntax/src/package.rs
index aa537863d..fe3577a3b 100644
--- a/crates/typst-syntax/src/package.rs
+++ b/crates/typst-syntax/src/package.rs
@@ -4,7 +4,7 @@ use std::collections::BTreeMap;
 use std::fmt::{self, Debug, Display, Formatter};
 use std::str::FromStr;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use serde::de::IgnoredAny;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use unscanny::Scanner;
@@ -562,8 +562,9 @@ mod tests {
     fn tool_section() {
         // NOTE: tool section must be table of tables, but we can't easily
         // compare the error structurally
-        assert!(toml::from_str::<PackageManifest>(
-            r#"
+        assert!(
+            toml::from_str::<PackageManifest>(
+                r#"
                 [package]
                 name = "package"
                 version = "0.1.0"
@@ -572,8 +573,9 @@ mod tests {
                 [tool]
                 not-table = "str"
             "#
-        )
-        .is_err());
+            )
+            .is_err()
+        );
 
         #[derive(Debug, PartialEq, Serialize, Deserialize)]
         struct MyTool {
diff --git a/crates/typst-syntax/src/parser.rs b/crates/typst-syntax/src/parser.rs
index 22f073601..5b354e9cd 100644
--- a/crates/typst-syntax/src/parser.rs
+++ b/crates/typst-syntax/src/parser.rs
@@ -2,12 +2,12 @@ use std::collections::{HashMap, HashSet};
 use std::mem;
 use std::ops::{Index, IndexMut, Range};
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_utils::default_math_class;
 use unicode_math_class::MathClass;
 
-use crate::set::{syntax_set, SyntaxSet};
-use crate::{ast, set, Lexer, SyntaxError, SyntaxKind, SyntaxMode, SyntaxNode};
+use crate::set::{SyntaxSet, syntax_set};
+use crate::{Lexer, SyntaxError, SyntaxKind, SyntaxMode, SyntaxNode, ast, set};
 
 /// Parses a source file as top-level markup.
 pub fn parse(text: &str) -> SyntaxNode {
@@ -443,12 +443,14 @@ fn math_unparen(p: &mut Parser, m: Marker) {
     }
 
     if let [first, .., last] = node.children_mut()
-        && first.text() == "(" && last.text() == ")" {
-            first.convert_to_kind(SyntaxKind::LeftParen);
-            last.convert_to_kind(SyntaxKind::RightParen);
-            // Only convert if we did have regular parens.
-            node.convert_to_kind(SyntaxKind::Math);
-        }
+        && first.text() == "("
+        && last.text() == ")"
+    {
+        first.convert_to_kind(SyntaxKind::LeftParen);
+        last.convert_to_kind(SyntaxKind::RightParen);
+        // Only convert if we did have regular parens.
+        node.convert_to_kind(SyntaxKind::Math);
+    }
 }
 
 /// The unicode math class of a string. Only returns `Some` if `text` has
@@ -1198,10 +1200,10 @@ fn array_or_dict_item(p: &mut Parser, state: &mut GroupState) {
             Some(ast::Expr::Ident(ident)) => Some(ident.get().clone()),
             Some(ast::Expr::Str(s)) => Some(s.get()),
             _ => None,
+        } && !state.seen.insert(key.clone())
+        {
+            node.convert_to_error(eco_format!("duplicate key: {key}"));
         }
-            && !state.seen.insert(key.clone()) {
-                node.convert_to_error(eco_format!("duplicate key: {key}"));
-            }
 
         p.wrap(m, pair_kind);
         state.maybe_just_parens = false;
@@ -1854,15 +1856,16 @@ impl<'s> Parser<'s> {
         func(self);
         self.nl_mode = previous;
         if let Some(newline) = self.token.newline
-            && mode != previous {
-                // Restore our actual token's kind or insert a fake end.
-                let actual_kind = self.token.node.kind();
-                if self.nl_mode.stop_at(newline, actual_kind) {
-                    self.token.kind = SyntaxKind::End;
-                } else {
-                    self.token.kind = actual_kind;
-                }
+            && mode != previous
+        {
+            // Restore our actual token's kind or insert a fake end.
+            let actual_kind = self.token.node.kind();
+            if self.nl_mode.stop_at(newline, actual_kind) {
+                self.token.kind = SyntaxKind::End;
+            } else {
+                self.token.kind = actual_kind;
             }
+        }
     }
 
     /// Move the lexer forward and prepare the current token. In Code, this
diff --git a/crates/typst-syntax/src/reparser.rs b/crates/typst-syntax/src/reparser.rs
index 2df606310..e0bc2214a 100644
--- a/crates/typst-syntax/src/reparser.rs
+++ b/crates/typst-syntax/src/reparser.rs
@@ -1,7 +1,7 @@
 use std::ops::Range;
 
 use crate::{
-    is_newline, parse, reparse_block, reparse_markup, Span, SyntaxKind, SyntaxNode,
+    Span, SyntaxKind, SyntaxNode, is_newline, parse, reparse_block, reparse_markup,
 };
 
 /// Refresh the given syntax node with as little parsing as possible.
@@ -71,12 +71,13 @@ fn try_reparse(
 
             // If the child is a block, try to reparse the block.
             if child.kind().is_block()
-                && let Some(newborn) = reparse_block(text, new_range.clone()) {
-                    return node
-                        .replace_children(i..i + 1, vec![newborn])
-                        .is_ok()
-                        .then_some(new_range);
-                }
+                && let Some(newborn) = reparse_block(text, new_range.clone())
+            {
+                return node
+                    .replace_children(i..i + 1, vec![newborn])
+                    .is_ok()
+                    .then_some(new_range);
+            }
         }
 
         // Does the child overlap with the edit?
@@ -239,7 +240,7 @@ fn next_nesting(node: &SyntaxNode, nesting: &mut usize) {
 mod tests {
     use std::ops::Range;
 
-    use crate::{parse, Source, Span};
+    use crate::{Source, Span, parse};
 
     #[track_caller]
     fn test(prev: &str, range: Range<usize>, with: &str, incremental: bool) {
diff --git a/crates/typst-syntax/src/source.rs b/crates/typst-syntax/src/source.rs
index abde1f981..05cfd62db 100644
--- a/crates/typst-syntax/src/source.rs
+++ b/crates/typst-syntax/src/source.rs
@@ -9,7 +9,7 @@ use typst_utils::LazyHash;
 
 use crate::lines::Lines;
 use crate::reparser::reparse;
-use crate::{parse, FileId, LinkedNode, Span, SyntaxNode, VirtualPath};
+use crate::{FileId, LinkedNode, Span, SyntaxNode, VirtualPath, parse};
 
 /// A source file.
 ///
diff --git a/crates/typst-syntax/src/span.rs b/crates/typst-syntax/src/span.rs
index b383ec27f..ff596c3a2 100644
--- a/crates/typst-syntax/src/span.rs
+++ b/crates/typst-syntax/src/span.rs
@@ -155,11 +155,7 @@ impl Span {
 
     /// Return `other` if `self` is detached and `self` otherwise.
     pub fn or(self, other: Self) -> Self {
-        if self.is_detached() {
-            other
-        } else {
-            self
-        }
+        if self.is_detached() { other } else { self }
     }
 
     /// Find the first non-detached span in the iterator.
diff --git a/crates/typst-utils/src/fat.rs b/crates/typst-utils/src/fat.rs
index 40751532b..d0d8c9cdb 100644
--- a/crates/typst-utils/src/fat.rs
+++ b/crates/typst-utils/src/fat.rs
@@ -16,11 +16,13 @@ use std::ptr::NonNull;
 /// to a value whose type implements the trait of `T` and the `vtable` must have
 /// been extracted with [`vtable`].
 #[track_caller]
-pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *const T { unsafe {
-    let fat = FatPointer { data, vtable };
-    debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
-    mem::transmute_copy::<FatPointer, *const T>(&fat)
-}}
+pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *const T {
+    unsafe {
+        let fat = FatPointer { data, vtable };
+        debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
+        mem::transmute_copy::<FatPointer, *const T>(&fat)
+    }
+}
 
 /// Create a mutable fat pointer from a data address and a vtable address.
 ///
@@ -29,23 +31,27 @@ pub unsafe fn from_raw_parts<T: ?Sized>(data: *const (), vtable: *const ()) -> *
 /// to a value whose type implements the trait of `T` and the `vtable` must have
 /// been extracted with [`vtable`].
 #[track_caller]
-pub unsafe fn from_raw_parts_mut<T: ?Sized>(data: *mut (), vtable: *const ()) -> *mut T { unsafe {
-    let fat = FatPointer { data, vtable };
-    debug_assert_eq!(Layout::new::<*mut T>(), Layout::new::<FatPointer>());
-    mem::transmute_copy::<FatPointer, *mut T>(&fat)
-}}
+pub unsafe fn from_raw_parts_mut<T: ?Sized>(data: *mut (), vtable: *const ()) -> *mut T {
+    unsafe {
+        let fat = FatPointer { data, vtable };
+        debug_assert_eq!(Layout::new::<*mut T>(), Layout::new::<FatPointer>());
+        mem::transmute_copy::<FatPointer, *mut T>(&fat)
+    }
+}
 
 /// Extract the address to a trait object's vtable.
 ///
 /// # Safety
 /// Must only be called when `T` is a `dyn Trait`.
 #[track_caller]
-pub unsafe fn vtable<T: ?Sized>(ptr: *const T) -> NonNull<()> { unsafe {
-    debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
-    NonNull::new_unchecked(
-        mem::transmute_copy::<*const T, FatPointer>(&ptr).vtable as *mut (),
-    )
-}}
+pub unsafe fn vtable<T: ?Sized>(ptr: *const T) -> NonNull<()> {
+    unsafe {
+        debug_assert_eq!(Layout::new::<*const T>(), Layout::new::<FatPointer>());
+        NonNull::new_unchecked(
+            mem::transmute_copy::<*const T, FatPointer>(&ptr).vtable as *mut (),
+        )
+    }
+}
 
 /// The memory representation of a trait object pointer.
 ///
diff --git a/crates/typst-utils/src/pico.rs b/crates/typst-utils/src/pico.rs
index 5f17a2672..b6f269af8 100644
--- a/crates/typst-utils/src/pico.rs
+++ b/crates/typst-utils/src/pico.rs
@@ -330,11 +330,7 @@ mod exceptions {
 
     /// Determine the minimum of two integers.
     const fn min(a: usize, b: usize) -> usize {
-        if a < b {
-            a
-        } else {
-            b
-        }
+        if a < b { a } else { b }
     }
 }
 
diff --git a/crates/typst/src/lib.rs b/crates/typst/src/lib.rs
index 8b4e60eee..47e5531fd 100644
--- a/crates/typst/src/lib.rs
+++ b/crates/typst/src/lib.rs
@@ -42,10 +42,10 @@ use std::collections::HashSet;
 use std::sync::LazyLock;
 
 use comemo::{Track, Tracked, Validate};
-use ecow::{eco_format, eco_vec, EcoString, EcoVec};
+use ecow::{EcoString, EcoVec, eco_format, eco_vec};
 use typst_html::HtmlDocument;
 use typst_library::diag::{
-    bail, warning, FileError, SourceDiagnostic, SourceResult, Warned,
+    FileError, SourceDiagnostic, SourceResult, Warned, bail, warning,
 };
 use typst_library::engine::{Engine, Route, Sink, Traced};
 use typst_library::foundations::{NativeRuleMap, StyleChain, Styles, Value};
@@ -53,7 +53,7 @@ use typst_library::introspection::Introspector;
 use typst_library::layout::PagedDocument;
 use typst_library::routines::Routines;
 use typst_syntax::{FileId, Span};
-use typst_timing::{timed, TimingScope};
+use typst_timing::{TimingScope, timed};
 
 use crate::foundations::{Target, TargetElem};
 use crate::model::DocumentInfo;
diff --git a/docs/src/html.rs b/docs/src/html.rs
index 9c02f08e9..f1c175bb7 100644
--- a/docs/src/html.rs
+++ b/docs/src/html.rs
@@ -16,7 +16,7 @@ use typst::{Library, World};
 use unscanny::Scanner;
 use yaml_front_matter::YamlFrontMatter;
 
-use crate::{contributors, OutlineItem, Resolver, FONTS, LIBRARY};
+use crate::{FONTS, LIBRARY, OutlineItem, Resolver, contributors};
 
 /// HTML documentation.
 #[derive(Serialize)]
@@ -84,14 +84,16 @@ impl Html {
             md::Parser::new_with_broken_link_callback(text, options, Some(&mut link))
                 .peekable();
 
-        let iter = std::iter::from_fn(|| loop {
-            let mut event = events.next()?;
-            handler.peeked = events.peek().and_then(|event| match event {
-                md::Event::Text(text) => Some(text.clone()),
-                _ => None,
-            });
-            if handler.handle(&mut event) {
-                return Some(event);
+        let iter = std::iter::from_fn(|| {
+            loop {
+                let mut event = events.next()?;
+                handler.peeked = events.peek().and_then(|event| match event {
+                    md::Event::Text(text) => Some(text.clone()),
+                    _ => None,
+                });
+                if handler.handle(&mut event) {
+                    return Some(event);
+                }
             }
         });
 
diff --git a/docs/src/lib.rs b/docs/src/lib.rs
index 155ffb827..352b90dec 100644
--- a/docs/src/lib.rs
+++ b/docs/src/lib.rs
@@ -11,12 +11,12 @@ pub use self::model::*;
 
 use std::collections::HashSet;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use heck::ToTitleCase;
 use serde::Deserialize;
 use serde_yaml as yaml;
 use std::sync::LazyLock;
-use typst::diag::{bail, StrResult};
+use typst::diag::{StrResult, bail};
 use typst::foundations::{
     AutoValue, Binding, Bytes, CastInfo, Func, Module, NoneValue, ParamInfo, Repr, Scope,
     Smart, Type, Value,
@@ -103,7 +103,7 @@ pub trait Resolver {
 
     /// Produce HTML for an example.
     fn example(&self, hash: u128, source: Option<Html>, document: &PagedDocument)
-        -> Html;
+    -> Html;
 
     /// Determine the commits between two tags.
     fn commits(&self, from: &str, to: &str) -> Vec<Commit>;
diff --git a/docs/src/link.rs b/docs/src/link.rs
index b883399e5..2c2fce21c 100644
--- a/docs/src/link.rs
+++ b/docs/src/link.rs
@@ -1,7 +1,7 @@
-use typst::diag::{bail, StrResult};
+use typst::diag::{StrResult, bail};
 use typst::foundations::{Binding, Func};
 
-use crate::{get_module, GROUPS, LIBRARY};
+use crate::{GROUPS, LIBRARY, get_module};
 
 /// Resolve an intra-doc link.
 pub fn resolve(link: &str, base: &str) -> StrResult<String> {
@@ -97,10 +97,11 @@ fn resolve_definition(head: &str, base: &str) -> StrResult<String> {
             route.push_str("/#definitions-");
             route.push_str(next);
             if let Some(next) = parts.next()
-                && field.cast::<Func>().is_ok_and(|func| func.param(next).is_some()) {
-                    route.push('-');
-                    route.push_str(next);
-                }
+                && field.cast::<Func>().is_ok_and(|func| func.param(next).is_some())
+            {
+                route.push('-');
+                route.push_str(next);
+            }
         } else if value
             .clone()
             .cast::<Func>()
diff --git a/docs/src/main.rs b/docs/src/main.rs
index d14c1347a..707cd7da2 100644
--- a/docs/src/main.rs
+++ b/docs/src/main.rs
@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
 
 use clap::Parser;
 use typst::layout::PagedDocument;
-use typst_docs::{provide, Html, Resolver};
+use typst_docs::{Html, Resolver, provide};
 use typst_render::render;
 
 #[derive(Debug)]
diff --git a/tests/fuzz/src/compile.rs b/tests/fuzz/src/compile.rs
index 1bc85fd62..3f1015339 100644
--- a/tests/fuzz/src/compile.rs
+++ b/tests/fuzz/src/compile.rs
@@ -67,8 +67,9 @@ impl World for FuzzWorld {
 fuzz_target!(|text: &str| {
     let world = FuzzWorld::new(text);
     if let Ok(document) = typst::compile::<PagedDocument>(&world).output
-        && let Some(page) = document.pages.first() {
-            std::hint::black_box(typst_render::render(page, 1.0));
-        }
+        && let Some(page) = document.pages.first()
+    {
+        std::hint::black_box(typst_render::render(page, 1.0));
+    }
     comemo::evict(10);
 });
diff --git a/tests/src/collect.rs b/tests/src/collect.rs
index 173488b01..d1b59cb9b 100644
--- a/tests/src/collect.rs
+++ b/tests/src/collect.rs
@@ -5,10 +5,10 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::LazyLock;
 
-use ecow::{eco_format, EcoString};
+use ecow::{EcoString, eco_format};
 use typst_syntax::package::PackageVersion;
 use typst_syntax::{
-    is_id_continue, is_ident, is_newline, FileId, Lines, Source, VirtualPath,
+    FileId, Lines, Source, VirtualPath, is_id_continue, is_ident, is_newline,
 };
 use unscanny::Scanner;
 
@@ -528,11 +528,7 @@ fn selected(name: &str, abs: PathBuf) -> bool {
     let patterns = &crate::ARGS.pattern;
     patterns.is_empty()
         || patterns.iter().any(|pattern: &regex::Regex| {
-            if exact {
-                name == pattern.as_str()
-            } else {
-                pattern.is_match(name)
-            }
+            if exact { name == pattern.as_str() } else { pattern.is_match(name) }
         })
 }
 
diff --git a/tests/src/custom.rs b/tests/src/custom.rs
index 965312abc..139d35f0c 100644
--- a/tests/src/custom.rs
+++ b/tests/src/custom.rs
@@ -1,9 +1,9 @@
 use std::fmt::Write;
 
+use typst::World;
 use typst::foundations::Smart;
 use typst::layout::PagedDocument;
 use typst::model::DocumentInfo;
-use typst::World;
 
 use crate::collect::Test;
 use crate::world::TestWorld;
diff --git a/tests/src/run.rs b/tests/src/run.rs
index 9af5c7899..913f9dd0b 100644
--- a/tests/src/run.rs
+++ b/tests/src/run.rs
@@ -14,7 +14,7 @@ use typst_syntax::{FileId, Lines};
 
 use crate::collect::{Attr, FileSize, NoteKind, Test};
 use crate::logger::TestResult;
-use crate::world::{system_path, TestWorld};
+use crate::world::{TestWorld, system_path};
 
 /// Runs a single test.
 ///
@@ -189,8 +189,14 @@ impl<'a> Runner<'a> {
                     log!(self, "reference output would exceed maximum size");
                     log!(self, "  maximum   | {}", FileSize(crate::REF_LIMIT));
                     log!(self, "  size      | {}", FileSize(ref_data.len()));
-                    log!(self, "please try to minimize the size of the test (smaller pages, less text, etc.)");
-                    log!(self, "if you think the test cannot be reasonably minimized, mark it as `large`");
+                    log!(
+                        self,
+                        "please try to minimize the size of the test (smaller pages, less text, etc.)"
+                    );
+                    log!(
+                        self,
+                        "if you think the test cannot be reasonably minimized, mark it as `large`"
+                    );
                     return;
                 }
                 std::fs::write(&ref_path, &ref_data).unwrap();
@@ -337,11 +343,7 @@ impl<'a> Runner<'a> {
             return "oob".into();
         };
 
-        if line == 1 {
-            format!("{col}")
-        } else {
-            format!("{line}:{col}")
-        }
+        if line == 1 { format!("{col}") } else { format!("{line}:{col}") }
     }
 
     #[track_caller]
diff --git a/tests/src/world.rs b/tests/src/world.rs
index 4b6cf5a34..85969700d 100644
--- a/tests/src/world.rs
+++ b/tests/src/world.rs
@@ -8,16 +8,16 @@ use std::sync::OnceLock;
 
 use comemo::Tracked;
 use parking_lot::Mutex;
-use typst::diag::{bail, At, FileError, FileResult, SourceResult, StrResult};
+use typst::diag::{At, FileError, FileResult, SourceResult, StrResult, bail};
 use typst::engine::Engine;
 use typst::foundations::{
-    func, Array, Bytes, Context, Datetime, IntoValue, NoneValue, Repr, Smart, Value,
+    Array, Bytes, Context, Datetime, IntoValue, NoneValue, Repr, Smart, Value, func,
 };
 use typst::layout::{Abs, Margin, PageElem};
 use typst::model::{Numbering, NumberingPattern};
 use typst::syntax::{FileId, Source, Span};
 use typst::text::{Font, FontBook, TextElem, TextSize};
-use typst::utils::{singleton, LazyHash};
+use typst::utils::{LazyHash, singleton};
 use typst::visualize::Color;
 use typst::{Feature, Library, LibraryExt, World};
 use typst_syntax::Lines;

From af2253ba16dfdc731e787e3a43a6f6a63ea65e0a Mon Sep 17 00:00:00 2001
From: Laurenz Stampfl <47084093+LaurenzV@users.noreply.github.com>
Date: Tue, 22 Jul 2025 13:06:44 +0200
Subject: [PATCH 099/101] Add support for PDF embedding (#6623)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 Cargo.lock                                    | 124 ++++++++++++++----
 Cargo.toml                                    |  10 +-
 crates/typst-library/Cargo.toml               |   1 +
 .../typst-library/src/visualize/image/mod.rs  |  76 ++++++++++-
 .../typst-library/src/visualize/image/pdf.rs  |  98 ++++++++++++++
 crates/typst-pdf/src/convert.rs               |  48 ++++++-
 crates/typst-pdf/src/image.rs                 |  21 ++-
 crates/typst-pdf/src/link.rs                  |   3 -
 crates/typst-render/Cargo.toml                |   2 +
 crates/typst-render/src/image.rs              |  61 ++++++++-
 crates/typst-svg/Cargo.toml                   |   2 +
 crates/typst-svg/src/image.rs                 |  66 +++++++++-
 docs/guides/guide-for-latex-users.md          |   9 --
 tests/ref/image-pdf-multiple-pages.png        | Bin 0 -> 7618 bytes
 tests/ref/image-pdf.png                       | Bin 0 -> 3987 bytes
 tests/suite/visualize/image.typ               |  15 ++-
 16 files changed, 473 insertions(+), 63 deletions(-)
 create mode 100644 crates/typst-library/src/visualize/image/pdf.rs
 create mode 100644 tests/ref/image-pdf-multiple-pages.png
 create mode 100644 tests/ref/image-pdf.png

diff --git a/Cargo.lock b/Cargo.lock
index 49a7c2b63..3e5fb87ee 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -181,9 +181,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.8.0"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"
+checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
 dependencies = [
  "serde",
 ]
@@ -214,9 +214,9 @@ checksum = "64fa3c856b712db6612c019f14756e64e4bcea13337a6b33b696333a9eaa2d06"
 
 [[package]]
 name = "bytemuck"
-version = "1.21.0"
+version = "1.23.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef657dfab802224e671f5818e9a4935f9b1957ed18e58292690cc39e7a4092a3"
+checksum = "5c76a5792e44e4abe34d3abf15636779261d45a7450612059293d1d2cfc63422"
 dependencies = [
  "bytemuck_derive",
 ]
@@ -964,6 +964,69 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "hayro"
+version = "0.1.0"
+source = "git+https://github.com/LaurenzV/hayro?rev=e701f95#e701f9569157a2fe4ade68930dc9e9283782dcca"
+dependencies = [
+ "bytemuck",
+ "hayro-interpret",
+ "image",
+ "kurbo",
+ "rustc-hash",
+ "smallvec",
+]
+
+[[package]]
+name = "hayro-font"
+version = "0.1.0"
+source = "git+https://github.com/LaurenzV/hayro?rev=e701f95#e701f9569157a2fe4ade68930dc9e9283782dcca"
+dependencies = [
+ "log",
+ "phf",
+]
+
+[[package]]
+name = "hayro-interpret"
+version = "0.1.0"
+source = "git+https://github.com/LaurenzV/hayro?rev=e701f95#e701f9569157a2fe4ade68930dc9e9283782dcca"
+dependencies = [
+ "bitflags 2.9.1",
+ "hayro-font",
+ "hayro-syntax",
+ "kurbo",
+ "log",
+ "phf",
+ "qcms",
+ "skrifa",
+ "smallvec",
+ "yoke 0.8.0",
+]
+
+[[package]]
+name = "hayro-syntax"
+version = "0.0.1"
+source = "git+https://github.com/LaurenzV/hayro?rev=e701f95#e701f9569157a2fe4ade68930dc9e9283782dcca"
+dependencies = [
+ "flate2",
+ "kurbo",
+ "log",
+ "rustc-hash",
+ "smallvec",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "hayro-write"
+version = "0.1.0"
+source = "git+https://github.com/LaurenzV/hayro?rev=e701f95#e701f9569157a2fe4ade68930dc9e9283782dcca"
+dependencies = [
+ "flate2",
+ "hayro-syntax",
+ "log",
+ "pdf-writer",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -1200,9 +1263,9 @@ dependencies = [
 
 [[package]]
 name = "image"
-version = "0.25.5"
+version = "0.25.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd6f44aed642f18953a158afeb30206f4d50da59fbc66ecb53c66488de73563b"
+checksum = "db35664ce6b9810857a38a906215e75a9c879f0696556a39f59c62829710251a"
 dependencies = [
  "bytemuck",
  "byteorder-lite",
@@ -1265,7 +1328,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "inotify-sys",
  "libc",
 ]
@@ -1361,7 +1424,7 @@ dependencies = [
 [[package]]
 name = "krilla"
 version = "0.4.0"
-source = "git+https://github.com/LaurenzV/krilla?rev=20c14fe#20c14fefee5002566b3d6668b338bbe2168784e7"
+source = "git+https://github.com/LaurenzV/krilla?rev=37b9a00#37b9a00bfac87ed0b347b7cf8e9d37a6f68fcccd"
 dependencies = [
  "base64",
  "bumpalo",
@@ -1370,6 +1433,7 @@ dependencies = [
  "float-cmp 0.10.0",
  "fxhash",
  "gif",
+ "hayro-write",
  "image-webp",
  "imagesize",
  "once_cell",
@@ -1379,6 +1443,7 @@ dependencies = [
  "rustybuzz",
  "siphasher",
  "skrifa",
+ "smallvec",
  "subsetter",
  "tiny-skia-path",
  "xmp-writer",
@@ -1389,7 +1454,7 @@ dependencies = [
 [[package]]
 name = "krilla-svg"
 version = "0.1.0"
-source = "git+https://github.com/LaurenzV/krilla?rev=20c14fe#20c14fefee5002566b3d6668b338bbe2168784e7"
+source = "git+https://github.com/LaurenzV/krilla?rev=37b9a00#37b9a00bfac87ed0b347b7cf8e9d37a6f68fcccd"
 dependencies = [
  "flate2",
  "fontdb",
@@ -1402,9 +1467,9 @@ dependencies = [
 
 [[package]]
 name = "kurbo"
-version = "0.11.1"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89234b2cc610a7dd927ebde6b41dd1a5d4214cffaef4cf1fb2195d592f92518f"
+checksum = "1077d333efea6170d9ccb96d3c3026f300ca0773da4938cc4c811daa6df68b0c"
 dependencies = [
  "arrayvec",
  "smallvec",
@@ -1456,7 +1521,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "libc",
  "redox_syscall",
 ]
@@ -1622,7 +1687,7 @@ version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2fee8403b3d66ac7b26aee6e40a897d85dc5ce26f44da36b8b73e987cc52e943"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "filetime",
  "fsevent-sys",
  "inotify",
@@ -1704,7 +1769,7 @@ version = "0.10.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fedfea7d58a1f73118430a55da6a286e7b044961736ce96a16a17068ea25e5da"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "cfg-if",
  "foreign-types",
  "libc",
@@ -1841,7 +1906,7 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ea27c5015ab81753fc61e49f8cde74999346605ee148bb20008ef3d3150e0dc"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "itoa",
  "memchr",
  "ryu",
@@ -1999,7 +2064,7 @@ version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57206b407293d2bcd3af849ce869d52068623f19e1b5ff8e8778e3309439682b"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "getopts",
  "memchr",
  "unicase",
@@ -2112,7 +2177,7 @@ version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03a862b389f93e68874fbf580b9de08dd02facb9a788ebadaf4a3fd33cf58834"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
@@ -2215,7 +2280,7 @@ version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "errno",
  "libc",
  "linux-raw-sys",
@@ -2234,7 +2299,7 @@ version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd3c7c96f8a08ee34eff8857b11b49b07d71d1c3f4e88f8a88d4c9e9f90b1702"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "bytemuck",
  "core_maths",
  "log",
@@ -2282,7 +2347,7 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "core-foundation",
  "core-foundation-sys",
  "libc",
@@ -2445,9 +2510,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.13.2"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "spin"
@@ -2855,7 +2920,7 @@ dependencies = [
 [[package]]
 name = "typst-assets"
 version = "0.13.1"
-source = "git+https://github.com/typst/typst-assets?rev=edf0d64#edf0d648376e29738a05a933af9ea99bb81557b1"
+source = "git+https://github.com/typst/typst-assets?rev=fbf00f9#fbf00f9539fdb0825bef4d39fb57d5986c51b756"
 
 [[package]]
 name = "typst-cli"
@@ -2905,7 +2970,7 @@ dependencies = [
 [[package]]
 name = "typst-dev-assets"
 version = "0.13.1"
-source = "git+https://github.com/typst/typst-dev-assets?rev=bfa947f#bfa947f3433d7d13a995168c40ae788a2ebfe648"
+source = "git+https://github.com/typst/typst-dev-assets?rev=c6c2acf#c6c2acf6cdc31f99a23a478d3d614f8bf806a4f5"
 
 [[package]]
 name = "typst-docs"
@@ -3055,7 +3120,7 @@ name = "typst-library"
 version = "0.13.1"
 dependencies = [
  "az",
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "bumpalo",
  "chinese-number",
  "ciborium",
@@ -3067,6 +3132,7 @@ dependencies = [
  "fontdb",
  "glidesort",
  "hayagriva",
+ "hayro-syntax",
  "icu_properties",
  "icu_provider",
  "icu_provider_blob",
@@ -3165,11 +3231,13 @@ version = "0.13.1"
 dependencies = [
  "bytemuck",
  "comemo",
+ "hayro",
  "image",
  "pixglyph",
  "resvg",
  "tiny-skia",
  "ttf-parser",
+ "typst-assets",
  "typst-library",
  "typst-macros",
  "typst-timing",
@@ -3183,8 +3251,10 @@ dependencies = [
  "comemo",
  "ecow",
  "flate2",
+ "hayro",
  "image",
  "ttf-parser",
+ "typst-assets",
  "typst-library",
  "typst-macros",
  "typst-timing",
@@ -3581,7 +3651,7 @@ version = "0.221.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9845c470a2e10b61dd42c385839cdd6496363ed63b5c9e420b5488b77bd22083"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
  "indexmap 2.7.1",
 ]
 
@@ -3716,7 +3786,7 @@ version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
 dependencies = [
- "bitflags 2.8.0",
+ "bitflags 2.9.1",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 08c6a8c8b..500d116a6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,8 +32,8 @@ typst-svg = { path = "crates/typst-svg", version = "0.13.1" }
 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 = "edf0d64" }
-typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "bfa947f" }
+typst-assets = { git = "https://github.com/typst/typst-assets", rev = "fbf00f9" }
+typst-dev-assets = { git = "https://github.com/typst/typst-dev-assets", rev = "c6c2acf" }
 arrayvec = "0.7.4"
 az = "1.2"
 base64 = "0.22"
@@ -61,6 +61,8 @@ fontdb = { version = "0.23", default-features = false }
 fs_extra = "1.3"
 glidesort = "0.1.2"
 hayagriva = "0.8.1"
+hayro-syntax = { git = "https://github.com/LaurenzV/hayro", rev = "e701f95" }
+hayro = { git = "https://github.com/LaurenzV/hayro", rev = "e701f95" }
 heck = "0.5"
 hypher = "0.1.4"
 icu_properties = { version = "1.4", features = ["serde"] }
@@ -72,8 +74,8 @@ image = { version = "0.25.5", default-features = false, features = ["png", "jpeg
 indexmap = { version = "2", features = ["serde"] }
 infer = { version = "0.19.0", default-features = false }
 kamadak-exif = "0.6"
-krilla = { git = "https://github.com/LaurenzV/krilla", rev = "20c14fe", default-features = false, features = ["raster-images", "comemo", "rayon"] }
-krilla-svg = { git = "https://github.com/LaurenzV/krilla", rev = "20c14fe" }
+krilla = { git = "https://github.com/LaurenzV/krilla", rev = "37b9a00", default-features = false, features = ["raster-images", "comemo", "rayon", "pdf"] }
+krilla-svg = { git = "https://github.com/LaurenzV/krilla", rev = "37b9a00"}
 kurbo = "0.11"
 libfuzzer-sys = "0.4"
 lipsum = "0.9"
diff --git a/crates/typst-library/Cargo.toml b/crates/typst-library/Cargo.toml
index f4b219882..2297f7ca7 100644
--- a/crates/typst-library/Cargo.toml
+++ b/crates/typst-library/Cargo.toml
@@ -31,6 +31,7 @@ flate2 = { workspace = true }
 fontdb = { workspace = true }
 glidesort = { workspace = true }
 hayagriva = { workspace = true }
+hayro-syntax = { workspace = true }
 icu_properties = { workspace = true }
 icu_provider = { workspace = true }
 icu_provider_blob = { workspace = true }
diff --git a/crates/typst-library/src/visualize/image/mod.rs b/crates/typst-library/src/visualize/image/mod.rs
index d037145e7..1a0e1e97a 100644
--- a/crates/typst-library/src/visualize/image/mod.rs
+++ b/crates/typst-library/src/visualize/image/mod.rs
@@ -1,8 +1,10 @@
 //! Image handling.
 
+mod pdf;
 mod raster;
 mod svg;
 
+pub use self::pdf::PdfImage;
 pub use self::raster::{
     ExchangeFormat, PixelEncoding, PixelFormat, RasterFormat, RasterImage,
 };
@@ -10,13 +12,15 @@ pub use self::svg::SvgImage;
 
 use std::ffi::OsStr;
 use std::fmt::{self, Debug, Formatter};
+use std::num::NonZeroUsize;
 use std::sync::Arc;
 
 use ecow::EcoString;
+use hayro_syntax::LoadPdfError;
 use typst_syntax::{Span, Spanned};
-use typst_utils::LazyHash;
+use typst_utils::{LazyHash, NonZeroExt};
 
-use crate::diag::{At, LoadedWithin, SourceResult, StrResult, warning};
+use crate::diag::{At, LoadedWithin, SourceResult, StrResult, bail, warning};
 use crate::engine::Engine;
 use crate::foundations::{
     Bytes, Cast, Content, Derived, NativeElement, Packed, Smart, StyleChain, cast, elem,
@@ -26,6 +30,7 @@ use crate::layout::{Length, Rel, Sizing};
 use crate::loading::{DataSource, Load, LoadSource, Loaded, Readable};
 use crate::model::Figurable;
 use crate::text::{LocalName, families};
+use crate::visualize::image::pdf::PdfDocument;
 
 /// A raster or vector graphic.
 ///
@@ -79,8 +84,7 @@ pub struct ImageElem {
     /// format automatically, but that's not always possible).
     ///
     /// Supported formats are `{"png"}`, `{"jpg"}`, `{"gif"}`, `{"svg"}`,
-    /// `{"webp"}` as well as raw pixel data. Embedding PDFs as images is
-    /// [not currently supported](https://github.com/typst/typst/issues/145).
+    /// `{"pdf"}`, `{"webp"}` as well as raw pixel data.
     ///
     /// When providing raw pixel data as the `source`, you must specify a
     /// dictionary with the following keys as the `format`:
@@ -126,6 +130,11 @@ pub struct ImageElem {
     /// A text describing the image.
     pub alt: Option<EcoString>,
 
+    /// The page number that should be embedded as an image. This attribute only
+    /// has an effect for PDF files.
+    #[default(NonZeroUsize::ONE)]
+    pub page: NonZeroUsize,
+
     /// How the image should adjust itself to a given area (the area is defined
     /// by the `width` and `height` fields). Note that `fit` doesn't visually
     /// change anything if the area's aspect ratio is the same as the image's
@@ -261,6 +270,45 @@ impl Packed<ImageElem> {
                 )
                 .within(loaded)?,
             ),
+            ImageFormat::Vector(VectorFormat::Pdf) => {
+                let document = match PdfDocument::new(loaded.data.clone()) {
+                    Ok(doc) => doc,
+                    Err(e) => match e {
+                        LoadPdfError::Encryption => {
+                            bail!(
+                                span,
+                                "the PDF is encrypted or password-protected";
+                                hint: "such PDFs are currently not supported";
+                                hint: "preprocess the PDF to remove the encryption"
+                            );
+                        }
+                        LoadPdfError::Invalid => {
+                            bail!(
+                                span,
+                                "the PDF could not be loaded";
+                                hint: "perhaps the PDF file is malformed"
+                            );
+                        }
+                    },
+                };
+
+                // The user provides the page number start from 1, but further
+                // down the pipeline, page numbers are 0-based.
+                let page_num = self.page.get(styles).get();
+                let page_idx = page_num - 1;
+                let num_pages = document.num_pages();
+
+                let Some(pdf_image) = PdfImage::new(document, page_idx) else {
+                    let s = if num_pages == 1 { "" } else { "s" };
+                    bail!(
+                        span,
+                        "page {page_num} does not exist";
+                        hint: "the document only has {num_pages} page{s}"
+                    );
+                };
+
+                ImageKind::Pdf(pdf_image)
+            }
         };
 
         Ok(Image::new(kind, self.alt.get_cloned(styles), self.scaling.get(styles)))
@@ -286,6 +334,7 @@ impl Packed<ImageElem> {
                 "jpg" | "jpeg" => return Ok(ExchangeFormat::Jpg.into()),
                 "gif" => return Ok(ExchangeFormat::Gif.into()),
                 "svg" | "svgz" => return Ok(VectorFormat::Svg.into()),
+                "pdf" => return Ok(VectorFormat::Pdf.into()),
                 "webp" => return Ok(ExchangeFormat::Webp.into()),
                 _ => {}
             }
@@ -373,6 +422,7 @@ impl Image {
         match &self.0.kind {
             ImageKind::Raster(raster) => raster.format().into(),
             ImageKind::Svg(_) => VectorFormat::Svg.into(),
+            ImageKind::Pdf(_) => VectorFormat::Pdf.into(),
         }
     }
 
@@ -381,6 +431,7 @@ impl Image {
         match &self.0.kind {
             ImageKind::Raster(raster) => raster.width() as f64,
             ImageKind::Svg(svg) => svg.width(),
+            ImageKind::Pdf(pdf) => pdf.width() as f64,
         }
     }
 
@@ -389,6 +440,7 @@ impl Image {
         match &self.0.kind {
             ImageKind::Raster(raster) => raster.height() as f64,
             ImageKind::Svg(svg) => svg.height(),
+            ImageKind::Pdf(pdf) => pdf.height() as f64,
         }
     }
 
@@ -397,6 +449,7 @@ impl Image {
         match &self.0.kind {
             ImageKind::Raster(raster) => raster.dpi(),
             ImageKind::Svg(_) => Some(Image::USVG_DEFAULT_DPI),
+            ImageKind::Pdf(_) => Some(Image::DEFAULT_DPI),
         }
     }
 
@@ -435,6 +488,8 @@ pub enum ImageKind {
     Raster(RasterImage),
     /// An SVG image.
     Svg(SvgImage),
+    /// A PDF image.
+    Pdf(PdfImage),
 }
 
 impl From<RasterImage> for ImageKind {
@@ -469,10 +524,20 @@ impl ImageFormat {
             return Some(Self::Vector(VectorFormat::Svg));
         }
 
+        if is_pdf(data) {
+            return Some(Self::Vector(VectorFormat::Pdf));
+        }
+
         None
     }
 }
 
+/// Checks whether the data looks like a PDF file.
+fn is_pdf(data: &[u8]) -> bool {
+    let head = &data[..data.len().min(2048)];
+    memchr::memmem::find(head, b"%PDF-").is_some()
+}
+
 /// Checks whether the data looks like an SVG or a compressed SVG.
 fn is_svg(data: &[u8]) -> bool {
     // Check for the gzip magic bytes. This check is perhaps a bit too
@@ -493,6 +558,9 @@ fn is_svg(data: &[u8]) -> bool {
 pub enum VectorFormat {
     /// The vector graphics format of the web.
     Svg,
+    /// High-fidelity document and graphics format, with focus on exact
+    /// reproduction in print.
+    Pdf,
 }
 
 impl<R> From<R> for ImageFormat
diff --git a/crates/typst-library/src/visualize/image/pdf.rs b/crates/typst-library/src/visualize/image/pdf.rs
new file mode 100644
index 000000000..3ab0b8f7f
--- /dev/null
+++ b/crates/typst-library/src/visualize/image/pdf.rs
@@ -0,0 +1,98 @@
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use hayro_syntax::page::Page;
+use hayro_syntax::{LoadPdfError, Pdf};
+
+use crate::foundations::Bytes;
+
+/// A PDF document.
+#[derive(Clone, Hash)]
+pub struct PdfDocument(Arc<DocumentRepr>);
+
+/// The internal representation of a `PdfDocument`.
+struct DocumentRepr {
+    pdf: Arc<Pdf>,
+    data: Bytes,
+}
+
+impl PdfDocument {
+    /// Loads a PDF document.
+    #[comemo::memoize]
+    #[typst_macros::time(name = "load pdf document")]
+    pub fn new(data: Bytes) -> Result<PdfDocument, LoadPdfError> {
+        let pdf = Arc::new(Pdf::new(Arc::new(data.clone()))?);
+        Ok(Self(Arc::new(DocumentRepr { data, pdf })))
+    }
+
+    /// Returns the underlying PDF document.
+    pub fn pdf(&self) -> &Arc<Pdf> {
+        &self.0.pdf
+    }
+
+    /// Return the number of pages in the PDF.
+    pub fn num_pages(&self) -> usize {
+        self.0.pdf.pages().len()
+    }
+}
+
+impl Hash for DocumentRepr {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.data.hash(state);
+    }
+}
+
+/// A specific page of a PDF acting as an image.
+#[derive(Clone, Hash)]
+pub struct PdfImage(Arc<ImageRepr>);
+
+/// The internal representation of a `PdfImage`.
+struct ImageRepr {
+    document: PdfDocument,
+    page_index: usize,
+    width: f32,
+    height: f32,
+}
+
+impl PdfImage {
+    /// Creates a new PDF image.
+    ///
+    /// Returns `None` if the page index is not valid.
+    #[comemo::memoize]
+    pub fn new(document: PdfDocument, page_index: usize) -> Option<PdfImage> {
+        let (width, height) = document.0.pdf.pages().get(page_index)?.render_dimensions();
+        Some(Self(Arc::new(ImageRepr { document, page_index, width, height })))
+    }
+
+    /// Returns the underlying Typst PDF document.
+    pub fn document(&self) -> &PdfDocument {
+        &self.0.document
+    }
+
+    /// Returns the PDF page of the image.
+    pub fn page(&self) -> &Page {
+        &self.document().pdf().pages()[self.0.page_index]
+    }
+
+    /// Returns the width of the image.
+    pub fn width(&self) -> f32 {
+        self.0.width
+    }
+
+    /// Returns the height of the image.
+    pub fn height(&self) -> f32 {
+        self.0.height
+    }
+
+    /// Returns the page index of the image.
+    pub fn page_index(&self) -> usize {
+        self.0.page_index
+    }
+}
+
+impl Hash for ImageRepr {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.document.hash(state);
+        self.page_index.hash(state);
+    }
+}
diff --git a/crates/typst-pdf/src/convert.rs b/crates/typst-pdf/src/convert.rs
index 058658156..12d1a78eb 100644
--- a/crates/typst-pdf/src/convert.rs
+++ b/crates/typst-pdf/src/convert.rs
@@ -9,6 +9,7 @@ use krilla::embed::EmbedError;
 use krilla::error::KrillaError;
 use krilla::geom::PathBuilder;
 use krilla::page::{PageLabel, PageSettings};
+use krilla::pdf::PdfError;
 use krilla::surface::Surface;
 use krilla::{Document, SerializeSettings};
 use krilla_svg::render_svg_glyph;
@@ -363,6 +364,42 @@ fn finish(
                     hint: "convert the image to 8 bit instead"
                 )
             }
+            KrillaError::Pdf(_, e, loc) => {
+                let span = to_span(loc);
+                match e {
+                    // We already validated in `typst-library` that the page index is valid.
+                    PdfError::InvalidPage(_) => bail!(
+                        span,
+                        "invalid page number for PDF file";
+                        hint: "please report this as a bug"
+                    ),
+                    PdfError::VersionMismatch(v) => {
+                        let pdf_ver = v.as_str();
+                        let config_ver = configuration.version();
+                        let cur_ver = config_ver.as_str();
+                        bail!(span,
+                            "the version of the PDF is too high";
+                            hint: "the current export target is {cur_ver}, while the PDF has version {pdf_ver}";
+                            hint: "raise the export target to {pdf_ver} or higher";
+                            hint: "or preprocess the PDF to convert it to a lower version"
+                        );
+                    }
+                }
+            }
+            KrillaError::DuplicateTagId(_, loc) => {
+                let span = to_span(loc);
+                bail!(span,
+                    "duplicate tag id";
+                    hint: "please report this as a bug"
+                );
+            }
+            KrillaError::UnknownTagId(_, loc) => {
+                let span = to_span(loc);
+                bail!(span,
+                    "unknown tag id";
+                    hint: "please report this as a bug"
+                );
+            }
         },
     }
 }
@@ -535,12 +572,12 @@ fn convert_error(
         }
         // The below errors cannot occur yet, only once Typst supports full PDF/A
         // and PDF/UA. But let's still add a message just to be on the safe side.
-        ValidationError::MissingAnnotationAltText => error!(
+        ValidationError::MissingAnnotationAltText(_) => error!(
             Span::detached(),
             "{prefix} missing annotation alt text";
             hint: "please report this as a bug"
         ),
-        ValidationError::MissingAltText => error!(
+        ValidationError::MissingAltText(_) => error!(
             Span::detached(),
             "{prefix} missing alt text";
             hint: "make sure your images and equations have alt text"
@@ -576,6 +613,13 @@ fn convert_error(
             "{prefix} missing document date";
             hint: "set the date of the document"
         ),
+        ValidationError::EmbeddedPDF(loc) => {
+            error!(
+                to_span(*loc),
+                "embedding PDFs is currently not supported in this export mode";
+                hint: "try converting the PDF to an SVG before embedding it"
+            )
+        }
     }
 }
 
diff --git a/crates/typst-pdf/src/image.rs b/crates/typst-pdf/src/image.rs
index 39a6e602c..b846d1799 100644
--- a/crates/typst-pdf/src/image.rs
+++ b/crates/typst-pdf/src/image.rs
@@ -3,13 +3,14 @@ use std::sync::{Arc, OnceLock};
 
 use image::{DynamicImage, EncodableLayout, GenericImageView, Rgba};
 use krilla::image::{BitsPerComponent, CustomImage, ImageColorspace};
+use krilla::pdf::PdfDocument;
 use krilla::surface::Surface;
 use krilla_svg::{SurfaceExt, SvgSettings};
 use typst_library::diag::{SourceResult, bail};
 use typst_library::foundations::Smart;
 use typst_library::layout::{Abs, Angle, Ratio, Size, Transform};
 use typst_library::visualize::{
-    ExchangeFormat, Image, ImageKind, ImageScaling, RasterFormat, RasterImage,
+    ExchangeFormat, Image, ImageKind, ImageScaling, PdfImage, RasterFormat, RasterImage,
 };
 use typst_syntax::Span;
 
@@ -60,6 +61,9 @@ pub(crate) fn handle_image(
                 SvgSettings { embed_text: true, ..Default::default() },
             );
         }
+        ImageKind::Pdf(pdf) => {
+            surface.draw_pdf_page(&convert_pdf(pdf), size.to_krilla(), pdf.page_index())
+        }
     }
 
     if image.alt().is_some() {
@@ -85,9 +89,9 @@ struct Repr {
 
 /// A wrapper around `RasterImage` so that we can implement `CustomImage`.
 #[derive(Clone)]
-struct PdfImage(Arc<Repr>);
+struct PdfRasterImage(Arc<Repr>);
 
-impl PdfImage {
+impl PdfRasterImage {
     pub fn new(raster: RasterImage) -> Self {
         Self(Arc::new(Repr {
             raster,
@@ -97,7 +101,7 @@ impl PdfImage {
     }
 }
 
-impl Hash for PdfImage {
+impl Hash for PdfRasterImage {
     fn hash<H: Hasher>(&self, state: &mut H) {
         // `alpha_channel` and `actual_dynamic` are generated from the underlying `RasterImage`,
         // so this is enough. Since `raster` is prehashed, this is also very cheap.
@@ -105,7 +109,7 @@ impl Hash for PdfImage {
     }
 }
 
-impl CustomImage for PdfImage {
+impl CustomImage for PdfRasterImage {
     fn color_channel(&self) -> &[u8] {
         self.0
             .actual_dynamic
@@ -196,10 +200,15 @@ fn convert_raster(
             interpolate,
         )
     } else {
-        krilla::image::Image::from_custom(PdfImage::new(raster), interpolate)
+        krilla::image::Image::from_custom(PdfRasterImage::new(raster), interpolate)
     }
 }
 
+#[comemo::memoize]
+fn convert_pdf(pdf: &PdfImage) -> PdfDocument {
+    PdfDocument::new(pdf.document().pdf().clone())
+}
+
 fn exif_transform(image: &RasterImage, size: Size) -> (Transform, Size) {
     let base = |hp: bool, vp: bool, mut base_ts: Transform, size: Size| {
         if hp {
diff --git a/crates/typst-pdf/src/link.rs b/crates/typst-pdf/src/link.rs
index 64cb8f0a2..2133be82c 100644
--- a/crates/typst-pdf/src/link.rs
+++ b/crates/typst-pdf/src/link.rs
@@ -49,7 +49,6 @@ pub(crate) fn handle_link(
             fc.push_annotation(
                 LinkAnnotation::new(
                     rect,
-                    None,
                     Target::Action(Action::Link(LinkAction::new(u.to_string()))),
                 )
                 .into(),
@@ -64,7 +63,6 @@ pub(crate) fn handle_link(
                 fc.push_annotation(
                     LinkAnnotation::new(
                         rect,
-                        None,
                         Target::Destination(krilla::destination::Destination::Named(
                             nd.clone(),
                         )),
@@ -83,7 +81,6 @@ pub(crate) fn handle_link(
         fc.push_annotation(
             LinkAnnotation::new(
                 rect,
-                None,
                 Target::Destination(krilla::destination::Destination::Xyz(
                     XyzDestination::new(index, pos.point.to_krilla()),
                 )),
diff --git a/crates/typst-render/Cargo.toml b/crates/typst-render/Cargo.toml
index 7d01d7e38..497343510 100644
--- a/crates/typst-render/Cargo.toml
+++ b/crates/typst-render/Cargo.toml
@@ -13,11 +13,13 @@ keywords = { workspace = true }
 readme = { workspace = true }
 
 [dependencies]
+typst-assets = { workspace = true }
 typst-library = { workspace = true }
 typst-macros = { workspace = true }
 typst-timing = { workspace = true }
 bytemuck = { workspace = true }
 comemo = { workspace = true }
+hayro = { workspace = true }
 image = { workspace = true }
 pixglyph = { workspace = true }
 resvg = { workspace = true }
diff --git a/crates/typst-render/src/image.rs b/crates/typst-render/src/image.rs
index 7425bdd2f..03347d5dd 100644
--- a/crates/typst-render/src/image.rs
+++ b/crates/typst-render/src/image.rs
@@ -1,11 +1,12 @@
-use std::sync::Arc;
-
+use hayro::{FontData, FontQuery, InterpreterSettings, RenderSettings, StandardFont};
 use image::imageops::FilterType;
 use image::{GenericImageView, Rgba};
+use std::sync::Arc;
 use tiny_skia as sk;
+use tiny_skia::IntSize;
 use typst_library::foundations::Smart;
 use typst_library::layout::Size;
-use typst_library::visualize::{Image, ImageKind, ImageScaling};
+use typst_library::visualize::{Image, ImageKind, ImageScaling, PdfImage};
 
 use crate::{AbsExt, State};
 
@@ -59,9 +60,9 @@ pub fn render_image(
 /// Prepare a texture for an image at a scaled size.
 #[comemo::memoize]
 fn build_texture(image: &Image, w: u32, h: u32) -> Option<Arc<sk::Pixmap>> {
-    let mut texture = sk::Pixmap::new(w, h)?;
-    match image.kind() {
+    let texture = match image.kind() {
         ImageKind::Raster(raster) => {
+            let mut texture = sk::Pixmap::new(w, h)?;
             let w = texture.width();
             let h = texture.height();
 
@@ -85,15 +86,63 @@ fn build_texture(image: &Image, w: u32, h: u32) -> Option<Arc<sk::Pixmap>> {
                 let Rgba([r, g, b, a]) = src;
                 *dest = sk::ColorU8::from_rgba(r, g, b, a).premultiply();
             }
+
+            texture
         }
         ImageKind::Svg(svg) => {
+            let mut texture = sk::Pixmap::new(w, h)?;
             let tree = svg.tree();
             let ts = tiny_skia::Transform::from_scale(
                 w as f32 / tree.size().width(),
                 h as f32 / tree.size().height(),
             );
             resvg::render(tree, ts, &mut texture.as_mut());
+            texture
         }
-    }
+        ImageKind::Pdf(pdf) => build_pdf_texture(pdf, w, h)?,
+    };
+
     Some(Arc::new(texture))
 }
+
+// Keep this in sync with `typst-svg`!
+fn build_pdf_texture(pdf: &PdfImage, w: u32, h: u32) -> Option<sk::Pixmap> {
+    let select_standard_font = move |font: StandardFont| -> Option<(FontData, u32)> {
+        let bytes = match font {
+            StandardFont::Helvetica => typst_assets::pdf::SANS,
+            StandardFont::HelveticaBold => typst_assets::pdf::SANS_BOLD,
+            StandardFont::HelveticaOblique => typst_assets::pdf::SANS_ITALIC,
+            StandardFont::HelveticaBoldOblique => typst_assets::pdf::SANS_BOLD_ITALIC,
+            StandardFont::Courier => typst_assets::pdf::FIXED,
+            StandardFont::CourierBold => typst_assets::pdf::FIXED_BOLD,
+            StandardFont::CourierOblique => typst_assets::pdf::FIXED_ITALIC,
+            StandardFont::CourierBoldOblique => typst_assets::pdf::FIXED_BOLD_ITALIC,
+            StandardFont::TimesRoman => typst_assets::pdf::SERIF,
+            StandardFont::TimesBold => typst_assets::pdf::SERIF_BOLD,
+            StandardFont::TimesItalic => typst_assets::pdf::SERIF_ITALIC,
+            StandardFont::TimesBoldItalic => typst_assets::pdf::SERIF_BOLD_ITALIC,
+            StandardFont::ZapfDingBats => typst_assets::pdf::DING_BATS,
+            StandardFont::Symbol => typst_assets::pdf::SYMBOL,
+        };
+        Some((Arc::new(bytes), 0))
+    };
+
+    let interpreter_settings = InterpreterSettings {
+        font_resolver: Arc::new(move |query| match query {
+            FontQuery::Standard(s) => select_standard_font(*s),
+            FontQuery::Fallback(f) => select_standard_font(f.pick_standard_font()),
+        }),
+        warning_sink: Arc::new(|_| {}),
+    };
+
+    let render_settings = RenderSettings {
+        x_scale: w as f32 / pdf.width(),
+        y_scale: h as f32 / pdf.height(),
+        width: Some(w as u16),
+        height: Some(h as u16),
+    };
+
+    let hayro_pix = hayro::render(pdf.page(), &interpreter_settings, &render_settings);
+
+    sk::Pixmap::from_vec(hayro_pix.take_u8(), IntSize::from_wh(w, h)?)
+}
diff --git a/crates/typst-svg/Cargo.toml b/crates/typst-svg/Cargo.toml
index 5416621e5..9b7dc538e 100644
--- a/crates/typst-svg/Cargo.toml
+++ b/crates/typst-svg/Cargo.toml
@@ -13,6 +13,7 @@ keywords = { workspace = true }
 readme = { workspace = true }
 
 [dependencies]
+typst-assets = { workspace = true }
 typst-library = { workspace = true }
 typst-macros = { workspace = true }
 typst-timing = { workspace = true }
@@ -21,6 +22,7 @@ base64 = { workspace = true }
 comemo = { workspace = true }
 ecow = { workspace = true }
 flate2 = { workspace = true }
+hayro = { workspace = true }
 image = { workspace = true }
 ttf-parser = { workspace = true }
 xmlparser = { workspace = true }
diff --git a/crates/typst-svg/src/image.rs b/crates/typst-svg/src/image.rs
index 58f0227b6..55a8f22ac 100644
--- a/crates/typst-svg/src/image.rs
+++ b/crates/typst-svg/src/image.rs
@@ -1,10 +1,13 @@
+use std::sync::Arc;
+
 use base64::Engine;
 use ecow::{EcoString, eco_format};
+use hayro::{FontData, FontQuery, InterpreterSettings, RenderSettings, StandardFont};
 use image::{ImageEncoder, codecs::png::PngEncoder};
 use typst_library::foundations::Smart;
 use typst_library::layout::{Abs, Axes};
 use typst_library::visualize::{
-    ExchangeFormat, Image, ImageKind, ImageScaling, RasterFormat,
+    ExchangeFormat, Image, ImageKind, ImageScaling, PdfImage, RasterFormat,
 };
 
 use crate::SVGRenderer;
@@ -66,6 +69,25 @@ pub fn convert_image_to_base64_url(image: &Image) -> EcoString {
             }),
         },
         ImageKind::Svg(svg) => ("svg+xml", svg.data()),
+        ImageKind::Pdf(pdf) => {
+            // To make sure the image isn't pixelated, we always scale up so the
+            // lowest dimension has at least 1000 pixels. However, we only scale
+            // up as much so that the largest dimension doesn't exceed 3000
+            // pixels.
+            const MIN_RES: f32 = 1000.0;
+            const MAX_RES: f32 = 3000.0;
+
+            let base_width = pdf.width();
+            let w_scale = (MIN_RES / base_width).max(MAX_RES / base_width);
+            let base_height = pdf.height();
+            let h_scale = (MIN_RES / base_height).min(MAX_RES / base_height);
+            let total_scale = w_scale.min(h_scale);
+            let width = (base_width * total_scale).ceil() as u32;
+            let height = (base_height * total_scale).ceil() as u32;
+
+            buf = pdf_to_png(pdf, width, height);
+            ("png", buf.as_slice())
+        }
     };
 
     let mut url = eco_format!("data:image/{format};base64,");
@@ -73,3 +95,45 @@ pub fn convert_image_to_base64_url(image: &Image) -> EcoString {
     url.push_str(&data);
     url
 }
+
+// Keep this in sync with `typst-png`!
+fn pdf_to_png(pdf: &PdfImage, w: u32, h: u32) -> Vec<u8> {
+    let select_standard_font = move |font: StandardFont| -> Option<(FontData, u32)> {
+        let bytes = match font {
+            StandardFont::Helvetica => typst_assets::pdf::SANS,
+            StandardFont::HelveticaBold => typst_assets::pdf::SANS_BOLD,
+            StandardFont::HelveticaOblique => typst_assets::pdf::SANS_ITALIC,
+            StandardFont::HelveticaBoldOblique => typst_assets::pdf::SANS_BOLD_ITALIC,
+            StandardFont::Courier => typst_assets::pdf::FIXED,
+            StandardFont::CourierBold => typst_assets::pdf::FIXED_BOLD,
+            StandardFont::CourierOblique => typst_assets::pdf::FIXED_ITALIC,
+            StandardFont::CourierBoldOblique => typst_assets::pdf::FIXED_BOLD_ITALIC,
+            StandardFont::TimesRoman => typst_assets::pdf::SERIF,
+            StandardFont::TimesBold => typst_assets::pdf::SERIF_BOLD,
+            StandardFont::TimesItalic => typst_assets::pdf::SERIF_ITALIC,
+            StandardFont::TimesBoldItalic => typst_assets::pdf::SERIF_BOLD_ITALIC,
+            StandardFont::ZapfDingBats => typst_assets::pdf::DING_BATS,
+            StandardFont::Symbol => typst_assets::pdf::SYMBOL,
+        };
+        Some((Arc::new(bytes), 0))
+    };
+
+    let interpreter_settings = InterpreterSettings {
+        font_resolver: Arc::new(move |query| match query {
+            FontQuery::Standard(s) => select_standard_font(*s),
+            FontQuery::Fallback(f) => select_standard_font(f.pick_standard_font()),
+        }),
+        warning_sink: Arc::new(|_| {}),
+    };
+
+    let render_settings = RenderSettings {
+        x_scale: w as f32 / pdf.width(),
+        y_scale: h as f32 / pdf.height(),
+        width: Some(w as u16),
+        height: Some(h as u16),
+    };
+
+    let hayro_pix = hayro::render(pdf.page(), &interpreter_settings, &render_settings);
+
+    hayro_pix.take_png()
+}
diff --git a/docs/guides/guide-for-latex-users.md b/docs/guides/guide-for-latex-users.md
index 93fa296fc..e8078086b 100644
--- a/docs/guides/guide-for-latex-users.md
+++ b/docs/guides/guide-for-latex-users.md
@@ -665,12 +665,3 @@ applicable, contains possible workarounds.
   [`page` function]($page) which will force a page break. If you just want a few
   paragraphs to stretch into the margins, then reverting to the old margins, you
   can use the [`pad` function]($pad) with negative padding.
-
-- **Include PDFs as images.** In LaTeX, it has become customary to insert vector
-  graphics as PDF or EPS files. Typst supports neither format as an image
-  format, but you can easily convert both into SVG files with [online
-  tools](https://cloudconvert.com/pdf-to-svg) or
-  [Inkscape](https://inkscape.org/). The web app will automatically convert PDF
-  files to SVG files upon uploading them. You can also use the
-  community-provided [`muchpdf` package](https://typst.app/universe/package/muchpdf)
-  to embed PDFs. It internally converts PDFs to SVGs on-the-fly.
diff --git a/tests/ref/image-pdf-multiple-pages.png b/tests/ref/image-pdf-multiple-pages.png
new file mode 100644
index 0000000000000000000000000000000000000000..a6be4a31391ab97054623ceaf5f702f033f724a2
GIT binary patch
literal 7618
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

literal 0
HcmV?d00001

diff --git a/tests/ref/image-pdf.png b/tests/ref/image-pdf.png
new file mode 100644
index 0000000000000000000000000000000000000000..6619dcee6a0804211bb3186fe9a4e6cecf699c38
GIT binary patch
literal 3987
zcmV;E4{Y#>P)<h;3K|Lk000e1NJLTq004LZ003VI0ssI2tgn;{000kKNkl<Zc-rjQ
zTTD}T9Ki8rTe;0KaJq}odYL%029!;m(01-&%a-h6OBRz|Oh^oSFv~94%d+q=#;&@D
zEenWiC^rRdOJiXOJ+_6@3#^o+SwXN+VzHp4LMVFLay+N!9RKpy#vmz{7}}ovzxk*6
z^`Aa8pVR!Co(eeBx+FjZ2pU175Hx~D&?p3rpiu}KK_lp7$>;NRc6Rpn_j4;XGc$vr
zA6p$A9bH{rt*x!#(PT1dG#W58Ha7MxRZ~-AHk-kw#bOy78*6WG?_bJjG<rOqwzf8#
z%~oAq4X)PE&`@n{EkO_ndgTDF)oL9b9R*ku6BEGB;cx(GZ~*`=aMbJdDwPVuu-VyJ
zU}`WJnwpxx)A8|fcmcFpt;^+7tJN(nEnpKtuRR>c34%aJ2MR$WXaxO8m6es%rDour
zb4w8f5#6k;tYjEwU|<03V;BbJWPuh41ZAlic<0<wUauF-pMI8Iv?qN_-cvM9Yc!fb
zAfQw#Ns>$=Xl|`BG-LnXa$2ka%cu8p>)V6SVzH2ze+9cBE-lIAmc;|;-lKY`4A*pz
zFHz82MZ)m)U54`_=^MO*rh*jo#mg~GaWfcnva<<;&KHv20+Tvlx}SH@<oqIp9y#UG
z9ykN%ghA&CDfiBvGkLOod^|cJZggE%4krqF+ZJKORe(3-%U<Inbl4wKNgANC`SXh$
z%Owo@B_ZS3g)2nzy?lg*-CiK+5Dn*qLBA+uth@1Qv3yTfYC$JH{}tk=_e>u>ak@f|
zT^$ar3e6fN=0CT~3lVfYU31?A#1AfyV=fl-3u(-SBK*Y5a>>(41U)!7=ytnpHk-%e
zNlxgmB^>})^`i?sepC1_w2lS+d>V7U82_a}{_2J#f_6Hc4u=CkPfkuI8#KKbah<&M
zYfj^_jAnpqJLlE?F|s=J=Jd$9{dnbW@uswJIIL7E!G2X$6~i#-=vX0!X8+mT5MA}9
z?WXz(s2m%5>!x(N`CxB_q)?O<iA1`)y90rMPN$<NiiglF%Z(4s{b!iE6(G4a<ugu0
z;)Ws(91h=CR(vrK6FP&cll6R8BrC|~`In)8I#?{MjjsCRPA>k&&U&D)u^flPCr{p0
z{{6#VmSJN-KbJwCe9QE0v2^FNe1m3#e%3$Ckqhu?Nwxy`{`RHi9Z?gsc3Q7<aTdH5
zg1*t^{eS-Ejm6b}f^W=R{OfJwSNo(pa(DzCnxnNxs5%*3wC?E4l^Z~I+4}f(H5Y$V
zJ@-$K9WBHZ@u>GYax+6G-o1G2fOLEAvX|NI_P)M8nx<0?I&zz;KLm-HVHF%kj~{`!
z2cJ<K-mAJdZ%}Y+j*atvbZ+LYpWoM)my~YXxcp4>`{5rhDF)4Wd+*{Z-=vf>W~2>5
z2TvV(_!Iqig?;^Q{O4pX{P4k@_Ra*VsVj}+35yDXtPv1JpssCCwY632OdaiLN3m|z
z<JO}N$D?g^a4Twy8(p+gmAZlmqB3Z}1+20tf~aUg0l~5g!zxQafk2WMl8~4AJD2lL
z3=l_zXYk}Z-+AZey^oidpZ9(D-tT_*8teYokDYAVf=*6O?s=eFl6*jxev;pE>t|Y0
ztIRk>ScmTj(Eu%#DA)sSVOr<)Mby%X9}lwCFq6q-$m!{UpwokZRS~gV9z2PzFH&6H
zNI)xdBhqeF!f%W<4cNQ!4kebe8B`i%(YMxf!R1Ah#}DLbm?8a)&*!rT8m&QXZLLr!
zd_~Z7Z7v}z51B?kPC<bv-B_Vv$tvi6eXG|kxio*uILH34xiJJ{xGF?BUcJ}RlCX`y
zRh(N$3N5JtIR839o10avUUqTrv~dp4K$n%3;aFT;Onx{<iLAN~<QNJB0u;zYAdM5w
z>!m;|YO96er|ORRN`5~mKk*5ntSnB%rPm93pt)JuO84_K-7I?dLYhZ#a4^mzB^3@D
zd6!7=U=K9HE2z#@RaH#V2`YF+MaBOQT3%jKxn?P&LjFlD#%zN&GcW$<%JAtkKkRRZ
zGuheMsKq$aG>!CBRzcU-*Qcka<6ArJI;uTa5ybT;j*x<~QK%v!YbZ?5IOKcpM8Ja@
zftY>Jj(yDwmV9$|%A61TJG9M#M;11#t|Kce3$CNnpj#;iA8k18U$x#H<>p7ZIIq0t
zrMxf(S|2jrviBb7nZPvR&HMFN?@)!MY=Q2Vx4<KG^1Ly;0UBmVYe&a}RnTzC2tdCO
zG*v52^UaE0lGrSish<~kc>u0p>)I-h<pg>~RCZ-T2@o?n!hR=V9Y1|z&b)QdVy^=T
z>vcEi0jB-3=59DWalr>Rjv8js(b0*CiR^)<C<?9viTK(<SKJXCu?%4}k6)yI6~3Y=
zHnK6|?9Ewz>WKza$OKU4Z<xFAZ-E4~`>-8_Yj+iS?j^YKw=Lo05Su5eqMmduXa^IE
z)PH<;eC(I+TMg1M!%vn<rR;%5>lYdtnv;{G9kir|QU{$AQrLb6X7(lUz5MAp0(!Lh
zUcZCM;2Y!-N<bf-u;uBc1Ry4=Qb@p;QDyAnE(YDlGWpYO{vRwGZRw<8h7}v=O0x%=
ztTE9Jnn=WqYYgZP8^)vx^%@Pb>S}AUr_?tDd_`$Ft)L}>=Rn{4scS*o_pwa+#QVs5
z?xQRQx2@4^H-?xeWLDs4Zwwm>8&S1i@QRc*#>|Mw@y|qVSV8{N_eUNhl;=8or_Npv
zxQvSbd<1*twWSPbm8iUnLHD*w9KY+}J1gHacW&DS!0IDbL8DE;<ac+^87dl@iZ<<K
zC^w~MtBBA_RbvTV8mm&uy1X&8>tz);W{>aiuiiCt(J)I(OT+RnRzc(Yu3Wjo&g3jD
zlPek;+3H6Fv~~2TeZLM_<7(oFp&3Sl1ThIJp;EI48oBQjMX@{!&Kl_c#@3fc9^5^6
zt&NeTL?ZF?^FxSZ|Ni}$1xI6u1pusqhO4TqtRx@dtkJE;K=I80%`>(+KlI3t12>E`
zd5eT9iI9;YdI7I39*vMG-Ym>Myb!doR2;oBWlx{8(3r1ML{-$wXHqwpUw>Sm-_VVq
zjcm?1AKPK?IlRvh4Ku8ZMyx~E1OHEQh2X294aK6DnruDZ|0L14<q6#c+Sbtalw*(=
zZ_BV=L)+%R!A<Kr=tBc9g6xeg4}47d!DD0cBg*mdpu+_XGijqdC8Q)`b7odlB~3p!
z#|pmcTAd>34$wA+wz&BwtM7*z57RKi&;emQod%7X3#{Rv-^jaA7B)R0&F>L^S^}xm
zO%)Qxtfrvp8%`Lb8!a!k$d#>5qd}$tI_E@Qw}3XVJ!*A&gSpobqv35w50R0PIt^No
zQBSb?n4U#lRw-mb&PR{h1>#IC5|*2*>7w80+|9=)?*`wfommX)$Ss-7O*BB)q}Fr?
zXln!BZ)Tw$Cfi*NhqrYd*j_=WK~qng3FvUQ_=eE^qFpnH*6o~4Wn83hyv=ByuiI+F
z@KZ}uqJPLHteKls-K}OQ-`;q)B){P!qhrv^C-b`yv=x`<)938hy>_@5jL<Mcb?yPP
z;3vn$0(AB6wFGhQiWMpI)}g>4R^DGg3h_Jn>JCI>p<LCS>ZUSLeGLV~jK*Im>MGEd
zT;7ky{1rw!2XjaC$ds^Vq5OoaKgiZ@`vR#zg74;Eo$|A2-+UT~Z@fz<Pf;}s2<Vs<
ztH9THQUZ>bx3@nM3*Mcs4to8pm@Wg&;cYVrTV~+x#OZ0E(Rpa7k>c2V_aZ=FU2rCU
z{kP@*LE=CU(J!A9xOCz>bg4fn^XGg^>he~n%Zldq)4$icMXQ7MoOiXWKwEHlo48?%
zx!wbN7U(~33#J*KBzn&`g!m0b?rmJ6o1V6mWGJGiwz5uJND2?aa$|nVd33!(%XCUr
zY13FW&<b=;IxDoOS{-yh4sRVNY(B@^f@6m<Fv*y~jzhWyn(~`Z?Vl=(KZt$>&Pc@y
z@Kx99ZF320DrB?BXU?<oZZ~=4c*aw!#E%perGoW~iHhTYS9Kr{{}7Bb3Rpb)TzR3e
z^8vyOOOWQE4%(c<`<fFro8xW8aYTFrdoy7c93cmqre8B?JOM%h1T-iUl?E-vnXDv%
z2I!<!s{vO-6-8;!BA+eNXLplIz*k+V`?plxBeX~W${L`}I6QX_-;J}=PN!VQ!~Y2u
zdSDijfR@GVA*^X}U1ebt;XBXz3@Q94rA*|zNS(6$;d2pQX=)PS)*bSG`ip1nj@5*9
zcY!Ydqb=yZ9Nw4QGgG-c`g4Zs5NI-mn30izWDh)U^QG<5VE0zg!fIUI>K4aTXOD5M
zA?%jNIr7YF@~i|}D%Q+QzZFa1N)n@R>{iftjoJfkJKx~nlMJ@m>KbSw8m<G%bUALH
zFY#Z0@A~ONvUo&`v=rVE`%EKnYd0++g{Fwps%{fnSf)6?NFB5($9AT{>Ax6wS@#Ig
zw6N->6CMka$lnTon8noPC*Esl1*>VhCLG((3{QS!@Vymxm=1UES`@TQqUw|o%F60|
z%J(xWXod6!U*t1ge)Aa1f&V^S+lfX&qYSrLaEHEu%irim0Ri0{<K0~Ht1Qu%Ix+_z
z(O+a4bZ@Q=dW~-zdYZqPpeZ5acADx(h;EG~W$E!HEQ9XFwHamXH^gXTU+$1M5HxWe
zjEbWsh;RNK1;v9%mO&eHt%n;Qaxz+H!hP$_1g)&h0a<m0_fRQYSO#sxwRY;|YiIng
z-dtDGc_l~P0`2PRYG-HX;^N}ku{b$74Hz(>{cFyHTpY|??9H6*Or0I=TwOc7&)~s>
z9UL57wF(UIU0MvBot^FN?NQL!V9=0j&EXhuxu#;V7`gs99}o~gQIxKLj*E*!>cPH!
z`!Ief=va`Ofb|LmTIKNJ!&pV2#Q+;u0D<<K1O^6T>tihjm@zqU-~bAEa`F=p++eO^
z?IumrI3m`8qt0yti_{*ZPUAOdvB7g=BNZ(M$R#9sBOM85qqToUU0ofriXtK+v_C3&
z+8(wEEH)>{Brz%x;vOK?QEqi+W+ry=*Iq}EL81NkBYOxo+6|EGg6+_?MBNag!J;et
zgXy<5)^BUvoe~ohgH{L&Mo{rl<FLFA`9XPkd3arlii(gDg~TZ0Loxra2i^JTHYS_#
z;={dSUITfBSUH0KmjW+1V(@4ofg7#~{uiDB?W!L1s|r|mbP3%6rl1F{7d>b_Xgz4X
t=t1j2>qQS*4_XgeFM7~=(0XZ4{tLOJpGAbbAcX(`002ovPDHLkV1kgxoG}0Z

literal 0
HcmV?d00001

diff --git a/tests/suite/visualize/image.typ b/tests/suite/visualize/image.typ
index 36ec06cb1..7c5fb2916 100644
--- a/tests/suite/visualize/image.typ
+++ b/tests/suite/visualize/image.typ
@@ -258,7 +258,7 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
 --- image-png-but-pixmap-format ---
 #image(
   read("/assets/images/tiger.jpg", encoding: none),
-  // Error: 11-18 expected "png", "jpg", "gif", "webp", dictionary, "svg", or auto
+  // Error: 11-18 expected "png", "jpg", "gif", "webp", dictionary, "svg", "pdf", or auto
   format: "rgba8",
 )
 
@@ -289,3 +289,16 @@ A #box(image("/assets/images/tiger.jpg", height: 1cm, width: 80%)) B
   ..rotations.map(v => raw(str(v), lang: "typc")),
   ..rotations.map(rotated)
 )
+
+--- image-pdf ---
+#image("/assets/images/matplotlib.pdf")
+
+--- image-pdf-multiple-pages ---
+#image("/assets/images/diagrams.pdf", page: 1)
+#image("/assets/images/diagrams.pdf", page: 3)
+#image("/assets/images/diagrams.pdf", page: 2)
+
+--- image-pdf-invalid-page ---
+// Error: 2-49 page 2 does not exist
+// Hint: 2-49 the document only has 1 page
+#image("/assets/images/matplotlib.pdf", page: 2)

From 78355421ad73fdcbe93b4acca890b439c4b6f98d Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 22 Jul 2025 14:07:29 +0200
Subject: [PATCH 100/101] Add `pdf` extension to image autocompletions (#6643)

---
 crates/typst-ide/src/complete.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/typst-ide/src/complete.rs b/crates/typst-ide/src/complete.rs
index 87b592ec0..d2c1040b4 100644
--- a/crates/typst-ide/src/complete.rs
+++ b/crates/typst-ide/src/complete.rs
@@ -834,7 +834,7 @@ fn param_value_completions<'a>(
 fn path_completion(func: &Func, param: &ParamInfo) -> Option<&'static [&'static str]> {
     Some(match (func.name(), param.name) {
         (Some("image"), "source") => {
-            &["png", "jpg", "jpeg", "gif", "svg", "svgz", "webp"]
+            &["png", "jpg", "jpeg", "gif", "svg", "svgz", "webp", "pdf"]
         }
         (Some("csv"), "source") => &["csv"],
         (Some("plugin"), "source") => &["wasm"],

From 7278d887cf05fadc9a96478830e5876739b78f53 Mon Sep 17 00:00:00 2001
From: Tobias Schmitz <tobiasschmitz2001@gmail.com>
Date: Wed, 23 Jul 2025 16:17:03 +0200
Subject: [PATCH 101/101] Fix bounding box computation for lines in curves
 (#6647)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-library/src/visualize/curve.rs |  26 +++++++-------------
 tests/ref/curve-stroke-gradient-sharp.png   | Bin 0 -> 399 bytes
 tests/ref/curve-stroke-gradient.png         | Bin 2136 -> 2367 bytes
 tests/suite/visualize/curve.typ             |  10 ++++++++
 4 files changed, 19 insertions(+), 17 deletions(-)
 create mode 100644 tests/ref/curve-stroke-gradient-sharp.png

diff --git a/crates/typst-library/src/visualize/curve.rs b/crates/typst-library/src/visualize/curve.rs
index 4bc5b45fb..9f4a21a4e 100644
--- a/crates/typst-library/src/visualize/curve.rs
+++ b/crates/typst-library/src/visualize/curve.rs
@@ -476,26 +476,18 @@ impl Curve {
 
     /// Computes the size of the bounding box of this curve.
     pub fn bbox_size(&self) -> Size {
-        let mut min_x = Abs::inf();
-        let mut min_y = Abs::inf();
-        let mut max_x = -Abs::inf();
-        let mut max_y = -Abs::inf();
+        let mut min = Point::splat(Abs::inf());
+        let mut max = Point::splat(-Abs::inf());
 
         let mut cursor = Point::zero();
         for item in self.0.iter() {
             match item {
                 CurveItem::Move(to) => {
-                    min_x = min_x.min(cursor.x);
-                    min_y = min_y.min(cursor.y);
-                    max_x = max_x.max(cursor.x);
-                    max_y = max_y.max(cursor.y);
                     cursor = *to;
                 }
                 CurveItem::Line(to) => {
-                    min_x = min_x.min(cursor.x);
-                    min_y = min_y.min(cursor.y);
-                    max_x = max_x.max(cursor.x);
-                    max_y = max_y.max(cursor.y);
+                    min = min.min(cursor).min(*to);
+                    max = max.max(cursor).max(*to);
                     cursor = *to;
                 }
                 CurveItem::Cubic(c0, c1, end) => {
@@ -507,17 +499,17 @@ impl Curve {
                     );
 
                     let bbox = cubic.bounding_box();
-                    min_x = min_x.min(Abs::pt(bbox.x0)).min(Abs::pt(bbox.x1));
-                    min_y = min_y.min(Abs::pt(bbox.y0)).min(Abs::pt(bbox.y1));
-                    max_x = max_x.max(Abs::pt(bbox.x0)).max(Abs::pt(bbox.x1));
-                    max_y = max_y.max(Abs::pt(bbox.y0)).max(Abs::pt(bbox.y1));
+                    min.x = min.x.min(Abs::pt(bbox.x0)).min(Abs::pt(bbox.x1));
+                    min.y = min.y.min(Abs::pt(bbox.y0)).min(Abs::pt(bbox.y1));
+                    max.x = max.x.max(Abs::pt(bbox.x0)).max(Abs::pt(bbox.x1));
+                    max.y = max.y.max(Abs::pt(bbox.y0)).max(Abs::pt(bbox.y1));
                     cursor = *end;
                 }
                 CurveItem::Close => (),
             }
         }
 
-        Size::new(max_x - min_x, max_y - min_y)
+        Size::new(max.x - min.x, max.y - min.y)
     }
 }
 
diff --git a/tests/ref/curve-stroke-gradient-sharp.png b/tests/ref/curve-stroke-gradient-sharp.png
new file mode 100644
index 0000000000000000000000000000000000000000..ae2a86ef02f1f159616ad435e783991f0ab12783
GIT binary patch
literal 399
zcmV;A0dW3_P)<h;3K|Lk000e1NJLTq007(o002A)0{{R3I>00`0000CP)t-s|NsC0
zK{lgsl>l_v$KM!+0003#Nkl<Zc-rmSF%HBq3<E)l_y0d12&7{dN?;0Y87qLNwO!YB
zUDtKJ2&mD1zcT8cwE?p>N7p^61K6aES-76Gu{m2-r#3ca`;P8mjp-g%PNz1}nYNrx
zZK5-6X`O<=Mr?VVa==Dxd7WawY+FvJ6i=s=oK7LOP9b?+3qy2<EvxGmgy;-gRM*`k
z*g7TTbxmBAr&GYb&i?_-ux;x6aWKQSsq=@y4BMv89|bdPn>v3G%&-M?GG^#x(;1x(
zc{<&4PNyTDPB)y>>42xx?Z$Pw?CT(#&FFN|*8#HCh)$P$9f+%n>vX}_fw-!S&bO&f
zKSy+d<A{K6^&lyx3mgFkbZdvVQQh*fdsw%6VG`GEUUlVlo0pV%-QM+bUbpx#Ag}xU
tla4Aw_wmO#<s>#+cTdT#>$<M%MSq3m2g=9!)0F@K002ovPDHLkV1fo%yAuEa

literal 0
HcmV?d00001

diff --git a/tests/ref/curve-stroke-gradient.png b/tests/ref/curve-stroke-gradient.png
index 042f540a5c4d839ec05a293c4484a46b84cd0010..7d5b1add45202106ffbaa244af9daa3575174c91 100644
GIT binary patch
literal 2367
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
T;tyWX#Yhbw7z#A{AI$zgPrz<p

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

diff --git a/tests/suite/visualize/curve.typ b/tests/suite/visualize/curve.typ
index 14a1c0cc8..c94f763c4 100644
--- a/tests/suite/visualize/curve.typ
+++ b/tests/suite/visualize/curve.typ
@@ -130,6 +130,16 @@
   down, up, down, up, down,
 )
 
+--- curve-stroke-gradient-sharp ---
+#set page(width: auto)
+#let down = curve.line((40pt, 40pt), relative: true)
+#let up = curve.line((40pt, -40pt), relative: true)
+
+#curve(
+  stroke: 4pt + gradient.linear(red, blue).sharp(3),
+  down, up, down, up, down,
+)
+
 --- curve-fill-rule ---
 #stack(
   dir: ltr,