From 40b87d4066fe85cb3fde6cf84cd60d748273ae25 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 7 Dec 2021 16:36:39 +0100
Subject: [PATCH] Set Rules Episode II: Attack of the properties

---
 Cargo.toml               |   5 +-
 src/eval/mod.rs          |  22 +-
 src/eval/node.rs         |   7 +-
 src/eval/styles.rs       | 124 ++++++
 src/frame.rs             |   9 +-
 src/lib.rs               |  26 +-
 src/library/align.rs     |  28 +-
 src/library/deco.rs      |   8 +-
 src/library/grid.rs      |   7 +-
 src/library/mod.rs       |  12 +-
 src/library/page.rs      | 392 ++++++++++++++---
 src/library/par.rs       |  66 +--
 src/library/placed.rs    |  15 +-
 src/library/text.rs      | 928 +++++++++++++++++++++++----------------
 src/library/transform.rs |   1 +
 src/style/mod.rs         | 419 ------------------
 src/style/paper.rs       | 233 ----------
 src/util/mod.rs          |  12 -
 tests/typeset.rs         |  28 +-
 19 files changed, 1119 insertions(+), 1223 deletions(-)
 create mode 100644 src/eval/styles.rs
 delete mode 100644 src/style/mod.rs
 delete mode 100644 src/style/paper.rs

diff --git a/Cargo.toml b/Cargo.toml
index 2778fd434..8b77f22d4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,17 +19,18 @@ debug = 0
 opt-level = 2
 
 [dependencies]
-fxhash = "0.2.1"
+fxhash = "0.2"
 image = { version = "0.23", default-features = false, features = ["png", "jpeg"] }
 itertools = "0.10"
 miniz_oxide = "0.4"
+once_cell = "1"
 pdf-writer = "0.4"
 rustybuzz = "0.4"
 serde = { version = "1", features = ["derive", "rc"] }
 svg2pdf = { version = "0.1", default-features = false, features = ["text", "png", "jpeg"] }
 ttf-parser = "0.12"
 unicode-bidi = "0.3.5"
-unicode-segmentation = "1.8"
+unicode-segmentation = "1"
 unicode-xid = "0.2"
 usvg = { version = "0.19", default-features = false, features = ["text"] }
 xi-unicode = "0.3"
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index e0143f6ce..c1f0b0248 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -6,6 +6,8 @@ mod array;
 mod dict;
 #[macro_use]
 mod value;
+#[macro_use]
+mod styles;
 mod capture;
 mod function;
 mod node;
@@ -18,6 +20,7 @@ pub use dict::*;
 pub use function::*;
 pub use node::*;
 pub use scope::*;
+pub use styles::*;
 pub use value::*;
 
 use std::cell::RefMut;
@@ -31,13 +34,12 @@ use unicode_segmentation::UnicodeSegmentation;
 use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult};
 use crate::geom::{Angle, Fractional, Length, Relative, Spec};
 use crate::image::ImageStore;
-use crate::library::{GridNode, TrackSizing};
+use crate::library::{GridNode, TextNode, TrackSizing};
 use crate::loading::Loader;
 use crate::source::{SourceId, SourceStore};
-use crate::style::Style;
 use crate::syntax::ast::*;
 use crate::syntax::{Span, Spanned};
-use crate::util::{BoolExt, EcoString, RefMutExt};
+use crate::util::{EcoString, RefMutExt};
 use crate::Context;
 
 /// Evaluate a parsed source file into a module.
@@ -70,8 +72,8 @@ pub struct EvalContext<'a> {
     pub modules: HashMap<SourceId, Module>,
     /// The active scopes.
     pub scopes: Scopes<'a>,
-    /// The active style.
-    pub style: Style,
+    /// The active styles.
+    pub styles: Styles,
 }
 
 impl<'a> EvalContext<'a> {
@@ -84,7 +86,7 @@ impl<'a> EvalContext<'a> {
             route: vec![source],
             modules: HashMap::new(),
             scopes: Scopes::new(Some(&ctx.std)),
-            style: ctx.style.clone(),
+            styles: Styles::new(),
         }
     }
 
@@ -158,14 +160,10 @@ impl Eval for Markup {
     type Output = Node;
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
-        let snapshot = ctx.style.clone();
-
         let mut result = Node::new();
         for piece in self.nodes() {
             result += piece.eval(ctx)?;
         }
-
-        ctx.style = snapshot;
         Ok(result)
     }
 }
@@ -179,11 +177,11 @@ impl Eval for MarkupNode {
             Self::Linebreak => Node::Linebreak,
             Self::Parbreak => Node::Parbreak,
             Self::Strong => {
-                ctx.style.text_mut().strong.flip();
+                ctx.styles.set(TextNode::STRONG, !ctx.styles.get(TextNode::STRONG));
                 Node::new()
             }
             Self::Emph => {
-                ctx.style.text_mut().emph.flip();
+                ctx.styles.set(TextNode::EMPH, !ctx.styles.get(TextNode::EMPH));
                 Node::new()
             }
             Self::Text(text) => Node::Text(text.clone()),
diff --git a/src/eval/node.rs b/src/eval/node.rs
index 58b294833..4d259e2d0 100644
--- a/src/eval/node.rs
+++ b/src/eval/node.rs
@@ -9,6 +9,7 @@ use crate::geom::SpecAxis;
 use crate::layout::{Layout, PackedNode};
 use crate::library::{
     Decoration, DocumentNode, FlowChild, FlowNode, PageNode, ParChild, ParNode, Spacing,
+    TextNode,
 };
 use crate::util::EcoString;
 
@@ -158,10 +159,10 @@ impl NodePacker {
     fn walk(&mut self, node: Node) {
         match node {
             Node::Space => {
-                self.push_inline(ParChild::Text(' '.into()));
+                self.push_inline(ParChild::Text(TextNode(' '.into())));
             }
             Node::Linebreak => {
-                self.push_inline(ParChild::Text('\n'.into()));
+                self.push_inline(ParChild::Text(TextNode('\n'.into())));
             }
             Node::Parbreak => {
                 self.parbreak();
@@ -170,7 +171,7 @@ impl NodePacker {
                 self.pagebreak();
             }
             Node::Text(text) => {
-                self.push_inline(ParChild::Text(text));
+                self.push_inline(ParChild::Text(TextNode(text)));
             }
             Node::Spacing(axis, amount) => match axis {
                 SpecAxis::Horizontal => self.push_inline(ParChild::Spacing(amount)),
diff --git a/src/eval/styles.rs b/src/eval/styles.rs
new file mode 100644
index 000000000..30822edbe
--- /dev/null
+++ b/src/eval/styles.rs
@@ -0,0 +1,124 @@
+use std::any::{Any, TypeId};
+use std::collections::HashMap;
+use std::fmt::{self, Debug, Formatter};
+use std::rc::Rc;
+
+// Possible optimizations:
+// - Ref-count map for cheaper cloning and smaller footprint
+// - Store map in `Option` to make empty maps non-allocating
+// - Store small properties inline
+
+/// A map of style properties.
+#[derive(Default, Clone)]
+pub struct Styles {
+    map: HashMap<TypeId, Rc<dyn Any>>,
+}
+
+impl Styles {
+    /// Create a new, empty style map.
+    pub fn new() -> Self {
+        Self { map: HashMap::new() }
+    }
+
+    /// Set the value for a style property.
+    pub fn set<P: Property>(&mut self, _: P, value: P::Value) {
+        self.map.insert(TypeId::of::<P>(), Rc::new(value));
+    }
+
+    /// Get the value of a copyable style property.
+    ///
+    /// Returns the property's default value if the map does not contain an
+    /// entry for it.
+    pub fn get<P: Property>(&self, key: P) -> P::Value
+    where
+        P::Value: Copy,
+    {
+        self.get_inner(key).copied().unwrap_or_else(P::default)
+    }
+
+    /// Get a reference to a style property.
+    ///
+    /// Returns a reference to the property's default value if the map does not
+    /// contain an entry for it.
+    pub fn get_ref<P: Property>(&self, key: P) -> &P::Value {
+        self.get_inner(key).unwrap_or_else(|| P::default_ref())
+    }
+
+    /// Get a reference to a style directly in this map.
+    fn get_inner<P: Property>(&self, _: P) -> Option<&P::Value> {
+        self.map
+            .get(&TypeId::of::<P>())
+            .and_then(|boxed| boxed.downcast_ref())
+    }
+}
+
+impl Debug for Styles {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        // TODO(set): Better debug printing possible?
+        f.pad("Styles(..)")
+    }
+}
+
+/// Stylistic property keys.
+pub trait Property: 'static {
+    /// The type of this property, for example, this could be
+    /// [`Length`](crate::geom::Length) for a `WIDTH` property.
+    type Value;
+
+    /// The default value of the property.
+    fn default() -> Self::Value;
+
+    /// A static reference to the default value of the property.
+    ///
+    /// This is automatically implemented through lazy-initialization in the
+    /// `properties!` macro. This way, expensive defaults don't need to be
+    /// recreated all the time.
+    fn default_ref() -> &'static Self::Value;
+}
+
+macro_rules! set {
+    ($ctx:expr, $target:expr => $source:expr) => {
+        if let Some(v) = $source {
+            $ctx.styles.set($target, v);
+        }
+    };
+}
+
+macro_rules! properties {
+    ($node:ty, $(
+        $(#[$attr:meta])*
+        $name:ident: $type:ty = $default:expr
+    ),* $(,)?) => {
+        // TODO(set): Fix possible name clash.
+        mod properties {
+            use std::marker::PhantomData;
+            use super::*;
+
+            $(#[allow(non_snake_case)] mod $name {
+                use $crate::eval::Property;
+                use once_cell::sync::Lazy;
+                use super::*;
+
+                pub struct Key<T>(pub PhantomData<T>);
+
+                impl Property for Key<$type> {
+                    type Value = $type;
+
+                    fn default() -> Self::Value {
+                        $default
+                    }
+
+                    fn default_ref() -> &'static Self::Value {
+                        static LAZY: Lazy<$type> = Lazy::new(|| $default);
+                        &*LAZY
+                    }
+                }
+            })*
+
+            impl $node {
+                $($(#[$attr])* pub const $name: $name::Key<$type>
+                    = $name::Key(PhantomData);)*
+            }
+        }
+    };
+}
diff --git a/src/frame.rs b/src/frame.rs
index b0442a06d..291259622 100644
--- a/src/frame.rs
+++ b/src/frame.rs
@@ -171,14 +171,19 @@ pub struct Text {
     pub face_id: FaceId,
     /// The font size.
     pub size: Length,
-    /// The width of the text run.
-    pub width: Length,
     /// Glyph color.
     pub fill: Paint,
     /// The glyphs.
     pub glyphs: Vec<Glyph>,
 }
 
+impl Text {
+    /// The width of the text run.
+    pub fn width(&self) -> Length {
+        self.glyphs.iter().map(|g| g.x_advance.to_length(self.size)).sum()
+    }
+}
+
 /// A glyph in a run of shaped text.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Glyph {
diff --git a/src/lib.rs b/src/lib.rs
index 096995b78..624526554 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -44,13 +44,12 @@ pub mod library;
 pub mod loading;
 pub mod parse;
 pub mod source;
-pub mod style;
 pub mod syntax;
 
 use std::rc::Rc;
 
 use crate::diag::TypResult;
-use crate::eval::{Module, Scope};
+use crate::eval::{Module, Scope, Styles};
 use crate::font::FontStore;
 use crate::frame::Frame;
 use crate::image::ImageStore;
@@ -59,7 +58,6 @@ use crate::layout::{EvictionPolicy, LayoutCache};
 use crate::library::DocumentNode;
 use crate::loading::Loader;
 use crate::source::{SourceId, SourceStore};
-use crate::style::Style;
 
 /// The core context which holds the loader, configuration and cached artifacts.
 pub struct Context {
@@ -76,8 +74,8 @@ pub struct Context {
     pub layouts: LayoutCache,
     /// The standard library scope.
     std: Scope,
-    /// The default style.
-    style: Style,
+    /// The default styles.
+    styles: Styles,
 }
 
 impl Context {
@@ -96,9 +94,9 @@ impl Context {
         &self.std
     }
 
-    /// A read-only reference to the style.
-    pub fn style(&self) -> &Style {
-        &self.style
+    /// A read-only reference to the styles.
+    pub fn styles(&self) -> &Styles {
+        &self.styles
     }
 
     /// Evaluate a source file and return the resulting module.
@@ -136,7 +134,7 @@ impl Context {
 /// This struct is created by [`Context::builder`].
 pub struct ContextBuilder {
     std: Option<Scope>,
-    style: Option<Style>,
+    styles: Option<Styles>,
     #[cfg(feature = "layout-cache")]
     policy: EvictionPolicy,
     #[cfg(feature = "layout-cache")]
@@ -151,9 +149,9 @@ impl ContextBuilder {
         self
     }
 
-    /// The initial properties for page size, font selection and so on.
-    pub fn style(mut self, style: Style) -> Self {
-        self.style = Some(style);
+    /// The default properties for page size, font selection and so on.
+    pub fn styles(mut self, styles: Styles) -> Self {
+        self.styles = Some(styles);
         self
     }
 
@@ -185,7 +183,7 @@ impl ContextBuilder {
             #[cfg(feature = "layout-cache")]
             layouts: LayoutCache::new(self.policy, self.max_size),
             std: self.std.unwrap_or_else(library::new),
-            style: self.style.unwrap_or_default(),
+            styles: self.styles.unwrap_or_default(),
         }
     }
 }
@@ -194,7 +192,7 @@ impl Default for ContextBuilder {
     fn default() -> Self {
         Self {
             std: None,
-            style: None,
+            styles: None,
             #[cfg(feature = "layout-cache")]
             policy: EvictionPolicy::default(),
             #[cfg(feature = "layout-cache")]
diff --git a/src/library/align.rs b/src/library/align.rs
index e2e7addb7..76db7fc42 100644
--- a/src/library/align.rs
+++ b/src/library/align.rs
@@ -2,18 +2,6 @@ use super::prelude::*;
 
 /// `align`: Configure the alignment along the layouting axes.
 pub fn align(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
-    castable! {
-        Spec<Option<Align>>,
-        Expected: "1d or 2d alignment",
-        @align: Align => {
-            let mut aligns = Spec::default();
-            aligns.set(align.axis(), Some(*align));
-            aligns
-        },
-        @aligns: Spec<Align> => aligns.map(Some),
-
-    }
-
     let aligns = args.expect::<Spec<_>>("alignment")?;
     let body = args.expect::<Node>("body")?;
 
@@ -62,3 +50,19 @@ impl Layout for AlignNode {
         frames
     }
 }
+
+dynamic! {
+    Align: "alignment",
+}
+
+castable! {
+    Spec<Option<Align>>,
+    Expected: "1d or 2d alignment",
+    @align: Align => {
+        let mut aligns = Spec::default();
+        aligns.set(align.axis(), Some(*align));
+        aligns
+    },
+    @aligns: Spec<Align> => aligns.map(Some),
+
+}
diff --git a/src/library/deco.rs b/src/library/deco.rs
index 3576e8fe5..b1ca030ac 100644
--- a/src/library/deco.rs
+++ b/src/library/deco.rs
@@ -31,7 +31,11 @@ fn line_impl(args: &mut Args, kind: LineKind) -> TypResult<Value> {
 pub fn link(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let url = args.expect::<EcoString>("url")?;
     let body = args.find().unwrap_or_else(|| {
-        Node::Text(url.trim_start_matches("mailto:").trim_start_matches("tel:").into())
+        let mut text = url.as_str();
+        for prefix in ["mailto:", "tel:"] {
+            text = text.trim_start_matches(prefix);
+        }
+        Node::Text(text.into())
     });
     Ok(Value::Node(body.decorate(Decoration::Link(url))))
 }
@@ -120,7 +124,7 @@ impl LineDecoration {
                 let extent = self.extent.resolve(text.size);
 
                 let subpos = Point::new(pos.x - extent, pos.y + offset);
-                let target = Point::new(text.width + 2.0 * extent, Length::zero());
+                let target = Point::new(text.width() + 2.0 * extent, Length::zero());
                 let shape = Shape::stroked(Geometry::Line(target), stroke);
                 frame.push(subpos, Element::Shape(shape));
             }
diff --git a/src/library/grid.rs b/src/library/grid.rs
index ba4ce11f2..e82f09ef0 100644
--- a/src/library/grid.rs
+++ b/src/library/grid.rs
@@ -39,8 +39,11 @@ pub fn grid(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
         row_gutter.unwrap_or(base_gutter),
     );
 
-    let children = args.all().map(Node::into_block).collect();
-    Ok(Value::block(GridNode { tracks, gutter, children }))
+    Ok(Value::block(GridNode {
+        tracks,
+        gutter,
+        children: args.all().map(Node::into_block).collect(),
+    }))
 }
 
 /// A node that arranges its children in a grid.
diff --git a/src/library/mod.rs b/src/library/mod.rs
index e19886357..7f7f95e3f 100644
--- a/src/library/mod.rs
+++ b/src/library/mod.rs
@@ -26,7 +26,7 @@ mod prelude {
     pub use std::rc::Rc;
 
     pub use crate::diag::{At, TypResult};
-    pub use crate::eval::{Args, EvalContext, Node, Smart, Value};
+    pub use crate::eval::{Args, EvalContext, Node, Property, Smart, Styles, Value};
     pub use crate::frame::*;
     pub use crate::geom::*;
     pub use crate::layout::*;
@@ -54,7 +54,6 @@ pub use utility::*;
 
 use crate::eval::{Scope, Value};
 use crate::geom::*;
-use crate::style::FontFamily;
 
 /// Construct a scope containing all standard library definitions.
 pub fn new() -> Scope {
@@ -139,15 +138,6 @@ dynamic! {
     Dir: "direction",
 }
 
-dynamic! {
-    Align: "alignment",
-}
-
-dynamic! {
-    FontFamily: "font family",
-    Value::Str(string) => Self::Named(string.to_lowercase()),
-}
-
 castable! {
     Paint,
     Expected: "color",
diff --git a/src/library/page.rs b/src/library/page.rs
index 9def54009..a4ad84f64 100644
--- a/src/library/page.rs
+++ b/src/library/page.rs
@@ -1,70 +1,43 @@
+#![allow(unused)]
+
+use std::fmt::{self, Display, Formatter};
+use std::str::FromStr;
+
 use super::prelude::*;
 use super::PadNode;
-use crate::style::{Paper, PaperClass};
 
 /// `page`: Configure pages.
 pub fn page(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     castable! {
         Paper,
         Expected: "string",
-        Value::Str(string) => Paper::from_name(&string).ok_or("unknown paper")?,
+        Value::Str(string) => Paper::from_str(&string).map_err(|e| e.to_string())?,
+    }
+
+    if let Some(paper) = args.named::<Paper>("paper")?.or_else(|| args.find()) {
+        ctx.styles.set(PageNode::CLASS, paper.class());
+        ctx.styles.set(PageNode::WIDTH, Smart::Custom(paper.width()));
+        ctx.styles.set(PageNode::HEIGHT, Smart::Custom(paper.height()));
+    }
+
+    if let Some(width) = args.named("width")? {
+        ctx.styles.set(PageNode::CLASS, PaperClass::Custom);
+        ctx.styles.set(PageNode::WIDTH, width);
+    }
+
+    if let Some(height) = args.named("height")? {
+        ctx.styles.set(PageNode::CLASS, PaperClass::Custom);
+        ctx.styles.set(PageNode::HEIGHT, height);
     }
 
-    let paper = args.named::<Paper>("paper")?.or_else(|| args.find());
-    let width = args.named::<Smart<_>>("width")?;
-    let height = args.named::<Smart<_>>("height")?;
-    let flip = args.named("flip")?;
     let margins = args.named("margins")?;
-    let left = args.named("left")?;
-    let top = args.named("top")?;
-    let right = args.named("right")?;
-    let bottom = args.named("bottom")?;
-    let fill = args.named("fill")?;
 
-    let page = ctx.style.page_mut();
-
-    if let Some(paper) = paper {
-        page.class = paper.class();
-        page.size = paper.size();
-    }
-
-    if let Some(width) = width {
-        page.class = PaperClass::Custom;
-        page.size.x = width.unwrap_or(Length::inf());
-    }
-
-    if let Some(height) = height {
-        page.class = PaperClass::Custom;
-        page.size.y = height.unwrap_or(Length::inf());
-    }
-
-    if flip.unwrap_or(false) {
-        std::mem::swap(&mut page.size.x, &mut page.size.y);
-    }
-
-    if let Some(margins) = margins {
-        page.margins = Sides::splat(margins);
-    }
-
-    if let Some(left) = left {
-        page.margins.left = left;
-    }
-
-    if let Some(top) = top {
-        page.margins.top = top;
-    }
-
-    if let Some(right) = right {
-        page.margins.right = right;
-    }
-
-    if let Some(bottom) = bottom {
-        page.margins.bottom = bottom;
-    }
-
-    if let Some(fill) = fill {
-        page.fill = fill;
-    }
+    set!(ctx, PageNode::FLIPPED => args.named("flipped")?);
+    set!(ctx, PageNode::LEFT => args.named("left")?.or(margins));
+    set!(ctx, PageNode::TOP => args.named("top")?.or(margins));
+    set!(ctx, PageNode::RIGHT => args.named("right")?.or(margins));
+    set!(ctx, PageNode::BOTTOM => args.named("bottom")?.or(margins));
+    set!(ctx, PageNode::FILL => args.named("fill")?);
 
     Ok(Value::None)
 }
@@ -74,29 +47,69 @@ pub fn pagebreak(_: &mut EvalContext, _: &mut Args) -> TypResult<Value> {
     Ok(Value::Node(Node::Pagebreak))
 }
 
-/// Layouts its children onto one or multiple pages.
+/// Layouts its child onto one or multiple pages.
 #[derive(Debug, Hash)]
 pub struct PageNode(pub PackedNode);
 
+properties! {
+    PageNode,
+
+    /// The unflipped width of the page.
+    WIDTH: Smart<Length> = Smart::Custom(Paper::default().width()),
+    /// The unflipped height of the page.
+    HEIGHT: Smart<Length> = Smart::Custom(Paper::default().height()),
+    /// The class of paper. Defines the default margins.
+    CLASS: PaperClass = Paper::default().class(),
+    /// Whether the page is flipped into landscape orientation.
+    FLIPPED: bool = false,
+    /// The left margin.
+    LEFT: Smart<Linear> = Smart::Auto,
+    /// The right margin.
+    RIGHT: Smart<Linear> = Smart::Auto,
+    /// The top margin.
+    TOP: Smart<Linear> = Smart::Auto,
+    /// The bottom margin.
+    BOTTOM: Smart<Linear> = Smart::Auto,
+    /// The page's background color.
+    FILL: Option<Paint> = None,
+}
+
 impl PageNode {
     /// Layout the page run into a sequence of frames, one per page.
     pub fn layout(&self, ctx: &mut LayoutContext) -> Vec<Rc<Frame>> {
-        // TODO(set): Get style from styles.
-        let style = crate::style::PageStyle::default();
+        // TODO(set): Take styles as parameter.
+        let styles = Styles::new();
 
         // When one of the lengths is infinite the page fits its content along
         // that axis.
-        let expand = style.size.map(Length::is_finite);
-        let regions = Regions::repeat(style.size, style.size, expand);
+        let width = styles.get(Self::WIDTH).unwrap_or(Length::inf());
+        let height = styles.get(Self::HEIGHT).unwrap_or(Length::inf());
+        let mut size = Size::new(width, height);
+        if styles.get(Self::FLIPPED) {
+            std::mem::swap(&mut size.x, &mut size.y);
+        }
+
+        // Determine the margins.
+        let class = styles.get(Self::CLASS);
+        let default = class.default_margins();
+        let padding = Sides {
+            left: styles.get(Self::LEFT).unwrap_or(default.left),
+            right: styles.get(Self::RIGHT).unwrap_or(default.right),
+            top: styles.get(Self::TOP).unwrap_or(default.top),
+            bottom: styles.get(Self::BOTTOM).unwrap_or(default.bottom),
+        };
+
+        // Pad the child.
+        let padded = PadNode { child: self.0.clone(), padding }.pack();
 
         // Layout the child.
-        let padding = style.margins();
-        let padded = PadNode { child: self.0.clone(), padding }.pack();
+        let expand = size.map(Length::is_finite);
+        let regions = Regions::repeat(size, size, expand);
         let mut frames: Vec<_> =
             padded.layout(ctx, &regions).into_iter().map(|c| c.item).collect();
 
         // Add background fill if requested.
-        if let Some(fill) = style.fill {
+        if let Some(fill) = styles.get(Self::FILL) {
             for frame in &mut frames {
                 let shape = Shape::filled(Geometry::Rect(frame.size), fill);
                 Rc::make_mut(frame).prepend(Point::zero(), Element::Shape(shape));
@@ -106,3 +119,256 @@ impl PageNode {
         frames
     }
 }
+
+/// Specification of a paper.
+#[derive(Debug, Copy, Clone)]
+pub struct Paper {
+    /// The broad class this paper belongs to.
+    class: PaperClass,
+    /// The width of the paper in millimeters.
+    width: f64,
+    /// The height of the paper in millimeters.
+    height: f64,
+}
+
+impl Paper {
+    /// The class of the paper.
+    pub fn class(self) -> PaperClass {
+        self.class
+    }
+
+    /// The width of the paper.
+    pub fn width(self) -> Length {
+        Length::mm(self.width)
+    }
+
+    /// The height of the paper.
+    pub fn height(self) -> Length {
+        Length::mm(self.height)
+    }
+}
+
+impl Default for Paper {
+    fn default() -> Self {
+        Paper::A4
+    }
+}
+
+/// Defines default margins for a class of related papers.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum PaperClass {
+    Custom,
+    Base,
+    US,
+    Newspaper,
+    Book,
+}
+
+impl PaperClass {
+    /// The default margins for this page class.
+    fn default_margins(self) -> Sides<Linear> {
+        let f = |r| Relative::new(r).into();
+        let s = |l, t, r, b| Sides::new(f(l), f(t), f(r), f(b));
+        match self {
+            Self::Custom => s(0.1190, 0.0842, 0.1190, 0.0842),
+            Self::Base => s(0.1190, 0.0842, 0.1190, 0.0842),
+            Self::US => s(0.1760, 0.1092, 0.1760, 0.0910),
+            Self::Newspaper => s(0.0455, 0.0587, 0.0455, 0.0294),
+            Self::Book => s(0.1200, 0.0852, 0.1500, 0.0965),
+        }
+    }
+}
+
+/// Defines paper constants and a paper parsing implementation.
+macro_rules! papers {
+    ($(($var:ident: $class:ident, $width:expr, $height: expr, $($pats:tt)*))*) => {
+        /// Predefined papers.
+        ///
+        /// Each paper is parsable from its name in kebab-case.
+        impl Paper {
+            $(pub const $var: Self = Self {
+                class: PaperClass::$class,
+                width: $width,
+                height: $height,
+            };)*
+        }
+
+        impl FromStr for Paper {
+            type Err = ParsePaperError;
+
+            fn from_str(name: &str) -> Result<Self, Self::Err> {
+                match name.to_lowercase().as_str() {
+                    $($($pats)* => Ok(Self::$var),)*
+                    _ => Err(ParsePaperError),
+                }
+            }
+        }
+
+        /// The error when parsing a [`Paper`] from a string fails.
+        #[derive(Debug, Copy, Clone, Eq, PartialEq)]
+        pub struct ParsePaperError;
+
+        impl Display for ParsePaperError {
+            fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+                f.pad("invalid paper name")
+            }
+        }
+
+        impl std::error::Error for ParsePaperError {}
+    };
+}
+
+// All paper sizes in mm.
+//
+// Resources:
+// - https://papersizes.io/
+// - https://en.wikipedia.org/wiki/Paper_size
+// - https://www.theedkins.co.uk/jo/units/oldunits/print.htm
+// - https://vintagepaper.co/blogs/news/traditional-paper-sizes
+papers! {
+    // ---------------------------------------------------------------------- //
+    // ISO 216 A Series
+    (A0:  Base, 841.0, 1189.0, "a0")
+    (A1:  Base, 594.0,  841.0, "a1")
+    (A2:  Base, 420.0,  594.0, "a2")
+    (A3:  Base, 297.0,  420.0, "a3")
+    (A4:  Base, 210.0,  297.0, "a4")
+    (A5:  Base, 148.0,  210.0, "a5")
+    (A6:  Book, 105.0,  148.0, "a6")
+    (A7:  Base,  74.0,  105.0, "a7")
+    (A8:  Base,  52.0,   74.0, "a8")
+    (A9:  Base,  37.0,   52.0, "a9")
+    (A10: Base,  26.0,   37.0, "a10")
+    (A11: Base,  18.0,   26.0, "a11")
+
+    // ISO 216 B Series
+    (ISO_B1: Base, 707.0, 1000.0, "iso-b1")
+    (ISO_B2: Base, 500.0, 707.0,  "iso-b2")
+    (ISO_B3: Base, 353.0, 500.0,  "iso-b3")
+    (ISO_B4: Base, 250.0, 353.0,  "iso-b4")
+    (ISO_B5: Book, 176.0, 250.0,  "iso-b5")
+    (ISO_B6: Book, 125.0, 176.0,  "iso-b6")
+    (ISO_B7: Base,  88.0, 125.0,  "iso-b7")
+    (ISO_B8: Base,  62.0,  88.0,  "iso-b8")
+
+    // ISO 216 C Series
+    (ISO_C3: Base, 324.0, 458.0, "iso-c3")
+    (ISO_C4: Base, 229.0, 324.0, "iso-c4")
+    (ISO_C5: Base, 162.0, 229.0, "iso-c5")
+    (ISO_C6: Base, 114.0, 162.0, "iso-c6")
+    (ISO_C7: Base,  81.0, 114.0, "iso-c7")
+    (ISO_C8: Base,  57.0,  81.0, "iso-c8")
+
+    // DIN D Series (extension to ISO)
+    (DIN_D3: Base, 272.0, 385.0, "din-d3")
+    (DIN_D4: Base, 192.0, 272.0, "din-d4")
+    (DIN_D5: Base, 136.0, 192.0, "din-d5")
+    (DIN_D6: Base,  96.0, 136.0, "din-d6")
+    (DIN_D7: Base,  68.0,  96.0, "din-d7")
+    (DIN_D8: Base,  48.0,  68.0, "din-d8")
+
+    // SIS (used in academia)
+    (SIS_G5: Base, 169.0, 239.0, "sis-g5")
+    (SIS_E5: Base, 115.0, 220.0, "sis-e5")
+
+    // ANSI Extensions
+    (ANSI_A: Base, 216.0,  279.0, "ansi-a")
+    (ANSI_B: Base, 279.0,  432.0, "ansi-b")
+    (ANSI_C: Base, 432.0,  559.0, "ansi-c")
+    (ANSI_D: Base, 559.0,  864.0, "ansi-d")
+    (ANSI_E: Base, 864.0, 1118.0, "ansi-e")
+
+    // ANSI Architectural Paper
+    (ARCH_A:  Base, 229.0,  305.0, "arch-a")
+    (ARCH_B:  Base, 305.0,  457.0, "arch-b")
+    (ARCH_C:  Base, 457.0,  610.0, "arch-c")
+    (ARCH_D:  Base, 610.0,  914.0, "arch-d")
+    (ARCH_E1: Base, 762.0, 1067.0, "arch-e1")
+    (ARCH_E:  Base, 914.0, 1219.0, "arch-e")
+
+    // JIS B Series
+    (JIS_B0:  Base, 1030.0, 1456.0, "jis-b0")
+    (JIS_B1:  Base,  728.0, 1030.0, "jis-b1")
+    (JIS_B2:  Base,  515.0,  728.0, "jis-b2")
+    (JIS_B3:  Base,  364.0,  515.0, "jis-b3")
+    (JIS_B4:  Base,  257.0,  364.0, "jis-b4")
+    (JIS_B5:  Base,  182.0,  257.0, "jis-b5")
+    (JIS_B6:  Base,  128.0,  182.0, "jis-b6")
+    (JIS_B7:  Base,   91.0,  128.0, "jis-b7")
+    (JIS_B8:  Base,   64.0,   91.0, "jis-b8")
+    (JIS_B9:  Base,   45.0,   64.0, "jis-b9")
+    (JIS_B10: Base,   32.0,   45.0, "jis-b10")
+    (JIS_B11: Base,   22.0,   32.0, "jis-b11")
+
+    // SAC D Series
+    (SAC_D0: Base, 764.0, 1064.0, "sac-d0")
+    (SAC_D1: Base, 532.0,  760.0, "sac-d1")
+    (SAC_D2: Base, 380.0,  528.0, "sac-d2")
+    (SAC_D3: Base, 264.0,  376.0, "sac-d3")
+    (SAC_D4: Base, 188.0,  260.0, "sac-d4")
+    (SAC_D5: Base, 130.0,  184.0, "sac-d5")
+    (SAC_D6: Base,  92.0,  126.0, "sac-d6")
+
+    // ISO 7810 ID
+    (ISO_ID_1: Base, 85.6, 53.98, "iso-id-1")
+    (ISO_ID_2: Base, 74.0, 105.0, "iso-id-2")
+    (ISO_ID_3: Base, 88.0, 125.0, "iso-id-3")
+
+    // ---------------------------------------------------------------------- //
+    // Asia
+    (ASIA_F4: Base, 210.0, 330.0, "asia-f4")
+
+    // Japan
+    (JP_SHIROKU_BAN_4: Base, 264.0, 379.0, "jp-shiroku-ban-4")
+    (JP_SHIROKU_BAN_5: Base, 189.0, 262.0, "jp-shiroku-ban-5")
+    (JP_SHIROKU_BAN_6: Base, 127.0, 188.0, "jp-shiroku-ban-6")
+    (JP_KIKU_4:        Base, 227.0, 306.0, "jp-kiku-4")
+    (JP_KIKU_5:        Base, 151.0, 227.0, "jp-kiku-5")
+    (JP_BUSINESS_CARD: Base,  91.0,  55.0, "jp-business-card")
+
+    // China
+    (CN_BUSINESS_CARD: Base, 90.0, 54.0, "cn-business-card")
+
+    // Europe
+    (EU_BUSINESS_CARD: Base, 85.0, 55.0, "eu-business-card")
+
+    // French Traditional (AFNOR)
+    (FR_TELLIERE:          Base, 340.0, 440.0, "fr-tellière")
+    (FR_COURONNE_ECRITURE: Base, 360.0, 460.0, "fr-couronne-écriture")
+    (FR_COURONNE_EDITION:  Base, 370.0, 470.0, "fr-couronne-édition")
+    (FR_RAISIN:            Base, 500.0, 650.0, "fr-raisin")
+    (FR_CARRE:             Base, 450.0, 560.0, "fr-carré")
+    (FR_JESUS:             Base, 560.0, 760.0, "fr-jésus")
+
+    // United Kingdom Imperial
+    (UK_BRIEF:    Base, 406.4, 342.9, "uk-brief")
+    (UK_DRAFT:    Base, 254.0, 406.4, "uk-draft")
+    (UK_FOOLSCAP: Base, 203.2, 330.2, "uk-foolscap")
+    (UK_QUARTO:   Base, 203.2, 254.0, "uk-quarto")
+    (UK_CROWN:    Base, 508.0, 381.0, "uk-crown")
+    (UK_BOOK_A:   Book, 111.0, 178.0, "uk-book-a")
+    (UK_BOOK_B:   Book, 129.0, 198.0, "uk-book-b")
+
+    // Unites States
+    (US_LETTER:         US,   215.9,  279.4, "us-letter")
+    (US_LEGAL:          US,   215.9,  355.6, "us-legal")
+    (US_TABLOID:        US,   279.4,  431.8, "us-tabloid")
+    (US_EXECUTIVE:      US,  184.15,  266.7, "us-executive")
+    (US_FOOLSCAP_FOLIO: US,   215.9,  342.9, "us-foolscap-folio")
+    (US_STATEMENT:      US,   139.7,  215.9, "us-statement")
+    (US_LEDGER:         US,   431.8,  279.4, "us-ledger")
+    (US_OFICIO:         US,   215.9, 340.36, "us-oficio")
+    (US_GOV_LETTER:     US,   203.2,  266.7, "us-gov-letter")
+    (US_GOV_LEGAL:      US,   215.9,  330.2, "us-gov-legal")
+    (US_BUSINESS_CARD:  Base,  88.9,   50.8, "us-business-card")
+    (US_DIGEST:         Book, 139.7,  215.9, "us-digest")
+    (US_TRADE:          Book, 152.4,  228.6, "us-trade")
+
+    // ---------------------------------------------------------------------- //
+    // Other
+    (NEWSPAPER_COMPACT:    Newspaper, 280.0, 430.0,    "newspaper-compact")
+    (NEWSPAPER_BERLINER:   Newspaper, 315.0, 470.0,    "newspaper-berliner")
+    (NEWSPAPER_BROADSHEET: Newspaper, 381.0, 578.0,    "newspaper-broadsheet")
+    (PRESENTATION_16_9:    Base,      297.0, 167.0625, "presentation-16-9")
+    (PRESENTATION_4_3:     Base,      280.0, 210.0,    "presentation-4-3")
+}
diff --git a/src/library/par.rs b/src/library/par.rs
index 6da1ee958..217602255 100644
--- a/src/library/par.rs
+++ b/src/library/par.rs
@@ -6,8 +6,7 @@ use unicode_bidi::{BidiInfo, Level};
 use xi_unicode::LineBreakIterator;
 
 use super::prelude::*;
-use super::{shape, Decoration, ShapedText, Spacing};
-use crate::style::TextStyle;
+use super::{shape, Decoration, ShapedText, Spacing, TextNode};
 use crate::util::{EcoString, RangeExt, RcExt, SliceExt};
 
 /// `par`: Configure paragraphs.
@@ -38,24 +37,14 @@ pub fn par(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
         align = Some(v);
     }
 
-    let par = ctx.style.par_mut();
-
-    if let Some(dir) = dir {
-        par.dir = dir;
-        par.align = if dir == Dir::LTR { Align::Left } else { Align::Right };
+    if let (Some(dir), None) = (dir, align) {
+        align = Some(if dir == Dir::LTR { Align::Left } else { Align::Right });
     }
 
-    if let Some(align) = align {
-        par.align = align;
-    }
-
-    if let Some(leading) = leading {
-        par.leading = leading;
-    }
-
-    if let Some(spacing) = spacing {
-        par.spacing = spacing;
-    }
+    set!(ctx, ParNode::DIR => dir);
+    set!(ctx, ParNode::ALIGN => align);
+    set!(ctx, ParNode::LEADING => leading);
+    set!(ctx, ParNode::SPACING => spacing);
 
     Ok(Value::None)
 }
@@ -64,24 +53,39 @@ pub fn par(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
 #[derive(Debug, Hash)]
 pub struct ParNode(pub Vec<ParChild>);
 
+properties! {
+    ParNode,
+
+    /// The direction for text and inline objects.
+    DIR: Dir = Dir::LTR,
+    /// How to align text and inline objects in their line.
+    ALIGN: Align = Align::Left,
+    // TODO(set): Make relative to font size.
+    /// The spacing between lines (dependent on scaled font size).
+    LEADING: Length = Length::pt(6.5),
+    /// The spacing between paragraphs (dependent on scaled font size).
+    SPACING: Length = Length::pt(12.0),
+}
+
 impl Layout for ParNode {
     fn layout(
         &self,
         ctx: &mut LayoutContext,
         regions: &Regions,
     ) -> Vec<Constrained<Rc<Frame>>> {
+        // TODO(set): Take styles as parameter.
+        let styles = Styles::new();
+
         // Collect all text into one string used for BiDi analysis.
         let text = self.collect_text();
 
         // Find out the BiDi embedding levels.
-        // TODO(set): Get dir from styles.
-        let bidi = BidiInfo::new(&text, Level::from_dir(Dir::LTR));
+        let default_level = Level::from_dir(styles.get(Self::DIR));
+        let bidi = BidiInfo::new(&text, default_level);
 
         // Prepare paragraph layout by building a representation on which we can
         // do line breaking without layouting each and every line from scratch.
-        // TODO(set): Get text style from styles.
-        let style = crate::style::TextStyle::default();
-        let layouter = ParLayouter::new(self, ctx, regions, bidi, &style);
+        let layouter = ParLayouter::new(self, ctx, regions, bidi, &styles);
 
         // Find suitable linebreaks.
         layouter.layout(ctx, regions.clone())
@@ -115,7 +119,7 @@ impl ParNode {
     fn strings(&self) -> impl Iterator<Item = &str> {
         self.0.iter().map(|child| match child {
             ParChild::Spacing(_) => " ",
-            ParChild::Text(ref piece, ..) => piece,
+            ParChild::Text(ref piece, ..) => &piece.0,
             ParChild::Node(..) => "\u{FFFC}",
             ParChild::Decorate(_) | ParChild::Undecorate => "",
         })
@@ -128,7 +132,8 @@ pub enum ParChild {
     /// Spacing between other nodes.
     Spacing(Spacing),
     /// A run of text and how to align it in its line.
-    Text(EcoString),
+    // TODO(set): A single text run may also have its own style.
+    Text(TextNode),
     /// Any child node and how to align it in its line.
     Node(PackedNode),
     /// A decoration that applies until a matching `Undecorate`.
@@ -188,7 +193,7 @@ impl<'a> ParLayouter<'a> {
         ctx: &mut LayoutContext,
         regions: &Regions,
         bidi: BidiInfo<'a>,
-        style: &'a TextStyle,
+        styles: &'a Styles,
     ) -> Self {
         let mut items = vec![];
         let mut ranges = vec![];
@@ -215,7 +220,7 @@ impl<'a> ParLayouter<'a> {
                         cursor += group.len();
                         let subrange = start .. cursor;
                         let text = &bidi.text[subrange.clone()];
-                        let shaped = shape(ctx, text, style, level.dir());
+                        let shaped = shape(ctx, text, styles, level.dir());
                         items.push(ParItem::Text(shaped));
                         ranges.push(subrange);
                     }
@@ -243,9 +248,8 @@ impl<'a> ParLayouter<'a> {
         }
 
         Self {
-            // TODO(set): Get alignment and leading from styles.
-            align: Align::Left,
-            leading: Length::pt(6.0),
+            align: styles.get(ParNode::ALIGN),
+            leading: styles.get(ParNode::LEADING),
             bidi,
             items,
             ranges,
@@ -540,7 +544,7 @@ impl<'a> LineLayout<'a> {
             // Compute the reordered ranges in visual order (left to right).
             self.par.bidi.visual_runs(para, self.line.clone())
         } else {
-            <_>::default()
+            (vec![], vec![])
         };
 
         runs.into_iter()
diff --git a/src/library/placed.rs b/src/library/placed.rs
index ce76a969a..3e2e1b26c 100644
--- a/src/library/placed.rs
+++ b/src/library/placed.rs
@@ -7,24 +7,21 @@ pub fn place(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
     let tx = args.named("dx")?.unwrap_or_default();
     let ty = args.named("dy")?.unwrap_or_default();
     let body: Node = args.expect("body")?;
-    Ok(Value::block(PlacedNode {
-        child: body.into_block().moved(Point::new(tx, ty)).aligned(aligns),
-    }))
+    Ok(Value::block(PlacedNode(
+        body.into_block().moved(Point::new(tx, ty)).aligned(aligns),
+    )))
 }
 
 /// A node that places its child absolutely.
 #[derive(Debug, Hash)]
-pub struct PlacedNode {
-    /// The node to be placed.
-    pub child: PackedNode,
-}
+pub struct PlacedNode(pub PackedNode);
 
 impl PlacedNode {
     /// Whether this node wants to be placed relative to its its parent's base
     /// origin. instead of relative to the parent's current flow/cursor
     /// position.
     pub fn out_of_flow(&self) -> bool {
-        self.child
+        self.0
             .downcast::<AlignNode>()
             .map_or(false, |node| node.aligns.y.is_some())
     }
@@ -46,7 +43,7 @@ impl Layout for PlacedNode {
             Regions::one(regions.base, regions.base, expand)
         };
 
-        let mut frames = self.child.layout(ctx, &pod);
+        let mut frames = self.0.layout(ctx, &pod);
         let Constrained { item: frame, cts } = &mut frames[0];
 
         // If expansion is off, zero all sizes so that we don't take up any
diff --git a/src/library/text.rs b/src/library/text.rs
index d96f7666a..012180871 100644
--- a/src/library/text.rs
+++ b/src/library/text.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::convert::TryInto;
+use std::fmt::{self, Debug, Formatter};
 use std::ops::Range;
 
 use rustybuzz::{Feature, UnicodeBuffer};
@@ -11,219 +12,326 @@ use crate::font::{
     VerticalFontMetric,
 };
 use crate::geom::{Dir, Em, Length, Point, Size};
-use crate::style::{
-    FontFamily, FontFeatures, NumberPosition, NumberType, NumberWidth, StylisticSet,
-    TextStyle,
-};
 use crate::util::{EcoString, SliceExt};
 
 /// `font`: Configure the font.
 pub fn font(ctx: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
-    castable! {
-        Vec<FontFamily>,
-        Expected: "string, generic family or array thereof",
-        Value::Str(string) => vec![FontFamily::Named(string.to_lowercase())],
-        Value::Array(values) => {
-            values.into_iter().filter_map(|v| v.cast().ok()).collect()
-        },
-        @family: FontFamily => vec![family.clone()],
-    }
-
-    castable! {
-        Vec<EcoString>,
-        Expected: "string or array of strings",
-        Value::Str(string) => vec![string.to_lowercase()],
-        Value::Array(values) => values
-            .into_iter()
-            .filter_map(|v| v.cast().ok())
-            .map(|string: EcoString| string.to_lowercase())
-            .collect(),
-    }
-
-    castable! {
-        FontStyle,
-        Expected: "string",
-        Value::Str(string) => match string.as_str() {
-            "normal" => Self::Normal,
-            "italic" => Self::Italic,
-            "oblique" => Self::Oblique,
-            _ => Err(r#"expected "normal", "italic" or "oblique""#)?,
-        },
-    }
-
-    castable! {
-        FontWeight,
-        Expected: "integer or string",
-        Value::Int(v) => v.try_into().map_or(Self::BLACK, Self::from_number),
-        Value::Str(string) => match string.as_str() {
-            "thin" => Self::THIN,
-            "extralight" => Self::EXTRALIGHT,
-            "light" => Self::LIGHT,
-            "regular" => Self::REGULAR,
-            "medium" => Self::MEDIUM,
-            "semibold" => Self::SEMIBOLD,
-            "bold" => Self::BOLD,
-            "extrabold" => Self::EXTRABOLD,
-            "black" => Self::BLACK,
-            _ => Err("unknown font weight")?,
-        },
-    }
-
-    castable! {
-        FontStretch,
-        Expected: "relative",
-        Value::Relative(v) => Self::from_ratio(v.get() as f32),
-    }
-
-    castable! {
-        VerticalFontMetric,
-        Expected: "linear or string",
-        Value::Length(v) => Self::Linear(v.into()),
-        Value::Relative(v) => Self::Linear(v.into()),
-        Value::Linear(v) => Self::Linear(v),
-        Value::Str(string) => match string.as_str() {
-            "ascender" => Self::Ascender,
-            "cap-height" => Self::CapHeight,
-            "x-height" => Self::XHeight,
-            "baseline" => Self::Baseline,
-            "descender" => Self::Descender,
-            _ => Err("unknown font metric")?,
-        },
-    }
-
-    castable! {
-        StylisticSet,
-        Expected: "integer",
-        Value::Int(v) => match v {
-            1 ..= 20 => Self::new(v as u8),
-            _ => Err("must be between 1 and 20")?,
-        },
-    }
-
-    castable! {
-        NumberType,
-        Expected: "string",
-        Value::Str(string) => match string.as_str() {
-            "lining" => Self::Lining,
-            "old-style" => Self::OldStyle,
-            _ => Err(r#"expected "lining" or "old-style""#)?,
-        },
-    }
-
-    castable! {
-        NumberWidth,
-        Expected: "string",
-        Value::Str(string) => match string.as_str() {
-            "proportional" => Self::Proportional,
-            "tabular" => Self::Tabular,
-            _ => Err(r#"expected "proportional" or "tabular""#)?,
-        },
-    }
-
-    castable! {
-        NumberPosition,
-        Expected: "string",
-        Value::Str(string) => match string.as_str() {
-            "normal" => Self::Normal,
-            "subscript" => Self::Subscript,
-            "superscript" => Self::Superscript,
-            _ => Err(r#"expected "normal", "subscript" or "superscript""#)?,
-        },
-    }
-
-    castable! {
-        Vec<(Tag, u32)>,
-        Expected: "array of strings or dictionary mapping tags to integers",
-        Value::Array(values) => values
-            .into_iter()
-            .filter_map(|v| v.cast().ok())
-            .map(|string: EcoString| (Tag::from_bytes_lossy(string.as_bytes()), 1))
-            .collect(),
-        Value::Dict(values) => values
-            .into_iter()
-            .filter_map(|(k, v)| {
-                let tag = Tag::from_bytes_lossy(k.as_bytes());
-                let num = v.cast::<i64>().ok()?.try_into().ok()?;
-                Some((tag, num))
-            })
-            .collect(),
-    }
-
     let list = args.named("family")?.or_else(|| {
         let families: Vec<_> = args.all().collect();
         (!families.is_empty()).then(|| families)
     });
 
-    let serif = args.named("serif")?;
-    let sans_serif = args.named("sans-serif")?;
-    let monospace = args.named("monospace")?;
-    let fallback = args.named("fallback")?;
-    let style = args.named("style")?;
-    let weight = args.named("weight")?;
-    let stretch = args.named("stretch")?;
-    let size = args.named::<Linear>("size")?.or_else(|| args.find());
-    let tracking = args.named("tracking")?.map(Em::new);
-    let top_edge = args.named("top-edge")?;
-    let bottom_edge = args.named("bottom-edge")?;
-    let fill = args.named("fill")?.or_else(|| args.find());
-    let kerning = args.named("kerning")?;
-    let smallcaps = args.named("smallcaps")?;
-    let alternates = args.named("alternates")?;
-    let stylistic_set = args.named("stylistic-set")?;
-    let ligatures = args.named("ligatures")?;
-    let discretionary_ligatures = args.named("discretionary-ligatures")?;
-    let historical_ligatures = args.named("historical-ligatures")?;
-    let number_type = args.named("number-type")?;
-    let number_width = args.named("number-width")?;
-    let number_position = args.named("number-position")?;
-    let slashed_zero = args.named("slashed-zero")?;
-    let fractions = args.named("fractions")?;
-    let features = args.named("features")?;
-
-    macro_rules! set {
-        ($target:expr => $source:expr) => {
-            if let Some(v) = $source {
-                $target = v;
-            }
-        };
-    }
-
-    let text = ctx.style.text_mut();
-    set!(text.families_mut().list => list.clone());
-    set!(text.families_mut().serif => serif.clone());
-    set!(text.families_mut().sans_serif => sans_serif.clone());
-    set!(text.families_mut().monospace => monospace.clone());
-    set!(text.fallback => fallback);
-    set!(text.variant.style => style);
-    set!(text.variant.weight => weight);
-    set!(text.variant.stretch => stretch);
-    set!(text.size => size.map(|v| v.resolve(text.size)));
-    set!(text.tracking => tracking);
-    set!(text.top_edge => top_edge);
-    set!(text.bottom_edge => bottom_edge);
-    set!(text.fill => fill);
-    set!(text.features_mut().kerning => kerning);
-    set!(text.features_mut().smallcaps => smallcaps);
-    set!(text.features_mut().alternates => alternates);
-    set!(text.features_mut().stylistic_set => stylistic_set);
-    set!(text.features_mut().ligatures.standard => ligatures);
-    set!(text.features_mut().ligatures.discretionary => discretionary_ligatures);
-    set!(text.features_mut().ligatures.historical => historical_ligatures);
-    set!(text.features_mut().numbers.type_ => number_type);
-    set!(text.features_mut().numbers.width => number_width);
-    set!(text.features_mut().numbers.position => number_position);
-    set!(text.features_mut().numbers.slashed_zero => slashed_zero);
-    set!(text.features_mut().numbers.fractions => fractions);
-    set!(text.features_mut().raw => features.clone());
+    set!(ctx, TextNode::FAMILY_LIST => list);
+    set!(ctx, TextNode::SERIF_LIST => args.named("serif")?);
+    set!(ctx, TextNode::SANS_SERIF_LIST => args.named("sans-serif")?);
+    set!(ctx, TextNode::MONOSPACE_LIST => args.named("monospace")?);
+    set!(ctx, TextNode::FALLBACK => args.named("fallback")?);
+    set!(ctx, TextNode::STYLE => args.named("style")?);
+    set!(ctx, TextNode::WEIGHT => args.named("weight")?);
+    set!(ctx, TextNode::STRETCH => args.named("stretch")?);
+    set!(ctx, TextNode::FILL => args.named("fill")?.or_else(|| args.find()));
+    set!(ctx, TextNode::SIZE => args.named("size")?.or_else(|| args.find()));
+    set!(ctx, TextNode::TRACKING => args.named("tracking")?.map(Em::new));
+    set!(ctx, TextNode::TOP_EDGE => args.named("top-edge")?);
+    set!(ctx, TextNode::BOTTOM_EDGE => args.named("bottom-edge")?);
+    set!(ctx, TextNode::KERNING => args.named("kerning")?);
+    set!(ctx, TextNode::SMALLCAPS => args.named("smallcaps")?);
+    set!(ctx, TextNode::ALTERNATES => args.named("alternates")?);
+    set!(ctx, TextNode::STYLISTIC_SET => args.named("stylistic-set")?);
+    set!(ctx, TextNode::LIGATURES => args.named("ligatures")?);
+    set!(ctx, TextNode::DISCRETIONARY_LIGATURES => args.named("discretionary-ligatures")?);
+    set!(ctx, TextNode::HISTORICAL_LIGATURES => args.named("historical-ligatures")?);
+    set!(ctx, TextNode::NUMBER_TYPE => args.named("number-type")?);
+    set!(ctx, TextNode::NUMBER_WIDTH => args.named("number-width")?);
+    set!(ctx, TextNode::NUMBER_POSITION => args.named("number-position")?);
+    set!(ctx, TextNode::SLASHED_ZERO => args.named("slashed-zero")?);
+    set!(ctx, TextNode::FRACTIONS => args.named("fractions")?);
+    set!(ctx, TextNode::FEATURES => args.named("features")?);
 
     Ok(Value::None)
 }
 
+/// A single run of text with the same style.
+#[derive(Debug, Hash)]
+pub struct TextNode(pub EcoString);
+
+properties! {
+    TextNode,
+
+    /// A prioritized sequence of font families.
+    FAMILY_LIST: Vec<FontFamily> = vec![FontFamily::SansSerif],
+    /// The serif font family/families.
+    SERIF_LIST: Vec<String> = vec!["ibm plex serif".into()],
+    /// The sans-serif font family/families.
+    SANS_SERIF_LIST: Vec<String> = vec!["ibm plex sans".into()],
+    /// The monospace font family/families.
+    MONOSPACE_LIST: Vec<String> = vec!["ibm plex mono".into()],
+    /// Whether to allow font fallback when the primary font list contains no
+    /// match.
+    FALLBACK: bool = true,
+
+    /// How the font is styled.
+    STYLE: FontStyle = FontStyle::Normal,
+    /// The boldness / thickness of the font's glyphs.
+    WEIGHT: FontWeight = FontWeight::REGULAR,
+    /// The width of the glyphs.
+    STRETCH: FontStretch = FontStretch::NORMAL,
+    /// Whether the font weight should be increased by 300.
+    STRONG: bool = false,
+    /// Whether the the font style should be inverted.
+    EMPH: bool = false,
+    /// Whether a monospace font should be preferred.
+    MONOSPACE: bool = false,
+    /// The glyph fill color.
+    FILL: Paint = RgbaColor::BLACK.into(),
+
+    /// The size of the glyphs.
+    // TODO(set): Resolve relative to outer font size.
+    SIZE: Length = Length::pt(11.0),
+    /// The amount of space that should be added between characters.
+    TRACKING: Em = Em::zero(),
+    /// The top end of the text bounding box.
+    TOP_EDGE: VerticalFontMetric = VerticalFontMetric::CapHeight,
+    /// The bottom end of the text bounding box.
+    BOTTOM_EDGE: VerticalFontMetric = VerticalFontMetric::Baseline,
+
+    /// Whether to apply kerning ("kern").
+    KERNING: bool = true,
+    /// Whether small capital glyphs should be used. ("smcp")
+    SMALLCAPS: bool = false,
+    /// Whether to apply stylistic alternates. ("salt")
+    ALTERNATES: bool = false,
+    /// Which stylistic set to apply. ("ss01" - "ss20")
+    STYLISTIC_SET: Option<StylisticSet> = None,
+    /// Whether standard ligatures are active. ("liga", "clig")
+    LIGATURES: bool = true,
+    /// Whether ligatures that should be used sparingly are active. ("dlig")
+    DISCRETIONARY_LIGATURES: bool = false,
+    /// Whether historical ligatures are active. ("hlig")
+    HISTORICAL_LIGATURES: bool = false,
+    /// Which kind of numbers / figures to select.
+    NUMBER_TYPE: Smart<NumberType> = Smart::Auto,
+    /// The width of numbers / figures.
+    NUMBER_WIDTH: Smart<NumberWidth> = Smart::Auto,
+    /// How to position numbers.
+    NUMBER_POSITION: NumberPosition = NumberPosition::Normal,
+    /// Whether to have a slash through the zero glyph. ("zero")
+    SLASHED_ZERO: bool = false,
+    /// Whether to convert fractions. ("frac")
+    FRACTIONS: bool = false,
+    /// Raw OpenType features to apply.
+    FEATURES: Vec<(Tag, u32)> = vec![],
+}
+
+/// A generic or named font family.
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub enum FontFamily {
+    /// A family that has "serifs", small strokes attached to letters.
+    Serif,
+    /// A family in which glyphs do not have "serifs", small attached strokes.
+    SansSerif,
+    /// A family in which (almost) all glyphs are of equal width.
+    Monospace,
+    /// A specific family with a name.
+    Named(String),
+}
+
+impl Debug for FontFamily {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.pad(match self {
+            Self::Serif => "serif",
+            Self::SansSerif => "sans-serif",
+            Self::Monospace => "monospace",
+            Self::Named(s) => s,
+        })
+    }
+}
+
+dynamic! {
+    FontFamily: "font family",
+    Value::Str(string) => Self::Named(string.to_lowercase().into()),
+}
+
+castable! {
+    Vec<FontFamily>,
+    Expected: "string, generic family or array thereof",
+    Value::Str(string) => vec![FontFamily::Named(string.to_lowercase().into())],
+    Value::Array(values) => {
+        values.into_iter().filter_map(|v| v.cast().ok()).collect()
+    },
+    @family: FontFamily => vec![family.clone()],
+}
+
+castable! {
+    Vec<String>,
+    Expected: "string or array of strings",
+    Value::Str(string) => vec![string.to_lowercase().into()],
+    Value::Array(values) => values
+        .into_iter()
+        .filter_map(|v| v.cast().ok())
+        .map(|string: EcoString| string.to_lowercase().into())
+        .collect(),
+}
+
+castable! {
+    FontStyle,
+    Expected: "string",
+    Value::Str(string) => match string.as_str() {
+        "normal" => Self::Normal,
+        "italic" => Self::Italic,
+        "oblique" => Self::Oblique,
+        _ => Err(r#"expected "normal", "italic" or "oblique""#)?,
+    },
+}
+
+castable! {
+    FontWeight,
+    Expected: "integer or string",
+    Value::Int(v) => v.try_into().map_or(Self::BLACK, Self::from_number),
+    Value::Str(string) => match string.as_str() {
+        "thin" => Self::THIN,
+        "extralight" => Self::EXTRALIGHT,
+        "light" => Self::LIGHT,
+        "regular" => Self::REGULAR,
+        "medium" => Self::MEDIUM,
+        "semibold" => Self::SEMIBOLD,
+        "bold" => Self::BOLD,
+        "extrabold" => Self::EXTRABOLD,
+        "black" => Self::BLACK,
+        _ => Err("unknown font weight")?,
+    },
+}
+
+castable! {
+    FontStretch,
+    Expected: "relative",
+    Value::Relative(v) => Self::from_ratio(v.get() as f32),
+}
+
+castable! {
+    VerticalFontMetric,
+    Expected: "linear or string",
+    Value::Length(v) => Self::Linear(v.into()),
+    Value::Relative(v) => Self::Linear(v.into()),
+    Value::Linear(v) => Self::Linear(v),
+    Value::Str(string) => match string.as_str() {
+        "ascender" => Self::Ascender,
+        "cap-height" => Self::CapHeight,
+        "x-height" => Self::XHeight,
+        "baseline" => Self::Baseline,
+        "descender" => Self::Descender,
+        _ => Err("unknown font metric")?,
+    },
+}
+
+/// A stylistic set in a font face.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct StylisticSet(u8);
+
+impl StylisticSet {
+    /// Creates a new set, clamping to 1-20.
+    pub fn new(index: u8) -> Self {
+        Self(index.clamp(1, 20))
+    }
+
+    /// Get the value, guaranteed to be 1-20.
+    pub fn get(self) -> u8 {
+        self.0
+    }
+}
+
+castable! {
+    StylisticSet,
+    Expected: "integer",
+    Value::Int(v) => match v {
+        1 ..= 20 => Self::new(v as u8),
+        _ => Err("must be between 1 and 20")?,
+    },
+}
+
+/// Which kind of numbers / figures to select.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum NumberType {
+    /// Numbers that fit well with capital text. ("lnum")
+    Lining,
+    /// Numbers that fit well into flow of upper- and lowercase text. ("onum")
+    OldStyle,
+}
+
+castable! {
+    NumberType,
+    Expected: "string",
+    Value::Str(string) => match string.as_str() {
+        "lining" => Self::Lining,
+        "old-style" => Self::OldStyle,
+        _ => Err(r#"expected "lining" or "old-style""#)?,
+    },
+}
+
+/// The width of numbers / figures.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum NumberWidth {
+    /// Number widths are glyph specific. ("pnum")
+    Proportional,
+    /// All numbers are of equal width / monospaced. ("tnum")
+    Tabular,
+}
+
+castable! {
+    NumberWidth,
+    Expected: "string",
+    Value::Str(string) => match string.as_str() {
+        "proportional" => Self::Proportional,
+        "tabular" => Self::Tabular,
+        _ => Err(r#"expected "proportional" or "tabular""#)?,
+    },
+}
+
+/// How to position numbers.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum NumberPosition {
+    /// Numbers are positioned on the same baseline as text.
+    Normal,
+    /// Numbers are smaller and placed at the bottom. ("subs")
+    Subscript,
+    /// Numbers are smaller and placed at the top. ("sups")
+    Superscript,
+}
+
+castable! {
+    NumberPosition,
+    Expected: "string",
+    Value::Str(string) => match string.as_str() {
+        "normal" => Self::Normal,
+        "subscript" => Self::Subscript,
+        "superscript" => Self::Superscript,
+        _ => Err(r#"expected "normal", "subscript" or "superscript""#)?,
+    },
+}
+
+castable! {
+    Vec<(Tag, u32)>,
+    Expected: "array of strings or dictionary mapping tags to integers",
+    Value::Array(values) => values
+        .into_iter()
+        .filter_map(|v| v.cast().ok())
+        .map(|string: EcoString| (Tag::from_bytes_lossy(string.as_bytes()), 1))
+        .collect(),
+    Value::Dict(values) => values
+        .into_iter()
+        .filter_map(|(k, v)| {
+            let tag = Tag::from_bytes_lossy(k.as_bytes());
+            let num = v.cast::<i64>().ok()?.try_into().ok()?;
+            Some((tag, num))
+        })
+        .collect(),
+}
+
 /// Shape text into [`ShapedText`].
 pub fn shape<'a>(
     ctx: &mut LayoutContext,
     text: &'a str,
-    style: &'a TextStyle,
+    styles: &'a Styles,
     dir: Dir,
 ) -> ShapedText<'a> {
     let mut glyphs = vec![];
@@ -233,188 +341,27 @@ pub fn shape<'a>(
             &mut glyphs,
             0,
             text,
-            style.variant(),
-            style.families(),
+            variant(styles),
+            families(styles),
             None,
             dir,
-            &tags(&style.features),
+            &tags(styles),
         );
     }
 
-    track(&mut glyphs, style.tracking);
+    track(&mut glyphs, styles.get(TextNode::TRACKING));
+    let (size, baseline) = measure(ctx, &glyphs, styles);
 
-    let (size, baseline) = measure(ctx, &glyphs, style);
     ShapedText {
         text,
         dir,
-        style,
+        styles,
         size,
         baseline,
         glyphs: Cow::Owned(glyphs),
     }
 }
 
-/// The result of shaping text.
-///
-/// This type contains owned or borrowed shaped text runs, which can be
-/// measured, used to reshape substrings more quickly and converted into a
-/// frame.
-#[derive(Debug, Clone)]
-pub struct ShapedText<'a> {
-    /// The text that was shaped.
-    pub text: &'a str,
-    /// The text direction.
-    pub dir: Dir,
-    /// The properties used for font selection.
-    pub style: &'a TextStyle,
-    /// The font size.
-    pub size: Size,
-    /// The baseline from the top of the frame.
-    pub baseline: Length,
-    /// The shaped glyphs.
-    pub glyphs: Cow<'a, [ShapedGlyph]>,
-}
-
-/// A single glyph resulting from shaping.
-#[derive(Debug, Copy, Clone)]
-pub struct ShapedGlyph {
-    /// The font face the glyph is contained in.
-    pub face_id: FaceId,
-    /// The glyph's index in the face.
-    pub glyph_id: u16,
-    /// The advance width of the glyph.
-    pub x_advance: Em,
-    /// The horizontal offset of the glyph.
-    pub x_offset: Em,
-    /// The start index of the glyph in the source text.
-    pub text_index: usize,
-    /// Whether splitting the shaping result before this glyph would yield the
-    /// same results as shaping the parts to both sides of `text_index`
-    /// separately.
-    pub safe_to_break: bool,
-}
-
-impl<'a> ShapedText<'a> {
-    /// Build the shaped text's frame.
-    pub fn build(&self) -> Frame {
-        let mut offset = Length::zero();
-        let mut frame = Frame::new(self.size);
-        frame.baseline = Some(self.baseline);
-
-        for (face_id, group) in self.glyphs.as_ref().group_by_key(|g| g.face_id) {
-            let pos = Point::new(offset, self.baseline);
-
-            let mut text = Text {
-                face_id,
-                size: self.style.size,
-                width: Length::zero(),
-                fill: self.style.fill,
-                glyphs: vec![],
-            };
-
-            for glyph in group {
-                text.glyphs.push(Glyph {
-                    id: glyph.glyph_id,
-                    x_advance: glyph.x_advance,
-                    x_offset: glyph.x_offset,
-                });
-                text.width += glyph.x_advance.to_length(text.size);
-            }
-
-            offset += text.width;
-            frame.push(pos, Element::Text(text));
-        }
-
-        frame
-    }
-
-    /// Reshape a range of the shaped text, reusing information from this
-    /// shaping process if possible.
-    pub fn reshape(
-        &'a self,
-        ctx: &mut LayoutContext,
-        text_range: Range<usize>,
-    ) -> ShapedText<'a> {
-        if let Some(glyphs) = self.slice_safe_to_break(text_range.clone()) {
-            let (size, baseline) = measure(ctx, glyphs, self.style);
-            Self {
-                text: &self.text[text_range],
-                dir: self.dir,
-                style: self.style,
-                size,
-                baseline,
-                glyphs: Cow::Borrowed(glyphs),
-            }
-        } else {
-            shape(ctx, &self.text[text_range], self.style, self.dir)
-        }
-    }
-
-    /// Find the subslice of glyphs that represent the given text range if both
-    /// sides are safe to break.
-    fn slice_safe_to_break(&self, text_range: Range<usize>) -> Option<&[ShapedGlyph]> {
-        let Range { mut start, mut end } = text_range;
-        if !self.dir.is_positive() {
-            std::mem::swap(&mut start, &mut end);
-        }
-
-        let left = self.find_safe_to_break(start, Side::Left)?;
-        let right = self.find_safe_to_break(end, Side::Right)?;
-        Some(&self.glyphs[left .. right])
-    }
-
-    /// Find the glyph offset matching the text index that is most towards the
-    /// given side and safe-to-break.
-    fn find_safe_to_break(&self, text_index: usize, towards: Side) -> Option<usize> {
-        let ltr = self.dir.is_positive();
-
-        // Handle edge cases.
-        let len = self.glyphs.len();
-        if text_index == 0 {
-            return Some(if ltr { 0 } else { len });
-        } else if text_index == self.text.len() {
-            return Some(if ltr { len } else { 0 });
-        }
-
-        // Find any glyph with the text index.
-        let mut idx = self
-            .glyphs
-            .binary_search_by(|g| {
-                let ordering = g.text_index.cmp(&text_index);
-                if ltr { ordering } else { ordering.reverse() }
-            })
-            .ok()?;
-
-        let next = match towards {
-            Side::Left => usize::checked_sub,
-            Side::Right => usize::checked_add,
-        };
-
-        // Search for the outermost glyph with the text index.
-        while let Some(next) = next(idx, 1) {
-            if self.glyphs.get(next).map_or(true, |g| g.text_index != text_index) {
-                break;
-            }
-            idx = next;
-        }
-
-        // RTL needs offset one because the left side of the range should be
-        // exclusive and the right side inclusive, contrary to the normal
-        // behaviour of ranges.
-        if !ltr {
-            idx += 1;
-        }
-
-        self.glyphs[idx].safe_to_break.then(|| idx)
-    }
-}
-
-/// A visual side.
-enum Side {
-    Left,
-    Right,
-}
-
 /// Shape text with font fallback using the `families` iterator.
 fn shape_segment<'a>(
     fonts: &mut FontStore,
@@ -562,23 +509,27 @@ fn track(glyphs: &mut [ShapedGlyph], tracking: Em) {
 fn measure(
     ctx: &mut LayoutContext,
     glyphs: &[ShapedGlyph],
-    style: &TextStyle,
+    styles: &Styles,
 ) -> (Size, Length) {
     let mut width = Length::zero();
     let mut top = Length::zero();
     let mut bottom = Length::zero();
 
+    let size = styles.get(TextNode::SIZE);
+    let top_edge = styles.get(TextNode::TOP_EDGE);
+    let bottom_edge = styles.get(TextNode::BOTTOM_EDGE);
+
     // Expand top and bottom by reading the face's vertical metrics.
     let mut expand = |face: &Face| {
-        top.set_max(face.vertical_metric(style.top_edge, style.size));
-        bottom.set_max(-face.vertical_metric(style.bottom_edge, style.size));
+        top.set_max(face.vertical_metric(top_edge, size));
+        bottom.set_max(-face.vertical_metric(bottom_edge, size));
     };
 
     if glyphs.is_empty() {
         // When there are no glyphs, we just use the vertical metrics of the
         // first available font.
-        for family in style.families() {
-            if let Some(face_id) = ctx.fonts.select(family, style.variant) {
+        for family in families(styles) {
+            if let Some(face_id) = ctx.fonts.select(family, variant(styles)) {
                 expand(ctx.fonts.get(face_id));
                 break;
             }
@@ -589,7 +540,7 @@ fn measure(
             expand(face);
 
             for glyph in group {
-                width += glyph.x_advance.to_length(style.size);
+                width += glyph.x_advance.to_length(size);
             }
         }
     }
@@ -597,75 +548,286 @@ fn measure(
     (Size::new(width, top + bottom), top)
 }
 
+/// Resolved the font variant with `STRONG` and `EMPH` factored in.
+fn variant(styles: &Styles) -> FontVariant {
+    let mut variant = FontVariant::new(
+        styles.get(TextNode::STYLE),
+        styles.get(TextNode::WEIGHT),
+        styles.get(TextNode::STRETCH),
+    );
+
+    if styles.get(TextNode::STRONG) {
+        variant.weight = variant.weight.thicken(300);
+    }
+
+    if styles.get(TextNode::EMPH) {
+        variant.style = match variant.style {
+            FontStyle::Normal => FontStyle::Italic,
+            FontStyle::Italic => FontStyle::Normal,
+            FontStyle::Oblique => FontStyle::Normal,
+        }
+    }
+
+    variant
+}
+
+/// Resolve a prioritized iterator over the font families.
+fn families(styles: &Styles) -> impl Iterator<Item = &str> + Clone {
+    let head = if styles.get(TextNode::MONOSPACE) {
+        styles.get_ref(TextNode::MONOSPACE_LIST).as_slice()
+    } else {
+        &[]
+    };
+
+    let core = styles.get_ref(TextNode::FAMILY_LIST).iter().flat_map(move |family| {
+        match family {
+            FontFamily::Named(name) => std::slice::from_ref(name),
+            FontFamily::Serif => styles.get_ref(TextNode::SERIF_LIST),
+            FontFamily::SansSerif => styles.get_ref(TextNode::SANS_SERIF_LIST),
+            FontFamily::Monospace => styles.get_ref(TextNode::MONOSPACE_LIST),
+        }
+    });
+
+    let tail: &[&str] = if styles.get(TextNode::FALLBACK) {
+        &["ibm plex sans", "latin modern math", "twitter color emoji"]
+    } else {
+        &[]
+    };
+
+    head.iter()
+        .chain(core)
+        .map(String::as_str)
+        .chain(tail.iter().copied())
+}
+
 /// Collect the tags of the OpenType features to apply.
-fn tags(features: &FontFeatures) -> Vec<Feature> {
+fn tags(styles: &Styles) -> Vec<Feature> {
     let mut tags = vec![];
     let mut feat = |tag, value| {
         tags.push(Feature::new(Tag::from_bytes(tag), value, ..));
     };
 
     // Features that are on by default in Harfbuzz are only added if disabled.
-    if !features.kerning {
+    if !styles.get(TextNode::KERNING) {
         feat(b"kern", 0);
     }
 
     // Features that are off by default in Harfbuzz are only added if enabled.
-    if features.smallcaps {
+    if styles.get(TextNode::SMALLCAPS) {
         feat(b"smcp", 1);
     }
 
-    if features.alternates {
+    if styles.get(TextNode::ALTERNATES) {
         feat(b"salt", 1);
     }
 
     let storage;
-    if let Some(set) = features.stylistic_set {
+    if let Some(set) = styles.get(TextNode::STYLISTIC_SET) {
         storage = [b's', b's', b'0' + set.get() / 10, b'0' + set.get() % 10];
         feat(&storage, 1);
     }
 
-    if !features.ligatures.standard {
+    if !styles.get(TextNode::LIGATURES) {
         feat(b"liga", 0);
         feat(b"clig", 0);
     }
 
-    if features.ligatures.discretionary {
+    if styles.get(TextNode::DISCRETIONARY_LIGATURES) {
         feat(b"dlig", 1);
     }
 
-    if features.ligatures.historical {
+    if styles.get(TextNode::HISTORICAL_LIGATURES) {
         feat(b"hilg", 1);
     }
 
-    match features.numbers.type_ {
+    match styles.get(TextNode::NUMBER_TYPE) {
         Smart::Auto => {}
         Smart::Custom(NumberType::Lining) => feat(b"lnum", 1),
         Smart::Custom(NumberType::OldStyle) => feat(b"onum", 1),
     }
 
-    match features.numbers.width {
+    match styles.get(TextNode::NUMBER_WIDTH) {
         Smart::Auto => {}
         Smart::Custom(NumberWidth::Proportional) => feat(b"pnum", 1),
         Smart::Custom(NumberWidth::Tabular) => feat(b"tnum", 1),
     }
 
-    match features.numbers.position {
+    match styles.get(TextNode::NUMBER_POSITION) {
         NumberPosition::Normal => {}
         NumberPosition::Subscript => feat(b"subs", 1),
         NumberPosition::Superscript => feat(b"sups", 1),
     }
 
-    if features.numbers.slashed_zero {
+    if styles.get(TextNode::SLASHED_ZERO) {
         feat(b"zero", 1);
     }
 
-    if features.numbers.fractions {
+    if styles.get(TextNode::FRACTIONS) {
         feat(b"frac", 1);
     }
 
-    for &(tag, value) in features.raw.iter() {
+    for &(tag, value) in styles.get_ref(TextNode::FEATURES).iter() {
         tags.push(Feature::new(tag, value, ..))
     }
 
     tags
 }
+
+/// The result of shaping text.
+///
+/// This type contains owned or borrowed shaped text runs, which can be
+/// measured, used to reshape substrings more quickly and converted into a
+/// frame.
+#[derive(Debug, Clone)]
+pub struct ShapedText<'a> {
+    /// The text that was shaped.
+    pub text: &'a str,
+    /// The text direction.
+    pub dir: Dir,
+    /// The text's style properties.
+    pub styles: &'a Styles,
+    /// The font size.
+    pub size: Size,
+    /// The baseline from the top of the frame.
+    pub baseline: Length,
+    /// The shaped glyphs.
+    pub glyphs: Cow<'a, [ShapedGlyph]>,
+}
+
+/// A single glyph resulting from shaping.
+#[derive(Debug, Copy, Clone)]
+pub struct ShapedGlyph {
+    /// The font face the glyph is contained in.
+    pub face_id: FaceId,
+    /// The glyph's index in the face.
+    pub glyph_id: u16,
+    /// The advance width of the glyph.
+    pub x_advance: Em,
+    /// The horizontal offset of the glyph.
+    pub x_offset: Em,
+    /// The start index of the glyph in the source text.
+    pub text_index: usize,
+    /// Whether splitting the shaping result before this glyph would yield the
+    /// same results as shaping the parts to both sides of `text_index`
+    /// separately.
+    pub safe_to_break: bool,
+}
+
+impl<'a> ShapedText<'a> {
+    /// Build the shaped text's frame.
+    pub fn build(&self) -> Frame {
+        let mut offset = Length::zero();
+        let mut frame = Frame::new(self.size);
+        frame.baseline = Some(self.baseline);
+
+        for (face_id, group) in self.glyphs.as_ref().group_by_key(|g| g.face_id) {
+            let pos = Point::new(offset, self.baseline);
+
+            let mut text = Text {
+                face_id,
+                size: self.styles.get(TextNode::SIZE),
+                fill: self.styles.get(TextNode::FILL),
+                glyphs: vec![],
+            };
+
+            for glyph in group {
+                text.glyphs.push(Glyph {
+                    id: glyph.glyph_id,
+                    x_advance: glyph.x_advance,
+                    x_offset: glyph.x_offset,
+                });
+            }
+
+            offset += text.width();
+            frame.push(pos, Element::Text(text));
+        }
+
+        frame
+    }
+
+    /// Reshape a range of the shaped text, reusing information from this
+    /// shaping process if possible.
+    pub fn reshape(
+        &'a self,
+        ctx: &mut LayoutContext,
+        text_range: Range<usize>,
+    ) -> ShapedText<'a> {
+        if let Some(glyphs) = self.slice_safe_to_break(text_range.clone()) {
+            let (size, baseline) = measure(ctx, glyphs, self.styles);
+            Self {
+                text: &self.text[text_range],
+                dir: self.dir,
+                styles: self.styles,
+                size,
+                baseline,
+                glyphs: Cow::Borrowed(glyphs),
+            }
+        } else {
+            shape(ctx, &self.text[text_range], self.styles, self.dir)
+        }
+    }
+
+    /// Find the subslice of glyphs that represent the given text range if both
+    /// sides are safe to break.
+    fn slice_safe_to_break(&self, text_range: Range<usize>) -> Option<&[ShapedGlyph]> {
+        let Range { mut start, mut end } = text_range;
+        if !self.dir.is_positive() {
+            std::mem::swap(&mut start, &mut end);
+        }
+
+        let left = self.find_safe_to_break(start, Side::Left)?;
+        let right = self.find_safe_to_break(end, Side::Right)?;
+        Some(&self.glyphs[left .. right])
+    }
+
+    /// Find the glyph offset matching the text index that is most towards the
+    /// given side and safe-to-break.
+    fn find_safe_to_break(&self, text_index: usize, towards: Side) -> Option<usize> {
+        let ltr = self.dir.is_positive();
+
+        // Handle edge cases.
+        let len = self.glyphs.len();
+        if text_index == 0 {
+            return Some(if ltr { 0 } else { len });
+        } else if text_index == self.text.len() {
+            return Some(if ltr { len } else { 0 });
+        }
+
+        // Find any glyph with the text index.
+        let mut idx = self
+            .glyphs
+            .binary_search_by(|g| {
+                let ordering = g.text_index.cmp(&text_index);
+                if ltr { ordering } else { ordering.reverse() }
+            })
+            .ok()?;
+
+        let next = match towards {
+            Side::Left => usize::checked_sub,
+            Side::Right => usize::checked_add,
+        };
+
+        // Search for the outermost glyph with the text index.
+        while let Some(next) = next(idx, 1) {
+            if self.glyphs.get(next).map_or(true, |g| g.text_index != text_index) {
+                break;
+            }
+            idx = next;
+        }
+
+        // RTL needs offset one because the left side of the range should be
+        // exclusive and the right side inclusive, contrary to the normal
+        // behaviour of ranges.
+        if !ltr {
+            idx += 1;
+        }
+
+        self.glyphs[idx].safe_to_break.then(|| idx)
+    }
+}
+
+/// A visual side.
+enum Side {
+    Left,
+    Right,
+}
diff --git a/src/library/transform.rs b/src/library/transform.rs
index 1b30c5b0c..6a6b40348 100644
--- a/src/library/transform.rs
+++ b/src/library/transform.rs
@@ -31,6 +31,7 @@ fn transform_impl(args: &mut Args, transform: Transform) -> TypResult<Value> {
         .named("origin")?
         .unwrap_or(Spec::splat(None))
         .unwrap_or(Align::CENTER_HORIZON);
+
     Ok(Value::inline(
         body.into_block().transformed(transform, origin),
     ))
diff --git a/src/style/mod.rs b/src/style/mod.rs
deleted file mode 100644
index 45dbeb546..000000000
--- a/src/style/mod.rs
+++ /dev/null
@@ -1,419 +0,0 @@
-//! Style properties.
-
-mod paper;
-
-pub use paper::*;
-
-use std::fmt::{self, Debug, Formatter};
-use std::rc::Rc;
-
-use ttf_parser::Tag;
-
-use crate::eval::Smart;
-use crate::font::*;
-use crate::geom::*;
-use crate::util::EcoString;
-
-/// Defines a set of properties a template can be instantiated with.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Style {
-    /// The page settings.
-    pub page: Rc<PageStyle>,
-    /// The paragraph settings.
-    pub par: Rc<ParStyle>,
-    /// The current text settings.
-    pub text: Rc<TextStyle>,
-}
-
-impl Style {
-    /// Access the `page` style mutably.
-    pub fn page_mut(&mut self) -> &mut PageStyle {
-        Rc::make_mut(&mut self.page)
-    }
-
-    /// Access the `par` style mutably.
-    pub fn par_mut(&mut self) -> &mut ParStyle {
-        Rc::make_mut(&mut self.par)
-    }
-
-    /// Access the `text` style mutably.
-    pub fn text_mut(&mut self) -> &mut TextStyle {
-        Rc::make_mut(&mut self.text)
-    }
-
-    /// The resolved line spacing.
-    pub fn leading(&self) -> Length {
-        self.par.leading.resolve(self.text.size)
-    }
-
-    /// The resolved paragraph spacing.
-    pub fn par_spacing(&self) -> Length {
-        self.par.spacing.resolve(self.text.size)
-    }
-}
-
-impl Default for Style {
-    fn default() -> Self {
-        Self {
-            page: Rc::new(PageStyle::default()),
-            par: Rc::new(ParStyle::default()),
-            text: Rc::new(TextStyle::default()),
-        }
-    }
-}
-
-/// Defines style properties of pages.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct PageStyle {
-    /// The class of this page.
-    pub class: PaperClass,
-    /// The width and height of the page.
-    pub size: Size,
-    /// The amount of white space on each side of the page. If a side is set to
-    /// `None`, the default for the paper class is used.
-    pub margins: Sides<Smart<Linear>>,
-    /// The background fill of the page.
-    pub fill: Option<Paint>,
-}
-
-impl PageStyle {
-    /// The resolved margins.
-    pub fn margins(&self) -> Sides<Linear> {
-        let default = self.class.default_margins();
-        Sides {
-            left: self.margins.left.unwrap_or(default.left),
-            top: self.margins.top.unwrap_or(default.top),
-            right: self.margins.right.unwrap_or(default.right),
-            bottom: self.margins.bottom.unwrap_or(default.bottom),
-        }
-    }
-}
-
-impl Default for PageStyle {
-    fn default() -> Self {
-        let paper = Paper::A4;
-        Self {
-            class: paper.class(),
-            size: paper.size(),
-            margins: Sides::splat(Smart::Auto),
-            fill: None,
-        }
-    }
-}
-
-/// Defines style properties of paragraphs.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ParStyle {
-    /// The direction for text and inline objects.
-    pub dir: Dir,
-    /// How to align text and inline objects in their line.
-    pub align: Align,
-    /// The spacing between lines (dependent on scaled font size).
-    pub leading: Linear,
-    /// The spacing between paragraphs (dependent on scaled font size).
-    pub spacing: Linear,
-}
-
-impl Default for ParStyle {
-    fn default() -> Self {
-        Self {
-            dir: Dir::LTR,
-            align: Align::Left,
-            leading: Relative::new(0.65).into(),
-            spacing: Relative::new(1.2).into(),
-        }
-    }
-}
-
-/// Defines style properties of text.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct TextStyle {
-    /// The font size.
-    pub size: Length,
-    /// The selected font variant (the final variant also depends on `strong`
-    /// and `emph`).
-    pub variant: FontVariant,
-    /// The top end of the text bounding box.
-    pub top_edge: VerticalFontMetric,
-    /// The bottom end of the text bounding box.
-    pub bottom_edge: VerticalFontMetric,
-    /// Glyph color.
-    pub fill: Paint,
-    /// A list of font families with generic class definitions (the final
-    /// family list also depends on `monospace`).
-    pub families: Rc<FamilyStyle>,
-    /// OpenType features.
-    pub features: Rc<FontFeatures>,
-    /// The amount of space that should be added between character.
-    pub tracking: Em,
-    /// Whether 300 extra font weight should be added to what is defined by the
-    /// `variant`.
-    pub strong: bool,
-    /// Whether the the font style defined by the `variant` should be inverted.
-    pub emph: bool,
-    /// Whether a monospace font should be preferred.
-    pub monospace: bool,
-    /// Whether font fallback to a base list should occur.
-    pub fallback: bool,
-}
-
-impl TextStyle {
-    /// The resolved variant with `strong` and `emph` factored in.
-    pub fn variant(&self) -> FontVariant {
-        let mut variant = self.variant;
-
-        if self.strong {
-            variant.weight = variant.weight.thicken(300);
-        }
-
-        if self.emph {
-            variant.style = match variant.style {
-                FontStyle::Normal => FontStyle::Italic,
-                FontStyle::Italic => FontStyle::Normal,
-                FontStyle::Oblique => FontStyle::Normal,
-            }
-        }
-
-        variant
-    }
-
-    /// The resolved family iterator.
-    pub fn families(&self) -> impl Iterator<Item = &str> + Clone {
-        let head = if self.monospace {
-            self.families.monospace.as_slice()
-        } else {
-            &[]
-        };
-
-        let core = self.families.list.iter().flat_map(move |family| {
-            match family {
-                FontFamily::Named(name) => std::slice::from_ref(name),
-                FontFamily::Serif => &self.families.serif,
-                FontFamily::SansSerif => &self.families.sans_serif,
-                FontFamily::Monospace => &self.families.monospace,
-            }
-        });
-
-        let tail = if self.fallback {
-            self.families.base.as_slice()
-        } else {
-            &[]
-        };
-
-        head.iter().chain(core).chain(tail).map(EcoString::as_str)
-    }
-
-    /// Access the `families` style mutably.
-    pub fn families_mut(&mut self) -> &mut FamilyStyle {
-        Rc::make_mut(&mut self.families)
-    }
-
-    /// Access the font `features` mutably.
-    pub fn features_mut(&mut self) -> &mut FontFeatures {
-        Rc::make_mut(&mut self.features)
-    }
-}
-
-impl Default for TextStyle {
-    fn default() -> Self {
-        Self {
-            size: Length::pt(11.0),
-            variant: FontVariant {
-                style: FontStyle::Normal,
-                weight: FontWeight::REGULAR,
-                stretch: FontStretch::NORMAL,
-            },
-            top_edge: VerticalFontMetric::CapHeight,
-            bottom_edge: VerticalFontMetric::Baseline,
-            fill: RgbaColor::BLACK.into(),
-            families: Rc::new(FamilyStyle::default()),
-            features: Rc::new(FontFeatures::default()),
-            tracking: Em::zero(),
-            strong: false,
-            emph: false,
-            monospace: false,
-            fallback: true,
-        }
-    }
-}
-
-/// Font list with family definitions.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct FamilyStyle {
-    /// The user-defined list of font families.
-    pub list: Vec<FontFamily>,
-    /// Definition of serif font families.
-    pub serif: Vec<EcoString>,
-    /// Definition of sans-serif font families.
-    pub sans_serif: Vec<EcoString>,
-    /// Definition of monospace font families used for raw text.
-    pub monospace: Vec<EcoString>,
-    /// Base fonts that are tried as last resort.
-    pub base: Vec<EcoString>,
-}
-
-impl Default for FamilyStyle {
-    fn default() -> Self {
-        Self {
-            list: vec![FontFamily::SansSerif],
-            serif: vec!["ibm plex serif".into()],
-            sans_serif: vec!["ibm plex sans".into()],
-            monospace: vec!["ibm plex mono".into()],
-            base: vec![
-                "ibm plex sans".into(),
-                "latin modern math".into(),
-                "twitter color emoji".into(),
-            ],
-        }
-    }
-}
-
-/// A generic or named font family.
-#[derive(Clone, Eq, PartialEq, Hash)]
-pub enum FontFamily {
-    /// A family that has "serifs", small strokes attached to letters.
-    Serif,
-    /// A family in which glyphs do not have "serifs", small attached strokes.
-    SansSerif,
-    /// A family in which (almost) all glyphs are of equal width.
-    Monospace,
-    /// A specific family with a name.
-    Named(EcoString),
-}
-
-impl Debug for FontFamily {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.pad(match self {
-            Self::Serif => "serif",
-            Self::SansSerif => "sans-serif",
-            Self::Monospace => "monospace",
-            Self::Named(s) => s,
-        })
-    }
-}
-
-/// Whether various kinds of ligatures should appear.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct FontFeatures {
-    /// Whether to apply kerning ("kern").
-    pub kerning: bool,
-    /// Whether the text should use small caps. ("smcp")
-    pub smallcaps: bool,
-    /// Whether to apply stylistic alternates. ("salt")
-    pub alternates: bool,
-    /// Which stylistic set to apply. ("ss01" - "ss20")
-    pub stylistic_set: Option<StylisticSet>,
-    /// Configuration of ligature features.
-    pub ligatures: LigatureFeatures,
-    /// Configuration of numbers features.
-    pub numbers: NumberFeatures,
-    /// Raw OpenType features to apply.
-    pub raw: Vec<(Tag, u32)>,
-}
-
-impl Default for FontFeatures {
-    fn default() -> Self {
-        Self {
-            kerning: true,
-            smallcaps: false,
-            alternates: false,
-            stylistic_set: None,
-            ligatures: LigatureFeatures::default(),
-            numbers: NumberFeatures::default(),
-            raw: vec![],
-        }
-    }
-}
-
-/// A stylistic set in a font face.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct StylisticSet(u8);
-
-impl StylisticSet {
-    /// Creates a new set, clamping to 1-20.
-    pub fn new(index: u8) -> Self {
-        Self(index.clamp(1, 20))
-    }
-
-    /// Get the value, guaranteed to be 1-20.
-    pub fn get(self) -> u8 {
-        self.0
-    }
-}
-
-/// Whether various kinds of ligatures should appear.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct LigatureFeatures {
-    /// Standard ligatures. ("liga", "clig")
-    pub standard: bool,
-    /// Ligatures that should be used sparringly. ("dlig")
-    pub discretionary: bool,
-    /// Historical ligatures. ("hlig")
-    pub historical: bool,
-}
-
-impl Default for LigatureFeatures {
-    fn default() -> Self {
-        Self {
-            standard: true,
-            discretionary: false,
-            historical: false,
-        }
-    }
-}
-
-/// Defines the style of numbers.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct NumberFeatures {
-    /// Whether to use lining or old-style numbers.
-    pub type_: Smart<NumberType>,
-    /// Whether to use proportional or tabular numbers.
-    pub width: Smart<NumberWidth>,
-    /// How to position numbers vertically.
-    pub position: NumberPosition,
-    /// Whether to have a slash through the zero glyph. ("zero")
-    pub slashed_zero: bool,
-    /// Whether to convert fractions. ("frac")
-    pub fractions: bool,
-}
-
-impl Default for NumberFeatures {
-    fn default() -> Self {
-        Self {
-            type_: Smart::Auto,
-            width: Smart::Auto,
-            position: NumberPosition::Normal,
-            slashed_zero: false,
-            fractions: false,
-        }
-    }
-}
-
-/// Which kind of numbers / figures to select.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum NumberType {
-    /// Numbers that fit well with capital text. ("lnum")
-    Lining,
-    /// Numbers that fit well into flow of upper- and lowercase text. ("onum")
-    OldStyle,
-}
-
-/// The width of numbers / figures.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum NumberWidth {
-    /// Number widths are glyph specific. ("pnum")
-    Proportional,
-    /// All numbers are of equal width / monospaced. ("tnum")
-    Tabular,
-}
-
-/// How to position numbers.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum NumberPosition {
-    /// Numbers are positioned on the same baseline as text.
-    Normal,
-    /// Numbers are smaller and placed at the bottom. ("subs")
-    Subscript,
-    /// Numbers are smaller and placed at the top. ("sups")
-    Superscript,
-}
diff --git a/src/style/paper.rs b/src/style/paper.rs
deleted file mode 100644
index 252d293de..000000000
--- a/src/style/paper.rs
+++ /dev/null
@@ -1,233 +0,0 @@
-use crate::geom::{Length, Linear, Relative, Sides, Size};
-
-/// Specification of a paper.
-#[derive(Debug, Copy, Clone)]
-pub struct Paper {
-    /// The broad class this paper belongs to.
-    class: PaperClass,
-    /// The width of the paper in millimeters.
-    width: f64,
-    /// The height of the paper in millimeters.
-    height: f64,
-}
-
-/// Defines default margins for a class of related papers.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum PaperClass {
-    Custom,
-    Base,
-    US,
-    Newspaper,
-    Book,
-}
-
-impl PaperClass {
-    /// The default margins for this page class.
-    pub fn default_margins(self) -> Sides<Linear> {
-        let f = |r| Relative::new(r).into();
-        let s = |l, t, r, b| Sides::new(f(l), f(t), f(r), f(b));
-        match self {
-            Self::Custom => s(0.1190, 0.0842, 0.1190, 0.0842),
-            Self::Base => s(0.1190, 0.0842, 0.1190, 0.0842),
-            Self::US => s(0.1760, 0.1092, 0.1760, 0.0910),
-            Self::Newspaper => s(0.0455, 0.0587, 0.0455, 0.0294),
-            Self::Book => s(0.1200, 0.0852, 0.1500, 0.0965),
-        }
-    }
-}
-
-macro_rules! papers {
-    ($(($var:ident: $class:ident, $width:expr, $height: expr, $($pats:tt)*))*) => {
-        impl Paper {
-            /// Parse a paper from its name.
-            ///
-            /// Both lower and upper case are fine.
-            pub fn from_name(name: &str) -> Option<Self> {
-                match name.to_lowercase().as_str() {
-                    $($($pats)* => Some(Self::$var),)*
-                    _ => None,
-                }
-            }
-
-            /// The class of the paper.
-            pub fn class(self) -> PaperClass {
-                self.class
-            }
-
-            /// The size of the paper.
-            pub fn size(self) -> Size {
-                Size::new(Length::mm(self.width), Length::mm(self.height))
-            }
-        }
-
-        /// Predefined papers.
-        ///
-        /// Each paper is parsable from its name in kebab-case.
-        impl Paper {
-            $(papers!(@$var, stringify!($($pats)*), $class, $width, $height);)*
-        }
-    };
-
-    (@$var:ident, $names:expr, $class:ident, $width:expr, $height:expr) => {
-        pub const $var: Self = Self {
-            class: PaperClass::$class,
-            width: $width,
-            height: $height,
-        };
-    };
-}
-
-// All paper sizes in mm.
-//
-// Resources:
-// - https://papersizes.io/
-// - https://en.wikipedia.org/wiki/Paper_size
-// - https://www.theedkins.co.uk/jo/units/oldunits/print.htm
-// - https://vintagepaper.co/blogs/news/traditional-paper-sizes
-papers! {
-    // ---------------------------------------------------------------------- //
-    // ISO 216 A Series
-    (A0:  Base, 841.0, 1189.0, "a0")
-    (A1:  Base, 594.0,  841.0, "a1")
-    (A2:  Base, 420.0,  594.0, "a2")
-    (A3:  Base, 297.0,  420.0, "a3")
-    (A4:  Base, 210.0,  297.0, "a4")
-    (A5:  Base, 148.0,  210.0, "a5")
-    (A6:  Book, 105.0,  148.0, "a6")
-    (A7:  Base,  74.0,  105.0, "a7")
-    (A8:  Base,  52.0,   74.0, "a8")
-    (A9:  Base,  37.0,   52.0, "a9")
-    (A10: Base,  26.0,   37.0, "a10")
-    (A11: Base,  18.0,   26.0, "a11")
-
-    // ISO 216 B Series
-    (ISO_B1: Base, 707.0, 1000.0, "iso-b1")
-    (ISO_B2: Base, 500.0, 707.0,  "iso-b2")
-    (ISO_B3: Base, 353.0, 500.0,  "iso-b3")
-    (ISO_B4: Base, 250.0, 353.0,  "iso-b4")
-    (ISO_B5: Book, 176.0, 250.0,  "iso-b5")
-    (ISO_B6: Book, 125.0, 176.0,  "iso-b6")
-    (ISO_B7: Base,  88.0, 125.0,  "iso-b7")
-    (ISO_B8: Base,  62.0,  88.0,  "iso-b8")
-
-    // ISO 216 C Series
-    (ISO_C3: Base, 324.0, 458.0, "iso-c3")
-    (ISO_C4: Base, 229.0, 324.0, "iso-c4")
-    (ISO_C5: Base, 162.0, 229.0, "iso-c5")
-    (ISO_C6: Base, 114.0, 162.0, "iso-c6")
-    (ISO_C7: Base,  81.0, 114.0, "iso-c7")
-    (ISO_C8: Base,  57.0,  81.0, "iso-c8")
-
-    // DIN D Series (extension to ISO)
-    (DIN_D3: Base, 272.0, 385.0, "din-d3")
-    (DIN_D4: Base, 192.0, 272.0, "din-d4")
-    (DIN_D5: Base, 136.0, 192.0, "din-d5")
-    (DIN_D6: Base,  96.0, 136.0, "din-d6")
-    (DIN_D7: Base,  68.0,  96.0, "din-d7")
-    (DIN_D8: Base,  48.0,  68.0, "din-d8")
-
-    // SIS (used in academia)
-    (SIS_G5: Base, 169.0, 239.0, "sis-g5")
-    (SIS_E5: Base, 115.0, 220.0, "sis-e5")
-
-    // ANSI Extensions
-    (ANSI_A: Base, 216.0,  279.0, "ansi-a")
-    (ANSI_B: Base, 279.0,  432.0, "ansi-b")
-    (ANSI_C: Base, 432.0,  559.0, "ansi-c")
-    (ANSI_D: Base, 559.0,  864.0, "ansi-d")
-    (ANSI_E: Base, 864.0, 1118.0, "ansi-e")
-
-    // ANSI Architectural Paper
-    (ARCH_A:  Base, 229.0,  305.0, "arch-a")
-    (ARCH_B:  Base, 305.0,  457.0, "arch-b")
-    (ARCH_C:  Base, 457.0,  610.0, "arch-c")
-    (ARCH_D:  Base, 610.0,  914.0, "arch-d")
-    (ARCH_E1: Base, 762.0, 1067.0, "arch-e1")
-    (ARCH_E:  Base, 914.0, 1219.0, "arch-e")
-
-    // JIS B Series
-    (JIS_B0:  Base, 1030.0, 1456.0, "jis-b0")
-    (JIS_B1:  Base,  728.0, 1030.0, "jis-b1")
-    (JIS_B2:  Base,  515.0,  728.0, "jis-b2")
-    (JIS_B3:  Base,  364.0,  515.0, "jis-b3")
-    (JIS_B4:  Base,  257.0,  364.0, "jis-b4")
-    (JIS_B5:  Base,  182.0,  257.0, "jis-b5")
-    (JIS_B6:  Base,  128.0,  182.0, "jis-b6")
-    (JIS_B7:  Base,   91.0,  128.0, "jis-b7")
-    (JIS_B8:  Base,   64.0,   91.0, "jis-b8")
-    (JIS_B9:  Base,   45.0,   64.0, "jis-b9")
-    (JIS_B10: Base,   32.0,   45.0, "jis-b10")
-    (JIS_B11: Base,   22.0,   32.0, "jis-b11")
-
-    // SAC D Series
-    (SAC_D0: Base, 764.0, 1064.0, "sac-d0")
-    (SAC_D1: Base, 532.0,  760.0, "sac-d1")
-    (SAC_D2: Base, 380.0,  528.0, "sac-d2")
-    (SAC_D3: Base, 264.0,  376.0, "sac-d3")
-    (SAC_D4: Base, 188.0,  260.0, "sac-d4")
-    (SAC_D5: Base, 130.0,  184.0, "sac-d5")
-    (SAC_D6: Base,  92.0,  126.0, "sac-d6")
-
-    // ISO 7810 ID
-    (ISO_ID_1: Base, 85.6, 53.98, "iso-id-1")
-    (ISO_ID_2: Base, 74.0, 105.0, "iso-id-2")
-    (ISO_ID_3: Base, 88.0, 125.0, "iso-id-3")
-
-    // ---------------------------------------------------------------------- //
-    // Asia
-    (ASIA_F4: Base, 210.0, 330.0, "asia-f4")
-
-    // Japan
-    (JP_SHIROKU_BAN_4: Base, 264.0, 379.0, "jp-shiroku-ban-4")
-    (JP_SHIROKU_BAN_5: Base, 189.0, 262.0, "jp-shiroku-ban-5")
-    (JP_SHIROKU_BAN_6: Base, 127.0, 188.0, "jp-shiroku-ban-6")
-    (JP_KIKU_4:        Base, 227.0, 306.0, "jp-kiku-4")
-    (JP_KIKU_5:        Base, 151.0, 227.0, "jp-kiku-5")
-    (JP_BUSINESS_CARD: Base,  91.0,  55.0, "jp-business-card")
-
-    // China
-    (CN_BUSINESS_CARD: Base, 90.0, 54.0, "cn-business-card")
-
-    // Europe
-    (EU_BUSINESS_CARD: Base, 85.0, 55.0, "eu-business-card")
-
-    // French Traditional (AFNOR)
-    (FR_TELLIERE:          Base, 340.0, 440.0, "fr-tellière")
-    (FR_COURONNE_ECRITURE: Base, 360.0, 460.0, "fr-couronne-écriture")
-    (FR_COURONNE_EDITION:  Base, 370.0, 470.0, "fr-couronne-édition")
-    (FR_RAISIN:            Base, 500.0, 650.0, "fr-raisin")
-    (FR_CARRE:             Base, 450.0, 560.0, "fr-carré")
-    (FR_JESUS:             Base, 560.0, 760.0, "fr-jésus")
-
-    // United Kingdom Imperial
-    (UK_BRIEF:    Base, 406.4, 342.9, "uk-brief")
-    (UK_DRAFT:    Base, 254.0, 406.4, "uk-draft")
-    (UK_FOOLSCAP: Base, 203.2, 330.2, "uk-foolscap")
-    (UK_QUARTO:   Base, 203.2, 254.0, "uk-quarto")
-    (UK_CROWN:    Base, 508.0, 381.0, "uk-crown")
-    (UK_BOOK_A:   Book, 111.0, 178.0, "uk-book-a")
-    (UK_BOOK_B:   Book, 129.0, 198.0, "uk-book-b")
-
-    // Unites States
-    (US_LETTER:         US,   215.9,  279.4, "us-letter")
-    (US_LEGAL:          US,   215.9,  355.6, "us-legal")
-    (US_TABLOID:        US,   279.4,  431.8, "us-tabloid")
-    (US_EXECUTIVE:      US,  184.15,  266.7, "us-executive")
-    (US_FOOLSCAP_FOLIO: US,   215.9,  342.9, "us-foolscap-folio")
-    (US_STATEMENT:      US,   139.7,  215.9, "us-statement")
-    (US_LEDGER:         US,   431.8,  279.4, "us-ledger")
-    (US_OFICIO:         US,   215.9, 340.36, "us-oficio")
-    (US_GOV_LETTER:     US,   203.2,  266.7, "us-gov-letter")
-    (US_GOV_LEGAL:      US,   215.9,  330.2, "us-gov-legal")
-    (US_BUSINESS_CARD:  Base,  88.9,   50.8, "us-business-card")
-    (US_DIGEST:         Book, 139.7,  215.9, "us-digest")
-    (US_TRADE:          Book, 152.4,  228.6, "us-trade")
-
-    // ---------------------------------------------------------------------- //
-    // Other
-    (NEWSPAPER_COMPACT:    Newspaper, 280.0, 430.0,    "newspaper-compact")
-    (NEWSPAPER_BERLINER:   Newspaper, 315.0, 470.0,    "newspaper-berliner")
-    (NEWSPAPER_BROADSHEET: Newspaper, 381.0, 578.0,    "newspaper-broadsheet")
-    (PRESENTATION_16_9:    Base,      297.0, 167.0625, "presentation-16-9")
-    (PRESENTATION_4_3:     Base,      280.0, 210.0,    "presentation-4-3")
-}
diff --git a/src/util/mod.rs b/src/util/mod.rs
index 6fc1fb59c..694c90c85 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -13,18 +13,6 @@ use std::ops::Range;
 use std::path::{Component, Path, PathBuf};
 use std::rc::Rc;
 
-/// Additional methods for booleans.
-pub trait BoolExt {
-    /// Toggle the value of the bool in place.
-    fn flip(&mut self);
-}
-
-impl BoolExt for bool {
-    fn flip(&mut self) {
-        *self = !*self;
-    }
-}
-
 /// Additional methods for options.
 pub trait OptionExt<T> {
     /// Sets `other` as the value if `self` is `None` or if it contains a value
diff --git a/tests/typeset.rs b/tests/typeset.rs
index 792251c32..a36fd3612 100644
--- a/tests/typeset.rs
+++ b/tests/typeset.rs
@@ -12,20 +12,17 @@ use usvg::FitTo;
 use walkdir::WalkDir;
 
 use typst::diag::Error;
-use typst::eval::{Smart, Value};
+use typst::eval::{Smart, Styles, Value};
 use typst::font::Face;
 use typst::frame::{Element, Frame, Geometry, Group, Shape, Stroke, Text};
-use typst::geom::{
-    self, Color, Length, Paint, PathElement, RgbaColor, Sides, Size, Transform,
-};
+use typst::geom::{self, Color, Length, Paint, PathElement, RgbaColor, Size, Transform};
 use typst::image::{Image, RasterImage, Svg};
 use typst::layout::layout;
 #[cfg(feature = "layout-cache")]
-use typst::library::DocumentNode;
+use typst::library::{DocumentNode, PageNode, TextNode};
 use typst::loading::FsLoader;
 use typst::parse::Scanner;
 use typst::source::SourceFile;
-use typst::style::Style;
 use typst::syntax::Span;
 use typst::Context;
 
@@ -64,12 +61,17 @@ fn main() {
         println!("Running {} tests", len);
     }
 
-    // We want to have "unbounded" pages, so we allow them to be infinitely
-    // large and fit them to match their content.
-    let mut style = Style::default();
-    style.page_mut().size = Size::new(Length::pt(120.0), Length::inf());
-    style.page_mut().margins = Sides::splat(Smart::Custom(Length::pt(10.0).into()));
-    style.text_mut().size = Length::pt(10.0);
+    // Set page width to 120pt with 10pt margins, so that the inner page is
+    // exactly 100pt wide. Page height is unbounded and font size is 10pt so
+    // that it multiplies to nice round numbers.
+    let mut styles = Styles::new();
+    styles.set(PageNode::WIDTH, Smart::Custom(Length::pt(120.0)));
+    styles.set(PageNode::HEIGHT, Smart::Auto);
+    styles.set(PageNode::LEFT, Smart::Custom(Length::pt(10.0).into()));
+    styles.set(PageNode::TOP, Smart::Custom(Length::pt(10.0).into()));
+    styles.set(PageNode::RIGHT, Smart::Custom(Length::pt(10.0).into()));
+    styles.set(PageNode::BOTTOM, Smart::Custom(Length::pt(10.0).into()));
+    styles.set(TextNode::SIZE, Length::pt(10.0));
 
     // Hook up an assert function into the global scope.
     let mut std = typst::library::new();
@@ -87,7 +89,7 @@ fn main() {
 
     // Create loader and context.
     let loader = FsLoader::new().with_path(FONT_DIR).wrap();
-    let mut ctx = Context::builder().std(std).style(style).build(loader);
+    let mut ctx = Context::builder().std(std).styles(styles).build(loader);
 
     // Run all the tests.
     let mut ok = true;