From 3ca5b238238e1128aa7bbfbd5db9e632045d8600 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 28 Feb 2022 15:50:48 +0100
Subject: Reorganize library

---
 src/eval/class.rs                |    2 +-
 src/eval/layout.rs               |    4 +-
 src/eval/mod.rs                  |   16 +-
 src/eval/styles.rs               |    3 +-
 src/eval/template.rs             |    7 +-
 src/library/align.rs             |   73 ---
 src/library/columns.rs           |  113 ----
 src/library/container.rs         |   26 -
 src/library/deco.rs              |   74 ---
 src/library/elements/heading.rs  |  150 +++++
 src/library/elements/image.rs    |  116 ++++
 src/library/elements/list.rs     |  212 ++++++++
 src/library/elements/math.rs     |   37 ++
 src/library/elements/mod.rs      |   15 +
 src/library/elements/shape.rs    |  166 ++++++
 src/library/elements/table.rs    |  100 ++++
 src/library/flow.rs              |  273 ----------
 src/library/grid.rs              |  581 --------------------
 src/library/heading.rs           |  152 ------
 src/library/hide.rs              |   32 --
 src/library/image.rs             |  118 ----
 src/library/layout/align.rs      |   71 +++
 src/library/layout/columns.rs    |  111 ++++
 src/library/layout/container.rs  |   24 +
 src/library/layout/flow.rs       |  272 ++++++++++
 src/library/layout/grid.rs       |  579 ++++++++++++++++++++
 src/library/layout/hide.rs       |   30 +
 src/library/layout/mod.rs        |   27 +
 src/library/layout/pad.rs        |   83 +++
 src/library/layout/page.rs       |  419 ++++++++++++++
 src/library/layout/place.rs      |   59 ++
 src/library/layout/spacing.rs    |   52 ++
 src/library/layout/stack.rs      |  259 +++++++++
 src/library/layout/transform.rs  |   86 +++
 src/library/link.rs              |   66 ---
 src/library/list.rs              |  210 -------
 src/library/math.rs              |   39 --
 src/library/mod.rs               |  206 +++----
 src/library/numbering.rs         |  113 ----
 src/library/pad.rs               |   85 ---
 src/library/page.rs              |  421 --------------
 src/library/par.rs               |  634 ----------------------
 src/library/place.rs             |   61 ---
 src/library/prelude.rs           |   20 +
 src/library/raw.rs               |  129 -----
 src/library/shape.rs             |  156 ------
 src/library/spacing.rs           |   54 --
 src/library/stack.rs             |  261 ---------
 src/library/table.rs             |  102 ----
 src/library/text.rs              | 1114 --------------------------------------
 src/library/text/deco.rs         |  250 +++++++++
 src/library/text/link.rs         |   64 +++
 src/library/text/mod.rs          |  409 ++++++++++++++
 src/library/text/par.rs          |  617 +++++++++++++++++++++
 src/library/text/raw.rs          |  127 +++++
 src/library/text/shaping.rs      |  552 +++++++++++++++++++
 src/library/transform.rs         |   79 ---
 src/library/utility.rs           |  294 ----------
 src/library/utility/math.rs      |  114 ++++
 src/library/utility/mod.rs       |  187 +++++++
 src/library/utility/numbering.rs |  111 ++++
 61 files changed, 5405 insertions(+), 5412 deletions(-)
 delete mode 100644 src/library/align.rs
 delete mode 100644 src/library/columns.rs
 delete mode 100644 src/library/container.rs
 delete mode 100644 src/library/deco.rs
 create mode 100644 src/library/elements/heading.rs
 create mode 100644 src/library/elements/image.rs
 create mode 100644 src/library/elements/list.rs
 create mode 100644 src/library/elements/math.rs
 create mode 100644 src/library/elements/mod.rs
 create mode 100644 src/library/elements/shape.rs
 create mode 100644 src/library/elements/table.rs
 delete mode 100644 src/library/flow.rs
 delete mode 100644 src/library/grid.rs
 delete mode 100644 src/library/heading.rs
 delete mode 100644 src/library/hide.rs
 delete mode 100644 src/library/image.rs
 create mode 100644 src/library/layout/align.rs
 create mode 100644 src/library/layout/columns.rs
 create mode 100644 src/library/layout/container.rs
 create mode 100644 src/library/layout/flow.rs
 create mode 100644 src/library/layout/grid.rs
 create mode 100644 src/library/layout/hide.rs
 create mode 100644 src/library/layout/mod.rs
 create mode 100644 src/library/layout/pad.rs
 create mode 100644 src/library/layout/page.rs
 create mode 100644 src/library/layout/place.rs
 create mode 100644 src/library/layout/spacing.rs
 create mode 100644 src/library/layout/stack.rs
 create mode 100644 src/library/layout/transform.rs
 delete mode 100644 src/library/link.rs
 delete mode 100644 src/library/list.rs
 delete mode 100644 src/library/math.rs
 delete mode 100644 src/library/numbering.rs
 delete mode 100644 src/library/pad.rs
 delete mode 100644 src/library/page.rs
 delete mode 100644 src/library/par.rs
 delete mode 100644 src/library/place.rs
 create mode 100644 src/library/prelude.rs
 delete mode 100644 src/library/raw.rs
 delete mode 100644 src/library/shape.rs
 delete mode 100644 src/library/spacing.rs
 delete mode 100644 src/library/stack.rs
 delete mode 100644 src/library/table.rs
 delete mode 100644 src/library/text.rs
 create mode 100644 src/library/text/deco.rs
 create mode 100644 src/library/text/link.rs
 create mode 100644 src/library/text/mod.rs
 create mode 100644 src/library/text/par.rs
 create mode 100644 src/library/text/raw.rs
 create mode 100644 src/library/text/shaping.rs
 delete mode 100644 src/library/transform.rs
 delete mode 100644 src/library/utility.rs
 create mode 100644 src/library/utility/math.rs
 create mode 100644 src/library/utility/mod.rs
 create mode 100644 src/library/utility/numbering.rs

(limited to 'src')

diff --git a/src/eval/class.rs b/src/eval/class.rs
index 5e1857d7..2cced74d 100644
--- a/src/eval/class.rs
+++ b/src/eval/class.rs
@@ -33,7 +33,7 @@ use crate::Context;
 /// ```
 ///
 /// [construct]: Self::construct
-/// [`TextNode`]: crate::library::TextNode
+/// [`TextNode`]: crate::library::text::TextNode
 /// [`set`]: Self::set
 #[derive(Clone)]
 pub struct Class {
diff --git a/src/eval/layout.rs b/src/eval/layout.rs
index 38ad3977..02912544 100644
--- a/src/eval/layout.rs
+++ b/src/eval/layout.rs
@@ -9,7 +9,7 @@ use crate::diag::TypResult;
 use crate::eval::StyleChain;
 use crate::frame::{Element, Frame, Geometry, Shape, Stroke};
 use crate::geom::{Align, Length, Linear, Paint, Point, Sides, Size, Spec, Transform};
-use crate::library::{AlignNode, PadNode, TransformNode, MOVE};
+use crate::library::layout::{AlignNode, MoveNode, PadNode};
 use crate::util::Prehashed;
 use crate::Context;
 
@@ -203,7 +203,7 @@ impl LayoutNode {
     /// Transform this node's contents without affecting layout.
     pub fn moved(self, offset: Point) -> Self {
         if !offset.is_zero() {
-            TransformNode::<MOVE> {
+            MoveNode {
                 transform: Transform::translation(offset.x, offset.y),
                 child: self,
             }
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 380e9e9d..f8b4b0f0 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -120,7 +120,7 @@ impl Eval for StrongNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::StrongNode(
+        Ok(Template::show(library::text::StrongNode(
             self.body().eval(ctx, scp)?,
         )))
     }
@@ -130,7 +130,7 @@ impl Eval for EmphNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::EmphNode(
+        Ok(Template::show(library::text::EmphNode(
             self.body().eval(ctx, scp)?,
         )))
     }
@@ -140,12 +140,12 @@ impl Eval for RawNode {
     type Output = Template;
 
     fn eval(&self, _: &mut Context, _: &mut Scopes) -> EvalResult<Self::Output> {
-        let template = Template::show(library::RawNode {
+        let template = Template::show(library::text::RawNode {
             text: self.text.clone(),
             block: self.block,
         });
         Ok(match self.lang {
-            Some(_) => template.styled(library::RawNode::LANG, self.lang.clone()),
+            Some(_) => template.styled(library::text::RawNode::LANG, self.lang.clone()),
             None => template,
         })
     }
@@ -155,7 +155,7 @@ impl Eval for MathNode {
     type Output = Template;
 
     fn eval(&self, _: &mut Context, _: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::MathNode {
+        Ok(Template::show(library::elements::MathNode {
             formula: self.formula.clone(),
             display: self.display,
         }))
@@ -166,7 +166,7 @@ impl Eval for HeadingNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::HeadingNode {
+        Ok(Template::show(library::elements::HeadingNode {
             body: self.body().eval(ctx, scp)?,
             level: self.level(),
         }))
@@ -177,7 +177,7 @@ impl Eval for ListNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::List(library::ListItem {
+        Ok(Template::List(library::elements::ListItem {
             number: None,
             body: Box::new(self.body().eval(ctx, scp)?),
         }))
@@ -188,7 +188,7 @@ impl Eval for EnumNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::Enum(library::ListItem {
+        Ok(Template::Enum(library::elements::ListItem {
             number: self.number(),
             body: Box::new(self.body().eval(ctx, scp)?),
         }))
diff --git a/src/eval/styles.rs b/src/eval/styles.rs
index 8e7bd4b6..5a8371a9 100644
--- a/src/eval/styles.rs
+++ b/src/eval/styles.rs
@@ -5,7 +5,8 @@ use std::sync::Arc;
 
 use super::{Args, Func, Span, Template, Value};
 use crate::diag::{At, TypResult};
-use crate::library::{PageNode, ParNode};
+use crate::library::layout::PageNode;
+use crate::library::text::ParNode;
 use crate::Context;
 
 /// A map of style properties.
diff --git a/src/eval/template.rs b/src/eval/template.rs
index 747e5d44..94cc0aff 100644
--- a/src/eval/template.rs
+++ b/src/eval/template.rs
@@ -10,11 +10,10 @@ use super::{
     StyleMap, StyleVecBuilder,
 };
 use crate::diag::StrResult;
+use crate::library::elements::{ListItem, ListKind, ListNode, ORDERED, UNORDERED};
+use crate::library::layout::{FlowChild, FlowNode, PageNode, PlaceNode, SpacingKind};
 use crate::library::prelude::*;
-use crate::library::{
-    DecoNode, FlowChild, FlowNode, ListItem, ListKind, ListNode, PageNode, ParChild,
-    ParNode, PlaceNode, SpacingKind, TextNode, ORDERED, UNDERLINE, UNORDERED,
-};
+use crate::library::text::{DecoNode, ParChild, ParNode, TextNode, UNDERLINE};
 use crate::util::EcoString;
 
 /// Composable representation of styled content.
diff --git a/src/library/align.rs b/src/library/align.rs
deleted file mode 100644
index 2fd734d3..00000000
--- a/src/library/align.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-//! Aligning nodes in their parent container.
-
-use super::prelude::*;
-use super::ParNode;
-
-/// Align a node along the layouting axes.
-#[derive(Debug, Hash)]
-pub struct AlignNode {
-    /// How to align the node horizontally and vertically.
-    pub aligns: Spec<Option<Align>>,
-    /// The node to be aligned.
-    pub child: LayoutNode,
-}
-
-#[class]
-impl AlignNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let aligns: Spec<_> = args.find()?.unwrap_or_default();
-        let body: LayoutNode = args.expect("body")?;
-        Ok(Template::block(body.aligned(aligns)))
-    }
-}
-
-impl Layout for AlignNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        // The child only needs to expand along an axis if there's no alignment.
-        let mut pod = regions.clone();
-        pod.expand &= self.aligns.map_is_none();
-
-        // Align paragraphs inside the child.
-        let mut passed = StyleMap::new();
-        if let Some(align) = self.aligns.x {
-            passed.set(ParNode::ALIGN, align);
-        }
-
-        // Layout the child.
-        let mut frames = self.child.layout(ctx, &pod, passed.chain(&styles))?;
-        for (region, frame) in regions.iter().zip(&mut frames) {
-            // Align in the target size. The target size depends on whether we
-            // should expand.
-            let target = regions.expand.select(region, frame.size);
-            let default = Spec::new(Align::Left, Align::Top);
-            let aligns = self.aligns.unwrap_or(default);
-            Arc::make_mut(frame).resize(target, aligns);
-        }
-
-        Ok(frames)
-    }
-}
-
-dynamic! {
-    Align: "alignment",
-}
-
-dynamic! {
-    Spec<Align>: "2d 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/columns.rs b/src/library/columns.rs
deleted file mode 100644
index 3ce9b6e5..00000000
--- a/src/library/columns.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//! Multi-column layouts.
-
-use super::prelude::*;
-use super::ParNode;
-
-/// Separate a region into multiple equally sized columns.
-#[derive(Debug, Hash)]
-pub struct ColumnsNode {
-    /// How many columns there should be.
-    pub columns: NonZeroUsize,
-    /// The child to be layouted into the columns. Most likely, this should be a
-    /// flow or stack node.
-    pub child: LayoutNode,
-}
-
-#[class]
-impl ColumnsNode {
-    /// The size of the gutter space between each column.
-    pub const GUTTER: Linear = Relative::new(0.04).into();
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::block(Self {
-            columns: args.expect("column count")?,
-            child: args.expect("body")?,
-        }))
-    }
-}
-
-impl Layout for ColumnsNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        // Separating the infinite space into infinite columns does not make
-        // much sense.
-        if regions.first.x.is_infinite() {
-            return self.child.layout(ctx, regions, styles);
-        }
-
-        // Determine the width of the gutter and each column.
-        let columns = self.columns.get();
-        let gutter = styles.get(Self::GUTTER).resolve(regions.base.x);
-        let width = (regions.first.x - gutter * (columns - 1) as f64) / columns as f64;
-
-        // Create the pod regions.
-        let pod = Regions {
-            first: Size::new(width, regions.first.y),
-            base: Size::new(width, regions.base.y),
-            backlog: std::iter::once(&regions.first.y)
-                .chain(regions.backlog.as_slice())
-                .flat_map(|&height| std::iter::repeat(height).take(columns))
-                .skip(1)
-                .collect(),
-            last: regions.last,
-            expand: Spec::new(true, regions.expand.y),
-        };
-
-        // Layout the children.
-        let mut frames = self.child.layout(ctx, &pod, styles)?.into_iter();
-
-        let dir = styles.get(ParNode::DIR);
-        let total_regions = (frames.len() as f32 / columns as f32).ceil() as usize;
-        let mut finished = vec![];
-
-        // Stitch together the columns for each region.
-        for region in regions.iter().take(total_regions) {
-            // The height should be the parent height if the node shall expand.
-            // Otherwise its the maximum column height for the frame. In that
-            // case, the frame is first created with zero height and then
-            // resized.
-            let height = if regions.expand.y { region.y } else { Length::zero() };
-            let mut output = Frame::new(Size::new(regions.first.x, height));
-            let mut cursor = Length::zero();
-
-            for _ in 0 .. columns {
-                let frame = match frames.next() {
-                    Some(frame) => frame,
-                    None => break,
-                };
-
-                if !regions.expand.y {
-                    output.size.y.set_max(frame.size.y);
-                }
-
-                let width = frame.size.x;
-                let x = if dir.is_positive() {
-                    cursor
-                } else {
-                    regions.first.x - cursor - width
-                };
-
-                output.push_frame(Point::with_x(x), frame);
-                cursor += width + gutter;
-            }
-
-            finished.push(Arc::new(output));
-        }
-
-        Ok(finished)
-    }
-}
-
-/// A column break.
-pub struct ColbreakNode;
-
-#[class]
-impl ColbreakNode {
-    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
-        Ok(Template::Colbreak)
-    }
-}
diff --git a/src/library/container.rs b/src/library/container.rs
deleted file mode 100644
index 5517d927..00000000
--- a/src/library/container.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//! Inline- and block-level containers.
-
-use super::prelude::*;
-
-/// Size content and place it into a paragraph.
-pub struct BoxNode;
-
-#[class]
-impl BoxNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let width = args.named("width")?;
-        let height = args.named("height")?;
-        let body: LayoutNode = args.find()?.unwrap_or_default();
-        Ok(Template::inline(body.sized(Spec::new(width, height))))
-    }
-}
-
-/// Place content into a separate flow.
-pub struct BlockNode;
-
-#[class]
-impl BlockNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::Block(args.find()?.unwrap_or_default()))
-    }
-}
diff --git a/src/library/deco.rs b/src/library/deco.rs
deleted file mode 100644
index 8c2b5a9a..00000000
--- a/src/library/deco.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-//! Text decorations.
-
-use super::prelude::*;
-use super::TextNode;
-
-/// Typeset underline, striken-through or overlined text.
-#[derive(Debug, Hash)]
-pub struct DecoNode<const L: DecoLine>(pub Template);
-
-#[class]
-impl<const L: DecoLine> DecoNode<L> {
-    /// Stroke color of the line, defaults to the text color if `None`.
-    #[shorthand]
-    pub const STROKE: Option<Paint> = None;
-    /// Thickness of the line's strokes (dependent on scaled font size), read
-    /// from the font tables if `None`.
-    #[shorthand]
-    pub const THICKNESS: Option<Linear> = None;
-    /// Position of the line relative to the baseline (dependent on scaled font
-    /// size), read from the font tables if `None`.
-    pub const OFFSET: Option<Linear> = None;
-    /// Amount that the line will be longer or shorter than its associated text
-    /// (dependent on scaled font size).
-    pub const EXTENT: Linear = Linear::zero();
-    /// Whether the line skips sections in which it would collide
-    /// with the glyphs. Does not apply to strikethrough.
-    pub const EVADE: bool = true;
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self(args.expect::<Template>("body")?)))
-    }
-}
-
-impl<const L: DecoLine> Show for DecoNode<L> {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        Ok(styles
-            .show(self, ctx, [Value::Template(self.0.clone())])?
-            .unwrap_or_else(|| {
-                self.0.clone().styled(TextNode::LINES, vec![Decoration {
-                    line: L,
-                    stroke: styles.get(Self::STROKE),
-                    thickness: styles.get(Self::THICKNESS),
-                    offset: styles.get(Self::OFFSET),
-                    extent: styles.get(Self::EXTENT),
-                    evade: styles.get(Self::EVADE),
-                }])
-            }))
-    }
-}
-
-/// Defines a line that is positioned over, under or on top of text.
-///
-/// For more details, see [`DecoNode`].
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct Decoration {
-    pub line: DecoLine,
-    pub stroke: Option<Paint>,
-    pub thickness: Option<Linear>,
-    pub offset: Option<Linear>,
-    pub extent: Linear,
-    pub evade: bool,
-}
-
-/// A kind of decorative line.
-pub type DecoLine = usize;
-
-/// A line under text.
-pub const UNDERLINE: DecoLine = 0;
-
-/// A line through text.
-pub const STRIKETHROUGH: DecoLine = 1;
-
-/// A line over text.
-pub const OVERLINE: DecoLine = 2;
diff --git a/src/library/elements/heading.rs b/src/library/elements/heading.rs
new file mode 100644
index 00000000..a67f4f24
--- /dev/null
+++ b/src/library/elements/heading.rs
@@ -0,0 +1,150 @@
+use crate::library::prelude::*;
+use crate::library::text::{FontFamily, TextNode};
+
+/// A section heading.
+#[derive(Debug, Hash)]
+pub struct HeadingNode {
+    /// The logical nesting depth of the section, starting from one. In the
+    /// default style, this controls the text size of the heading.
+    pub level: usize,
+    /// The heading's contents.
+    pub body: Template,
+}
+
+#[class]
+impl HeadingNode {
+    /// The heading's font family. Just the normal text family if `auto`.
+    pub const FAMILY: Leveled<Smart<FontFamily>> = Leveled::Value(Smart::Auto);
+    /// The color of text in the heading. Just the normal text color if `auto`.
+    pub const FILL: Leveled<Smart<Paint>> = Leveled::Value(Smart::Auto);
+    /// The size of text in the heading.
+    pub const SIZE: Leveled<Linear> = Leveled::Mapping(|level| {
+        let upscale = (1.6 - 0.1 * level as f64).max(0.75);
+        Relative::new(upscale).into()
+    });
+    /// Whether text in the heading is strengthend.
+    pub const STRONG: Leveled<bool> = Leveled::Value(true);
+    /// Whether text in the heading is emphasized.
+    pub const EMPH: Leveled<bool> = Leveled::Value(false);
+    /// Whether the heading is underlined.
+    pub const UNDERLINE: Leveled<bool> = Leveled::Value(false);
+    /// The extra padding above the heading.
+    pub const ABOVE: Leveled<Length> = Leveled::Value(Length::zero());
+    /// The extra padding below the heading.
+    pub const BELOW: Leveled<Length> = Leveled::Value(Length::zero());
+    /// Whether the heading is block-level.
+    pub const BLOCK: Leveled<bool> = Leveled::Value(true);
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self {
+            body: args.expect("body")?,
+            level: args.named("level")?.unwrap_or(1),
+        }))
+    }
+}
+
+impl Show for HeadingNode {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        macro_rules! resolve {
+            ($key:expr) => {
+                styles.get_cloned($key).resolve(ctx, self.level)?
+            };
+        }
+
+        // Resolve the user recipe.
+        let mut body = styles
+            .show(self, ctx, [
+                Value::Int(self.level as i64),
+                Value::Template(self.body.clone()),
+            ])?
+            .unwrap_or_else(|| self.body.clone());
+
+        let mut map = StyleMap::new();
+        map.set(TextNode::SIZE, resolve!(Self::SIZE));
+
+        if let Smart::Custom(family) = resolve!(Self::FAMILY) {
+            map.set(
+                TextNode::FAMILY,
+                std::iter::once(family)
+                    .chain(styles.get_ref(TextNode::FAMILY).iter().cloned())
+                    .collect(),
+            );
+        }
+
+        if let Smart::Custom(fill) = resolve!(Self::FILL) {
+            map.set(TextNode::FILL, fill);
+        }
+
+        if resolve!(Self::STRONG) {
+            map.set(TextNode::STRONG, true);
+        }
+
+        if resolve!(Self::EMPH) {
+            map.set(TextNode::EMPH, true);
+        }
+
+        let mut seq = vec![];
+        if resolve!(Self::UNDERLINE) {
+            body = body.underlined();
+        }
+
+        let above = resolve!(Self::ABOVE);
+        if !above.is_zero() {
+            seq.push(Template::Vertical(above.into()));
+        }
+
+        seq.push(body);
+
+        let below = resolve!(Self::BELOW);
+        if !below.is_zero() {
+            seq.push(Template::Vertical(below.into()));
+        }
+
+        let mut template = Template::sequence(seq).styled_with_map(map);
+        if resolve!(Self::BLOCK) {
+            template = Template::block(template);
+        }
+
+        Ok(template)
+    }
+}
+
+/// Either the value or a closure mapping to the value.
+#[derive(Debug, Clone, PartialEq, Hash)]
+pub enum Leveled<T> {
+    /// A bare value.
+    Value(T),
+    /// A simple mapping from a heading level to a value.
+    Mapping(fn(usize) -> T),
+    /// A closure mapping from a heading level to a value.
+    Func(Func, Span),
+}
+
+impl<T: Cast> Leveled<T> {
+    /// Resolve the value based on the level.
+    pub fn resolve(self, ctx: &mut Context, level: usize) -> TypResult<T> {
+        Ok(match self {
+            Self::Value(value) => value,
+            Self::Mapping(mapping) => mapping(level),
+            Self::Func(func, span) => {
+                let args = Args::from_values(span, [Value::Int(level as i64)]);
+                func.call(ctx, args)?.cast().at(span)?
+            }
+        })
+    }
+}
+
+impl<T: Cast> Cast<Spanned<Value>> for Leveled<T> {
+    fn is(value: &Spanned<Value>) -> bool {
+        matches!(&value.v, Value::Func(_)) || T::is(&value.v)
+    }
+
+    fn cast(value: Spanned<Value>) -> StrResult<Self> {
+        match value.v {
+            Value::Func(v) => Ok(Self::Func(v, value.span)),
+            v => T::cast(v)
+                .map(Self::Value)
+                .map_err(|msg| with_alternative(msg, "function")),
+        }
+    }
+}
diff --git a/src/library/elements/image.rs b/src/library/elements/image.rs
new file mode 100644
index 00000000..66fb8f4b
--- /dev/null
+++ b/src/library/elements/image.rs
@@ -0,0 +1,116 @@
+use crate::diag::Error;
+use crate::image::ImageId;
+use crate::library::prelude::*;
+use crate::library::text::TextNode;
+
+/// Show a raster or vector graphic.
+#[derive(Debug, Hash)]
+pub struct ImageNode(pub ImageId);
+
+#[class]
+impl ImageNode {
+    /// How the image should adjust itself to a given area.
+    pub const FIT: ImageFit = ImageFit::Cover;
+
+    fn construct(ctx: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let path = args.expect::<Spanned<EcoString>>("path to image file")?;
+        let full = ctx.resolve(&path.v);
+        let id = ctx.images.load(&full).map_err(|err| {
+            Error::boxed(path.span, match err.kind() {
+                std::io::ErrorKind::NotFound => "file not found".into(),
+                _ => format!("failed to load image ({})", err),
+            })
+        })?;
+
+        let width = args.named("width")?;
+        let height = args.named("height")?;
+
+        Ok(Template::inline(
+            ImageNode(id).pack().sized(Spec::new(width, height)),
+        ))
+    }
+}
+
+impl Layout for ImageNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let img = ctx.images.get(self.0);
+        let pxw = img.width() as f64;
+        let pxh = img.height() as f64;
+        let px_ratio = pxw / pxh;
+
+        // Find out whether the image is wider or taller than the target size.
+        let &Regions { first, expand, .. } = regions;
+        let region_ratio = first.x / first.y;
+        let wide = px_ratio > region_ratio;
+
+        // The space into which the image will be placed according to its fit.
+        let target = if expand.x && expand.y {
+            first
+        } else if expand.x || (!expand.y && wide && first.x.is_finite()) {
+            Size::new(first.x, first.y.min(first.x.safe_div(px_ratio)))
+        } else if first.y.is_finite() {
+            Size::new(first.x.min(first.y * px_ratio), first.y)
+        } else {
+            Size::new(Length::pt(pxw), Length::pt(pxh))
+        };
+
+        // Compute the actual size of the fitted image.
+        let fit = styles.get(Self::FIT);
+        let fitted = match fit {
+            ImageFit::Cover | ImageFit::Contain => {
+                if wide == (fit == ImageFit::Contain) {
+                    Size::new(target.x, target.x / px_ratio)
+                } else {
+                    Size::new(target.y * px_ratio, target.y)
+                }
+            }
+            ImageFit::Stretch => target,
+        };
+
+        // First, place the image in a frame of exactly its size and then resize
+        // the frame to the target size, center aligning the image in the
+        // process.
+        let mut frame = Frame::new(fitted);
+        frame.push(Point::zero(), Element::Image(self.0, fitted));
+        frame.resize(target, Align::CENTER_HORIZON);
+
+        // Create a clipping group if only part of the image should be visible.
+        if fit == ImageFit::Cover && !target.fits(fitted) {
+            frame.clip();
+        }
+
+        // Apply link if it exists.
+        if let Some(url) = styles.get_ref(TextNode::LINK) {
+            frame.link(url);
+        }
+
+        Ok(vec![Arc::new(frame)])
+    }
+}
+
+/// How an image should adjust itself to a given area.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum ImageFit {
+    /// The image should completely cover the area.
+    Cover,
+    /// The image should be fully contained in the area.
+    Contain,
+    /// The image should be stretched so that it exactly fills the area.
+    Stretch,
+}
+
+castable! {
+    ImageFit,
+    Expected: "string",
+    Value::Str(string) => match string.as_str() {
+        "cover" => Self::Cover,
+        "contain" => Self::Contain,
+        "stretch" => Self::Stretch,
+        _ => Err(r#"expected "cover", "contain" or "stretch""#)?,
+    },
+}
diff --git a/src/library/elements/list.rs b/src/library/elements/list.rs
new file mode 100644
index 00000000..726a2834
--- /dev/null
+++ b/src/library/elements/list.rs
@@ -0,0 +1,212 @@
+use crate::library::layout::{GridNode, TrackSizing};
+use crate::library::prelude::*;
+use crate::library::text::{ParNode, TextNode};
+use crate::library::utility::Numbering;
+use crate::parse::Scanner;
+
+/// An unordered (bulleted) or ordered (numbered) list.
+#[derive(Debug, Hash)]
+pub struct ListNode<const L: ListKind = UNORDERED> {
+    /// Where the list starts.
+    pub start: usize,
+    /// If true, there is paragraph spacing between the items, if false
+    /// there is list spacing between the items.
+    pub wide: bool,
+    /// The individual bulleted or numbered items.
+    pub items: Vec<ListItem>,
+}
+
+/// An item in a list.
+#[derive(Debug, Clone, PartialEq, Hash)]
+pub struct ListItem {
+    /// The number of the item.
+    pub number: Option<usize>,
+    /// The node that produces the item's body.
+    pub body: Box<Template>,
+}
+
+/// An ordered list.
+pub type EnumNode = ListNode<ORDERED>;
+
+#[class]
+impl<const L: ListKind> ListNode<L> {
+    /// How the list is labelled.
+    pub const LABEL: Label = Label::Default;
+    /// The spacing between the list items of a non-wide list.
+    pub const SPACING: Linear = Linear::zero();
+    /// The indentation of each item's label.
+    pub const INDENT: Linear = Relative::new(0.0).into();
+    /// The space between the label and the body of each item.
+    pub const BODY_INDENT: Linear = Relative::new(0.5).into();
+    /// The extra padding above the list.
+    pub const ABOVE: Length = Length::zero();
+    /// The extra padding below the list.
+    pub const BELOW: Length = Length::zero();
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self {
+            start: args.named("start")?.unwrap_or(0),
+            wide: args.named("wide")?.unwrap_or(false),
+            items: args
+                .all()?
+                .into_iter()
+                .map(|body| ListItem { number: None, body: Box::new(body) })
+                .collect(),
+        }))
+    }
+}
+
+impl<const L: ListKind> Show for ListNode<L> {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        let template = if let Some(template) = styles.show(
+            self,
+            ctx,
+            self.items.iter().map(|item| Value::Template((*item.body).clone())),
+        )? {
+            template
+        } else {
+            let mut children = vec![];
+            let mut number = self.start;
+
+            let label = styles.get_ref(Self::LABEL);
+
+            for item in &self.items {
+                number = item.number.unwrap_or(number);
+                if L == UNORDERED {
+                    number = 1;
+                }
+
+                children.push(LayoutNode::default());
+                children.push(label.resolve(ctx, L, number)?.pack());
+                children.push(LayoutNode::default());
+                children.push((*item.body).clone().pack());
+                number += 1;
+            }
+
+            let em = styles.get(TextNode::SIZE).abs;
+            let leading = styles.get(ParNode::LEADING);
+            let spacing = if self.wide {
+                styles.get(ParNode::SPACING)
+            } else {
+                styles.get(Self::SPACING)
+            };
+
+            let gutter = (leading + spacing).resolve(em);
+            let indent = styles.get(Self::INDENT).resolve(em);
+            let body_indent = styles.get(Self::BODY_INDENT).resolve(em);
+
+            Template::block(GridNode {
+                tracks: Spec::with_x(vec![
+                    TrackSizing::Linear(indent.into()),
+                    TrackSizing::Auto,
+                    TrackSizing::Linear(body_indent.into()),
+                    TrackSizing::Auto,
+                ]),
+                gutter: Spec::with_y(vec![TrackSizing::Linear(gutter.into())]),
+                children,
+            })
+        };
+
+        let mut seq = vec![];
+        let above = styles.get(Self::ABOVE);
+        if !above.is_zero() {
+            seq.push(Template::Vertical(above.into()));
+        }
+
+        seq.push(template);
+
+        let below = styles.get(Self::BELOW);
+        if !below.is_zero() {
+            seq.push(Template::Vertical(below.into()));
+        }
+
+        Ok(Template::sequence(seq))
+    }
+}
+
+impl<const L: ListKind> From<ListItem> for ListNode<L> {
+    fn from(item: ListItem) -> Self {
+        Self { items: vec![item], wide: false, start: 1 }
+    }
+}
+
+/// How to label a list.
+pub type ListKind = usize;
+
+/// Unordered list labelling style.
+pub const UNORDERED: ListKind = 0;
+
+/// Ordered list labelling style.
+pub const ORDERED: ListKind = 1;
+
+/// Either a template or a closure mapping to a template.
+#[derive(Debug, Clone, PartialEq, Hash)]
+pub enum Label {
+    /// The default labelling.
+    Default,
+    /// A pattern with prefix, numbering, lower / upper case and suffix.
+    Pattern(EcoString, Numbering, bool, EcoString),
+    /// A bare template.
+    Template(Template),
+    /// A closure mapping from an item number to a value.
+    Func(Func, Span),
+}
+
+impl Label {
+    /// Resolve the value based on the level.
+    pub fn resolve(
+        &self,
+        ctx: &mut Context,
+        kind: ListKind,
+        number: usize,
+    ) -> TypResult<Template> {
+        Ok(match self {
+            Self::Default => match kind {
+                UNORDERED => Template::Text('•'.into()),
+                ORDERED | _ => Template::Text(format_eco!("{}.", number)),
+            },
+            Self::Pattern(prefix, numbering, upper, suffix) => {
+                let fmt = numbering.apply(number);
+                let mid = if *upper { fmt.to_uppercase() } else { fmt.to_lowercase() };
+                Template::Text(format_eco!("{}{}{}", prefix, mid, suffix))
+            }
+            Self::Template(template) => template.clone(),
+            Self::Func(func, span) => {
+                let args = Args::from_values(*span, [Value::Int(number as i64)]);
+                func.call(ctx, args)?.cast().at(*span)?
+            }
+        })
+    }
+}
+
+impl Cast<Spanned<Value>> for Label {
+    fn is(value: &Spanned<Value>) -> bool {
+        matches!(&value.v, Value::Template(_) | Value::Func(_))
+    }
+
+    fn cast(value: Spanned<Value>) -> StrResult<Self> {
+        match value.v {
+            Value::Str(pattern) => {
+                let mut s = Scanner::new(&pattern);
+                let mut prefix;
+                let numbering = loop {
+                    prefix = s.eaten();
+                    match s.eat().map(|c| c.to_ascii_lowercase()) {
+                        Some('1') => break Numbering::Arabic,
+                        Some('a') => break Numbering::Letter,
+                        Some('i') => break Numbering::Roman,
+                        Some('*') => break Numbering::Symbol,
+                        Some(_) => {}
+                        None => Err("invalid pattern")?,
+                    }
+                };
+                let upper = s.prev(0).map_or(false, char::is_uppercase);
+                let suffix = s.rest().into();
+                Ok(Self::Pattern(prefix.into(), numbering, upper, suffix))
+            }
+            Value::Template(v) => Ok(Self::Template(v)),
+            Value::Func(v) => Ok(Self::Func(v, value.span)),
+            _ => Err("expected pattern, template or function")?,
+        }
+    }
+}
diff --git a/src/library/elements/math.rs b/src/library/elements/math.rs
new file mode 100644
index 00000000..761b4480
--- /dev/null
+++ b/src/library/elements/math.rs
@@ -0,0 +1,37 @@
+use crate::library::prelude::*;
+
+/// A mathematical formula.
+#[derive(Debug, Hash)]
+pub struct MathNode {
+    /// The formula.
+    pub formula: EcoString,
+    /// Whether the formula is display-level.
+    pub display: bool,
+}
+
+#[class]
+impl MathNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self {
+            formula: args.expect("formula")?,
+            display: args.named("display")?.unwrap_or(false),
+        }))
+    }
+}
+
+impl Show for MathNode {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, ctx, [
+                Value::Str(self.formula.clone()),
+                Value::Bool(self.display),
+            ])?
+            .unwrap_or_else(|| {
+                let mut template = Template::Text(self.formula.trim().into());
+                if self.display {
+                    template = Template::Block(template.pack());
+                }
+                template.monospaced()
+            }))
+    }
+}
diff --git a/src/library/elements/mod.rs b/src/library/elements/mod.rs
new file mode 100644
index 00000000..572010bb
--- /dev/null
+++ b/src/library/elements/mod.rs
@@ -0,0 +1,15 @@
+//! Primitive and semantic elements.
+
+mod heading;
+mod image;
+mod list;
+mod math;
+mod shape;
+mod table;
+
+pub use self::image::*;
+pub use heading::*;
+pub use list::*;
+pub use math::*;
+pub use shape::*;
+pub use table::*;
diff --git a/src/library/elements/shape.rs b/src/library/elements/shape.rs
new file mode 100644
index 00000000..8b967412
--- /dev/null
+++ b/src/library/elements/shape.rs
@@ -0,0 +1,166 @@
+use std::f64::consts::SQRT_2;
+
+use crate::library::prelude::*;
+use crate::library::text::TextNode;
+
+/// Place a node into a sizable and fillable shape.
+#[derive(Debug, Hash)]
+pub struct ShapeNode<const S: ShapeKind>(pub Option<LayoutNode>);
+
+/// Place a node into a square.
+pub type SquareNode = ShapeNode<SQUARE>;
+
+/// Place a node into a rectangle.
+pub type RectNode = ShapeNode<RECT>;
+
+/// Place a node into a circle.
+pub type CircleNode = ShapeNode<CIRCLE>;
+
+/// Place a node into an ellipse.
+pub type EllipseNode = ShapeNode<ELLIPSE>;
+
+#[class]
+impl<const S: ShapeKind> ShapeNode<S> {
+    /// How to fill the shape.
+    pub const FILL: Option<Paint> = None;
+    /// How the stroke the shape.
+    pub const STROKE: Smart<Option<Paint>> = Smart::Auto;
+    /// The stroke's thickness.
+    pub const THICKNESS: Length = Length::pt(1.0);
+    /// How much to pad the shape's content.
+    pub const PADDING: Linear = Linear::zero();
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let size = match S {
+            SQUARE => args.named::<Length>("size")?.map(Linear::from),
+            CIRCLE => args.named::<Length>("radius")?.map(|r| 2.0 * Linear::from(r)),
+            _ => None,
+        };
+
+        let width = match size {
+            None => args.named("width")?,
+            size => size,
+        };
+
+        let height = match size {
+            None => args.named("height")?,
+            size => size,
+        };
+
+        Ok(Template::inline(
+            Self(args.find()?).pack().sized(Spec::new(width, height)),
+        ))
+    }
+}
+
+impl<const S: ShapeKind> Layout for ShapeNode<S> {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let mut frames;
+        if let Some(child) = &self.0 {
+            let mut padding = styles.get(Self::PADDING);
+            if is_round(S) {
+                padding.rel += Relative::new(0.5 - SQRT_2 / 4.0);
+            }
+
+            // Pad the child.
+            let child = child.clone().padded(Sides::splat(padding));
+
+            let mut pod = Regions::one(regions.first, regions.base, regions.expand);
+            frames = child.layout(ctx, &pod, styles)?;
+
+            // Relayout with full expansion into square region to make sure
+            // the result is really a square or circle.
+            if is_quadratic(S) {
+                let length = if regions.expand.x || regions.expand.y {
+                    let target = regions.expand.select(regions.first, Size::zero());
+                    target.x.max(target.y)
+                } else {
+                    let size = frames[0].size;
+                    let desired = size.x.max(size.y);
+                    desired.min(regions.first.x).min(regions.first.y)
+                };
+
+                pod.first = Size::splat(length);
+                pod.expand = Spec::splat(true);
+                frames = child.layout(ctx, &pod, styles)?;
+            }
+        } else {
+            // The default size that a shape takes on if it has no child and
+            // enough space.
+            let mut size =
+                Size::new(Length::pt(45.0), Length::pt(30.0)).min(regions.first);
+
+            if is_quadratic(S) {
+                let length = if regions.expand.x || regions.expand.y {
+                    let target = regions.expand.select(regions.first, Size::zero());
+                    target.x.max(target.y)
+                } else {
+                    size.x.min(size.y)
+                };
+                size = Size::splat(length);
+            } else {
+                size = regions.expand.select(regions.first, size);
+            }
+
+            frames = vec![Arc::new(Frame::new(size))];
+        }
+
+        let frame = Arc::make_mut(&mut frames[0]);
+
+        // Add fill and/or stroke.
+        let fill = styles.get(Self::FILL);
+        let thickness = styles.get(Self::THICKNESS);
+        let stroke = styles
+            .get(Self::STROKE)
+            .unwrap_or(fill.is_none().then(|| Color::BLACK.into()))
+            .map(|paint| Stroke { paint, thickness });
+
+        if fill.is_some() || stroke.is_some() {
+            let geometry = if is_round(S) {
+                Geometry::Ellipse(frame.size)
+            } else {
+                Geometry::Rect(frame.size)
+            };
+
+            let shape = Shape { geometry, fill, stroke };
+            frame.prepend(Point::zero(), Element::Shape(shape));
+        }
+
+        // Apply link if it exists.
+        if let Some(url) = styles.get_ref(TextNode::LINK) {
+            frame.link(url);
+        }
+
+        Ok(frames)
+    }
+}
+
+/// A category of shape.
+pub type ShapeKind = usize;
+
+/// A rectangle with equal side lengths.
+const SQUARE: ShapeKind = 0;
+
+/// A quadrilateral with four right angles.
+const RECT: ShapeKind = 1;
+
+/// An ellipse with coinciding foci.
+const CIRCLE: ShapeKind = 2;
+
+/// A curve around two focal points.
+const ELLIPSE: ShapeKind = 3;
+
+/// Whether a shape kind is curvy.
+fn is_round(kind: ShapeKind) -> bool {
+    matches!(kind, CIRCLE | ELLIPSE)
+}
+
+/// Whether a shape kind has equal side length.
+fn is_quadratic(kind: ShapeKind) -> bool {
+    matches!(kind, SQUARE | CIRCLE)
+}
diff --git a/src/library/elements/table.rs b/src/library/elements/table.rs
new file mode 100644
index 00000000..555dcc44
--- /dev/null
+++ b/src/library/elements/table.rs
@@ -0,0 +1,100 @@
+use crate::library::layout::{GridNode, TrackSizing};
+use crate::library::prelude::*;
+
+/// A table of items.
+#[derive(Debug, Hash)]
+pub struct TableNode {
+    /// Defines sizing for content rows and columns.
+    pub tracks: Spec<Vec<TrackSizing>>,
+    /// Defines sizing of gutter rows and columns between content.
+    pub gutter: Spec<Vec<TrackSizing>>,
+    /// The nodes to be arranged in the table.
+    pub children: Vec<Template>,
+}
+
+#[class]
+impl TableNode {
+    /// The primary cell fill color.
+    pub const PRIMARY: Option<Paint> = None;
+    /// The secondary cell fill color.
+    pub const SECONDARY: Option<Paint> = None;
+    /// How the stroke the cells.
+    pub const STROKE: Option<Paint> = Some(Color::BLACK.into());
+    /// The stroke's thickness.
+    pub const THICKNESS: Length = Length::pt(1.0);
+    /// How much to pad the cells's content.
+    pub const PADDING: Linear = Length::pt(5.0).into();
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let columns = args.named("columns")?.unwrap_or_default();
+        let rows = args.named("rows")?.unwrap_or_default();
+        let base_gutter: Vec<TrackSizing> = args.named("gutter")?.unwrap_or_default();
+        let column_gutter = args.named("column-gutter")?;
+        let row_gutter = args.named("row-gutter")?;
+        Ok(Template::show(Self {
+            tracks: Spec::new(columns, rows),
+            gutter: Spec::new(
+                column_gutter.unwrap_or_else(|| base_gutter.clone()),
+                row_gutter.unwrap_or(base_gutter),
+            ),
+            children: args.all()?,
+        }))
+    }
+
+    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
+        let fill = args.named("fill")?;
+        styles.set_opt(Self::PRIMARY, args.named("primary")?.or(fill));
+        styles.set_opt(Self::SECONDARY, args.named("secondary")?.or(fill));
+        styles.set_opt(Self::STROKE, args.named("stroke")?);
+        styles.set_opt(Self::THICKNESS, args.named("thickness")?);
+        styles.set_opt(Self::PADDING, args.named("padding")?);
+        Ok(())
+    }
+}
+
+impl Show for TableNode {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        if let Some(template) = styles.show(
+            self,
+            ctx,
+            self.children.iter().map(|child| Value::Template(child.clone())),
+        )? {
+            return Ok(template);
+        }
+
+        let primary = styles.get(Self::PRIMARY);
+        let secondary = styles.get(Self::SECONDARY);
+        let thickness = styles.get(Self::THICKNESS);
+        let stroke = styles.get(Self::STROKE).map(|paint| Stroke { paint, thickness });
+        let padding = styles.get(Self::PADDING);
+
+        let cols = self.tracks.x.len().max(1);
+        let children = self
+            .children
+            .iter()
+            .cloned()
+            .enumerate()
+            .map(|(i, child)| {
+                let mut child = child.pack().padded(Sides::splat(padding));
+
+                if let Some(stroke) = stroke {
+                    child = child.stroked(stroke);
+                }
+
+                let x = i % cols;
+                let y = i / cols;
+                if let Some(fill) = [primary, secondary][(x + y) % 2] {
+                    child = child.filled(fill);
+                }
+
+                child
+            })
+            .collect();
+
+        Ok(Template::block(GridNode {
+            tracks: self.tracks.clone(),
+            gutter: self.gutter.clone(),
+            children,
+        }))
+    }
+}
diff --git a/src/library/flow.rs b/src/library/flow.rs
deleted file mode 100644
index 9e039d3a..00000000
--- a/src/library/flow.rs
+++ /dev/null
@@ -1,273 +0,0 @@
-//! A flow of paragraphs and other block-level nodes.
-
-use super::prelude::*;
-use super::{AlignNode, ParNode, PlaceNode, SpacingKind, TextNode};
-
-/// Arrange spacing, paragraphs and other block-level nodes into a flow.
-///
-/// This node is reponsible for layouting both the top-level content flow and
-/// the contents of boxes.
-#[derive(Hash)]
-pub struct FlowNode(pub StyleVec<FlowChild>);
-
-/// A child of a flow node.
-#[derive(Hash)]
-pub enum FlowChild {
-    /// Leading between other children.
-    Leading,
-    /// A paragraph / block break.
-    Parbreak,
-    /// A column / region break.
-    Colbreak,
-    /// Vertical spacing between other children.
-    Spacing(SpacingKind),
-    /// An arbitrary block-level node.
-    Node(LayoutNode),
-}
-
-impl Layout for FlowNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let mut layouter = FlowLayouter::new(regions);
-
-        for (child, map) in self.0.iter() {
-            let styles = map.chain(&styles);
-            match child {
-                FlowChild::Leading => {
-                    let em = styles.get(TextNode::SIZE).abs;
-                    let amount = styles.get(ParNode::LEADING).resolve(em);
-                    layouter.layout_spacing(amount.into());
-                }
-                FlowChild::Parbreak => {
-                    let em = styles.get(TextNode::SIZE).abs;
-                    let leading = styles.get(ParNode::LEADING);
-                    let spacing = styles.get(ParNode::SPACING);
-                    let amount = (leading + spacing).resolve(em);
-                    layouter.layout_spacing(amount.into());
-                }
-                FlowChild::Colbreak => {
-                    layouter.finish_region();
-                }
-                FlowChild::Spacing(kind) => {
-                    layouter.layout_spacing(*kind);
-                }
-                FlowChild::Node(ref node) => {
-                    layouter.layout_node(ctx, node, styles)?;
-                }
-            }
-        }
-
-        Ok(layouter.finish())
-    }
-}
-
-impl Merge for FlowChild {
-    fn merge(&mut self, _: &Self) -> bool {
-        false
-    }
-}
-
-impl Debug for FlowNode {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_str("Flow ")?;
-        self.0.fmt(f)
-    }
-}
-
-impl Debug for FlowChild {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::Leading => f.pad("Leading"),
-            Self::Parbreak => f.pad("Parbreak"),
-            Self::Colbreak => f.pad("Colbreak"),
-            Self::Spacing(kind) => write!(f, "{:?}", kind),
-            Self::Node(node) => node.fmt(f),
-        }
-    }
-}
-
-/// Performs flow layout.
-pub struct FlowLayouter {
-    /// The regions to layout children into.
-    regions: Regions,
-    /// Whether the flow should expand to fill the region.
-    expand: Spec<bool>,
-    /// The full size of `regions.size` that was available before we started
-    /// subtracting.
-    full: Size,
-    /// The size used by the frames for the current region.
-    used: Size,
-    /// The sum of fractional ratios in the current region.
-    fr: Fractional,
-    /// Spacing and layouted nodes.
-    items: Vec<FlowItem>,
-    /// Finished frames for previous regions.
-    finished: Vec<Arc<Frame>>,
-}
-
-/// A prepared item in a flow layout.
-enum FlowItem {
-    /// Absolute spacing between other items.
-    Absolute(Length),
-    /// Fractional spacing between other items.
-    Fractional(Fractional),
-    /// A frame for a layouted child node and how to align it.
-    Frame(Arc<Frame>, Spec<Align>),
-    /// An absolutely placed frame.
-    Placed(Arc<Frame>),
-}
-
-impl FlowLayouter {
-    /// Create a new flow layouter.
-    pub fn new(regions: &Regions) -> Self {
-        let expand = regions.expand;
-        let full = regions.first;
-
-        // Disable vertical expansion for children.
-        let mut regions = regions.clone();
-        regions.expand.y = false;
-
-        Self {
-            regions,
-            expand,
-            full,
-            used: Size::zero(),
-            fr: Fractional::zero(),
-            items: vec![],
-            finished: vec![],
-        }
-    }
-
-    /// Layout spacing.
-    pub fn layout_spacing(&mut self, spacing: SpacingKind) {
-        match spacing {
-            SpacingKind::Linear(v) => {
-                // Resolve the linear and limit it to the remaining space.
-                let resolved = v.resolve(self.full.y);
-                let limited = resolved.min(self.regions.first.y);
-                self.regions.first.y -= limited;
-                self.used.y += limited;
-                self.items.push(FlowItem::Absolute(resolved));
-            }
-            SpacingKind::Fractional(v) => {
-                self.items.push(FlowItem::Fractional(v));
-                self.fr += v;
-            }
-        }
-    }
-
-    /// Layout a node.
-    pub fn layout_node(
-        &mut self,
-        ctx: &mut Context,
-        node: &LayoutNode,
-        styles: StyleChain,
-    ) -> TypResult<()> {
-        // Don't even try layouting into a full region.
-        if self.regions.is_full() {
-            self.finish_region();
-        }
-
-        // Placed nodes that are out of flow produce placed items which aren't
-        // aligned later.
-        if let Some(placed) = node.downcast::<PlaceNode>() {
-            if placed.out_of_flow() {
-                let frame = node.layout(ctx, &self.regions, styles)?.remove(0);
-                self.items.push(FlowItem::Placed(frame));
-                return Ok(());
-            }
-        }
-
-        // How to align the node.
-        let aligns = Spec::new(
-            // For non-expanding paragraphs it is crucial that we align the
-            // whole paragraph as it is itself aligned.
-            styles.get(ParNode::ALIGN),
-            // Vertical align node alignment is respected by the flow node.
-            node.downcast::<AlignNode>()
-                .and_then(|aligned| aligned.aligns.y)
-                .unwrap_or(Align::Top),
-        );
-
-        let frames = node.layout(ctx, &self.regions, styles)?;
-        let len = frames.len();
-        for (i, frame) in frames.into_iter().enumerate() {
-            // Grow our size, shrink the region and save the frame for later.
-            let size = frame.size;
-            self.used.y += size.y;
-            self.used.x.set_max(size.x);
-            self.regions.first.y -= size.y;
-            self.items.push(FlowItem::Frame(frame, aligns));
-
-            if i + 1 < len {
-                self.finish_region();
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Finish the frame for one region.
-    pub fn finish_region(&mut self) {
-        // Determine the size of the flow in this region dependening on whether
-        // the region expands.
-        let mut size = self.expand.select(self.full, self.used);
-
-        // Account for fractional spacing in the size calculation.
-        let remaining = self.full.y - self.used.y;
-        if self.fr.get() > 0.0 && self.full.y.is_finite() {
-            self.used.y = self.full.y;
-            size.y = self.full.y;
-        }
-
-        let mut output = Frame::new(size);
-        let mut offset = Length::zero();
-        let mut ruler = Align::Top;
-
-        // Place all frames.
-        for item in self.items.drain(..) {
-            match item {
-                FlowItem::Absolute(v) => {
-                    offset += v;
-                }
-                FlowItem::Fractional(v) => {
-                    offset += v.resolve(self.fr, remaining);
-                }
-                FlowItem::Frame(frame, aligns) => {
-                    ruler = ruler.max(aligns.y);
-                    let x = aligns.x.resolve(size.x - frame.size.x);
-                    let y = offset + ruler.resolve(size.y - self.used.y);
-                    let pos = Point::new(x, y);
-                    offset += frame.size.y;
-                    output.push_frame(pos, frame);
-                }
-                FlowItem::Placed(frame) => {
-                    output.push_frame(Point::zero(), frame);
-                }
-            }
-        }
-
-        // Advance to the next region.
-        self.regions.next();
-        self.full = self.regions.first;
-        self.used = Size::zero();
-        self.fr = Fractional::zero();
-        self.finished.push(Arc::new(output));
-    }
-
-    /// Finish layouting and return the resulting frames.
-    pub fn finish(mut self) -> Vec<Arc<Frame>> {
-        if self.expand.y {
-            while self.regions.backlog.len() > 0 {
-                self.finish_region();
-            }
-        }
-
-        self.finish_region();
-        self.finished
-    }
-}
diff --git a/src/library/grid.rs b/src/library/grid.rs
deleted file mode 100644
index 2d8cb462..00000000
--- a/src/library/grid.rs
+++ /dev/null
@@ -1,581 +0,0 @@
-//! Layout along a row and column raster.
-
-use super::prelude::*;
-
-/// Arrange nodes in a grid.
-#[derive(Debug, Hash)]
-pub struct GridNode {
-    /// Defines sizing for content rows and columns.
-    pub tracks: Spec<Vec<TrackSizing>>,
-    /// Defines sizing of gutter rows and columns between content.
-    pub gutter: Spec<Vec<TrackSizing>>,
-    /// The nodes to be arranged in a grid.
-    pub children: Vec<LayoutNode>,
-}
-
-#[class]
-impl GridNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let columns = args.named("columns")?.unwrap_or_default();
-        let rows = args.named("rows")?.unwrap_or_default();
-        let base_gutter: Vec<TrackSizing> = args.named("gutter")?.unwrap_or_default();
-        let column_gutter = args.named("column-gutter")?;
-        let row_gutter = args.named("row-gutter")?;
-        Ok(Template::block(Self {
-            tracks: Spec::new(columns, rows),
-            gutter: Spec::new(
-                column_gutter.unwrap_or_else(|| base_gutter.clone()),
-                row_gutter.unwrap_or(base_gutter),
-            ),
-            children: args.all()?,
-        }))
-    }
-}
-
-impl Layout for GridNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        // Prepare grid layout by unifying content and gutter tracks.
-        let layouter = GridLayouter::new(
-            self.tracks.as_deref(),
-            self.gutter.as_deref(),
-            &self.children,
-            regions,
-            styles,
-        );
-
-        // Measure the columns and layout the grid row-by-row.
-        layouter.layout(ctx)
-    }
-}
-
-/// Defines how to size a grid cell along an axis.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum TrackSizing {
-    /// Fit the cell to its contents.
-    Auto,
-    /// A length stated in absolute values and/or relative to the parent's size.
-    Linear(Linear),
-    /// A length that is the fraction of the remaining free space in the parent.
-    Fractional(Fractional),
-}
-
-castable! {
-    Vec<TrackSizing>,
-    Expected: "integer or (auto, linear, fractional, or array thereof)",
-    Value::Auto => vec![TrackSizing::Auto],
-    Value::Length(v) => vec![TrackSizing::Linear(v.into())],
-    Value::Relative(v) => vec![TrackSizing::Linear(v.into())],
-    Value::Linear(v) => vec![TrackSizing::Linear(v)],
-    Value::Fractional(v) => vec![TrackSizing::Fractional(v)],
-    Value::Int(v) => vec![TrackSizing::Auto; Value::Int(v).cast::<NonZeroUsize>()?.get()],
-    Value::Array(values) => values
-        .into_iter()
-        .filter_map(|v| v.cast().ok())
-        .collect(),
-}
-
-castable! {
-    TrackSizing,
-    Expected: "auto, linear, or fractional",
-    Value::Auto => Self::Auto,
-    Value::Length(v) => Self::Linear(v.into()),
-    Value::Relative(v) => Self::Linear(v.into()),
-    Value::Linear(v) => Self::Linear(v),
-    Value::Fractional(v) => Self::Fractional(v),
-}
-
-/// Performs grid layout.
-pub struct GridLayouter<'a> {
-    /// The  grid cells.
-    cells: &'a [LayoutNode],
-    /// The column tracks including gutter tracks.
-    cols: Vec<TrackSizing>,
-    /// The row tracks including gutter tracks.
-    rows: Vec<TrackSizing>,
-    /// The regions to layout children into.
-    regions: Regions,
-    /// The inherited styles.
-    styles: StyleChain<'a>,
-    /// Resolved column sizes.
-    rcols: Vec<Length>,
-    /// Rows in the current region.
-    lrows: Vec<Row>,
-    /// The full height of the current region.
-    full: Length,
-    /// The used-up size of the current region. The horizontal size is
-    /// determined once after columns are resolved and not touched again.
-    used: Size,
-    /// The sum of fractional ratios in the current region.
-    fr: Fractional,
-    /// Frames for finished regions.
-    finished: Vec<Arc<Frame>>,
-}
-
-/// Produced by initial row layout, auto and linear rows are already finished,
-/// fractional rows not yet.
-enum Row {
-    /// Finished row frame of auto or linear row.
-    Frame(Frame),
-    /// Ratio of a fractional row and y index of the track.
-    Fr(Fractional, usize),
-}
-
-impl<'a> GridLayouter<'a> {
-    /// Create a new grid layouter.
-    ///
-    /// This prepares grid layout by unifying content and gutter tracks.
-    pub fn new(
-        tracks: Spec<&[TrackSizing]>,
-        gutter: Spec<&[TrackSizing]>,
-        cells: &'a [LayoutNode],
-        regions: &Regions,
-        styles: StyleChain<'a>,
-    ) -> Self {
-        let mut cols = vec![];
-        let mut rows = vec![];
-
-        // Number of content columns: Always at least one.
-        let c = tracks.x.len().max(1);
-
-        // Number of content rows: At least as many as given, but also at least
-        // as many as needed to place each item.
-        let r = {
-            let len = cells.len();
-            let given = tracks.y.len();
-            let needed = len / c + (len % c).clamp(0, 1);
-            given.max(needed)
-        };
-
-        let auto = TrackSizing::Auto;
-        let zero = TrackSizing::Linear(Linear::zero());
-        let get_or = |tracks: &[_], idx, default| {
-            tracks.get(idx).or(tracks.last()).copied().unwrap_or(default)
-        };
-
-        // Collect content and gutter columns.
-        for x in 0 .. c {
-            cols.push(get_or(tracks.x, x, auto));
-            cols.push(get_or(gutter.x, x, zero));
-        }
-
-        // Collect content and gutter rows.
-        for y in 0 .. r {
-            rows.push(get_or(tracks.y, y, auto));
-            rows.push(get_or(gutter.y, y, zero));
-        }
-
-        // Remove superfluous gutter tracks.
-        cols.pop();
-        rows.pop();
-
-        let full = regions.first.y;
-        let rcols = vec![Length::zero(); cols.len()];
-        let lrows = vec![];
-
-        // We use the regions for auto row measurement. Since at that moment,
-        // columns are already sized, we can enable horizontal expansion.
-        let mut regions = regions.clone();
-        regions.expand = Spec::new(true, false);
-
-        Self {
-            cells,
-            cols,
-            rows,
-            regions,
-            styles,
-            rcols,
-            lrows,
-            full,
-            used: Size::zero(),
-            fr: Fractional::zero(),
-            finished: vec![],
-        }
-    }
-
-    /// Determines the columns sizes and then layouts the grid row-by-row.
-    pub fn layout(mut self, ctx: &mut Context) -> TypResult<Vec<Arc<Frame>>> {
-        self.measure_columns(ctx)?;
-
-        for y in 0 .. self.rows.len() {
-            // Skip to next region if current one is full, but only for content
-            // rows, not for gutter rows.
-            if y % 2 == 0 && self.regions.is_full() {
-                self.finish_region(ctx)?;
-            }
-
-            match self.rows[y] {
-                TrackSizing::Auto => self.layout_auto_row(ctx, y)?,
-                TrackSizing::Linear(v) => self.layout_linear_row(ctx, v, y)?,
-                TrackSizing::Fractional(v) => {
-                    self.lrows.push(Row::Fr(v, y));
-                    self.fr += v;
-                }
-            }
-        }
-
-        self.finish_region(ctx)?;
-        Ok(self.finished)
-    }
-
-    /// Determine all column sizes.
-    fn measure_columns(&mut self, ctx: &mut Context) -> TypResult<()> {
-        // Sum of sizes of resolved linear tracks.
-        let mut linear = Length::zero();
-
-        // Sum of fractions of all fractional tracks.
-        let mut fr = Fractional::zero();
-
-        // Resolve the size of all linear columns and compute the sum of all
-        // fractional tracks.
-        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
-            match col {
-                TrackSizing::Auto => {}
-                TrackSizing::Linear(v) => {
-                    let resolved = v.resolve(self.regions.base.x);
-                    *rcol = resolved;
-                    linear += resolved;
-                }
-                TrackSizing::Fractional(v) => fr += v,
-            }
-        }
-
-        // Size that is not used by fixed-size columns.
-        let available = self.regions.first.x - linear;
-        if available >= Length::zero() {
-            // Determine size of auto columns.
-            let (auto, count) = self.measure_auto_columns(ctx, available)?;
-
-            // If there is remaining space, distribute it to fractional columns,
-            // otherwise shrink auto columns.
-            let remaining = available - auto;
-            if remaining >= Length::zero() {
-                if !fr.is_zero() {
-                    self.grow_fractional_columns(remaining, fr);
-                }
-            } else {
-                self.shrink_auto_columns(available, count);
-            }
-        }
-
-        // Sum up the resolved column sizes once here.
-        self.used.x = self.rcols.iter().sum();
-
-        Ok(())
-    }
-
-    /// Measure the size that is available to auto columns.
-    fn measure_auto_columns(
-        &mut self,
-        ctx: &mut Context,
-        available: Length,
-    ) -> TypResult<(Length, usize)> {
-        let mut auto = Length::zero();
-        let mut count = 0;
-
-        // Determine size of auto columns by laying out all cells in those
-        // columns, measuring them and finding the largest one.
-        for (x, &col) in self.cols.iter().enumerate() {
-            if col != TrackSizing::Auto {
-                continue;
-            }
-
-            let mut resolved = Length::zero();
-            for y in 0 .. self.rows.len() {
-                if let Some(node) = self.cell(x, y) {
-                    let size = Size::new(available, self.regions.base.y);
-                    let mut pod =
-                        Regions::one(size, self.regions.base, Spec::splat(false));
-
-                    // For linear rows, we can already resolve the correct
-                    // base, for auto it's already correct and for fr we could
-                    // only guess anyway.
-                    if let TrackSizing::Linear(v) = self.rows[y] {
-                        pod.base.y = v.resolve(self.regions.base.y);
-                    }
-
-                    let frame = node.layout(ctx, &pod, self.styles)?.remove(0);
-                    resolved.set_max(frame.size.x);
-                }
-            }
-
-            self.rcols[x] = resolved;
-            auto += resolved;
-            count += 1;
-        }
-
-        Ok((auto, count))
-    }
-
-    /// Distribute remaining space to fractional columns.
-    fn grow_fractional_columns(&mut self, remaining: Length, fr: Fractional) {
-        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
-            if let TrackSizing::Fractional(v) = col {
-                *rcol = v.resolve(fr, remaining);
-            }
-        }
-    }
-
-    /// Redistribute space to auto columns so that each gets a fair share.
-    fn shrink_auto_columns(&mut self, available: Length, count: usize) {
-        // The fair share each auto column may have.
-        let fair = available / count as f64;
-
-        // The number of overlarge auto columns and the space that will be
-        // equally redistributed to them.
-        let mut overlarge: usize = 0;
-        let mut redistribute = available;
-
-        // Find out the number of and space used by overlarge auto columns.
-        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
-            if col == TrackSizing::Auto {
-                if *rcol > fair {
-                    overlarge += 1;
-                } else {
-                    redistribute -= *rcol;
-                }
-            }
-        }
-
-        // Redistribute the space equally.
-        let share = redistribute / overlarge as f64;
-        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
-            if col == TrackSizing::Auto && *rcol > fair {
-                *rcol = share;
-            }
-        }
-    }
-
-    /// Layout a row with automatic height. Such a row may break across multiple
-    /// regions.
-    fn layout_auto_row(&mut self, ctx: &mut Context, y: usize) -> TypResult<()> {
-        let mut resolved: Vec<Length> = vec![];
-
-        // Determine the size for each region of the row.
-        for (x, &rcol) in self.rcols.iter().enumerate() {
-            if let Some(node) = self.cell(x, y) {
-                let mut pod = self.regions.clone();
-                pod.first.x = rcol;
-
-                // All widths should be `rcol` except the base for auto columns.
-                if self.cols[x] == TrackSizing::Auto {
-                    pod.base.x = self.regions.base.x;
-                }
-
-                let mut sizes = node
-                    .layout(ctx, &pod, self.styles)?
-                    .into_iter()
-                    .map(|frame| frame.size.y);
-
-                // For each region, we want to know the maximum height any
-                // column requires.
-                for (target, size) in resolved.iter_mut().zip(&mut sizes) {
-                    target.set_max(size);
-                }
-
-                // New heights are maximal by virtue of being new. Note that
-                // this extend only uses the rest of the sizes iterator.
-                resolved.extend(sizes);
-            }
-        }
-
-        // Nothing to layout.
-        if resolved.is_empty() {
-            return Ok(());
-        }
-
-        // Layout into a single region.
-        if let &[first] = resolved.as_slice() {
-            let frame = self.layout_single_row(ctx, first, y)?;
-            self.push_row(frame);
-            return Ok(());
-        }
-
-        // Expand all but the last region if the space is not
-        // eaten up by any fr rows.
-        if self.fr.is_zero() {
-            let len = resolved.len();
-            for (region, target) in self.regions.iter().zip(&mut resolved[.. len - 1]) {
-                target.set_max(region.y);
-            }
-        }
-
-        // Layout into multiple regions.
-        let frames = self.layout_multi_row(ctx, &resolved, y)?;
-        let len = frames.len();
-        for (i, frame) in frames.into_iter().enumerate() {
-            self.push_row(frame);
-            if i + 1 < len {
-                self.finish_region(ctx)?;
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Layout a row with linear height. Such a row cannot break across multiple
-    /// regions, but it may force a region break.
-    fn layout_linear_row(
-        &mut self,
-        ctx: &mut Context,
-        v: Linear,
-        y: usize,
-    ) -> TypResult<()> {
-        let resolved = v.resolve(self.regions.base.y);
-        let frame = self.layout_single_row(ctx, resolved, y)?;
-
-        // Skip to fitting region.
-        let height = frame.size.y;
-        while !self.regions.first.y.fits(height) && !self.regions.in_last() {
-            self.finish_region(ctx)?;
-
-            // Don't skip multiple regions for gutter and don't push a row.
-            if y % 2 == 1 {
-                return Ok(());
-            }
-        }
-
-        self.push_row(frame);
-
-        Ok(())
-    }
-
-    /// Layout a row with fixed height and return its frame.
-    fn layout_single_row(
-        &self,
-        ctx: &mut Context,
-        height: Length,
-        y: usize,
-    ) -> TypResult<Frame> {
-        let mut output = Frame::new(Size::new(self.used.x, height));
-        let mut pos = Point::zero();
-
-        for (x, &rcol) in self.rcols.iter().enumerate() {
-            if let Some(node) = self.cell(x, y) {
-                let size = Size::new(rcol, height);
-
-                // Set the base to the region's base for auto rows and to the
-                // size for linear and fractional rows.
-                let base = Spec::new(self.cols[x], self.rows[y])
-                    .map(|s| s == TrackSizing::Auto)
-                    .select(self.regions.base, size);
-
-                let pod = Regions::one(size, base, Spec::splat(true));
-                let frame = node.layout(ctx, &pod, self.styles)?.remove(0);
-                output.push_frame(pos, frame);
-            }
-
-            pos.x += rcol;
-        }
-
-        Ok(output)
-    }
-
-    /// Layout a row spanning multiple regions.
-    fn layout_multi_row(
-        &self,
-        ctx: &mut Context,
-        heights: &[Length],
-        y: usize,
-    ) -> TypResult<Vec<Frame>> {
-        // Prepare frames.
-        let mut outputs: Vec<_> = heights
-            .iter()
-            .map(|&h| Frame::new(Size::new(self.used.x, h)))
-            .collect();
-
-        // Prepare regions.
-        let size = Size::new(self.used.x, heights[0]);
-        let mut pod = Regions::one(size, self.regions.base, Spec::splat(true));
-        pod.backlog = heights[1 ..].to_vec();
-
-        // Layout the row.
-        let mut pos = Point::zero();
-        for (x, &rcol) in self.rcols.iter().enumerate() {
-            if let Some(node) = self.cell(x, y) {
-                pod.first.x = rcol;
-
-                // All widths should be `rcol` except the base for auto columns.
-                if self.cols[x] == TrackSizing::Auto {
-                    pod.base.x = self.regions.base.x;
-                }
-
-                // Push the layouted frames into the individual output frames.
-                let frames = node.layout(ctx, &pod, self.styles)?;
-                for (output, frame) in outputs.iter_mut().zip(frames) {
-                    output.push_frame(pos, frame);
-                }
-            }
-
-            pos.x += rcol;
-        }
-
-        Ok(outputs)
-    }
-
-    /// Push a row frame into the current region.
-    fn push_row(&mut self, frame: Frame) {
-        self.regions.first.y -= frame.size.y;
-        self.used.y += frame.size.y;
-        self.lrows.push(Row::Frame(frame));
-    }
-
-    /// Finish rows for one region.
-    fn finish_region(&mut self, ctx: &mut Context) -> TypResult<()> {
-        // Determine the size of the grid in this region, expanding fully if
-        // there are fr rows.
-        let mut size = self.used;
-        if self.fr.get() > 0.0 && self.full.is_finite() {
-            size.y = self.full;
-        }
-
-        // The frame for the region.
-        let mut output = Frame::new(size);
-        let mut pos = Point::zero();
-
-        // Place finished rows and layout fractional rows.
-        for row in std::mem::take(&mut self.lrows) {
-            let frame = match row {
-                Row::Frame(frame) => frame,
-                Row::Fr(v, y) => {
-                    let remaining = self.full - self.used.y;
-                    let height = v.resolve(self.fr, remaining);
-                    self.layout_single_row(ctx, height, y)?
-                }
-            };
-
-            let height = frame.size.y;
-            output.merge_frame(pos, frame);
-            pos.y += height;
-        }
-
-        self.finished.push(Arc::new(output));
-        self.regions.next();
-        self.full = self.regions.first.y;
-        self.used.y = Length::zero();
-        self.fr = Fractional::zero();
-
-        Ok(())
-    }
-
-    /// Get the node in the cell in column `x` and row `y`.
-    ///
-    /// Returns `None` if it's a gutter cell.
-    #[track_caller]
-    fn cell(&self, x: usize, y: usize) -> Option<&'a LayoutNode> {
-        assert!(x < self.cols.len());
-        assert!(y < self.rows.len());
-
-        // Even columns and rows are children, odd ones are gutter.
-        if x % 2 == 0 && y % 2 == 0 {
-            let c = 1 + self.cols.len() / 2;
-            self.cells.get((y / 2) * c + x / 2)
-        } else {
-            None
-        }
-    }
-}
diff --git a/src/library/heading.rs b/src/library/heading.rs
deleted file mode 100644
index 0c9c8e27..00000000
--- a/src/library/heading.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-//! Document-structuring section headings.
-
-use super::prelude::*;
-use super::{FontFamily, TextNode};
-
-/// A section heading.
-#[derive(Debug, Hash)]
-pub struct HeadingNode {
-    /// The logical nesting depth of the section, starting from one. In the
-    /// default style, this controls the text size of the heading.
-    pub level: usize,
-    /// The heading's contents.
-    pub body: Template,
-}
-
-#[class]
-impl HeadingNode {
-    /// The heading's font family. Just the normal text family if `auto`.
-    pub const FAMILY: Leveled<Smart<FontFamily>> = Leveled::Value(Smart::Auto);
-    /// The color of text in the heading. Just the normal text color if `auto`.
-    pub const FILL: Leveled<Smart<Paint>> = Leveled::Value(Smart::Auto);
-    /// The size of text in the heading.
-    pub const SIZE: Leveled<Linear> = Leveled::Mapping(|level| {
-        let upscale = (1.6 - 0.1 * level as f64).max(0.75);
-        Relative::new(upscale).into()
-    });
-    /// Whether text in the heading is strengthend.
-    pub const STRONG: Leveled<bool> = Leveled::Value(true);
-    /// Whether text in the heading is emphasized.
-    pub const EMPH: Leveled<bool> = Leveled::Value(false);
-    /// Whether the heading is underlined.
-    pub const UNDERLINE: Leveled<bool> = Leveled::Value(false);
-    /// The extra padding above the heading.
-    pub const ABOVE: Leveled<Length> = Leveled::Value(Length::zero());
-    /// The extra padding below the heading.
-    pub const BELOW: Leveled<Length> = Leveled::Value(Length::zero());
-    /// Whether the heading is block-level.
-    pub const BLOCK: Leveled<bool> = Leveled::Value(true);
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self {
-            body: args.expect("body")?,
-            level: args.named("level")?.unwrap_or(1),
-        }))
-    }
-}
-
-impl Show for HeadingNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        macro_rules! resolve {
-            ($key:expr) => {
-                styles.get_cloned($key).resolve(ctx, self.level)?
-            };
-        }
-
-        // Resolve the user recipe.
-        let mut body = styles
-            .show(self, ctx, [
-                Value::Int(self.level as i64),
-                Value::Template(self.body.clone()),
-            ])?
-            .unwrap_or_else(|| self.body.clone());
-
-        let mut map = StyleMap::new();
-        map.set(TextNode::SIZE, resolve!(Self::SIZE));
-
-        if let Smart::Custom(family) = resolve!(Self::FAMILY) {
-            map.set(
-                TextNode::FAMILY,
-                std::iter::once(family)
-                    .chain(styles.get_ref(TextNode::FAMILY).iter().cloned())
-                    .collect(),
-            );
-        }
-
-        if let Smart::Custom(fill) = resolve!(Self::FILL) {
-            map.set(TextNode::FILL, fill);
-        }
-
-        if resolve!(Self::STRONG) {
-            map.set(TextNode::STRONG, true);
-        }
-
-        if resolve!(Self::EMPH) {
-            map.set(TextNode::EMPH, true);
-        }
-
-        let mut seq = vec![];
-        if resolve!(Self::UNDERLINE) {
-            body = body.underlined();
-        }
-
-        let above = resolve!(Self::ABOVE);
-        if !above.is_zero() {
-            seq.push(Template::Vertical(above.into()));
-        }
-
-        seq.push(body);
-
-        let below = resolve!(Self::BELOW);
-        if !below.is_zero() {
-            seq.push(Template::Vertical(below.into()));
-        }
-
-        let mut template = Template::sequence(seq).styled_with_map(map);
-        if resolve!(Self::BLOCK) {
-            template = Template::block(template);
-        }
-
-        Ok(template)
-    }
-}
-
-/// Either the value or a closure mapping to the value.
-#[derive(Debug, Clone, PartialEq, Hash)]
-pub enum Leveled<T> {
-    /// A bare value.
-    Value(T),
-    /// A simple mapping from a heading level to a value.
-    Mapping(fn(usize) -> T),
-    /// A closure mapping from a heading level to a value.
-    Func(Func, Span),
-}
-
-impl<T: Cast> Leveled<T> {
-    /// Resolve the value based on the level.
-    pub fn resolve(self, ctx: &mut Context, level: usize) -> TypResult<T> {
-        Ok(match self {
-            Self::Value(value) => value,
-            Self::Mapping(mapping) => mapping(level),
-            Self::Func(func, span) => {
-                let args = Args::from_values(span, [Value::Int(level as i64)]);
-                func.call(ctx, args)?.cast().at(span)?
-            }
-        })
-    }
-}
-
-impl<T: Cast> Cast<Spanned<Value>> for Leveled<T> {
-    fn is(value: &Spanned<Value>) -> bool {
-        matches!(&value.v, Value::Func(_)) || T::is(&value.v)
-    }
-
-    fn cast(value: Spanned<Value>) -> StrResult<Self> {
-        match value.v {
-            Value::Func(v) => Ok(Self::Func(v, value.span)),
-            v => T::cast(v)
-                .map(Self::Value)
-                .map_err(|msg| with_alternative(msg, "function")),
-        }
-    }
-}
diff --git a/src/library/hide.rs b/src/library/hide.rs
deleted file mode 100644
index 89aea6d3..00000000
--- a/src/library/hide.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//! Hiding of nodes without affecting layout.
-
-use super::prelude::*;
-
-/// Hide a node without affecting layout.
-#[derive(Debug, Hash)]
-pub struct HideNode(pub LayoutNode);
-
-#[class]
-impl HideNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::inline(Self(args.expect("body")?)))
-    }
-}
-
-impl Layout for HideNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let mut frames = self.0.layout(ctx, regions, styles)?;
-
-        // Clear the frames.
-        for frame in &mut frames {
-            *frame = Arc::new(Frame { elements: vec![], ..**frame });
-        }
-
-        Ok(frames)
-    }
-}
diff --git a/src/library/image.rs b/src/library/image.rs
deleted file mode 100644
index c1220734..00000000
--- a/src/library/image.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-//! Raster and vector graphics.
-
-use super::prelude::*;
-use super::TextNode;
-use crate::diag::Error;
-use crate::image::ImageId;
-
-/// Show a raster or vector graphic.
-#[derive(Debug, Hash)]
-pub struct ImageNode(pub ImageId);
-
-#[class]
-impl ImageNode {
-    /// How the image should adjust itself to a given area.
-    pub const FIT: ImageFit = ImageFit::Cover;
-
-    fn construct(ctx: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let path = args.expect::<Spanned<EcoString>>("path to image file")?;
-        let full = ctx.resolve(&path.v);
-        let id = ctx.images.load(&full).map_err(|err| {
-            Error::boxed(path.span, match err.kind() {
-                std::io::ErrorKind::NotFound => "file not found".into(),
-                _ => format!("failed to load image ({})", err),
-            })
-        })?;
-
-        let width = args.named("width")?;
-        let height = args.named("height")?;
-
-        Ok(Template::inline(
-            ImageNode(id).pack().sized(Spec::new(width, height)),
-        ))
-    }
-}
-
-impl Layout for ImageNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let img = ctx.images.get(self.0);
-        let pxw = img.width() as f64;
-        let pxh = img.height() as f64;
-        let px_ratio = pxw / pxh;
-
-        // Find out whether the image is wider or taller than the target size.
-        let &Regions { first, expand, .. } = regions;
-        let region_ratio = first.x / first.y;
-        let wide = px_ratio > region_ratio;
-
-        // The space into which the image will be placed according to its fit.
-        let target = if expand.x && expand.y {
-            first
-        } else if expand.x || (!expand.y && wide && first.x.is_finite()) {
-            Size::new(first.x, first.y.min(first.x.safe_div(px_ratio)))
-        } else if first.y.is_finite() {
-            Size::new(first.x.min(first.y * px_ratio), first.y)
-        } else {
-            Size::new(Length::pt(pxw), Length::pt(pxh))
-        };
-
-        // Compute the actual size of the fitted image.
-        let fit = styles.get(Self::FIT);
-        let fitted = match fit {
-            ImageFit::Cover | ImageFit::Contain => {
-                if wide == (fit == ImageFit::Contain) {
-                    Size::new(target.x, target.x / px_ratio)
-                } else {
-                    Size::new(target.y * px_ratio, target.y)
-                }
-            }
-            ImageFit::Stretch => target,
-        };
-
-        // First, place the image in a frame of exactly its size and then resize
-        // the frame to the target size, center aligning the image in the
-        // process.
-        let mut frame = Frame::new(fitted);
-        frame.push(Point::zero(), Element::Image(self.0, fitted));
-        frame.resize(target, Align::CENTER_HORIZON);
-
-        // Create a clipping group if only part of the image should be visible.
-        if fit == ImageFit::Cover && !target.fits(fitted) {
-            frame.clip();
-        }
-
-        // Apply link if it exists.
-        if let Some(url) = styles.get_ref(TextNode::LINK) {
-            frame.link(url);
-        }
-
-        Ok(vec![Arc::new(frame)])
-    }
-}
-
-/// How an image should adjust itself to a given area.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum ImageFit {
-    /// The image should completely cover the area.
-    Cover,
-    /// The image should be fully contained in the area.
-    Contain,
-    /// The image should be stretched so that it exactly fills the area.
-    Stretch,
-}
-
-castable! {
-    ImageFit,
-    Expected: "string",
-    Value::Str(string) => match string.as_str() {
-        "cover" => Self::Cover,
-        "contain" => Self::Contain,
-        "stretch" => Self::Stretch,
-        _ => Err(r#"expected "cover", "contain" or "stretch""#)?,
-    },
-}
diff --git a/src/library/layout/align.rs b/src/library/layout/align.rs
new file mode 100644
index 00000000..7fbe0d01
--- /dev/null
+++ b/src/library/layout/align.rs
@@ -0,0 +1,71 @@
+use crate::library::prelude::*;
+use crate::library::text::ParNode;
+
+/// Align a node along the layouting axes.
+#[derive(Debug, Hash)]
+pub struct AlignNode {
+    /// How to align the node horizontally and vertically.
+    pub aligns: Spec<Option<Align>>,
+    /// The node to be aligned.
+    pub child: LayoutNode,
+}
+
+#[class]
+impl AlignNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let aligns: Spec<_> = args.find()?.unwrap_or_default();
+        let body: LayoutNode = args.expect("body")?;
+        Ok(Template::block(body.aligned(aligns)))
+    }
+}
+
+impl Layout for AlignNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        // The child only needs to expand along an axis if there's no alignment.
+        let mut pod = regions.clone();
+        pod.expand &= self.aligns.map_is_none();
+
+        // Align paragraphs inside the child.
+        let mut passed = StyleMap::new();
+        if let Some(align) = self.aligns.x {
+            passed.set(ParNode::ALIGN, align);
+        }
+
+        // Layout the child.
+        let mut frames = self.child.layout(ctx, &pod, passed.chain(&styles))?;
+        for (region, frame) in regions.iter().zip(&mut frames) {
+            // Align in the target size. The target size depends on whether we
+            // should expand.
+            let target = regions.expand.select(region, frame.size);
+            let default = Spec::new(Align::Left, Align::Top);
+            let aligns = self.aligns.unwrap_or(default);
+            Arc::make_mut(frame).resize(target, aligns);
+        }
+
+        Ok(frames)
+    }
+}
+
+dynamic! {
+    Align: "alignment",
+}
+
+dynamic! {
+    Spec<Align>: "2d 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/layout/columns.rs b/src/library/layout/columns.rs
new file mode 100644
index 00000000..167e7068
--- /dev/null
+++ b/src/library/layout/columns.rs
@@ -0,0 +1,111 @@
+use crate::library::prelude::*;
+use crate::library::text::ParNode;
+
+/// Separate a region into multiple equally sized columns.
+#[derive(Debug, Hash)]
+pub struct ColumnsNode {
+    /// How many columns there should be.
+    pub columns: NonZeroUsize,
+    /// The child to be layouted into the columns. Most likely, this should be a
+    /// flow or stack node.
+    pub child: LayoutNode,
+}
+
+#[class]
+impl ColumnsNode {
+    /// The size of the gutter space between each column.
+    pub const GUTTER: Linear = Relative::new(0.04).into();
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::block(Self {
+            columns: args.expect("column count")?,
+            child: args.expect("body")?,
+        }))
+    }
+}
+
+impl Layout for ColumnsNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        // Separating the infinite space into infinite columns does not make
+        // much sense.
+        if regions.first.x.is_infinite() {
+            return self.child.layout(ctx, regions, styles);
+        }
+
+        // Determine the width of the gutter and each column.
+        let columns = self.columns.get();
+        let gutter = styles.get(Self::GUTTER).resolve(regions.base.x);
+        let width = (regions.first.x - gutter * (columns - 1) as f64) / columns as f64;
+
+        // Create the pod regions.
+        let pod = Regions {
+            first: Size::new(width, regions.first.y),
+            base: Size::new(width, regions.base.y),
+            backlog: std::iter::once(&regions.first.y)
+                .chain(regions.backlog.as_slice())
+                .flat_map(|&height| std::iter::repeat(height).take(columns))
+                .skip(1)
+                .collect(),
+            last: regions.last,
+            expand: Spec::new(true, regions.expand.y),
+        };
+
+        // Layout the children.
+        let mut frames = self.child.layout(ctx, &pod, styles)?.into_iter();
+
+        let dir = styles.get(ParNode::DIR);
+        let total_regions = (frames.len() as f32 / columns as f32).ceil() as usize;
+        let mut finished = vec![];
+
+        // Stitch together the columns for each region.
+        for region in regions.iter().take(total_regions) {
+            // The height should be the parent height if the node shall expand.
+            // Otherwise its the maximum column height for the frame. In that
+            // case, the frame is first created with zero height and then
+            // resized.
+            let height = if regions.expand.y { region.y } else { Length::zero() };
+            let mut output = Frame::new(Size::new(regions.first.x, height));
+            let mut cursor = Length::zero();
+
+            for _ in 0 .. columns {
+                let frame = match frames.next() {
+                    Some(frame) => frame,
+                    None => break,
+                };
+
+                if !regions.expand.y {
+                    output.size.y.set_max(frame.size.y);
+                }
+
+                let width = frame.size.x;
+                let x = if dir.is_positive() {
+                    cursor
+                } else {
+                    regions.first.x - cursor - width
+                };
+
+                output.push_frame(Point::with_x(x), frame);
+                cursor += width + gutter;
+            }
+
+            finished.push(Arc::new(output));
+        }
+
+        Ok(finished)
+    }
+}
+
+/// A column break.
+pub struct ColbreakNode;
+
+#[class]
+impl ColbreakNode {
+    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
+        Ok(Template::Colbreak)
+    }
+}
diff --git a/src/library/layout/container.rs b/src/library/layout/container.rs
new file mode 100644
index 00000000..55579878
--- /dev/null
+++ b/src/library/layout/container.rs
@@ -0,0 +1,24 @@
+use crate::library::prelude::*;
+
+/// An inline-level container that sizes content and places it into a paragraph.
+pub struct BoxNode;
+
+#[class]
+impl BoxNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let width = args.named("width")?;
+        let height = args.named("height")?;
+        let body: LayoutNode = args.find()?.unwrap_or_default();
+        Ok(Template::inline(body.sized(Spec::new(width, height))))
+    }
+}
+
+/// A block-level container that places content into a separate flow.
+pub struct BlockNode;
+
+#[class]
+impl BlockNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::Block(args.find()?.unwrap_or_default()))
+    }
+}
diff --git a/src/library/layout/flow.rs b/src/library/layout/flow.rs
new file mode 100644
index 00000000..f4b885b1
--- /dev/null
+++ b/src/library/layout/flow.rs
@@ -0,0 +1,272 @@
+use super::{AlignNode, PlaceNode, SpacingKind};
+use crate::library::prelude::*;
+use crate::library::text::{ParNode, TextNode};
+
+/// Arrange spacing, paragraphs and other block-level nodes into a flow.
+///
+/// This node is reponsible for layouting both the top-level content flow and
+/// the contents of boxes.
+#[derive(Hash)]
+pub struct FlowNode(pub StyleVec<FlowChild>);
+
+/// A child of a flow node.
+#[derive(Hash)]
+pub enum FlowChild {
+    /// Leading between other children.
+    Leading,
+    /// A paragraph / block break.
+    Parbreak,
+    /// A column / region break.
+    Colbreak,
+    /// Vertical spacing between other children.
+    Spacing(SpacingKind),
+    /// An arbitrary block-level node.
+    Node(LayoutNode),
+}
+
+impl Layout for FlowNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let mut layouter = FlowLayouter::new(regions);
+
+        for (child, map) in self.0.iter() {
+            let styles = map.chain(&styles);
+            match child {
+                FlowChild::Leading => {
+                    let em = styles.get(TextNode::SIZE).abs;
+                    let amount = styles.get(ParNode::LEADING).resolve(em);
+                    layouter.layout_spacing(amount.into());
+                }
+                FlowChild::Parbreak => {
+                    let em = styles.get(TextNode::SIZE).abs;
+                    let leading = styles.get(ParNode::LEADING);
+                    let spacing = styles.get(ParNode::SPACING);
+                    let amount = (leading + spacing).resolve(em);
+                    layouter.layout_spacing(amount.into());
+                }
+                FlowChild::Colbreak => {
+                    layouter.finish_region();
+                }
+                FlowChild::Spacing(kind) => {
+                    layouter.layout_spacing(*kind);
+                }
+                FlowChild::Node(ref node) => {
+                    layouter.layout_node(ctx, node, styles)?;
+                }
+            }
+        }
+
+        Ok(layouter.finish())
+    }
+}
+
+impl Merge for FlowChild {
+    fn merge(&mut self, _: &Self) -> bool {
+        false
+    }
+}
+
+impl Debug for FlowNode {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("Flow ")?;
+        self.0.fmt(f)
+    }
+}
+
+impl Debug for FlowChild {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Leading => f.pad("Leading"),
+            Self::Parbreak => f.pad("Parbreak"),
+            Self::Colbreak => f.pad("Colbreak"),
+            Self::Spacing(kind) => write!(f, "{:?}", kind),
+            Self::Node(node) => node.fmt(f),
+        }
+    }
+}
+
+/// Performs flow layout.
+pub struct FlowLayouter {
+    /// The regions to layout children into.
+    regions: Regions,
+    /// Whether the flow should expand to fill the region.
+    expand: Spec<bool>,
+    /// The full size of `regions.size` that was available before we started
+    /// subtracting.
+    full: Size,
+    /// The size used by the frames for the current region.
+    used: Size,
+    /// The sum of fractional ratios in the current region.
+    fr: Fractional,
+    /// Spacing and layouted nodes.
+    items: Vec<FlowItem>,
+    /// Finished frames for previous regions.
+    finished: Vec<Arc<Frame>>,
+}
+
+/// A prepared item in a flow layout.
+enum FlowItem {
+    /// Absolute spacing between other items.
+    Absolute(Length),
+    /// Fractional spacing between other items.
+    Fractional(Fractional),
+    /// A frame for a layouted child node and how to align it.
+    Frame(Arc<Frame>, Spec<Align>),
+    /// An absolutely placed frame.
+    Placed(Arc<Frame>),
+}
+
+impl FlowLayouter {
+    /// Create a new flow layouter.
+    pub fn new(regions: &Regions) -> Self {
+        let expand = regions.expand;
+        let full = regions.first;
+
+        // Disable vertical expansion for children.
+        let mut regions = regions.clone();
+        regions.expand.y = false;
+
+        Self {
+            regions,
+            expand,
+            full,
+            used: Size::zero(),
+            fr: Fractional::zero(),
+            items: vec![],
+            finished: vec![],
+        }
+    }
+
+    /// Layout spacing.
+    pub fn layout_spacing(&mut self, spacing: SpacingKind) {
+        match spacing {
+            SpacingKind::Linear(v) => {
+                // Resolve the linear and limit it to the remaining space.
+                let resolved = v.resolve(self.full.y);
+                let limited = resolved.min(self.regions.first.y);
+                self.regions.first.y -= limited;
+                self.used.y += limited;
+                self.items.push(FlowItem::Absolute(resolved));
+            }
+            SpacingKind::Fractional(v) => {
+                self.items.push(FlowItem::Fractional(v));
+                self.fr += v;
+            }
+        }
+    }
+
+    /// Layout a node.
+    pub fn layout_node(
+        &mut self,
+        ctx: &mut Context,
+        node: &LayoutNode,
+        styles: StyleChain,
+    ) -> TypResult<()> {
+        // Don't even try layouting into a full region.
+        if self.regions.is_full() {
+            self.finish_region();
+        }
+
+        // Placed nodes that are out of flow produce placed items which aren't
+        // aligned later.
+        if let Some(placed) = node.downcast::<PlaceNode>() {
+            if placed.out_of_flow() {
+                let frame = node.layout(ctx, &self.regions, styles)?.remove(0);
+                self.items.push(FlowItem::Placed(frame));
+                return Ok(());
+            }
+        }
+
+        // How to align the node.
+        let aligns = Spec::new(
+            // For non-expanding paragraphs it is crucial that we align the
+            // whole paragraph as it is itself aligned.
+            styles.get(ParNode::ALIGN),
+            // Vertical align node alignment is respected by the flow node.
+            node.downcast::<AlignNode>()
+                .and_then(|aligned| aligned.aligns.y)
+                .unwrap_or(Align::Top),
+        );
+
+        let frames = node.layout(ctx, &self.regions, styles)?;
+        let len = frames.len();
+        for (i, frame) in frames.into_iter().enumerate() {
+            // Grow our size, shrink the region and save the frame for later.
+            let size = frame.size;
+            self.used.y += size.y;
+            self.used.x.set_max(size.x);
+            self.regions.first.y -= size.y;
+            self.items.push(FlowItem::Frame(frame, aligns));
+
+            if i + 1 < len {
+                self.finish_region();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Finish the frame for one region.
+    pub fn finish_region(&mut self) {
+        // Determine the size of the flow in this region dependening on whether
+        // the region expands.
+        let mut size = self.expand.select(self.full, self.used);
+
+        // Account for fractional spacing in the size calculation.
+        let remaining = self.full.y - self.used.y;
+        if self.fr.get() > 0.0 && self.full.y.is_finite() {
+            self.used.y = self.full.y;
+            size.y = self.full.y;
+        }
+
+        let mut output = Frame::new(size);
+        let mut offset = Length::zero();
+        let mut ruler = Align::Top;
+
+        // Place all frames.
+        for item in self.items.drain(..) {
+            match item {
+                FlowItem::Absolute(v) => {
+                    offset += v;
+                }
+                FlowItem::Fractional(v) => {
+                    offset += v.resolve(self.fr, remaining);
+                }
+                FlowItem::Frame(frame, aligns) => {
+                    ruler = ruler.max(aligns.y);
+                    let x = aligns.x.resolve(size.x - frame.size.x);
+                    let y = offset + ruler.resolve(size.y - self.used.y);
+                    let pos = Point::new(x, y);
+                    offset += frame.size.y;
+                    output.push_frame(pos, frame);
+                }
+                FlowItem::Placed(frame) => {
+                    output.push_frame(Point::zero(), frame);
+                }
+            }
+        }
+
+        // Advance to the next region.
+        self.regions.next();
+        self.full = self.regions.first;
+        self.used = Size::zero();
+        self.fr = Fractional::zero();
+        self.finished.push(Arc::new(output));
+    }
+
+    /// Finish layouting and return the resulting frames.
+    pub fn finish(mut self) -> Vec<Arc<Frame>> {
+        if self.expand.y {
+            while self.regions.backlog.len() > 0 {
+                self.finish_region();
+            }
+        }
+
+        self.finish_region();
+        self.finished
+    }
+}
diff --git a/src/library/layout/grid.rs b/src/library/layout/grid.rs
new file mode 100644
index 00000000..63cd83b1
--- /dev/null
+++ b/src/library/layout/grid.rs
@@ -0,0 +1,579 @@
+use crate::library::prelude::*;
+
+/// Arrange nodes in a grid.
+#[derive(Debug, Hash)]
+pub struct GridNode {
+    /// Defines sizing for content rows and columns.
+    pub tracks: Spec<Vec<TrackSizing>>,
+    /// Defines sizing of gutter rows and columns between content.
+    pub gutter: Spec<Vec<TrackSizing>>,
+    /// The nodes to be arranged in a grid.
+    pub children: Vec<LayoutNode>,
+}
+
+#[class]
+impl GridNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let columns = args.named("columns")?.unwrap_or_default();
+        let rows = args.named("rows")?.unwrap_or_default();
+        let base_gutter: Vec<TrackSizing> = args.named("gutter")?.unwrap_or_default();
+        let column_gutter = args.named("column-gutter")?;
+        let row_gutter = args.named("row-gutter")?;
+        Ok(Template::block(Self {
+            tracks: Spec::new(columns, rows),
+            gutter: Spec::new(
+                column_gutter.unwrap_or_else(|| base_gutter.clone()),
+                row_gutter.unwrap_or(base_gutter),
+            ),
+            children: args.all()?,
+        }))
+    }
+}
+
+impl Layout for GridNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        // Prepare grid layout by unifying content and gutter tracks.
+        let layouter = GridLayouter::new(
+            self.tracks.as_deref(),
+            self.gutter.as_deref(),
+            &self.children,
+            regions,
+            styles,
+        );
+
+        // Measure the columns and layout the grid row-by-row.
+        layouter.layout(ctx)
+    }
+}
+
+/// Defines how to size a grid cell along an axis.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum TrackSizing {
+    /// Fit the cell to its contents.
+    Auto,
+    /// A length stated in absolute values and/or relative to the parent's size.
+    Linear(Linear),
+    /// A length that is the fraction of the remaining free space in the parent.
+    Fractional(Fractional),
+}
+
+castable! {
+    Vec<TrackSizing>,
+    Expected: "integer or (auto, linear, fractional, or array thereof)",
+    Value::Auto => vec![TrackSizing::Auto],
+    Value::Length(v) => vec![TrackSizing::Linear(v.into())],
+    Value::Relative(v) => vec![TrackSizing::Linear(v.into())],
+    Value::Linear(v) => vec![TrackSizing::Linear(v)],
+    Value::Fractional(v) => vec![TrackSizing::Fractional(v)],
+    Value::Int(v) => vec![TrackSizing::Auto; Value::Int(v).cast::<NonZeroUsize>()?.get()],
+    Value::Array(values) => values
+        .into_iter()
+        .filter_map(|v| v.cast().ok())
+        .collect(),
+}
+
+castable! {
+    TrackSizing,
+    Expected: "auto, linear, or fractional",
+    Value::Auto => Self::Auto,
+    Value::Length(v) => Self::Linear(v.into()),
+    Value::Relative(v) => Self::Linear(v.into()),
+    Value::Linear(v) => Self::Linear(v),
+    Value::Fractional(v) => Self::Fractional(v),
+}
+
+/// Performs grid layout.
+pub struct GridLayouter<'a> {
+    /// The  grid cells.
+    cells: &'a [LayoutNode],
+    /// The column tracks including gutter tracks.
+    cols: Vec<TrackSizing>,
+    /// The row tracks including gutter tracks.
+    rows: Vec<TrackSizing>,
+    /// The regions to layout children into.
+    regions: Regions,
+    /// The inherited styles.
+    styles: StyleChain<'a>,
+    /// Resolved column sizes.
+    rcols: Vec<Length>,
+    /// Rows in the current region.
+    lrows: Vec<Row>,
+    /// The full height of the current region.
+    full: Length,
+    /// The used-up size of the current region. The horizontal size is
+    /// determined once after columns are resolved and not touched again.
+    used: Size,
+    /// The sum of fractional ratios in the current region.
+    fr: Fractional,
+    /// Frames for finished regions.
+    finished: Vec<Arc<Frame>>,
+}
+
+/// Produced by initial row layout, auto and linear rows are already finished,
+/// fractional rows not yet.
+enum Row {
+    /// Finished row frame of auto or linear row.
+    Frame(Frame),
+    /// Ratio of a fractional row and y index of the track.
+    Fr(Fractional, usize),
+}
+
+impl<'a> GridLayouter<'a> {
+    /// Create a new grid layouter.
+    ///
+    /// This prepares grid layout by unifying content and gutter tracks.
+    pub fn new(
+        tracks: Spec<&[TrackSizing]>,
+        gutter: Spec<&[TrackSizing]>,
+        cells: &'a [LayoutNode],
+        regions: &Regions,
+        styles: StyleChain<'a>,
+    ) -> Self {
+        let mut cols = vec![];
+        let mut rows = vec![];
+
+        // Number of content columns: Always at least one.
+        let c = tracks.x.len().max(1);
+
+        // Number of content rows: At least as many as given, but also at least
+        // as many as needed to place each item.
+        let r = {
+            let len = cells.len();
+            let given = tracks.y.len();
+            let needed = len / c + (len % c).clamp(0, 1);
+            given.max(needed)
+        };
+
+        let auto = TrackSizing::Auto;
+        let zero = TrackSizing::Linear(Linear::zero());
+        let get_or = |tracks: &[_], idx, default| {
+            tracks.get(idx).or(tracks.last()).copied().unwrap_or(default)
+        };
+
+        // Collect content and gutter columns.
+        for x in 0 .. c {
+            cols.push(get_or(tracks.x, x, auto));
+            cols.push(get_or(gutter.x, x, zero));
+        }
+
+        // Collect content and gutter rows.
+        for y in 0 .. r {
+            rows.push(get_or(tracks.y, y, auto));
+            rows.push(get_or(gutter.y, y, zero));
+        }
+
+        // Remove superfluous gutter tracks.
+        cols.pop();
+        rows.pop();
+
+        let full = regions.first.y;
+        let rcols = vec![Length::zero(); cols.len()];
+        let lrows = vec![];
+
+        // We use the regions for auto row measurement. Since at that moment,
+        // columns are already sized, we can enable horizontal expansion.
+        let mut regions = regions.clone();
+        regions.expand = Spec::new(true, false);
+
+        Self {
+            cells,
+            cols,
+            rows,
+            regions,
+            styles,
+            rcols,
+            lrows,
+            full,
+            used: Size::zero(),
+            fr: Fractional::zero(),
+            finished: vec![],
+        }
+    }
+
+    /// Determines the columns sizes and then layouts the grid row-by-row.
+    pub fn layout(mut self, ctx: &mut Context) -> TypResult<Vec<Arc<Frame>>> {
+        self.measure_columns(ctx)?;
+
+        for y in 0 .. self.rows.len() {
+            // Skip to next region if current one is full, but only for content
+            // rows, not for gutter rows.
+            if y % 2 == 0 && self.regions.is_full() {
+                self.finish_region(ctx)?;
+            }
+
+            match self.rows[y] {
+                TrackSizing::Auto => self.layout_auto_row(ctx, y)?,
+                TrackSizing::Linear(v) => self.layout_linear_row(ctx, v, y)?,
+                TrackSizing::Fractional(v) => {
+                    self.lrows.push(Row::Fr(v, y));
+                    self.fr += v;
+                }
+            }
+        }
+
+        self.finish_region(ctx)?;
+        Ok(self.finished)
+    }
+
+    /// Determine all column sizes.
+    fn measure_columns(&mut self, ctx: &mut Context) -> TypResult<()> {
+        // Sum of sizes of resolved linear tracks.
+        let mut linear = Length::zero();
+
+        // Sum of fractions of all fractional tracks.
+        let mut fr = Fractional::zero();
+
+        // Resolve the size of all linear columns and compute the sum of all
+        // fractional tracks.
+        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
+            match col {
+                TrackSizing::Auto => {}
+                TrackSizing::Linear(v) => {
+                    let resolved = v.resolve(self.regions.base.x);
+                    *rcol = resolved;
+                    linear += resolved;
+                }
+                TrackSizing::Fractional(v) => fr += v,
+            }
+        }
+
+        // Size that is not used by fixed-size columns.
+        let available = self.regions.first.x - linear;
+        if available >= Length::zero() {
+            // Determine size of auto columns.
+            let (auto, count) = self.measure_auto_columns(ctx, available)?;
+
+            // If there is remaining space, distribute it to fractional columns,
+            // otherwise shrink auto columns.
+            let remaining = available - auto;
+            if remaining >= Length::zero() {
+                if !fr.is_zero() {
+                    self.grow_fractional_columns(remaining, fr);
+                }
+            } else {
+                self.shrink_auto_columns(available, count);
+            }
+        }
+
+        // Sum up the resolved column sizes once here.
+        self.used.x = self.rcols.iter().sum();
+
+        Ok(())
+    }
+
+    /// Measure the size that is available to auto columns.
+    fn measure_auto_columns(
+        &mut self,
+        ctx: &mut Context,
+        available: Length,
+    ) -> TypResult<(Length, usize)> {
+        let mut auto = Length::zero();
+        let mut count = 0;
+
+        // Determine size of auto columns by laying out all cells in those
+        // columns, measuring them and finding the largest one.
+        for (x, &col) in self.cols.iter().enumerate() {
+            if col != TrackSizing::Auto {
+                continue;
+            }
+
+            let mut resolved = Length::zero();
+            for y in 0 .. self.rows.len() {
+                if let Some(node) = self.cell(x, y) {
+                    let size = Size::new(available, self.regions.base.y);
+                    let mut pod =
+                        Regions::one(size, self.regions.base, Spec::splat(false));
+
+                    // For linear rows, we can already resolve the correct
+                    // base, for auto it's already correct and for fr we could
+                    // only guess anyway.
+                    if let TrackSizing::Linear(v) = self.rows[y] {
+                        pod.base.y = v.resolve(self.regions.base.y);
+                    }
+
+                    let frame = node.layout(ctx, &pod, self.styles)?.remove(0);
+                    resolved.set_max(frame.size.x);
+                }
+            }
+
+            self.rcols[x] = resolved;
+            auto += resolved;
+            count += 1;
+        }
+
+        Ok((auto, count))
+    }
+
+    /// Distribute remaining space to fractional columns.
+    fn grow_fractional_columns(&mut self, remaining: Length, fr: Fractional) {
+        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
+            if let TrackSizing::Fractional(v) = col {
+                *rcol = v.resolve(fr, remaining);
+            }
+        }
+    }
+
+    /// Redistribute space to auto columns so that each gets a fair share.
+    fn shrink_auto_columns(&mut self, available: Length, count: usize) {
+        // The fair share each auto column may have.
+        let fair = available / count as f64;
+
+        // The number of overlarge auto columns and the space that will be
+        // equally redistributed to them.
+        let mut overlarge: usize = 0;
+        let mut redistribute = available;
+
+        // Find out the number of and space used by overlarge auto columns.
+        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
+            if col == TrackSizing::Auto {
+                if *rcol > fair {
+                    overlarge += 1;
+                } else {
+                    redistribute -= *rcol;
+                }
+            }
+        }
+
+        // Redistribute the space equally.
+        let share = redistribute / overlarge as f64;
+        for (&col, rcol) in self.cols.iter().zip(&mut self.rcols) {
+            if col == TrackSizing::Auto && *rcol > fair {
+                *rcol = share;
+            }
+        }
+    }
+
+    /// Layout a row with automatic height. Such a row may break across multiple
+    /// regions.
+    fn layout_auto_row(&mut self, ctx: &mut Context, y: usize) -> TypResult<()> {
+        let mut resolved: Vec<Length> = vec![];
+
+        // Determine the size for each region of the row.
+        for (x, &rcol) in self.rcols.iter().enumerate() {
+            if let Some(node) = self.cell(x, y) {
+                let mut pod = self.regions.clone();
+                pod.first.x = rcol;
+
+                // All widths should be `rcol` except the base for auto columns.
+                if self.cols[x] == TrackSizing::Auto {
+                    pod.base.x = self.regions.base.x;
+                }
+
+                let mut sizes = node
+                    .layout(ctx, &pod, self.styles)?
+                    .into_iter()
+                    .map(|frame| frame.size.y);
+
+                // For each region, we want to know the maximum height any
+                // column requires.
+                for (target, size) in resolved.iter_mut().zip(&mut sizes) {
+                    target.set_max(size);
+                }
+
+                // New heights are maximal by virtue of being new. Note that
+                // this extend only uses the rest of the sizes iterator.
+                resolved.extend(sizes);
+            }
+        }
+
+        // Nothing to layout.
+        if resolved.is_empty() {
+            return Ok(());
+        }
+
+        // Layout into a single region.
+        if let &[first] = resolved.as_slice() {
+            let frame = self.layout_single_row(ctx, first, y)?;
+            self.push_row(frame);
+            return Ok(());
+        }
+
+        // Expand all but the last region if the space is not
+        // eaten up by any fr rows.
+        if self.fr.is_zero() {
+            let len = resolved.len();
+            for (region, target) in self.regions.iter().zip(&mut resolved[.. len - 1]) {
+                target.set_max(region.y);
+            }
+        }
+
+        // Layout into multiple regions.
+        let frames = self.layout_multi_row(ctx, &resolved, y)?;
+        let len = frames.len();
+        for (i, frame) in frames.into_iter().enumerate() {
+            self.push_row(frame);
+            if i + 1 < len {
+                self.finish_region(ctx)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Layout a row with linear height. Such a row cannot break across multiple
+    /// regions, but it may force a region break.
+    fn layout_linear_row(
+        &mut self,
+        ctx: &mut Context,
+        v: Linear,
+        y: usize,
+    ) -> TypResult<()> {
+        let resolved = v.resolve(self.regions.base.y);
+        let frame = self.layout_single_row(ctx, resolved, y)?;
+
+        // Skip to fitting region.
+        let height = frame.size.y;
+        while !self.regions.first.y.fits(height) && !self.regions.in_last() {
+            self.finish_region(ctx)?;
+
+            // Don't skip multiple regions for gutter and don't push a row.
+            if y % 2 == 1 {
+                return Ok(());
+            }
+        }
+
+        self.push_row(frame);
+
+        Ok(())
+    }
+
+    /// Layout a row with fixed height and return its frame.
+    fn layout_single_row(
+        &self,
+        ctx: &mut Context,
+        height: Length,
+        y: usize,
+    ) -> TypResult<Frame> {
+        let mut output = Frame::new(Size::new(self.used.x, height));
+        let mut pos = Point::zero();
+
+        for (x, &rcol) in self.rcols.iter().enumerate() {
+            if let Some(node) = self.cell(x, y) {
+                let size = Size::new(rcol, height);
+
+                // Set the base to the region's base for auto rows and to the
+                // size for linear and fractional rows.
+                let base = Spec::new(self.cols[x], self.rows[y])
+                    .map(|s| s == TrackSizing::Auto)
+                    .select(self.regions.base, size);
+
+                let pod = Regions::one(size, base, Spec::splat(true));
+                let frame = node.layout(ctx, &pod, self.styles)?.remove(0);
+                output.push_frame(pos, frame);
+            }
+
+            pos.x += rcol;
+        }
+
+        Ok(output)
+    }
+
+    /// Layout a row spanning multiple regions.
+    fn layout_multi_row(
+        &self,
+        ctx: &mut Context,
+        heights: &[Length],
+        y: usize,
+    ) -> TypResult<Vec<Frame>> {
+        // Prepare frames.
+        let mut outputs: Vec<_> = heights
+            .iter()
+            .map(|&h| Frame::new(Size::new(self.used.x, h)))
+            .collect();
+
+        // Prepare regions.
+        let size = Size::new(self.used.x, heights[0]);
+        let mut pod = Regions::one(size, self.regions.base, Spec::splat(true));
+        pod.backlog = heights[1 ..].to_vec();
+
+        // Layout the row.
+        let mut pos = Point::zero();
+        for (x, &rcol) in self.rcols.iter().enumerate() {
+            if let Some(node) = self.cell(x, y) {
+                pod.first.x = rcol;
+
+                // All widths should be `rcol` except the base for auto columns.
+                if self.cols[x] == TrackSizing::Auto {
+                    pod.base.x = self.regions.base.x;
+                }
+
+                // Push the layouted frames into the individual output frames.
+                let frames = node.layout(ctx, &pod, self.styles)?;
+                for (output, frame) in outputs.iter_mut().zip(frames) {
+                    output.push_frame(pos, frame);
+                }
+            }
+
+            pos.x += rcol;
+        }
+
+        Ok(outputs)
+    }
+
+    /// Push a row frame into the current region.
+    fn push_row(&mut self, frame: Frame) {
+        self.regions.first.y -= frame.size.y;
+        self.used.y += frame.size.y;
+        self.lrows.push(Row::Frame(frame));
+    }
+
+    /// Finish rows for one region.
+    fn finish_region(&mut self, ctx: &mut Context) -> TypResult<()> {
+        // Determine the size of the grid in this region, expanding fully if
+        // there are fr rows.
+        let mut size = self.used;
+        if self.fr.get() > 0.0 && self.full.is_finite() {
+            size.y = self.full;
+        }
+
+        // The frame for the region.
+        let mut output = Frame::new(size);
+        let mut pos = Point::zero();
+
+        // Place finished rows and layout fractional rows.
+        for row in std::mem::take(&mut self.lrows) {
+            let frame = match row {
+                Row::Frame(frame) => frame,
+                Row::Fr(v, y) => {
+                    let remaining = self.full - self.used.y;
+                    let height = v.resolve(self.fr, remaining);
+                    self.layout_single_row(ctx, height, y)?
+                }
+            };
+
+            let height = frame.size.y;
+            output.merge_frame(pos, frame);
+            pos.y += height;
+        }
+
+        self.finished.push(Arc::new(output));
+        self.regions.next();
+        self.full = self.regions.first.y;
+        self.used.y = Length::zero();
+        self.fr = Fractional::zero();
+
+        Ok(())
+    }
+
+    /// Get the node in the cell in column `x` and row `y`.
+    ///
+    /// Returns `None` if it's a gutter cell.
+    #[track_caller]
+    fn cell(&self, x: usize, y: usize) -> Option<&'a LayoutNode> {
+        assert!(x < self.cols.len());
+        assert!(y < self.rows.len());
+
+        // Even columns and rows are children, odd ones are gutter.
+        if x % 2 == 0 && y % 2 == 0 {
+            let c = 1 + self.cols.len() / 2;
+            self.cells.get((y / 2) * c + x / 2)
+        } else {
+            None
+        }
+    }
+}
diff --git a/src/library/layout/hide.rs b/src/library/layout/hide.rs
new file mode 100644
index 00000000..861a1208
--- /dev/null
+++ b/src/library/layout/hide.rs
@@ -0,0 +1,30 @@
+use crate::library::prelude::*;
+
+/// Hide a node without affecting layout.
+#[derive(Debug, Hash)]
+pub struct HideNode(pub LayoutNode);
+
+#[class]
+impl HideNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::inline(Self(args.expect("body")?)))
+    }
+}
+
+impl Layout for HideNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let mut frames = self.0.layout(ctx, regions, styles)?;
+
+        // Clear the frames.
+        for frame in &mut frames {
+            *frame = Arc::new(Frame { elements: vec![], ..**frame });
+        }
+
+        Ok(frames)
+    }
+}
diff --git a/src/library/layout/mod.rs b/src/library/layout/mod.rs
new file mode 100644
index 00000000..944548ab
--- /dev/null
+++ b/src/library/layout/mod.rs
@@ -0,0 +1,27 @@
+//! Composable layouts.
+
+mod align;
+mod columns;
+mod container;
+mod flow;
+mod grid;
+mod hide;
+mod pad;
+mod page;
+mod place;
+mod spacing;
+mod stack;
+mod transform;
+
+pub use align::*;
+pub use columns::*;
+pub use container::*;
+pub use flow::*;
+pub use grid::*;
+pub use hide::*;
+pub use pad::*;
+pub use page::*;
+pub use place::*;
+pub use spacing::*;
+pub use stack::*;
+pub use transform::*;
diff --git a/src/library/layout/pad.rs b/src/library/layout/pad.rs
new file mode 100644
index 00000000..175a54f0
--- /dev/null
+++ b/src/library/layout/pad.rs
@@ -0,0 +1,83 @@
+use crate::library::prelude::*;
+
+/// Pad a node at the sides.
+#[derive(Debug, Hash)]
+pub struct PadNode {
+    /// The amount of padding.
+    pub padding: Sides<Linear>,
+    /// The child node whose sides to pad.
+    pub child: LayoutNode,
+}
+
+#[class]
+impl PadNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let all = args.find()?;
+        let hor = args.named("horizontal")?;
+        let ver = args.named("vertical")?;
+        let left = args.named("left")?.or(hor).or(all).unwrap_or_default();
+        let top = args.named("top")?.or(ver).or(all).unwrap_or_default();
+        let right = args.named("right")?.or(hor).or(all).unwrap_or_default();
+        let bottom = args.named("bottom")?.or(ver).or(all).unwrap_or_default();
+        let body: LayoutNode = args.expect("body")?;
+        let padding = Sides::new(left, top, right, bottom);
+        Ok(Template::block(body.padded(padding)))
+    }
+}
+
+impl Layout for PadNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        // Layout child into padded regions.
+        let pod = regions.map(|size| shrink(size, self.padding));
+        let mut frames = self.child.layout(ctx, &pod, styles)?;
+
+        for frame in &mut frames {
+            // Apply the padding inversely such that the grown size padded
+            // yields the frame's size.
+            let padded = grow(frame.size, self.padding);
+            let padding = self.padding.resolve(padded);
+            let offset = Point::new(padding.left, padding.top);
+
+            // Grow the frame and translate everything in the frame inwards.
+            let frame = Arc::make_mut(frame);
+            frame.size = padded;
+            frame.translate(offset);
+        }
+
+        Ok(frames)
+    }
+}
+
+/// Shrink a size by padding relative to the size itself.
+fn shrink(size: Size, padding: Sides<Linear>) -> Size {
+    size - padding.resolve(size).sum_by_axis()
+}
+
+/// Grow a size by padding relative to the grown size.
+/// This is the inverse operation to `shrink()`.
+///
+/// For the horizontal axis the derivation looks as follows.
+/// (Vertical axis is analogous.)
+///
+/// Let w be the grown target width,
+///     s be given width,
+///     l be the left padding,
+///     r be the right padding,
+///     p = l + r.
+///
+/// We want that: w - l.resolve(w) - r.resolve(w) = s
+///
+/// Thus: w - l.resolve(w) - r.resolve(w) = s
+///   <=> w - p.resolve(w) = s
+///   <=> w - p.rel * w - p.abs = s
+///   <=> (1 - p.rel) * w = s + p.abs
+///   <=> w = (s + p.abs) / (1 - p.rel)
+fn grow(size: Size, padding: Sides<Linear>) -> Size {
+    size.zip(padding.sum_by_axis())
+        .map(|(s, p)| (s + p.abs).safe_div(1.0 - p.rel.get()))
+}
diff --git a/src/library/layout/page.rs b/src/library/layout/page.rs
new file mode 100644
index 00000000..f5d766a5
--- /dev/null
+++ b/src/library/layout/page.rs
@@ -0,0 +1,419 @@
+use std::fmt::{self, Display, Formatter};
+use std::str::FromStr;
+
+use super::ColumnsNode;
+use crate::library::prelude::*;
+
+/// Layouts its child onto one or multiple pages.
+#[derive(Clone, PartialEq, Hash)]
+pub struct PageNode(pub LayoutNode);
+
+#[class]
+impl PageNode {
+    /// The unflipped width of the page.
+    pub const WIDTH: Smart<Length> = Smart::Custom(Paper::A4.width());
+    /// The unflipped height of the page.
+    pub const HEIGHT: Smart<Length> = Smart::Custom(Paper::A4.height());
+    /// Whether the page is flipped into landscape orientation.
+    pub const FLIPPED: bool = false;
+    /// The left margin.
+    pub const LEFT: Smart<Linear> = Smart::Auto;
+    /// The right margin.
+    pub const RIGHT: Smart<Linear> = Smart::Auto;
+    /// The top margin.
+    pub const TOP: Smart<Linear> = Smart::Auto;
+    /// The bottom margin.
+    pub const BOTTOM: Smart<Linear> = Smart::Auto;
+    /// The page's background color.
+    pub const FILL: Option<Paint> = None;
+    /// How many columns the page has.
+    pub const COLUMNS: NonZeroUsize = NonZeroUsize::new(1).unwrap();
+    /// The page's header.
+    pub const HEADER: Marginal = Marginal::None;
+    /// The page's footer.
+    pub const FOOTER: Marginal = Marginal::None;
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::Page(Self(args.expect("body")?)))
+    }
+
+    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
+        if let Some(paper) = args.named_or_find::<Paper>("paper")? {
+            styles.set(Self::WIDTH, Smart::Custom(paper.width()));
+            styles.set(Self::HEIGHT, Smart::Custom(paper.height()));
+        }
+
+        styles.set_opt(Self::WIDTH, args.named("width")?);
+        styles.set_opt(Self::HEIGHT, args.named("height")?);
+
+        let all = args.named("margins")?;
+        let hor = args.named("horizontal")?;
+        let ver = args.named("vertical")?;
+        styles.set_opt(Self::LEFT, args.named("left")?.or(hor).or(all));
+        styles.set_opt(Self::TOP, args.named("top")?.or(ver).or(all));
+        styles.set_opt(Self::RIGHT, args.named("right")?.or(hor).or(all));
+        styles.set_opt(Self::BOTTOM, args.named("bottom")?.or(ver).or(all));
+
+        styles.set_opt(Self::FLIPPED, args.named("flipped")?);
+        styles.set_opt(Self::FILL, args.named("fill")?);
+        styles.set_opt(Self::COLUMNS, args.named("columns")?);
+        styles.set_opt(Self::HEADER, args.named("header")?);
+        styles.set_opt(Self::FOOTER, args.named("footer")?);
+
+        Ok(())
+    }
+}
+
+impl PageNode {
+    /// Layout the page run into a sequence of frames, one per page.
+    pub fn layout(
+        &self,
+        ctx: &mut Context,
+        mut page: usize,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        // When one of the lengths is infinite the page fits its content along
+        // that axis.
+        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);
+        }
+
+        let mut min = width.min(height);
+        if min.is_infinite() {
+            min = Paper::A4.width();
+        }
+
+        // Determine the margins.
+        let default = Linear::from(0.1190 * min);
+        let padding = Sides {
+            left: styles.get(Self::LEFT).unwrap_or(default),
+            right: styles.get(Self::RIGHT).unwrap_or(default),
+            top: styles.get(Self::TOP).unwrap_or(default),
+            bottom: styles.get(Self::BOTTOM).unwrap_or(default),
+        };
+
+        let mut child = self.0.clone();
+
+        // Realize columns with columns node.
+        let columns = styles.get(Self::COLUMNS);
+        if columns.get() > 1 {
+            child = ColumnsNode { columns, child: self.0.clone() }.pack();
+        }
+
+        // Realize margins.
+        child = child.padded(padding);
+
+        // Realize background fill.
+        if let Some(fill) = styles.get(Self::FILL) {
+            child = child.filled(fill);
+        }
+
+        // Layout the child.
+        let regions = Regions::repeat(size, size, size.map(Length::is_finite));
+        let mut frames = child.layout(ctx, &regions, styles)?;
+
+        let header = styles.get_ref(Self::HEADER);
+        let footer = styles.get_ref(Self::FOOTER);
+
+        // Realize header and footer.
+        for frame in &mut frames {
+            let size = frame.size;
+            let padding = padding.resolve(size);
+            for (y, h, marginal) in [
+                (Length::zero(), padding.top, header),
+                (size.y - padding.bottom, padding.bottom, footer),
+            ] {
+                if let Some(template) = marginal.resolve(ctx, page)? {
+                    let pos = Point::new(padding.left, y);
+                    let w = size.x - padding.left - padding.right;
+                    let area = Size::new(w, h);
+                    let pod = Regions::one(area, area, area.map(Length::is_finite));
+                    let sub = Layout::layout(&template, ctx, &pod, styles)?.remove(0);
+                    Arc::make_mut(frame).push_frame(pos, sub);
+                }
+            }
+
+            page += 1;
+        }
+
+        Ok(frames)
+    }
+}
+
+impl Debug for PageNode {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("Page(")?;
+        self.0.fmt(f)?;
+        f.write_str(")")
+    }
+}
+
+/// A page break.
+pub struct PagebreakNode;
+
+#[class]
+impl PagebreakNode {
+    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
+        Ok(Template::Pagebreak)
+    }
+}
+
+/// A header or footer definition.
+#[derive(Debug, Clone, PartialEq, Hash)]
+pub enum Marginal {
+    /// Nothing,
+    None,
+    /// A bare template.
+    Template(Template),
+    /// A closure mapping from a page number to a template.
+    Func(Func, Span),
+}
+
+impl Marginal {
+    /// Resolve the marginal based on the page number.
+    pub fn resolve(&self, ctx: &mut Context, page: usize) -> TypResult<Option<Template>> {
+        Ok(match self {
+            Self::None => None,
+            Self::Template(template) => Some(template.clone()),
+            Self::Func(func, span) => {
+                let args = Args::from_values(*span, [Value::Int(page as i64)]);
+                func.call(ctx, args)?.cast().at(*span)?
+            }
+        })
+    }
+}
+
+impl Cast<Spanned<Value>> for Marginal {
+    fn is(value: &Spanned<Value>) -> bool {
+        matches!(&value.v, Value::Template(_) | Value::Func(_))
+    }
+
+    fn cast(value: Spanned<Value>) -> StrResult<Self> {
+        match value.v {
+            Value::None => Ok(Self::None),
+            Value::Template(v) => Ok(Self::Template(v)),
+            Value::Func(v) => Ok(Self::Func(v, value.span)),
+            _ => Err("expected none, template or function")?,
+        }
+    }
+}
+
+/// Specification of a paper.
+#[derive(Debug, Copy, Clone)]
+pub struct Paper {
+    /// The width of the paper in millimeters.
+    width: f64,
+    /// The height of the paper in millimeters.
+    height: f64,
+}
+
+impl Paper {
+    /// 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)
+    }
+}
+
+/// Defines paper constants and a paper parsing implementation.
+macro_rules! papers {
+    ($(($var: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 { width: $width, height: $height };)*
+        }
+
+        impl FromStr for Paper {
+            type Err = PaperError;
+
+            fn from_str(name: &str) -> Result<Self, Self::Err> {
+                match name.to_lowercase().as_str() {
+                    $($($pats)* => Ok(Self::$var),)*
+                    _ => Err(PaperError),
+                }
+            }
+        }
+    };
+}
+
+// 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:  841.0, 1189.0, "a0")
+    (A1:  594.0,  841.0, "a1")
+    (A2:  420.0,  594.0, "a2")
+    (A3:  297.0,  420.0, "a3")
+    (A4:  210.0,  297.0, "a4")
+    (A5:  148.0,  210.0, "a5")
+    (A6:  105.0,  148.0, "a6")
+    (A7:   74.0,  105.0, "a7")
+    (A8:   52.0,   74.0, "a8")
+    (A9:   37.0,   52.0, "a9")
+    (A10:  26.0,   37.0, "a10")
+    (A11:  18.0,   26.0, "a11")
+
+    // ISO 216 B Series
+    (ISO_B1: 707.0, 1000.0, "iso-b1")
+    (ISO_B2: 500.0,  707.0,  "iso-b2")
+    (ISO_B3: 353.0,  500.0,  "iso-b3")
+    (ISO_B4: 250.0,  353.0,  "iso-b4")
+    (ISO_B5: 176.0,  250.0,  "iso-b5")
+    (ISO_B6: 125.0,  176.0,  "iso-b6")
+    (ISO_B7:  88.0,  125.0,  "iso-b7")
+    (ISO_B8:  62.0,   88.0,  "iso-b8")
+
+    // ISO 216 C Series
+    (ISO_C3: 324.0, 458.0, "iso-c3")
+    (ISO_C4: 229.0, 324.0, "iso-c4")
+    (ISO_C5: 162.0, 229.0, "iso-c5")
+    (ISO_C6: 114.0, 162.0, "iso-c6")
+    (ISO_C7:  81.0, 114.0, "iso-c7")
+    (ISO_C8:  57.0,  81.0, "iso-c8")
+
+    // DIN D Series (extension to ISO)
+    (DIN_D3: 272.0, 385.0, "din-d3")
+    (DIN_D4: 192.0, 272.0, "din-d4")
+    (DIN_D5: 136.0, 192.0, "din-d5")
+    (DIN_D6:  96.0, 136.0, "din-d6")
+    (DIN_D7:  68.0,  96.0, "din-d7")
+    (DIN_D8:  48.0,  68.0, "din-d8")
+
+    // SIS (used in academia)
+    (SIS_G5: 169.0, 239.0, "sis-g5")
+    (SIS_E5: 115.0, 220.0, "sis-e5")
+
+    // ANSI Extensions
+    (ANSI_A: 216.0,  279.0, "ansi-a")
+    (ANSI_B: 279.0,  432.0, "ansi-b")
+    (ANSI_C: 432.0,  559.0, "ansi-c")
+    (ANSI_D: 559.0,  864.0, "ansi-d")
+    (ANSI_E: 864.0, 1118.0, "ansi-e")
+
+    // ANSI Architectural Paper
+    (ARCH_A:  229.0,  305.0, "arch-a")
+    (ARCH_B:  305.0,  457.0, "arch-b")
+    (ARCH_C:  457.0,  610.0, "arch-c")
+    (ARCH_D:  610.0,  914.0, "arch-d")
+    (ARCH_E1: 762.0, 1067.0, "arch-e1")
+    (ARCH_E:  914.0, 1219.0, "arch-e")
+
+    // JIS B Series
+    (JIS_B0:  1030.0, 1456.0, "jis-b0")
+    (JIS_B1:   728.0, 1030.0, "jis-b1")
+    (JIS_B2:   515.0,  728.0, "jis-b2")
+    (JIS_B3:   364.0,  515.0, "jis-b3")
+    (JIS_B4:   257.0,  364.0, "jis-b4")
+    (JIS_B5:   182.0,  257.0, "jis-b5")
+    (JIS_B6:   128.0,  182.0, "jis-b6")
+    (JIS_B7:    91.0,  128.0, "jis-b7")
+    (JIS_B8:    64.0,   91.0, "jis-b8")
+    (JIS_B9:    45.0,   64.0, "jis-b9")
+    (JIS_B10:   32.0,   45.0, "jis-b10")
+    (JIS_B11:   22.0,   32.0, "jis-b11")
+
+    // SAC D Series
+    (SAC_D0: 764.0, 1064.0, "sac-d0")
+    (SAC_D1: 532.0,  760.0, "sac-d1")
+    (SAC_D2: 380.0,  528.0, "sac-d2")
+    (SAC_D3: 264.0,  376.0, "sac-d3")
+    (SAC_D4: 188.0,  260.0, "sac-d4")
+    (SAC_D5: 130.0,  184.0, "sac-d5")
+    (SAC_D6:  92.0,  126.0, "sac-d6")
+
+    // ISO 7810 ID
+    (ISO_ID_1: 85.6, 53.98, "iso-id-1")
+    (ISO_ID_2: 74.0, 105.0, "iso-id-2")
+    (ISO_ID_3: 88.0, 125.0, "iso-id-3")
+
+    // ---------------------------------------------------------------------- //
+    // Asia
+    (ASIA_F4: 210.0, 330.0, "asia-f4")
+
+    // Japan
+    (JP_SHIROKU_BAN_4: 264.0, 379.0, "jp-shiroku-ban-4")
+    (JP_SHIROKU_BAN_5: 189.0, 262.0, "jp-shiroku-ban-5")
+    (JP_SHIROKU_BAN_6: 127.0, 188.0, "jp-shiroku-ban-6")
+    (JP_KIKU_4:        227.0, 306.0, "jp-kiku-4")
+    (JP_KIKU_5:        151.0, 227.0, "jp-kiku-5")
+    (JP_BUSINESS_CARD:  91.0,  55.0, "jp-business-card")
+
+    // China
+    (CN_BUSINESS_CARD: 90.0, 54.0, "cn-business-card")
+
+    // Europe
+    (EU_BUSINESS_CARD: 85.0, 55.0, "eu-business-card")
+
+    // French Traditional (AFNOR)
+    (FR_TELLIERE:          340.0, 440.0, "fr-tellière")
+    (FR_COURONNE_ECRITURE: 360.0, 460.0, "fr-couronne-écriture")
+    (FR_COURONNE_EDITION:  370.0, 470.0, "fr-couronne-édition")
+    (FR_RAISIN:            500.0, 650.0, "fr-raisin")
+    (FR_CARRE:             450.0, 560.0, "fr-carré")
+    (FR_JESUS:             560.0, 760.0, "fr-jésus")
+
+    // United Kingdom Imperial
+    (UK_BRIEF:    406.4, 342.9, "uk-brief")
+    (UK_DRAFT:    254.0, 406.4, "uk-draft")
+    (UK_FOOLSCAP: 203.2, 330.2, "uk-foolscap")
+    (UK_QUARTO:   203.2, 254.0, "uk-quarto")
+    (UK_CROWN:    508.0, 381.0, "uk-crown")
+    (UK_BOOK_A:   111.0, 178.0, "uk-book-a")
+    (UK_BOOK_B:   129.0, 198.0, "uk-book-b")
+
+    // Unites States
+    (US_LETTER:         215.9,  279.4, "us-letter")
+    (US_LEGAL:          215.9,  355.6, "us-legal")
+    (US_TABLOID:        279.4,  431.8, "us-tabloid")
+    (US_EXECUTIVE:      84.15,  266.7, "us-executive")
+    (US_FOOLSCAP_FOLIO: 215.9,  342.9, "us-foolscap-folio")
+    (US_STATEMENT:      139.7,  215.9, "us-statement")
+    (US_LEDGER:         431.8,  279.4, "us-ledger")
+    (US_OFICIO:         215.9, 340.36, "us-oficio")
+    (US_GOV_LETTER:     203.2,  266.7, "us-gov-letter")
+    (US_GOV_LEGAL:      215.9,  330.2, "us-gov-legal")
+    (US_BUSINESS_CARD:   88.9,   50.8, "us-business-card")
+    (US_DIGEST:         139.7,  215.9, "us-digest")
+    (US_TRADE:          152.4,  228.6, "us-trade")
+
+    // ---------------------------------------------------------------------- //
+    // Other
+    (NEWSPAPER_COMPACT:    280.0,    430.0,    "newspaper-compact")
+    (NEWSPAPER_BERLINER:   315.0,    470.0,    "newspaper-berliner")
+    (NEWSPAPER_BROADSHEET: 381.0,    578.0,    "newspaper-broadsheet")
+    (PRESENTATION_16_9:    297.0, 167.0625, "presentation-16-9")
+    (PRESENTATION_4_3:     280.0,    210.0,    "presentation-4-3")
+}
+
+castable! {
+    Paper,
+    Expected: "string",
+    Value::Str(string) => Paper::from_str(&string).map_err(|e| e.to_string())?,
+}
+
+/// The error when parsing a [`Paper`] from a string fails.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct PaperError;
+
+impl Display for PaperError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.pad("invalid paper name")
+    }
+}
+
+impl std::error::Error for PaperError {}
diff --git a/src/library/layout/place.rs b/src/library/layout/place.rs
new file mode 100644
index 00000000..d65b3836
--- /dev/null
+++ b/src/library/layout/place.rs
@@ -0,0 +1,59 @@
+use super::AlignNode;
+use crate::library::prelude::*;
+
+/// Place a node at an absolute position.
+#[derive(Debug, Hash)]
+pub struct PlaceNode(pub LayoutNode);
+
+#[class]
+impl PlaceNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let aligns = args.find()?.unwrap_or(Spec::with_x(Some(Align::Left)));
+        let tx = args.named("dx")?.unwrap_or_default();
+        let ty = args.named("dy")?.unwrap_or_default();
+        let body: LayoutNode = args.expect("body")?;
+        Ok(Template::block(Self(
+            body.moved(Point::new(tx, ty)).aligned(aligns),
+        )))
+    }
+}
+
+impl Layout for PlaceNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let out_of_flow = self.out_of_flow();
+
+        // The pod is the base area of the region because for absolute
+        // placement we don't really care about the already used area.
+        let pod = {
+            let finite = regions.base.map(Length::is_finite);
+            let expand = finite & (regions.expand | out_of_flow);
+            Regions::one(regions.base, regions.base, expand)
+        };
+
+        let mut frames = self.0.layout(ctx, &pod, styles)?;
+
+        // If expansion is off, zero all sizes so that we don't take up any
+        // space in our parent. Otherwise, respect the expand settings.
+        let frame = &mut frames[0];
+        let target = regions.expand.select(regions.first, Size::zero());
+        Arc::make_mut(frame).resize(target, Align::LEFT_TOP);
+
+        Ok(frames)
+    }
+}
+
+impl PlaceNode {
+    /// 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.0
+            .downcast::<AlignNode>()
+            .map_or(false, |node| node.aligns.y.is_some())
+    }
+}
diff --git a/src/library/layout/spacing.rs b/src/library/layout/spacing.rs
new file mode 100644
index 00000000..3bebfb14
--- /dev/null
+++ b/src/library/layout/spacing.rs
@@ -0,0 +1,52 @@
+use crate::library::prelude::*;
+
+/// Horizontal spacing.
+pub struct HNode;
+
+#[class]
+impl HNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::Horizontal(args.expect("spacing")?))
+    }
+}
+
+/// Vertical spacing.
+pub struct VNode;
+
+#[class]
+impl VNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::Vertical(args.expect("spacing")?))
+    }
+}
+
+/// Kinds of spacing.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum SpacingKind {
+    /// A length stated in absolute values and/or relative to the parent's size.
+    Linear(Linear),
+    /// A length that is the fraction of the remaining free space in the parent.
+    Fractional(Fractional),
+}
+
+impl SpacingKind {
+    /// Whether this is fractional spacing.
+    pub fn is_fractional(self) -> bool {
+        matches!(self, Self::Fractional(_))
+    }
+}
+
+impl From<Length> for SpacingKind {
+    fn from(length: Length) -> Self {
+        Self::Linear(length.into())
+    }
+}
+
+castable! {
+    SpacingKind,
+    Expected: "linear or fractional",
+    Value::Length(v) => Self::Linear(v.into()),
+    Value::Relative(v) => Self::Linear(v.into()),
+    Value::Linear(v) => Self::Linear(v),
+    Value::Fractional(v) => Self::Fractional(v),
+}
diff --git a/src/library/layout/stack.rs b/src/library/layout/stack.rs
new file mode 100644
index 00000000..414490ef
--- /dev/null
+++ b/src/library/layout/stack.rs
@@ -0,0 +1,259 @@
+use super::{AlignNode, SpacingKind};
+use crate::library::prelude::*;
+
+/// Arrange nodes and spacing along an axis.
+#[derive(Debug, Hash)]
+pub struct StackNode {
+    /// The stacking direction.
+    pub dir: Dir,
+    /// The spacing between non-spacing children.
+    pub spacing: Option<SpacingKind>,
+    /// The children to be stacked.
+    pub children: Vec<StackChild>,
+}
+
+#[class]
+impl StackNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::block(Self {
+            dir: args.named("dir")?.unwrap_or(Dir::TTB),
+            spacing: args.named("spacing")?,
+            children: args.all()?,
+        }))
+    }
+}
+
+impl Layout for StackNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let mut layouter = StackLayouter::new(self.dir, regions);
+
+        // Spacing to insert before the next node.
+        let mut deferred = None;
+
+        for child in &self.children {
+            match child {
+                StackChild::Spacing(kind) => {
+                    layouter.layout_spacing(*kind);
+                    deferred = None;
+                }
+                StackChild::Node(node) => {
+                    if let Some(kind) = deferred {
+                        layouter.layout_spacing(kind);
+                    }
+
+                    layouter.layout_node(ctx, node, styles)?;
+                    deferred = self.spacing;
+                }
+            }
+        }
+
+        Ok(layouter.finish())
+    }
+}
+
+/// A child of a stack node.
+#[derive(Hash)]
+pub enum StackChild {
+    /// Spacing between other nodes.
+    Spacing(SpacingKind),
+    /// An arbitrary node.
+    Node(LayoutNode),
+}
+
+impl Debug for StackChild {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Spacing(kind) => kind.fmt(f),
+            Self::Node(node) => node.fmt(f),
+        }
+    }
+}
+
+castable! {
+    StackChild,
+    Expected: "linear, fractional or template",
+    Value::Length(v) => Self::Spacing(SpacingKind::Linear(v.into())),
+    Value::Relative(v) => Self::Spacing(SpacingKind::Linear(v.into())),
+    Value::Linear(v) => Self::Spacing(SpacingKind::Linear(v)),
+    Value::Fractional(v) => Self::Spacing(SpacingKind::Fractional(v)),
+    Value::Template(v) => Self::Node(v.pack()),
+}
+
+/// Performs stack layout.
+pub struct StackLayouter {
+    /// The stacking direction.
+    dir: Dir,
+    /// The axis of the stacking direction.
+    axis: SpecAxis,
+    /// The regions to layout children into.
+    regions: Regions,
+    /// Whether the stack itself should expand to fill the region.
+    expand: Spec<bool>,
+    /// The full size of the current region that was available at the start.
+    full: Size,
+    /// The generic size used by the frames for the current region.
+    used: Gen<Length>,
+    /// The sum of fractional ratios in the current region.
+    fr: Fractional,
+    /// Already layouted items whose exact positions are not yet known due to
+    /// fractional spacing.
+    items: Vec<StackItem>,
+    /// Finished frames for previous regions.
+    finished: Vec<Arc<Frame>>,
+}
+
+/// A prepared item in a stack layout.
+enum StackItem {
+    /// Absolute spacing between other items.
+    Absolute(Length),
+    /// Fractional spacing between other items.
+    Fractional(Fractional),
+    /// A frame for a layouted child node.
+    Frame(Arc<Frame>, Align),
+}
+
+impl StackLayouter {
+    /// Create a new stack layouter.
+    pub fn new(dir: Dir, regions: &Regions) -> Self {
+        let axis = dir.axis();
+        let expand = regions.expand;
+        let full = regions.first;
+
+        // Disable expansion along the block axis for children.
+        let mut regions = regions.clone();
+        regions.expand.set(axis, false);
+
+        Self {
+            dir,
+            axis,
+            regions,
+            expand,
+            full,
+            used: Gen::zero(),
+            fr: Fractional::zero(),
+            items: vec![],
+            finished: vec![],
+        }
+    }
+
+    /// Add spacing along the spacing direction.
+    pub fn layout_spacing(&mut self, spacing: SpacingKind) {
+        match spacing {
+            SpacingKind::Linear(v) => {
+                // Resolve the linear and limit it to the remaining space.
+                let resolved = v.resolve(self.regions.base.get(self.axis));
+                let remaining = self.regions.first.get_mut(self.axis);
+                let limited = resolved.min(*remaining);
+                *remaining -= limited;
+                self.used.main += limited;
+                self.items.push(StackItem::Absolute(resolved));
+            }
+            SpacingKind::Fractional(v) => {
+                self.fr += v;
+                self.items.push(StackItem::Fractional(v));
+            }
+        }
+    }
+
+    /// Layout an arbitrary node.
+    pub fn layout_node(
+        &mut self,
+        ctx: &mut Context,
+        node: &LayoutNode,
+        styles: StyleChain,
+    ) -> TypResult<()> {
+        if self.regions.is_full() {
+            self.finish_region();
+        }
+
+        // Align nodes' block-axis alignment is respected by the stack node.
+        let align = node
+            .downcast::<AlignNode>()
+            .and_then(|node| node.aligns.get(self.axis))
+            .unwrap_or(self.dir.start().into());
+
+        let frames = node.layout(ctx, &self.regions, styles)?;
+        let len = frames.len();
+        for (i, frame) in frames.into_iter().enumerate() {
+            // Grow our size, shrink the region and save the frame for later.
+            let size = frame.size.to_gen(self.axis);
+            self.used.main += size.main;
+            self.used.cross.set_max(size.cross);
+            *self.regions.first.get_mut(self.axis) -= size.main;
+            self.items.push(StackItem::Frame(frame, align));
+
+            if i + 1 < len {
+                self.finish_region();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Advance to the next region.
+    pub fn finish_region(&mut self) {
+        // Determine the size of the stack in this region dependening on whether
+        // the region expands.
+        let used = self.used.to_spec(self.axis);
+        let mut size = self.expand.select(self.full, used);
+
+        // Expand fully if there are fr spacings.
+        let full = self.full.get(self.axis);
+        let remaining = full - self.used.main;
+        if self.fr.get() > 0.0 && full.is_finite() {
+            self.used.main = full;
+            size.set(self.axis, full);
+        }
+
+        let mut output = Frame::new(size);
+        let mut cursor = Length::zero();
+        let mut ruler: Align = self.dir.start().into();
+
+        // Place all frames.
+        for item in self.items.drain(..) {
+            match item {
+                StackItem::Absolute(v) => cursor += v,
+                StackItem::Fractional(v) => cursor += v.resolve(self.fr, remaining),
+                StackItem::Frame(frame, align) => {
+                    if self.dir.is_positive() {
+                        ruler = ruler.max(align);
+                    } else {
+                        ruler = ruler.min(align);
+                    }
+
+                    // Align along the block axis.
+                    let parent = size.get(self.axis);
+                    let child = frame.size.get(self.axis);
+                    let block = ruler.resolve(parent - self.used.main)
+                        + if self.dir.is_positive() {
+                            cursor
+                        } else {
+                            self.used.main - child - cursor
+                        };
+
+                    let pos = Gen::new(Length::zero(), block).to_point(self.axis);
+                    cursor += child;
+                    output.push_frame(pos, frame);
+                }
+            }
+        }
+
+        // Advance to the next region.
+        self.regions.next();
+        self.full = self.regions.first;
+        self.used = Gen::zero();
+        self.fr = Fractional::zero();
+        self.finished.push(Arc::new(output));
+    }
+
+    /// Finish layouting and return the resulting frames.
+    pub fn finish(mut self) -> Vec<Arc<Frame>> {
+        self.finish_region();
+        self.finished
+    }
+}
diff --git a/src/library/layout/transform.rs b/src/library/layout/transform.rs
new file mode 100644
index 00000000..fafb37a4
--- /dev/null
+++ b/src/library/layout/transform.rs
@@ -0,0 +1,86 @@
+use crate::geom::Transform;
+use crate::library::prelude::*;
+
+/// Transform a node without affecting layout.
+#[derive(Debug, Hash)]
+pub struct TransformNode<const T: TransformKind> {
+    /// Transformation to apply to the contents.
+    pub transform: Transform,
+    /// The node whose contents should be transformed.
+    pub child: LayoutNode,
+}
+
+/// Transform a node by translating it without affecting layout.
+pub type MoveNode = TransformNode<MOVE>;
+
+/// Transform a node by rotating it without affecting layout.
+pub type RotateNode = TransformNode<ROTATE>;
+
+/// Transform a node by scaling it without affecting layout.
+pub type ScaleNode = TransformNode<SCALE>;
+
+#[class]
+impl<const T: TransformKind> TransformNode<T> {
+    /// The origin of the transformation.
+    pub const ORIGIN: Spec<Option<Align>> = Spec::default();
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        let transform = match T {
+            MOVE => {
+                let tx = args.named("x")?.unwrap_or_default();
+                let ty = args.named("y")?.unwrap_or_default();
+                Transform::translation(tx, ty)
+            }
+            ROTATE => {
+                let angle = args.named_or_find("angle")?.unwrap_or_default();
+                Transform::rotation(angle)
+            }
+            SCALE | _ => {
+                let all = args.find()?;
+                let sx = args.named("x")?.or(all).unwrap_or(Relative::one());
+                let sy = args.named("y")?.or(all).unwrap_or(Relative::one());
+                Transform::scale(sx, sy)
+            }
+        };
+
+        Ok(Template::inline(Self {
+            transform,
+            child: args.expect("body")?,
+        }))
+    }
+}
+
+impl<const T: TransformKind> Layout for TransformNode<T> {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
+        let mut frames = self.child.layout(ctx, regions, styles)?;
+
+        for frame in &mut frames {
+            let Spec { x, y } = origin.zip(frame.size).map(|(o, s)| o.resolve(s));
+            let transform = Transform::translation(x, y)
+                .pre_concat(self.transform)
+                .pre_concat(Transform::translation(-x, -y));
+
+            Arc::make_mut(frame).transform(transform);
+        }
+
+        Ok(frames)
+    }
+}
+
+/// Kinds of transformations.
+pub type TransformKind = usize;
+
+/// A translation on the X and Y axes.
+const MOVE: TransformKind = 0;
+
+/// A rotational transformation.
+const ROTATE: TransformKind = 1;
+
+/// A scale transformation.
+const SCALE: TransformKind = 2;
diff --git a/src/library/link.rs b/src/library/link.rs
deleted file mode 100644
index 4a153d46..00000000
--- a/src/library/link.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! Hyperlinking.
-
-use super::prelude::*;
-use super::TextNode;
-use crate::util::EcoString;
-
-/// Link text and other elements to an URL.
-#[derive(Debug, Hash)]
-pub struct LinkNode {
-    /// The url the link points to.
-    pub url: EcoString,
-    /// How the link is represented.
-    pub body: Option<Template>,
-}
-
-#[class]
-impl LinkNode {
-    /// The fill color of text in the link. Just the surrounding text color
-    /// if `auto`.
-    pub const FILL: Smart<Paint> = Smart::Auto;
-    /// Whether to underline link.
-    pub const UNDERLINE: bool = true;
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self {
-            url: args.expect::<EcoString>("url")?,
-            body: args.find()?,
-        }))
-    }
-}
-
-impl Show for LinkNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        let mut body = styles
-            .show(self, ctx, [
-                Value::Str(self.url.clone()),
-                match &self.body {
-                    Some(body) => Value::Template(body.clone()),
-                    None => Value::None,
-                },
-            ])?
-            .or_else(|| self.body.clone())
-            .unwrap_or_else(|| {
-                let url = &self.url;
-                let mut text = url.as_str();
-                for prefix in ["mailto:", "tel:"] {
-                    text = text.trim_start_matches(prefix);
-                }
-                let shorter = text.len() < url.len();
-                Template::Text(if shorter { text.into() } else { url.clone() })
-            });
-
-        let mut map = StyleMap::new();
-        map.set(TextNode::LINK, Some(self.url.clone()));
-
-        if let Smart::Custom(fill) = styles.get(Self::FILL) {
-            map.set(TextNode::FILL, fill);
-        }
-
-        if styles.get(Self::UNDERLINE) {
-            body = body.underlined();
-        }
-
-        Ok(body.styled_with_map(map))
-    }
-}
diff --git a/src/library/list.rs b/src/library/list.rs
deleted file mode 100644
index baa8a0c9..00000000
--- a/src/library/list.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-//! Unordered (bulleted) and ordered (numbered) lists.
-
-use super::prelude::*;
-use super::{GridNode, Numbering, ParNode, TextNode, TrackSizing};
-
-use crate::parse::Scanner;
-
-/// An unordered or ordered list.
-#[derive(Debug, Hash)]
-pub struct ListNode<const L: ListKind> {
-    /// Where the list starts.
-    pub start: usize,
-    /// If true, there is paragraph spacing between the items, if false
-    /// there is list spacing between the items.
-    pub wide: bool,
-    /// The individual bulleted or numbered items.
-    pub items: Vec<ListItem>,
-}
-
-/// An item in a list.
-#[derive(Debug, Clone, PartialEq, Hash)]
-pub struct ListItem {
-    /// The number of the item.
-    pub number: Option<usize>,
-    /// The node that produces the item's body.
-    pub body: Box<Template>,
-}
-
-#[class]
-impl<const L: ListKind> ListNode<L> {
-    /// How the list is labelled.
-    pub const LABEL: Label = Label::Default;
-    /// The spacing between the list items of a non-wide list.
-    pub const SPACING: Linear = Linear::zero();
-    /// The indentation of each item's label.
-    pub const INDENT: Linear = Relative::new(0.0).into();
-    /// The space between the label and the body of each item.
-    pub const BODY_INDENT: Linear = Relative::new(0.5).into();
-    /// The extra padding above the list.
-    pub const ABOVE: Length = Length::zero();
-    /// The extra padding below the list.
-    pub const BELOW: Length = Length::zero();
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self {
-            start: args.named("start")?.unwrap_or(0),
-            wide: args.named("wide")?.unwrap_or(false),
-            items: args
-                .all()?
-                .into_iter()
-                .map(|body| ListItem { number: None, body: Box::new(body) })
-                .collect(),
-        }))
-    }
-}
-
-impl<const L: ListKind> Show for ListNode<L> {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        let template = if let Some(template) = styles.show(
-            self,
-            ctx,
-            self.items.iter().map(|item| Value::Template((*item.body).clone())),
-        )? {
-            template
-        } else {
-            let mut children = vec![];
-            let mut number = self.start;
-
-            let label = styles.get_ref(Self::LABEL);
-
-            for item in &self.items {
-                number = item.number.unwrap_or(number);
-                if L == UNORDERED {
-                    number = 1;
-                }
-
-                children.push(LayoutNode::default());
-                children.push(label.resolve(ctx, L, number)?.pack());
-                children.push(LayoutNode::default());
-                children.push((*item.body).clone().pack());
-                number += 1;
-            }
-
-            let em = styles.get(TextNode::SIZE).abs;
-            let leading = styles.get(ParNode::LEADING);
-            let spacing = if self.wide {
-                styles.get(ParNode::SPACING)
-            } else {
-                styles.get(Self::SPACING)
-            };
-
-            let gutter = (leading + spacing).resolve(em);
-            let indent = styles.get(Self::INDENT).resolve(em);
-            let body_indent = styles.get(Self::BODY_INDENT).resolve(em);
-
-            Template::block(GridNode {
-                tracks: Spec::with_x(vec![
-                    TrackSizing::Linear(indent.into()),
-                    TrackSizing::Auto,
-                    TrackSizing::Linear(body_indent.into()),
-                    TrackSizing::Auto,
-                ]),
-                gutter: Spec::with_y(vec![TrackSizing::Linear(gutter.into())]),
-                children,
-            })
-        };
-
-        let mut seq = vec![];
-        let above = styles.get(Self::ABOVE);
-        if !above.is_zero() {
-            seq.push(Template::Vertical(above.into()));
-        }
-
-        seq.push(template);
-
-        let below = styles.get(Self::BELOW);
-        if !below.is_zero() {
-            seq.push(Template::Vertical(below.into()));
-        }
-
-        Ok(Template::sequence(seq))
-    }
-}
-
-impl<const L: ListKind> From<ListItem> for ListNode<L> {
-    fn from(item: ListItem) -> Self {
-        Self { items: vec![item], wide: false, start: 1 }
-    }
-}
-
-/// How to label a list.
-pub type ListKind = usize;
-
-/// Unordered list labelling style.
-pub const UNORDERED: ListKind = 0;
-
-/// Ordered list labelling style.
-pub const ORDERED: ListKind = 1;
-
-/// Either a template or a closure mapping to a template.
-#[derive(Debug, Clone, PartialEq, Hash)]
-pub enum Label {
-    /// The default labelling.
-    Default,
-    /// A pattern with prefix, numbering, lower / upper case and suffix.
-    Pattern(EcoString, Numbering, bool, EcoString),
-    /// A bare template.
-    Template(Template),
-    /// A closure mapping from an item number to a value.
-    Func(Func, Span),
-}
-
-impl Label {
-    /// Resolve the value based on the level.
-    pub fn resolve(
-        &self,
-        ctx: &mut Context,
-        kind: ListKind,
-        number: usize,
-    ) -> TypResult<Template> {
-        Ok(match self {
-            Self::Default => match kind {
-                UNORDERED => Template::Text('•'.into()),
-                ORDERED | _ => Template::Text(format_eco!("{}.", number)),
-            },
-            Self::Pattern(prefix, numbering, upper, suffix) => {
-                let fmt = numbering.apply(number);
-                let mid = if *upper { fmt.to_uppercase() } else { fmt.to_lowercase() };
-                Template::Text(format_eco!("{}{}{}", prefix, mid, suffix))
-            }
-            Self::Template(template) => template.clone(),
-            Self::Func(func, span) => {
-                let args = Args::from_values(*span, [Value::Int(number as i64)]);
-                func.call(ctx, args)?.cast().at(*span)?
-            }
-        })
-    }
-}
-
-impl Cast<Spanned<Value>> for Label {
-    fn is(value: &Spanned<Value>) -> bool {
-        matches!(&value.v, Value::Template(_) | Value::Func(_))
-    }
-
-    fn cast(value: Spanned<Value>) -> StrResult<Self> {
-        match value.v {
-            Value::Str(pattern) => {
-                let mut s = Scanner::new(&pattern);
-                let mut prefix;
-                let numbering = loop {
-                    prefix = s.eaten();
-                    match s.eat().map(|c| c.to_ascii_lowercase()) {
-                        Some('1') => break Numbering::Arabic,
-                        Some('a') => break Numbering::Letter,
-                        Some('i') => break Numbering::Roman,
-                        Some('*') => break Numbering::Symbol,
-                        Some(_) => {}
-                        None => Err("invalid pattern")?,
-                    }
-                };
-                let upper = s.prev(0).map_or(false, char::is_uppercase);
-                let suffix = s.rest().into();
-                Ok(Self::Pattern(prefix.into(), numbering, upper, suffix))
-            }
-            Value::Template(v) => Ok(Self::Template(v)),
-            Value::Func(v) => Ok(Self::Func(v, value.span)),
-            _ => Err("expected pattern, template or function")?,
-        }
-    }
-}
diff --git a/src/library/math.rs b/src/library/math.rs
deleted file mode 100644
index 5d0ae41b..00000000
--- a/src/library/math.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Mathematical formulas.
-
-use super::prelude::*;
-
-/// A mathematical formula.
-#[derive(Debug, Hash)]
-pub struct MathNode {
-    /// The formula.
-    pub formula: EcoString,
-    /// Whether the formula is display-level.
-    pub display: bool,
-}
-
-#[class]
-impl MathNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self {
-            formula: args.expect("formula")?,
-            display: args.named("display")?.unwrap_or(false),
-        }))
-    }
-}
-
-impl Show for MathNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        Ok(styles
-            .show(self, ctx, [
-                Value::Str(self.formula.clone()),
-                Value::Bool(self.display),
-            ])?
-            .unwrap_or_else(|| {
-                let mut template = Template::Text(self.formula.trim().into());
-                if self.display {
-                    template = Template::Block(template.pack());
-                }
-                template.monospaced()
-            }))
-    }
-}
diff --git a/src/library/mod.rs b/src/library/mod.rs
index 590dd331..4a80ef43 100644
--- a/src/library/mod.rs
+++ b/src/library/mod.rs
@@ -3,79 +3,11 @@
 //! Call [`new`] to obtain a [`Scope`] containing all standard library
 //! definitions.
 
-pub mod align;
-pub mod columns;
-pub mod container;
-pub mod deco;
-pub mod flow;
-pub mod grid;
-pub mod heading;
-pub mod hide;
-pub mod image;
-pub mod link;
-pub mod list;
-pub mod math;
-pub mod numbering;
-pub mod pad;
-pub mod page;
-pub mod par;
-pub mod place;
-pub mod raw;
-pub mod shape;
-pub mod spacing;
-pub mod stack;
-pub mod table;
+pub mod elements;
+pub mod layout;
+pub mod prelude;
 pub mod text;
-pub mod transform;
-
 pub mod utility;
-pub use self::image::*;
-pub use align::*;
-pub use columns::*;
-pub use container::*;
-pub use deco::*;
-pub use flow::*;
-pub use grid::*;
-pub use heading::*;
-pub use hide::*;
-pub use link::*;
-pub use list::*;
-pub use math::*;
-pub use numbering::*;
-pub use pad::*;
-pub use page::*;
-pub use par::*;
-pub use place::*;
-pub use raw::*;
-pub use shape::*;
-pub use spacing::*;
-pub use stack::*;
-pub use table::*;
-pub use text::*;
-pub use transform::*;
-pub use utility::*;
-
-/// Helpful imports for creating library functionality.
-pub mod prelude {
-    pub use std::fmt::{self, Debug, Formatter};
-    pub use std::hash::Hash;
-    pub use std::num::NonZeroUsize;
-    pub use std::sync::Arc;
-
-    pub use typst_macros::class;
-
-    pub use crate::diag::{with_alternative, At, StrResult, TypResult};
-    pub use crate::eval::{
-        Arg, Args, Cast, Construct, Func, Layout, LayoutNode, Merge, Property, Regions,
-        Scope, Set, Show, ShowNode, Smart, StyleChain, StyleMap, StyleVec, Template,
-        Value,
-    };
-    pub use crate::frame::*;
-    pub use crate::geom::*;
-    pub use crate::syntax::{Span, Spanned};
-    pub use crate::util::{EcoString, OptionExt};
-    pub use crate::Context;
-}
 
 use prelude::*;
 
@@ -83,72 +15,74 @@ use prelude::*;
 pub fn new() -> Scope {
     let mut std = Scope::new();
 
-    // Structure and semantics.
-    std.def_class::<PageNode>("page");
-    std.def_class::<PagebreakNode>("pagebreak");
-    std.def_class::<ParNode>("par");
-    std.def_class::<ParbreakNode>("parbreak");
-    std.def_class::<LinebreakNode>("linebreak");
-    std.def_class::<TextNode>("text");
-    std.def_class::<StrongNode>("strong");
-    std.def_class::<EmphNode>("emph");
-    std.def_class::<RawNode>("raw");
-    std.def_class::<MathNode>("math");
-    std.def_class::<DecoNode<UNDERLINE>>("underline");
-    std.def_class::<DecoNode<STRIKETHROUGH>>("strike");
-    std.def_class::<DecoNode<OVERLINE>>("overline");
-    std.def_class::<LinkNode>("link");
-    std.def_class::<HeadingNode>("heading");
-    std.def_class::<ListNode<UNORDERED>>("list");
-    std.def_class::<ListNode<ORDERED>>("enum");
-    std.def_class::<TableNode>("table");
-    std.def_class::<ImageNode>("image");
-    std.def_class::<ShapeNode<RECT>>("rect");
-    std.def_class::<ShapeNode<SQUARE>>("square");
-    std.def_class::<ShapeNode<ELLIPSE>>("ellipse");
-    std.def_class::<ShapeNode<CIRCLE>>("circle");
+    // Text.
+    std.def_class::<text::TextNode>("text");
+    std.def_class::<text::ParNode>("par");
+    std.def_class::<text::ParbreakNode>("parbreak");
+    std.def_class::<text::LinebreakNode>("linebreak");
+    std.def_class::<text::StrongNode>("strong");
+    std.def_class::<text::EmphNode>("emph");
+    std.def_class::<text::RawNode>("raw");
+    std.def_class::<text::UnderlineNode>("underline");
+    std.def_class::<text::StrikethroughNode>("strike");
+    std.def_class::<text::OverlineNode>("overline");
+    std.def_class::<text::LinkNode>("link");
+
+    // Elements.
+    std.def_class::<elements::MathNode>("math");
+    std.def_class::<elements::HeadingNode>("heading");
+    std.def_class::<elements::ListNode>("list");
+    std.def_class::<elements::EnumNode>("enum");
+    std.def_class::<elements::TableNode>("table");
+    std.def_class::<elements::ImageNode>("image");
+    std.def_class::<elements::RectNode>("rect");
+    std.def_class::<elements::SquareNode>("square");
+    std.def_class::<elements::EllipseNode>("ellipse");
+    std.def_class::<elements::CircleNode>("circle");
 
     // Layout.
-    std.def_class::<HNode>("h");
-    std.def_class::<VNode>("v");
-    std.def_class::<BoxNode>("box");
-    std.def_class::<BlockNode>("block");
-    std.def_class::<AlignNode>("align");
-    std.def_class::<PadNode>("pad");
-    std.def_class::<PlaceNode>("place");
-    std.def_class::<TransformNode<MOVE>>("move");
-    std.def_class::<TransformNode<SCALE>>("scale");
-    std.def_class::<TransformNode<ROTATE>>("rotate");
-    std.def_class::<HideNode>("hide");
-    std.def_class::<StackNode>("stack");
-    std.def_class::<GridNode>("grid");
-    std.def_class::<ColumnsNode>("columns");
-    std.def_class::<ColbreakNode>("colbreak");
+    std.def_class::<layout::PageNode>("page");
+    std.def_class::<layout::PagebreakNode>("pagebreak");
+    std.def_class::<layout::HNode>("h");
+    std.def_class::<layout::VNode>("v");
+    std.def_class::<layout::BoxNode>("box");
+    std.def_class::<layout::BlockNode>("block");
+    std.def_class::<layout::AlignNode>("align");
+    std.def_class::<layout::PadNode>("pad");
+    std.def_class::<layout::StackNode>("stack");
+    std.def_class::<layout::GridNode>("grid");
+    std.def_class::<layout::ColumnsNode>("columns");
+    std.def_class::<layout::ColbreakNode>("colbreak");
+    std.def_class::<layout::PlaceNode>("place");
+    std.def_class::<layout::MoveNode>("move");
+    std.def_class::<layout::ScaleNode>("scale");
+    std.def_class::<layout::RotateNode>("rotate");
+    std.def_class::<layout::HideNode>("hide");
 
     // Utility functions.
-    std.def_func("assert", assert);
-    std.def_func("type", type_);
-    std.def_func("repr", repr);
-    std.def_func("join", join);
-    std.def_func("int", int);
-    std.def_func("float", float);
-    std.def_func("str", str);
-    std.def_func("abs", abs);
-    std.def_func("min", min);
-    std.def_func("max", max);
-    std.def_func("even", even);
-    std.def_func("odd", odd);
-    std.def_func("mod", modulo);
-    std.def_func("range", range);
-    std.def_func("rgb", rgb);
-    std.def_func("cmyk", cmyk);
-    std.def_func("lower", lower);
-    std.def_func("upper", upper);
-    std.def_func("letter", letter);
-    std.def_func("roman", roman);
-    std.def_func("symbol", symbol);
-    std.def_func("len", len);
-    std.def_func("sorted", sorted);
+    std.def_func("assert", utility::assert);
+    std.def_func("type", utility::type_);
+    std.def_func("repr", utility::repr);
+    std.def_func("join", utility::join);
+    std.def_func("int", utility::int);
+    std.def_func("float", utility::float);
+    std.def_func("str", utility::str);
+    std.def_func("abs", utility::abs);
+    std.def_func("min", utility::min);
+    std.def_func("max", utility::max);
+    std.def_func("even", utility::even);
+    std.def_func("odd", utility::odd);
+    std.def_func("mod", utility::modulo);
+    std.def_func("range", utility::range);
+    std.def_func("rgb", utility::rgb);
+    std.def_func("cmyk", utility::cmyk);
+    std.def_func("lower", utility::lower);
+    std.def_func("upper", utility::upper);
+    std.def_func("letter", utility::letter);
+    std.def_func("roman", utility::roman);
+    std.def_func("symbol", utility::symbol);
+    std.def_func("len", utility::len);
+    std.def_func("sorted", utility::sorted);
 
     // Predefined colors.
     std.def_const("black", Color::BLACK);
@@ -181,9 +115,9 @@ pub fn new() -> Scope {
     std.def_const("top", Align::Top);
     std.def_const("horizon", Align::Horizon);
     std.def_const("bottom", Align::Bottom);
-    std.def_const("serif", FontFamily::Serif);
-    std.def_const("sans-serif", FontFamily::SansSerif);
-    std.def_const("monospace", FontFamily::Monospace);
+    std.def_const("serif", text::FontFamily::Serif);
+    std.def_const("sans-serif", text::FontFamily::SansSerif);
+    std.def_const("monospace", text::FontFamily::Monospace);
 
     std
 }
diff --git a/src/library/numbering.rs b/src/library/numbering.rs
deleted file mode 100644
index 05a39e36..00000000
--- a/src/library/numbering.rs
+++ /dev/null
@@ -1,113 +0,0 @@
-//! Conversion of numbers into letters, roman numerals and symbols.
-
-use super::prelude::*;
-
-static ROMANS: &'static [(&'static str, usize)] = &[
-    ("M̅", 1000000),
-    ("D̅", 500000),
-    ("C̅", 100000),
-    ("L̅", 50000),
-    ("X̅", 10000),
-    ("V̅", 5000),
-    ("I̅V̅", 4000),
-    ("M", 1000),
-    ("CM", 900),
-    ("D", 500),
-    ("CD", 400),
-    ("C", 100),
-    ("XC", 90),
-    ("L", 50),
-    ("XL", 40),
-    ("X", 10),
-    ("IX", 9),
-    ("V", 5),
-    ("IV", 4),
-    ("I", 1),
-];
-
-static SYMBOLS: &'static [char] = &['*', '†', '‡', '§', '‖', '¶'];
-
-/// The different kinds of numberings.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Numbering {
-    Arabic,
-    Letter,
-    Roman,
-    Symbol,
-}
-
-impl Numbering {
-    /// Apply the numbering to the given number.
-    pub fn apply(self, mut n: usize) -> EcoString {
-        match self {
-            Self::Arabic => {
-                format_eco!("{}", n)
-            }
-            Self::Letter => {
-                if n == 0 {
-                    return '-'.into();
-                }
-
-                n -= 1;
-
-                let mut letters = vec![];
-                loop {
-                    letters.push(b'a' + (n % 26) as u8);
-                    n /= 26;
-                    if n == 0 {
-                        break;
-                    }
-                }
-
-                letters.reverse();
-                String::from_utf8(letters).unwrap().into()
-            }
-            Self::Roman => {
-                if n == 0 {
-                    return 'N'.into();
-                }
-
-                // Adapted from Yann Villessuzanne's roman.rs under the Unlicense, at
-                // https://github.com/linfir/roman.rs/
-                let mut fmt = EcoString::new();
-                for &(name, value) in ROMANS {
-                    while n >= value {
-                        n -= value;
-                        fmt.push_str(name);
-                    }
-                }
-
-                fmt
-            }
-            Self::Symbol => {
-                if n == 0 {
-                    return '-'.into();
-                }
-
-                let symbol = SYMBOLS[(n - 1) % SYMBOLS.len()];
-                let amount = ((n - 1) / SYMBOLS.len()) + 1;
-                std::iter::repeat(symbol).take(amount).collect()
-            }
-        }
-    }
-}
-
-/// Converts an integer into one or multiple letters.
-pub fn letter(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    convert(Numbering::Letter, args)
-}
-
-/// Converts an integer into a roman numeral.
-pub fn roman(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    convert(Numbering::Roman, args)
-}
-
-/// Convert a number into a symbol.
-pub fn symbol(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    convert(Numbering::Symbol, args)
-}
-
-fn convert(numbering: Numbering, args: &mut Args) -> TypResult<Value> {
-    let n = args.expect::<usize>("non-negative integer")?;
-    Ok(Value::Str(numbering.apply(n)))
-}
diff --git a/src/library/pad.rs b/src/library/pad.rs
deleted file mode 100644
index 174322e4..00000000
--- a/src/library/pad.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-//! Surrounding nodes with extra space.
-
-use super::prelude::*;
-
-/// Pad a node at the sides.
-#[derive(Debug, Hash)]
-pub struct PadNode {
-    /// The amount of padding.
-    pub padding: Sides<Linear>,
-    /// The child node whose sides to pad.
-    pub child: LayoutNode,
-}
-
-#[class]
-impl PadNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let all = args.find()?;
-        let hor = args.named("horizontal")?;
-        let ver = args.named("vertical")?;
-        let left = args.named("left")?.or(hor).or(all).unwrap_or_default();
-        let top = args.named("top")?.or(ver).or(all).unwrap_or_default();
-        let right = args.named("right")?.or(hor).or(all).unwrap_or_default();
-        let bottom = args.named("bottom")?.or(ver).or(all).unwrap_or_default();
-        let body: LayoutNode = args.expect("body")?;
-        let padding = Sides::new(left, top, right, bottom);
-        Ok(Template::block(body.padded(padding)))
-    }
-}
-
-impl Layout for PadNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        // Layout child into padded regions.
-        let pod = regions.map(|size| shrink(size, self.padding));
-        let mut frames = self.child.layout(ctx, &pod, styles)?;
-
-        for frame in &mut frames {
-            // Apply the padding inversely such that the grown size padded
-            // yields the frame's size.
-            let padded = grow(frame.size, self.padding);
-            let padding = self.padding.resolve(padded);
-            let offset = Point::new(padding.left, padding.top);
-
-            // Grow the frame and translate everything in the frame inwards.
-            let frame = Arc::make_mut(frame);
-            frame.size = padded;
-            frame.translate(offset);
-        }
-
-        Ok(frames)
-    }
-}
-
-/// Shrink a size by padding relative to the size itself.
-fn shrink(size: Size, padding: Sides<Linear>) -> Size {
-    size - padding.resolve(size).sum_by_axis()
-}
-
-/// Grow a size by padding relative to the grown size.
-/// This is the inverse operation to `shrink()`.
-///
-/// For the horizontal axis the derivation looks as follows.
-/// (Vertical axis is analogous.)
-///
-/// Let w be the grown target width,
-///     s be given width,
-///     l be the left padding,
-///     r be the right padding,
-///     p = l + r.
-///
-/// We want that: w - l.resolve(w) - r.resolve(w) = s
-///
-/// Thus: w - l.resolve(w) - r.resolve(w) = s
-///   <=> w - p.resolve(w) = s
-///   <=> w - p.rel * w - p.abs = s
-///   <=> (1 - p.rel) * w = s + p.abs
-///   <=> w = (s + p.abs) / (1 - p.rel)
-fn grow(size: Size, padding: Sides<Linear>) -> Size {
-    size.zip(padding.sum_by_axis())
-        .map(|(s, p)| (s + p.abs).safe_div(1.0 - p.rel.get()))
-}
diff --git a/src/library/page.rs b/src/library/page.rs
deleted file mode 100644
index 5281c501..00000000
--- a/src/library/page.rs
+++ /dev/null
@@ -1,421 +0,0 @@
-//! Pages of paper.
-
-use std::fmt::{self, Display, Formatter};
-use std::str::FromStr;
-
-use super::prelude::*;
-use super::ColumnsNode;
-
-/// Layouts its child onto one or multiple pages.
-#[derive(Clone, PartialEq, Hash)]
-pub struct PageNode(pub LayoutNode);
-
-#[class]
-impl PageNode {
-    /// The unflipped width of the page.
-    pub const WIDTH: Smart<Length> = Smart::Custom(Paper::A4.width());
-    /// The unflipped height of the page.
-    pub const HEIGHT: Smart<Length> = Smart::Custom(Paper::A4.height());
-    /// Whether the page is flipped into landscape orientation.
-    pub const FLIPPED: bool = false;
-    /// The left margin.
-    pub const LEFT: Smart<Linear> = Smart::Auto;
-    /// The right margin.
-    pub const RIGHT: Smart<Linear> = Smart::Auto;
-    /// The top margin.
-    pub const TOP: Smart<Linear> = Smart::Auto;
-    /// The bottom margin.
-    pub const BOTTOM: Smart<Linear> = Smart::Auto;
-    /// The page's background color.
-    pub const FILL: Option<Paint> = None;
-    /// How many columns the page has.
-    pub const COLUMNS: NonZeroUsize = NonZeroUsize::new(1).unwrap();
-    /// The page's header.
-    pub const HEADER: Marginal = Marginal::None;
-    /// The page's footer.
-    pub const FOOTER: Marginal = Marginal::None;
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::Page(Self(args.expect("body")?)))
-    }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        if let Some(paper) = args.named_or_find::<Paper>("paper")? {
-            styles.set(Self::WIDTH, Smart::Custom(paper.width()));
-            styles.set(Self::HEIGHT, Smart::Custom(paper.height()));
-        }
-
-        styles.set_opt(Self::WIDTH, args.named("width")?);
-        styles.set_opt(Self::HEIGHT, args.named("height")?);
-
-        let all = args.named("margins")?;
-        let hor = args.named("horizontal")?;
-        let ver = args.named("vertical")?;
-        styles.set_opt(Self::LEFT, args.named("left")?.or(hor).or(all));
-        styles.set_opt(Self::TOP, args.named("top")?.or(ver).or(all));
-        styles.set_opt(Self::RIGHT, args.named("right")?.or(hor).or(all));
-        styles.set_opt(Self::BOTTOM, args.named("bottom")?.or(ver).or(all));
-
-        styles.set_opt(Self::FLIPPED, args.named("flipped")?);
-        styles.set_opt(Self::FILL, args.named("fill")?);
-        styles.set_opt(Self::COLUMNS, args.named("columns")?);
-        styles.set_opt(Self::HEADER, args.named("header")?);
-        styles.set_opt(Self::FOOTER, args.named("footer")?);
-
-        Ok(())
-    }
-}
-
-impl PageNode {
-    /// Layout the page run into a sequence of frames, one per page.
-    pub fn layout(
-        &self,
-        ctx: &mut Context,
-        mut page: usize,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        // When one of the lengths is infinite the page fits its content along
-        // that axis.
-        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);
-        }
-
-        let mut min = width.min(height);
-        if min.is_infinite() {
-            min = Paper::A4.width();
-        }
-
-        // Determine the margins.
-        let default = Linear::from(0.1190 * min);
-        let padding = Sides {
-            left: styles.get(Self::LEFT).unwrap_or(default),
-            right: styles.get(Self::RIGHT).unwrap_or(default),
-            top: styles.get(Self::TOP).unwrap_or(default),
-            bottom: styles.get(Self::BOTTOM).unwrap_or(default),
-        };
-
-        let mut child = self.0.clone();
-
-        // Realize columns with columns node.
-        let columns = styles.get(Self::COLUMNS);
-        if columns.get() > 1 {
-            child = ColumnsNode { columns, child: self.0.clone() }.pack();
-        }
-
-        // Realize margins.
-        child = child.padded(padding);
-
-        // Realize background fill.
-        if let Some(fill) = styles.get(Self::FILL) {
-            child = child.filled(fill);
-        }
-
-        // Layout the child.
-        let regions = Regions::repeat(size, size, size.map(Length::is_finite));
-        let mut frames = child.layout(ctx, &regions, styles)?;
-
-        let header = styles.get_ref(Self::HEADER);
-        let footer = styles.get_ref(Self::FOOTER);
-
-        // Realize header and footer.
-        for frame in &mut frames {
-            let size = frame.size;
-            let padding = padding.resolve(size);
-            for (y, h, marginal) in [
-                (Length::zero(), padding.top, header),
-                (size.y - padding.bottom, padding.bottom, footer),
-            ] {
-                if let Some(template) = marginal.resolve(ctx, page)? {
-                    let pos = Point::new(padding.left, y);
-                    let w = size.x - padding.left - padding.right;
-                    let area = Size::new(w, h);
-                    let pod = Regions::one(area, area, area.map(Length::is_finite));
-                    let sub = Layout::layout(&template, ctx, &pod, styles)?.remove(0);
-                    Arc::make_mut(frame).push_frame(pos, sub);
-                }
-            }
-
-            page += 1;
-        }
-
-        Ok(frames)
-    }
-}
-
-impl Debug for PageNode {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_str("Page(")?;
-        self.0.fmt(f)?;
-        f.write_str(")")
-    }
-}
-
-/// A page break.
-pub struct PagebreakNode;
-
-#[class]
-impl PagebreakNode {
-    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
-        Ok(Template::Pagebreak)
-    }
-}
-
-/// A header or footer definition.
-#[derive(Debug, Clone, PartialEq, Hash)]
-pub enum Marginal {
-    /// Nothing,
-    None,
-    /// A bare template.
-    Template(Template),
-    /// A closure mapping from a page number to a template.
-    Func(Func, Span),
-}
-
-impl Marginal {
-    /// Resolve the marginal based on the page number.
-    pub fn resolve(&self, ctx: &mut Context, page: usize) -> TypResult<Option<Template>> {
-        Ok(match self {
-            Self::None => None,
-            Self::Template(template) => Some(template.clone()),
-            Self::Func(func, span) => {
-                let args = Args::from_values(*span, [Value::Int(page as i64)]);
-                func.call(ctx, args)?.cast().at(*span)?
-            }
-        })
-    }
-}
-
-impl Cast<Spanned<Value>> for Marginal {
-    fn is(value: &Spanned<Value>) -> bool {
-        matches!(&value.v, Value::Template(_) | Value::Func(_))
-    }
-
-    fn cast(value: Spanned<Value>) -> StrResult<Self> {
-        match value.v {
-            Value::None => Ok(Self::None),
-            Value::Template(v) => Ok(Self::Template(v)),
-            Value::Func(v) => Ok(Self::Func(v, value.span)),
-            _ => Err("expected none, template or function")?,
-        }
-    }
-}
-
-/// Specification of a paper.
-#[derive(Debug, Copy, Clone)]
-pub struct Paper {
-    /// The width of the paper in millimeters.
-    width: f64,
-    /// The height of the paper in millimeters.
-    height: f64,
-}
-
-impl Paper {
-    /// 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)
-    }
-}
-
-/// Defines paper constants and a paper parsing implementation.
-macro_rules! papers {
-    ($(($var: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 { width: $width, height: $height };)*
-        }
-
-        impl FromStr for Paper {
-            type Err = PaperError;
-
-            fn from_str(name: &str) -> Result<Self, Self::Err> {
-                match name.to_lowercase().as_str() {
-                    $($($pats)* => Ok(Self::$var),)*
-                    _ => Err(PaperError),
-                }
-            }
-        }
-    };
-}
-
-// 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:  841.0, 1189.0, "a0")
-    (A1:  594.0,  841.0, "a1")
-    (A2:  420.0,  594.0, "a2")
-    (A3:  297.0,  420.0, "a3")
-    (A4:  210.0,  297.0, "a4")
-    (A5:  148.0,  210.0, "a5")
-    (A6:  105.0,  148.0, "a6")
-    (A7:   74.0,  105.0, "a7")
-    (A8:   52.0,   74.0, "a8")
-    (A9:   37.0,   52.0, "a9")
-    (A10:  26.0,   37.0, "a10")
-    (A11:  18.0,   26.0, "a11")
-
-    // ISO 216 B Series
-    (ISO_B1: 707.0, 1000.0, "iso-b1")
-    (ISO_B2: 500.0,  707.0,  "iso-b2")
-    (ISO_B3: 353.0,  500.0,  "iso-b3")
-    (ISO_B4: 250.0,  353.0,  "iso-b4")
-    (ISO_B5: 176.0,  250.0,  "iso-b5")
-    (ISO_B6: 125.0,  176.0,  "iso-b6")
-    (ISO_B7:  88.0,  125.0,  "iso-b7")
-    (ISO_B8:  62.0,   88.0,  "iso-b8")
-
-    // ISO 216 C Series
-    (ISO_C3: 324.0, 458.0, "iso-c3")
-    (ISO_C4: 229.0, 324.0, "iso-c4")
-    (ISO_C5: 162.0, 229.0, "iso-c5")
-    (ISO_C6: 114.0, 162.0, "iso-c6")
-    (ISO_C7:  81.0, 114.0, "iso-c7")
-    (ISO_C8:  57.0,  81.0, "iso-c8")
-
-    // DIN D Series (extension to ISO)
-    (DIN_D3: 272.0, 385.0, "din-d3")
-    (DIN_D4: 192.0, 272.0, "din-d4")
-    (DIN_D5: 136.0, 192.0, "din-d5")
-    (DIN_D6:  96.0, 136.0, "din-d6")
-    (DIN_D7:  68.0,  96.0, "din-d7")
-    (DIN_D8:  48.0,  68.0, "din-d8")
-
-    // SIS (used in academia)
-    (SIS_G5: 169.0, 239.0, "sis-g5")
-    (SIS_E5: 115.0, 220.0, "sis-e5")
-
-    // ANSI Extensions
-    (ANSI_A: 216.0,  279.0, "ansi-a")
-    (ANSI_B: 279.0,  432.0, "ansi-b")
-    (ANSI_C: 432.0,  559.0, "ansi-c")
-    (ANSI_D: 559.0,  864.0, "ansi-d")
-    (ANSI_E: 864.0, 1118.0, "ansi-e")
-
-    // ANSI Architectural Paper
-    (ARCH_A:  229.0,  305.0, "arch-a")
-    (ARCH_B:  305.0,  457.0, "arch-b")
-    (ARCH_C:  457.0,  610.0, "arch-c")
-    (ARCH_D:  610.0,  914.0, "arch-d")
-    (ARCH_E1: 762.0, 1067.0, "arch-e1")
-    (ARCH_E:  914.0, 1219.0, "arch-e")
-
-    // JIS B Series
-    (JIS_B0:  1030.0, 1456.0, "jis-b0")
-    (JIS_B1:   728.0, 1030.0, "jis-b1")
-    (JIS_B2:   515.0,  728.0, "jis-b2")
-    (JIS_B3:   364.0,  515.0, "jis-b3")
-    (JIS_B4:   257.0,  364.0, "jis-b4")
-    (JIS_B5:   182.0,  257.0, "jis-b5")
-    (JIS_B6:   128.0,  182.0, "jis-b6")
-    (JIS_B7:    91.0,  128.0, "jis-b7")
-    (JIS_B8:    64.0,   91.0, "jis-b8")
-    (JIS_B9:    45.0,   64.0, "jis-b9")
-    (JIS_B10:   32.0,   45.0, "jis-b10")
-    (JIS_B11:   22.0,   32.0, "jis-b11")
-
-    // SAC D Series
-    (SAC_D0: 764.0, 1064.0, "sac-d0")
-    (SAC_D1: 532.0,  760.0, "sac-d1")
-    (SAC_D2: 380.0,  528.0, "sac-d2")
-    (SAC_D3: 264.0,  376.0, "sac-d3")
-    (SAC_D4: 188.0,  260.0, "sac-d4")
-    (SAC_D5: 130.0,  184.0, "sac-d5")
-    (SAC_D6:  92.0,  126.0, "sac-d6")
-
-    // ISO 7810 ID
-    (ISO_ID_1: 85.6, 53.98, "iso-id-1")
-    (ISO_ID_2: 74.0, 105.0, "iso-id-2")
-    (ISO_ID_3: 88.0, 125.0, "iso-id-3")
-
-    // ---------------------------------------------------------------------- //
-    // Asia
-    (ASIA_F4: 210.0, 330.0, "asia-f4")
-
-    // Japan
-    (JP_SHIROKU_BAN_4: 264.0, 379.0, "jp-shiroku-ban-4")
-    (JP_SHIROKU_BAN_5: 189.0, 262.0, "jp-shiroku-ban-5")
-    (JP_SHIROKU_BAN_6: 127.0, 188.0, "jp-shiroku-ban-6")
-    (JP_KIKU_4:        227.0, 306.0, "jp-kiku-4")
-    (JP_KIKU_5:        151.0, 227.0, "jp-kiku-5")
-    (JP_BUSINESS_CARD:  91.0,  55.0, "jp-business-card")
-
-    // China
-    (CN_BUSINESS_CARD: 90.0, 54.0, "cn-business-card")
-
-    // Europe
-    (EU_BUSINESS_CARD: 85.0, 55.0, "eu-business-card")
-
-    // French Traditional (AFNOR)
-    (FR_TELLIERE:          340.0, 440.0, "fr-tellière")
-    (FR_COURONNE_ECRITURE: 360.0, 460.0, "fr-couronne-écriture")
-    (FR_COURONNE_EDITION:  370.0, 470.0, "fr-couronne-édition")
-    (FR_RAISIN:            500.0, 650.0, "fr-raisin")
-    (FR_CARRE:             450.0, 560.0, "fr-carré")
-    (FR_JESUS:             560.0, 760.0, "fr-jésus")
-
-    // United Kingdom Imperial
-    (UK_BRIEF:    406.4, 342.9, "uk-brief")
-    (UK_DRAFT:    254.0, 406.4, "uk-draft")
-    (UK_FOOLSCAP: 203.2, 330.2, "uk-foolscap")
-    (UK_QUARTO:   203.2, 254.0, "uk-quarto")
-    (UK_CROWN:    508.0, 381.0, "uk-crown")
-    (UK_BOOK_A:   111.0, 178.0, "uk-book-a")
-    (UK_BOOK_B:   129.0, 198.0, "uk-book-b")
-
-    // Unites States
-    (US_LETTER:         215.9,  279.4, "us-letter")
-    (US_LEGAL:          215.9,  355.6, "us-legal")
-    (US_TABLOID:        279.4,  431.8, "us-tabloid")
-    (US_EXECUTIVE:      84.15,  266.7, "us-executive")
-    (US_FOOLSCAP_FOLIO: 215.9,  342.9, "us-foolscap-folio")
-    (US_STATEMENT:      139.7,  215.9, "us-statement")
-    (US_LEDGER:         431.8,  279.4, "us-ledger")
-    (US_OFICIO:         215.9, 340.36, "us-oficio")
-    (US_GOV_LETTER:     203.2,  266.7, "us-gov-letter")
-    (US_GOV_LEGAL:      215.9,  330.2, "us-gov-legal")
-    (US_BUSINESS_CARD:   88.9,   50.8, "us-business-card")
-    (US_DIGEST:         139.7,  215.9, "us-digest")
-    (US_TRADE:          152.4,  228.6, "us-trade")
-
-    // ---------------------------------------------------------------------- //
-    // Other
-    (NEWSPAPER_COMPACT:    280.0,    430.0,    "newspaper-compact")
-    (NEWSPAPER_BERLINER:   315.0,    470.0,    "newspaper-berliner")
-    (NEWSPAPER_BROADSHEET: 381.0,    578.0,    "newspaper-broadsheet")
-    (PRESENTATION_16_9:    297.0, 167.0625, "presentation-16-9")
-    (PRESENTATION_4_3:     280.0,    210.0,    "presentation-4-3")
-}
-
-castable! {
-    Paper,
-    Expected: "string",
-    Value::Str(string) => Paper::from_str(&string).map_err(|e| e.to_string())?,
-}
-
-/// The error when parsing a [`Paper`] from a string fails.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct PaperError;
-
-impl Display for PaperError {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.pad("invalid paper name")
-    }
-}
-
-impl std::error::Error for PaperError {}
diff --git a/src/library/par.rs b/src/library/par.rs
deleted file mode 100644
index 6d5a0597..00000000
--- a/src/library/par.rs
+++ /dev/null
@@ -1,634 +0,0 @@
-//! Paragraph layout.
-
-use std::sync::Arc;
-
-use either::Either;
-use unicode_bidi::{BidiInfo, Level};
-use xi_unicode::LineBreakIterator;
-
-use super::prelude::*;
-use super::{shape, ShapedText, SpacingKind, TextNode};
-use crate::font::FontStore;
-use crate::util::{ArcExt, EcoString, RangeExt, SliceExt};
-
-/// Arrange text, spacing and inline-level nodes into a paragraph.
-#[derive(Hash)]
-pub struct ParNode(pub StyleVec<ParChild>);
-
-/// A uniformly styled atomic piece of a paragraph.
-#[derive(Hash)]
-pub enum ParChild {
-    /// A chunk of text.
-    Text(EcoString),
-    /// Horizontal spacing between other children.
-    Spacing(SpacingKind),
-    /// An arbitrary inline-level node.
-    Node(LayoutNode),
-}
-
-#[class]
-impl ParNode {
-    /// The direction for text and inline objects.
-    pub const DIR: Dir = Dir::LTR;
-    /// How to align text and inline objects in their line.
-    pub const ALIGN: Align = Align::Left;
-    /// Whether to justify text in its line.
-    pub const JUSTIFY: bool = false;
-    /// The spacing between lines (dependent on scaled font size).
-    pub const LEADING: Linear = Relative::new(0.65).into();
-    /// The extra spacing between paragraphs (dependent on scaled font size).
-    pub const SPACING: Linear = Relative::new(0.55).into();
-    /// The indent the first line of a consecutive paragraph should have.
-    pub const INDENT: Linear = Linear::zero();
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        // The paragraph constructor is special: It doesn't create a paragraph
-        // since that happens automatically through markup. Instead, it just
-        // lifts the passed body to the block level so that it won't merge with
-        // adjacent stuff and it styles the contained paragraphs.
-        Ok(Template::Block(args.expect("body")?))
-    }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        let mut dir =
-            args.named("lang")?
-                .map(|iso: EcoString| match iso.to_lowercase().as_str() {
-                    "ar" | "he" | "fa" | "ur" | "ps" | "yi" => Dir::RTL,
-                    "en" | "fr" | "de" => Dir::LTR,
-                    _ => Dir::LTR,
-                });
-
-        if let Some(Spanned { v, span }) = args.named::<Spanned<Dir>>("dir")? {
-            if v.axis() != SpecAxis::Horizontal {
-                bail!(span, "must be horizontal");
-            }
-            dir = Some(v);
-        }
-
-        let align =
-            if let Some(Spanned { v, span }) = args.named::<Spanned<Align>>("align")? {
-                if v.axis() != SpecAxis::Horizontal {
-                    bail!(span, "must be horizontal");
-                }
-                Some(v)
-            } else {
-                dir.map(|dir| dir.start().into())
-            };
-
-        styles.set_opt(Self::DIR, dir);
-        styles.set_opt(Self::ALIGN, align);
-        styles.set_opt(Self::JUSTIFY, args.named("justify")?);
-        styles.set_opt(Self::LEADING, args.named("leading")?);
-        styles.set_opt(Self::SPACING, args.named("spacing")?);
-        styles.set_opt(Self::INDENT, args.named("indent")?);
-
-        Ok(())
-    }
-}
-
-impl ParNode {
-    /// Concatenate all text in the paragraph into one string, replacing spacing
-    /// with a space character and other non-text nodes with the object
-    /// replacement character.
-    fn collect_text(&self) -> String {
-        let mut text = String::new();
-        for string in self.strings() {
-            text.push_str(string);
-        }
-        text
-    }
-
-    /// The range of each item in the collected text.
-    fn ranges(&self) -> impl Iterator<Item = Range> + '_ {
-        let mut cursor = 0;
-        self.strings().map(move |string| {
-            let start = cursor;
-            cursor += string.len();
-            start .. cursor
-        })
-    }
-
-    /// The string representation of each child.
-    fn strings(&self) -> impl Iterator<Item = &str> {
-        self.0.items().map(|child| match child {
-            ParChild::Text(text) => text,
-            ParChild::Spacing(_) => " ",
-            ParChild::Node(_) => "\u{FFFC}",
-        })
-    }
-}
-
-impl Layout for ParNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        // Collect all text into one string and perform BiDi analysis.
-        let text = self.collect_text();
-        let level = Level::from_dir(styles.get(Self::DIR));
-        let bidi = BidiInfo::new(&text, level);
-
-        // Prepare paragraph layout by building a representation on which we can
-        // do line breaking without layouting each and every line from scratch.
-        let par = ParLayout::new(ctx, self, bidi, regions, &styles)?;
-
-        // Break the paragraph into lines.
-        let lines = break_lines(&mut ctx.fonts, &par, regions.first.x);
-
-        // Stack the lines into one frame per region.
-        Ok(stack_lines(&ctx.fonts, lines, regions, styles))
-    }
-}
-
-/// Perform line breaking.
-fn break_lines<'a>(
-    fonts: &mut FontStore,
-    par: &'a ParLayout<'a>,
-    width: Length,
-) -> Vec<LineLayout<'a>> {
-    // The already determined lines and the current line attempt.
-    let mut lines = vec![];
-    let mut start = 0;
-    let mut last = None;
-
-    // Find suitable line breaks.
-    for (end, mandatory) in LineBreakIterator::new(&par.bidi.text) {
-        // Compute the line and its size.
-        let mut line = par.line(fonts, start .. end, mandatory);
-
-        // If the line doesn't fit anymore, we push the last fitting attempt
-        // into the stack and rebuild the line from its end. The resulting
-        // line cannot be broken up further.
-        if !width.fits(line.size.x) {
-            if let Some((last_line, last_end)) = last.take() {
-                lines.push(last_line);
-                start = last_end;
-                line = par.line(fonts, start .. end, mandatory);
-            }
-        }
-
-        // Finish the current line if there is a mandatory line break (i.e.
-        // due to "\n") or if the line doesn't fit horizontally already
-        // since then no shorter line will be possible.
-        if mandatory || !width.fits(line.size.x) {
-            lines.push(line);
-            start = end;
-            last = None;
-        } else {
-            last = Some((line, end));
-        }
-    }
-
-    if let Some((line, _)) = last {
-        lines.push(line);
-    }
-
-    lines
-}
-
-/// Combine the lines into one frame per region.
-fn stack_lines(
-    fonts: &FontStore,
-    lines: Vec<LineLayout>,
-    regions: &Regions,
-    styles: StyleChain,
-) -> Vec<Arc<Frame>> {
-    let em = styles.get(TextNode::SIZE).abs;
-    let leading = styles.get(ParNode::LEADING).resolve(em);
-    let align = styles.get(ParNode::ALIGN);
-    let justify = styles.get(ParNode::JUSTIFY);
-
-    // Determine the paragraph's width: Full width of the region if we
-    // should expand or there's fractional spacing, fit-to-width otherwise.
-    let mut width = regions.first.x;
-    if !regions.expand.x && lines.iter().all(|line| line.fr.is_zero()) {
-        width = lines.iter().map(|line| line.size.x).max().unwrap_or_default();
-    }
-
-    // State for final frame building.
-    let mut regions = regions.clone();
-    let mut finished = vec![];
-    let mut first = true;
-    let mut output = Frame::new(Size::with_x(width));
-
-    // Stack the lines into one frame per region.
-    for line in lines {
-        while !regions.first.y.fits(line.size.y) && !regions.in_last() {
-            finished.push(Arc::new(output));
-            output = Frame::new(Size::with_x(width));
-            regions.next();
-            first = true;
-        }
-
-        if !first {
-            output.size.y += leading;
-        }
-
-        let frame = line.build(fonts, width, align, justify);
-        let pos = Point::with_y(output.size.y);
-        output.size.y += frame.size.y;
-        output.merge_frame(pos, frame);
-
-        regions.first.y -= line.size.y + leading;
-        first = false;
-    }
-
-    finished.push(Arc::new(output));
-    finished
-}
-
-impl Debug for ParNode {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        f.write_str("Par ")?;
-        self.0.fmt(f)
-    }
-}
-
-impl Debug for ParChild {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::Text(text) => write!(f, "Text({:?})", text),
-            Self::Spacing(kind) => write!(f, "{:?}", kind),
-            Self::Node(node) => node.fmt(f),
-        }
-    }
-}
-
-impl Merge for ParChild {
-    fn merge(&mut self, next: &Self) -> bool {
-        if let (Self::Text(left), Self::Text(right)) = (self, next) {
-            left.push_str(right);
-            true
-        } else {
-            false
-        }
-    }
-}
-
-/// A paragraph break.
-pub struct ParbreakNode;
-
-#[class]
-impl ParbreakNode {
-    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
-        Ok(Template::Parbreak)
-    }
-}
-
-/// A line break.
-pub struct LinebreakNode;
-
-#[class]
-impl LinebreakNode {
-    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
-        Ok(Template::Linebreak)
-    }
-}
-
-/// A paragraph representation in which children are already layouted and text
-/// is already preshaped.
-struct ParLayout<'a> {
-    /// Bidirectional text embedding levels for the paragraph.
-    bidi: BidiInfo<'a>,
-    /// Spacing, separated text runs and layouted nodes.
-    items: Vec<ParItem<'a>>,
-    /// The ranges of the items in `bidi.text`.
-    ranges: Vec<Range>,
-}
-
-/// Range of a substring of text.
-type Range = std::ops::Range<usize>;
-
-/// A prepared item in a paragraph layout.
-enum ParItem<'a> {
-    /// Absolute spacing between other items.
-    Absolute(Length),
-    /// Fractional spacing between other items.
-    Fractional(Fractional),
-    /// A shaped text run with consistent direction.
-    Text(ShapedText<'a>),
-    /// A layouted child node.
-    Frame(Frame),
-}
-
-impl<'a> ParLayout<'a> {
-    /// Prepare initial shaped text and layouted children.
-    fn new(
-        ctx: &mut Context,
-        par: &'a ParNode,
-        bidi: BidiInfo<'a>,
-        regions: &Regions,
-        styles: &'a StyleChain<'a>,
-    ) -> TypResult<Self> {
-        let mut items = vec![];
-        let mut ranges = vec![];
-
-        // Layout the children and collect them into items.
-        for (range, (child, map)) in par.ranges().zip(par.0.iter()) {
-            let styles = map.chain(styles);
-            match child {
-                ParChild::Text(_) => {
-                    // TODO: Also split by language and script.
-                    let mut cursor = range.start;
-                    for (level, count) in bidi.levels[range].group() {
-                        let start = cursor;
-                        cursor += count;
-                        let subrange = start .. cursor;
-                        let text = &bidi.text[subrange.clone()];
-                        let shaped = shape(&mut ctx.fonts, text, styles, level.dir());
-                        items.push(ParItem::Text(shaped));
-                        ranges.push(subrange);
-                    }
-                }
-                ParChild::Spacing(kind) => match *kind {
-                    SpacingKind::Linear(v) => {
-                        let resolved = v.resolve(regions.first.x);
-                        items.push(ParItem::Absolute(resolved));
-                        ranges.push(range);
-                    }
-                    SpacingKind::Fractional(v) => {
-                        items.push(ParItem::Fractional(v));
-                        ranges.push(range);
-                    }
-                },
-                ParChild::Node(node) => {
-                    let size = Size::new(regions.first.x, regions.base.y);
-                    let pod = Regions::one(size, regions.base, Spec::splat(false));
-                    let frame = node.layout(ctx, &pod, styles)?.remove(0);
-                    items.push(ParItem::Frame(Arc::take(frame)));
-                    ranges.push(range);
-                }
-            }
-        }
-
-        Ok(Self { bidi, items, ranges })
-    }
-
-    /// Create a line which spans the given range.
-    fn line(
-        &'a self,
-        fonts: &mut FontStore,
-        mut range: Range,
-        mandatory: bool,
-    ) -> LineLayout<'a> {
-        // Find the items which bound the text range.
-        let last_idx = self.find(range.end.saturating_sub(1)).unwrap();
-        let first_idx = if range.is_empty() {
-            last_idx
-        } else {
-            self.find(range.start).unwrap()
-        };
-
-        // Slice out the relevant items and ranges.
-        let mut items = &self.items[first_idx ..= last_idx];
-        let ranges = &self.ranges[first_idx ..= last_idx];
-
-        // Reshape the last item if it's split in half.
-        let mut last = None;
-        if let Some((ParItem::Text(shaped), rest)) = items.split_last() {
-            // Compute the range we want to shape, trimming whitespace at the
-            // end of the line.
-            let base = self.ranges[last_idx].start;
-            let start = range.start.max(base);
-            let end = start + self.bidi.text[start .. range.end].trim_end().len();
-            let shifted = start - base .. end - base;
-
-            // Reshape if necessary.
-            if shifted.len() < shaped.text.len() {
-                // If start == end and the rest is empty, then we have an empty
-                // line. To make that line have the appropriate height, we shape the
-                // empty string.
-                if !shifted.is_empty() || rest.is_empty() {
-                    // Reshape that part.
-                    let reshaped = shaped.reshape(fonts, shifted);
-                    last = Some(ParItem::Text(reshaped));
-                }
-
-                items = rest;
-                range.end = end;
-            }
-        }
-
-        // Reshape the start item if it's split in half.
-        let mut first = None;
-        if let Some((ParItem::Text(shaped), rest)) = items.split_first() {
-            // Compute the range we want to shape.
-            let Range { start: base, end: first_end } = self.ranges[first_idx];
-            let start = range.start;
-            let end = range.end.min(first_end);
-            let shifted = start - base .. end - base;
-
-            // Reshape if necessary.
-            if shifted.len() < shaped.text.len() {
-                if !shifted.is_empty() {
-                    let reshaped = shaped.reshape(fonts, shifted);
-                    first = Some(ParItem::Text(reshaped));
-                }
-
-                items = rest;
-            }
-        }
-
-        let mut width = Length::zero();
-        let mut top = Length::zero();
-        let mut bottom = Length::zero();
-        let mut fr = Fractional::zero();
-
-        // Measure the size of the line.
-        for item in first.iter().chain(items).chain(&last) {
-            match item {
-                ParItem::Absolute(v) => width += *v,
-                ParItem::Fractional(v) => fr += *v,
-                ParItem::Text(shaped) => {
-                    width += shaped.size.x;
-                    top.set_max(shaped.baseline);
-                    bottom.set_max(shaped.size.y - shaped.baseline);
-                }
-                ParItem::Frame(frame) => {
-                    width += frame.size.x;
-                    top.set_max(frame.baseline());
-                    bottom.set_max(frame.size.y - frame.baseline());
-                }
-            }
-        }
-
-        LineLayout {
-            bidi: &self.bidi,
-            range,
-            first,
-            items,
-            last,
-            ranges,
-            size: Size::new(width, top + bottom),
-            baseline: top,
-            fr,
-            mandatory,
-        }
-    }
-
-
-    /// Find the index of the item whose range contains the `text_offset`.
-    fn find(&self, text_offset: usize) -> Option<usize> {
-        self.ranges.binary_search_by(|r| r.locate(text_offset)).ok()
-    }
-}
-
-/// A lightweight representation of a line that spans a specific range in a
-/// paragraph's text. This type enables you to cheaply measure the size of a
-/// line in a range before comitting to building the line's frame.
-struct LineLayout<'a> {
-    /// Bidi information about the paragraph.
-    bidi: &'a BidiInfo<'a>,
-    /// The range the line spans in the paragraph.
-    range: Range,
-    /// A reshaped text item if the line sliced up a text item at the start.
-    first: Option<ParItem<'a>>,
-    /// Middle items which don't need to be reprocessed.
-    items: &'a [ParItem<'a>],
-    /// A reshaped text item if the line sliced up a text item at the end. If
-    /// there is only one text item, this takes precedence over `first`.
-    last: Option<ParItem<'a>>,
-    /// The ranges, indexed as `[first, ..items, last]`. The ranges for `first`
-    /// and `last` aren't trimmed to the line, but it doesn't matter because
-    /// we're just checking which range an index falls into.
-    ranges: &'a [Range],
-    /// The size of the line.
-    size: Size,
-    /// The baseline of the line.
-    baseline: Length,
-    /// The sum of fractional ratios in the line.
-    fr: Fractional,
-    /// Whether the line ends at a mandatory break.
-    mandatory: bool,
-}
-
-impl<'a> LineLayout<'a> {
-    /// Build the line's frame.
-    fn build(
-        &self,
-        fonts: &FontStore,
-        width: Length,
-        align: Align,
-        justify: bool,
-    ) -> Frame {
-        let size = Size::new(width, self.size.y);
-
-        let mut remaining = width - self.size.x;
-        let mut offset = Length::zero();
-        let mut output = Frame::new(size);
-        output.baseline = Some(self.baseline);
-
-        let mut justification = Length::zero();
-        if justify
-            && !self.mandatory
-            && self.range.end < self.bidi.text.len()
-            && self.fr.is_zero()
-        {
-            justification = remaining / self.spaces() as f64;
-            remaining = Length::zero();
-        }
-
-        for item in self.reordered() {
-            let mut position = |frame: Frame| {
-                let x = offset + align.resolve(remaining);
-                let y = self.baseline - frame.baseline();
-                offset += frame.size.x;
-                output.merge_frame(Point::new(x, y), frame);
-            };
-
-            match item {
-                ParItem::Absolute(v) => offset += *v,
-                ParItem::Fractional(v) => offset += v.resolve(self.fr, remaining),
-                ParItem::Text(shaped) => position(shaped.build(fonts, justification)),
-                ParItem::Frame(frame) => position(frame.clone()),
-            }
-        }
-
-        output
-    }
-
-    /// The number of spaces in the line.
-    fn spaces(&self) -> usize {
-        self.shapeds().map(ShapedText::spaces).sum()
-    }
-
-    /// Iterate through the line's items in visual order.
-    fn reordered(&self) -> impl Iterator<Item = &ParItem<'a>> {
-        // The bidi crate doesn't like empty lines.
-        let (levels, runs) = if !self.range.is_empty() {
-            // Find the paragraph that contains the line.
-            let para = self
-                .bidi
-                .paragraphs
-                .iter()
-                .find(|para| para.range.contains(&self.range.start))
-                .unwrap();
-
-            // Compute the reordered ranges in visual order (left to right).
-            self.bidi.visual_runs(para, self.range.clone())
-        } else {
-            (vec![], vec![])
-        };
-
-        runs.into_iter()
-            .flat_map(move |run| {
-                let first_idx = self.find(run.start).unwrap();
-                let last_idx = self.find(run.end - 1).unwrap();
-                let range = first_idx ..= last_idx;
-
-                // Provide the items forwards or backwards depending on the run's
-                // direction.
-                if levels[run.start].is_ltr() {
-                    Either::Left(range)
-                } else {
-                    Either::Right(range.rev())
-                }
-            })
-            .map(move |idx| self.get(idx).unwrap())
-    }
-
-    /// Iterate over the line's items.
-    fn items(&self) -> impl Iterator<Item = &ParItem<'a>> {
-        self.first.iter().chain(self.items).chain(&self.last)
-    }
-
-    /// Iterate through the line's text items.
-    fn shapeds(&self) -> impl Iterator<Item = &ShapedText<'a>> {
-        self.items().filter_map(|item| match item {
-            ParItem::Text(shaped) => Some(shaped),
-            _ => None,
-        })
-    }
-
-    /// Find the index of the item whose range contains the `text_offset`.
-    fn find(&self, text_offset: usize) -> Option<usize> {
-        self.ranges.binary_search_by(|r| r.locate(text_offset)).ok()
-    }
-
-    /// Get the item at the index.
-    fn get(&self, index: usize) -> Option<&ParItem<'a>> {
-        self.items().nth(index)
-    }
-}
-
-/// Additional methods for BiDi levels.
-trait LevelExt: Sized {
-    fn from_dir(dir: Dir) -> Option<Self>;
-    fn dir(self) -> Dir;
-}
-
-impl LevelExt for Level {
-    fn from_dir(dir: Dir) -> Option<Self> {
-        match dir {
-            Dir::LTR => Some(Level::ltr()),
-            Dir::RTL => Some(Level::rtl()),
-            _ => None,
-        }
-    }
-
-    fn dir(self) -> Dir {
-        if self.is_ltr() { Dir::LTR } else { Dir::RTL }
-    }
-}
diff --git a/src/library/place.rs b/src/library/place.rs
deleted file mode 100644
index 00e72dfb..00000000
--- a/src/library/place.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-//! Absolute placement of nodes.
-
-use super::prelude::*;
-use super::AlignNode;
-
-/// Place a node at an absolute position.
-#[derive(Debug, Hash)]
-pub struct PlaceNode(pub LayoutNode);
-
-#[class]
-impl PlaceNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let aligns = args.find()?.unwrap_or(Spec::with_x(Some(Align::Left)));
-        let tx = args.named("dx")?.unwrap_or_default();
-        let ty = args.named("dy")?.unwrap_or_default();
-        let body: LayoutNode = args.expect("body")?;
-        Ok(Template::block(Self(
-            body.moved(Point::new(tx, ty)).aligned(aligns),
-        )))
-    }
-}
-
-impl Layout for PlaceNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let out_of_flow = self.out_of_flow();
-
-        // The pod is the base area of the region because for absolute
-        // placement we don't really care about the already used area.
-        let pod = {
-            let finite = regions.base.map(Length::is_finite);
-            let expand = finite & (regions.expand | out_of_flow);
-            Regions::one(regions.base, regions.base, expand)
-        };
-
-        let mut frames = self.0.layout(ctx, &pod, styles)?;
-
-        // If expansion is off, zero all sizes so that we don't take up any
-        // space in our parent. Otherwise, respect the expand settings.
-        let frame = &mut frames[0];
-        let target = regions.expand.select(regions.first, Size::zero());
-        Arc::make_mut(frame).resize(target, Align::LEFT_TOP);
-
-        Ok(frames)
-    }
-}
-
-impl PlaceNode {
-    /// 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.0
-            .downcast::<AlignNode>()
-            .map_or(false, |node| node.aligns.y.is_some())
-    }
-}
diff --git a/src/library/prelude.rs b/src/library/prelude.rs
new file mode 100644
index 00000000..4d13a655
--- /dev/null
+++ b/src/library/prelude.rs
@@ -0,0 +1,20 @@
+//! Helpful imports for creating library functionality.
+
+pub use std::fmt::{self, Debug, Formatter};
+pub use std::hash::Hash;
+pub use std::num::NonZeroUsize;
+pub use std::sync::Arc;
+
+pub use typst_macros::class;
+
+pub use crate::diag::{with_alternative, At, StrResult, TypResult};
+pub use crate::eval::{
+    Arg, Args, Array, Cast, Construct, Dict, Func, Layout, LayoutNode, Merge, Property,
+    Regions, Scope, Set, Show, ShowNode, Smart, StyleChain, StyleMap, StyleVec, Template,
+    Value,
+};
+pub use crate::frame::*;
+pub use crate::geom::*;
+pub use crate::syntax::{Span, Spanned};
+pub use crate::util::{EcoString, OptionExt};
+pub use crate::Context;
diff --git a/src/library/raw.rs b/src/library/raw.rs
deleted file mode 100644
index 785eeac5..00000000
--- a/src/library/raw.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-//! Monospaced text and code.
-
-use once_cell::sync::Lazy;
-use syntect::easy::HighlightLines;
-use syntect::highlighting::{FontStyle, Highlighter, Style, Theme, ThemeSet};
-use syntect::parsing::SyntaxSet;
-
-use super::prelude::*;
-use crate::library::TextNode;
-use crate::source::SourceId;
-use crate::syntax::{self, RedNode};
-
-/// The lazily-loaded theme used for syntax highlighting.
-static THEME: Lazy<Theme> =
-    Lazy::new(|| ThemeSet::load_defaults().themes.remove("InspiredGitHub").unwrap());
-
-/// The lazily-loaded syntect syntax definitions.
-static SYNTAXES: Lazy<SyntaxSet> = Lazy::new(|| SyntaxSet::load_defaults_newlines());
-
-/// Monospaced text with optional syntax highlighting.
-#[derive(Debug, Hash)]
-pub struct RawNode {
-    /// The raw text.
-    pub text: EcoString,
-    /// Whether the node is block-level.
-    pub block: bool,
-}
-
-#[class]
-impl RawNode {
-    /// The language to syntax-highlight in.
-    pub const LANG: Option<EcoString> = None;
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self {
-            text: args.expect("text")?,
-            block: args.named("block")?.unwrap_or(false),
-        }))
-    }
-}
-
-impl Show for RawNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        let lang = styles.get_ref(Self::LANG).as_ref();
-
-        if let Some(template) = styles.show(self, ctx, [
-            Value::Str(self.text.clone()),
-            match lang {
-                Some(lang) => Value::Str(lang.clone()),
-                None => Value::None,
-            },
-            Value::Bool(self.block),
-        ])? {
-            return Ok(template);
-        }
-
-        let foreground = THEME
-            .settings
-            .foreground
-            .map(Color::from)
-            .unwrap_or(Color::BLACK)
-            .into();
-
-        let mut template = if matches!(
-            lang.map(|s| s.to_lowercase()).as_deref(),
-            Some("typ" | "typst")
-        ) {
-            let mut seq = vec![];
-            let green = crate::parse::parse(&self.text);
-            let red = RedNode::from_root(green, SourceId::from_raw(0));
-            let highlighter = Highlighter::new(&THEME);
-
-            syntax::highlight_syntect(red.as_ref(), &highlighter, &mut |range, style| {
-                seq.push(styled(&self.text[range], foreground, style));
-            });
-
-            Template::sequence(seq)
-        } else if let Some(syntax) =
-            lang.and_then(|token| SYNTAXES.find_syntax_by_token(&token))
-        {
-            let mut seq = vec![];
-            let mut highlighter = HighlightLines::new(syntax, &THEME);
-            for (i, line) in self.text.lines().enumerate() {
-                if i != 0 {
-                    seq.push(Template::Linebreak);
-                }
-
-                for (style, piece) in highlighter.highlight(line, &SYNTAXES) {
-                    seq.push(styled(piece, foreground, style));
-                }
-            }
-
-            Template::sequence(seq)
-        } else {
-            Template::Text(self.text.clone())
-        };
-
-        if self.block {
-            template = Template::Block(template.pack());
-        }
-
-        Ok(template.monospaced())
-    }
-}
-
-/// Style a piece of text with a syntect style.
-fn styled(piece: &str, foreground: Paint, style: Style) -> Template {
-    let mut styles = StyleMap::new();
-    let mut body = Template::Text(piece.into());
-
-    let paint = style.foreground.into();
-    if paint != foreground {
-        styles.set(TextNode::FILL, paint);
-    }
-
-    if style.font_style.contains(FontStyle::BOLD) {
-        styles.set(TextNode::STRONG, true);
-    }
-
-    if style.font_style.contains(FontStyle::ITALIC) {
-        styles.set(TextNode::EMPH, true);
-    }
-
-    if style.font_style.contains(FontStyle::UNDERLINE) {
-        body = body.underlined();
-    }
-
-    body.styled_with_map(styles)
-}
diff --git a/src/library/shape.rs b/src/library/shape.rs
deleted file mode 100644
index bf159c52..00000000
--- a/src/library/shape.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-//! Colorable geometrical shapes.
-
-use std::f64::consts::SQRT_2;
-
-use super::prelude::*;
-use super::TextNode;
-
-/// Place a node into a sizable and fillable shape.
-#[derive(Debug, Hash)]
-pub struct ShapeNode<const S: ShapeKind>(pub Option<LayoutNode>);
-
-#[class]
-impl<const S: ShapeKind> ShapeNode<S> {
-    /// How to fill the shape.
-    pub const FILL: Option<Paint> = None;
-    /// How the stroke the shape.
-    pub const STROKE: Smart<Option<Paint>> = Smart::Auto;
-    /// The stroke's thickness.
-    pub const THICKNESS: Length = Length::pt(1.0);
-    /// How much to pad the shape's content.
-    pub const PADDING: Linear = Linear::zero();
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let size = match S {
-            SQUARE => args.named::<Length>("size")?.map(Linear::from),
-            CIRCLE => args.named::<Length>("radius")?.map(|r| 2.0 * Linear::from(r)),
-            _ => None,
-        };
-
-        let width = match size {
-            None => args.named("width")?,
-            size => size,
-        };
-
-        let height = match size {
-            None => args.named("height")?,
-            size => size,
-        };
-
-        Ok(Template::inline(
-            Self(args.find()?).pack().sized(Spec::new(width, height)),
-        ))
-    }
-}
-
-impl<const S: ShapeKind> Layout for ShapeNode<S> {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let mut frames;
-        if let Some(child) = &self.0 {
-            let mut padding = styles.get(Self::PADDING);
-            if is_round(S) {
-                padding.rel += Relative::new(0.5 - SQRT_2 / 4.0);
-            }
-
-            // Pad the child.
-            let child = child.clone().padded(Sides::splat(padding));
-
-            let mut pod = Regions::one(regions.first, regions.base, regions.expand);
-            frames = child.layout(ctx, &pod, styles)?;
-
-            // Relayout with full expansion into square region to make sure
-            // the result is really a square or circle.
-            if is_quadratic(S) {
-                let length = if regions.expand.x || regions.expand.y {
-                    let target = regions.expand.select(regions.first, Size::zero());
-                    target.x.max(target.y)
-                } else {
-                    let size = frames[0].size;
-                    let desired = size.x.max(size.y);
-                    desired.min(regions.first.x).min(regions.first.y)
-                };
-
-                pod.first = Size::splat(length);
-                pod.expand = Spec::splat(true);
-                frames = child.layout(ctx, &pod, styles)?;
-            }
-        } else {
-            // The default size that a shape takes on if it has no child and
-            // enough space.
-            let mut size =
-                Size::new(Length::pt(45.0), Length::pt(30.0)).min(regions.first);
-
-            if is_quadratic(S) {
-                let length = if regions.expand.x || regions.expand.y {
-                    let target = regions.expand.select(regions.first, Size::zero());
-                    target.x.max(target.y)
-                } else {
-                    size.x.min(size.y)
-                };
-                size = Size::splat(length);
-            } else {
-                size = regions.expand.select(regions.first, size);
-            }
-
-            frames = vec![Arc::new(Frame::new(size))];
-        }
-
-        let frame = Arc::make_mut(&mut frames[0]);
-
-        // Add fill and/or stroke.
-        let fill = styles.get(Self::FILL);
-        let thickness = styles.get(Self::THICKNESS);
-        let stroke = styles
-            .get(Self::STROKE)
-            .unwrap_or(fill.is_none().then(|| Color::BLACK.into()))
-            .map(|paint| Stroke { paint, thickness });
-
-        if fill.is_some() || stroke.is_some() {
-            let geometry = if is_round(S) {
-                Geometry::Ellipse(frame.size)
-            } else {
-                Geometry::Rect(frame.size)
-            };
-
-            let shape = Shape { geometry, fill, stroke };
-            frame.prepend(Point::zero(), Element::Shape(shape));
-        }
-
-        // Apply link if it exists.
-        if let Some(url) = styles.get_ref(TextNode::LINK) {
-            frame.link(url);
-        }
-
-        Ok(frames)
-    }
-}
-
-/// A category of shape.
-pub type ShapeKind = usize;
-
-/// A rectangle with equal side lengths.
-pub const SQUARE: ShapeKind = 0;
-
-/// A quadrilateral with four right angles.
-pub const RECT: ShapeKind = 1;
-
-/// An ellipse with coinciding foci.
-pub const CIRCLE: ShapeKind = 2;
-
-/// A curve around two focal points.
-pub const ELLIPSE: ShapeKind = 3;
-
-/// Whether a shape kind is curvy.
-fn is_round(kind: ShapeKind) -> bool {
-    matches!(kind, CIRCLE | ELLIPSE)
-}
-
-/// Whether a shape kind has equal side length.
-fn is_quadratic(kind: ShapeKind) -> bool {
-    matches!(kind, SQUARE | CIRCLE)
-}
diff --git a/src/library/spacing.rs b/src/library/spacing.rs
deleted file mode 100644
index 6f57c71c..00000000
--- a/src/library/spacing.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! Horizontal and vertical spacing between nodes.
-
-use super::prelude::*;
-
-/// Horizontal spacing.
-pub struct HNode;
-
-#[class]
-impl HNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::Horizontal(args.expect("spacing")?))
-    }
-}
-
-/// Vertical spacing.
-pub struct VNode;
-
-#[class]
-impl VNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::Vertical(args.expect("spacing")?))
-    }
-}
-
-/// Kinds of spacing.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum SpacingKind {
-    /// A length stated in absolute values and/or relative to the parent's size.
-    Linear(Linear),
-    /// A length that is the fraction of the remaining free space in the parent.
-    Fractional(Fractional),
-}
-
-impl SpacingKind {
-    /// Whether this is fractional spacing.
-    pub fn is_fractional(self) -> bool {
-        matches!(self, Self::Fractional(_))
-    }
-}
-
-impl From<Length> for SpacingKind {
-    fn from(length: Length) -> Self {
-        Self::Linear(length.into())
-    }
-}
-
-castable! {
-    SpacingKind,
-    Expected: "linear or fractional",
-    Value::Length(v) => Self::Linear(v.into()),
-    Value::Relative(v) => Self::Linear(v.into()),
-    Value::Linear(v) => Self::Linear(v),
-    Value::Fractional(v) => Self::Fractional(v),
-}
diff --git a/src/library/stack.rs b/src/library/stack.rs
deleted file mode 100644
index 8e463f6a..00000000
--- a/src/library/stack.rs
+++ /dev/null
@@ -1,261 +0,0 @@
-//! Side-by-side layout of nodes along an axis.
-
-use super::prelude::*;
-use super::{AlignNode, SpacingKind};
-
-/// Arrange nodes and spacing along an axis.
-#[derive(Debug, Hash)]
-pub struct StackNode {
-    /// The stacking direction.
-    pub dir: Dir,
-    /// The spacing between non-spacing children.
-    pub spacing: Option<SpacingKind>,
-    /// The children to be stacked.
-    pub children: Vec<StackChild>,
-}
-
-#[class]
-impl StackNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::block(Self {
-            dir: args.named("dir")?.unwrap_or(Dir::TTB),
-            spacing: args.named("spacing")?,
-            children: args.all()?,
-        }))
-    }
-}
-
-impl Layout for StackNode {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let mut layouter = StackLayouter::new(self.dir, regions);
-
-        // Spacing to insert before the next node.
-        let mut deferred = None;
-
-        for child in &self.children {
-            match child {
-                StackChild::Spacing(kind) => {
-                    layouter.layout_spacing(*kind);
-                    deferred = None;
-                }
-                StackChild::Node(node) => {
-                    if let Some(kind) = deferred {
-                        layouter.layout_spacing(kind);
-                    }
-
-                    layouter.layout_node(ctx, node, styles)?;
-                    deferred = self.spacing;
-                }
-            }
-        }
-
-        Ok(layouter.finish())
-    }
-}
-
-/// A child of a stack node.
-#[derive(Hash)]
-pub enum StackChild {
-    /// Spacing between other nodes.
-    Spacing(SpacingKind),
-    /// An arbitrary node.
-    Node(LayoutNode),
-}
-
-impl Debug for StackChild {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::Spacing(kind) => kind.fmt(f),
-            Self::Node(node) => node.fmt(f),
-        }
-    }
-}
-
-castable! {
-    StackChild,
-    Expected: "linear, fractional or template",
-    Value::Length(v) => Self::Spacing(SpacingKind::Linear(v.into())),
-    Value::Relative(v) => Self::Spacing(SpacingKind::Linear(v.into())),
-    Value::Linear(v) => Self::Spacing(SpacingKind::Linear(v)),
-    Value::Fractional(v) => Self::Spacing(SpacingKind::Fractional(v)),
-    Value::Template(v) => Self::Node(v.pack()),
-}
-
-/// Performs stack layout.
-pub struct StackLayouter {
-    /// The stacking direction.
-    dir: Dir,
-    /// The axis of the stacking direction.
-    axis: SpecAxis,
-    /// The regions to layout children into.
-    regions: Regions,
-    /// Whether the stack itself should expand to fill the region.
-    expand: Spec<bool>,
-    /// The full size of the current region that was available at the start.
-    full: Size,
-    /// The generic size used by the frames for the current region.
-    used: Gen<Length>,
-    /// The sum of fractional ratios in the current region.
-    fr: Fractional,
-    /// Already layouted items whose exact positions are not yet known due to
-    /// fractional spacing.
-    items: Vec<StackItem>,
-    /// Finished frames for previous regions.
-    finished: Vec<Arc<Frame>>,
-}
-
-/// A prepared item in a stack layout.
-enum StackItem {
-    /// Absolute spacing between other items.
-    Absolute(Length),
-    /// Fractional spacing between other items.
-    Fractional(Fractional),
-    /// A frame for a layouted child node.
-    Frame(Arc<Frame>, Align),
-}
-
-impl StackLayouter {
-    /// Create a new stack layouter.
-    pub fn new(dir: Dir, regions: &Regions) -> Self {
-        let axis = dir.axis();
-        let expand = regions.expand;
-        let full = regions.first;
-
-        // Disable expansion along the block axis for children.
-        let mut regions = regions.clone();
-        regions.expand.set(axis, false);
-
-        Self {
-            dir,
-            axis,
-            regions,
-            expand,
-            full,
-            used: Gen::zero(),
-            fr: Fractional::zero(),
-            items: vec![],
-            finished: vec![],
-        }
-    }
-
-    /// Add spacing along the spacing direction.
-    pub fn layout_spacing(&mut self, spacing: SpacingKind) {
-        match spacing {
-            SpacingKind::Linear(v) => {
-                // Resolve the linear and limit it to the remaining space.
-                let resolved = v.resolve(self.regions.base.get(self.axis));
-                let remaining = self.regions.first.get_mut(self.axis);
-                let limited = resolved.min(*remaining);
-                *remaining -= limited;
-                self.used.main += limited;
-                self.items.push(StackItem::Absolute(resolved));
-            }
-            SpacingKind::Fractional(v) => {
-                self.fr += v;
-                self.items.push(StackItem::Fractional(v));
-            }
-        }
-    }
-
-    /// Layout an arbitrary node.
-    pub fn layout_node(
-        &mut self,
-        ctx: &mut Context,
-        node: &LayoutNode,
-        styles: StyleChain,
-    ) -> TypResult<()> {
-        if self.regions.is_full() {
-            self.finish_region();
-        }
-
-        // Align nodes' block-axis alignment is respected by the stack node.
-        let align = node
-            .downcast::<AlignNode>()
-            .and_then(|node| node.aligns.get(self.axis))
-            .unwrap_or(self.dir.start().into());
-
-        let frames = node.layout(ctx, &self.regions, styles)?;
-        let len = frames.len();
-        for (i, frame) in frames.into_iter().enumerate() {
-            // Grow our size, shrink the region and save the frame for later.
-            let size = frame.size.to_gen(self.axis);
-            self.used.main += size.main;
-            self.used.cross.set_max(size.cross);
-            *self.regions.first.get_mut(self.axis) -= size.main;
-            self.items.push(StackItem::Frame(frame, align));
-
-            if i + 1 < len {
-                self.finish_region();
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Advance to the next region.
-    pub fn finish_region(&mut self) {
-        // Determine the size of the stack in this region dependening on whether
-        // the region expands.
-        let used = self.used.to_spec(self.axis);
-        let mut size = self.expand.select(self.full, used);
-
-        // Expand fully if there are fr spacings.
-        let full = self.full.get(self.axis);
-        let remaining = full - self.used.main;
-        if self.fr.get() > 0.0 && full.is_finite() {
-            self.used.main = full;
-            size.set(self.axis, full);
-        }
-
-        let mut output = Frame::new(size);
-        let mut cursor = Length::zero();
-        let mut ruler: Align = self.dir.start().into();
-
-        // Place all frames.
-        for item in self.items.drain(..) {
-            match item {
-                StackItem::Absolute(v) => cursor += v,
-                StackItem::Fractional(v) => cursor += v.resolve(self.fr, remaining),
-                StackItem::Frame(frame, align) => {
-                    if self.dir.is_positive() {
-                        ruler = ruler.max(align);
-                    } else {
-                        ruler = ruler.min(align);
-                    }
-
-                    // Align along the block axis.
-                    let parent = size.get(self.axis);
-                    let child = frame.size.get(self.axis);
-                    let block = ruler.resolve(parent - self.used.main)
-                        + if self.dir.is_positive() {
-                            cursor
-                        } else {
-                            self.used.main - child - cursor
-                        };
-
-                    let pos = Gen::new(Length::zero(), block).to_point(self.axis);
-                    cursor += child;
-                    output.push_frame(pos, frame);
-                }
-            }
-        }
-
-        // Advance to the next region.
-        self.regions.next();
-        self.full = self.regions.first;
-        self.used = Gen::zero();
-        self.fr = Fractional::zero();
-        self.finished.push(Arc::new(output));
-    }
-
-    /// Finish layouting and return the resulting frames.
-    pub fn finish(mut self) -> Vec<Arc<Frame>> {
-        self.finish_region();
-        self.finished
-    }
-}
diff --git a/src/library/table.rs b/src/library/table.rs
deleted file mode 100644
index 07f28737..00000000
--- a/src/library/table.rs
+++ /dev/null
@@ -1,102 +0,0 @@
-//! Tabular container.
-
-use super::prelude::*;
-use super::{GridNode, TrackSizing};
-
-/// A table of items.
-#[derive(Debug, Hash)]
-pub struct TableNode {
-    /// Defines sizing for content rows and columns.
-    pub tracks: Spec<Vec<TrackSizing>>,
-    /// Defines sizing of gutter rows and columns between content.
-    pub gutter: Spec<Vec<TrackSizing>>,
-    /// The nodes to be arranged in the table.
-    pub children: Vec<Template>,
-}
-
-#[class]
-impl TableNode {
-    /// The primary cell fill color.
-    pub const PRIMARY: Option<Paint> = None;
-    /// The secondary cell fill color.
-    pub const SECONDARY: Option<Paint> = None;
-    /// How the stroke the cells.
-    pub const STROKE: Option<Paint> = Some(Color::BLACK.into());
-    /// The stroke's thickness.
-    pub const THICKNESS: Length = Length::pt(1.0);
-    /// How much to pad the cells's content.
-    pub const PADDING: Linear = Length::pt(5.0).into();
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let columns = args.named("columns")?.unwrap_or_default();
-        let rows = args.named("rows")?.unwrap_or_default();
-        let base_gutter: Vec<TrackSizing> = args.named("gutter")?.unwrap_or_default();
-        let column_gutter = args.named("column-gutter")?;
-        let row_gutter = args.named("row-gutter")?;
-        Ok(Template::show(Self {
-            tracks: Spec::new(columns, rows),
-            gutter: Spec::new(
-                column_gutter.unwrap_or_else(|| base_gutter.clone()),
-                row_gutter.unwrap_or(base_gutter),
-            ),
-            children: args.all()?,
-        }))
-    }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        let fill = args.named("fill")?;
-        styles.set_opt(Self::PRIMARY, args.named("primary")?.or(fill));
-        styles.set_opt(Self::SECONDARY, args.named("secondary")?.or(fill));
-        styles.set_opt(Self::STROKE, args.named("stroke")?);
-        styles.set_opt(Self::THICKNESS, args.named("thickness")?);
-        styles.set_opt(Self::PADDING, args.named("padding")?);
-        Ok(())
-    }
-}
-
-impl Show for TableNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        if let Some(template) = styles.show(
-            self,
-            ctx,
-            self.children.iter().map(|child| Value::Template(child.clone())),
-        )? {
-            return Ok(template);
-        }
-
-        let primary = styles.get(Self::PRIMARY);
-        let secondary = styles.get(Self::SECONDARY);
-        let thickness = styles.get(Self::THICKNESS);
-        let stroke = styles.get(Self::STROKE).map(|paint| Stroke { paint, thickness });
-        let padding = styles.get(Self::PADDING);
-
-        let cols = self.tracks.x.len().max(1);
-        let children = self
-            .children
-            .iter()
-            .cloned()
-            .enumerate()
-            .map(|(i, child)| {
-                let mut child = child.pack().padded(Sides::splat(padding));
-
-                if let Some(stroke) = stroke {
-                    child = child.stroked(stroke);
-                }
-
-                let x = i % cols;
-                let y = i / cols;
-                if let Some(fill) = [primary, secondary][(x + y) % 2] {
-                    child = child.filled(fill);
-                }
-
-                child
-            })
-            .collect();
-
-        Ok(Template::block(GridNode {
-            tracks: self.tracks.clone(),
-            gutter: self.gutter.clone(),
-            children,
-        }))
-    }
-}
diff --git a/src/library/text.rs b/src/library/text.rs
deleted file mode 100644
index b76b60ee..00000000
--- a/src/library/text.rs
+++ /dev/null
@@ -1,1114 +0,0 @@
-//! Text shaping and styling.
-
-use std::borrow::Cow;
-use std::fmt::{self, Debug, Formatter};
-use std::ops::{BitXor, Range};
-
-use kurbo::{BezPath, Line, ParamCurve};
-use rustybuzz::{Feature, UnicodeBuffer};
-use ttf_parser::{GlyphId, OutlineBuilder, Tag};
-
-use super::prelude::*;
-use super::Decoration;
-use crate::font::{
-    Face, FaceId, FontStore, FontStretch, FontStyle, FontVariant, FontWeight,
-    VerticalFontMetric,
-};
-use crate::geom::{Dir, Em, Length, Point, Size};
-use crate::util::{EcoString, SliceExt};
-
-/// A single run of text with the same style.
-#[derive(Hash)]
-pub struct TextNode;
-
-#[class]
-impl TextNode {
-    /// A prioritized sequence of font families.
-    #[variadic]
-    pub const FAMILY: Vec<FontFamily> = vec![FontFamily::SansSerif];
-    /// The serif font family/families.
-    pub const SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Serif")];
-    /// The sans-serif font family/families.
-    pub const SANS_SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Sans")];
-    /// The monospace font family/families.
-    pub const MONOSPACE: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Mono")];
-    /// Whether to allow font fallback when the primary font list contains no
-    /// match.
-    pub const FALLBACK: bool = true;
-
-    /// How the font is styled.
-    pub const STYLE: FontStyle = FontStyle::Normal;
-    /// The boldness / thickness of the font's glyphs.
-    pub const WEIGHT: FontWeight = FontWeight::REGULAR;
-    /// The width of the glyphs.
-    pub const STRETCH: FontStretch = FontStretch::NORMAL;
-    /// The glyph fill color.
-    #[shorthand]
-    pub const FILL: Paint = Color::BLACK.into();
-
-    /// The size of the glyphs.
-    #[shorthand]
-    #[fold(Linear::compose)]
-    pub const SIZE: Linear = Length::pt(11.0).into();
-    /// The amount of space that should be added between characters.
-    pub const TRACKING: Em = Em::zero();
-    /// The top end of the text bounding box.
-    pub const TOP_EDGE: VerticalFontMetric = VerticalFontMetric::CapHeight;
-    /// The bottom end of the text bounding box.
-    pub const BOTTOM_EDGE: VerticalFontMetric = VerticalFontMetric::Baseline;
-
-    /// Whether to apply kerning ("kern").
-    pub const KERNING: bool = true;
-    /// Whether small capital glyphs should be used. ("smcp")
-    pub const SMALLCAPS: bool = false;
-    /// Whether to apply stylistic alternates. ("salt")
-    pub const ALTERNATES: bool = false;
-    /// Which stylistic set to apply. ("ss01" - "ss20")
-    pub const STYLISTIC_SET: Option<StylisticSet> = None;
-    /// Whether standard ligatures are active. ("liga", "clig")
-    pub const LIGATURES: bool = true;
-    /// Whether ligatures that should be used sparingly are active. ("dlig")
-    pub const DISCRETIONARY_LIGATURES: bool = false;
-    /// Whether historical ligatures are active. ("hlig")
-    pub const HISTORICAL_LIGATURES: bool = false;
-    /// Which kind of numbers / figures to select.
-    pub const NUMBER_TYPE: Smart<NumberType> = Smart::Auto;
-    /// The width of numbers / figures.
-    pub const NUMBER_WIDTH: Smart<NumberWidth> = Smart::Auto;
-    /// How to position numbers.
-    pub const NUMBER_POSITION: NumberPosition = NumberPosition::Normal;
-    /// Whether to have a slash through the zero glyph. ("zero")
-    pub const SLASHED_ZERO: bool = false;
-    /// Whether to convert fractions. ("frac")
-    pub const FRACTIONS: bool = false;
-    /// Raw OpenType features to apply.
-    pub const FEATURES: Vec<(Tag, u32)> = vec![];
-
-    /// Whether the font weight should be increased by 300.
-    #[skip]
-    #[fold(bool::bitxor)]
-    pub const STRONG: bool = false;
-    /// Whether the the font style should be inverted.
-    #[skip]
-    #[fold(bool::bitxor)]
-    pub const EMPH: bool = false;
-    /// Whether a monospace font should be preferred.
-    #[skip]
-    pub const MONOSPACED: bool = false;
-    /// The case transformation that should be applied to the next.
-    #[skip]
-    pub const CASE: Option<Case> = None;
-    /// Decorative lines.
-    #[skip]
-    #[fold(|a, b| a.into_iter().chain(b).collect())]
-    pub const LINES: Vec<Decoration> = vec![];
-    /// An URL the text should link to.
-    #[skip]
-    pub const LINK: Option<EcoString> = None;
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        // The text constructor is special: It doesn't create a text node.
-        // Instead, it leaves the passed argument structurally unchanged, but
-        // styles all text in it.
-        args.expect("body")
-    }
-}
-
-/// Strong text, rendered in boldface.
-#[derive(Debug, Hash)]
-pub struct StrongNode(pub Template);
-
-#[class]
-impl StrongNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self(args.expect("body")?)))
-    }
-}
-
-impl Show for StrongNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        Ok(styles
-            .show(self, ctx, [Value::Template(self.0.clone())])?
-            .unwrap_or_else(|| self.0.clone().styled(TextNode::STRONG, true)))
-    }
-}
-
-/// Emphasized text, rendered with an italic face.
-#[derive(Debug, Hash)]
-pub struct EmphNode(pub Template);
-
-#[class]
-impl EmphNode {
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::show(Self(args.expect("body")?)))
-    }
-}
-
-impl Show for EmphNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
-        Ok(styles
-            .show(self, ctx, [Value::Template(self.0.clone())])?
-            .unwrap_or_else(|| self.0.clone().styled(TextNode::EMPH, true)))
-    }
-}
-
-/// 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 font family like "Arial".
-    Named(NamedFamily),
-}
-
-impl Debug for FontFamily {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::Serif => f.pad("serif"),
-            Self::SansSerif => f.pad("sans-serif"),
-            Self::Monospace => f.pad("monospace"),
-            Self::Named(s) => s.fmt(f),
-        }
-    }
-}
-
-dynamic! {
-    FontFamily: "font family",
-    Value::Str(string) => Self::Named(NamedFamily::new(&string)),
-}
-
-castable! {
-    Vec<FontFamily>,
-    Expected: "string, generic family or array thereof",
-    Value::Str(string) => vec![FontFamily::Named(NamedFamily::new(&string))],
-    Value::Array(values) => {
-        values.into_iter().filter_map(|v| v.cast().ok()).collect()
-    },
-    @family: FontFamily => vec![family.clone()],
-}
-
-/// A specific font family like "Arial".
-#[derive(Clone, Eq, PartialEq, Hash)]
-pub struct NamedFamily(EcoString);
-
-impl NamedFamily {
-    /// Create a named font family variant.
-    pub fn new(string: &str) -> Self {
-        Self(string.to_lowercase().into())
-    }
-
-    /// The lowercased family name.
-    pub fn as_str(&self) -> &str {
-        &self.0
-    }
-}
-
-impl Debug for NamedFamily {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-castable! {
-    Vec<NamedFamily>,
-    Expected: "string or array of strings",
-    Value::Str(string) => vec![NamedFamily::new(&string)],
-    Value::Array(values) => values
-        .into_iter()
-        .filter_map(|v| v.cast().ok())
-        .map(|string: EcoString| NamedFamily::new(&string))
-        .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) => Value::Int(v)
-        .cast::<usize>()?
-        .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! {
-    Em,
-    Expected: "float",
-    Value::Float(v) => Self::new(v),
-}
-
-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(),
-}
-
-/// A case transformation on text.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum Case {
-    /// Everything is uppercased.
-    Upper,
-    /// Everything is lowercased.
-    Lower,
-}
-
-impl Case {
-    /// Apply the case to a string of text.
-    pub fn apply(self, text: &str) -> String {
-        match self {
-            Self::Upper => text.to_uppercase(),
-            Self::Lower => text.to_lowercase(),
-        }
-    }
-}
-
-/// 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: Cow<'a, str>,
-    /// The text direction.
-    pub dir: Dir,
-    /// The text's style properties.
-    pub styles: StyleChain<'a>,
-    /// The size of the text's bounding box.
-    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,
-    /// Whether this glyph represents a space.
-    pub is_space: bool,
-}
-
-/// A visual side.
-enum Side {
-    Left,
-    Right,
-}
-
-impl<'a> ShapedText<'a> {
-    /// Build the shaped text's frame.
-    ///
-    /// The `justification` defines how much extra advance width each
-    /// [space glyph](ShapedGlyph::is_space) will get.
-    pub fn build(&self, fonts: &FontStore, justification: Length) -> 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 size = self.styles.get(TextNode::SIZE).abs;
-            let fill = self.styles.get(TextNode::FILL);
-            let glyphs = group
-                .iter()
-                .map(|glyph| Glyph {
-                    id: glyph.glyph_id,
-                    x_advance: glyph.x_advance
-                        + if glyph.is_space {
-                            frame.size.x += justification;
-                            Em::from_length(justification, size)
-                        } else {
-                            Em::zero()
-                        },
-                    x_offset: glyph.x_offset,
-                })
-                .collect();
-
-            let text = Text { face_id, size, fill, glyphs };
-            let text_layer = frame.layer();
-            let width = text.width();
-
-            // Apply line decorations.
-            for deco in self.styles.get_cloned(TextNode::LINES) {
-                decorate(&mut frame, &deco, fonts, &text, pos, width);
-            }
-
-            frame.insert(text_layer, pos, Element::Text(text));
-            offset += width;
-        }
-
-        // Apply link if it exists.
-        if let Some(url) = self.styles.get_ref(TextNode::LINK) {
-            frame.link(url);
-        }
-
-        frame
-    }
-
-    /// How many spaces the text contains.
-    pub fn spaces(&self) -> usize {
-        self.glyphs.iter().filter(|g| g.is_space).count()
-    }
-
-    /// Reshape a range of the shaped text, reusing information from this
-    /// shaping process if possible.
-    pub fn reshape(
-        &'a self,
-        fonts: &mut FontStore,
-        text_range: Range<usize>,
-    ) -> ShapedText<'a> {
-        if let Some(glyphs) = self.slice_safe_to_break(text_range.clone()) {
-            let (size, baseline) = measure(fonts, glyphs, self.styles);
-            Self {
-                text: Cow::Borrowed(&self.text[text_range]),
-                dir: self.dir,
-                styles: self.styles.clone(),
-                size,
-                baseline,
-                glyphs: Cow::Borrowed(glyphs),
-            }
-        } else {
-            shape(fonts, &self.text[text_range], self.styles.clone(), 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)
-    }
-}
-
-/// Shape text into [`ShapedText`].
-pub fn shape<'a>(
-    fonts: &mut FontStore,
-    text: &'a str,
-    styles: StyleChain<'a>,
-    dir: Dir,
-) -> ShapedText<'a> {
-    let text = match styles.get(TextNode::CASE) {
-        Some(case) => Cow::Owned(case.apply(text)),
-        None => Cow::Borrowed(text),
-    };
-
-    let mut glyphs = vec![];
-    if !text.is_empty() {
-        shape_segment(
-            fonts,
-            &mut glyphs,
-            0,
-            &text,
-            variant(styles),
-            families(styles),
-            None,
-            dir,
-            &tags(styles),
-        );
-    }
-
-    track(&mut glyphs, styles.get(TextNode::TRACKING));
-    let (size, baseline) = measure(fonts, &glyphs, styles);
-
-    ShapedText {
-        text,
-        dir,
-        styles,
-        size,
-        baseline,
-        glyphs: Cow::Owned(glyphs),
-    }
-}
-
-/// Resolve the font variant with `STRONG` and `EMPH` factored in.
-fn variant(styles: StyleChain) -> 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: StyleChain) -> impl Iterator<Item = &str> + Clone {
-    let head = if styles.get(TextNode::MONOSPACED) {
-        styles.get_ref(TextNode::MONOSPACE).as_slice()
-    } else {
-        &[]
-    };
-
-    let core = styles.get_ref(TextNode::FAMILY).iter().flat_map(move |family| {
-        match family {
-            FontFamily::Named(name) => std::slice::from_ref(name),
-            FontFamily::Serif => styles.get_ref(TextNode::SERIF),
-            FontFamily::SansSerif => styles.get_ref(TextNode::SANS_SERIF),
-            FontFamily::Monospace => styles.get_ref(TextNode::MONOSPACE),
-        }
-    });
-
-    let tail: &[&str] = if styles.get(TextNode::FALLBACK) {
-        &["ibm plex sans", "latin modern math", "twitter color emoji"]
-    } else {
-        &[]
-    };
-
-    head.iter()
-        .chain(core)
-        .map(|named| named.as_str())
-        .chain(tail.iter().copied())
-}
-
-/// Collect the tags of the OpenType features to apply.
-fn tags(styles: StyleChain) -> 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 !styles.get(TextNode::KERNING) {
-        feat(b"kern", 0);
-    }
-
-    // Features that are off by default in Harfbuzz are only added if enabled.
-    if styles.get(TextNode::SMALLCAPS) {
-        feat(b"smcp", 1);
-    }
-
-    if styles.get(TextNode::ALTERNATES) {
-        feat(b"salt", 1);
-    }
-
-    let storage;
-    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 !styles.get(TextNode::LIGATURES) {
-        feat(b"liga", 0);
-        feat(b"clig", 0);
-    }
-
-    if styles.get(TextNode::DISCRETIONARY_LIGATURES) {
-        feat(b"dlig", 1);
-    }
-
-    if styles.get(TextNode::HISTORICAL_LIGATURES) {
-        feat(b"hilg", 1);
-    }
-
-    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 styles.get(TextNode::NUMBER_WIDTH) {
-        Smart::Auto => {}
-        Smart::Custom(NumberWidth::Proportional) => feat(b"pnum", 1),
-        Smart::Custom(NumberWidth::Tabular) => feat(b"tnum", 1),
-    }
-
-    match styles.get(TextNode::NUMBER_POSITION) {
-        NumberPosition::Normal => {}
-        NumberPosition::Subscript => feat(b"subs", 1),
-        NumberPosition::Superscript => feat(b"sups", 1),
-    }
-
-    if styles.get(TextNode::SLASHED_ZERO) {
-        feat(b"zero", 1);
-    }
-
-    if styles.get(TextNode::FRACTIONS) {
-        feat(b"frac", 1);
-    }
-
-    for &(tag, value) in styles.get_ref(TextNode::FEATURES).iter() {
-        tags.push(Feature::new(tag, value, ..))
-    }
-
-    tags
-}
-
-/// Shape text with font fallback using the `families` iterator.
-fn shape_segment<'a>(
-    fonts: &mut FontStore,
-    glyphs: &mut Vec<ShapedGlyph>,
-    base: usize,
-    text: &str,
-    variant: FontVariant,
-    mut families: impl Iterator<Item = &'a str> + Clone,
-    mut first_face: Option<FaceId>,
-    dir: Dir,
-    tags: &[rustybuzz::Feature],
-) {
-    // No font has newlines.
-    if text.chars().all(|c| c == '\n') {
-        return;
-    }
-
-    // Select the font family.
-    let (face_id, fallback) = loop {
-        // Try to load the next available font family.
-        match families.next() {
-            Some(family) => {
-                if let Some(id) = fonts.select(family, variant) {
-                    break (id, true);
-                }
-            }
-            // We're out of families, so we don't do any more fallback and just
-            // shape the tofus with the first face we originally used.
-            None => match first_face {
-                Some(id) => break (id, false),
-                None => return,
-            },
-        }
-    };
-
-    // Remember the id if this the first available face since we use that one to
-    // shape tofus.
-    first_face.get_or_insert(face_id);
-
-    // Fill the buffer with our text.
-    let mut buffer = UnicodeBuffer::new();
-    buffer.push_str(text);
-    buffer.set_direction(match dir {
-        Dir::LTR => rustybuzz::Direction::LeftToRight,
-        Dir::RTL => rustybuzz::Direction::RightToLeft,
-        _ => unimplemented!(),
-    });
-
-    // Shape!
-    let mut face = fonts.get(face_id);
-    let buffer = rustybuzz::shape(face.ttf(), tags, buffer);
-    let infos = buffer.glyph_infos();
-    let pos = buffer.glyph_positions();
-
-    // Collect the shaped glyphs, doing fallback and shaping parts again with
-    // the next font if necessary.
-    let mut i = 0;
-    while i < infos.len() {
-        let info = &infos[i];
-        let cluster = info.cluster as usize;
-
-        if info.glyph_id != 0 || !fallback {
-            // Add the glyph to the shaped output.
-            // TODO: Don't ignore y_advance and y_offset.
-            glyphs.push(ShapedGlyph {
-                face_id,
-                glyph_id: info.glyph_id as u16,
-                x_advance: face.to_em(pos[i].x_advance),
-                x_offset: face.to_em(pos[i].x_offset),
-                text_index: base + cluster,
-                safe_to_break: !info.unsafe_to_break(),
-                is_space: text[cluster ..].chars().next() == Some(' '),
-            });
-        } else {
-            // Determine the source text range for the tofu sequence.
-            let range = {
-                // First, search for the end of the tofu sequence.
-                let k = i;
-                while infos.get(i + 1).map_or(false, |info| info.glyph_id == 0) {
-                    i += 1;
-                }
-
-                // Then, determine the start and end text index.
-                //
-                // Examples:
-                // Everything is shown in visual order. Tofus are written as "_".
-                // We want to find out that the tofus span the text `2..6`.
-                // Note that the clusters are longer than 1 char.
-                //
-                // Left-to-right:
-                // Text:     h a l i h a l l o
-                // Glyphs:   A   _   _   C   E
-                // Clusters: 0   2   4   6   8
-                //              k=1 i=2
-                //
-                // Right-to-left:
-                // Text:     O L L A H I L A H
-                // Glyphs:   E   C   _   _   A
-                // Clusters: 8   6   4   2   0
-                //                  k=2 i=3
-                let ltr = dir.is_positive();
-                let first = if ltr { k } else { i };
-                let start = infos[first].cluster as usize;
-                let last = if ltr { i.checked_add(1) } else { k.checked_sub(1) };
-                let end = last
-                    .and_then(|last| infos.get(last))
-                    .map_or(text.len(), |info| info.cluster as usize);
-
-                start .. end
-            };
-
-            // Recursively shape the tofu sequence with the next family.
-            shape_segment(
-                fonts,
-                glyphs,
-                base + range.start,
-                &text[range],
-                variant,
-                families.clone(),
-                first_face,
-                dir,
-                tags,
-            );
-
-            face = fonts.get(face_id);
-        }
-
-        i += 1;
-    }
-}
-
-/// Apply tracking to a slice of shaped glyphs.
-fn track(glyphs: &mut [ShapedGlyph], tracking: Em) {
-    if tracking.is_zero() {
-        return;
-    }
-
-    let mut glyphs = glyphs.iter_mut().peekable();
-    while let Some(glyph) = glyphs.next() {
-        if glyphs
-            .peek()
-            .map_or(false, |next| glyph.text_index != next.text_index)
-        {
-            glyph.x_advance += tracking;
-        }
-    }
-}
-
-/// Measure the size and baseline of a run of shaped glyphs with the given
-/// properties.
-fn measure(
-    fonts: &mut FontStore,
-    glyphs: &[ShapedGlyph],
-    styles: StyleChain,
-) -> (Size, Length) {
-    let mut width = Length::zero();
-    let mut top = Length::zero();
-    let mut bottom = Length::zero();
-
-    let size = styles.get(TextNode::SIZE).abs;
-    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(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 families(styles) {
-            if let Some(face_id) = fonts.select(family, variant(styles)) {
-                expand(fonts.get(face_id));
-                break;
-            }
-        }
-    } else {
-        for (face_id, group) in glyphs.group_by_key(|g| g.face_id) {
-            let face = fonts.get(face_id);
-            expand(face);
-
-            for glyph in group {
-                width += glyph.x_advance.resolve(size);
-            }
-        }
-    }
-
-    (Size::new(width, top + bottom), top)
-}
-
-/// Add line decorations to a single run of shaped text.
-fn decorate(
-    frame: &mut Frame,
-    deco: &Decoration,
-    fonts: &FontStore,
-    text: &Text,
-    pos: Point,
-    width: Length,
-) {
-    let face = fonts.get(text.face_id);
-    let metrics = match deco.line {
-        super::STRIKETHROUGH => face.strikethrough,
-        super::OVERLINE => face.overline,
-        super::UNDERLINE | _ => face.underline,
-    };
-
-    let evade = deco.evade && deco.line != super::STRIKETHROUGH;
-    let extent = deco.extent.resolve(text.size);
-    let offset = deco
-        .offset
-        .map(|s| s.resolve(text.size))
-        .unwrap_or(-metrics.position.resolve(text.size));
-
-    let stroke = Stroke {
-        paint: deco.stroke.unwrap_or(text.fill),
-        thickness: deco
-            .thickness
-            .map(|s| s.resolve(text.size))
-            .unwrap_or(metrics.thickness.resolve(text.size)),
-    };
-
-    let gap_padding = 0.08 * text.size;
-    let min_width = 0.162 * text.size;
-
-    let mut start = pos.x - extent;
-    let end = pos.x + (width + 2.0 * extent);
-
-    let mut push_segment = |from: Length, to: Length| {
-        let origin = Point::new(from, pos.y + offset);
-        let target = Point::new(to - from, Length::zero());
-
-        if target.x >= min_width || !evade {
-            let shape = Shape::stroked(Geometry::Line(target), stroke);
-            frame.push(origin, Element::Shape(shape));
-        }
-    };
-
-    if !evade {
-        push_segment(start, end);
-        return;
-    }
-
-    let line = Line::new(
-        kurbo::Point::new(pos.x.to_raw(), offset.to_raw()),
-        kurbo::Point::new((pos.x + width).to_raw(), offset.to_raw()),
-    );
-
-    let mut x = pos.x;
-    let mut intersections = vec![];
-
-    for glyph in text.glyphs.iter() {
-        let dx = glyph.x_offset.resolve(text.size) + x;
-        let mut builder = BezPathBuilder::new(face.units_per_em, text.size, dx.to_raw());
-
-        let bbox = face.ttf().outline_glyph(GlyphId(glyph.id), &mut builder);
-        let path = builder.finish();
-
-        x += glyph.x_advance.resolve(text.size);
-
-        // Only do the costly segments intersection test if the line
-        // intersects the bounding box.
-        if bbox.map_or(false, |bbox| {
-            let y_min = -face.to_em(bbox.y_max).resolve(text.size);
-            let y_max = -face.to_em(bbox.y_min).resolve(text.size);
-
-            offset >= y_min && offset <= y_max
-        }) {
-            // Find all intersections of segments with the line.
-            intersections.extend(
-                path.segments()
-                    .flat_map(|seg| seg.intersect_line(line))
-                    .map(|is| Length::raw(line.eval(is.line_t).x)),
-            );
-        }
-    }
-
-    // When emitting the decorative line segments, we move from left to
-    // right. The intersections are not necessarily in this order, yet.
-    intersections.sort();
-
-    for gap in intersections.chunks_exact(2) {
-        let l = gap[0] - gap_padding;
-        let r = gap[1] + gap_padding;
-
-        if start >= end {
-            break;
-        }
-
-        if start >= l {
-            start = r;
-            continue;
-        }
-
-        push_segment(start, l);
-        start = r;
-    }
-
-    if start < end {
-        push_segment(start, end);
-    }
-}
-
-/// Builds a kurbo [`BezPath`] for a glyph.
-struct BezPathBuilder {
-    path: BezPath,
-    units_per_em: f64,
-    font_size: Length,
-    x_offset: f64,
-}
-
-impl BezPathBuilder {
-    fn new(units_per_em: f64, font_size: Length, x_offset: f64) -> Self {
-        Self {
-            path: BezPath::new(),
-            units_per_em,
-            font_size,
-            x_offset,
-        }
-    }
-
-    fn finish(self) -> BezPath {
-        self.path
-    }
-
-    fn p(&self, x: f32, y: f32) -> kurbo::Point {
-        kurbo::Point::new(self.s(x) + self.x_offset, -self.s(y))
-    }
-
-    fn s(&self, v: f32) -> f64 {
-        Em::from_units(v, self.units_per_em).resolve(self.font_size).to_raw()
-    }
-}
-
-impl OutlineBuilder for BezPathBuilder {
-    fn move_to(&mut self, x: f32, y: f32) {
-        self.path.move_to(self.p(x, y));
-    }
-
-    fn line_to(&mut self, x: f32, y: f32) {
-        self.path.line_to(self.p(x, y));
-    }
-
-    fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
-        self.path.quad_to(self.p(x1, y1), self.p(x, y));
-    }
-
-    fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
-        self.path.curve_to(self.p(x1, y1), self.p(x2, y2), self.p(x, y));
-    }
-
-    fn close(&mut self) {
-        self.path.close_path();
-    }
-}
diff --git a/src/library/text/deco.rs b/src/library/text/deco.rs
new file mode 100644
index 00000000..a288c995
--- /dev/null
+++ b/src/library/text/deco.rs
@@ -0,0 +1,250 @@
+use kurbo::{BezPath, Line, ParamCurve};
+use ttf_parser::{GlyphId, OutlineBuilder};
+
+use super::TextNode;
+use crate::font::FontStore;
+use crate::library::prelude::*;
+
+/// Typeset underline, stricken-through or overlined text.
+#[derive(Debug, Hash)]
+pub struct DecoNode<const L: DecoLine>(pub Template);
+
+/// Typeset underlined text.
+pub type UnderlineNode = DecoNode<UNDERLINE>;
+
+/// Typeset stricken-through text.
+pub type StrikethroughNode = DecoNode<STRIKETHROUGH>;
+
+/// Typeset overlined text.
+pub type OverlineNode = DecoNode<OVERLINE>;
+
+#[class]
+impl<const L: DecoLine> DecoNode<L> {
+    /// Stroke color of the line, defaults to the text color if `None`.
+    #[shorthand]
+    pub const STROKE: Option<Paint> = None;
+    /// Thickness of the line's strokes (dependent on scaled font size), read
+    /// from the font tables if `None`.
+    #[shorthand]
+    pub const THICKNESS: Option<Linear> = None;
+    /// Position of the line relative to the baseline (dependent on scaled font
+    /// size), read from the font tables if `None`.
+    pub const OFFSET: Option<Linear> = None;
+    /// Amount that the line will be longer or shorter than its associated text
+    /// (dependent on scaled font size).
+    pub const EXTENT: Linear = Linear::zero();
+    /// Whether the line skips sections in which it would collide
+    /// with the glyphs. Does not apply to strikethrough.
+    pub const EVADE: bool = true;
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self(args.expect::<Template>("body")?)))
+    }
+}
+
+impl<const L: DecoLine> Show for DecoNode<L> {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, ctx, [Value::Template(self.0.clone())])?
+            .unwrap_or_else(|| {
+                self.0.clone().styled(TextNode::LINES, vec![Decoration {
+                    line: L,
+                    stroke: styles.get(Self::STROKE),
+                    thickness: styles.get(Self::THICKNESS),
+                    offset: styles.get(Self::OFFSET),
+                    extent: styles.get(Self::EXTENT),
+                    evade: styles.get(Self::EVADE),
+                }])
+            }))
+    }
+}
+
+/// Defines a line that is positioned over, under or on top of text.
+///
+/// For more details, see [`DecoNode`].
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Decoration {
+    pub line: DecoLine,
+    pub stroke: Option<Paint>,
+    pub thickness: Option<Linear>,
+    pub offset: Option<Linear>,
+    pub extent: Linear,
+    pub evade: bool,
+}
+
+/// A kind of decorative line.
+pub type DecoLine = usize;
+
+/// A line under text.
+pub const UNDERLINE: DecoLine = 0;
+
+/// A line through text.
+pub const STRIKETHROUGH: DecoLine = 1;
+
+/// A line over text.
+pub const OVERLINE: DecoLine = 2;
+
+/// Add line decorations to a single run of shaped text.
+pub fn decorate(
+    frame: &mut Frame,
+    deco: &Decoration,
+    fonts: &FontStore,
+    text: &Text,
+    pos: Point,
+    width: Length,
+) {
+    let face = fonts.get(text.face_id);
+    let metrics = match deco.line {
+        STRIKETHROUGH => face.strikethrough,
+        OVERLINE => face.overline,
+        UNDERLINE | _ => face.underline,
+    };
+
+    let evade = deco.evade && deco.line != STRIKETHROUGH;
+    let extent = deco.extent.resolve(text.size);
+    let offset = deco
+        .offset
+        .map(|s| s.resolve(text.size))
+        .unwrap_or(-metrics.position.resolve(text.size));
+
+    let stroke = Stroke {
+        paint: deco.stroke.unwrap_or(text.fill),
+        thickness: deco
+            .thickness
+            .map(|s| s.resolve(text.size))
+            .unwrap_or(metrics.thickness.resolve(text.size)),
+    };
+
+    let gap_padding = 0.08 * text.size;
+    let min_width = 0.162 * text.size;
+
+    let mut start = pos.x - extent;
+    let end = pos.x + (width + 2.0 * extent);
+
+    let mut push_segment = |from: Length, to: Length| {
+        let origin = Point::new(from, pos.y + offset);
+        let target = Point::new(to - from, Length::zero());
+
+        if target.x >= min_width || !evade {
+            let shape = Shape::stroked(Geometry::Line(target), stroke);
+            frame.push(origin, Element::Shape(shape));
+        }
+    };
+
+    if !evade {
+        push_segment(start, end);
+        return;
+    }
+
+    let line = Line::new(
+        kurbo::Point::new(pos.x.to_raw(), offset.to_raw()),
+        kurbo::Point::new((pos.x + width).to_raw(), offset.to_raw()),
+    );
+
+    let mut x = pos.x;
+    let mut intersections = vec![];
+
+    for glyph in text.glyphs.iter() {
+        let dx = glyph.x_offset.resolve(text.size) + x;
+        let mut builder = BezPathBuilder::new(face.units_per_em, text.size, dx.to_raw());
+
+        let bbox = face.ttf().outline_glyph(GlyphId(glyph.id), &mut builder);
+        let path = builder.finish();
+
+        x += glyph.x_advance.resolve(text.size);
+
+        // Only do the costly segments intersection test if the line
+        // intersects the bounding box.
+        if bbox.map_or(false, |bbox| {
+            let y_min = -face.to_em(bbox.y_max).resolve(text.size);
+            let y_max = -face.to_em(bbox.y_min).resolve(text.size);
+
+            offset >= y_min && offset <= y_max
+        }) {
+            // Find all intersections of segments with the line.
+            intersections.extend(
+                path.segments()
+                    .flat_map(|seg| seg.intersect_line(line))
+                    .map(|is| Length::raw(line.eval(is.line_t).x)),
+            );
+        }
+    }
+
+    // When emitting the decorative line segments, we move from left to
+    // right. The intersections are not necessarily in this order, yet.
+    intersections.sort();
+
+    for gap in intersections.chunks_exact(2) {
+        let l = gap[0] - gap_padding;
+        let r = gap[1] + gap_padding;
+
+        if start >= end {
+            break;
+        }
+
+        if start >= l {
+            start = r;
+            continue;
+        }
+
+        push_segment(start, l);
+        start = r;
+    }
+
+    if start < end {
+        push_segment(start, end);
+    }
+}
+
+/// Builds a kurbo [`BezPath`] for a glyph.
+struct BezPathBuilder {
+    path: BezPath,
+    units_per_em: f64,
+    font_size: Length,
+    x_offset: f64,
+}
+
+impl BezPathBuilder {
+    fn new(units_per_em: f64, font_size: Length, x_offset: f64) -> Self {
+        Self {
+            path: BezPath::new(),
+            units_per_em,
+            font_size,
+            x_offset,
+        }
+    }
+
+    fn finish(self) -> BezPath {
+        self.path
+    }
+
+    fn p(&self, x: f32, y: f32) -> kurbo::Point {
+        kurbo::Point::new(self.s(x) + self.x_offset, -self.s(y))
+    }
+
+    fn s(&self, v: f32) -> f64 {
+        Em::from_units(v, self.units_per_em).resolve(self.font_size).to_raw()
+    }
+}
+
+impl OutlineBuilder for BezPathBuilder {
+    fn move_to(&mut self, x: f32, y: f32) {
+        self.path.move_to(self.p(x, y));
+    }
+
+    fn line_to(&mut self, x: f32, y: f32) {
+        self.path.line_to(self.p(x, y));
+    }
+
+    fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
+        self.path.quad_to(self.p(x1, y1), self.p(x, y));
+    }
+
+    fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
+        self.path.curve_to(self.p(x1, y1), self.p(x2, y2), self.p(x, y));
+    }
+
+    fn close(&mut self) {
+        self.path.close_path();
+    }
+}
diff --git a/src/library/text/link.rs b/src/library/text/link.rs
new file mode 100644
index 00000000..29f41927
--- /dev/null
+++ b/src/library/text/link.rs
@@ -0,0 +1,64 @@
+use super::TextNode;
+use crate::library::prelude::*;
+use crate::util::EcoString;
+
+/// Link text and other elements to an URL.
+#[derive(Debug, Hash)]
+pub struct LinkNode {
+    /// The url the link points to.
+    pub url: EcoString,
+    /// How the link is represented.
+    pub body: Option<Template>,
+}
+
+#[class]
+impl LinkNode {
+    /// The fill color of text in the link. Just the surrounding text color
+    /// if `auto`.
+    pub const FILL: Smart<Paint> = Smart::Auto;
+    /// Whether to underline link.
+    pub const UNDERLINE: bool = true;
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self {
+            url: args.expect::<EcoString>("url")?,
+            body: args.find()?,
+        }))
+    }
+}
+
+impl Show for LinkNode {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        let mut body = styles
+            .show(self, ctx, [
+                Value::Str(self.url.clone()),
+                match &self.body {
+                    Some(body) => Value::Template(body.clone()),
+                    None => Value::None,
+                },
+            ])?
+            .or_else(|| self.body.clone())
+            .unwrap_or_else(|| {
+                let url = &self.url;
+                let mut text = url.as_str();
+                for prefix in ["mailto:", "tel:"] {
+                    text = text.trim_start_matches(prefix);
+                }
+                let shorter = text.len() < url.len();
+                Template::Text(if shorter { text.into() } else { url.clone() })
+            });
+
+        let mut map = StyleMap::new();
+        map.set(TextNode::LINK, Some(self.url.clone()));
+
+        if let Smart::Custom(fill) = styles.get(Self::FILL) {
+            map.set(TextNode::FILL, fill);
+        }
+
+        if styles.get(Self::UNDERLINE) {
+            body = body.underlined();
+        }
+
+        Ok(body.styled_with_map(map))
+    }
+}
diff --git a/src/library/text/mod.rs b/src/library/text/mod.rs
new file mode 100644
index 00000000..0df59007
--- /dev/null
+++ b/src/library/text/mod.rs
@@ -0,0 +1,409 @@
+mod deco;
+mod link;
+mod par;
+mod raw;
+mod shaping;
+
+pub use deco::*;
+pub use link::*;
+pub use par::*;
+pub use raw::*;
+pub use shaping::*;
+
+use std::borrow::Cow;
+use std::ops::BitXor;
+
+use ttf_parser::Tag;
+
+use crate::font::{Face, FontStretch, FontStyle, FontWeight, VerticalFontMetric};
+use crate::library::prelude::*;
+use crate::util::EcoString;
+
+/// A single run of text with the same style.
+#[derive(Hash)]
+pub struct TextNode;
+
+#[class]
+impl TextNode {
+    /// A prioritized sequence of font families.
+    #[variadic]
+    pub const FAMILY: Vec<FontFamily> = vec![FontFamily::SansSerif];
+    /// The serif font family/families.
+    pub const SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Serif")];
+    /// The sans-serif font family/families.
+    pub const SANS_SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Sans")];
+    /// The monospace font family/families.
+    pub const MONOSPACE: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Mono")];
+    /// Whether to allow font fallback when the primary font list contains no
+    /// match.
+    pub const FALLBACK: bool = true;
+
+    /// How the font is styled.
+    pub const STYLE: FontStyle = FontStyle::Normal;
+    /// The boldness / thickness of the font's glyphs.
+    pub const WEIGHT: FontWeight = FontWeight::REGULAR;
+    /// The width of the glyphs.
+    pub const STRETCH: FontStretch = FontStretch::NORMAL;
+    /// The glyph fill color.
+    #[shorthand]
+    pub const FILL: Paint = Color::BLACK.into();
+
+    /// The size of the glyphs.
+    #[shorthand]
+    #[fold(Linear::compose)]
+    pub const SIZE: Linear = Length::pt(11.0).into();
+    /// The amount of space that should be added between characters.
+    pub const TRACKING: Em = Em::zero();
+    /// The top end of the text bounding box.
+    pub const TOP_EDGE: VerticalFontMetric = VerticalFontMetric::CapHeight;
+    /// The bottom end of the text bounding box.
+    pub const BOTTOM_EDGE: VerticalFontMetric = VerticalFontMetric::Baseline;
+
+    /// Whether to apply kerning ("kern").
+    pub const KERNING: bool = true;
+    /// Whether small capital glyphs should be used. ("smcp")
+    pub const SMALLCAPS: bool = false;
+    /// Whether to apply stylistic alternates. ("salt")
+    pub const ALTERNATES: bool = false;
+    /// Which stylistic set to apply. ("ss01" - "ss20")
+    pub const STYLISTIC_SET: Option<StylisticSet> = None;
+    /// Whether standard ligatures are active. ("liga", "clig")
+    pub const LIGATURES: bool = true;
+    /// Whether ligatures that should be used sparingly are active. ("dlig")
+    pub const DISCRETIONARY_LIGATURES: bool = false;
+    /// Whether historical ligatures are active. ("hlig")
+    pub const HISTORICAL_LIGATURES: bool = false;
+    /// Which kind of numbers / figures to select.
+    pub const NUMBER_TYPE: Smart<NumberType> = Smart::Auto;
+    /// The width of numbers / figures.
+    pub const NUMBER_WIDTH: Smart<NumberWidth> = Smart::Auto;
+    /// How to position numbers.
+    pub const NUMBER_POSITION: NumberPosition = NumberPosition::Normal;
+    /// Whether to have a slash through the zero glyph. ("zero")
+    pub const SLASHED_ZERO: bool = false;
+    /// Whether to convert fractions. ("frac")
+    pub const FRACTIONS: bool = false;
+    /// Raw OpenType features to apply.
+    pub const FEATURES: Vec<(Tag, u32)> = vec![];
+
+    /// Whether the font weight should be increased by 300.
+    #[skip]
+    #[fold(bool::bitxor)]
+    pub const STRONG: bool = false;
+    /// Whether the the font style should be inverted.
+    #[skip]
+    #[fold(bool::bitxor)]
+    pub const EMPH: bool = false;
+    /// Whether a monospace font should be preferred.
+    #[skip]
+    pub const MONOSPACED: bool = false;
+    /// The case transformation that should be applied to the next.
+    #[skip]
+    pub const CASE: Option<Case> = None;
+    /// Decorative lines.
+    #[skip]
+    #[fold(|a, b| a.into_iter().chain(b).collect())]
+    pub const LINES: Vec<Decoration> = vec![];
+    /// An URL the text should link to.
+    #[skip]
+    pub const LINK: Option<EcoString> = None;
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        // The text constructor is special: It doesn't create a text node.
+        // Instead, it leaves the passed argument structurally unchanged, but
+        // styles all text in it.
+        args.expect("body")
+    }
+}
+
+/// Strong text, rendered in boldface.
+#[derive(Debug, Hash)]
+pub struct StrongNode(pub Template);
+
+#[class]
+impl StrongNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self(args.expect("body")?)))
+    }
+}
+
+impl Show for StrongNode {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, ctx, [Value::Template(self.0.clone())])?
+            .unwrap_or_else(|| self.0.clone().styled(TextNode::STRONG, true)))
+    }
+}
+
+/// Emphasized text, rendered with an italic face.
+#[derive(Debug, Hash)]
+pub struct EmphNode(pub Template);
+
+#[class]
+impl EmphNode {
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self(args.expect("body")?)))
+    }
+}
+
+impl Show for EmphNode {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        Ok(styles
+            .show(self, ctx, [Value::Template(self.0.clone())])?
+            .unwrap_or_else(|| self.0.clone().styled(TextNode::EMPH, true)))
+    }
+}
+
+/// 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 font family like "Arial".
+    Named(NamedFamily),
+}
+
+impl Debug for FontFamily {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Serif => f.pad("serif"),
+            Self::SansSerif => f.pad("sans-serif"),
+            Self::Monospace => f.pad("monospace"),
+            Self::Named(s) => s.fmt(f),
+        }
+    }
+}
+
+dynamic! {
+    FontFamily: "font family",
+    Value::Str(string) => Self::Named(NamedFamily::new(&string)),
+}
+
+castable! {
+    Vec<FontFamily>,
+    Expected: "string, generic family or array thereof",
+    Value::Str(string) => vec![FontFamily::Named(NamedFamily::new(&string))],
+    Value::Array(values) => {
+        values.into_iter().filter_map(|v| v.cast().ok()).collect()
+    },
+    @family: FontFamily => vec![family.clone()],
+}
+
+/// A specific font family like "Arial".
+#[derive(Clone, Eq, PartialEq, Hash)]
+pub struct NamedFamily(EcoString);
+
+impl NamedFamily {
+    /// Create a named font family variant.
+    pub fn new(string: &str) -> Self {
+        Self(string.to_lowercase().into())
+    }
+
+    /// The lowercased family name.
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+impl Debug for NamedFamily {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+castable! {
+    Vec<NamedFamily>,
+    Expected: "string or array of strings",
+    Value::Str(string) => vec![NamedFamily::new(&string)],
+    Value::Array(values) => values
+        .into_iter()
+        .filter_map(|v| v.cast().ok())
+        .map(|string: EcoString| NamedFamily::new(&string))
+        .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) => Value::Int(v)
+        .cast::<usize>()?
+        .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! {
+    Em,
+    Expected: "float",
+    Value::Float(v) => Self::new(v),
+}
+
+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(),
+}
+
+/// A case transformation on text.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum Case {
+    /// Everything is uppercased.
+    Upper,
+    /// Everything is lowercased.
+    Lower,
+}
+
+impl Case {
+    /// Apply the case to a string of text.
+    pub fn apply(self, text: &str) -> String {
+        match self {
+            Self::Upper => text.to_uppercase(),
+            Self::Lower => text.to_lowercase(),
+        }
+    }
+}
diff --git a/src/library/text/par.rs b/src/library/text/par.rs
new file mode 100644
index 00000000..812231c2
--- /dev/null
+++ b/src/library/text/par.rs
@@ -0,0 +1,617 @@
+use std::sync::Arc;
+
+use either::Either;
+use unicode_bidi::{BidiInfo, Level};
+use xi_unicode::LineBreakIterator;
+
+use super::{shape, ShapedText, TextNode};
+use crate::font::FontStore;
+use crate::library::layout::SpacingKind;
+use crate::library::prelude::*;
+use crate::util::{ArcExt, EcoString, RangeExt, SliceExt};
+
+/// Arrange text, spacing and inline-level nodes into a paragraph.
+#[derive(Hash)]
+pub struct ParNode(pub StyleVec<ParChild>);
+
+/// A uniformly styled atomic piece of a paragraph.
+#[derive(Hash)]
+pub enum ParChild {
+    /// A chunk of text.
+    Text(EcoString),
+    /// Horizontal spacing between other children.
+    Spacing(SpacingKind),
+    /// An arbitrary inline-level node.
+    Node(LayoutNode),
+}
+
+#[class]
+impl ParNode {
+    /// The direction for text and inline objects.
+    pub const DIR: Dir = Dir::LTR;
+    /// How to align text and inline objects in their line.
+    pub const ALIGN: Align = Align::Left;
+    /// Whether to justify text in its line.
+    pub const JUSTIFY: bool = false;
+    /// The spacing between lines (dependent on scaled font size).
+    pub const LEADING: Linear = Relative::new(0.65).into();
+    /// The extra spacing between paragraphs (dependent on scaled font size).
+    pub const SPACING: Linear = Relative::new(0.55).into();
+    /// The indent the first line of a consecutive paragraph should have.
+    pub const INDENT: Linear = Linear::zero();
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        // The paragraph constructor is special: It doesn't create a paragraph
+        // since that happens automatically through markup. Instead, it just
+        // lifts the passed body to the block level so that it won't merge with
+        // adjacent stuff and it styles the contained paragraphs.
+        Ok(Template::Block(args.expect("body")?))
+    }
+
+    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
+        let mut dir =
+            args.named("lang")?
+                .map(|iso: EcoString| match iso.to_lowercase().as_str() {
+                    "ar" | "he" | "fa" | "ur" | "ps" | "yi" => Dir::RTL,
+                    "en" | "fr" | "de" => Dir::LTR,
+                    _ => Dir::LTR,
+                });
+
+        if let Some(Spanned { v, span }) = args.named::<Spanned<Dir>>("dir")? {
+            if v.axis() != SpecAxis::Horizontal {
+                bail!(span, "must be horizontal");
+            }
+            dir = Some(v);
+        }
+
+        let align =
+            if let Some(Spanned { v, span }) = args.named::<Spanned<Align>>("align")? {
+                if v.axis() != SpecAxis::Horizontal {
+                    bail!(span, "must be horizontal");
+                }
+                Some(v)
+            } else {
+                dir.map(|dir| dir.start().into())
+            };
+
+        styles.set_opt(Self::DIR, dir);
+        styles.set_opt(Self::ALIGN, align);
+        styles.set_opt(Self::JUSTIFY, args.named("justify")?);
+        styles.set_opt(Self::LEADING, args.named("leading")?);
+        styles.set_opt(Self::SPACING, args.named("spacing")?);
+        styles.set_opt(Self::INDENT, args.named("indent")?);
+
+        Ok(())
+    }
+}
+
+impl ParNode {
+    /// Concatenate all text in the paragraph into one string, replacing spacing
+    /// with a space character and other non-text nodes with the object
+    /// replacement character.
+    fn collect_text(&self) -> String {
+        let mut text = String::new();
+        for string in self.strings() {
+            text.push_str(string);
+        }
+        text
+    }
+
+    /// The range of each item in the collected text.
+    fn ranges(&self) -> impl Iterator<Item = Range> + '_ {
+        let mut cursor = 0;
+        self.strings().map(move |string| {
+            let start = cursor;
+            cursor += string.len();
+            start .. cursor
+        })
+    }
+
+    /// The string representation of each child.
+    fn strings(&self) -> impl Iterator<Item = &str> {
+        self.0.items().map(|child| match child {
+            ParChild::Text(text) => text,
+            ParChild::Spacing(_) => " ",
+            ParChild::Node(_) => "\u{FFFC}",
+        })
+    }
+}
+
+impl Layout for ParNode {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        // Collect all text into one string and perform BiDi analysis.
+        let text = self.collect_text();
+        let bidi = BidiInfo::new(&text, match styles.get(Self::DIR) {
+            Dir::LTR => Some(Level::ltr()),
+            Dir::RTL => Some(Level::rtl()),
+            _ => None,
+        });
+
+        // Prepare paragraph layout by building a representation on which we can
+        // do line breaking without layouting each and every line from scratch.
+        let par = ParLayout::new(ctx, self, bidi, regions, &styles)?;
+
+        // Break the paragraph into lines.
+        let lines = break_into_lines(&mut ctx.fonts, &par, regions.first.x);
+
+        // Stack the lines into one frame per region.
+        Ok(stack_lines(&ctx.fonts, lines, regions, styles))
+    }
+}
+
+impl Debug for ParNode {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        f.write_str("Par ")?;
+        self.0.fmt(f)
+    }
+}
+
+impl Debug for ParChild {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Text(text) => write!(f, "Text({:?})", text),
+            Self::Spacing(kind) => write!(f, "{:?}", kind),
+            Self::Node(node) => node.fmt(f),
+        }
+    }
+}
+
+impl Merge for ParChild {
+    fn merge(&mut self, next: &Self) -> bool {
+        if let (Self::Text(left), Self::Text(right)) = (self, next) {
+            left.push_str(right);
+            true
+        } else {
+            false
+        }
+    }
+}
+
+/// A paragraph break.
+pub struct ParbreakNode;
+
+#[class]
+impl ParbreakNode {
+    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
+        Ok(Template::Parbreak)
+    }
+}
+
+/// A line break.
+pub struct LinebreakNode;
+
+#[class]
+impl LinebreakNode {
+    fn construct(_: &mut Context, _: &mut Args) -> TypResult<Template> {
+        Ok(Template::Linebreak)
+    }
+}
+
+/// A paragraph representation in which children are already layouted and text
+/// is already preshaped.
+struct ParLayout<'a> {
+    /// Bidirectional text embedding levels for the paragraph.
+    bidi: BidiInfo<'a>,
+    /// Spacing, separated text runs and layouted nodes.
+    items: Vec<ParItem<'a>>,
+    /// The ranges of the items in `bidi.text`.
+    ranges: Vec<Range>,
+}
+
+/// Range of a substring of text.
+type Range = std::ops::Range<usize>;
+
+/// A prepared item in a paragraph layout.
+enum ParItem<'a> {
+    /// Absolute spacing between other items.
+    Absolute(Length),
+    /// Fractional spacing between other items.
+    Fractional(Fractional),
+    /// A shaped text run with consistent direction.
+    Text(ShapedText<'a>),
+    /// A layouted child node.
+    Frame(Frame),
+}
+
+impl<'a> ParLayout<'a> {
+    /// Prepare initial shaped text and layouted children.
+    fn new(
+        ctx: &mut Context,
+        par: &'a ParNode,
+        bidi: BidiInfo<'a>,
+        regions: &Regions,
+        styles: &'a StyleChain<'a>,
+    ) -> TypResult<Self> {
+        let mut items = vec![];
+        let mut ranges = vec![];
+
+        // Layout the children and collect them into items.
+        for (range, (child, map)) in par.ranges().zip(par.0.iter()) {
+            let styles = map.chain(styles);
+            match child {
+                ParChild::Text(_) => {
+                    // TODO: Also split by language and script.
+                    let mut cursor = range.start;
+                    for (level, count) in bidi.levels[range].group() {
+                        let start = cursor;
+                        cursor += count;
+                        let subrange = start .. cursor;
+                        let text = &bidi.text[subrange.clone()];
+                        let dir = if level.is_ltr() { Dir::LTR } else { Dir::RTL };
+                        let shaped = shape(&mut ctx.fonts, text, styles, dir);
+                        items.push(ParItem::Text(shaped));
+                        ranges.push(subrange);
+                    }
+                }
+                ParChild::Spacing(kind) => match *kind {
+                    SpacingKind::Linear(v) => {
+                        let resolved = v.resolve(regions.first.x);
+                        items.push(ParItem::Absolute(resolved));
+                        ranges.push(range);
+                    }
+                    SpacingKind::Fractional(v) => {
+                        items.push(ParItem::Fractional(v));
+                        ranges.push(range);
+                    }
+                },
+                ParChild::Node(node) => {
+                    let size = Size::new(regions.first.x, regions.base.y);
+                    let pod = Regions::one(size, regions.base, Spec::splat(false));
+                    let frame = node.layout(ctx, &pod, styles)?.remove(0);
+                    items.push(ParItem::Frame(Arc::take(frame)));
+                    ranges.push(range);
+                }
+            }
+        }
+
+        Ok(Self { bidi, items, ranges })
+    }
+
+    /// Create a line which spans the given range.
+    fn line(
+        &'a self,
+        fonts: &mut FontStore,
+        mut range: Range,
+        mandatory: bool,
+    ) -> LineLayout<'a> {
+        // Find the items which bound the text range.
+        let last_idx = self.find(range.end.saturating_sub(1)).unwrap();
+        let first_idx = if range.is_empty() {
+            last_idx
+        } else {
+            self.find(range.start).unwrap()
+        };
+
+        // Slice out the relevant items and ranges.
+        let mut items = &self.items[first_idx ..= last_idx];
+        let ranges = &self.ranges[first_idx ..= last_idx];
+
+        // Reshape the last item if it's split in half.
+        let mut last = None;
+        if let Some((ParItem::Text(shaped), rest)) = items.split_last() {
+            // Compute the range we want to shape, trimming whitespace at the
+            // end of the line.
+            let base = self.ranges[last_idx].start;
+            let start = range.start.max(base);
+            let end = start + self.bidi.text[start .. range.end].trim_end().len();
+            let shifted = start - base .. end - base;
+
+            // Reshape if necessary.
+            if shifted.len() < shaped.text.len() {
+                // If start == end and the rest is empty, then we have an empty
+                // line. To make that line have the appropriate height, we shape the
+                // empty string.
+                if !shifted.is_empty() || rest.is_empty() {
+                    // Reshape that part.
+                    let reshaped = shaped.reshape(fonts, shifted);
+                    last = Some(ParItem::Text(reshaped));
+                }
+
+                items = rest;
+                range.end = end;
+            }
+        }
+
+        // Reshape the start item if it's split in half.
+        let mut first = None;
+        if let Some((ParItem::Text(shaped), rest)) = items.split_first() {
+            // Compute the range we want to shape.
+            let Range { start: base, end: first_end } = self.ranges[first_idx];
+            let start = range.start;
+            let end = range.end.min(first_end);
+            let shifted = start - base .. end - base;
+
+            // Reshape if necessary.
+            if shifted.len() < shaped.text.len() {
+                if !shifted.is_empty() {
+                    let reshaped = shaped.reshape(fonts, shifted);
+                    first = Some(ParItem::Text(reshaped));
+                }
+
+                items = rest;
+            }
+        }
+
+        let mut width = Length::zero();
+        let mut top = Length::zero();
+        let mut bottom = Length::zero();
+        let mut fr = Fractional::zero();
+
+        // Measure the size of the line.
+        for item in first.iter().chain(items).chain(&last) {
+            match item {
+                ParItem::Absolute(v) => width += *v,
+                ParItem::Fractional(v) => fr += *v,
+                ParItem::Text(shaped) => {
+                    width += shaped.size.x;
+                    top.set_max(shaped.baseline);
+                    bottom.set_max(shaped.size.y - shaped.baseline);
+                }
+                ParItem::Frame(frame) => {
+                    width += frame.size.x;
+                    top.set_max(frame.baseline());
+                    bottom.set_max(frame.size.y - frame.baseline());
+                }
+            }
+        }
+
+        LineLayout {
+            bidi: &self.bidi,
+            range,
+            first,
+            items,
+            last,
+            ranges,
+            size: Size::new(width, top + bottom),
+            baseline: top,
+            fr,
+            mandatory,
+        }
+    }
+
+
+    /// Find the index of the item whose range contains the `text_offset`.
+    fn find(&self, text_offset: usize) -> Option<usize> {
+        self.ranges.binary_search_by(|r| r.locate(text_offset)).ok()
+    }
+}
+
+/// A lightweight representation of a line that spans a specific range in a
+/// paragraph's text. This type enables you to cheaply measure the size of a
+/// line in a range before comitting to building the line's frame.
+struct LineLayout<'a> {
+    /// Bidi information about the paragraph.
+    bidi: &'a BidiInfo<'a>,
+    /// The range the line spans in the paragraph.
+    range: Range,
+    /// A reshaped text item if the line sliced up a text item at the start.
+    first: Option<ParItem<'a>>,
+    /// Middle items which don't need to be reprocessed.
+    items: &'a [ParItem<'a>],
+    /// A reshaped text item if the line sliced up a text item at the end. If
+    /// there is only one text item, this takes precedence over `first`.
+    last: Option<ParItem<'a>>,
+    /// The ranges, indexed as `[first, ..items, last]`. The ranges for `first`
+    /// and `last` aren't trimmed to the line, but it doesn't matter because
+    /// we're just checking which range an index falls into.
+    ranges: &'a [Range],
+    /// The size of the line.
+    size: Size,
+    /// The baseline of the line.
+    baseline: Length,
+    /// The sum of fractional ratios in the line.
+    fr: Fractional,
+    /// Whether the line ends at a mandatory break.
+    mandatory: bool,
+}
+
+impl<'a> LineLayout<'a> {
+    /// Build the line's frame.
+    fn build(
+        &self,
+        fonts: &FontStore,
+        width: Length,
+        align: Align,
+        justify: bool,
+    ) -> Frame {
+        let size = Size::new(width, self.size.y);
+
+        let mut remaining = width - self.size.x;
+        let mut offset = Length::zero();
+        let mut output = Frame::new(size);
+        output.baseline = Some(self.baseline);
+
+        let mut justification = Length::zero();
+        if justify
+            && !self.mandatory
+            && self.range.end < self.bidi.text.len()
+            && self.fr.is_zero()
+        {
+            justification = remaining / self.spaces() as f64;
+            remaining = Length::zero();
+        }
+
+        for item in self.reordered() {
+            let mut position = |frame: Frame| {
+                let x = offset + align.resolve(remaining);
+                let y = self.baseline - frame.baseline();
+                offset += frame.size.x;
+                output.merge_frame(Point::new(x, y), frame);
+            };
+
+            match item {
+                ParItem::Absolute(v) => offset += *v,
+                ParItem::Fractional(v) => offset += v.resolve(self.fr, remaining),
+                ParItem::Text(shaped) => position(shaped.build(fonts, justification)),
+                ParItem::Frame(frame) => position(frame.clone()),
+            }
+        }
+
+        output
+    }
+
+    /// The number of spaces in the line.
+    fn spaces(&self) -> usize {
+        self.shapeds().map(ShapedText::spaces).sum()
+    }
+
+    /// Iterate through the line's items in visual order.
+    fn reordered(&self) -> impl Iterator<Item = &ParItem<'a>> {
+        // The bidi crate doesn't like empty lines.
+        let (levels, runs) = if !self.range.is_empty() {
+            // Find the paragraph that contains the line.
+            let para = self
+                .bidi
+                .paragraphs
+                .iter()
+                .find(|para| para.range.contains(&self.range.start))
+                .unwrap();
+
+            // Compute the reordered ranges in visual order (left to right).
+            self.bidi.visual_runs(para, self.range.clone())
+        } else {
+            (vec![], vec![])
+        };
+
+        runs.into_iter()
+            .flat_map(move |run| {
+                let first_idx = self.find(run.start).unwrap();
+                let last_idx = self.find(run.end - 1).unwrap();
+                let range = first_idx ..= last_idx;
+
+                // Provide the items forwards or backwards depending on the run's
+                // direction.
+                if levels[run.start].is_ltr() {
+                    Either::Left(range)
+                } else {
+                    Either::Right(range.rev())
+                }
+            })
+            .map(move |idx| self.get(idx).unwrap())
+    }
+
+    /// Iterate over the line's items.
+    fn items(&self) -> impl Iterator<Item = &ParItem<'a>> {
+        self.first.iter().chain(self.items).chain(&self.last)
+    }
+
+    /// Iterate through the line's text items.
+    fn shapeds(&self) -> impl Iterator<Item = &ShapedText<'a>> {
+        self.items().filter_map(|item| match item {
+            ParItem::Text(shaped) => Some(shaped),
+            _ => None,
+        })
+    }
+
+    /// Find the index of the item whose range contains the `text_offset`.
+    fn find(&self, text_offset: usize) -> Option<usize> {
+        self.ranges.binary_search_by(|r| r.locate(text_offset)).ok()
+    }
+
+    /// Get the item at the index.
+    fn get(&self, index: usize) -> Option<&ParItem<'a>> {
+        self.items().nth(index)
+    }
+}
+
+/// Perform line breaking.
+fn break_into_lines<'a>(
+    fonts: &mut FontStore,
+    par: &'a ParLayout<'a>,
+    width: Length,
+) -> Vec<LineLayout<'a>> {
+    // The already determined lines and the current line attempt.
+    let mut lines = vec![];
+    let mut start = 0;
+    let mut last = None;
+
+    // Find suitable line breaks.
+    for (end, mandatory) in LineBreakIterator::new(&par.bidi.text) {
+        // Compute the line and its size.
+        let mut line = par.line(fonts, start .. end, mandatory);
+
+        // If the line doesn't fit anymore, we push the last fitting attempt
+        // into the stack and rebuild the line from its end. The resulting
+        // line cannot be broken up further.
+        if !width.fits(line.size.x) {
+            if let Some((last_line, last_end)) = last.take() {
+                lines.push(last_line);
+                start = last_end;
+                line = par.line(fonts, start .. end, mandatory);
+            }
+        }
+
+        // Finish the current line if there is a mandatory line break (i.e.
+        // due to "\n") or if the line doesn't fit horizontally already
+        // since then no shorter line will be possible.
+        if mandatory || !width.fits(line.size.x) {
+            lines.push(line);
+            start = end;
+            last = None;
+        } else {
+            last = Some((line, end));
+        }
+    }
+
+    if let Some((line, _)) = last {
+        lines.push(line);
+    }
+
+    lines
+}
+
+/// Combine the lines into one frame per region.
+fn stack_lines(
+    fonts: &FontStore,
+    lines: Vec<LineLayout>,
+    regions: &Regions,
+    styles: StyleChain,
+) -> Vec<Arc<Frame>> {
+    let em = styles.get(TextNode::SIZE).abs;
+    let leading = styles.get(ParNode::LEADING).resolve(em);
+    let align = styles.get(ParNode::ALIGN);
+    let justify = styles.get(ParNode::JUSTIFY);
+
+    // Determine the paragraph's width: Full width of the region if we
+    // should expand or there's fractional spacing, fit-to-width otherwise.
+    let mut width = regions.first.x;
+    if !regions.expand.x && lines.iter().all(|line| line.fr.is_zero()) {
+        width = lines.iter().map(|line| line.size.x).max().unwrap_or_default();
+    }
+
+    // State for final frame building.
+    let mut regions = regions.clone();
+    let mut finished = vec![];
+    let mut first = true;
+    let mut output = Frame::new(Size::with_x(width));
+
+    // Stack the lines into one frame per region.
+    for line in lines {
+        while !regions.first.y.fits(line.size.y) && !regions.in_last() {
+            finished.push(Arc::new(output));
+            output = Frame::new(Size::with_x(width));
+            regions.next();
+            first = true;
+        }
+
+        if !first {
+            output.size.y += leading;
+        }
+
+        let frame = line.build(fonts, width, align, justify);
+        let pos = Point::with_y(output.size.y);
+        output.size.y += frame.size.y;
+        output.merge_frame(pos, frame);
+
+        regions.first.y -= line.size.y + leading;
+        first = false;
+    }
+
+    finished.push(Arc::new(output));
+    finished
+}
diff --git a/src/library/text/raw.rs b/src/library/text/raw.rs
new file mode 100644
index 00000000..97857f11
--- /dev/null
+++ b/src/library/text/raw.rs
@@ -0,0 +1,127 @@
+use once_cell::sync::Lazy;
+use syntect::easy::HighlightLines;
+use syntect::highlighting::{FontStyle, Highlighter, Style, Theme, ThemeSet};
+use syntect::parsing::SyntaxSet;
+
+use crate::library::prelude::*;
+use crate::library::text::TextNode;
+use crate::source::SourceId;
+use crate::syntax::{self, RedNode};
+
+/// The lazily-loaded theme used for syntax highlighting.
+static THEME: Lazy<Theme> =
+    Lazy::new(|| ThemeSet::load_defaults().themes.remove("InspiredGitHub").unwrap());
+
+/// The lazily-loaded syntect syntax definitions.
+static SYNTAXES: Lazy<SyntaxSet> = Lazy::new(|| SyntaxSet::load_defaults_newlines());
+
+/// Monospaced text with optional syntax highlighting.
+#[derive(Debug, Hash)]
+pub struct RawNode {
+    /// The raw text.
+    pub text: EcoString,
+    /// Whether the node is block-level.
+    pub block: bool,
+}
+
+#[class]
+impl RawNode {
+    /// The language to syntax-highlight in.
+    pub const LANG: Option<EcoString> = None;
+
+    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
+        Ok(Template::show(Self {
+            text: args.expect("text")?,
+            block: args.named("block")?.unwrap_or(false),
+        }))
+    }
+}
+
+impl Show for RawNode {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+        let lang = styles.get_ref(Self::LANG).as_ref();
+
+        if let Some(template) = styles.show(self, ctx, [
+            Value::Str(self.text.clone()),
+            match lang {
+                Some(lang) => Value::Str(lang.clone()),
+                None => Value::None,
+            },
+            Value::Bool(self.block),
+        ])? {
+            return Ok(template);
+        }
+
+        let foreground = THEME
+            .settings
+            .foreground
+            .map(Color::from)
+            .unwrap_or(Color::BLACK)
+            .into();
+
+        let mut template = if matches!(
+            lang.map(|s| s.to_lowercase()).as_deref(),
+            Some("typ" | "typst")
+        ) {
+            let mut seq = vec![];
+            let green = crate::parse::parse(&self.text);
+            let red = RedNode::from_root(green, SourceId::from_raw(0));
+            let highlighter = Highlighter::new(&THEME);
+
+            syntax::highlight_syntect(red.as_ref(), &highlighter, &mut |range, style| {
+                seq.push(styled(&self.text[range], foreground, style));
+            });
+
+            Template::sequence(seq)
+        } else if let Some(syntax) =
+            lang.and_then(|token| SYNTAXES.find_syntax_by_token(&token))
+        {
+            let mut seq = vec![];
+            let mut highlighter = HighlightLines::new(syntax, &THEME);
+            for (i, line) in self.text.lines().enumerate() {
+                if i != 0 {
+                    seq.push(Template::Linebreak);
+                }
+
+                for (style, piece) in highlighter.highlight(line, &SYNTAXES) {
+                    seq.push(styled(piece, foreground, style));
+                }
+            }
+
+            Template::sequence(seq)
+        } else {
+            Template::Text(self.text.clone())
+        };
+
+        if self.block {
+            template = Template::Block(template.pack());
+        }
+
+        Ok(template.monospaced())
+    }
+}
+
+/// Style a piece of text with a syntect style.
+fn styled(piece: &str, foreground: Paint, style: Style) -> Template {
+    let mut styles = StyleMap::new();
+    let mut body = Template::Text(piece.into());
+
+    let paint = style.foreground.into();
+    if paint != foreground {
+        styles.set(TextNode::FILL, paint);
+    }
+
+    if style.font_style.contains(FontStyle::BOLD) {
+        styles.set(TextNode::STRONG, true);
+    }
+
+    if style.font_style.contains(FontStyle::ITALIC) {
+        styles.set(TextNode::EMPH, true);
+    }
+
+    if style.font_style.contains(FontStyle::UNDERLINE) {
+        body = body.underlined();
+    }
+
+    body.styled_with_map(styles)
+}
diff --git a/src/library/text/shaping.rs b/src/library/text/shaping.rs
new file mode 100644
index 00000000..26c8daf3
--- /dev/null
+++ b/src/library/text/shaping.rs
@@ -0,0 +1,552 @@
+use std::ops::Range;
+
+use rustybuzz::{Feature, UnicodeBuffer};
+
+use super::*;
+use crate::font::{FaceId, FontStore, FontVariant};
+use crate::library::prelude::*;
+use crate::util::SliceExt;
+
+/// 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: Cow<'a, str>,
+    /// The text direction.
+    pub dir: Dir,
+    /// The text's style properties.
+    pub styles: StyleChain<'a>,
+    /// The size of the text's bounding box.
+    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,
+    /// Whether this glyph represents a space.
+    pub is_space: bool,
+}
+
+/// A side you can go toward.
+enum Side {
+    /// Go toward the west.
+    Left,
+    /// Go toward the east.
+    Right,
+}
+
+impl<'a> ShapedText<'a> {
+    /// Build the shaped text's frame.
+    ///
+    /// The `justification` defines how much extra advance width each
+    /// [space glyph](ShapedGlyph::is_space) will get.
+    pub fn build(&self, fonts: &FontStore, justification: Length) -> 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 size = self.styles.get(TextNode::SIZE).abs;
+            let fill = self.styles.get(TextNode::FILL);
+            let glyphs = group
+                .iter()
+                .map(|glyph| Glyph {
+                    id: glyph.glyph_id,
+                    x_advance: glyph.x_advance
+                        + if glyph.is_space {
+                            frame.size.x += justification;
+                            Em::from_length(justification, size)
+                        } else {
+                            Em::zero()
+                        },
+                    x_offset: glyph.x_offset,
+                })
+                .collect();
+
+            let text = Text { face_id, size, fill, glyphs };
+            let text_layer = frame.layer();
+            let width = text.width();
+
+            // Apply line decorations.
+            for deco in self.styles.get_cloned(TextNode::LINES) {
+                decorate(&mut frame, &deco, fonts, &text, pos, width);
+            }
+
+            frame.insert(text_layer, pos, Element::Text(text));
+            offset += width;
+        }
+
+        // Apply link if it exists.
+        if let Some(url) = self.styles.get_ref(TextNode::LINK) {
+            frame.link(url);
+        }
+
+        frame
+    }
+
+    /// How many spaces the text contains.
+    pub fn spaces(&self) -> usize {
+        self.glyphs.iter().filter(|g| g.is_space).count()
+    }
+
+    /// Reshape a range of the shaped text, reusing information from this
+    /// shaping process if possible.
+    pub fn reshape(
+        &'a self,
+        fonts: &mut FontStore,
+        text_range: Range<usize>,
+    ) -> ShapedText<'a> {
+        if let Some(glyphs) = self.slice_safe_to_break(text_range.clone()) {
+            let (size, baseline) = measure(fonts, glyphs, self.styles);
+            Self {
+                text: Cow::Borrowed(&self.text[text_range]),
+                dir: self.dir,
+                styles: self.styles.clone(),
+                size,
+                baseline,
+                glyphs: Cow::Borrowed(glyphs),
+            }
+        } else {
+            shape(fonts, &self.text[text_range], self.styles.clone(), 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)
+    }
+}
+
+/// Shape text into [`ShapedText`].
+pub fn shape<'a>(
+    fonts: &mut FontStore,
+    text: &'a str,
+    styles: StyleChain<'a>,
+    dir: Dir,
+) -> ShapedText<'a> {
+    let text = match styles.get(TextNode::CASE) {
+        Some(case) => Cow::Owned(case.apply(text)),
+        None => Cow::Borrowed(text),
+    };
+
+    let mut glyphs = vec![];
+    if !text.is_empty() {
+        shape_segment(
+            fonts,
+            &mut glyphs,
+            0,
+            &text,
+            variant(styles),
+            families(styles),
+            None,
+            dir,
+            &tags(styles),
+        );
+    }
+
+    track(&mut glyphs, styles.get(TextNode::TRACKING));
+    let (size, baseline) = measure(fonts, &glyphs, styles);
+
+    ShapedText {
+        text,
+        dir,
+        styles,
+        size,
+        baseline,
+        glyphs: Cow::Owned(glyphs),
+    }
+}
+
+/// Resolve the font variant with `STRONG` and `EMPH` factored in.
+fn variant(styles: StyleChain) -> 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: StyleChain) -> impl Iterator<Item = &str> + Clone {
+    let head = if styles.get(TextNode::MONOSPACED) {
+        styles.get_ref(TextNode::MONOSPACE).as_slice()
+    } else {
+        &[]
+    };
+
+    let core = styles.get_ref(TextNode::FAMILY).iter().flat_map(move |family| {
+        match family {
+            FontFamily::Named(name) => std::slice::from_ref(name),
+            FontFamily::Serif => styles.get_ref(TextNode::SERIF),
+            FontFamily::SansSerif => styles.get_ref(TextNode::SANS_SERIF),
+            FontFamily::Monospace => styles.get_ref(TextNode::MONOSPACE),
+        }
+    });
+
+    let tail: &[&str] = if styles.get(TextNode::FALLBACK) {
+        &["ibm plex sans", "latin modern math", "twitter color emoji"]
+    } else {
+        &[]
+    };
+
+    head.iter()
+        .chain(core)
+        .map(|named| named.as_str())
+        .chain(tail.iter().copied())
+}
+
+/// Collect the tags of the OpenType features to apply.
+fn tags(styles: StyleChain) -> 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 !styles.get(TextNode::KERNING) {
+        feat(b"kern", 0);
+    }
+
+    // Features that are off by default in Harfbuzz are only added if enabled.
+    if styles.get(TextNode::SMALLCAPS) {
+        feat(b"smcp", 1);
+    }
+
+    if styles.get(TextNode::ALTERNATES) {
+        feat(b"salt", 1);
+    }
+
+    let storage;
+    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 !styles.get(TextNode::LIGATURES) {
+        feat(b"liga", 0);
+        feat(b"clig", 0);
+    }
+
+    if styles.get(TextNode::DISCRETIONARY_LIGATURES) {
+        feat(b"dlig", 1);
+    }
+
+    if styles.get(TextNode::HISTORICAL_LIGATURES) {
+        feat(b"hilg", 1);
+    }
+
+    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 styles.get(TextNode::NUMBER_WIDTH) {
+        Smart::Auto => {}
+        Smart::Custom(NumberWidth::Proportional) => feat(b"pnum", 1),
+        Smart::Custom(NumberWidth::Tabular) => feat(b"tnum", 1),
+    }
+
+    match styles.get(TextNode::NUMBER_POSITION) {
+        NumberPosition::Normal => {}
+        NumberPosition::Subscript => feat(b"subs", 1),
+        NumberPosition::Superscript => feat(b"sups", 1),
+    }
+
+    if styles.get(TextNode::SLASHED_ZERO) {
+        feat(b"zero", 1);
+    }
+
+    if styles.get(TextNode::FRACTIONS) {
+        feat(b"frac", 1);
+    }
+
+    for &(tag, value) in styles.get_ref(TextNode::FEATURES).iter() {
+        tags.push(Feature::new(tag, value, ..))
+    }
+
+    tags
+}
+
+/// Shape text with font fallback using the `families` iterator.
+fn shape_segment<'a>(
+    fonts: &mut FontStore,
+    glyphs: &mut Vec<ShapedGlyph>,
+    base: usize,
+    text: &str,
+    variant: FontVariant,
+    mut families: impl Iterator<Item = &'a str> + Clone,
+    mut first_face: Option<FaceId>,
+    dir: Dir,
+    tags: &[rustybuzz::Feature],
+) {
+    // No font has newlines.
+    if text.chars().all(|c| c == '\n') {
+        return;
+    }
+
+    // Select the font family.
+    let (face_id, fallback) = loop {
+        // Try to load the next available font family.
+        match families.next() {
+            Some(family) => {
+                if let Some(id) = fonts.select(family, variant) {
+                    break (id, true);
+                }
+            }
+            // We're out of families, so we don't do any more fallback and just
+            // shape the tofus with the first face we originally used.
+            None => match first_face {
+                Some(id) => break (id, false),
+                None => return,
+            },
+        }
+    };
+
+    // Remember the id if this the first available face since we use that one to
+    // shape tofus.
+    first_face.get_or_insert(face_id);
+
+    // Fill the buffer with our text.
+    let mut buffer = UnicodeBuffer::new();
+    buffer.push_str(text);
+    buffer.set_direction(match dir {
+        Dir::LTR => rustybuzz::Direction::LeftToRight,
+        Dir::RTL => rustybuzz::Direction::RightToLeft,
+        _ => unimplemented!(),
+    });
+
+    // Shape!
+    let mut face = fonts.get(face_id);
+    let buffer = rustybuzz::shape(face.ttf(), tags, buffer);
+    let infos = buffer.glyph_infos();
+    let pos = buffer.glyph_positions();
+
+    // Collect the shaped glyphs, doing fallback and shaping parts again with
+    // the next font if necessary.
+    let mut i = 0;
+    while i < infos.len() {
+        let info = &infos[i];
+        let cluster = info.cluster as usize;
+
+        if info.glyph_id != 0 || !fallback {
+            // Add the glyph to the shaped output.
+            // TODO: Don't ignore y_advance and y_offset.
+            glyphs.push(ShapedGlyph {
+                face_id,
+                glyph_id: info.glyph_id as u16,
+                x_advance: face.to_em(pos[i].x_advance),
+                x_offset: face.to_em(pos[i].x_offset),
+                text_index: base + cluster,
+                safe_to_break: !info.unsafe_to_break(),
+                is_space: text[cluster ..].chars().next() == Some(' '),
+            });
+        } else {
+            // Determine the source text range for the tofu sequence.
+            let range = {
+                // First, search for the end of the tofu sequence.
+                let k = i;
+                while infos.get(i + 1).map_or(false, |info| info.glyph_id == 0) {
+                    i += 1;
+                }
+
+                // Then, determine the start and end text index.
+                //
+                // Examples:
+                // Everything is shown in visual order. Tofus are written as "_".
+                // We want to find out that the tofus span the text `2..6`.
+                // Note that the clusters are longer than 1 char.
+                //
+                // Left-to-right:
+                // Text:     h a l i h a l l o
+                // Glyphs:   A   _   _   C   E
+                // Clusters: 0   2   4   6   8
+                //              k=1 i=2
+                //
+                // Right-to-left:
+                // Text:     O L L A H I L A H
+                // Glyphs:   E   C   _   _   A
+                // Clusters: 8   6   4   2   0
+                //                  k=2 i=3
+                let ltr = dir.is_positive();
+                let first = if ltr { k } else { i };
+                let start = infos[first].cluster as usize;
+                let last = if ltr { i.checked_add(1) } else { k.checked_sub(1) };
+                let end = last
+                    .and_then(|last| infos.get(last))
+                    .map_or(text.len(), |info| info.cluster as usize);
+
+                start .. end
+            };
+
+            // Recursively shape the tofu sequence with the next family.
+            shape_segment(
+                fonts,
+                glyphs,
+                base + range.start,
+                &text[range],
+                variant,
+                families.clone(),
+                first_face,
+                dir,
+                tags,
+            );
+
+            face = fonts.get(face_id);
+        }
+
+        i += 1;
+    }
+}
+
+/// Apply tracking to a slice of shaped glyphs.
+fn track(glyphs: &mut [ShapedGlyph], tracking: Em) {
+    if tracking.is_zero() {
+        return;
+    }
+
+    let mut glyphs = glyphs.iter_mut().peekable();
+    while let Some(glyph) = glyphs.next() {
+        if glyphs
+            .peek()
+            .map_or(false, |next| glyph.text_index != next.text_index)
+        {
+            glyph.x_advance += tracking;
+        }
+    }
+}
+
+/// Measure the size and baseline of a run of shaped glyphs with the given
+/// properties.
+fn measure(
+    fonts: &mut FontStore,
+    glyphs: &[ShapedGlyph],
+    styles: StyleChain,
+) -> (Size, Length) {
+    let mut width = Length::zero();
+    let mut top = Length::zero();
+    let mut bottom = Length::zero();
+
+    let size = styles.get(TextNode::SIZE).abs;
+    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(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 families(styles) {
+            if let Some(face_id) = fonts.select(family, variant(styles)) {
+                expand(fonts.get(face_id));
+                break;
+            }
+        }
+    } else {
+        for (face_id, group) in glyphs.group_by_key(|g| g.face_id) {
+            let face = fonts.get(face_id);
+            expand(face);
+
+            for glyph in group {
+                width += glyph.x_advance.resolve(size);
+            }
+        }
+    }
+
+    (Size::new(width, top + bottom), top)
+}
diff --git a/src/library/transform.rs b/src/library/transform.rs
deleted file mode 100644
index 897f3144..00000000
--- a/src/library/transform.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-//! Affine transformations on nodes.
-
-use super::prelude::*;
-use crate::geom::Transform;
-
-/// Transform a node without affecting layout.
-#[derive(Debug, Hash)]
-pub struct TransformNode<const T: TransformKind> {
-    /// Transformation to apply to the contents.
-    pub transform: Transform,
-    /// The node whose contents should be transformed.
-    pub child: LayoutNode,
-}
-
-#[class]
-impl<const T: TransformKind> TransformNode<T> {
-    /// The origin of the transformation.
-    pub const ORIGIN: Spec<Option<Align>> = Spec::default();
-
-    fn construct(_: &mut Context, args: &mut Args) -> TypResult<Template> {
-        let transform = match T {
-            MOVE => {
-                let tx = args.named("x")?.unwrap_or_default();
-                let ty = args.named("y")?.unwrap_or_default();
-                Transform::translation(tx, ty)
-            }
-            ROTATE => {
-                let angle = args.named_or_find("angle")?.unwrap_or_default();
-                Transform::rotation(angle)
-            }
-            SCALE | _ => {
-                let all = args.find()?;
-                let sx = args.named("x")?.or(all).unwrap_or(Relative::one());
-                let sy = args.named("y")?.or(all).unwrap_or(Relative::one());
-                Transform::scale(sx, sy)
-            }
-        };
-
-        Ok(Template::inline(Self {
-            transform,
-            child: args.expect("body")?,
-        }))
-    }
-}
-
-impl<const T: TransformKind> Layout for TransformNode<T> {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
-        let mut frames = self.child.layout(ctx, regions, styles)?;
-
-        for frame in &mut frames {
-            let Spec { x, y } = origin.zip(frame.size).map(|(o, s)| o.resolve(s));
-            let transform = Transform::translation(x, y)
-                .pre_concat(self.transform)
-                .pre_concat(Transform::translation(-x, -y));
-
-            Arc::make_mut(frame).transform(transform);
-        }
-
-        Ok(frames)
-    }
-}
-
-/// Kinds of transformations.
-pub type TransformKind = usize;
-
-/// A translation on the X and Y axes.
-pub const MOVE: TransformKind = 0;
-
-/// A rotational transformation.
-pub const ROTATE: TransformKind = 1;
-
-/// A scale transformation.
-pub const SCALE: TransformKind = 2;
diff --git a/src/library/utility.rs b/src/library/utility.rs
deleted file mode 100644
index ceae20bf..00000000
--- a/src/library/utility.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-//! Computational utility functions.
-
-use std::cmp::Ordering;
-use std::str::FromStr;
-
-use super::prelude::*;
-use super::{Case, TextNode};
-use crate::eval::Array;
-
-/// Ensure that a condition is fulfilled.
-pub fn assert(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect::<Spanned<bool>>("condition")?;
-    if !v {
-        bail!(span, "assertion failed");
-    }
-    Ok(Value::None)
-}
-
-/// The name of a value's type.
-pub fn type_(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    Ok(args.expect::<Value>("value")?.type_name().into())
-}
-
-/// The string representation of a value.
-pub fn repr(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    Ok(args.expect::<Value>("value")?.repr().into())
-}
-
-/// Join a sequence of values, optionally interspersing it with another value.
-pub fn join(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let span = args.span;
-    let sep = args.named::<Value>("sep")?.unwrap_or(Value::None);
-
-    let mut result = Value::None;
-    let mut iter = args.all::<Value>()?.into_iter();
-
-    if let Some(first) = iter.next() {
-        result = first;
-    }
-
-    for value in iter {
-        result = result.join(sep.clone()).at(span)?;
-        result = result.join(value).at(span)?;
-    }
-
-    Ok(result)
-}
-
-/// Convert a value to a integer.
-pub fn int(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect("value")?;
-    Ok(Value::Int(match v {
-        Value::Bool(v) => v as i64,
-        Value::Int(v) => v,
-        Value::Float(v) => v as i64,
-        Value::Str(v) => match v.parse() {
-            Ok(v) => v,
-            Err(_) => bail!(span, "invalid integer"),
-        },
-        v => bail!(span, "cannot convert {} to integer", v.type_name()),
-    }))
-}
-
-/// Convert a value to a float.
-pub fn float(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect("value")?;
-    Ok(Value::Float(match v {
-        Value::Int(v) => v as f64,
-        Value::Float(v) => v,
-        Value::Str(v) => match v.parse() {
-            Ok(v) => v,
-            Err(_) => bail!(span, "invalid float"),
-        },
-        v => bail!(span, "cannot convert {} to float", v.type_name()),
-    }))
-}
-
-/// Try to convert a value to a string.
-pub fn str(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect("value")?;
-    Ok(Value::Str(match v {
-        Value::Int(v) => format_eco!("{}", v),
-        Value::Float(v) => format_eco!("{}", v),
-        Value::Str(v) => v,
-        v => bail!(span, "cannot convert {} to string", v.type_name()),
-    }))
-}
-
-/// Create an RGB(A) color.
-pub fn rgb(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    Ok(Value::from(
-        if let Some(string) = args.find::<Spanned<EcoString>>()? {
-            match RgbaColor::from_str(&string.v) {
-                Ok(color) => color,
-                Err(_) => bail!(string.span, "invalid hex string"),
-            }
-        } else {
-            struct Component(u8);
-
-            castable! {
-                Component,
-                Expected: "integer or relative",
-                Value::Int(v) => match v {
-                    0 ..= 255 => Self(v as u8),
-                    _ => Err("must be between 0 and 255")?,
-                },
-                Value::Relative(v) => if (0.0 ..= 1.0).contains(&v.get()) {
-                    Self((v.get() * 255.0).round() as u8)
-                } else {
-                    Err("must be between 0% and 100%")?
-                },
-            }
-
-            let Component(r) = args.expect("red component")?;
-            let Component(g) = args.expect("green component")?;
-            let Component(b) = args.expect("blue component")?;
-            let Component(a) = args.eat()?.unwrap_or(Component(255));
-            RgbaColor::new(r, g, b, a)
-        },
-    ))
-}
-
-/// Create a CMYK color.
-pub fn cmyk(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    struct Component(u8);
-
-    castable! {
-        Component,
-        Expected: "relative",
-        Value::Relative(v) => if (0.0 ..= 1.0).contains(&v.get()) {
-            Self((v.get() * 255.0).round() as u8)
-        } else {
-            Err("must be between 0% and 100%")?
-        },
-    }
-
-    let Component(c) = args.expect("cyan component")?;
-    let Component(m) = args.expect("magenta component")?;
-    let Component(y) = args.expect("yellow component")?;
-    let Component(k) = args.expect("key component")?;
-    Ok(Value::Color(CmykColor::new(c, m, y, k).into()))
-}
-
-/// The absolute value of a numeric value.
-pub fn abs(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect("numeric value")?;
-    Ok(match v {
-        Value::Int(v) => Value::Int(v.abs()),
-        Value::Float(v) => Value::Float(v.abs()),
-        Value::Length(v) => Value::Length(v.abs()),
-        Value::Angle(v) => Value::Angle(v.abs()),
-        Value::Relative(v) => Value::Relative(v.abs()),
-        Value::Fractional(v) => Value::Fractional(v.abs()),
-        Value::Linear(_) => bail!(span, "cannot take absolute value of a linear"),
-        v => bail!(span, "expected numeric value, found {}", v.type_name()),
-    })
-}
-
-/// The minimum of a sequence of values.
-pub fn min(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    minmax(args, Ordering::Less)
-}
-
-/// The maximum of a sequence of values.
-pub fn max(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    minmax(args, Ordering::Greater)
-}
-
-/// Whether an integer is even.
-pub fn even(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    Ok(Value::Bool(args.expect::<i64>("integer")? % 2 == 0))
-}
-
-/// Whether an integer is odd.
-pub fn odd(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    Ok(Value::Bool(args.expect::<i64>("integer")? % 2 != 0))
-}
-
-/// The modulo of two numbers.
-pub fn modulo(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v: v1, span: span1 } = args.expect("integer or float")?;
-    let Spanned { v: v2, span: span2 } = args.expect("integer or float")?;
-
-    let (a, b) = match (v1, v2) {
-        (Value::Int(a), Value::Int(b)) => match a.checked_rem(b) {
-            Some(res) => return Ok(Value::Int(res)),
-            None => bail!(span2, "divisor must not be zero"),
-        },
-        (Value::Int(a), Value::Float(b)) => (a as f64, b),
-        (Value::Float(a), Value::Int(b)) => (a, b as f64),
-        (Value::Float(a), Value::Float(b)) => (a, b),
-        (Value::Int(_), b) | (Value::Float(_), b) => bail!(
-            span2,
-            format!("expected integer or float, found {}", b.type_name())
-        ),
-        (a, _) => bail!(
-            span1,
-            format!("expected integer or float, found {}", a.type_name())
-        ),
-    };
-
-    if b == 0.0 {
-        bail!(span2, "divisor must not be zero");
-    }
-
-    Ok(Value::Float(a % b))
-}
-
-/// Find the minimum or maximum of a sequence of values.
-fn minmax(args: &mut Args, goal: Ordering) -> TypResult<Value> {
-    let mut extremum = args.expect::<Value>("value")?;
-    for Spanned { v, span } in args.all::<Spanned<Value>>()? {
-        match v.partial_cmp(&extremum) {
-            Some(ordering) => {
-                if ordering == goal {
-                    extremum = v;
-                }
-            }
-            None => bail!(
-                span,
-                "cannot compare {} with {}",
-                extremum.type_name(),
-                v.type_name(),
-            ),
-        }
-    }
-    Ok(extremum)
-}
-
-/// Create a sequence of numbers.
-pub fn range(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let first = args.expect::<i64>("end")?;
-    let (start, end) = match args.eat::<i64>()? {
-        Some(second) => (first, second),
-        None => (0, first),
-    };
-
-    let step: i64 = match args.named("step")? {
-        Some(Spanned { v: 0, span }) => bail!(span, "step must not be zero"),
-        Some(Spanned { v, .. }) => v,
-        None => 1,
-    };
-
-    let mut x = start;
-    let mut seq = vec![];
-
-    while x.cmp(&end) == 0.cmp(&step) {
-        seq.push(Value::Int(x));
-        x += step;
-    }
-
-    Ok(Value::Array(Array::from_vec(seq)))
-}
-
-/// Convert a string to lowercase.
-pub fn lower(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    case(Case::Lower, args)
-}
-
-/// Convert a string to uppercase.
-pub fn upper(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    case(Case::Upper, args)
-}
-
-/// Change the case of a string or template.
-fn case(case: Case, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect("string or template")?;
-    Ok(match v {
-        Value::Str(v) => Value::Str(case.apply(&v).into()),
-        Value::Template(v) => Value::Template(v.styled(TextNode::CASE, Some(case))),
-        v => bail!(span, "expected string or template, found {}", v.type_name()),
-    })
-}
-
-/// The length of a string, an array or a dictionary.
-pub fn len(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect("collection")?;
-    Ok(Value::Int(match v {
-        Value::Str(v) => v.len() as i64,
-        Value::Array(v) => v.len(),
-        Value::Dict(v) => v.len(),
-        v => bail!(
-            span,
-            "expected string, array or dictionary, found {}",
-            v.type_name(),
-        ),
-    }))
-}
-
-/// The sorted version of an array.
-pub fn sorted(_: &mut Context, args: &mut Args) -> TypResult<Value> {
-    let Spanned { v, span } = args.expect::<Spanned<Array>>("array")?;
-    Ok(Value::Array(v.sorted().at(span)?))
-}
diff --git a/src/library/utility/math.rs b/src/library/utility/math.rs
new file mode 100644
index 00000000..795f39fd
--- /dev/null
+++ b/src/library/utility/math.rs
@@ -0,0 +1,114 @@
+use std::cmp::Ordering;
+
+use crate::library::prelude::*;
+
+/// The absolute value of a numeric value.
+pub fn abs(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect("numeric value")?;
+    Ok(match v {
+        Value::Int(v) => Value::Int(v.abs()),
+        Value::Float(v) => Value::Float(v.abs()),
+        Value::Length(v) => Value::Length(v.abs()),
+        Value::Angle(v) => Value::Angle(v.abs()),
+        Value::Relative(v) => Value::Relative(v.abs()),
+        Value::Fractional(v) => Value::Fractional(v.abs()),
+        Value::Linear(_) => bail!(span, "cannot take absolute value of a linear"),
+        v => bail!(span, "expected numeric value, found {}", v.type_name()),
+    })
+}
+
+/// The minimum of a sequence of values.
+pub fn min(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    minmax(args, Ordering::Less)
+}
+
+/// The maximum of a sequence of values.
+pub fn max(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    minmax(args, Ordering::Greater)
+}
+
+/// Find the minimum or maximum of a sequence of values.
+fn minmax(args: &mut Args, goal: Ordering) -> TypResult<Value> {
+    let mut extremum = args.expect::<Value>("value")?;
+    for Spanned { v, span } in args.all::<Spanned<Value>>()? {
+        match v.partial_cmp(&extremum) {
+            Some(ordering) => {
+                if ordering == goal {
+                    extremum = v;
+                }
+            }
+            None => bail!(
+                span,
+                "cannot compare {} with {}",
+                extremum.type_name(),
+                v.type_name(),
+            ),
+        }
+    }
+    Ok(extremum)
+}
+
+/// Whether an integer is even.
+pub fn even(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    Ok(Value::Bool(args.expect::<i64>("integer")? % 2 == 0))
+}
+
+/// Whether an integer is odd.
+pub fn odd(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    Ok(Value::Bool(args.expect::<i64>("integer")? % 2 != 0))
+}
+
+/// The modulo of two numbers.
+pub fn modulo(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v: v1, span: span1 } = args.expect("integer or float")?;
+    let Spanned { v: v2, span: span2 } = args.expect("integer or float")?;
+
+    let (a, b) = match (v1, v2) {
+        (Value::Int(a), Value::Int(b)) => match a.checked_rem(b) {
+            Some(res) => return Ok(Value::Int(res)),
+            None => bail!(span2, "divisor must not be zero"),
+        },
+        (Value::Int(a), Value::Float(b)) => (a as f64, b),
+        (Value::Float(a), Value::Int(b)) => (a, b as f64),
+        (Value::Float(a), Value::Float(b)) => (a, b),
+        (Value::Int(_), b) | (Value::Float(_), b) => bail!(
+            span2,
+            format!("expected integer or float, found {}", b.type_name())
+        ),
+        (a, _) => bail!(
+            span1,
+            format!("expected integer or float, found {}", a.type_name())
+        ),
+    };
+
+    if b == 0.0 {
+        bail!(span2, "divisor must not be zero");
+    }
+
+    Ok(Value::Float(a % b))
+}
+
+/// Create a sequence of numbers.
+pub fn range(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let first = args.expect::<i64>("end")?;
+    let (start, end) = match args.eat::<i64>()? {
+        Some(second) => (first, second),
+        None => (0, first),
+    };
+
+    let step: i64 = match args.named("step")? {
+        Some(Spanned { v: 0, span }) => bail!(span, "step must not be zero"),
+        Some(Spanned { v, .. }) => v,
+        None => 1,
+    };
+
+    let mut x = start;
+    let mut seq = vec![];
+
+    while x.cmp(&end) == 0.cmp(&step) {
+        seq.push(Value::Int(x));
+        x += step;
+    }
+
+    Ok(Value::Array(Array::from_vec(seq)))
+}
diff --git a/src/library/utility/mod.rs b/src/library/utility/mod.rs
new file mode 100644
index 00000000..886cdc13
--- /dev/null
+++ b/src/library/utility/mod.rs
@@ -0,0 +1,187 @@
+//! Computational utility functions.
+
+mod math;
+mod numbering;
+
+pub use math::*;
+pub use numbering::*;
+
+use std::str::FromStr;
+
+use crate::library::prelude::*;
+use crate::library::text::{Case, TextNode};
+
+/// Ensure that a condition is fulfilled.
+pub fn assert(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect::<Spanned<bool>>("condition")?;
+    if !v {
+        bail!(span, "assertion failed");
+    }
+    Ok(Value::None)
+}
+
+/// The name of a value's type.
+pub fn type_(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    Ok(args.expect::<Value>("value")?.type_name().into())
+}
+
+/// The string representation of a value.
+pub fn repr(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    Ok(args.expect::<Value>("value")?.repr().into())
+}
+
+/// Join a sequence of values, optionally interspersing it with another value.
+pub fn join(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let span = args.span;
+    let sep = args.named::<Value>("sep")?.unwrap_or(Value::None);
+
+    let mut result = Value::None;
+    let mut iter = args.all::<Value>()?.into_iter();
+
+    if let Some(first) = iter.next() {
+        result = first;
+    }
+
+    for value in iter {
+        result = result.join(sep.clone()).at(span)?;
+        result = result.join(value).at(span)?;
+    }
+
+    Ok(result)
+}
+
+/// Convert a value to a integer.
+pub fn int(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect("value")?;
+    Ok(Value::Int(match v {
+        Value::Bool(v) => v as i64,
+        Value::Int(v) => v,
+        Value::Float(v) => v as i64,
+        Value::Str(v) => match v.parse() {
+            Ok(v) => v,
+            Err(_) => bail!(span, "invalid integer"),
+        },
+        v => bail!(span, "cannot convert {} to integer", v.type_name()),
+    }))
+}
+
+/// Convert a value to a float.
+pub fn float(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect("value")?;
+    Ok(Value::Float(match v {
+        Value::Int(v) => v as f64,
+        Value::Float(v) => v,
+        Value::Str(v) => match v.parse() {
+            Ok(v) => v,
+            Err(_) => bail!(span, "invalid float"),
+        },
+        v => bail!(span, "cannot convert {} to float", v.type_name()),
+    }))
+}
+
+/// Cconvert a value to a string.
+pub fn str(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect("value")?;
+    Ok(Value::Str(match v {
+        Value::Int(v) => format_eco!("{}", v),
+        Value::Float(v) => format_eco!("{}", v),
+        Value::Str(v) => v,
+        v => bail!(span, "cannot convert {} to string", v.type_name()),
+    }))
+}
+
+/// Create an RGB(A) color.
+pub fn rgb(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    Ok(Value::from(
+        if let Some(string) = args.find::<Spanned<EcoString>>()? {
+            match RgbaColor::from_str(&string.v) {
+                Ok(color) => color,
+                Err(_) => bail!(string.span, "invalid hex string"),
+            }
+        } else {
+            struct Component(u8);
+
+            castable! {
+                Component,
+                Expected: "integer or relative",
+                Value::Int(v) => match v {
+                    0 ..= 255 => Self(v as u8),
+                    _ => Err("must be between 0 and 255")?,
+                },
+                Value::Relative(v) => if (0.0 ..= 1.0).contains(&v.get()) {
+                    Self((v.get() * 255.0).round() as u8)
+                } else {
+                    Err("must be between 0% and 100%")?
+                },
+            }
+
+            let Component(r) = args.expect("red component")?;
+            let Component(g) = args.expect("green component")?;
+            let Component(b) = args.expect("blue component")?;
+            let Component(a) = args.eat()?.unwrap_or(Component(255));
+            RgbaColor::new(r, g, b, a)
+        },
+    ))
+}
+
+/// Create a CMYK color.
+pub fn cmyk(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    struct Component(u8);
+
+    castable! {
+        Component,
+        Expected: "relative",
+        Value::Relative(v) => if (0.0 ..= 1.0).contains(&v.get()) {
+            Self((v.get() * 255.0).round() as u8)
+        } else {
+            Err("must be between 0% and 100%")?
+        },
+    }
+
+    let Component(c) = args.expect("cyan component")?;
+    let Component(m) = args.expect("magenta component")?;
+    let Component(y) = args.expect("yellow component")?;
+    let Component(k) = args.expect("key component")?;
+    Ok(Value::Color(CmykColor::new(c, m, y, k).into()))
+}
+
+/// The length of a string, an array or a dictionary.
+pub fn len(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect("collection")?;
+    Ok(Value::Int(match v {
+        Value::Str(v) => v.len() as i64,
+        Value::Array(v) => v.len(),
+        Value::Dict(v) => v.len(),
+        v => bail!(
+            span,
+            "expected string, array or dictionary, found {}",
+            v.type_name(),
+        ),
+    }))
+}
+
+/// Convert a string to lowercase.
+pub fn lower(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    case(Case::Lower, args)
+}
+
+/// Convert a string to uppercase.
+pub fn upper(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    case(Case::Upper, args)
+}
+
+/// Change the case of a string or template.
+fn case(case: Case, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect("string or template")?;
+    Ok(match v {
+        Value::Str(v) => Value::Str(case.apply(&v).into()),
+        Value::Template(v) => Value::Template(v.styled(TextNode::CASE, Some(case))),
+        v => bail!(span, "expected string or template, found {}", v.type_name()),
+    })
+}
+
+/// The sorted version of an array.
+pub fn sorted(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    let Spanned { v, span } = args.expect::<Spanned<Array>>("array")?;
+    Ok(Value::Array(v.sorted().at(span)?))
+}
diff --git a/src/library/utility/numbering.rs b/src/library/utility/numbering.rs
new file mode 100644
index 00000000..0070873f
--- /dev/null
+++ b/src/library/utility/numbering.rs
@@ -0,0 +1,111 @@
+use crate::library::prelude::*;
+
+/// Converts an integer into one or multiple letters.
+pub fn letter(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    convert(Numbering::Letter, args)
+}
+
+/// Converts an integer into a roman numeral.
+pub fn roman(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    convert(Numbering::Roman, args)
+}
+
+/// Convert a number into a symbol.
+pub fn symbol(_: &mut Context, args: &mut Args) -> TypResult<Value> {
+    convert(Numbering::Symbol, args)
+}
+
+fn convert(numbering: Numbering, args: &mut Args) -> TypResult<Value> {
+    let n = args.expect::<usize>("non-negative integer")?;
+    Ok(Value::Str(numbering.apply(n)))
+}
+
+/// Allows to convert a number into letters, roman numerals and symbols.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub enum Numbering {
+    Arabic,
+    Letter,
+    Roman,
+    Symbol,
+}
+
+impl Numbering {
+    /// Apply the numbering to the given number.
+    pub fn apply(self, mut n: usize) -> EcoString {
+        match self {
+            Self::Arabic => {
+                format_eco!("{}", n)
+            }
+            Self::Letter => {
+                if n == 0 {
+                    return '-'.into();
+                }
+
+                n -= 1;
+
+                let mut letters = vec![];
+                loop {
+                    letters.push(b'a' + (n % 26) as u8);
+                    n /= 26;
+                    if n == 0 {
+                        break;
+                    }
+                }
+
+                letters.reverse();
+                String::from_utf8(letters).unwrap().into()
+            }
+            Self::Roman => {
+                if n == 0 {
+                    return 'N'.into();
+                }
+
+                // Adapted from Yann Villessuzanne's roman.rs under the Unlicense, at
+                // https://github.com/linfir/roman.rs/
+                let mut fmt = EcoString::new();
+                for &(name, value) in ROMANS {
+                    while n >= value {
+                        n -= value;
+                        fmt.push_str(name);
+                    }
+                }
+
+                fmt
+            }
+            Self::Symbol => {
+                if n == 0 {
+                    return '-'.into();
+                }
+
+                let symbol = SYMBOLS[(n - 1) % SYMBOLS.len()];
+                let amount = ((n - 1) / SYMBOLS.len()) + 1;
+                std::iter::repeat(symbol).take(amount).collect()
+            }
+        }
+    }
+}
+
+static ROMANS: &'static [(&'static str, usize)] = &[
+    ("M̅", 1000000),
+    ("D̅", 500000),
+    ("C̅", 100000),
+    ("L̅", 50000),
+    ("X̅", 10000),
+    ("V̅", 5000),
+    ("I̅V̅", 4000),
+    ("M", 1000),
+    ("CM", 900),
+    ("D", 500),
+    ("CD", 400),
+    ("C", 100),
+    ("XC", 90),
+    ("L", 50),
+    ("XL", 40),
+    ("X", 10),
+    ("IX", 9),
+    ("V", 5),
+    ("IV", 4),
+    ("I", 1),
+];
+
+static SYMBOLS: &'static [char] = &['*', '†', '‡', '§', '‖', '¶'];
-- 
cgit v1.2.3