From 7f139517b9ba8cf4f51083d5387971571d1aa950 Mon Sep 17 00:00:00 2001
From: Andrew Voynov <37143421+Andrew15-5@users.noreply.github.com>
Date: Mon, 16 Dec 2024 15:18:34 +0300
Subject: [PATCH 01/10] Derivation comment for calculation in `repeat` (#5575)

---
 crates/typst-layout/src/repeat.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/crates/typst-layout/src/repeat.rs b/crates/typst-layout/src/repeat.rs
index b761438c8..bfc7b32ce 100644
--- a/crates/typst-layout/src/repeat.rs
+++ b/crates/typst-layout/src/repeat.rs
@@ -33,8 +33,17 @@ pub fn layout_repeat(
     let fill = region.size.x;
     let width = piece.width();
 
-    // count * width + (count - 1) * gap = fill, but count is an integer so
-    // we need to round down and get the remainder.
+    // We need to fit the body N times, but the number of gaps is (N - 1):
+    // N * w + (N - 1) * g ≤ F
+    // where N - body count (count)
+    //       w - body width (width)
+    //       g - gap width (gap)
+    //       F - available space to fill (fill)
+    //
+    // N * w + N * g - g ≤ F
+    // N * (w + g) ≤ F + g
+    // N ≤ (F + g) / (w + g)
+    // N = ⌊(F + g) / (w + g)⌋
     let count = ((fill + gap) / (width + gap)).floor();
     let remaining = (fill + gap) % (width + gap);
 
@@ -52,7 +61,7 @@ pub fn layout_repeat(
     if width > Abs::zero() {
         for _ in 0..(count as usize).min(1000) {
             frame.push_frame(Point::with_x(offset), piece.clone());
-            offset += piece.width() + gap;
+            offset += width + gap;
         }
     }
 

From d3620df4c63b5856832b23b26eba71aecd9f543e Mon Sep 17 00:00:00 2001
From: +merlan #flirora <uruwi@protonmail.com>
Date: Mon, 16 Dec 2024 08:45:57 -0500
Subject: [PATCH 02/10] Add reversed numbering (#5563)

---
 crates/typst-layout/src/lists.rs              |   8 ++++--
 crates/typst-library/src/model/enum.rs        |  23 +++++++++++++++---
 .../ref/enum-numbering-reversed-overriden.png | Bin 0 -> 666 bytes
 tests/ref/enum-numbering-reversed.png         | Bin 0 -> 620 bytes
 tests/suite/model/enum.typ                    |  17 +++++++++++++
 5 files changed, 42 insertions(+), 6 deletions(-)
 create mode 100644 tests/ref/enum-numbering-reversed-overriden.png
 create mode 100644 tests/ref/enum-numbering-reversed.png

diff --git a/crates/typst-layout/src/lists.rs b/crates/typst-layout/src/lists.rs
index 08c2a2f45..0d51a1e4e 100644
--- a/crates/typst-layout/src/lists.rs
+++ b/crates/typst-layout/src/lists.rs
@@ -74,6 +74,7 @@ pub fn layout_enum(
     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 gutter = elem.spacing(styles).unwrap_or_else(|| {
@@ -86,7 +87,9 @@ pub fn layout_enum(
 
     let mut cells = vec![];
     let mut locator = locator.split();
-    let mut number = elem.start(styles);
+    let mut number =
+        elem.start(styles)
+            .unwrap_or_else(|| if reversed { elem.children.len() } else { 1 });
     let mut parents = EnumElem::parents_in(styles);
 
     let full = elem.full(styles);
@@ -127,7 +130,8 @@ pub fn layout_enum(
             item.body.clone().styled(EnumElem::set_parents(smallvec![number])),
             locator.next(&item.body.span()),
         ));
-        number = number.saturating_add(1);
+        number =
+            if reversed { number.saturating_sub(1) } else { number.saturating_add(1) };
     }
 
     let grid = CellGrid::new(
diff --git a/crates/typst-library/src/model/enum.rs b/crates/typst-library/src/model/enum.rs
index e0121ba24..eb3c2ea45 100644
--- a/crates/typst-library/src/model/enum.rs
+++ b/crates/typst-library/src/model/enum.rs
@@ -9,7 +9,7 @@ use crate::foundations::{
     cast, elem, scope, Array, Content, NativeElement, Packed, Show, Smart, StyleChain,
     Styles, TargetElem,
 };
-use crate::html::{attr, tag, HtmlElem};
+use crate::html::{attr, tag, HtmlAttr, HtmlElem};
 use crate::layout::{Alignment, BlockElem, Em, HAlignment, Length, VAlignment, VElem};
 use crate::model::{ListItemLike, ListLike, Numbering, NumberingPattern, ParElem};
 
@@ -127,8 +127,7 @@ pub struct EnumElem {
     ///   [Ahead],
     /// )
     /// ```
-    #[default(1)]
-    pub start: usize,
+    pub start: Smart<usize>,
 
     /// Whether to display the full numbering, including the numbers of
     /// all parent enumerations.
@@ -144,6 +143,17 @@ pub struct EnumElem {
     #[default(false)]
     pub full: bool,
 
+    /// Whether to reverse the numbering for this enumeration.
+    ///
+    /// ```example
+    /// #set enum(reversed: true)
+    /// + Coffee
+    /// + Tea
+    /// + Milk
+    /// ```
+    #[default(false)]
+    pub reversed: bool,
+
     /// The indentation of each item.
     #[resolve]
     pub indent: Length,
@@ -217,7 +227,12 @@ impl EnumElem {
 impl Show for Packed<EnumElem> {
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         if TargetElem::target_in(styles).is_html() {
-            return Ok(HtmlElem::new(tag::ol)
+            let mut elem = HtmlElem::new(tag::ol);
+            if self.reversed(styles) {
+                elem =
+                    elem.with_attr(const { HtmlAttr::constant("reversed") }, "reversed");
+            }
+            return Ok(elem
                 .with_body(Some(Content::sequence(self.children.iter().map(|item| {
                     let mut li = HtmlElem::new(tag::li);
                     if let Some(nr) = item.number(styles) {
diff --git a/tests/ref/enum-numbering-reversed-overriden.png b/tests/ref/enum-numbering-reversed-overriden.png
new file mode 100644
index 0000000000000000000000000000000000000000..827f38d1d57648b5a673159ab19f849df0198375
GIT binary patch
literal 666
zcmV;L0%iS)P)<h;3K|Lk000e1NJLTq004LZ003MF00000fHE#F0007ENkl<Zc-rmO
z-%C?*7{_t{jIN^#i!QoSgpmnZxP&f(ic+YJsMHEcN@K$u%{I2tFjpxPYplc(Q3};a
z><7Vw)<{`yZN`diYAYt0Tl?Ym3C?!T&h?0=E}rkz`|ib;=kR<_4gS%oVVGft8U8Eq
zH&3N=iUJw@T$7a=F14Eq{;tfUa?A_uRPe0}rXv#V)xO@AB7*f#a4=AAXg_?sbe{<J
z44@_DO$!~>0ZV&{VA!30+>8Q1PJb<n>8_`|Kp1AYN_f)wK+NmS4r7=K-t3r~6FasW
zZx2zyUrnE-PBdn%lT`5P#9*fc@3^PZ5Pn=+^U{rh=6NDGkxbViloR?(J<uAUnsK*v
z3Hpf8mg8eiA1@Gw8Ll4AElL?Q+s;mr!F>j?Vn;WTQB%QgqfyL@F90No;N<8t3EuA~
zoUzV$sx?&ZGZTa`^3#J@EePqU+W=;%;7o7l`sHw`-}T=f|H%u4VTP-PbDj+`Z>a31
z_f&AaE7&e}M1fS#FcCat$FXJEe>EC@(7+Gda%!I(KJB7`F*{zHmBWYqL@=x_q)HWU
z1Xh$Ff=Apy$0s56iZRE)8ZQur8Lk#CMx`9;8P>g`f>Y;To)bINfV7PYo^M-Mi@nl>
zFsNYk)`lc_`{)5Oc;RZWE>pR2gbcRKL7ga;I@Sa{N)y4$n#Xr>GAMNa&Jl}}7YM@)
zR}25n=6~hOeaB!kc&T8=z7xBW<qp&%Y^H*JMQCM@M3ivGGc&SBqJ<FdhU~_Rba3>F
zl<_?P9o**wR6!v%Tiy`DYXAzoxfo`c;r|}~1Cu#{AAX{UQUCw|07*qoM6N<$f?anv
Ak^lez

literal 0
HcmV?d00001

diff --git a/tests/ref/enum-numbering-reversed.png b/tests/ref/enum-numbering-reversed.png
new file mode 100644
index 0000000000000000000000000000000000000000..12d77df45ae3408bddf5f972aa4510d1f077ac8d
GIT binary patch
literal 620
zcmV-y0+aoTP)<h;3K|Lk000e1NJLTq004LZ001=z00000ugP${0006rNkl<Zc-rmM
z-%C?r9LI70l_H7)p%G=~BBaO*%YFw#>0(K(MrbiwL%b*utJx2WZEZHh`Rhp0upkz!
zCa$O?(B?GfX^z^~4rn_z=RrC<=M$X$Fz>v1Cg}5Ay}vili-!lkC0L_VLSYJ1ctgO6
zAEKKj34iTL6#C6=%Xw=yKis{eia80w{hqKU-vJ#UH)Ok>gBl<RXT+9g`M%@_Aj8w%
z#!c<8IXCyfJzz)5YMCGa<Gs$5&#Ey1m^+T(VN?nz!}nvp-9deKM>Po;*p|-4)ehx%
z>wqm;xYHPqN~Pi0Zvt>^fiJ@sL1}hZ7{V)lXOh*RJSlC*x4k02sAUi(08g16aXil5
z9JksS2@|ch`B0<h<CS5!Om1+72QzeYQJBK3fn(3Pd{*5%rM=NuBskQXuE?d}MN=1E
z773o8g-R?;H~WEi0}LhyZ)FI>z>BB&AO3ZEe1Fh^<{{GXunQ~TUj5kUQow$}MHr4Z
zqc=VMH#Zrbm{iM4i)!5OBn*2swOX`9lt%EfA&Q5FKKYT=ZW8DMq44^Gg$SZ4!f>Qe
zfirUebUr*0?KR1YA)>Hk-n2YawgIDCfg}<qVDJ-uartt#s{rOmhP{?nVE^?QlCZi^
zlB@nL@2#E1z6Aw#Ortn(!ZUK#E$c%#q`bK9B8bAJ04FK+c?5eH82vcF|ExxXPt!*d
z?m9RKBdesz42DnXn#OCo9Vb7Xv-~;wnr<!%Q<%aV9{vY+m_a%3z%5<?0000<MNUMn
GLSTX{ARPDr

literal 0
HcmV?d00001

diff --git a/tests/suite/model/enum.typ b/tests/suite/model/enum.typ
index c5e562159..258c6f6bc 100644
--- a/tests/suite/model/enum.typ
+++ b/tests/suite/model/enum.typ
@@ -71,6 +71,23 @@ a + 0.
 + First
   + Nested
 
+--- enum-numbering-reversed ---
+// Test reverse numbering.
+#set enum(reversed: true)
++ Coffee
++ Tea
++ Milk
+
+--- enum-numbering-reversed-overriden ---
+// Test reverse numbering with overriden numbers.
+#set enum(reversed: true)
++ A
++ B
++ C
+9. D
++ E
++ F
+
 --- enum-numbering-closure ---
 // Test numbering with closure.
 #enum(

From 1b10d19d76e2ddf09a63d00a6fc56556d2bbfe08 Mon Sep 17 00:00:00 2001
From: Myriad-Dreamin <35292584+Myriad-Dreamin@users.noreply.github.com>
Date: Mon, 16 Dec 2024 22:09:38 +0800
Subject: [PATCH 03/10] Consider parameters when iterating items in scope
 (#5517)

---
 crates/typst-ide/src/matchers.rs | 41 ++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/crates/typst-ide/src/matchers.rs b/crates/typst-ide/src/matchers.rs
index 4aeba29be..18262f701 100644
--- a/crates/typst-ide/src/matchers.rs
+++ b/crates/typst-ide/src/matchers.rs
@@ -123,6 +123,36 @@ 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.
+                let body = parent.find(v.body().span());
+                body.is_some_and(|n| n.find(node.span()).is_some())
+            }) {
+                for param in v.params().children() {
+                    match param {
+                        ast::Param::Pos(pattern) => {
+                            for ident in pattern.bindings() {
+                                if let Some(t) = recv(NamedItem::Var(ident)) {
+                                    return Some(t);
+                                }
+                            }
+                        }
+                        ast::Param::Named(n) => {
+                            if let Some(t) = recv(NamedItem::Var(n.name())) {
+                                return Some(t);
+                            }
+                        }
+                        ast::Param::Spread(s) => {
+                            if let Some(sink_ident) = s.sink_ident() {
+                                if let Some(t) = recv(NamedItem::Var(sink_ident)) {
+                                    return Some(t);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
             ancestor = Some(parent.clone());
             continue;
         }
@@ -269,6 +299,17 @@ mod tests {
         assert!(!has_named_items(r#"#let a = 1;#let b = 2;"#, 8, "b"));
     }
 
+    #[test]
+    fn test_param_named_items() {
+        // Has named items
+        assert!(has_named_items(r#"#let f(a) = 1;#let b = 2;"#, 12, "a"));
+        assert!(has_named_items(r#"#let f(a: b) = 1;#let b = 2;"#, 15, "a"));
+
+        // Doesn't have named items
+        assert!(!has_named_items(r#"#let f(a) = 1;#let b = 2;"#, 19, "a"));
+        assert!(!has_named_items(r#"#let f(a: b) = 1;#let b = 2;"#, 15, "b"));
+    }
+
     #[test]
     fn test_import_named_items() {
         // Cannot test much.

From 8b1e0d3a233950bd8fd553e118ec6342efb42855 Mon Sep 17 00:00:00 2001
From: Malo <57839069+MDLC01@users.noreply.github.com>
Date: Mon, 16 Dec 2024 15:10:42 +0100
Subject: [PATCH 04/10] Improve `symbol` `repr` (#5505)

---
 .../typst-library/src/foundations/symbol.rs   | 42 ++++++++++++-
 tests/suite/symbols/symbol.typ                | 62 +++++++++++++++++++
 2 files changed, 103 insertions(+), 1 deletion(-)

diff --git a/crates/typst-library/src/foundations/symbol.rs b/crates/typst-library/src/foundations/symbol.rs
index fcb3a3ce5..880305284 100644
--- a/crates/typst-library/src/foundations/symbol.rs
+++ b/crates/typst-library/src/foundations/symbol.rs
@@ -246,10 +246,50 @@ impl Debug for List {
 
 impl crate::foundations::Repr for Symbol {
     fn repr(&self) -> EcoString {
-        eco_format!("\"{}\"", self.get())
+        match &self.0 {
+            Repr::Single(c) => eco_format!("symbol(\"{}\")", *c),
+            Repr::Complex(variants) => {
+                eco_format!("symbol{}", repr_variants(variants.iter().copied(), ""))
+            }
+            Repr::Modified(arc) => {
+                let (list, modifiers) = arc.as_ref();
+                if modifiers.is_empty() {
+                    eco_format!("symbol{}", repr_variants(list.variants(), ""))
+                } else {
+                    eco_format!("symbol{}", repr_variants(list.variants(), modifiers))
+                }
+            }
+        }
     }
 }
 
+fn repr_variants<'a>(
+    variants: impl Iterator<Item = (&'a str, char)>,
+    applied_modifiers: &str,
+) -> String {
+    crate::foundations::repr::pretty_array_like(
+        &variants
+            .filter(|(variant, _)| {
+                // Only keep variants that can still be accessed, i.e., variants
+                // that contain all applied modifiers.
+                parts(applied_modifiers).all(|am| variant.split('.').any(|m| m == am))
+            })
+            .map(|(variant, c)| {
+                let trimmed_variant = variant
+                    .split('.')
+                    .filter(|&m| parts(applied_modifiers).all(|am| m != am));
+                if trimmed_variant.clone().all(|m| m.is_empty()) {
+                    eco_format!("\"{c}\"")
+                } else {
+                    let trimmed_modifiers = trimmed_variant.collect::<Vec<_>>().join(".");
+                    eco_format!("(\"{}\", \"{}\")", trimmed_modifiers, c)
+                }
+            })
+            .collect::<Vec<_>>(),
+        false,
+    )
+}
+
 impl Serialize for Symbol {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
diff --git a/tests/suite/symbols/symbol.typ b/tests/suite/symbols/symbol.typ
index 30d87e44f..f2f6abf85 100644
--- a/tests/suite/symbols/symbol.typ
+++ b/tests/suite/symbols/symbol.typ
@@ -49,3 +49,65 @@
 --- symbol-unknown-modifier ---
 // Error: 13-20 unknown symbol modifier
 #emoji.face.garbage
+
+--- symbol-repr ---
+#test(
+  repr(sym.amp),
+  `symbol("&", ("inv", "⅋"))`.text,
+)
+#test(
+  repr(sym.amp.inv),
+  `symbol("⅋")`.text,
+)
+#test(
+  repr(sym.arrow.double.r),
+  ```
+  symbol(
+    "⇒",
+    ("bar", "⤇"),
+    ("long", "⟹"),
+    ("long.bar", "⟾"),
+    ("not", "⇏"),
+    ("l", "⇔"),
+    ("l.long", "⟺"),
+    ("l.not", "⇎"),
+  )
+  ```.text,
+)
+#test(repr(sym.smash), "symbol(\"⨳\")")
+
+#let envelope = symbol(
+  "🖂",
+  ("stamped", "🖃"),
+  ("stamped.pen", "🖆"),
+  ("lightning", "🖄"),
+  ("fly", "🖅"),
+)
+#test(
+  repr(envelope),
+  ```
+  symbol(
+    "🖂",
+    ("stamped", "🖃"),
+    ("stamped.pen", "🖆"),
+    ("lightning", "🖄"),
+    ("fly", "🖅"),
+  )
+  ```.text,
+)
+#test(
+  repr(envelope.stamped),
+  `symbol("🖃", ("pen", "🖆"))`.text,
+)
+#test(
+  repr(envelope.stamped.pen),
+  `symbol("🖆")`.text,
+)
+#test(
+  repr(envelope.lightning),
+  `symbol("🖄")`.text,
+)
+#test(
+  repr(envelope.fly),
+  `symbol("🖅")`.text,
+)

From 75273937f762ebeb05f71e91434b298b52b44670 Mon Sep 17 00:00:00 2001
From: Johann Birnick <6528009+jbirnick@users.noreply.github.com>
Date: Mon, 16 Dec 2024 10:22:00 -0800
Subject: [PATCH 05/10] Transform high level headings to HTML (#5525)

---
 crates/typst-library/src/html/dom.rs      | 14 ++++++++----
 crates/typst-library/src/model/heading.rs | 28 +++++++++++++++++++----
 2 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/crates/typst-library/src/html/dom.rs b/crates/typst-library/src/html/dom.rs
index 3d558fb0f..5b6eab4d6 100644
--- a/crates/typst-library/src/html/dom.rs
+++ b/crates/typst-library/src/html/dom.rs
@@ -122,8 +122,8 @@ impl HtmlTag {
         let bytes = string.as_bytes();
         let mut i = 0;
         while i < bytes.len() {
-            if !bytes[i].is_ascii_alphanumeric() {
-                panic!("constant tag name must be ASCII alphanumeric");
+            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;
         }
@@ -220,8 +220,10 @@ impl HtmlAttr {
         let bytes = string.as_bytes();
         let mut i = 0;
         while i < bytes.len() {
-            if !bytes[i].is_ascii_alphanumeric() {
-                panic!("constant attribute name must be ASCII alphanumeric");
+            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;
         }
@@ -621,5 +623,9 @@ pub mod attr {
         href
         name
         value
+        role
     }
+
+    #[allow(non_upper_case_globals)]
+    pub const aria_level: HtmlAttr = HtmlAttr::constant("aria-level");
 }
diff --git a/crates/typst-library/src/model/heading.rs b/crates/typst-library/src/model/heading.rs
index fc0e4ad25..ec9cf4e99 100644
--- a/crates/typst-library/src/model/heading.rs
+++ b/crates/typst-library/src/model/heading.rs
@@ -1,14 +1,15 @@
 use std::num::NonZeroUsize;
 
+use ecow::eco_format;
 use typst_utils::NonZeroExt;
 
-use crate::diag::SourceResult;
+use crate::diag::{warning, SourceResult};
 use crate::engine::Engine;
 use crate::foundations::{
     elem, Content, NativeElement, Packed, Resolve, Show, ShowSet, Smart, StyleChain,
     Styles, Synthesize, TargetElem,
 };
-use crate::html::{tag, HtmlElem};
+use crate::html::{attr, tag, HtmlElem};
 use crate::introspection::{
     Count, Counter, CounterUpdate, Locatable, Locator, LocatorLink,
 };
@@ -272,9 +273,26 @@ impl Show for Packed<HeadingElem> {
             // 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);
-            let t = [tag::h2, tag::h3, tag::h4, tag::h5, tag::h6][level.get().min(5) - 1];
-            HtmlElem::new(t).with_body(Some(realized)).pack().spanned(span)
+            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 realized = BlockBody::Content(realized);
             BlockElem::new().with_body(Some(realized)).pack().spanned(span)

From 51020fcf3cd6fbe62d148d2188b9aaac4445bf63 Mon Sep 17 00:00:00 2001
From: Eric Biedert <github@ericbiedert.de>
Date: Mon, 16 Dec 2024 21:23:13 +0100
Subject: [PATCH 06/10] Get numbering of page counter from style chain (#5589)

---
 .../src/introspection/counter.rs              |  30 ++++++++++--------
 tests/ref/counter-page-display.png            | Bin 0 -> 150 bytes
 tests/suite/introspection/counter.typ         |   8 +++++
 3 files changed, 24 insertions(+), 14 deletions(-)
 create mode 100644 tests/ref/counter-page-display.png

diff --git a/crates/typst-library/src/introspection/counter.rs b/crates/typst-library/src/introspection/counter.rs
index b884844c6..f67c6daab 100644
--- a/crates/typst-library/src/introspection/counter.rs
+++ b/crates/typst-library/src/introspection/counter.rs
@@ -366,20 +366,22 @@ impl Counter {
             .custom()
             .or_else(|| {
                 let styles = styles?;
-                let CounterKey::Selector(Selector::Elem(func, _)) = self.0 else {
-                    return None;
-                };
-
-                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())
-                } else {
-                    None
+                match self.0 {
+                    CounterKey::Page => PageElem::numbering_in(styles).clone(),
+                    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())
+                        } else {
+                            None
+                        }
+                    }
+                    _ => None,
                 }
             })
             .unwrap_or_else(|| NumberingPattern::from_str("1.1").unwrap().into());
diff --git a/tests/ref/counter-page-display.png b/tests/ref/counter-page-display.png
new file mode 100644
index 0000000000000000000000000000000000000000..040b634d5976906bbce629db4767413e3ea52211
GIT binary patch
literal 150
zcmeAS@N?(olHy`uVBq!ia0vp^6+kS<0VEg>Eo$`yQn8*cjv*Ddl7HAcG$dYm6xi*q
zE4Q@*!dTXJw4ICn#G{kb_Ol&%<i7f~IZww?Q|q)=o|dEbUF+hu{xM(>J8$v(fBp56
rU(q$IQ{MiMpS$$C8}|gTF$LX>f+v31PV_aI53<nH)z4*}Q$iB}WDz=|

literal 0
HcmV?d00001

diff --git a/tests/suite/introspection/counter.typ b/tests/suite/introspection/counter.typ
index e97f05dd4..2f095f2fb 100644
--- a/tests/suite/introspection/counter.typ
+++ b/tests/suite/introspection/counter.typ
@@ -102,6 +102,14 @@ B
 #set page(numbering: "1 / 1", margin: (bottom: 20pt))
 #counter(page).update(5)
 
+--- counter-page-display ---
+// Counter display should use numbering from style chain.
+#set page(
+  numbering: "A",
+  margin: (bottom: 20pt),
+  footer: context align(center, counter(page).display())
+)
+
 --- counter-figure ---
 // Count figures.
 #figure(numbering: "A", caption: [Four 'A's], kind: image, supplement: "Figure")[_AAAA!_]

From ed67220e4b5ae6b3a1bc50f59bd52b5b1dea3a6b Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 17 Dec 2024 10:25:15 +0100
Subject: [PATCH 07/10] Remove deprecated things and compatibility behaviours
 (#5591)

---
 crates/typst-library/src/foundations/mod.rs   |   1 -
 crates/typst-library/src/foundations/ops.rs   |  16 ---
 .../typst-library/src/foundations/styles.rs   |  62 +-----------
 crates/typst-library/src/foundations/ty.rs    |  18 ----
 .../src/introspection/counter.rs              |  46 +--------
 .../typst-library/src/introspection/locate.rs |  92 ++----------------
 .../typst-library/src/introspection/query.rs  |  20 +---
 .../typst-library/src/introspection/state.rs  |  80 +--------------
 crates/typst-library/src/layout/measure.rs    |  22 +----
 crates/typst-library/src/model/outline.rs     |  11 +--
 docs/changelog/0.11.0.md                      |   8 +-
 docs/changelog/0.12.0.md                      |   4 +-
 docs/changelog/earlier.md                     |   2 +-
 tests/ref/context-compatibility-locate.png    | Bin 1523 -> 0 bytes
 tests/ref/context-compatibility-styling.png   | Bin 380 -> 0 bytes
 tests/ref/outline-indent-no-numbering.png     | Bin 4654 -> 2924 bytes
 tests/ref/outline-indent-numbering.png        | Bin 10607 -> 7101 bytes
 tests/suite/foundations/context.typ           |  40 --------
 tests/suite/foundations/type.typ              |   8 --
 tests/suite/model/outline.typ                 |   4 -
 tests/suite/styling/fold.typ                  |  12 +--
 21 files changed, 35 insertions(+), 411 deletions(-)
 delete mode 100644 tests/ref/context-compatibility-locate.png
 delete mode 100644 tests/ref/context-compatibility-styling.png

diff --git a/crates/typst-library/src/foundations/mod.rs b/crates/typst-library/src/foundations/mod.rs
index 28f983186..d960a666c 100644
--- a/crates/typst-library/src/foundations/mod.rs
+++ b/crates/typst-library/src/foundations/mod.rs
@@ -119,7 +119,6 @@ pub(super) fn define(global: &mut Scope, inputs: Dict, features: &Features) {
     global.define_func::<panic>();
     global.define_func::<assert>();
     global.define_func::<eval>();
-    global.define_func::<style>();
     if features.is_enabled(Feature::Html) {
         global.define_func::<target>();
     }
diff --git a/crates/typst-library/src/foundations/ops.rs b/crates/typst-library/src/foundations/ops.rs
index ba36137f0..b41fce8d0 100644
--- a/crates/typst-library/src/foundations/ops.rs
+++ b/crates/typst-library/src/foundations/ops.rs
@@ -36,11 +36,6 @@ pub fn join(lhs: Value, rhs: Value) -> StrResult<Value> {
         (Symbol(a), Content(b)) => Content(TextElem::packed(a.get()) + b),
         (Array(a), Array(b)) => Array(a + b),
         (Dict(a), Dict(b)) => Dict(a + b),
-
-        // Type compatibility.
-        (Type(a), Str(b)) => Str(format_str!("{a}{b}")),
-        (Str(a), Type(b)) => Str(format_str!("{a}{b}")),
-
         (a, b) => mismatch!("cannot join {} with {}", a, b),
     })
 }
@@ -157,10 +152,6 @@ pub fn add(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
         (Datetime(a), Duration(b)) => Datetime(a + b),
         (Duration(a), Datetime(b)) => Datetime(b + a),
 
-        // Type compatibility.
-        (Type(a), Str(b)) => Str(format_str!("{a}{b}")),
-        (Str(a), Type(b)) => Str(format_str!("{a}{b}")),
-
         (Dyn(a), Dyn(b)) => {
             // Alignments can be summed.
             if let (Some(&a), Some(&b)) =
@@ -469,9 +460,6 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
             rat == rel.rel && rel.abs.is_zero()
         }
 
-        // Type compatibility.
-        (Type(ty), Str(str)) | (Str(str), Type(ty)) => ty.compat_name() == str.as_str(),
-
         _ => false,
     }
 }
@@ -569,10 +557,6 @@ pub fn contains(lhs: &Value, rhs: &Value) -> Option<bool> {
         (Str(a), Dict(b)) => Some(b.contains(a)),
         (a, Array(b)) => Some(b.contains(a.clone())),
 
-        // Type compatibility.
-        (Type(a), Str(b)) => Some(b.as_str().contains(a.compat_name())),
-        (Type(a), Dict(b)) => Some(b.contains(a.compat_name())),
-
         _ => Option::None,
     }
 }
diff --git a/crates/typst-library/src/foundations/styles.rs b/crates/typst-library/src/foundations/styles.rs
index af4909e54..7354719e9 100644
--- a/crates/typst-library/src/foundations/styles.rs
+++ b/crates/typst-library/src/foundations/styles.rs
@@ -3,75 +3,19 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::{mem, ptr};
 
-use comemo::{Track, Tracked};
+use comemo::Tracked;
 use ecow::{eco_vec, EcoString, EcoVec};
 use smallvec::SmallVec;
 use typst_syntax::Span;
 use typst_utils::LazyHash;
 
-use crate::diag::{warning, SourceResult, Trace, Tracepoint};
+use crate::diag::{SourceResult, Trace, Tracepoint};
 use crate::engine::Engine;
 use crate::foundations::{
-    cast, elem, func, ty, Content, Context, Element, Func, NativeElement, Packed, Repr,
-    Selector, Show,
+    cast, ty, Content, Context, Element, Func, NativeElement, Repr, Selector,
 };
-use crate::introspection::Locatable;
 use crate::text::{FontFamily, FontList, TextElem};
 
-/// Provides access to active styles.
-///
-/// **Deprecation planned.** Use [context] instead.
-///
-/// ```example
-/// #let thing(body) = style(styles => {
-///   let size = measure(body, styles)
-///   [Width of "#body" is #size.width]
-/// })
-///
-/// #thing[Hey] \
-/// #thing[Welcome]
-/// ```
-#[func]
-pub fn style(
-    /// The engine.
-    engine: &mut Engine,
-    /// The call site span.
-    span: Span,
-    /// A function to call with the styles. Its return value is displayed
-    /// in the document.
-    ///
-    /// This function is called once for each time the content returned by
-    /// `style` appears in the document. That makes it possible to generate
-    /// content that depends on the style context it appears in.
-    func: Func,
-) -> Content {
-    engine.sink.warn(warning!(
-        span, "`style` is deprecated";
-        hint: "use a `context` expression instead"
-    ));
-
-    StyleElem::new(func).pack().spanned(span)
-}
-
-/// Executes a style access.
-#[elem(Locatable, Show)]
-struct StyleElem {
-    /// The function to call with the styles.
-    #[required]
-    func: Func,
-}
-
-impl Show for Packed<StyleElem> {
-    #[typst_macros::time(name = "style", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let context = Context::new(self.location(), Some(styles));
-        Ok(self
-            .func()
-            .call(engine, context.track(), [styles.to_map()])?
-            .display())
-    }
-}
-
 /// A list of style properties.
 #[ty(cast)]
 #[derive(Default, PartialEq, Clone, Hash)]
diff --git a/crates/typst-library/src/foundations/ty.rs b/crates/typst-library/src/foundations/ty.rs
index 8b20e2c62..a2395f2a7 100644
--- a/crates/typst-library/src/foundations/ty.rs
+++ b/crates/typst-library/src/foundations/ty.rs
@@ -44,16 +44,6 @@ use crate::foundations::{
 /// #type(int) \
 /// #type(type)
 /// ```
-///
-/// # Compatibility
-/// In Typst 0.7 and lower, the `type` function returned a string instead of a
-/// type. Compatibility with the old way will remain for a while to give package
-/// authors time to upgrade, but it will be removed at some point.
-///
-/// - Checks like `{int == "integer"}` evaluate to `{true}`
-/// - Adding/joining a type and string will yield a string
-/// - The `{in}` operator on a type and a dictionary will evaluate to `{true}`
-///   if the dictionary has a string key matching the type's name
 #[ty(scope, cast)]
 #[derive(Copy, Clone, Eq, PartialEq, Hash)]
 pub struct Type(Static<NativeTypeData>);
@@ -111,14 +101,6 @@ impl Type {
     }
 }
 
-// Type compatibility.
-impl Type {
-    /// The type's backward-compatible name.
-    pub fn compat_name(&self) -> &str {
-        self.long_name()
-    }
-}
-
 #[scope]
 impl Type {
     /// Determines a value's type.
diff --git a/crates/typst-library/src/introspection/counter.rs b/crates/typst-library/src/introspection/counter.rs
index f67c6daab..e189103d9 100644
--- a/crates/typst-library/src/introspection/counter.rs
+++ b/crates/typst-library/src/introspection/counter.rs
@@ -7,7 +7,7 @@ use smallvec::{smallvec, SmallVec};
 use typst_syntax::Span;
 use typst_utils::NonZeroExt;
 
-use crate::diag::{bail, warning, At, HintedStrResult, SourceResult};
+use crate::diag::{bail, At, HintedStrResult, SourceResult};
 use crate::engine::{Engine, Route, Sink, Traced};
 use crate::foundations::{
     cast, elem, func, scope, select_where, ty, Args, Array, Construct, Content, Context,
@@ -353,7 +353,7 @@ impl Counter {
     }
 
     /// Shared implementation of displaying between `counter.display` and
-    /// `DisplayElem`, which will be deprecated.
+    /// `CounterDisplayElem`.
     fn display_impl(
         &self,
         engine: &mut Engine,
@@ -441,11 +441,6 @@ impl Counter {
 
     /// Displays the current value of the counter with a numbering and returns
     /// the formatted output.
-    ///
-    /// _Compatibility:_ For compatibility with Typst 0.10 and lower, this
-    /// function also works without an established context. Then, it will create
-    /// opaque contextual content rather than directly returning the output of
-    /// the numbering. This behaviour will be removed in a future release.
     #[func(contextual)]
     pub fn display(
         self,
@@ -474,19 +469,8 @@ impl Counter {
         #[default(false)]
         both: bool,
     ) -> SourceResult<Value> {
-        if let Ok(loc) = context.location() {
-            self.display_impl(engine, loc, numbering, both, context.styles().ok())
-        } else {
-            engine.sink.warn(warning!(
-                span, "`counter.display` without context is deprecated";
-                hint: "use it in a `context` expression instead"
-            ));
-
-            Ok(CounterDisplayElem::new(self, numbering, both)
-                .pack()
-                .spanned(span)
-                .into_value())
-        }
+        let loc = context.location().at(span)?;
+        self.display_impl(engine, loc, numbering, both, context.styles().ok())
     }
 
     /// Retrieves the value of the counter at the given location. Always returns
@@ -495,10 +479,6 @@ impl Counter {
     /// The `selector` must match exactly one element in the document. The most
     /// useful kinds of selectors for this are [labels]($label) and
     /// [locations]($location).
-    ///
-    /// _Compatibility:_ For compatibility with Typst 0.10 and lower, this
-    /// function also works without a known context if the `selector` is a
-    /// location. This behaviour will be removed in a future release.
     #[func(contextual)]
     pub fn at(
         &self,
@@ -526,21 +506,8 @@ impl Counter {
         context: Tracked<Context>,
         /// The callsite span.
         span: Span,
-        /// _Compatibility:_ This argument is deprecated. It only exists for
-        /// compatibility with Typst 0.10 and lower and shouldn't be used
-        /// anymore.
-        #[default]
-        location: Option<Location>,
     ) -> SourceResult<CounterState> {
-        if location.is_none() {
-            context.location().at(span)?;
-        } else {
-            engine.sink.warn(warning!(
-                span, "calling `counter.final` with a location is deprecated";
-                hint: "try removing the location argument"
-            ));
-        }
-
+        context.introspect().at(span)?;
         let sequence = self.sequence(engine)?;
         let (mut state, page) = sequence.last().unwrap().clone();
         if self.is_page() {
@@ -761,8 +728,6 @@ impl Count for Packed<CounterUpdateElem> {
 }
 
 /// Executes a display of a counter.
-///
-/// **Deprecation planned.**
 #[elem(Construct, Locatable, Show)]
 pub struct CounterDisplayElem {
     /// The counter.
@@ -788,7 +753,6 @@ impl Construct for CounterDisplayElem {
 }
 
 impl Show for Packed<CounterDisplayElem> {
-    #[typst_macros::time(name = "counter.display", span = self.span())]
     fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
         Ok(self
             .counter
diff --git a/crates/typst-library/src/introspection/locate.rs b/crates/typst-library/src/introspection/locate.rs
index 9a0e28e29..f6631b021 100644
--- a/crates/typst-library/src/introspection/locate.rs
+++ b/crates/typst-library/src/introspection/locate.rs
@@ -1,13 +1,9 @@
-use comemo::{Track, Tracked};
-use typst_syntax::Span;
+use comemo::Tracked;
 
-use crate::diag::{warning, HintedStrResult, SourceResult};
+use crate::diag::HintedStrResult;
 use crate::engine::Engine;
-use crate::foundations::{
-    cast, elem, func, Content, Context, Func, LocatableSelector, NativeElement, Packed,
-    Show, StyleChain, Value,
-};
-use crate::introspection::{Locatable, Location};
+use crate::foundations::{func, Context, LocatableSelector};
+use crate::introspection::Location;
 
 /// Determines the location of an element in the document.
 ///
@@ -26,23 +22,12 @@ use crate::introspection::{Locatable, Location};
 ///
 /// = Introduction <intro>
 /// ```
-///
-/// # Compatibility
-/// In Typst 0.10 and lower, the `locate` function took a closure that made the
-/// current location in the document available (like [`here`] does now). This
-/// usage pattern is deprecated. Compatibility with the old way will remain for
-/// a while to give package authors time to upgrade. To that effect, `locate`
-/// detects whether it received a selector or a user-defined function and
-/// adjusts its semantics accordingly. This behaviour will be removed in the
-/// future.
 #[func(contextual)]
 pub fn locate(
     /// The engine.
     engine: &mut Engine,
     /// The callsite context.
     context: Tracked<Context>,
-    /// The span of the `locate` call.
-    span: Span,
     /// A selector that should match exactly one element. This element will be
     /// located.
     ///
@@ -50,70 +35,7 @@ pub fn locate(
     /// - [`here`] to locate the current context,
     /// - a [`location`] retrieved from some queried element via the
     ///   [`location()`]($content.location) method on content.
-    selector: LocateInput,
-) -> HintedStrResult<LocateOutput> {
-    Ok(match selector {
-        LocateInput::Selector(selector) => {
-            LocateOutput::Location(selector.resolve_unique(engine.introspector, context)?)
-        }
-        LocateInput::Func(func) => {
-            engine.sink.warn(warning!(
-                span, "`locate` with callback function is deprecated";
-                hint: "use a `context` expression instead"
-            ));
-
-            LocateOutput::Content(LocateElem::new(func).pack().spanned(span))
-        }
-    })
-}
-
-/// Compatible input type.
-pub enum LocateInput {
-    Selector(LocatableSelector),
-    Func(Func),
-}
-
-cast! {
-    LocateInput,
-    v: Func => {
-        if v.element().is_some() {
-            Self::Selector(Value::Func(v).cast()?)
-        } else {
-            Self::Func(v)
-        }
-    },
-    v: LocatableSelector => Self::Selector(v),
-}
-
-/// Compatible output type.
-pub enum LocateOutput {
-    Location(Location),
-    Content(Content),
-}
-
-cast! {
-    LocateOutput,
-    self => match self {
-        Self::Location(v) => v.into_value(),
-        Self::Content(v) => v.into_value(),
-    },
-    v: Location => Self::Location(v),
-    v: Content => Self::Content(v),
-}
-
-/// Executes a `locate` call.
-#[elem(Locatable, Show)]
-struct LocateElem {
-    /// The function to call with the location.
-    #[required]
-    func: Func,
-}
-
-impl Show for Packed<LocateElem> {
-    #[typst_macros::time(name = "locate", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let location = self.location().unwrap();
-        let context = Context::new(Some(location), Some(styles));
-        Ok(self.func().call(engine, context.track(), [location])?.display())
-    }
+    selector: LocatableSelector,
+) -> HintedStrResult<Location> {
+    selector.resolve_unique(engine.introspector, context)
 }
diff --git a/crates/typst-library/src/introspection/query.rs b/crates/typst-library/src/introspection/query.rs
index 7b106bf02..f616208c5 100644
--- a/crates/typst-library/src/introspection/query.rs
+++ b/crates/typst-library/src/introspection/query.rs
@@ -1,10 +1,8 @@
 use comemo::Tracked;
-use typst_syntax::Span;
 
-use crate::diag::{warning, HintedStrResult};
+use crate::diag::HintedStrResult;
 use crate::engine::Engine;
 use crate::foundations::{func, Array, Context, LocatableSelector, Value};
-use crate::introspection::Location;
 
 /// Finds elements in the document.
 ///
@@ -142,8 +140,6 @@ pub fn query(
     engine: &mut Engine,
     /// The callsite context.
     context: Tracked<Context>,
-    /// The span of the `query` call.
-    span: Span,
     /// Can be
     /// - an element function like a `heading` or `figure`,
     /// - a `{<label>}`,
@@ -152,20 +148,8 @@ pub fn query(
     ///
     /// Only [locatable]($location/#locatable) element functions are supported.
     target: LocatableSelector,
-    /// _Compatibility:_ This argument is deprecated. It only exists for
-    /// compatibility with Typst 0.10 and lower and shouldn't be used anymore.
-    #[default]
-    location: Option<Location>,
 ) -> HintedStrResult<Array> {
-    if location.is_none() {
-        context.introspect()?;
-    } else {
-        engine.sink.warn(warning!(
-            span, "calling `query` with a location is deprecated";
-            hint: "try removing the location argument"
-        ));
-    }
-
+    context.introspect()?;
     let vec = engine.introspector.query(&target.0);
     Ok(vec.into_iter().map(Value::Content).collect())
 }
diff --git a/crates/typst-library/src/introspection/state.rs b/crates/typst-library/src/introspection/state.rs
index 772a4fbfb..7e019e6c7 100644
--- a/crates/typst-library/src/introspection/state.rs
+++ b/crates/typst-library/src/introspection/state.rs
@@ -2,7 +2,7 @@ use comemo::{Track, Tracked, TrackedMut};
 use ecow::{eco_format, eco_vec, EcoString, EcoVec};
 use typst_syntax::Span;
 
-use crate::diag::{bail, warning, At, SourceResult};
+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,
@@ -305,10 +305,6 @@ impl State {
     /// The `selector` must match exactly one element in the document. The most
     /// useful kinds of selectors for this are [labels]($label) and
     /// [locations]($location).
-    ///
-    /// _Compatibility:_ For compatibility with Typst 0.10 and lower, this
-    /// function also works without a known context if the `selector` is a
-    /// location. This behaviour will be removed in a future release.
     #[typst_macros::time(name = "state.at", span = span)]
     #[func(contextual)]
     pub fn at(
@@ -336,21 +332,8 @@ impl State {
         context: Tracked<Context>,
         /// The callsite span.
         span: Span,
-        /// _Compatibility:_ This argument is deprecated. It only exists for
-        /// compatibility with Typst 0.10 and lower and shouldn't be used
-        /// anymore.
-        #[default]
-        location: Option<Location>,
     ) -> SourceResult<Value> {
-        if location.is_none() {
-            context.location().at(span)?;
-        } else {
-            engine.sink.warn(warning!(
-                span, "calling `state.final` with a location is deprecated";
-                hint: "try removing the location argument"
-            ));
-        }
-
+        context.introspect().at(span)?;
         let sequence = self.sequence(engine)?;
         Ok(sequence.last().unwrap().clone())
     }
@@ -375,30 +358,6 @@ impl State {
     ) -> Content {
         StateUpdateElem::new(self.key, update).pack().spanned(span)
     }
-
-    /// Displays the current value of the state.
-    ///
-    /// **Deprecation planned:** Use [`get`]($state.get) instead.
-    #[func]
-    pub fn display(
-        self,
-        /// The engine.
-        engine: &mut Engine,
-        /// The span of the `display` call.
-        span: Span,
-        /// A function which receives the value of the state and can return
-        /// arbitrary content which is then displayed. If this is omitted, the
-        /// value is directly displayed.
-        #[default]
-        func: Option<Func>,
-    ) -> Content {
-        engine.sink.warn(warning!(
-            span, "`state.display` is deprecated";
-            hint: "use `state.get` in a `context` expression instead"
-        ));
-
-        StateDisplayElem::new(self, func).pack().spanned(span)
-    }
 }
 
 impl Repr for State {
@@ -446,38 +405,3 @@ impl Show for Packed<StateUpdateElem> {
         Ok(Content::empty())
     }
 }
-
-/// Executes a display of a state.
-///
-/// **Deprecation planned.**
-#[elem(Construct, Locatable, Show)]
-struct StateDisplayElem {
-    /// The state.
-    #[required]
-    #[internal]
-    state: State,
-
-    /// The function to display the state with.
-    #[required]
-    #[internal]
-    func: Option<Func>,
-}
-
-impl Show for Packed<StateDisplayElem> {
-    #[typst_macros::time(name = "state.display", span = self.span())]
-    fn show(&self, engine: &mut Engine, styles: StyleChain) -> SourceResult<Content> {
-        let location = self.location().unwrap();
-        let context = Context::new(Some(location), Some(styles));
-        let value = self.state().at_loc(engine, location)?;
-        Ok(match self.func() {
-            Some(func) => func.call(engine, context.track(), [value])?.display(),
-            None => value.display(),
-        })
-    }
-}
-
-impl Construct for StateDisplayElem {
-    fn construct(_: &mut Engine, args: &mut Args) -> SourceResult<Content> {
-        bail!(args.span, "cannot be constructed manually");
-    }
-}
diff --git a/crates/typst-library/src/layout/measure.rs b/crates/typst-library/src/layout/measure.rs
index 2fa51b2df..0c6071eb0 100644
--- a/crates/typst-library/src/layout/measure.rs
+++ b/crates/typst-library/src/layout/measure.rs
@@ -1,11 +1,9 @@
 use comemo::Tracked;
 use typst_syntax::Span;
 
-use crate::diag::{warning, At, SourceResult};
+use crate::diag::{At, SourceResult};
 use crate::engine::Engine;
-use crate::foundations::{
-    dict, func, Content, Context, Dict, Resolve, Smart, StyleChain, Styles,
-};
+use crate::foundations::{dict, func, Content, Context, Dict, Resolve, Smart};
 use crate::introspection::{Locator, LocatorLink};
 use crate::layout::{Abs, Axes, Length, Region, Size};
 
@@ -76,23 +74,9 @@ pub fn measure(
     height: Smart<Length>,
     /// The content whose size to measure.
     content: Content,
-    /// _Compatibility:_ This argument is deprecated. It only exists for
-    /// compatibility with Typst 0.10 and lower and shouldn't be used anymore.
-    #[default]
-    styles: Option<Styles>,
 ) -> SourceResult<Dict> {
-    let styles = match &styles {
-        Some(styles) => {
-            engine.sink.warn(warning!(
-                span, "calling `measure` with a styles argument is deprecated";
-                hint: "try removing the styles argument"
-            ));
-            StyleChain::new(styles)
-        }
-        None => context.styles().at(span)?,
-    };
-
     // Create a pod region with the available space.
+    let styles = context.styles().at(span)?;
     let pod = Region::new(
         Axes::new(
             width.resolve(styles).unwrap_or(Abs::inf()),
diff --git a/crates/typst-library/src/model/outline.rs b/crates/typst-library/src/model/outline.rs
index 0be1a9d0a..e8d32a540 100644
--- a/crates/typst-library/src/model/outline.rs
+++ b/crates/typst-library/src/model/outline.rs
@@ -137,10 +137,6 @@ pub struct OutlineElem {
     ///   `{n => n * 2em}` would be equivalent to just specifying `{2em}`, while
     ///   `{n => [→ ] * n}` would indent with one arrow per nesting level.
     ///
-    /// *Migration hints:*  Specifying `{true}` (equivalent to `{auto}`) or
-    /// `{false}` (equivalent to `{none}`) for this option is deprecated and
-    /// will be removed in a future release.
-    ///
     /// ```example
     /// #set heading(numbering: "1.a.")
     ///
@@ -294,7 +290,6 @@ pub trait Outlinable: Refable {
 /// Defines how an outline is indented.
 #[derive(Debug, Clone, PartialEq, Hash)]
 pub enum OutlineIndent {
-    Bool(bool),
     Rel(Rel<Length>),
     Func(Func),
 }
@@ -310,10 +305,10 @@ impl OutlineIndent {
     ) -> SourceResult<()> {
         match indent {
             // 'none' | 'false' => no indenting
-            None | Some(Smart::Custom(OutlineIndent::Bool(false))) => {}
+            None => {}
 
             // 'auto' | 'true' => use numbering alignment for indenting
-            Some(Smart::Auto | Smart::Custom(OutlineIndent::Bool(true))) => {
+            Some(Smart::Auto) => {
                 // Add hidden ancestors numberings to realize the indent.
                 let mut hidden = Content::empty();
                 for ancestor in ancestors {
@@ -368,11 +363,9 @@ impl OutlineIndent {
 cast! {
     OutlineIndent,
     self => match self {
-        Self::Bool(v) => v.into_value(),
         Self::Rel(v) => v.into_value(),
         Self::Func(v) => v.into_value()
     },
-    v: bool => OutlineIndent::Bool(v),
     v: Rel<Length> => OutlineIndent::Rel(v),
     v: Func => OutlineIndent::Func(v),
 }
diff --git a/docs/changelog/0.11.0.md b/docs/changelog/0.11.0.md
index 2a018e45b..27478862d 100644
--- a/docs/changelog/0.11.0.md
+++ b/docs/changelog/0.11.0.md
@@ -59,13 +59,13 @@ _Thanks to [@PgBiel](https://github.com/PgBiel) for his work on tables!_
 - When context is available, [`counter.display`] now directly returns the result
   of applying the numbering instead of yielding opaque content. It should not be
   used anymore without context. (Deprecation planned)
-- The [`state.display`] function should not be used anymore, use [`state.get`]
+- The `state.display` function should not be used anymore, use [`state.get`]
   instead (Deprecation planned)
 - The `location` argument of [`query`], [`counter.final`], and [`state.final`]
   should not be used anymore (Deprecation planned)
-- The [`styles`]($measure.styles) argument of the `measure` function should not
-  be used anymore (Deprecation planned)
-- The [`style`] function should not be used anymore, use context instead
+- The `styles` argument of the `measure` function should not be used anymore
+  (Deprecation planned)
+- The `style` function should not be used anymore, use context instead
   (Deprecation planned)
 - The correct context is now also provided in various other places where it is
   available, e.g. in show rules, layout callbacks, and numbering functions in
diff --git a/docs/changelog/0.12.0.md b/docs/changelog/0.12.0.md
index 835e2b1c6..e8152c531 100644
--- a/docs/changelog/0.12.0.md
+++ b/docs/changelog/0.12.0.md
@@ -380,11 +380,11 @@ description: Changes in Typst 0.12.0
 - [`counter.display`] without an established context
 - [`counter.final`] with a location
 - [`state.final`] with a location
-- [`state.display`]
+- `state.display`
 - [`query`] with a location as the second argument
 - [`locate`] with a callback function
 - [`measure`] with styles
-- [`style`]
+- `style`
 
 ## Development
 - Added `typst-kit` crate which provides useful APIs for `World` implementors
diff --git a/docs/changelog/earlier.md b/docs/changelog/earlier.md
index cecc56e57..ecf6816df 100644
--- a/docs/changelog/earlier.md
+++ b/docs/changelog/earlier.md
@@ -83,7 +83,7 @@ description: Changes in early, unversioned Typst
 
 - New [`measure`] function
   - Measure the layouted size of elements
-  - To be used in combination with the new [`style`] function that lets you
+  - To be used in combination with the new `style` function that lets you
     generate different content based on the style context something is inserted
     into (because that affects the measured size of content)
 
diff --git a/tests/ref/context-compatibility-locate.png b/tests/ref/context-compatibility-locate.png
deleted file mode 100644
index 9a78d3eb44906e968d4f532244cf4addfc49343f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1523
zcmV<P1q}L$P)<h;3K|Lk000e1NJLTq004LZ002)2000001#n&)000HLNkl<Zc-rmP
ze@xVM9LMp-YOY`FpZ=(=TCJMpva)nVXqL5VDW)rb5E<kTz|ut2Qv?+hRKVaAK?H@n
zgZrYVr-Fx+7#NzTAbQ*#{x}d+K#}8z;8!@gAJ23*oVl^NuY;!D^PkV3kN@7UeIDUI
z>Jbm@fj#j52sZuQUvS#!>(q~5Lm%b(b7w7S;LcS7&V7Z_VV?Dagf{xfGL3)b#9jBw
zVX&?|W1n<5dO{*{5rtY?G2R#<V?hq+ea)6x);&VXO}H(v$~XZ>+LlrvBZ>kc9DtE9
zg40u_!!ez29h8fC^NOE$PCs^h9Gd_p8yfaHw&UZnOe3U>_ehM>y#bg47<-|j7aojt
zG}2*Cy*6K*uV`$fJS1nFB^RJ1Oz9#sXIR%wcy2i#;Cry)3UDTn6F%|1@G$B_B*WL|
zgVsyj9!LXxsw(*K8UQ{jjKR(kot59Qd{^6x*3~i811G1T;xmBmAuz|N-D}rNgfkb_
zK)T(Lu(A{inq5i&*nJiI((Osw^o6yJD{|JAip$~*K-$8(mFg0J&2x*mx<NtP8qekO
zzz-PQVCpY;^S3?J`^D2o>35ApCcT{mN68`SFi(d-T+6+VM0f8SH4LWPemN=~UOpxh
zxrkO>ToGtm6-}f7`hY4+sI^GQxiu1VEyn4fQWyZmZ<GqL0Qi8|>UTvt9Ah1PTrL*L
zj4!yR8p^&U)d~2XYSuV18FdpTxQut%lze0;P#M73)`Pvbny7EgNQWsOyi^R^XfRM3
zn)`WuHbCLhYzI5D-@ZK(<MRxs-6QeW@Qm9qdD2J1wh%HO6|?8i3ZoR-(d_^(Zv|CB
ze00q;nWcNXU+G#Qrv<3=V^`0|06lL*6UpmcrzOH$LTX@5k8N@EAF#c_u^s?a&DiD$
z5j#?5)t-}OEG}%F6Q>7~XVuBn`2eYYMI>gWxmuQZE|&-Pz_=?I@?}lC|C@;e4)byt
zD7-ob9)3Nvqa(ws3td!5OW{}9UtTF)5p;1t;4e~A0=>E}K4JC_cMg(i+Mg-)ojxG&
zVo-Z^Wj=YJxRIwc6nN>1>jnaT?q}HKb>*;E!qH;qASGuW3oqYij_h~1VCJti?Mr5E
zMm1$+k8b92JG=eD#S=2m0r9{OE!=#jzu<I#JN45N=%bBy{Uns&t|9L#P~9dOc0Ktk
zthL_jPeR1qiR4RP!0H?%!$f|ZgIpwEI9w5IS{+MNF6e`+EQ_oqg61aN7FKPX4T91P
zs5Wp!hzBmU@fOMykPgQ*y<RC7i^I>p<eFqUHi=XR@b%f2Tt~Y5ClOS}J7jD+{tjRW
zU|dHL0NDZ`sRMpTI*k6!Wnx&;(PNY>$Q^S@1)z(}wv%_qPvV;$M-A?u#DVu!07cti
zIJKWkhHuCq?J-dq%2gPp(2QvXaC&EPI*5^?c?#hLJ+Io9ZKNHj{GNQ<DBxTyO4p=o
zmBFra65)&)HL#+mD>S+QaxU280bpwr-NC{FO>#i3B`hse*Blgg7+4=z7pB$%+Nu7*
zRIlFJVGZ+KE)V>G!8aQF3*Iu%Mg8m~`Y7&u?yPkOxa&OB1Fp-`VaK555ZiRGBhiez
zQ;FvBn0@1=!z_A#FLIIMTw_IqIZ4ji9iWe>vP4<Sg#EWhBKo{B67tpO0ZkSrAq_Zp
zi6O8n;eJM<?$v6!sE=xWjj?AB|3Hcj_@u5Q(~;yJi5bTjijY+^0yrLkuT2ZUo>a)Y
zFPQ!B#)ykn>2wrEXhybX0ql$sY#huUdV3@$Zqfbe9*JGU^8xf3+#hTYhqaH3=@Hm)
z`D7`_H38VYw^BWmPsCGx$o4bXDa*nJnEWYj_XZlH*zH0S3oR1i&68{3mm8fwMr$Fp
z+7=D~i5Kbg7k=87IH9(3cC!DT`YCZmz`BWbL24zSp6Kt#<&YmQHqY=}E)VR1J@CT~
Z{{w>MMweAi@DKn1002ovPDHLkV1f++)?)ww

diff --git a/tests/ref/context-compatibility-styling.png b/tests/ref/context-compatibility-styling.png
deleted file mode 100644
index aee16c3ab6398a47fc15bbb674e9012dc5ffb611..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 380
zcmV-?0fYXDP)<h;3K|Lk000e1NJLTq004LZ000^Y0{{R3ONMB%0002DP)t-s|NsC0
z{{H{{{r~*@{`&g<`TG9$_x<(t{q*(y^7H)h^8E1e{O|Dm?(qBS>-*^H`seBT<mUO|
z<oVy>_}$?5*V^~i+4aoO^vBEd#me)=$@9d>^TEdQz{T;pzwfcP@36M-uC(s0v+Sd)
z?4qgcps4GfrR$xg>z$<QoTKWQpy`sE>5-Y}keTR@nCOm{=ZKN!f{f*Xi{yHR;&OfB
zaeU%%d*W|;;ca-~Y<J*kb>Cra+fZG=!V+r$004kVL_t(|+U?WV5rRM%0O36h;2BXw
zF(=Gf&)k1qj!m2}^M4KO(;|crsTPF%g}**Tim*B;1UZ^G-8OdA7MqshvF|sI6%40Q
zJj0IO5O@{g7tVa<t0#7J#()8~b$wTF&&y+nzAhaM5M6dRrssHqEgD>aQr3mCFQW?~
a66p&9nFyquXi;SV0000<MNUMnLSTa0z}qPR

diff --git a/tests/ref/outline-indent-no-numbering.png b/tests/ref/outline-indent-no-numbering.png
index d074dfefdd53c904b3ea738796e3fcd9ea65f48f..7c3a0ec0b54e31577b81bf4044eece9015a303f6 100644
GIT binary patch
literal 2924
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
W#Eh_<&*;_w0000<MNUMnLSTYyCzdh*

literal 4654
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
Ji>htte*obE{fPho

diff --git a/tests/ref/outline-indent-numbering.png b/tests/ref/outline-indent-numbering.png
index 3d0dcb071f266f3c9254d39a7571aa5026e9c08c..e3195f7663bf3336be0bb9120b14bef7fd5f0e3a 100644
GIT binary patch
literal 7101
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

literal 10607
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
RaF7yCLPSQmR1o6*zW{!s#Kiyr

diff --git a/tests/suite/foundations/context.typ b/tests/suite/foundations/context.typ
index 9ed317575..e506d50db 100644
--- a/tests/suite/foundations/context.typ
+++ b/tests/suite/foundations/context.typ
@@ -37,46 +37,6 @@
 // Error: 11-12 variables from outside the context expression are read-only and cannot be modified
 #context (i = 1)
 
---- context-compatibility-locate ---
-#let s = state("x", 0)
-#let compute(expr) = [
-  #s.update(x =>
-    eval(expr.replace("x", str(x)))
-  )
-  // Warning: 17-28 `state.display` is deprecated
-  // Hint: 17-28 use `state.get` in a `context` expression instead
-  New value is #s.display().
-]
-
-// Warning: 1:2-6:3 `locate` with callback function is deprecated
-// Hint: 1:2-6:3 use a `context` expression instead
-#locate(loc => {
-  // Warning: 14-32 calling `query` with a location is deprecated
-  // Hint: 14-32 try removing the location argument
-  let elem = query(<here>, loc).first()
-  test(s.at(elem.location()), 13)
-})
-
-#compute("10") \
-#compute("x + 3") \
-*Here.* <here> \
-#compute("x * 2") \
-#compute("x - 5")
-
---- context-compatibility-styling ---
-// Warning: 2-53 `style` is deprecated
-// Hint: 2-53 use a `context` expression instead
-// Warning: 18-39 calling `measure` with a styles argument is deprecated
-// Hint: 18-39 try removing the styles argument
-#style(styles => measure([it], styles).width < 20pt)
-
---- context-compatibility-counter-display ---
-#counter(heading).update(10)
-
-// Warning: 2-44 `counter.display` without context is deprecated
-// Hint: 2-44 use it in a `context` expression instead
-#counter(heading).display(n => test(n, 10))
-
 --- context-delayed-warning ---
 // Ensure that the warning that triggers in the first layout iteration is not
 // surfaced since it goes away in the second one. Just like errors in show
diff --git a/tests/suite/foundations/type.typ b/tests/suite/foundations/type.typ
index 6ab4be4f0..068b858de 100644
--- a/tests/suite/foundations/type.typ
+++ b/tests/suite/foundations/type.typ
@@ -3,14 +3,6 @@
 #test(type(ltr), direction)
 #test(type(10 / 3), float)
 
---- type-string-compatibility ---
-#test(type(10), int)
-#test(type(10), "integer")
-#test("is " + type(10), "is integer")
-#test(int in ("integer", "string"), true)
-#test(int in "integers or strings", true)
-#test(str in "integers or strings", true)
-
 --- issue-3110-type-constructor ---
 // Let the error message report the type name.
 // Error: 2-9 type content does not have a constructor
diff --git a/tests/suite/model/outline.typ b/tests/suite/model/outline.typ
index 18c61df8a..a8426d6c6 100644
--- a/tests/suite/model/outline.typ
+++ b/tests/suite/model/outline.typ
@@ -43,8 +43,6 @@ A
 #set outline(fill: none)
 
 #context test(outline.indent, none)
-#outline(indent: false)
-#outline(indent: true)
 #outline(indent: none)
 #outline(indent: auto)
 #outline(indent: 2em)
@@ -62,8 +60,6 @@ A
 #show heading: none
 #set outline(fill: none)
 
-#outline(indent: false)
-#outline(indent: true)
 #outline(indent: none)
 #outline(indent: auto)
 #outline(indent: n => 2em * n)
diff --git a/tests/suite/styling/fold.typ b/tests/suite/styling/fold.typ
index 4b77f9d52..104d3d1ac 100644
--- a/tests/suite/styling/fold.typ
+++ b/tests/suite/styling/fold.typ
@@ -13,12 +13,8 @@ fi
 #let c = counter("mycounter")
 #c.update(1)
 
-// Warning: 1:2-7:3 `locate` with callback function is deprecated
-// Hint: 1:2-7:3 use a `context` expression instead
-#locate(loc => [
+#context [
   #c.update(2)
-  #c.at(loc) \
-  // Warning: 12-36 `locate` with callback function is deprecated
-  // Hint: 12-36 use a `context` expression instead
-  Second: #locate(loc => c.at(loc))
-])
+  #c.get() \
+  Second: #context c.get()
+]

From 134638525516995d5947c5b3f98ffbc13784a143 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 17 Dec 2024 10:25:27 +0100
Subject: [PATCH 08/10] Rename `pattern` to `tiling` (#5590)

---
 crates/typst-layout/src/shapes.rs             |   6 +-
 crates/typst-library/src/foundations/ops.rs   |   4 +-
 crates/typst-library/src/foundations/value.rs |  16 +-
 .../src/introspection/locator.rs              |   2 +-
 crates/typst-library/src/text/mod.rs          |   2 +-
 crates/typst-library/src/visualize/mod.rs     |  11 +-
 crates/typst-library/src/visualize/paint.rs   |  28 +--
 crates/typst-library/src/visualize/stroke.rs  |  26 ++-
 .../src/visualize/{pattern.rs => tiling.rs}   | 102 +++++------
 crates/typst-pdf/src/color.rs                 |   4 +-
 crates/typst-pdf/src/content.rs               |  14 +-
 crates/typst-pdf/src/lib.rs                   |  10 +-
 crates/typst-pdf/src/resources.rs             |  44 ++---
 .../typst-pdf/src/{pattern.rs => tiling.rs}   |  34 ++--
 crates/typst-render/src/paint.rs              |  36 ++--
 crates/typst-render/src/shape.rs              |   8 +-
 crates/typst-render/src/text.rs               |   8 +-
 crates/typst-svg/src/lib.rs                   |  28 +--
 crates/typst-svg/src/paint.rs                 |  97 ++++++-----
 crates/typst-svg/src/shape.rs                 |  14 +-
 crates/typst-svg/src/text.rs                  |   2 +-
 crates/typst-syntax/src/ast.rs                |   4 +-
 crates/typst-syntax/src/kind.rs               |   2 +-
 crates/typst-syntax/src/parser.rs             |   2 +-
 docs/changelog/0.10.0.md                      |   2 +-
 docs/changelog/0.11.1.md                      |   2 +-
 docs/guides/tables.md                         |   4 +-
 ...oke-pattern.png => grid-stroke-tiling.png} | Bin
 .../ref/{pattern-line.png => tiling-line.png} | Bin
 .../{pattern-lines.png => tiling-lines.png}   | Bin
 tests/ref/tiling-pattern-compatibility.png    | Bin 0 -> 125 bytes
 ...-parent.png => tiling-relative-parent.png} | Bin
 ...tive-self.png => tiling-relative-self.png} | Bin
 .../{pattern-small.png => tiling-small.png}   | Bin
 ...gative.png => tiling-spacing-negative.png} | Bin
 ...sitive.png => tiling-spacing-positive.png} | Bin
 ...acing-zero.png => tiling-spacing-zero.png} | Bin
 ....png => tiling-stroke-relative-parent.png} | Bin
 .../{pattern-stroke.png => tiling-stroke.png} | Bin
 .../ref/{pattern-text.png => tiling-text.png} | Bin
 tests/suite/layout/grid/stroke.typ            |   4 +-
 tests/suite/layout/table.typ                  |   2 +-
 tests/suite/text/font.typ                     |   6 +-
 tests/suite/visualize/gradient.typ            |   2 +-
 tests/suite/visualize/pattern.typ             | 159 -----------------
 tests/suite/visualize/rect.typ                |   2 +-
 tests/suite/visualize/tiling.typ              | 163 ++++++++++++++++++
 47 files changed, 426 insertions(+), 424 deletions(-)
 rename crates/typst-library/src/visualize/{pattern.rs => tiling.rs} (71%)
 rename crates/typst-pdf/src/{pattern.rs => tiling.rs} (87%)
 rename tests/ref/{grid-stroke-pattern.png => grid-stroke-tiling.png} (100%)
 rename tests/ref/{pattern-line.png => tiling-line.png} (100%)
 rename tests/ref/{pattern-lines.png => tiling-lines.png} (100%)
 create mode 100644 tests/ref/tiling-pattern-compatibility.png
 rename tests/ref/{pattern-relative-parent.png => tiling-relative-parent.png} (100%)
 rename tests/ref/{pattern-relative-self.png => tiling-relative-self.png} (100%)
 rename tests/ref/{pattern-small.png => tiling-small.png} (100%)
 rename tests/ref/{pattern-spacing-negative.png => tiling-spacing-negative.png} (100%)
 rename tests/ref/{pattern-spacing-positive.png => tiling-spacing-positive.png} (100%)
 rename tests/ref/{pattern-spacing-zero.png => tiling-spacing-zero.png} (100%)
 rename tests/ref/{pattern-stroke-relative-parent.png => tiling-stroke-relative-parent.png} (100%)
 rename tests/ref/{pattern-stroke.png => tiling-stroke.png} (100%)
 rename tests/ref/{pattern-text.png => tiling-text.png} (100%)
 delete mode 100644 tests/suite/visualize/pattern.typ
 create mode 100644 tests/suite/visualize/tiling.typ

diff --git a/crates/typst-layout/src/shapes.rs b/crates/typst-layout/src/shapes.rs
index db9acece3..2044c917e 100644
--- a/crates/typst-layout/src/shapes.rs
+++ b/crates/typst-layout/src/shapes.rs
@@ -719,11 +719,7 @@ fn segment(
         false
     }
 
-    let solid = stroke
-        .dash
-        .as_ref()
-        .map(|pattern| pattern.array.is_empty())
-        .unwrap_or(true);
+    let solid = stroke.dash.as_ref().map(|dash| dash.array.is_empty()).unwrap_or(true);
 
     let use_fill = solid && fill_corners(start, end, corners);
     let shape = if use_fill {
diff --git a/crates/typst-library/src/foundations/ops.rs b/crates/typst-library/src/foundations/ops.rs
index b41fce8d0..8d12966bf 100644
--- a/crates/typst-library/src/foundations/ops.rs
+++ b/crates/typst-library/src/foundations/ops.rs
@@ -144,8 +144,8 @@ pub fn add(lhs: Value, rhs: Value) -> HintedStrResult<Value> {
         | (Length(thickness), Gradient(gradient)) => {
             Stroke::from_pair(gradient, thickness).into_value()
         }
-        (Pattern(pattern), Length(thickness)) | (Length(thickness), Pattern(pattern)) => {
-            Stroke::from_pair(pattern, thickness).into_value()
+        (Tiling(tiling), Length(thickness)) | (Length(thickness), Tiling(tiling)) => {
+            Stroke::from_pair(tiling, thickness).into_value()
         }
 
         (Duration(a), Duration(b)) => Duration(a + b),
diff --git a/crates/typst-library/src/foundations/value.rs b/crates/typst-library/src/foundations/value.rs
index 538b4f1b8..eb0d6eedc 100644
--- a/crates/typst-library/src/foundations/value.rs
+++ b/crates/typst-library/src/foundations/value.rs
@@ -20,7 +20,7 @@ use crate::foundations::{
 };
 use crate::layout::{Abs, Angle, Em, Fr, Length, Ratio, Rel};
 use crate::text::{RawContent, RawElem, TextElem};
-use crate::visualize::{Color, Gradient, Pattern};
+use crate::visualize::{Color, Gradient, Tiling};
 
 /// A computational value.
 #[derive(Default, Clone)]
@@ -50,8 +50,8 @@ pub enum Value {
     Color(Color),
     /// A gradient value: `gradient.linear(...)`.
     Gradient(Gradient),
-    /// A pattern fill: `pattern(...)`.
-    Pattern(Pattern),
+    /// A tiling fill: `tiling(...)`.
+    Tiling(Tiling),
     /// A symbol: `arrow.l`.
     Symbol(Symbol),
     /// A version.
@@ -130,7 +130,7 @@ impl Value {
             Self::Fraction(_) => Type::of::<Fr>(),
             Self::Color(_) => Type::of::<Color>(),
             Self::Gradient(_) => Type::of::<Gradient>(),
-            Self::Pattern(_) => Type::of::<Pattern>(),
+            Self::Tiling(_) => Type::of::<Tiling>(),
             Self::Symbol(_) => Type::of::<Symbol>(),
             Self::Version(_) => Type::of::<Version>(),
             Self::Str(_) => Type::of::<Str>(),
@@ -244,7 +244,7 @@ impl Debug for Value {
             Self::Fraction(v) => Debug::fmt(v, f),
             Self::Color(v) => Debug::fmt(v, f),
             Self::Gradient(v) => Debug::fmt(v, f),
-            Self::Pattern(v) => Debug::fmt(v, f),
+            Self::Tiling(v) => Debug::fmt(v, f),
             Self::Symbol(v) => Debug::fmt(v, f),
             Self::Version(v) => Debug::fmt(v, f),
             Self::Str(v) => Debug::fmt(v, f),
@@ -282,7 +282,7 @@ impl Repr for Value {
             Self::Fraction(v) => v.repr(),
             Self::Color(v) => v.repr(),
             Self::Gradient(v) => v.repr(),
-            Self::Pattern(v) => v.repr(),
+            Self::Tiling(v) => v.repr(),
             Self::Symbol(v) => v.repr(),
             Self::Version(v) => v.repr(),
             Self::Str(v) => v.repr(),
@@ -333,7 +333,7 @@ impl Hash for Value {
             Self::Fraction(v) => v.hash(state),
             Self::Color(v) => v.hash(state),
             Self::Gradient(v) => v.hash(state),
-            Self::Pattern(v) => v.hash(state),
+            Self::Tiling(v) => v.hash(state),
             Self::Symbol(v) => v.hash(state),
             Self::Version(v) => v.hash(state),
             Self::Str(v) => v.hash(state),
@@ -640,7 +640,7 @@ primitive! { Rel<Length>:  "relative length",
 primitive! { Fr: "fraction", Fraction }
 primitive! { Color: "color", Color }
 primitive! { Gradient: "gradient", Gradient }
-primitive! { Pattern: "pattern", Pattern }
+primitive! { Tiling: "tiling", Tiling }
 primitive! { Symbol: "symbol", Symbol }
 primitive! { Version: "version", Version }
 primitive! {
diff --git a/crates/typst-library/src/introspection/locator.rs b/crates/typst-library/src/introspection/locator.rs
index a84cf1639..3ba3d6486 100644
--- a/crates/typst-library/src/introspection/locator.rs
+++ b/crates/typst-library/src/introspection/locator.rs
@@ -161,7 +161,7 @@ impl<'a> Locator<'a> {
     ///
     /// Should typically only be created at the document level, though there
     /// are a few places where we use it as well that just don't support
-    /// introspection (e.g. drawable patterns).
+    /// introspection (e.g. tilings).
     pub fn root() -> Self {
         Self { local: 0, outer: None }
     }
diff --git a/crates/typst-library/src/text/mod.rs b/crates/typst-library/src/text/mod.rs
index 62c870513..91927b572 100644
--- a/crates/typst-library/src/text/mod.rs
+++ b/crates/typst-library/src/text/mod.rs
@@ -249,7 +249,7 @@ pub struct TextElem {
             if paint.v.relative() == Smart::Custom(RelativeTo::Self_) {
                 bail!(
                     paint.span,
-                    "gradients and patterns on text must be relative to the parent";
+                    "gradients and tilings on text must be relative to the parent";
                     hint: "make sure to set `relative: auto` on your text fill"
                 );
             }
diff --git a/crates/typst-library/src/visualize/mod.rs b/crates/typst-library/src/visualize/mod.rs
index 5c8bf6468..61c56a61c 100644
--- a/crates/typst-library/src/visualize/mod.rs
+++ b/crates/typst-library/src/visualize/mod.rs
@@ -6,10 +6,10 @@ mod image;
 mod line;
 mod paint;
 mod path;
-mod pattern;
 mod polygon;
 mod shape;
 mod stroke;
+mod tiling;
 
 pub use self::color::*;
 pub use self::gradient::*;
@@ -17,12 +17,12 @@ pub use self::image::*;
 pub use self::line::*;
 pub use self::paint::*;
 pub use self::path::*;
-pub use self::pattern::*;
 pub use self::polygon::*;
 pub use self::shape::*;
 pub use self::stroke::*;
+pub use self::tiling::*;
 
-use crate::foundations::{category, Category, Scope};
+use crate::foundations::{category, Category, Scope, Type};
 
 /// Drawing and data visualization.
 ///
@@ -37,7 +37,7 @@ pub(super) fn define(global: &mut Scope) {
     global.category(VISUALIZE);
     global.define_type::<Color>();
     global.define_type::<Gradient>();
-    global.define_type::<Pattern>();
+    global.define_type::<Tiling>();
     global.define_type::<Stroke>();
     global.define_elem::<ImageElem>();
     global.define_elem::<LineElem>();
@@ -47,4 +47,7 @@ pub(super) fn define(global: &mut Scope) {
     global.define_elem::<CircleElem>();
     global.define_elem::<PolygonElem>();
     global.define_elem::<PathElem>();
+
+    // Compatibility.
+    global.define("pattern", Type::of::<Tiling>());
 }
diff --git a/crates/typst-library/src/visualize/paint.rs b/crates/typst-library/src/visualize/paint.rs
index cd1006aa3..a618e5154 100644
--- a/crates/typst-library/src/visualize/paint.rs
+++ b/crates/typst-library/src/visualize/paint.rs
@@ -3,7 +3,7 @@ use std::fmt::{self, Debug, Formatter};
 use ecow::EcoString;
 
 use crate::foundations::{cast, Repr, Smart};
-use crate::visualize::{Color, Gradient, Pattern, RelativeTo};
+use crate::visualize::{Color, Gradient, RelativeTo, Tiling};
 
 /// How a fill or stroke should be painted.
 #[derive(Clone, Eq, PartialEq, Hash)]
@@ -12,8 +12,8 @@ pub enum Paint {
     Solid(Color),
     /// A gradient.
     Gradient(Gradient),
-    /// A pattern.
-    Pattern(Pattern),
+    /// A tiling.
+    Tiling(Tiling),
 }
 
 impl Paint {
@@ -21,7 +21,7 @@ impl Paint {
     pub fn unwrap_solid(&self) -> Color {
         match self {
             Self::Solid(color) => *color,
-            Self::Gradient(_) | Self::Pattern(_) => panic!("expected solid color"),
+            Self::Gradient(_) | Self::Tiling(_) => panic!("expected solid color"),
         }
     }
 
@@ -30,7 +30,7 @@ impl Paint {
         match self {
             Self::Solid(_) => Smart::Auto,
             Self::Gradient(gradient) => gradient.relative(),
-            Self::Pattern(pattern) => pattern.relative(),
+            Self::Tiling(tiling) => tiling.relative(),
         }
     }
 
@@ -44,8 +44,8 @@ impl Paint {
             Self::Gradient(gradient) => {
                 Self::Gradient(gradient.clone().with_relative(RelativeTo::Parent))
             }
-            Self::Pattern(pattern) => {
-                Self::Pattern(pattern.clone().with_relative(RelativeTo::Parent))
+            Self::Tiling(tiling) => {
+                Self::Tiling(tiling.clone().with_relative(RelativeTo::Parent))
             }
         }
     }
@@ -56,14 +56,14 @@ impl Debug for Paint {
         match self {
             Self::Solid(v) => v.fmt(f),
             Self::Gradient(v) => v.fmt(f),
-            Self::Pattern(v) => v.fmt(f),
+            Self::Tiling(v) => v.fmt(f),
         }
     }
 }
 
-impl From<Pattern> for Paint {
-    fn from(pattern: Pattern) -> Self {
-        Self::Pattern(pattern)
+impl From<Tiling> for Paint {
+    fn from(tiling: Tiling) -> Self {
+        Self::Tiling(tiling)
     }
 }
 
@@ -72,7 +72,7 @@ impl Repr for Paint {
         match self {
             Self::Solid(color) => color.repr(),
             Self::Gradient(gradient) => gradient.repr(),
-            Self::Pattern(pattern) => pattern.repr(),
+            Self::Tiling(tiling) => tiling.repr(),
         }
     }
 }
@@ -94,9 +94,9 @@ cast! {
     self => match self {
         Self::Solid(color) => color.into_value(),
         Self::Gradient(gradient) => gradient.into_value(),
-        Self::Pattern(pattern) => pattern.into_value(),
+        Self::Tiling(tiling) => tiling.into_value(),
     },
     color: Color => Self::Solid(color),
     gradient: Gradient => Self::Gradient(gradient),
-    pattern: Pattern => Self::Pattern(pattern),
+    tiling: Tiling => Self::Tiling(tiling),
 }
diff --git a/crates/typst-library/src/visualize/stroke.rs b/crates/typst-library/src/visualize/stroke.rs
index 4ca10920f..2ab493a53 100644
--- a/crates/typst-library/src/visualize/stroke.rs
+++ b/crates/typst-library/src/visualize/stroke.rs
@@ -7,7 +7,7 @@ use crate::foundations::{
     Resolve, Smart, StyleChain, Value,
 };
 use crate::layout::{Abs, Length};
-use crate::visualize::{Color, Gradient, Paint, Pattern};
+use crate::visualize::{Color, Gradient, Paint, Tiling};
 
 /// Defines how to draw a line.
 ///
@@ -213,9 +213,9 @@ impl<T: Numeric> Stroke<T> {
             thickness: self.thickness.map(&f),
             cap: self.cap,
             join: self.join,
-            dash: self.dash.map(|pattern| {
-                pattern.map(|pattern| DashPattern {
-                    array: pattern
+            dash: self.dash.map(|dash| {
+                dash.map(|dash| DashPattern {
+                    array: dash
                         .array
                         .into_iter()
                         .map(|l| match l {
@@ -223,7 +223,7 @@ impl<T: Numeric> Stroke<T> {
                             DashLength::LineWidth => DashLength::LineWidth,
                         })
                         .collect(),
-                    phase: f(pattern.phase),
+                    phase: f(dash.phase),
                 })
             }),
             miter_limit: self.miter_limit,
@@ -237,14 +237,10 @@ impl Stroke<Abs> {
         let thickness = self.thickness.unwrap_or(default.thickness);
         let dash = self
             .dash
-            .map(|pattern| {
-                pattern.map(|pattern| DashPattern {
-                    array: pattern
-                        .array
-                        .into_iter()
-                        .map(|l| l.finish(thickness))
-                        .collect(),
-                    phase: pattern.phase,
+            .map(|dash| {
+                dash.map(|dash| DashPattern {
+                    array: dash.array.into_iter().map(|l| l.finish(thickness)).collect(),
+                    phase: dash.phase,
                 })
             })
             .unwrap_or(default.dash);
@@ -372,8 +368,8 @@ cast! {
         paint: Smart::Custom(gradient.into()),
         ..Default::default()
     },
-    pattern: Pattern => Self {
-        paint: Smart::Custom(pattern.into()),
+    tiling: Tiling => Self {
+        paint: Smart::Custom(tiling.into()),
         ..Default::default()
     },
     mut dict: Dict => {
diff --git a/crates/typst-library/src/visualize/pattern.rs b/crates/typst-library/src/visualize/tiling.rs
similarity index 71%
rename from crates/typst-library/src/visualize/pattern.rs
rename to crates/typst-library/src/visualize/tiling.rs
index 2017ea655..d699d3b6d 100644
--- a/crates/typst-library/src/visualize/pattern.rs
+++ b/crates/typst-library/src/visualize/tiling.rs
@@ -13,18 +13,18 @@ use crate::layout::{Abs, Axes, Frame, Length, Region, Size};
 use crate::visualize::RelativeTo;
 use crate::World;
 
-/// A repeating pattern fill.
+/// A repeating tiling fill.
 ///
-/// Typst supports the most common pattern type of tiled patterns, where a
-/// pattern is repeated in a grid-like fashion, covering the entire area of an
-/// element that is filled or stroked. The pattern is defined by a tile size and
-/// a body defining the content of each cell. You can also add horizontal or
-/// vertical spacing between the cells of the pattern.
+/// Typst supports the most common type of tilings, where a pattern is repeated
+/// in a grid-like fashion, covering the entire area of an element that is
+/// filled or stroked. The pattern is defined by a tile size and a body defining
+/// the content of each cell. You can also add horizontal or vertical spacing
+/// between the cells of the tiling.
 ///
 /// # Examples
 ///
 /// ```example
-/// #let pat = pattern(size: (30pt, 30pt))[
+/// #let pat = tiling(size: (30pt, 30pt))[
 ///   #place(line(start: (0%, 0%), end: (100%, 100%)))
 ///   #place(line(start: (0%, 100%), end: (100%, 0%)))
 /// ]
@@ -32,14 +32,14 @@ use crate::World;
 /// #rect(fill: pat, width: 100%, height: 60pt, stroke: 1pt)
 /// ```
 ///
-/// Patterns are also supported on text, but only when setting the
-/// [relativeness]($pattern.relative) to either `{auto}` (the default value) or
-/// `{"parent"}`. To create word-by-word or glyph-by-glyph patterns, you can
+/// Tilings are also supported on text, but only when setting the
+/// [relativeness]($tiling.relative) to either `{auto}` (the default value) or
+/// `{"parent"}`. To create word-by-word or glyph-by-glyph tilings, you can
 /// wrap the words or characters of your text in [boxes]($box) manually or
 /// through a [show rule]($styling/#show-rules).
 ///
 /// ```example
-/// #let pat = pattern(
+/// #let pat = tiling(
 ///   size: (30pt, 30pt),
 ///   relative: "parent",
 ///   square(
@@ -54,13 +54,13 @@ use crate::World;
 /// ```
 ///
 /// You can also space the elements further or closer apart using the
-/// [`spacing`]($pattern.spacing) feature of the pattern. If the spacing
-/// is lower than the size of the pattern, the pattern will overlap.
-/// If it is higher, the pattern will have gaps of the same color as the
-/// background of the pattern.
+/// [`spacing`]($tiling.spacing) feature of the tiling. If the spacing
+/// is lower than the size of the tiling, the tiling will overlap.
+/// If it is higher, the tiling will have gaps of the same color as the
+/// background of the tiling.
 ///
 /// ```example
-/// #let pat = pattern(
+/// #let pat = tiling(
 ///   size: (30pt, 30pt),
 ///   spacing: (10pt, 10pt),
 ///   relative: "parent",
@@ -79,11 +79,11 @@ use crate::World;
 /// ```
 ///
 /// # Relativeness
-/// The location of the starting point of the pattern is dependent on the
+/// The location of the starting point of the tiling is dependent on the
 /// dimensions of a container. This container can either be the shape that it is
 /// being painted on, or the closest surrounding container. This is controlled
-/// by the `relative` argument of a pattern constructor. By default, patterns
-/// are relative to the shape they are being painted on, unless the pattern is
+/// by the `relative` argument of a tiling constructor. By default, tilings
+/// are relative to the shape they are being painted on, unless the tiling is
 /// applied on text, in which case they are relative to the closest ancestor
 /// container.
 ///
@@ -94,29 +94,33 @@ use crate::World;
 ///   contains the shape. This includes the boxes and blocks that are implicitly
 ///   created by show rules and elements. For example, a [`rotate`] will not
 ///   affect the parent of a gradient, but a [`grid`] will.
-#[ty(scope, cast)]
+///
+/// # Compatibility
+/// This type used to be called `pattern`. The name remains as an alias, but is
+/// deprecated since Typst 0.13.
+#[ty(scope, cast, keywords = ["pattern"])]
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Pattern(Arc<Repr>);
+pub struct Tiling(Arc<Repr>);
 
-/// Internal representation of [`Pattern`].
+/// Internal representation of [`Tiling`].
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 struct Repr {
-    /// The pattern's rendered content.
+    /// The tiling's rendered content.
     frame: LazyHash<Frame>,
-    /// The pattern's tile size.
+    /// The tiling's tile size.
     size: Size,
-    /// The pattern's tile spacing.
+    /// The tiling's tile spacing.
     spacing: Size,
-    /// The pattern's relative transform.
+    /// The tiling's relative transform.
     relative: Smart<RelativeTo>,
 }
 
 #[scope]
-impl Pattern {
-    /// Construct a new pattern.
+impl Tiling {
+    /// Construct a new tiling.
     ///
     /// ```example
-    /// #let pat = pattern(
+    /// #let pat = tiling(
     ///   size: (20pt, 20pt),
     ///   relative: "parent",
     ///   place(
@@ -136,15 +140,15 @@ impl Pattern {
         engine: &mut Engine,
         /// The callsite span.
         span: Span,
-        /// The bounding box of each cell of the pattern.
+        /// The bounding box of each cell of the tiling.
         #[named]
         #[default(Spanned::new(Smart::Auto, Span::detached()))]
         size: Spanned<Smart<Axes<Length>>>,
-        /// The spacing between cells of the pattern.
+        /// The spacing between cells of the tiling.
         #[named]
         #[default(Spanned::new(Axes::splat(Length::zero()), Span::detached()))]
         spacing: Spanned<Axes<Length>>,
-        /// The [relative placement](#relativeness) of the pattern.
+        /// The [relative placement](#relativeness) of the tiling.
         ///
         /// For an element placed at the root/top level of the document, the
         /// parent is the page itself. For other elements, the parent is the
@@ -153,14 +157,14 @@ impl Pattern {
         #[named]
         #[default(Smart::Auto)]
         relative: Smart<RelativeTo>,
-        /// The content of each cell of the pattern.
+        /// The content of each cell of the tiling.
         body: Content,
-    ) -> SourceResult<Pattern> {
+    ) -> SourceResult<Tiling> {
         let size_span = size.span;
         if let Smart::Custom(size) = size.v {
             // Ensure that sizes are absolute.
             if !size.x.em.is_zero() || !size.y.em.is_zero() {
-                bail!(size_span, "pattern tile size must be absolute");
+                bail!(size_span, "tile size must be absolute");
             }
 
             // Ensure that sizes are non-zero and finite.
@@ -169,25 +173,25 @@ impl Pattern {
                 || !size.x.is_finite()
                 || !size.y.is_finite()
             {
-                bail!(size_span, "pattern tile size must be non-zero and non-infinite");
+                bail!(size_span, "tile size must be non-zero and non-infinite");
             }
         }
 
         // Ensure that spacing is absolute.
         if !spacing.v.x.em.is_zero() || !spacing.v.y.em.is_zero() {
-            bail!(spacing.span, "pattern tile spacing must be absolute");
+            bail!(spacing.span, "tile spacing must be absolute");
         }
 
         // Ensure that spacing is finite.
         if !spacing.v.x.is_finite() || !spacing.v.y.is_finite() {
-            bail!(spacing.span, "pattern tile spacing must be finite");
+            bail!(spacing.span, "tile spacing must be finite");
         }
 
         // The size of the frame
         let size = size.v.map(|l| l.map(|a| a.abs));
         let region = size.unwrap_or_else(|| Axes::splat(Abs::inf()));
 
-        // Layout the pattern.
+        // Layout the tiling.
         let world = engine.world;
         let library = world.library();
         let locator = Locator::root();
@@ -204,7 +208,7 @@ impl Pattern {
         // Check that the frame is non-zero.
         if frame.width().is_zero() || frame.height().is_zero() {
             bail!(
-                span, "pattern tile size must be non-zero";
+                span, "tile size must be non-zero";
                 hint: "try setting the size manually"
             );
         }
@@ -218,8 +222,8 @@ impl Pattern {
     }
 }
 
-impl Pattern {
-    /// Set the relative placement of the pattern.
+impl Tiling {
+    /// Set the relative placement of the tiling.
     pub fn with_relative(mut self, relative: RelativeTo) -> Self {
         if let Some(this) = Arc::get_mut(&mut self.0) {
             this.relative = Smart::Custom(relative);
@@ -233,27 +237,27 @@ impl Pattern {
         self
     }
 
-    /// Return the frame of the pattern.
+    /// Return the frame of the tiling.
     pub fn frame(&self) -> &Frame {
         &self.0.frame
     }
 
-    /// Return the size of the pattern in absolute units.
+    /// Return the size of the tiling in absolute units.
     pub fn size(&self) -> Size {
         self.0.size
     }
 
-    /// Return the spacing of the pattern in absolute units.
+    /// Return the spacing of the tiling in absolute units.
     pub fn spacing(&self) -> Size {
         self.0.spacing
     }
 
-    /// Returns the relative placement of the pattern.
+    /// Returns the relative placement of the tiling.
     pub fn relative(&self) -> Smart<RelativeTo> {
         self.0.relative
     }
 
-    /// Returns the relative placement of the pattern.
+    /// 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 {
@@ -265,10 +269,10 @@ impl Pattern {
     }
 }
 
-impl repr::Repr for Pattern {
+impl repr::Repr for Tiling {
     fn repr(&self) -> EcoString {
         let mut out =
-            eco_format!("pattern(({}, {})", self.0.size.x.repr(), self.0.size.y.repr());
+            eco_format!("tiling(({}, {})", self.0.size.x.repr(), self.0.size.y.repr());
 
         if self.0.spacing.is_zero() {
             out.push_str(", spacing: (");
diff --git a/crates/typst-pdf/src/color.rs b/crates/typst-pdf/src/color.rs
index 7097c14a5..412afca9a 100644
--- a/crates/typst-pdf/src/color.rs
+++ b/crates/typst-pdf/src/color.rs
@@ -222,7 +222,7 @@ impl PaintEncode for Paint {
         match self {
             Self::Solid(c) => c.set_as_fill(ctx, on_text, transforms),
             Self::Gradient(gradient) => gradient.set_as_fill(ctx, on_text, transforms),
-            Self::Pattern(pattern) => pattern.set_as_fill(ctx, on_text, transforms),
+            Self::Tiling(tiling) => tiling.set_as_fill(ctx, on_text, transforms),
         }
     }
 
@@ -235,7 +235,7 @@ impl PaintEncode for Paint {
         match self {
             Self::Solid(c) => c.set_as_stroke(ctx, on_text, transforms),
             Self::Gradient(gradient) => gradient.set_as_stroke(ctx, on_text, transforms),
-            Self::Pattern(pattern) => pattern.set_as_stroke(ctx, on_text, transforms),
+            Self::Tiling(tiling) => tiling.set_as_stroke(ctx, on_text, transforms),
         }
     }
 }
diff --git a/crates/typst-pdf/src/content.rs b/crates/typst-pdf/src/content.rs
index ce72365dd..d57f20939 100644
--- a/crates/typst-pdf/src/content.rs
+++ b/crates/typst-pdf/src/content.rs
@@ -1,6 +1,6 @@
 //! Generic writer for PDF content.
 //!
-//! It is used to write page contents, color glyph instructions, and patterns.
+//! It is used to write page contents, color glyph instructions, and tilings.
 //!
 //! See also [`pdf_writer::Content`].
 
@@ -96,7 +96,7 @@ pub struct Encoded {
 /// objects only through resources.
 ///
 /// Content streams can be used for page contents, but also to describe color
-/// glyphs and patterns.
+/// glyphs and tilings.
 pub struct Builder<'a, R = ()> {
     /// Settings for PDF export.
     pub(crate) options: &'a PdfOptions<'a>,
@@ -187,7 +187,7 @@ impl State {
     }
 }
 
-/// Subset of the state used to calculate the transform of gradients and patterns.
+/// Subset of the state used to calculate the transform of gradients and tilings.
 #[derive(Debug, Clone, Copy)]
 pub(super) struct Transforms {
     /// The transform of the current item.
@@ -229,7 +229,7 @@ impl Builder<'_, ()> {
         let get_opacity = |paint: &Paint| {
             let color = match paint {
                 Paint::Solid(color) => *color,
-                Paint::Gradient(_) | Paint::Pattern(_) => return 255,
+                Paint::Gradient(_) | Paint::Tiling(_) => return 255,
             };
 
             color.alpha().map_or(255, |v| (v * 255.0).round() as u8)
@@ -330,10 +330,10 @@ impl Builder<'_, ()> {
                 self.content.set_line_join(to_pdf_line_join(*join));
             }
             if self.state.stroke.as_ref().map(|s| &s.dash) != Some(dash) {
-                if let Some(pattern) = dash {
+                if let Some(dash) = dash {
                     self.content.set_dash_pattern(
-                        pattern.array.iter().map(|l| l.to_f32()),
-                        pattern.phase.to_f32(),
+                        dash.array.iter().map(|l| l.to_f32()),
+                        dash.phase.to_f32(),
                     );
                 } else {
                     self.content.set_dash_pattern([], 0.0);
diff --git a/crates/typst-pdf/src/lib.rs b/crates/typst-pdf/src/lib.rs
index f9b4e902d..c315684de 100644
--- a/crates/typst-pdf/src/lib.rs
+++ b/crates/typst-pdf/src/lib.rs
@@ -11,8 +11,8 @@ mod image;
 mod named_destination;
 mod outline;
 mod page;
-mod pattern;
 mod resources;
+mod tiling;
 
 use std::collections::HashMap;
 use std::fmt::{self, Debug, Formatter};
@@ -39,10 +39,10 @@ use crate::gradient::{write_gradients, PdfGradient};
 use crate::image::write_images;
 use crate::named_destination::{write_named_destinations, NamedDestinations};
 use crate::page::{alloc_page_refs, traverse_pages, write_page_tree, EncodedPage};
-use crate::pattern::{write_patterns, PdfPattern};
 use crate::resources::{
     alloc_resources_refs, write_resource_dictionaries, Resources, ResourcesRefs,
 };
+use crate::tiling::{write_tilings, PdfTiling};
 
 /// Export a document into a PDF file.
 ///
@@ -65,7 +65,7 @@ pub fn pdf(document: &PagedDocument, options: &PdfOptions) -> SourceResult<Vec<u
                 color_fonts: builder.run(write_color_fonts)?,
                 images: builder.run(write_images)?,
                 gradients: builder.run(write_gradients)?,
-                patterns: builder.run(write_patterns)?,
+                tilings: builder.run(write_tilings)?,
                 ext_gs: builder.run(write_graphic_states)?,
             })
         })?
@@ -267,8 +267,8 @@ struct References {
     images: HashMap<Image, Ref>,
     /// The IDs of written gradients.
     gradients: HashMap<PdfGradient, Ref>,
-    /// The IDs of written patterns.
-    patterns: HashMap<PdfPattern, Ref>,
+    /// The IDs of written tilings.
+    tilings: HashMap<PdfTiling, Ref>,
     /// The IDs of written external graphics states.
     ext_gs: HashMap<ExtGState, Ref>,
 }
diff --git a/crates/typst-pdf/src/resources.rs b/crates/typst-pdf/src/resources.rs
index d3fde5dd7..bdbf2f1e4 100644
--- a/crates/typst-pdf/src/resources.rs
+++ b/crates/typst-pdf/src/resources.rs
@@ -23,7 +23,7 @@ use crate::color_font::ColorFontMap;
 use crate::extg::ExtGState;
 use crate::gradient::PdfGradient;
 use crate::image::EncodedImage;
-use crate::pattern::PatternRemapper;
+use crate::tiling::TilingRemapper;
 use crate::{PdfChunk, Renumber, WithEverything, WithResources};
 
 /// All the resources that have been collected when traversing the document.
@@ -31,16 +31,16 @@ use crate::{PdfChunk, Renumber, WithEverything, WithResources};
 /// This does not allocate references to resources, only track what was used
 /// and deduplicate what can be deduplicated.
 ///
-/// You may notice that this structure is a tree: [`PatternRemapper`] and
+/// You may notice that this structure is a tree: [`TilingRemapper`] and
 /// [`ColorFontMap`] (that are present in the fields of [`Resources`]),
 /// themselves contain [`Resources`] (that will be called "sub-resources" from
-/// now on). Because color glyphs and patterns are defined using content
+/// now on). Because color glyphs and tilings are defined using content
 /// streams, just like pages, they can refer to resources too, which are tracked
 /// by the respective sub-resources.
 ///
 /// Each instance of this structure will become a `/Resources` dictionary in
 /// the final PDF. It is not possible to use a single shared dictionary for all
-/// pages, patterns and color fonts, because if a resource is listed in its own
+/// pages, tilings and color fonts, because if a resource is listed in its own
 /// `/Resources` dictionary, some PDF readers will fail to open the document.
 ///
 /// Because we need to lazily initialize sub-resources (we don't know how deep
@@ -66,8 +66,8 @@ pub struct Resources<R = Ref> {
     pub deferred_images: HashMap<usize, (Deferred<StrResult<EncodedImage>>, Span)>,
     /// Deduplicates gradients used across the document.
     pub gradients: Remapper<PdfGradient>,
-    /// Deduplicates patterns used across the document.
-    pub patterns: Option<Box<PatternRemapper<R>>>,
+    /// Deduplicates tilings used across the document.
+    pub tilings: Option<Box<TilingRemapper<R>>>,
     /// Deduplicates external graphics states used across the document.
     pub ext_gs: Remapper<ExtGState>,
     /// Deduplicates color glyphs.
@@ -107,8 +107,8 @@ impl<R: Renumber> Renumber for Resources<R> {
             color_fonts.resources.renumber(offset);
         }
 
-        if let Some(patterns) = &mut self.patterns {
-            patterns.resources.renumber(offset);
+        if let Some(tilings) = &mut self.tilings {
+            tilings.resources.renumber(offset);
         }
     }
 }
@@ -122,7 +122,7 @@ impl Default for Resources<()> {
             images: Remapper::new("Im"),
             deferred_images: HashMap::new(),
             gradients: Remapper::new("Gr"),
-            patterns: None,
+            tilings: None,
             ext_gs: Remapper::new("Gs"),
             color_fonts: None,
             languages: BTreeMap::new(),
@@ -144,9 +144,9 @@ impl Resources<()> {
             images: self.images,
             deferred_images: self.deferred_images,
             gradients: self.gradients,
-            patterns: self
-                .patterns
-                .zip(refs.patterns.as_ref())
+            tilings: self
+                .tilings
+                .zip(refs.tilings.as_ref())
                 .map(|(p, r)| Box::new(p.with_refs(r))),
             ext_gs: self.ext_gs,
             color_fonts: self
@@ -172,8 +172,8 @@ impl<R> Resources<R> {
         if let Some(color_fonts) = &self.color_fonts {
             color_fonts.resources.traverse(process)?;
         }
-        if let Some(patterns) = &self.patterns {
-            patterns.resources.traverse(process)?;
+        if let Some(tilings) = &self.tilings {
+            tilings.resources.traverse(process)?;
         }
         Ok(())
     }
@@ -186,7 +186,7 @@ impl<R> Resources<R> {
 pub struct ResourcesRefs {
     pub reference: Ref,
     pub color_fonts: Option<Box<ResourcesRefs>>,
-    pub patterns: Option<Box<ResourcesRefs>>,
+    pub tilings: Option<Box<ResourcesRefs>>,
 }
 
 impl Renumber for ResourcesRefs {
@@ -195,8 +195,8 @@ impl Renumber for ResourcesRefs {
         if let Some(color_fonts) = &mut self.color_fonts {
             color_fonts.renumber(offset);
         }
-        if let Some(patterns) = &mut self.patterns {
-            patterns.renumber(offset);
+        if let Some(tilings) = &mut self.tilings {
+            tilings.renumber(offset);
         }
     }
 }
@@ -214,8 +214,8 @@ pub fn alloc_resources_refs(
                 .color_fonts
                 .as_ref()
                 .map(|c| Box::new(refs_for(&c.resources, chunk))),
-            patterns: resources
-                .patterns
+            tilings: resources
+                .tilings
                 .as_ref()
                 .map(|p| Box::new(refs_for(&p.resources, chunk))),
         }
@@ -231,7 +231,7 @@ pub fn alloc_resources_refs(
 /// to the root node of the page tree because using the resource inheritance
 /// feature breaks PDF merging with Apple Preview.
 ///
-/// Also write resource dictionaries for Type3 fonts and patterns.
+/// Also write resource dictionaries for Type3 fonts and PDF patterns.
 pub fn write_resource_dictionaries(ctx: &WithEverything) -> SourceResult<(PdfChunk, ())> {
     let mut chunk = PdfChunk::new();
     let mut used_color_spaces = ColorSpaces::default();
@@ -266,8 +266,8 @@ pub fn write_resource_dictionaries(ctx: &WithEverything) -> SourceResult<(PdfChu
         resources
             .gradients
             .write(&ctx.references.gradients, &mut patterns_dict);
-        if let Some(p) = &resources.patterns {
-            p.remapper.write(&ctx.references.patterns, &mut patterns_dict);
+        if let Some(p) = &resources.tilings {
+            p.remapper.write(&ctx.references.tilings, &mut patterns_dict);
         }
         patterns_dict.finish();
 
diff --git a/crates/typst-pdf/src/pattern.rs b/crates/typst-pdf/src/tiling.rs
similarity index 87%
rename from crates/typst-pdf/src/pattern.rs
rename to crates/typst-pdf/src/tiling.rs
index ddc22fbd6..f8950f344 100644
--- a/crates/typst-pdf/src/pattern.rs
+++ b/crates/typst-pdf/src/tiling.rs
@@ -5,7 +5,7 @@ use pdf_writer::types::{ColorSpaceOperand, PaintType, TilingType};
 use pdf_writer::{Filter, Name, Rect, Ref};
 use typst_library::diag::SourceResult;
 use typst_library::layout::{Abs, Ratio, Transform};
-use typst_library::visualize::{Pattern, RelativeTo};
+use typst_library::visualize::{RelativeTo, Tiling};
 use typst_utils::Numeric;
 
 use crate::color::PaintEncode;
@@ -14,18 +14,18 @@ use crate::{content, transform_to_array, PdfChunk, Resources, WithGlobalRefs};
 
 /// Writes the actual patterns (tiling patterns) to the PDF.
 /// This is performed once after writing all pages.
-pub fn write_patterns(
+pub fn write_tilings(
     context: &WithGlobalRefs,
-) -> SourceResult<(PdfChunk, HashMap<PdfPattern, Ref>)> {
+) -> SourceResult<(PdfChunk, HashMap<PdfTiling, Ref>)> {
     let mut chunk = PdfChunk::new();
     let mut out = HashMap::new();
     context.resources.traverse(&mut |resources| {
-        let Some(patterns) = &resources.patterns else {
+        let Some(patterns) = &resources.tilings else {
             return Ok(());
         };
 
         for pdf_pattern in patterns.remapper.items() {
-            let PdfPattern { transform, pattern, content, .. } = pdf_pattern;
+            let PdfTiling { transform, pattern, content, .. } = pdf_pattern;
             if out.contains_key(pdf_pattern) {
                 continue;
             }
@@ -69,11 +69,11 @@ pub fn write_patterns(
 
 /// A pattern and its transform.
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
-pub struct PdfPattern {
+pub struct PdfTiling {
     /// The transform to apply to the pattern.
     pub transform: Transform,
     /// The pattern to paint.
-    pub pattern: Pattern,
+    pub pattern: Tiling,
     /// The rendered pattern.
     pub content: Vec<u8>,
 }
@@ -81,14 +81,14 @@ pub struct PdfPattern {
 /// Registers a pattern with the PDF.
 fn register_pattern(
     ctx: &mut content::Builder,
-    pattern: &Pattern,
+    pattern: &Tiling,
     on_text: bool,
     mut transforms: content::Transforms,
 ) -> SourceResult<usize> {
     let patterns = ctx
         .resources
-        .patterns
-        .get_or_insert_with(|| Box::new(PatternRemapper::new()));
+        .tilings
+        .get_or_insert_with(|| Box::new(TilingRemapper::new()));
 
     // Edge cases for strokes.
     if transforms.size.x.is_zero() {
@@ -113,7 +113,7 @@ fn register_pattern(
         None,
     )?;
 
-    let pdf_pattern = PdfPattern {
+    let pdf_pattern = PdfTiling {
         transform,
         pattern: pattern.clone(),
         content: content.content.wait().clone(),
@@ -122,7 +122,7 @@ fn register_pattern(
     Ok(patterns.remapper.insert(pdf_pattern))
 }
 
-impl PaintEncode for Pattern {
+impl PaintEncode for Tiling {
     fn set_as_fill(
         &self,
         ctx: &mut content::Builder,
@@ -159,14 +159,14 @@ impl PaintEncode for Pattern {
 }
 
 /// De-duplicate patterns and the resources they require to be drawn.
-pub struct PatternRemapper<R> {
+pub struct TilingRemapper<R> {
     /// Pattern de-duplicator.
-    pub remapper: Remapper<PdfPattern>,
+    pub remapper: Remapper<PdfTiling>,
     /// PDF resources that are used by these patterns.
     pub resources: Resources<R>,
 }
 
-impl PatternRemapper<()> {
+impl TilingRemapper<()> {
     pub fn new() -> Self {
         Self {
             remapper: Remapper::new("P"),
@@ -175,8 +175,8 @@ impl PatternRemapper<()> {
     }
 
     /// Allocate a reference to the resource dictionary of these patterns.
-    pub fn with_refs(self, refs: &ResourcesRefs) -> PatternRemapper<Ref> {
-        PatternRemapper {
+    pub fn with_refs(self, refs: &ResourcesRefs) -> TilingRemapper<Ref> {
+        TilingRemapper {
             remapper: self.remapper,
             resources: self.resources.with_refs(refs),
         }
diff --git a/crates/typst-render/src/paint.rs b/crates/typst-render/src/paint.rs
index 689f28a89..ce92fd6a3 100644
--- a/crates/typst-render/src/paint.rs
+++ b/crates/typst-render/src/paint.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
 
 use tiny_skia as sk;
 use typst_library::layout::{Axes, Point, Ratio, Size};
-use typst_library::visualize::{Color, Gradient, Paint, Pattern, RelativeTo};
+use typst_library::visualize::{Color, Gradient, Paint, RelativeTo, Tiling};
 
 use crate::{AbsExt, State};
 
@@ -72,26 +72,26 @@ impl PaintSampler for GradientSampler<'_> {
     }
 }
 
-/// State used when sampling patterns for text.
+/// State used when sampling tilings for text.
 ///
 /// It caches the inverse transform to the parent, so that we can
 /// reuse it instead of recomputing it for each pixel.
 #[derive(Clone, Copy)]
-pub struct PatternSampler<'a> {
+pub struct TilingSampler<'a> {
     size: Size,
     transform_to_parent: sk::Transform,
     pixmap: &'a sk::Pixmap,
     pixel_per_pt: f32,
 }
 
-impl<'a> PatternSampler<'a> {
+impl<'a> TilingSampler<'a> {
     pub fn new(
-        pattern: &'a Pattern,
+        tilings: &'a Tiling,
         pixmap: &'a sk::Pixmap,
         state: &State,
         on_text: bool,
     ) -> Self {
-        let relative = pattern.unwrap_relative(on_text);
+        let relative = tilings.unwrap_relative(on_text);
         let fill_transform = match relative {
             RelativeTo::Self_ => sk::Transform::identity(),
             RelativeTo::Parent => state.container_transform.invert().unwrap(),
@@ -99,17 +99,17 @@ impl<'a> PatternSampler<'a> {
 
         Self {
             pixmap,
-            size: (pattern.size() + pattern.spacing()) * state.pixel_per_pt as f64,
+            size: (tilings.size() + tilings.spacing()) * state.pixel_per_pt as f64,
             transform_to_parent: fill_transform,
             pixel_per_pt: state.pixel_per_pt,
         }
     }
 }
 
-impl PaintSampler for PatternSampler<'_> {
+impl PaintSampler for TilingSampler<'_> {
     /// Samples a single point in a glyph.
     fn sample(self, (x, y): (u32, u32)) -> sk::PremultipliedColorU8 {
-        // Compute the point in the pattern's coordinate space.
+        // Compute the point in the tilings's coordinate space.
         let mut point = sk::Point { x: x as f32, y: y as f32 };
         self.transform_to_parent.map_point(&mut point);
 
@@ -118,7 +118,7 @@ impl PaintSampler for PatternSampler<'_> {
         let y =
             (point.y * self.pixel_per_pt).rem_euclid(self.size.y.to_f32()).floor() as u32;
 
-        // Sample the pattern
+        // Sample the tilings
         self.pixmap.pixel(x, y).unwrap()
     }
 }
@@ -218,8 +218,8 @@ pub fn to_sk_paint<'a>(
 
             sk_paint.anti_alias = gradient.anti_alias();
         }
-        Paint::Pattern(pattern) => {
-            let relative = pattern.unwrap_relative(on_text);
+        Paint::Tiling(tilings) => {
+            let relative = tilings.unwrap_relative(on_text);
 
             let fill_transform = match relative {
                 RelativeTo::Self_ => fill_transform.unwrap_or_default(),
@@ -228,7 +228,7 @@ pub fn to_sk_paint<'a>(
                     .post_concat(state.transform.invert().unwrap()),
             };
 
-            let canvas = render_pattern_frame(&state, pattern);
+            let canvas = render_tiling_frame(&state, tilings);
             *pixmap = Some(Arc::new(canvas));
 
             let offset = match relative {
@@ -265,17 +265,17 @@ pub fn to_sk_color_u8(color: Color) -> sk::ColorU8 {
     sk::ColorU8::from_rgba(r, g, b, a)
 }
 
-pub fn render_pattern_frame(state: &State, pattern: &Pattern) -> sk::Pixmap {
-    let size = pattern.size() + pattern.spacing();
+pub fn render_tiling_frame(state: &State, tilings: &Tiling) -> sk::Pixmap {
+    let size = tilings.size() + tilings.spacing();
     let mut canvas = sk::Pixmap::new(
         (size.x.to_f32() * state.pixel_per_pt).round() as u32,
         (size.y.to_f32() * state.pixel_per_pt).round() as u32,
     )
     .unwrap();
 
-    // Render the pattern into a new canvas.
+    // Render the tilings into a new canvas.
     let ts = sk::Transform::from_scale(state.pixel_per_pt, state.pixel_per_pt);
-    let temp_state = State::new(pattern.size(), ts, state.pixel_per_pt);
-    crate::render_frame(&mut canvas, temp_state, pattern.frame());
+    let temp_state = State::new(tilings.size(), ts, state.pixel_per_pt);
+    crate::render_frame(&mut canvas, temp_state, tilings.frame());
     canvas
 }
diff --git a/crates/typst-render/src/shape.rs b/crates/typst-render/src/shape.rs
index f9ff7f3a9..57d8ebc1a 100644
--- a/crates/typst-render/src/shape.rs
+++ b/crates/typst-render/src/shape.rs
@@ -168,11 +168,11 @@ pub fn to_sk_line_join(join: LineJoin) -> sk::LineJoin {
     }
 }
 
-pub fn to_sk_dash_pattern(pattern: &DashPattern<Abs, Abs>) -> Option<sk::StrokeDash> {
+pub fn to_sk_dash_pattern(dash: &DashPattern<Abs, Abs>) -> Option<sk::StrokeDash> {
     // tiny-skia only allows dash patterns with an even number of elements,
     // while pdf allows any number.
-    let pattern_len = pattern.array.len();
+    let pattern_len = dash.array.len();
     let len = if pattern_len % 2 == 1 { 2 * pattern_len } else { pattern_len };
-    let dash_array = pattern.array.iter().map(|l| l.to_f32()).cycle().take(len).collect();
-    sk::StrokeDash::new(dash_array, pattern.phase.to_f32())
+    let dash_array = dash.array.iter().map(|l| l.to_f32()).cycle().take(len).collect();
+    sk::StrokeDash::new(dash_array, dash.phase.to_f32())
 }
diff --git a/crates/typst-render/src/text.rs b/crates/typst-render/src/text.rs
index b47659cba..16490aff4 100644
--- a/crates/typst-render/src/text.rs
+++ b/crates/typst-render/src/text.rs
@@ -8,7 +8,7 @@ use typst_library::text::color::{glyph_frame, should_outline};
 use typst_library::text::{Font, TextItem};
 use typst_library::visualize::{FixedStroke, Paint};
 
-use crate::paint::{self, GradientSampler, PaintSampler, PatternSampler};
+use crate::paint::{self, GradientSampler, PaintSampler, TilingSampler};
 use crate::{shape, AbsExt, State};
 
 /// Render a text run into the canvas.
@@ -145,9 +145,9 @@ fn render_outline_glyph(
                 paint::to_sk_color_u8(*color).premultiply(),
             )?;
         }
-        Paint::Pattern(pattern) => {
-            let pixmap = paint::render_pattern_frame(&state, pattern);
-            let sampler = PatternSampler::new(pattern, &pixmap, &state, true);
+        Paint::Tiling(tiling) => {
+            let pixmap = paint::render_tiling_frame(&state, tiling);
+            let sampler = TilingSampler::new(tiling, &pixmap, &state, true);
             write_bitmap(canvas, &bitmap, &state, sampler)?;
         }
     }
diff --git a/crates/typst-svg/src/lib.rs b/crates/typst-svg/src/lib.rs
index b21fe4fb8..f99513321 100644
--- a/crates/typst-svg/src/lib.rs
+++ b/crates/typst-svg/src/lib.rs
@@ -14,11 +14,11 @@ use typst_library::layout::{
     Abs, Frame, FrameItem, FrameKind, GroupItem, Page, PagedDocument, Point, Ratio, Size,
     Transform,
 };
-use typst_library::visualize::{Geometry, Gradient, Pattern};
+use typst_library::visualize::{Geometry, Gradient, Tiling};
 use typst_utils::hash128;
 use xmlwriter::XmlWriter;
 
-use crate::paint::{GradientRef, PatternRef, SVGSubGradient};
+use crate::paint::{GradientRef, SVGSubGradient, TilingRef};
 use crate::text::RenderedGlyph;
 
 /// Export a frame into a SVG file.
@@ -92,12 +92,12 @@ struct SVGRenderer {
     /// different transforms. Therefore this allows us to reuse the same gradient
     /// multiple times.
     gradient_refs: Deduplicator<GradientRef>,
-    /// Deduplicated patterns with transform matrices. They use a reference
-    /// (`href`) to a "source" pattern instead of being defined inline.
-    /// This saves a lot of space since patterns are often reused but with
+    /// Deduplicated tilings with transform matrices. They use a reference
+    /// (`href`) to a "source" tiling instead of being defined inline.
+    /// This saves a lot of space since tilings are often reused but with
     /// different transforms. Therefore this allows us to reuse the same gradient
     /// multiple times.
-    pattern_refs: Deduplicator<PatternRef>,
+    tiling_refs: Deduplicator<TilingRef>,
     /// These are the actual gradients being written in the SVG file.
     /// These gradients are deduplicated because they do not contain the transform
     /// matrix, allowing them to be reused across multiple invocations.
@@ -105,12 +105,12 @@ struct SVGRenderer {
     /// The `Ratio` is the aspect ratio of the gradient, this is used to correct
     /// the angle of the gradient.
     gradients: Deduplicator<(Gradient, Ratio)>,
-    /// These are the actual patterns being written in the SVG file.
-    /// These patterns are deduplicated because they do not contain the transform
+    /// These are the actual tilings being written in the SVG file.
+    /// These tilings are deduplicated because they do not contain the transform
     /// matrix, allowing them to be reused across multiple invocations.
     ///
-    /// The `String` is the rendered pattern frame.
-    patterns: Deduplicator<Pattern>,
+    /// The `String` is the rendered tiling frame.
+    tilings: Deduplicator<Tiling>,
     /// These are the gradients that compose a conic gradient.
     conic_subgradients: Deduplicator<SVGSubGradient>,
 }
@@ -163,8 +163,8 @@ impl SVGRenderer {
             gradient_refs: Deduplicator::new('g'),
             gradients: Deduplicator::new('f'),
             conic_subgradients: Deduplicator::new('s'),
-            pattern_refs: Deduplicator::new('p'),
-            patterns: Deduplicator::new('t'),
+            tiling_refs: Deduplicator::new('p'),
+            tilings: Deduplicator::new('t'),
         }
     }
 
@@ -272,8 +272,8 @@ impl SVGRenderer {
         self.write_gradients();
         self.write_gradient_refs();
         self.write_subgradients();
-        self.write_patterns();
-        self.write_pattern_refs();
+        self.write_tilings();
+        self.write_tiling_refs();
         self.xml.end_document()
     }
 
diff --git a/crates/typst-svg/src/paint.rs b/crates/typst-svg/src/paint.rs
index 58348c94b..75ab41cdf 100644
--- a/crates/typst-svg/src/paint.rs
+++ b/crates/typst-svg/src/paint.rs
@@ -4,7 +4,7 @@ use ecow::{eco_format, EcoString};
 use ttf_parser::OutlineBuilder;
 use typst_library::foundations::Repr;
 use typst_library::layout::{Angle, Axes, Frame, Quadrant, Ratio, Size, Transform};
-use typst_library::visualize::{Color, FillRule, Gradient, Paint, Pattern, RatioOrAngle};
+use typst_library::visualize::{Color, FillRule, Gradient, Paint, RatioOrAngle, Tiling};
 use typst_utils::hash128;
 use xmlwriter::XmlWriter;
 
@@ -17,7 +17,7 @@ const CONIC_SEGMENT: usize = 360;
 
 impl SVGRenderer {
     /// Render a frame to a string.
-    pub(super) fn render_pattern_frame(
+    pub(super) fn render_tiling_frame(
         &mut self,
         state: State,
         ts: Transform,
@@ -44,8 +44,8 @@ impl SVGRenderer {
                 let id = self.push_gradient(gradient, size, ts);
                 self.xml.write_attribute_fmt("fill", format_args!("url(#{id})"));
             }
-            Paint::Pattern(pattern) => {
-                let id = self.push_pattern(pattern, size, ts);
+            Paint::Tiling(tiling) => {
+                let id = self.push_tiling(tiling, size, ts);
                 self.xml.write_attribute_fmt("fill", format_args!("url(#{id})"));
             }
         }
@@ -86,32 +86,31 @@ impl SVGRenderer {
             })
     }
 
-    pub(super) fn push_pattern(
+    pub(super) fn push_tiling(
         &mut self,
-        pattern: &Pattern,
+        tiling: &Tiling,
         size: Size,
         ts: Transform,
     ) -> Id {
-        let pattern_size = pattern.size() + pattern.spacing();
+        let tiling_size = tiling.size() + tiling.spacing();
         // Unfortunately due to a limitation of `xmlwriter`, we need to
         // render the frame twice: once to allocate all of the resources
         // that it needs and once to actually render it.
-        self.render_pattern_frame(
-            State::new(pattern_size, Transform::identity()),
+        self.render_tiling_frame(
+            State::new(tiling_size, Transform::identity()),
             Transform::identity(),
-            pattern.frame(),
+            tiling.frame(),
         );
 
-        let pattern_id = self.patterns.insert_with(hash128(pattern), || pattern.clone());
-        self.pattern_refs
-            .insert_with(hash128(&(pattern_id, ts)), || PatternRef {
-                id: pattern_id,
-                transform: ts,
-                ratio: Axes::new(
-                    Ratio::new(pattern_size.x.to_pt() / size.x.to_pt()),
-                    Ratio::new(pattern_size.y.to_pt() / size.y.to_pt()),
-                ),
-            })
+        let tiling_id = self.tilings.insert_with(hash128(tiling), || tiling.clone());
+        self.tiling_refs.insert_with(hash128(&(tiling_id, ts)), || TilingRef {
+            id: tiling_id,
+            transform: ts,
+            ratio: Axes::new(
+                Ratio::new(tiling_size.x.to_pt() / size.x.to_pt()),
+                Ratio::new(tiling_size.y.to_pt() / size.y.to_pt()),
+            ),
+        })
     }
 
     /// Write the raw gradients (without transform) to the SVG file.
@@ -188,12 +187,12 @@ impl SVGRenderer {
                         // Create the path for the segment.
                         let mut builder = SvgPathBuilder::default();
                         builder.move_to(
-                            correct_pattern_pos(center.0),
-                            correct_pattern_pos(center.1),
+                            correct_tiling_pos(center.0),
+                            correct_tiling_pos(center.1),
                         );
                         builder.line_to(
-                            correct_pattern_pos(-2.0 * (theta1 + angle).cos() + center.0),
-                            correct_pattern_pos(2.0 * (theta1 + angle).sin() + center.1),
+                            correct_tiling_pos(-2.0 * (theta1 + angle).cos() + center.0),
+                            correct_tiling_pos(2.0 * (theta1 + angle).sin() + center.1),
                         );
                         builder.arc(
                             (2.0, 2.0),
@@ -201,10 +200,10 @@ impl SVGRenderer {
                             0,
                             1,
                             (
-                                correct_pattern_pos(
+                                correct_tiling_pos(
                                     -2.0 * (theta2 + angle).cos() + center.0,
                                 ),
-                                correct_pattern_pos(
+                                correct_tiling_pos(
                                     2.0 * (theta2 + angle).sin() + center.1,
                                 ),
                             ),
@@ -370,19 +369,19 @@ impl SVGRenderer {
         self.xml.end_element();
     }
 
-    /// Write the raw gradients (without transform) to the SVG file.
-    pub(super) fn write_patterns(&mut self) {
-        if self.patterns.is_empty() {
+    /// Write the raw tilings (without transform) to the SVG file.
+    pub(super) fn write_tilings(&mut self) {
+        if self.tilings.is_empty() {
             return;
         }
 
         self.xml.start_element("defs");
-        self.xml.write_attribute("id", "patterns");
+        self.xml.write_attribute("id", "tilings");
 
-        for (id, pattern) in
-            self.patterns.iter().map(|(i, p)| (i, p.clone())).collect::<Vec<_>>()
+        for (id, tiling) in
+            self.tilings.iter().map(|(i, p)| (i, p.clone())).collect::<Vec<_>>()
         {
-            let size = pattern.size() + pattern.spacing();
+            let size = tiling.size() + tiling.spacing();
             self.xml.start_element("pattern");
             self.xml.write_attribute("id", &id);
             self.xml.write_attribute("width", &size.x.to_pt());
@@ -396,7 +395,7 @@ impl SVGRenderer {
             // Render the frame.
             let state = State::new(size, Transform::identity());
             let ts = Transform::identity();
-            self.render_frame(state, ts, pattern.frame());
+            self.render_frame(state, ts, tiling.frame());
 
             self.xml.end_element();
         }
@@ -404,28 +403,28 @@ impl SVGRenderer {
         self.xml.end_element()
     }
 
-    /// Writes the references to the deduplicated patterns for each usage site.
-    pub(super) fn write_pattern_refs(&mut self) {
-        if self.pattern_refs.is_empty() {
+    /// Writes the references to the deduplicated tilings for each usage site.
+    pub(super) fn write_tiling_refs(&mut self) {
+        if self.tiling_refs.is_empty() {
             return;
         }
 
         self.xml.start_element("defs");
-        self.xml.write_attribute("id", "pattern-refs");
-        for (id, pattern_ref) in self.pattern_refs.iter() {
+        self.xml.write_attribute("id", "tilings-refs");
+        for (id, tiling_ref) in self.tiling_refs.iter() {
             self.xml.start_element("pattern");
             self.xml
-                .write_attribute("patternTransform", &SvgMatrix(pattern_ref.transform));
+                .write_attribute("patternTransform", &SvgMatrix(tiling_ref.transform));
 
             self.xml.write_attribute("id", &id);
 
             // Writing the href attribute to the "reference" pattern.
             self.xml
-                .write_attribute_fmt("href", format_args!("#{}", pattern_ref.id));
+                .write_attribute_fmt("href", format_args!("#{}", tiling_ref.id));
 
             // Also writing the xlink:href attribute for compatibility.
             self.xml
-                .write_attribute_fmt("xlink:href", format_args!("#{}", pattern_ref.id));
+                .write_attribute_fmt("xlink:href", format_args!("#{}", tiling_ref.id));
             self.xml.end_element();
         }
 
@@ -433,15 +432,15 @@ impl SVGRenderer {
     }
 }
 
-/// A reference to a deduplicated pattern, with a transform matrix.
+/// A reference to a deduplicated tiling, with a transform matrix.
 ///
-/// Allows patterns to be reused across multiple invocations,
-/// simply by changing the transform matrix.
+/// Allows tilings to be reused across multiple invocations, simply by changing
+/// the transform matrix.
 #[derive(Hash)]
-pub struct PatternRef {
+pub struct TilingRef {
     /// The ID of the deduplicated gradient
     id: Id,
-    /// The transform matrix to apply to the pattern.
+    /// The transform matrix to apply to the tiling.
     transform: Transform,
     /// The ratio of the size of the cell to the size of the filled area.
     ratio: Axes<Ratio>,
@@ -587,7 +586,7 @@ impl ColorEncode for Color {
     }
 }
 
-/// Maps a coordinate in a unit size square to a coordinate in the pattern.
-pub fn correct_pattern_pos(x: f32) -> f32 {
+/// Maps a coordinate in a unit size square to a coordinate in the tiling.
+pub fn correct_tiling_pos(x: f32) -> f32 {
     (x + 0.5) / 2.0
 }
diff --git a/crates/typst-svg/src/shape.rs b/crates/typst-svg/src/shape.rs
index e188ed8ba..151049d69 100644
--- a/crates/typst-svg/src/shape.rs
+++ b/crates/typst-svg/src/shape.rs
@@ -67,8 +67,8 @@ impl SVGRenderer {
                 )
                 .post_concat(state.transform.invert().unwrap()),
             }
-        } else if let Paint::Pattern(pattern) = paint {
-            match pattern.unwrap_relative(false) {
+        } else if let Paint::Tiling(tiling) = paint {
+            match tiling.unwrap_relative(false) {
                 RelativeTo::Self_ => Transform::identity(),
                 RelativeTo::Parent => state.transform.invert().unwrap(),
             }
@@ -112,8 +112,8 @@ impl SVGRenderer {
                 let id = self.push_gradient(gradient, size, fill_transform);
                 self.xml.write_attribute_fmt("stroke", format_args!("url(#{id})"));
             }
-            Paint::Pattern(pattern) => {
-                let id = self.push_pattern(pattern, size, fill_transform);
+            Paint::Tiling(tiling) => {
+                let id = self.push_tiling(tiling, size, fill_transform);
                 self.xml.write_attribute_fmt("stroke", format_args!("url(#{id})"));
             }
         }
@@ -137,11 +137,11 @@ impl SVGRenderer {
         );
         self.xml
             .write_attribute("stroke-miterlimit", &stroke.miter_limit.get());
-        if let Some(pattern) = &stroke.dash {
-            self.xml.write_attribute("stroke-dashoffset", &pattern.phase.to_pt());
+        if let Some(dash) = &stroke.dash {
+            self.xml.write_attribute("stroke-dashoffset", &dash.phase.to_pt());
             self.xml.write_attribute(
                 "stroke-dasharray",
-                &pattern
+                &dash
                     .array
                     .iter()
                     .map(|dash| dash.to_pt().to_string())
diff --git a/crates/typst-svg/src/text.rs b/crates/typst-svg/src/text.rs
index 76cd53cb2..80de32089 100644
--- a/crates/typst-svg/src/text.rs
+++ b/crates/typst-svg/src/text.rs
@@ -165,7 +165,7 @@ impl SVGRenderer {
                 )
                 .post_concat(state.transform.invert().unwrap()),
             },
-            Paint::Pattern(pattern) => match pattern.unwrap_relative(true) {
+            Paint::Tiling(tiling) => match tiling.unwrap_relative(true) {
                 RelativeTo::Self_ => Transform::identity(),
                 RelativeTo::Parent => state.transform.invert().unwrap(),
             },
diff --git a/crates/typst-syntax/src/ast.rs b/crates/typst-syntax/src/ast.rs
index 34bd0110a..45d995a92 100644
--- a/crates/typst-syntax/src/ast.rs
+++ b/crates/typst-syntax/src/ast.rs
@@ -163,7 +163,7 @@ pub enum Expr<'a> {
     Parenthesized(Parenthesized<'a>),
     /// An array: `(1, "hi", 12cm)`.
     Array(Array<'a>),
-    /// A dictionary: `(thickness: 3pt, pattern: dashed)`.
+    /// A dictionary: `(thickness: 3pt, dash: "solid")`.
     Dict(Dict<'a>),
     /// A unary operation: `-x`.
     Unary(Unary<'a>),
@@ -1195,7 +1195,7 @@ impl<'a> AstNode<'a> for ArrayItem<'a> {
 }
 
 node! {
-    /// A dictionary: `(thickness: 3pt, pattern: dashed)`.
+    /// A dictionary: `(thickness: 3pt, dash: "solid")`.
     Dict
 }
 
diff --git a/crates/typst-syntax/src/kind.rs b/crates/typst-syntax/src/kind.rs
index a4456b9f4..0a7c160b4 100644
--- a/crates/typst-syntax/src/kind.rs
+++ b/crates/typst-syntax/src/kind.rs
@@ -224,7 +224,7 @@ pub enum SyntaxKind {
     Parenthesized,
     /// An array: `(1, "hi", 12cm)`.
     Array,
-    /// A dictionary: `(thickness: 3pt, pattern: dashed)`.
+    /// A dictionary: `(thickness: 3pt, dash: "solid")`.
     Dict,
     /// A named pair: `thickness: 3pt`.
     Named,
diff --git a/crates/typst-syntax/src/parser.rs b/crates/typst-syntax/src/parser.rs
index cb5e2dd85..6c1778c4a 100644
--- a/crates/typst-syntax/src/parser.rs
+++ b/crates/typst-syntax/src/parser.rs
@@ -1077,7 +1077,7 @@ fn expr_with_paren(p: &mut Parser, atomic: bool) {
 /// Parses either
 /// - a parenthesized expression: `(1 + 2)`, or
 /// - an array: `(1, "hi", 12cm)`, or
-/// - a dictionary: `(thickness: 3pt, pattern: dashed)`.
+/// - a dictionary: `(thickness: 3pt, dash: "solid")`.
 fn parenthesized_or_array_or_dict(p: &mut Parser) -> SyntaxKind {
     let mut state = GroupState {
         count: 0,
diff --git a/docs/changelog/0.10.0.md b/docs/changelog/0.10.0.md
index 0b17bea51..5a2a3dea3 100644
--- a/docs/changelog/0.10.0.md
+++ b/docs/changelog/0.10.0.md
@@ -31,7 +31,7 @@ description: Changes in Typst 0.10.0
 - More LaTeX commands (e.g. for quotes) are now respected in `.bib` files
 
 ## Visualization
-- Added support for [patterns]($pattern) as fills and strokes
+- Added support for [patterns]($tiling) as fills and strokes
 - The `alpha` parameter of the [`components`]($color.components) function on
   colors is now a named parameter **(Breaking change)**
 - Added support for the [Oklch]($color.oklch) color space
diff --git a/docs/changelog/0.11.1.md b/docs/changelog/0.11.1.md
index 3269c5586..e045914b5 100644
--- a/docs/changelog/0.11.1.md
+++ b/docs/changelog/0.11.1.md
@@ -37,7 +37,7 @@ description: Changes in Typst 0.11.1
 
 ## Export
 - Fixed [smart quotes]($smartquote) in PDF outline
-- Fixed [patterns]($pattern) with spacing in PDF
+- Fixed [patterns]($tiling) with spacing in PDF
 - Fixed wrong PDF page labels when [page numbering]($page.numbering) was
   disabled after being previously enabled
 
diff --git a/docs/guides/tables.md b/docs/guides/tables.md
index d59073678..5c9cf11da 100644
--- a/docs/guides/tables.md
+++ b/docs/guides/tables.md
@@ -226,7 +226,7 @@ applications, while academic applications tend to use strokes instead.
 To add zebra stripes to a table, we use the `table` function's `fill` argument.
 It can take three kinds of arguments:
 
-- A single color (this can also be a gradient or a pattern) to fill all cells
+- A single color (this can also be a gradient or a tiling) to fill all cells
   with. Because we want some cells to have another color, this is not useful if
   we want to build zebra tables.
 - An array with colors which Typst cycles through for each column. We can use an
@@ -828,7 +828,7 @@ line appears because there is no `top` line that could suppress it.
 
 ### How to achieve a double line? { #double-stroke }
 Typst does not yet have a native way to draw double strokes, but there are
-multiple ways to emulate them, for example with [patterns]($pattern). We will
+multiple ways to emulate them, for example with [tilings]($tiling). We will
 show a different workaround in this section: Table gutters.
 
 Tables can space their cells apart using the `gutter` argument. When a gutter is
diff --git a/tests/ref/grid-stroke-pattern.png b/tests/ref/grid-stroke-tiling.png
similarity index 100%
rename from tests/ref/grid-stroke-pattern.png
rename to tests/ref/grid-stroke-tiling.png
diff --git a/tests/ref/pattern-line.png b/tests/ref/tiling-line.png
similarity index 100%
rename from tests/ref/pattern-line.png
rename to tests/ref/tiling-line.png
diff --git a/tests/ref/pattern-lines.png b/tests/ref/tiling-lines.png
similarity index 100%
rename from tests/ref/pattern-lines.png
rename to tests/ref/tiling-lines.png
diff --git a/tests/ref/tiling-pattern-compatibility.png b/tests/ref/tiling-pattern-compatibility.png
new file mode 100644
index 0000000000000000000000000000000000000000..b891b6d7ccc8649f064968a63b5166411845ef0e
GIT binary patch
literal 125
zcmeAS@N?(olHy`uVBq!ia0vp^Mj*@qBp9qiuIB<N7f%<*kcwMxFD~R|FkoPE{1)F7
zn0aYQ#s$_=wyz8hcb{%5zPT}DdDAQYkopC`m~GvSjz%nt$oLvw4@Li1)-#xSzHc=@
RukQph*VEO{Wt~$(698N?EhPW|

literal 0
HcmV?d00001

diff --git a/tests/ref/pattern-relative-parent.png b/tests/ref/tiling-relative-parent.png
similarity index 100%
rename from tests/ref/pattern-relative-parent.png
rename to tests/ref/tiling-relative-parent.png
diff --git a/tests/ref/pattern-relative-self.png b/tests/ref/tiling-relative-self.png
similarity index 100%
rename from tests/ref/pattern-relative-self.png
rename to tests/ref/tiling-relative-self.png
diff --git a/tests/ref/pattern-small.png b/tests/ref/tiling-small.png
similarity index 100%
rename from tests/ref/pattern-small.png
rename to tests/ref/tiling-small.png
diff --git a/tests/ref/pattern-spacing-negative.png b/tests/ref/tiling-spacing-negative.png
similarity index 100%
rename from tests/ref/pattern-spacing-negative.png
rename to tests/ref/tiling-spacing-negative.png
diff --git a/tests/ref/pattern-spacing-positive.png b/tests/ref/tiling-spacing-positive.png
similarity index 100%
rename from tests/ref/pattern-spacing-positive.png
rename to tests/ref/tiling-spacing-positive.png
diff --git a/tests/ref/pattern-spacing-zero.png b/tests/ref/tiling-spacing-zero.png
similarity index 100%
rename from tests/ref/pattern-spacing-zero.png
rename to tests/ref/tiling-spacing-zero.png
diff --git a/tests/ref/pattern-stroke-relative-parent.png b/tests/ref/tiling-stroke-relative-parent.png
similarity index 100%
rename from tests/ref/pattern-stroke-relative-parent.png
rename to tests/ref/tiling-stroke-relative-parent.png
diff --git a/tests/ref/pattern-stroke.png b/tests/ref/tiling-stroke.png
similarity index 100%
rename from tests/ref/pattern-stroke.png
rename to tests/ref/tiling-stroke.png
diff --git a/tests/ref/pattern-text.png b/tests/ref/tiling-text.png
similarity index 100%
rename from tests/ref/pattern-text.png
rename to tests/ref/tiling-text.png
diff --git a/tests/suite/layout/grid/stroke.typ b/tests/suite/layout/grid/stroke.typ
index 3a26b69af..4e81d549e 100644
--- a/tests/suite/layout/grid/stroke.typ
+++ b/tests/suite/layout/grid/stroke.typ
@@ -1,5 +1,5 @@
---- grid-stroke-pattern ---
-#let double-line = pattern(size: (1.5pt, 1.5pt), {
+--- grid-stroke-tiling ---
+#let double-line = tiling(size: (1.5pt, 1.5pt), {
   place(line(stroke: .6pt, start: (0%, 50%), end: (100%, 50%)))
 })
 
diff --git a/tests/suite/layout/table.typ b/tests/suite/layout/table.typ
index fe138f60a..f59d8b424 100644
--- a/tests/suite/layout/table.typ
+++ b/tests/suite/layout/table.typ
@@ -17,7 +17,7 @@
 #table(columns: 3, stroke: none, fill: green, [A], [B], [C])
 
 --- table-fill-bad ---
-// Error: 14-19 expected color, gradient, pattern, none, array, or function, found string
+// Error: 14-19 expected color, gradient, tiling, none, array, or function, found string
 #table(fill: "hey")
 
 --- table-align-array ---
diff --git a/tests/suite/text/font.typ b/tests/suite/text/font.typ
index 5c972ff32..bb75f4ae7 100644
--- a/tests/suite/text/font.typ
+++ b/tests/suite/text/font.typ
@@ -84,7 +84,7 @@ I
 
 --- issue-5499-text-fill-in-clip-block ---
 
-#let pat = pattern(
+#let t = tiling(
   size: (30pt, 30pt),
   relative: "parent",
   square(
@@ -101,7 +101,7 @@ I
   [ ]
   text(fill: gradient.linear(..color.map.rainbow), "Hello")
   [ ]
-  text(fill: pat, "Hello")
+  text(fill: t, "Hello")
 })
 #block(clip: true, height: 2em, {
   text(fill: blue, "Hello")
@@ -110,5 +110,5 @@ I
   [ ]
   text(fill: gradient.linear(..color.map.rainbow), "Hello")
   [ ]
-  text(fill: pat, "Hello")
+  text(fill: t, "Hello")
 })
diff --git a/tests/suite/visualize/gradient.typ b/tests/suite/visualize/gradient.typ
index d66241f78..b221f411d 100644
--- a/tests/suite/visualize/gradient.typ
+++ b/tests/suite/visualize/gradient.typ
@@ -390,7 +390,7 @@
 --- gradient-text-bad-relative ---
 // Make sure they don't work when `relative: "self"`.
 // Hint: 17-61 make sure to set `relative: auto` on your text fill
-// Error: 17-61 gradients and patterns on text must be relative to the parent
+// Error: 17-61 gradients and tilings on text must be relative to the parent
 #set text(fill: gradient.linear(red, blue, relative: "self"))
 
 --- gradient-text-global ---
diff --git a/tests/suite/visualize/pattern.typ b/tests/suite/visualize/pattern.typ
deleted file mode 100644
index b87b77559..000000000
--- a/tests/suite/visualize/pattern.typ
+++ /dev/null
@@ -1,159 +0,0 @@
-// Test patterns.
-
---- pattern-line ---
-// Tests that simple patterns work.
-#set page(width: auto, height: auto, margin: 0pt)
-#let pat = pattern(size: (10pt, 10pt), line(stroke: 4pt, start: (0%, 0%), end: (100%, 100%)))
-#rect(width: 50pt, height: 50pt, fill: pat)
-
---- pattern-lines ---
-#set page(width: auto, height: auto, margin: 0pt)
-
-#let pat = pattern(size: (10pt, 10pt), {
-    place(line(stroke: 4pt, start: (0%, 0%), end: (100%, 100%)))
-    place(line(stroke: 4pt, start: (100%,0%), end: (200%, 100%)))
-    place(line(stroke: 4pt, start: (0%,100%), end: (100%, 200%)))
-    place(line(stroke: 4pt, start: (-100%,0%), end: (0%, 100%)))
-    place(line(stroke: 4pt, start: (0%,-100%), end: (100%, 0%)))
-})
-#rect(width: 50pt, height: 50pt, fill: pat)
-
---- pattern-relative-self ---
-// Test with relative set to `"self"`
-#let pat(..args) = pattern(size: (30pt, 30pt), ..args)[
-  #set line(stroke: green)
-  #place(top + left, line(start: (0%, 0%), end: (100%, 100%), stroke: 1pt))
-  #place(top + left, line(start: (0%, 100%), end: (100%, 0%), stroke: 1pt))
-]
-
-#set page(fill: pat(), width: 100pt, height: 100pt)
-#rect(
-  width: 100%,
-  height: 100%,
-  fill: pat(relative: "self"),
-  stroke: 1pt + green,
-)
-
---- pattern-relative-parent ---
-// Test with relative set to `"parent"`
-#let pat(fill, ..args) = pattern(size: (30pt, 30pt), ..args)[
-  #rect(width: 100%, height: 100%, fill: fill, stroke: none)
-  #place(top + left, line(start: (0%, 0%), end: (100%, 100%), stroke: 1pt))
-  #place(top + left, line(start: (0%, 100%), end: (100%, 0%), stroke: 1pt))
-]
-
-#set page(fill: pat(white), width: 100pt, height: 100pt)
-
-#rect(fill: pat(none, relative: "parent"), width: 100%, height: 100%, stroke: 1pt)
-
---- pattern-small ---
-// Tests small patterns for pixel accuracy.
-#box(
-  width: 8pt,
-  height: 1pt,
-  fill: pattern(size: (1pt, 1pt), square(size: 1pt, fill: black))
-)
-#v(-1em)
-#box(
-  width: 8pt,
-  height: 1pt,
-  fill: pattern(size: (2pt, 1pt), square(size: 1pt, fill: black))
-)
-
---- pattern-zero-sized ---
-// Error: 15-52 pattern tile size must be non-zero
-// Hint: 15-52 try setting the size manually
-#line(stroke: pattern(path((0pt, 0pt), (1em, 0pt))))
-
---- pattern-spacing-negative ---
-// Test with spacing set to `(-10pt, -10pt)`
-#let pat(..args) = pattern(size: (30pt, 30pt), ..args)[
-  #square(width: 100%, height: 100%, stroke: 1pt, fill: blue)
-]
-
-#set page(width: 100pt, height: 100pt)
-
-#rect(fill: pat(spacing: (-10pt, -10pt)), width: 100%, height: 100%, stroke: 1pt)
-
---- pattern-spacing-zero ---
-// Test with spacing set to `(0pt, 0pt)`
-#let pat(..args) = pattern(size: (30pt, 30pt), ..args)[
-  #square(width: 100%, height: 100%, stroke: 1pt, fill: blue)
-]
-
-#set page(width: 100pt, height: 100pt)
-
-#rect(fill: pat(spacing: (0pt, 0pt)), width: 100%, height: 100%, stroke: 1pt)
-
---- pattern-spacing-positive ---
-// Test with spacing set to `(10pt, 10pt)`
-#let pat(..args) = pattern(size: (30pt, 30pt), ..args)[
-  #square(width: 100%, height: 100%, stroke: 1pt, fill: blue)
-]
-
-#set page(width: 100pt, height: 100pt)
-
-#rect(fill: pat(spacing: (10pt, 10pt,)), width: 100%, height: 100%, stroke: 1pt)
-
---- pattern-stroke ---
-// Test pattern on strokes
-#align(
-  center + top,
-  square(
-    size: 50pt,
-    fill: pattern(
-      size: (5pt, 5pt),
-      align(horizon + center, circle(fill: blue, radius: 2.5pt))
-    ),
-    stroke: 7.5pt + pattern(
-      size: (5pt, 5pt),
-      align(horizon + center, circle(fill: red, radius: 2.5pt))
-    )
-  )
-)
-
---- pattern-stroke-relative-parent ---
-// Test pattern on strokes with relative set to `"parent"`
-// The pattern on the circle should align with the pattern on the square.
-#align(
-  center + top,
-  block(
-    width: 50pt,
-    height: 50pt,
-    fill: pattern(size: (5pt, 5pt), circle(radius: 2.5pt, fill: blue)),
-    align(center + horizon, circle(
-      radius: 15pt,
-      stroke: 7.5pt + pattern(
-        size: (5pt, 5pt), circle(radius: 2.5pt, fill: red), relative: "parent"
-      ),
-    ))
-  )
-)
-
---- pattern-text ---
-// Test a pattern on some text
-// You shouldn't be able to see the text, if you can then
-// that means that the transform matrices are not being
-// applied to the text correctly.
-#let pat = pattern(
-  size: (30pt, 30pt),
-  relative: "parent",
-  square(size: 30pt, fill: gradient.conic(..color.map.rainbow))
-);
-
-#set page(
-  width: 140pt,
-  height: 140pt,
-  fill: pat
-)
-
-#rotate(45deg, scale(x: 50%, y: 70%, rect(
-  width: 100%,
-  height: 100%,
-  stroke: 1pt,
-)[
-  #lorem(10)
-
-  #set text(fill: pat)
-  #lorem(10)
-]))
diff --git a/tests/suite/visualize/rect.typ b/tests/suite/visualize/rect.typ
index 5dfe29f3f..a659287e7 100644
--- a/tests/suite/visualize/rect.typ
+++ b/tests/suite/visualize/rect.typ
@@ -55,7 +55,7 @@
 #rect(width: 20pt, height: 20pt, stroke: (thickness: 5pt, join: "round"))
 
 --- red-stroke-bad-type ---
-// Error: 15-21 expected length, color, gradient, pattern, dictionary, stroke, none, or auto, found array
+// Error: 15-21 expected length, color, gradient, tiling, dictionary, stroke, none, or auto, found array
 #rect(stroke: (1, 2))
 
 --- rect-fill-stroke ---
diff --git a/tests/suite/visualize/tiling.typ b/tests/suite/visualize/tiling.typ
new file mode 100644
index 000000000..5272328dc
--- /dev/null
+++ b/tests/suite/visualize/tiling.typ
@@ -0,0 +1,163 @@
+// Test tilings.
+
+--- tiling-line ---
+// Tests that simple tilings work.
+#set page(width: auto, height: auto, margin: 0pt)
+#let t = tiling(size: (10pt, 10pt), line(stroke: 4pt, start: (0%, 0%), end: (100%, 100%)))
+#rect(width: 50pt, height: 50pt, fill: t)
+
+--- tiling-lines ---
+#set page(width: auto, height: auto, margin: 0pt)
+
+#let t = tiling(size: (10pt, 10pt), {
+    place(line(stroke: 4pt, start: (0%, 0%), end: (100%, 100%)))
+    place(line(stroke: 4pt, start: (100%,0%), end: (200%, 100%)))
+    place(line(stroke: 4pt, start: (0%,100%), end: (100%, 200%)))
+    place(line(stroke: 4pt, start: (-100%,0%), end: (0%, 100%)))
+    place(line(stroke: 4pt, start: (0%,-100%), end: (100%, 0%)))
+})
+#rect(width: 50pt, height: 50pt, fill: t)
+
+--- tiling-relative-self ---
+// Test with relative set to `"self"`
+#let t(..args) = tiling(size: (30pt, 30pt), ..args)[
+  #set line(stroke: green)
+  #place(top + left, line(start: (0%, 0%), end: (100%, 100%), stroke: 1pt))
+  #place(top + left, line(start: (0%, 100%), end: (100%, 0%), stroke: 1pt))
+]
+
+#set page(fill: t(), width: 100pt, height: 100pt)
+#rect(
+  width: 100%,
+  height: 100%,
+  fill: t(relative: "self"),
+  stroke: 1pt + green,
+)
+
+--- tiling-relative-parent ---
+// Test with relative set to `"parent"`
+#let t(fill, ..args) = tiling(size: (30pt, 30pt), ..args)[
+  #rect(width: 100%, height: 100%, fill: fill, stroke: none)
+  #place(top + left, line(start: (0%, 0%), end: (100%, 100%), stroke: 1pt))
+  #place(top + left, line(start: (0%, 100%), end: (100%, 0%), stroke: 1pt))
+]
+
+#set page(fill: t(white), width: 100pt, height: 100pt)
+
+#rect(fill: t(none, relative: "parent"), width: 100%, height: 100%, stroke: 1pt)
+
+--- tiling-small ---
+// Tests small tilings for pixel accuracy.
+#box(
+  width: 8pt,
+  height: 1pt,
+  fill: tiling(size: (1pt, 1pt), square(size: 1pt, fill: black))
+)
+#v(-1em)
+#box(
+  width: 8pt,
+  height: 1pt,
+  fill: tiling(size: (2pt, 1pt), square(size: 1pt, fill: black))
+)
+
+--- tiling-zero-sized ---
+// Error: 15-51 tile size must be non-zero
+// Hint: 15-51 try setting the size manually
+#line(stroke: tiling(path((0pt, 0pt), (1em, 0pt))))
+
+--- tiling-spacing-negative ---
+// Test with spacing set to `(-10pt, -10pt)`
+#let t(..args) = tiling(size: (30pt, 30pt), ..args)[
+  #square(width: 100%, height: 100%, stroke: 1pt, fill: blue)
+]
+
+#set page(width: 100pt, height: 100pt)
+
+#rect(fill: t(spacing: (-10pt, -10pt)), width: 100%, height: 100%, stroke: 1pt)
+
+--- tiling-spacing-zero ---
+// Test with spacing set to `(0pt, 0pt)`
+#let t(..args) = tiling(size: (30pt, 30pt), ..args)[
+  #square(width: 100%, height: 100%, stroke: 1pt, fill: blue)
+]
+
+#set page(width: 100pt, height: 100pt)
+
+#rect(fill: t(spacing: (0pt, 0pt)), width: 100%, height: 100%, stroke: 1pt)
+
+--- tiling-spacing-positive ---
+// Test with spacing set to `(10pt, 10pt)`
+#let t(..args) = tiling(size: (30pt, 30pt), ..args)[
+  #square(width: 100%, height: 100%, stroke: 1pt, fill: blue)
+]
+
+#set page(width: 100pt, height: 100pt)
+
+#rect(fill: t(spacing: (10pt, 10pt,)), width: 100%, height: 100%, stroke: 1pt)
+
+--- tiling-stroke ---
+// Test tiling on strokes
+#align(
+  center + top,
+  square(
+    size: 50pt,
+    fill: tiling(
+      size: (5pt, 5pt),
+      align(horizon + center, circle(fill: blue, radius: 2.5pt))
+    ),
+    stroke: 7.5pt + tiling(
+      size: (5pt, 5pt),
+      align(horizon + center, circle(fill: red, radius: 2.5pt))
+    )
+  )
+)
+
+--- tiling-stroke-relative-parent ---
+// Test tiling on strokes with relative set to `"parent"`
+// The tiling on the circle should align with the tiling on the square.
+#align(
+  center + top,
+  block(
+    width: 50pt,
+    height: 50pt,
+    fill: tiling(size: (5pt, 5pt), circle(radius: 2.5pt, fill: blue)),
+    align(center + horizon, circle(
+      radius: 15pt,
+      stroke: 7.5pt + tiling(
+        size: (5pt, 5pt), circle(radius: 2.5pt, fill: red), relative: "parent"
+      ),
+    ))
+  )
+)
+
+--- tiling-text ---
+// Test a tiling on some text. You shouldn't be able to see the text, if you can
+// then that means that the transform matrices are not being applied to the text
+// correctly.
+#let t = tiling(
+  size: (30pt, 30pt),
+  relative: "parent",
+  square(size: 30pt, fill: gradient.conic(..color.map.rainbow))
+);
+
+#set page(
+  width: 140pt,
+  height: 140pt,
+  fill: t
+)
+
+#rotate(45deg, scale(x: 50%, y: 70%, rect(
+  width: 100%,
+  height: 100%,
+  stroke: 1pt,
+)[
+  #lorem(10)
+
+  #set text(fill: t)
+  #lorem(10)
+]))
+
+--- tiling-pattern-compatibility ---
+#set page(width: auto, height: auto, margin: 0pt)
+#let t = pattern(size: (10pt, 10pt), line(stroke: 4pt, start: (0%, 0%), end: (100%, 100%)))
+#rect(width: 50pt, height: 50pt, fill: t)

From 60f246ece2a088a802759975f68745f29bef8deb Mon Sep 17 00:00:00 2001
From: PgBiel <9021226+PgBiel@users.noreply.github.com>
Date: Tue, 17 Dec 2024 06:41:18 -0300
Subject: [PATCH 09/10] Fix sticky blocks at the top of blocks and pages
 (#5581)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-layout/src/flow/distribute.rs    |  49 +++++++++++++++---
 ...ssue-5296-block-sticky-in-block-at-top.png | Bin 0 -> 277 bytes
 ...6-block-sticky-spaced-from-top-of-page.png | Bin 0 -> 277 bytes
 ...-sticky-weakly-spaced-from-top-of-page.png | Bin 0 -> 236 bytes
 tests/suite/layout/container.typ              |  25 +++++++++
 5 files changed, 67 insertions(+), 7 deletions(-)
 create mode 100644 tests/ref/issue-5296-block-sticky-in-block-at-top.png
 create mode 100644 tests/ref/issue-5296-block-sticky-spaced-from-top-of-page.png
 create mode 100644 tests/ref/issue-5296-block-sticky-weakly-spaced-from-top-of-page.png

diff --git a/crates/typst-layout/src/flow/distribute.rs b/crates/typst-layout/src/flow/distribute.rs
index 7a1cf4264..f504d22e7 100644
--- a/crates/typst-layout/src/flow/distribute.rs
+++ b/crates/typst-layout/src/flow/distribute.rs
@@ -17,7 +17,7 @@ pub fn distribute(composer: &mut Composer, regions: Regions) -> FlowResult<Frame
         regions,
         items: vec![],
         sticky: None,
-        stickable: false,
+        stickable: None,
     };
     let init = distributor.snapshot();
     let forced = match distributor.run() {
@@ -42,9 +42,26 @@ struct Distributor<'a, 'b, 'x, 'y, 'z> {
     /// A snapshot which can be restored to migrate a suffix of sticky blocks to
     /// the next region.
     sticky: Option<DistributionSnapshot<'a, 'b>>,
-    /// Whether there was at least one proper block. Otherwise, sticky blocks
-    /// are disabled (or else they'd keep being migrated).
-    stickable: bool,
+    /// Whether the current group of consecutive sticky blocks are still sticky
+    /// and may migrate with the attached frame. This is `None` while we aren't
+    /// processing sticky blocks. On the first sticky block, this will become
+    /// `Some(true)` if migrating sticky blocks as usual would make a
+    /// difference - this is given by `regions.may_progress()`. Otherwise, it
+    /// is set to `Some(false)`, which is usually the case when the first
+    /// sticky block in the group is at the very top of the page (then,
+    /// migrating it would just lead us back to the top of the page, leading
+    /// to an infinite loop). In that case, all sticky blocks of the group are
+    /// also disabled, until this is reset to `None` on the first non-sticky
+    /// frame we find.
+    ///
+    /// While this behavior of disabling stickiness of sticky blocks at the
+    /// very top of the page may seem non-ideal, it is only problematic (that
+    /// is, may lead to orphaned sticky blocks / headings) if the combination
+    /// of 'sticky blocks + attached frame' doesn't fit in one page, in which
+    /// case there is nothing Typst can do to improve the situation, as sticky
+    /// blocks are supposed to always be in the same page as the subsequent
+    /// frame, but that is impossible in that case, which is thus pathological.
+    stickable: Option<bool>,
 }
 
 /// A snapshot of the distribution state.
@@ -314,13 +331,31 @@ impl<'a, 'b> Distributor<'a, 'b, '_, '_, '_> {
             // If the frame is sticky and we haven't remembered a preceding
             // sticky element, make a checkpoint which we can restore should we
             // end on this sticky element.
-            if self.stickable && self.sticky.is_none() {
+            //
+            // The first sticky block within consecutive sticky blocks
+            // determines whether this group of sticky blocks has stickiness
+            // disabled or not.
+            //
+            // The criteria used here is: if migrating this group of sticky
+            // blocks together with the "attached" block can't improve the lack
+            // of space, since we're at the start of the region, then we don't
+            // do so, and stickiness is disabled (at least, for this region).
+            // Otherwise, migration is allowed.
+            //
+            // Note that, since the whole region is checked, this ensures sticky
+            // blocks at the top of a block - but not necessarily of the page -
+            // can still be migrated.
+            if self.sticky.is_none()
+                && *self.stickable.get_or_insert_with(|| self.regions.may_progress())
+            {
                 self.sticky = Some(self.snapshot());
             }
         } else if !frame.is_empty() {
-            // If the frame isn't sticky, we can forget a previous snapshot.
-            self.stickable = true;
+            // If the frame isn't sticky, we can forget a previous snapshot. We
+            // interrupt a group of sticky blocks, if there was one, so we reset
+            // the saved stickable check for the next group of sticky blocks.
             self.sticky = None;
+            self.stickable = None;
         }
 
         // Handle footnotes.
diff --git a/tests/ref/issue-5296-block-sticky-in-block-at-top.png b/tests/ref/issue-5296-block-sticky-in-block-at-top.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad0ace76f3b1919c07b1efd8b38f75faa1063f40
GIT binary patch
literal 277
zcmeAS@N?(olHy`uVBq!ia0vp^6+pb214uA*EM@NpQg=LE978H@y}jbNsxeXIc;ffI
z_e^V^-&_BViAT4oamtw<mDHRCQ&c4k43*W^ICxD=Qd7Q|E&QwR;OE;1F2B68e?pU1
z!@&dt2_Cj)+|)VtzEk}N6F%&IP%SVgH2FbfSWU};t#7}pFx~sl-~E(h$4<Mg^?5%J
zKM(S1Utjm{!-DPpm-F6d>^zWQ@T2%)m@>z_@TLc$sg<3L_2xJAo;@;o!E*3zA<Ld0
m(pTpTez1+z6~|)#&o4}$3VkBOKYzah@~@|>pUXO@geCw|&~}*s

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-5296-block-sticky-spaced-from-top-of-page.png b/tests/ref/issue-5296-block-sticky-spaced-from-top-of-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..ad0ace76f3b1919c07b1efd8b38f75faa1063f40
GIT binary patch
literal 277
zcmeAS@N?(olHy`uVBq!ia0vp^6+pb214uA*EM@NpQg=LE978H@y}jbNsxeXIc;ffI
z_e^V^-&_BViAT4oamtw<mDHRCQ&c4k43*W^ICxD=Qd7Q|E&QwR;OE;1F2B68e?pU1
z!@&dt2_Cj)+|)VtzEk}N6F%&IP%SVgH2FbfSWU};t#7}pFx~sl-~E(h$4<Mg^?5%J
zKM(S1Utjm{!-DPpm-F6d>^zWQ@T2%)m@>z_@TLc$sg<3L_2xJAo;@;o!E*3zA<Ld0
m(pTpTez1+z6~|)#&o4}$3VkBOKYzah@~@|>pUXO@geCw|&~}*s

literal 0
HcmV?d00001

diff --git a/tests/ref/issue-5296-block-sticky-weakly-spaced-from-top-of-page.png b/tests/ref/issue-5296-block-sticky-weakly-spaced-from-top-of-page.png
new file mode 100644
index 0000000000000000000000000000000000000000..9bcdbe569a54673aac2291453d9e1ec4cc3ded5c
GIT binary patch
literal 236
zcmeAS@N?(olHy`uVBq!ia0vp^6+j%y0VEif+txn=Qky+p978H@y}h!L^H6|<>%)w<
z3^U#3EgF_OA8}&YxS307$u<s-zJ!Ina~JjcDL6R@ZV_HR;X`_NxwA!iWB=_r2VA%t
z8XIS`Jy*KXYx3b>Yb%S~{oB^8bG}}G7{GXb-TNJ%zw_6#rJcWa%6^X8%(v4|b{8=+
zGc#WopXcxT!BFVn^cR1w9=JQZIzujcm%zb~VT|*uW_zw|DE=L&mw*-6uV#3cKJ#Yo
R$2PDxJYD@<);T3K0RR@2Vfp|7

literal 0
HcmV?d00001

diff --git a/tests/suite/layout/container.typ b/tests/suite/layout/container.typ
index 799300f0d..9948a00e3 100644
--- a/tests/suite/layout/container.typ
+++ b/tests/suite/layout/container.typ
@@ -279,3 +279,28 @@ First!
 // Test box in 100% width block.
 #block(width: 100%, fill: red, box("a box"))
 #block(width: 100%, fill: red, [#box("a box") #box()])
+
+--- issue-5296-block-sticky-in-block-at-top ---
+#set page(height: 3cm)
+#v(1.6cm)
+#block(height: 2cm, breakable: true)[
+  #block(sticky: true)[*A*]
+
+  b
+]
+
+--- issue-5296-block-sticky-spaced-from-top-of-page ---
+#set page(height: 3cm)
+#v(2cm)
+
+#block(sticky: true)[*A*]
+
+b
+
+--- issue-5296-block-sticky-weakly-spaced-from-top-of-page ---
+#set page(height: 3cm)
+#v(2cm, weak: true)
+
+#block(sticky: true)[*A*]
+
+b

From 54cee16c3128695089d7472451f02646c6d81521 Mon Sep 17 00:00:00 2001
From: Zhuofeng Wang <35804928+wzf03@users.noreply.github.com>
Date: Tue, 17 Dec 2024 17:43:01 +0800
Subject: [PATCH 10/10] Add timezone to PDF's default timestamp. (#5564)

Co-authored-by: Laurenz <laurmaedje@gmail.com>
---
 crates/typst-cli/src/compile.rs | 26 +++++++---
 crates/typst-pdf/src/catalog.rs | 47 +++++++++++++----
 crates/typst-pdf/src/lib.rs     | 89 +++++++++++++++++++++++++++++++--
 3 files changed, 144 insertions(+), 18 deletions(-)

diff --git a/crates/typst-cli/src/compile.rs b/crates/typst-cli/src/compile.rs
index 3aa3aa3b9..adeef0f2d 100644
--- a/crates/typst-cli/src/compile.rs
+++ b/crates/typst-cli/src/compile.rs
@@ -17,7 +17,7 @@ use typst::html::HtmlDocument;
 use typst::layout::{Frame, Page, PageRanges, PagedDocument};
 use typst::syntax::{FileId, Source, Span};
 use typst::WorldExt;
-use typst_pdf::{PdfOptions, PdfStandards};
+use typst_pdf::{PdfOptions, PdfStandards, Timestamp};
 
 use crate::args::{
     CompileArgs, CompileCommand, DiagnosticFormat, Input, Output, OutputFormat,
@@ -55,7 +55,7 @@ pub struct CompileConfig {
     pub output_format: OutputFormat,
     /// Which pages to export.
     pub pages: Option<PageRanges>,
-    /// The document's creation date formatted as a UNIX timestamp.
+    /// The document's creation date formatted as a UNIX timestamp, with UTC suffix.
     pub creation_timestamp: Option<DateTime<Utc>>,
     /// The format to emit diagnostics in.
     pub diagnostic_format: DiagnosticFormat,
@@ -271,11 +271,23 @@ fn export_paged(document: &PagedDocument, config: &CompileConfig) -> SourceResul
 
 /// Export to a PDF.
 fn export_pdf(document: &PagedDocument, config: &CompileConfig) -> SourceResult<()> {
+    // If the timestamp is provided through the CLI, use UTC suffix,
+    // else, use the current local time and timezone.
+    let timestamp = match config.creation_timestamp {
+        Some(timestamp) => convert_datetime(timestamp).map(Timestamp::new_utc),
+        None => {
+            let local_datetime = chrono::Local::now();
+            convert_datetime(local_datetime).and_then(|datetime| {
+                Timestamp::new_local(
+                    datetime,
+                    local_datetime.offset().local_minus_utc() / 60,
+                )
+            })
+        }
+    };
     let options = PdfOptions {
         ident: Smart::Auto,
-        timestamp: convert_datetime(
-            config.creation_timestamp.unwrap_or_else(chrono::Utc::now),
-        ),
+        timestamp,
         page_ranges: config.pages.clone(),
         standards: config.pdf_standards.clone(),
     };
@@ -289,7 +301,9 @@ fn export_pdf(document: &PagedDocument, config: &CompileConfig) -> SourceResult<
 }
 
 /// Convert [`chrono::DateTime`] to [`Datetime`]
-fn convert_datetime(date_time: chrono::DateTime<chrono::Utc>) -> Option<Datetime> {
+fn convert_datetime<Tz: chrono::TimeZone>(
+    date_time: chrono::DateTime<Tz>,
+) -> Option<Datetime> {
     Datetime::from_ymd_hms(
         date_time.year(),
         date_time.month().try_into().ok()?,
diff --git a/crates/typst-pdf/src/catalog.rs b/crates/typst-pdf/src/catalog.rs
index 753b8cb6b..c4b0e2e83 100644
--- a/crates/typst-pdf/src/catalog.rs
+++ b/crates/typst-pdf/src/catalog.rs
@@ -9,10 +9,10 @@ use typst_library::foundations::{Datetime, Smart};
 use typst_library::layout::Dir;
 use typst_library::text::Lang;
 use typst_syntax::Span;
-use xmp_writer::{DateTime, LangId, RenditionClass, Timezone, XmpWriter};
+use xmp_writer::{DateTime, LangId, RenditionClass, XmpWriter};
 
 use crate::page::PdfPageLabel;
-use crate::{hash_base64, outline, TextStrExt, WithEverything};
+use crate::{hash_base64, outline, TextStrExt, Timezone, WithEverything};
 
 /// Write the document catalog.
 pub fn write_catalog(
@@ -87,8 +87,17 @@ pub fn write_catalog(
         xmp.pdf_keywords(&joined);
     }
 
-    let date = ctx.document.info.date.unwrap_or(ctx.options.timestamp);
-    let tz = ctx.document.info.date.is_auto();
+    // (1) If the `document.date` is set to specific `datetime` or `none`, use it.
+    // (2) If the `document.date` is set to `auto` or not set, try to use the
+    //     date from the options.
+    // (3) Otherwise, we don't write date metadata.
+    let (date, tz) = match (ctx.document.info.date, ctx.options.timestamp) {
+        (Smart::Custom(date), _) => (date, None),
+        (Smart::Auto, Some(timestamp)) => {
+            (Some(timestamp.datetime), Some(timestamp.timezone))
+        }
+        _ => (None, None),
+    };
     if let Some(date) = date {
         if let Some(pdf_date) = pdf_date(date, tz) {
             info.creation_date(pdf_date);
@@ -281,7 +290,7 @@ pub(crate) fn write_page_labels(
 }
 
 /// Converts a datetime to a pdf-writer date.
-fn pdf_date(datetime: Datetime, tz: bool) -> Option<pdf_writer::Date> {
+fn pdf_date(datetime: Datetime, tz: Option<Timezone>) -> Option<pdf_writer::Date> {
     let year = datetime.year().filter(|&y| y >= 0)? as u16;
 
     let mut pdf_date = pdf_writer::Date::new(year);
@@ -306,16 +315,36 @@ fn pdf_date(datetime: Datetime, tz: bool) -> Option<pdf_writer::Date> {
         pdf_date = pdf_date.second(s);
     }
 
-    if tz {
-        pdf_date = pdf_date.utc_offset_hour(0).utc_offset_minute(0);
+    match tz {
+        Some(Timezone::UTC) => {
+            pdf_date = pdf_date.utc_offset_hour(0).utc_offset_minute(0)
+        }
+        Some(Timezone::Local { hour_offset, minute_offset }) => {
+            pdf_date =
+                pdf_date.utc_offset_hour(hour_offset).utc_offset_minute(minute_offset)
+        }
+        None => {}
     }
 
     Some(pdf_date)
 }
 
 /// Converts a datetime to an xmp-writer datetime.
-fn xmp_date(datetime: Datetime, tz: bool) -> Option<xmp_writer::DateTime> {
+fn xmp_date(
+    datetime: Datetime,
+    timezone: Option<Timezone>,
+) -> Option<xmp_writer::DateTime> {
     let year = datetime.year().filter(|&y| y >= 0)? as u16;
+    let timezone = timezone.map(|tz| match tz {
+        Timezone::UTC => xmp_writer::Timezone::Utc,
+        Timezone::Local { hour_offset, minute_offset } => {
+            // The xmp-writer use signed integers for the minute offset, which
+            // can be buggy if the minute offset is negative. And because our
+            // minute_offset is ensured to be `0 <= minute_offset < 60`, we can
+            // safely cast it to a signed integer.
+            xmp_writer::Timezone::Local { hour: hour_offset, minute: minute_offset as i8 }
+        }
+    });
     Some(DateTime {
         year,
         month: datetime.month(),
@@ -323,6 +352,6 @@ fn xmp_date(datetime: Datetime, tz: bool) -> Option<xmp_writer::DateTime> {
         hour: datetime.hour(),
         minute: datetime.minute(),
         second: datetime.second(),
-        timezone: if tz { Some(Timezone::Utc) } else { None },
+        timezone,
     })
 }
diff --git a/crates/typst-pdf/src/lib.rs b/crates/typst-pdf/src/lib.rs
index c315684de..f45c62bb5 100644
--- a/crates/typst-pdf/src/lib.rs
+++ b/crates/typst-pdf/src/lib.rs
@@ -89,9 +89,9 @@ pub struct PdfOptions<'a> {
     /// `Auto`, a hash of the document's title and author is used instead (which
     /// is reasonably unique and stable).
     pub ident: Smart<&'a str>,
-    /// If not `None`, shall be the creation date of the document as a UTC
-    /// datetime. It will only be used if `set document(date: ..)` is `auto`.
-    pub timestamp: Option<Datetime>,
+    /// If not `None`, shall be the creation timestamp of the document. It will
+    /// only be used if `set document(date: ..)` is `auto`.
+    pub timestamp: Option<Timestamp>,
     /// Specifies which ranges of pages should be exported in the PDF. When
     /// `None`, all pages should be exported.
     pub page_ranges: Option<PageRanges>,
@@ -99,6 +99,51 @@ pub struct PdfOptions<'a> {
     pub standards: PdfStandards,
 }
 
+/// A timestamp with timezone information.
+#[derive(Debug, Clone, Copy)]
+pub struct Timestamp {
+    /// The datetime of the timestamp.
+    pub(crate) datetime: Datetime,
+    /// The timezone of the timestamp.
+    pub(crate) timezone: Timezone,
+}
+
+impl Timestamp {
+    /// Create a new timestamp with a given datetime and UTC suffix.
+    pub fn new_utc(datetime: Datetime) -> Self {
+        Self { datetime, timezone: Timezone::UTC }
+    }
+
+    /// Create a new timestamp with a given datetime, and a local timezone offset.
+    pub fn new_local(datetime: Datetime, whole_minute_offset: i32) -> Option<Self> {
+        let hour_offset = (whole_minute_offset / 60).try_into().ok()?;
+        // Note: the `%` operator in Rust is the remainder operator, not the
+        // modulo operator. The remainder operator can return negative results.
+        // We can simply apply `abs` here because we assume the `minute_offset`
+        // will have the same sign as `hour_offset`.
+        let minute_offset = (whole_minute_offset % 60).abs().try_into().ok()?;
+        match (hour_offset, minute_offset) {
+            // Only accept valid timezone offsets with `-23 <= hours <= 23`,
+            // and `0 <= minutes <= 59`.
+            (-23..=23, 0..=59) => Some(Self {
+                datetime,
+                timezone: Timezone::Local { hour_offset, minute_offset },
+            }),
+            _ => None,
+        }
+    }
+}
+
+/// A timezone.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Timezone {
+    /// The UTC timezone.
+    UTC,
+    /// The local timezone offset from UTC. And the `minute_offset` will have
+    /// same sign as `hour_offset`.
+    Local { hour_offset: i8, minute_offset: u8 },
+}
+
 /// Encapsulates a list of compatible PDF standards.
 #[derive(Clone)]
 pub struct PdfStandards {
@@ -612,3 +657,41 @@ fn transform_to_array(ts: Transform) -> [f32; 6] {
         ts.ty.to_f32(),
     ]
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_timestamp_new_local() {
+        let dummy_datetime = Datetime::from_ymd_hms(2024, 12, 17, 10, 10, 10).unwrap();
+        let test = |whole_minute_offset, expect_timezone| {
+            assert_eq!(
+                Timestamp::new_local(dummy_datetime, whole_minute_offset)
+                    .unwrap()
+                    .timezone,
+                expect_timezone
+            );
+        };
+
+        // Valid timezone offsets
+        test(0, Timezone::Local { hour_offset: 0, minute_offset: 0 });
+        test(480, Timezone::Local { hour_offset: 8, minute_offset: 0 });
+        test(-480, Timezone::Local { hour_offset: -8, minute_offset: 0 });
+        test(330, Timezone::Local { hour_offset: 5, minute_offset: 30 });
+        test(-210, Timezone::Local { hour_offset: -3, minute_offset: 30 });
+        test(-720, Timezone::Local { hour_offset: -12, minute_offset: 0 }); // AoE
+
+        // Corner cases
+        test(315, Timezone::Local { hour_offset: 5, minute_offset: 15 });
+        test(-225, Timezone::Local { hour_offset: -3, minute_offset: 45 });
+        test(1439, Timezone::Local { hour_offset: 23, minute_offset: 59 });
+        test(-1439, Timezone::Local { hour_offset: -23, minute_offset: 59 });
+
+        // Invalid timezone offsets
+        assert!(Timestamp::new_local(dummy_datetime, 1440).is_none());
+        assert!(Timestamp::new_local(dummy_datetime, -1440).is_none());
+        assert!(Timestamp::new_local(dummy_datetime, i32::MAX).is_none());
+        assert!(Timestamp::new_local(dummy_datetime, i32::MIN).is_none());
+    }
+}