From e089b6ea40015e012302dc55ac5d6cb42ca4876e Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Tue, 8 Feb 2022 16:39:37 +0100
Subject: Set rules for everything

---
 src/eval/collapse.rs     |  26 +++--
 src/eval/mod.rs          | 150 +++++-------------------
 src/eval/show.rs         |  96 +++++++++++++++
 src/eval/styles.rs       |  30 ++---
 src/eval/template.rs     | 217 ++++++++++++++++++++--------------
 src/eval/value.rs        |   2 +-
 src/layout/mod.rs        |  78 ++++++-------
 src/library/align.rs     |   4 +-
 src/library/columns.rs   |   7 +-
 src/library/container.rs |   2 +-
 src/library/deco.rs      |  76 ++++++------
 src/library/flow.rs      |  34 +++---
 src/library/grid.rs      |   8 +-
 src/library/heading.rs   |  78 +++++++------
 src/library/hide.rs      |   2 +-
 src/library/image.rs     |   5 -
 src/library/link.rs      |  34 +++++-
 src/library/list.rs      |  57 +++++----
 src/library/math.rs      |  32 +++++
 src/library/mod.rs       |  20 ++--
 src/library/pad.rs       |   4 +-
 src/library/page.rs      | 296 ++++++++++++++++++++---------------------------
 src/library/par.rs       |   2 +-
 src/library/place.rs     |   4 +-
 src/library/raw.rs       | 117 +++++++++++++++++++
 src/library/shape.rs     |  10 +-
 src/library/spacing.rs   |   6 +
 src/library/stack.rs     |   4 +-
 src/library/table.rs     |  19 +--
 src/library/text.rs      | 125 +++++++++-----------
 src/library/transform.rs |   7 +-
 src/util/mod.rs          |   2 +
 src/util/prehashed.rs    |  72 ++++++++++++
 33 files changed, 934 insertions(+), 692 deletions(-)
 create mode 100644 src/eval/show.rs
 create mode 100644 src/library/math.rs
 create mode 100644 src/library/raw.rs
 create mode 100644 src/util/prehashed.rs

(limited to 'src')

diff --git a/src/eval/collapse.rs b/src/eval/collapse.rs
index 0e91cae6..ef8a5255 100644
--- a/src/eval/collapse.rs
+++ b/src/eval/collapse.rs
@@ -3,7 +3,7 @@ use super::{StyleChain, StyleVec, StyleVecBuilder};
 /// A wrapper around a [`StyleVecBuilder`] that allows to collapse items.
 pub struct CollapsingBuilder<'a, T> {
     builder: StyleVecBuilder<'a, T>,
-    staged: Vec<(T, StyleChain<'a>, bool)>,
+    staged: Vec<(T, StyleChain<'a>, Option<u8>)>,
     last: Last,
 }
 
@@ -29,9 +29,21 @@ impl<'a, T: Merge> CollapsingBuilder<'a, T> {
     /// and to its right, with no destructive items or weak items in between to
     /// its left and no destructive items in between to its right. There may be
     /// ignorant items in between in both directions.
-    pub fn weak(&mut self, item: T, styles: StyleChain<'a>) {
-        if self.last == Last::Supportive {
-            self.staged.push((item, styles, true));
+    pub fn weak(&mut self, item: T, strength: u8, styles: StyleChain<'a>) {
+        if self.last != Last::Destructive {
+            if self.last == Last::Weak {
+                if let Some(i) = self
+                    .staged
+                    .iter()
+                    .position(|(.., prev)| prev.map_or(false, |p| p < strength))
+                {
+                    self.staged.remove(i);
+                } else {
+                    return;
+                }
+            }
+
+            self.staged.push((item, styles, Some(strength)));
             self.last = Last::Weak;
         }
     }
@@ -52,7 +64,7 @@ impl<'a, T: Merge> CollapsingBuilder<'a, T> {
 
     /// Has no influence on other items.
     pub fn ignorant(&mut self, item: T, styles: StyleChain<'a>) {
-        self.staged.push((item, styles, false));
+        self.staged.push((item, styles, None));
     }
 
     /// Return the finish style vec and the common prefix chain.
@@ -63,8 +75,8 @@ impl<'a, T: Merge> CollapsingBuilder<'a, T> {
 
     /// Push the staged items, filtering out weak items if `supportive` is false.
     fn flush(&mut self, supportive: bool) {
-        for (item, styles, weak) in self.staged.drain(..) {
-            if !weak || supportive {
+        for (item, styles, strength) in self.staged.drain(..) {
+            if supportive || strength.is_none() {
                 push_merging(&mut self.builder, item, styles);
             }
         }
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 98b0152c..5a67555c 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -14,6 +14,7 @@ mod collapse;
 mod func;
 mod ops;
 mod scope;
+mod show;
 mod template;
 
 pub use array::*;
@@ -23,6 +24,7 @@ pub use collapse::*;
 pub use dict::*;
 pub use func::*;
 pub use scope::*;
+pub use show::*;
 pub use styles::*;
 pub use template::*;
 pub use value::*;
@@ -33,34 +35,23 @@ use std::io;
 use std::mem;
 use std::path::PathBuf;
 
-use once_cell::sync::Lazy;
-use syntect::easy::HighlightLines;
-use syntect::highlighting::{FontStyle, Highlighter, Style as SynStyle, Theme, ThemeSet};
-use syntect::parsing::SyntaxSet;
 use unicode_segmentation::UnicodeSegmentation;
 
 use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult};
-use crate::geom::{Angle, Color, Fractional, Length, Paint, Relative};
+use crate::geom::{Angle, Fractional, Length, Relative};
 use crate::image::ImageStore;
 use crate::layout::Layout;
-use crate::library::{self, DecoLine, TextNode};
+use crate::library::{self};
 use crate::loading::Loader;
-use crate::parse;
 use crate::source::{SourceId, SourceStore};
-use crate::syntax;
 use crate::syntax::ast::*;
-use crate::syntax::{RedNode, Span, Spanned};
+use crate::syntax::{Span, Spanned};
 use crate::util::{EcoString, RefMutExt};
 use crate::Context;
 
-static THEME: Lazy<Theme> =
-    Lazy::new(|| ThemeSet::load_defaults().themes.remove("InspiredGitHub").unwrap());
-
-static SYNTAXES: Lazy<SyntaxSet> = Lazy::new(|| SyntaxSet::load_defaults_newlines());
-
 /// An evaluated module, ready for importing or conversion to a root layout
 /// tree.
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Clone)]
 pub struct Module {
     /// The top-level definitions that were bound in this module.
     pub scope: Scope,
@@ -194,17 +185,13 @@ fn eval_markup(
             MarkupNode::Expr(Expr::Wrap(wrap)) => {
                 let tail = eval_markup(ctx, nodes)?;
                 ctx.scopes.def_mut(wrap.binding().take(), tail);
-                wrap.body().eval(ctx)?.show()
+                wrap.body().eval(ctx)?.display()
             }
             _ => node.eval(ctx)?,
         });
     }
 
-    if seq.len() == 1 {
-        Ok(seq.into_iter().next().unwrap())
-    } else {
-        Ok(Template::Sequence(seq))
-    }
+    Ok(Template::sequence(seq))
 }
 
 impl Eval for MarkupNode {
@@ -223,7 +210,7 @@ impl Eval for MarkupNode {
             Self::Heading(heading) => heading.eval(ctx)?,
             Self::List(list) => list.eval(ctx)?,
             Self::Enum(enum_) => enum_.eval(ctx)?,
-            Self::Expr(expr) => expr.eval(ctx)?.show(),
+            Self::Expr(expr) => expr.eval(ctx)?.display(),
         })
     }
 }
@@ -232,7 +219,7 @@ impl Eval for StrongNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
-        Ok(self.body().eval(ctx)?.styled(TextNode::STRONG, true))
+        Ok(Template::show(library::StrongNode(self.body().eval(ctx)?)))
     }
 }
 
@@ -240,7 +227,7 @@ impl Eval for EmphNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
-        Ok(self.body().eval(ctx)?.styled(TextNode::EMPH, true))
+        Ok(Template::show(library::EmphNode(self.body().eval(ctx)?)))
     }
 }
 
@@ -248,104 +235,25 @@ impl Eval for RawNode {
     type Output = Template;
 
     fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> {
-        let code = self.highlighted();
-        Ok(if self.block { Template::Block(code.pack()) } else { code })
-    }
-}
-
-impl RawNode {
-    /// Styled template for a code block, with optional syntax highlighting.
-    pub fn highlighted(&self) -> Template {
-        let mut seq: Vec<Template> = vec![];
-
-        let syntax = if let Some(syntax) = self
-            .lang
-            .as_ref()
-            .and_then(|token| SYNTAXES.find_syntax_by_token(&token))
-        {
-            Some(syntax)
-        } else if matches!(
-            self.lang.as_ref().map(|s| s.to_ascii_lowercase()).as_deref(),
-            Some("typ" | "typst")
-        ) {
-            None
-        } else {
-            return Template::Text(self.text.clone()).monospaced();
-        };
-
-        let foreground = THEME
-            .settings
-            .foreground
-            .map(Color::from)
-            .unwrap_or(Color::BLACK)
-            .into();
-
-        match syntax {
-            Some(syntax) => {
-                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(style_piece(piece, foreground, style));
-                    }
-                }
-            }
-            None => {
-                let green = 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(style_piece(&self.text[range], foreground, style));
-                    },
-                )
-            }
-        }
-
-        Template::Sequence(seq).monospaced()
-    }
-}
-
-/// Style a piece of text with a syntect style.
-fn style_piece(piece: &str, foreground: Paint, style: SynStyle) -> Template {
-    let mut styles = StyleMap::new();
-
-    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) {
-        styles.set(TextNode::LINES, vec![DecoLine::Underline.into()]);
+        let template = Template::show(library::RawNode {
+            text: self.text.clone(),
+            block: self.block,
+        });
+        Ok(match self.lang {
+            Some(_) => template.styled(library::RawNode::LANG, self.lang.clone()),
+            None => template,
+        })
     }
-
-    Template::Text(piece.into()).styled_with_map(styles)
 }
 
 impl Eval for MathNode {
     type Output = Template;
 
     fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> {
-        let text = Template::Text(self.formula.trim().into()).monospaced();
-        Ok(if self.display {
-            Template::Block(text.pack())
-        } else {
-            text
-        })
+        Ok(Template::show(library::MathNode {
+            formula: self.formula.clone(),
+            display: self.display,
+        }))
     }
 }
 
@@ -353,8 +261,8 @@ impl Eval for HeadingNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
-        Ok(Template::block(library::HeadingNode {
-            child: self.body().eval(ctx)?.pack(),
+        Ok(Template::show(library::HeadingNode {
+            body: self.body().eval(ctx)?,
             level: self.level(),
         }))
     }
@@ -364,9 +272,9 @@ impl Eval for ListNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
-        Ok(Template::block(library::ListNode {
+        Ok(Template::show(library::ListNode {
             child: self.body().eval(ctx)?.pack(),
-            kind: library::Unordered,
+            label: library::Unordered,
         }))
     }
 }
@@ -375,9 +283,9 @@ impl Eval for EnumNode {
     type Output = Template;
 
     fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
-        Ok(Template::block(library::ListNode {
+        Ok(Template::show(library::ListNode {
             child: self.body().eval(ctx)?.pack(),
-            kind: library::Ordered(self.number()),
+            label: library::Ordered(self.number()),
         }))
     }
 }
diff --git a/src/eval/show.rs b/src/eval/show.rs
new file mode 100644
index 00000000..6157485d
--- /dev/null
+++ b/src/eval/show.rs
@@ -0,0 +1,96 @@
+use std::any::{Any, TypeId};
+use std::fmt::{self, Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use super::{StyleChain, Template};
+use crate::util::Prehashed;
+
+/// A node that can be realized given some styles.
+pub trait Show {
+    /// Realize the template in the given styles.
+    fn show(&self, styles: StyleChain) -> Template;
+
+    /// Convert to a packed show node.
+    fn pack(self) -> ShowNode
+    where
+        Self: Debug + Hash + Sized + Sync + Send + 'static,
+    {
+        ShowNode::new(self)
+    }
+}
+
+/// A type-erased showable node with a precomputed hash.
+#[derive(Clone, Hash)]
+pub struct ShowNode(Arc<Prehashed<dyn Bounds>>);
+
+impl ShowNode {
+    /// Pack any showable node.
+    pub fn new<T>(node: T) -> Self
+    where
+        T: Show + Debug + Hash + Sync + Send + 'static,
+    {
+        Self(Arc::new(Prehashed::new(node)))
+    }
+
+    /// The type id of this node.
+    pub fn id(&self) -> TypeId {
+        self.0.as_any().type_id()
+    }
+}
+
+impl Show for ShowNode {
+    fn show(&self, styles: StyleChain) -> Template {
+        self.0.show(styles)
+    }
+
+    fn pack(self) -> ShowNode {
+        self
+    }
+}
+
+impl Debug for ShowNode {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl PartialEq for ShowNode {
+    fn eq(&self, other: &Self) -> bool {
+        // We cast to thin pointers for comparison because we don't want to
+        // compare vtables (which can be different across codegen units).
+        std::ptr::eq(
+            Arc::as_ptr(&self.0) as *const (),
+            Arc::as_ptr(&other.0) as *const (),
+        )
+    }
+}
+
+trait Bounds: Show + Debug + Sync + Send + 'static {
+    fn as_any(&self) -> &dyn Any;
+    fn hash64(&self) -> u64;
+}
+
+impl<T> Bounds for T
+where
+    T: Show + Debug + Hash + Sync + Send + 'static,
+{
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn hash64(&self) -> u64 {
+        // Also hash the TypeId since nodes with different types but
+        // equal data should be different.
+        let mut state = fxhash::FxHasher64::default();
+        self.type_id().hash(&mut state);
+        self.hash(&mut state);
+        state.finish()
+    }
+}
+
+impl Hash for dyn Bounds {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_u64(self.hash64());
+    }
+}
diff --git a/src/eval/styles.rs b/src/eval/styles.rs
index 863dcc6f..2bf3f239 100644
--- a/src/eval/styles.rs
+++ b/src/eval/styles.rs
@@ -49,6 +49,11 @@ impl StyleMap {
         self
     }
 
+    /// Whether this map contains scoped styles.
+    pub fn has_scoped(&self) -> bool {
+        self.0.iter().any(|e| e.scoped)
+    }
+
     /// Make `self` the first link of the style chain `outer`.
     ///
     /// The resulting style chain contains styles from `self` as well as
@@ -136,20 +141,6 @@ impl<'a> StyleChain<'a> {
         self.links().count()
     }
 
-    /// Convert to an owned style map.
-    ///
-    /// Panics if the chain contains barrier links.
-    pub fn to_map(self) -> StyleMap {
-        let mut suffix = StyleMap::new();
-        for link in self.links() {
-            match link {
-                Link::Map(map) => suffix.apply(map),
-                Link::Barrier(_) => panic!("chain contains barrier"),
-            }
-        }
-        suffix
-    }
-
     /// Build a style map from the suffix (all links beyond the `len`) of the
     /// chain.
     ///
@@ -170,6 +161,17 @@ impl<'a> StyleChain<'a> {
     pub fn pop(&mut self) {
         *self = self.outer.copied().unwrap_or_default();
     }
+
+    /// Return the chain, but without the last link if that one contains only
+    /// scoped styles. This is a hack.
+    pub(crate) fn unscoped(mut self, node: TypeId) -> Self {
+        if let Some(Link::Map(map)) = self.link {
+            if map.0.iter().all(|e| e.scoped && e.is_of_id(node)) {
+                self.pop();
+            }
+        }
+        self
+    }
 }
 
 impl<'a> StyleChain<'a> {
diff --git a/src/eval/template.rs b/src/eval/template.rs
index a6693c84..84888b95 100644
--- a/src/eval/template.rs
+++ b/src/eval/template.rs
@@ -6,12 +6,15 @@ use std::ops::{Add, AddAssign};
 
 use typed_arena::Arena;
 
-use super::{CollapsingBuilder, Interruption, Property, StyleMap, StyleVecBuilder};
+use super::{
+    CollapsingBuilder, Interruption, Property, Show, ShowNode, StyleMap, StyleVecBuilder,
+};
 use crate::diag::StrResult;
-use crate::layout::{Layout, PackedNode};
+use crate::layout::{Layout, LayoutNode};
 use crate::library::prelude::*;
 use crate::library::{
-    FlowChild, FlowNode, PageNode, ParChild, ParNode, PlaceNode, SpacingKind, TextNode,
+    DecoNode, FlowChild, FlowNode, PageNode, ParChild, ParNode, PlaceNode, SpacingKind,
+    TextNode, Underline,
 };
 use crate::util::EcoString;
 use crate::Context;
@@ -52,7 +55,7 @@ pub enum Template {
     /// Plain text.
     Text(EcoString),
     /// An inline-level node.
-    Inline(PackedNode),
+    Inline(LayoutNode),
     /// A paragraph break.
     Parbreak,
     /// A column break.
@@ -60,21 +63,23 @@ pub enum Template {
     /// Vertical spacing.
     Vertical(SpacingKind),
     /// A block-level node.
-    Block(PackedNode),
+    Block(LayoutNode),
     /// A page break.
     Pagebreak,
     /// A page node.
     Page(PageNode),
+    /// A node that can be realized with styles.
+    Show(ShowNode),
     /// A template with attached styles.
-    Styled(Box<Self>, StyleMap),
+    Styled(Arc<(Self, StyleMap)>),
     /// A sequence of multiple subtemplates.
-    Sequence(Vec<Self>),
+    Sequence(Arc<Vec<Self>>),
 }
 
 impl Template {
     /// Create an empty template.
     pub fn new() -> Self {
-        Self::Sequence(vec![])
+        Self::sequence(vec![])
     }
 
     /// Create a template from an inline-level node.
@@ -93,42 +98,63 @@ impl Template {
         Self::Block(node.pack())
     }
 
-    /// Layout this template into a collection of pages.
-    pub fn layout(&self, ctx: &mut Context) -> Vec<Arc<Frame>> {
-        let (mut ctx, styles) = LayoutContext::new(ctx);
-        let (pages, shared) = Builder::build_pages(self);
-        let styles = shared.chain(&styles);
-        pages
-            .iter()
-            .flat_map(|(page, map)| page.layout(&mut ctx, map.chain(&styles)))
-            .collect()
+    /// Create a template from a showable node.
+    pub fn show<T>(node: T) -> Self
+    where
+        T: Show + Debug + Hash + Sync + Send + 'static,
+    {
+        Self::Show(node.pack())
     }
 
     /// Style this template with a single property.
     pub fn styled<P: Property>(mut self, key: P, value: P::Value) -> Self {
-        if let Self::Styled(_, map) = &mut self {
-            map.set(key, value);
-            self
-        } else {
-            self.styled_with_map(StyleMap::with(key, value))
+        if let Self::Styled(styled) = &mut self {
+            if let Some((_, map)) = Arc::get_mut(styled) {
+                if !map.has_scoped() {
+                    map.set(key, value);
+                }
+                return self;
+            }
         }
+
+        self.styled_with_map(StyleMap::with(key, value))
     }
 
     /// Style this template with a full style map.
     pub fn styled_with_map(mut self, styles: StyleMap) -> Self {
         if styles.is_empty() {
-            self
-        } else if let Self::Styled(_, map) = &mut self {
-            map.apply(&styles);
-            self
-        } else {
-            Self::Styled(Box::new(self), styles)
+            return self;
         }
+
+        if let Self::Styled(styled) = &mut self {
+            if let Some((_, map)) = Arc::get_mut(styled) {
+                if !styles.has_scoped() && !map.has_scoped() {
+                    map.apply(&styles);
+                    return self;
+                }
+            }
+        }
+
+        Self::Styled(Arc::new((self, styles)))
     }
 
     /// Style this template in monospace.
     pub fn monospaced(self) -> Self {
-        self.styled(TextNode::MONOSPACE, true)
+        self.styled(TextNode::MONOSPACED, true)
+    }
+
+    /// Underline this template.
+    pub fn underlined(self) -> Self {
+        Self::show(DecoNode { kind: Underline, body: self })
+    }
+
+    /// Create a new sequence template.
+    pub fn sequence(seq: Vec<Self>) -> Self {
+        if seq.len() == 1 {
+            seq.into_iter().next().unwrap()
+        } else {
+            Self::Sequence(Arc::new(seq))
+        }
     }
 
     /// Repeat this template `n` times.
@@ -136,7 +162,24 @@ impl Template {
         let count = usize::try_from(n)
             .map_err(|_| format!("cannot repeat this template {} times", n))?;
 
-        Ok(Self::Sequence(vec![self.clone(); count]))
+        Ok(Self::sequence(vec![self.clone(); count]))
+    }
+
+    /// Layout this template into a collection of pages.
+    pub fn layout(&self, ctx: &mut Context) -> Vec<Arc<Frame>> {
+        let style_arena = Arena::new();
+        let template_arena = Arena::new();
+        let (mut ctx, styles) = LayoutContext::new(ctx);
+
+        let mut builder = Builder::new(&style_arena, &template_arena, true);
+        builder.process(self, styles);
+        builder.finish_page(true, false, styles);
+
+        let (pages, shared) = builder.pages.unwrap().finish();
+        pages
+            .iter()
+            .flat_map(|(page, map)| page.layout(&mut ctx, map.chain(&shared)))
+            .collect()
     }
 }
 
@@ -168,11 +211,17 @@ impl Debug for Template {
             }
             Self::Pagebreak => f.pad("Pagebreak"),
             Self::Page(page) => page.fmt(f),
-            Self::Styled(sub, map) => {
+            Self::Show(node) => {
+                f.write_str("Show(")?;
+                node.fmt(f)?;
+                f.write_str(")")
+            }
+            Self::Styled(styled) => {
+                let (sub, map) = styled.as_ref();
                 map.fmt(f)?;
                 sub.fmt(f)
             }
-            Self::Sequence(seq) => f.debug_list().entries(seq).finish(),
+            Self::Sequence(seq) => f.debug_list().entries(seq.iter()).finish(),
         }
     }
 }
@@ -183,20 +232,22 @@ impl Add for Template {
     fn add(self, rhs: Self) -> Self::Output {
         Self::Sequence(match (self, rhs) {
             (Self::Sequence(mut lhs), Self::Sequence(rhs)) => {
-                lhs.extend(rhs);
+                let mutable = Arc::make_mut(&mut lhs);
+                match Arc::try_unwrap(rhs) {
+                    Ok(vec) => mutable.extend(vec),
+                    Err(rc) => mutable.extend(rc.iter().cloned()),
+                }
                 lhs
             }
             (Self::Sequence(mut lhs), rhs) => {
-                lhs.push(rhs);
+                Arc::make_mut(&mut lhs).push(rhs);
                 lhs
             }
             (lhs, Self::Sequence(mut rhs)) => {
-                rhs.insert(0, lhs);
+                Arc::make_mut(&mut rhs).insert(0, lhs);
                 rhs
             }
-            (lhs, rhs) => {
-                vec![lhs, rhs]
-            }
+            (lhs, rhs) => Arc::new(vec![lhs, rhs]),
         })
     }
 }
@@ -209,7 +260,7 @@ impl AddAssign for Template {
 
 impl Sum for Template {
     fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        Self::Sequence(iter.collect())
+        Self::sequence(iter.collect())
     }
 }
 
@@ -220,14 +271,21 @@ impl Layout for Template {
         regions: &Regions,
         styles: StyleChain,
     ) -> Vec<Constrained<Arc<Frame>>> {
-        let (flow, shared) = Builder::build_flow(self);
-        flow.layout(ctx, regions, shared.chain(&styles))
+        let style_arena = Arena::new();
+        let template_arena = Arena::new();
+
+        let mut builder = Builder::new(&style_arena, &template_arena, false);
+        builder.process(self, styles);
+        builder.finish_par(styles);
+
+        let (flow, shared) = builder.flow.finish();
+        FlowNode(flow).layout(ctx, regions, shared)
     }
 
-    fn pack(self) -> PackedNode {
+    fn pack(self) -> LayoutNode {
         match self {
             Template::Block(node) => node,
-            other => PackedNode::new(other),
+            other => LayoutNode::new(other),
         }
     }
 }
@@ -235,7 +293,9 @@ impl Layout for Template {
 /// Builds a flow or page nodes from a template.
 struct Builder<'a> {
     /// An arena where intermediate style chains are stored.
-    arena: &'a Arena<StyleChain<'a>>,
+    style_arena: &'a Arena<StyleChain<'a>>,
+    /// An arena where intermediate templates are stored.
+    template_arena: &'a Arena<Template>,
     /// The already built page runs.
     pages: Option<StyleVecBuilder<'a, PageNode>>,
     /// The currently built flow.
@@ -247,34 +307,15 @@ struct Builder<'a> {
 }
 
 impl<'a> Builder<'a> {
-    /// Build page runs from a template.
-    fn build_pages(template: &Template) -> (StyleVec<PageNode>, StyleMap) {
-        let arena = Arena::new();
-
-        let mut builder = Builder::prepare(&arena, true);
-        builder.process(template, StyleChain::default());
-        builder.finish_page(true, false, StyleChain::default());
-
-        let (pages, shared) = builder.pages.unwrap().finish();
-        (pages, shared.to_map())
-    }
-
-    /// Build a subflow from a template.
-    fn build_flow(template: &Template) -> (FlowNode, StyleMap) {
-        let arena = Arena::new();
-
-        let mut builder = Builder::prepare(&arena, false);
-        builder.process(template, StyleChain::default());
-        builder.finish_par();
-
-        let (flow, shared) = builder.flow.finish();
-        (FlowNode(flow), shared.to_map())
-    }
-
     /// Prepare the builder.
-    fn prepare(arena: &'a Arena<StyleChain<'a>>, top: bool) -> Self {
+    fn new(
+        style_arena: &'a Arena<StyleChain<'a>>,
+        template_arena: &'a Arena<Template>,
+        top: bool,
+    ) -> Self {
         Self {
-            arena,
+            style_arena,
+            template_arena,
             pages: top.then(|| StyleVecBuilder::new()),
             flow: CollapsingBuilder::new(),
             par: CollapsingBuilder::new(),
@@ -286,7 +327,7 @@ impl<'a> Builder<'a> {
     fn process(&mut self, template: &'a Template, styles: StyleChain<'a>) {
         match template {
             Template::Space => {
-                self.par.weak(ParChild::Text(' '.into()), styles);
+                self.par.weak(ParChild::Text(' '.into()), 0, styles);
             }
             Template::Linebreak => {
                 self.par.destructive(ParChild::Text('\n'.into()), styles);
@@ -306,15 +347,15 @@ impl<'a> Builder<'a> {
                 self.par.supportive(ParChild::Node(node.clone()), styles);
             }
             Template::Parbreak => {
-                self.finish_par();
-                self.flow.weak(FlowChild::Parbreak, styles);
+                self.finish_par(styles);
+                self.flow.weak(FlowChild::Parbreak, 1, styles);
             }
             Template::Colbreak => {
-                self.finish_par();
+                self.finish_par(styles);
                 self.flow.destructive(FlowChild::Colbreak, styles);
             }
             Template::Vertical(kind) => {
-                self.finish_par();
+                self.finish_par(styles);
                 let child = FlowChild::Spacing(*kind);
                 if kind.is_fractional() {
                     self.flow.destructive(child, styles);
@@ -323,13 +364,14 @@ impl<'a> Builder<'a> {
                 }
             }
             Template::Block(node) => {
-                self.finish_par();
+                self.finish_par(styles);
                 let child = FlowChild::Node(node.clone());
                 if node.is::<PlaceNode>() {
                     self.flow.ignorant(child, styles);
                 } else {
                     self.flow.supportive(child, styles);
                 }
+                self.finish_par(styles);
             }
             Template::Pagebreak => {
                 self.finish_page(true, true, styles);
@@ -340,26 +382,32 @@ impl<'a> Builder<'a> {
                     pages.push(page.clone(), styles);
                 }
             }
-            Template::Styled(sub, map) => {
+            Template::Show(node) => {
+                let template = self.template_arena.alloc(node.show(styles));
+                self.process(template, styles.unscoped(node.id()));
+            }
+            Template::Styled(styled) => {
+                let (sub, map) = styled.as_ref();
+                let stored = self.style_arena.alloc(styles);
+                let styles = map.chain(stored);
+
                 let interruption = map.interruption();
                 match interruption {
                     Some(Interruption::Page) => self.finish_page(false, true, styles),
-                    Some(Interruption::Par) => self.finish_par(),
+                    Some(Interruption::Par) => self.finish_par(styles),
                     None => {}
                 }
 
-                let outer = self.arena.alloc(styles);
-                let styles = map.chain(outer);
                 self.process(sub, styles);
 
                 match interruption {
                     Some(Interruption::Page) => self.finish_page(true, false, styles),
-                    Some(Interruption::Par) => self.finish_par(),
+                    Some(Interruption::Par) => self.finish_par(styles),
                     None => {}
                 }
             }
             Template::Sequence(seq) => {
-                for sub in seq {
+                for sub in seq.iter() {
                     self.process(sub, styles);
                 }
             }
@@ -367,17 +415,18 @@ impl<'a> Builder<'a> {
     }
 
     /// Finish the currently built paragraph.
-    fn finish_par(&mut self) {
+    fn finish_par(&mut self, styles: StyleChain<'a>) {
         let (par, shared) = mem::take(&mut self.par).finish();
         if !par.is_empty() {
             let node = ParNode(par).pack();
             self.flow.supportive(FlowChild::Node(node), shared);
         }
+        self.flow.weak(FlowChild::Leading, 0, styles);
     }
 
     /// Finish the currently built page run.
     fn finish_page(&mut self, keep_last: bool, keep_next: bool, styles: StyleChain<'a>) {
-        self.finish_par();
+        self.finish_par(styles);
         if let Some(pages) = &mut self.pages {
             let (flow, shared) = mem::take(&mut self.flow).finish();
             if !flow.is_empty() || (keep_last && self.keep_next) {
diff --git a/src/eval/value.rs b/src/eval/value.rs
index d0b822f1..2d37b34f 100644
--- a/src/eval/value.rs
+++ b/src/eval/value.rs
@@ -115,7 +115,7 @@ impl Value {
     }
 
     /// Return the display representation of the value.
-    pub fn show(self) -> Template {
+    pub fn display(self) -> Template {
         match self {
             Value::None => Template::new(),
             Value::Int(v) => Template::Text(format_eco!("{}", v)),
diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 3cccee28..139d027a 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -10,7 +10,7 @@ pub use constraints::*;
 pub use incremental::*;
 pub use regions::*;
 
-use std::any::Any;
+use std::any::{Any, TypeId};
 use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
@@ -21,6 +21,7 @@ use crate::frame::{Element, Frame, Geometry, Shape, Stroke};
 use crate::geom::{Align, Linear, Paint, Point, Sides, Size, Spec};
 use crate::image::ImageStore;
 use crate::library::{AlignNode, Move, PadNode, TransformNode};
+use crate::util::Prehashed;
 use crate::Context;
 
 /// A node that can be layouted into a sequence of regions.
@@ -37,11 +38,11 @@ pub trait Layout {
     ) -> Vec<Constrained<Arc<Frame>>>;
 
     /// Convert to a packed node.
-    fn pack(self) -> PackedNode
+    fn pack(self) -> LayoutNode
     where
         Self: Debug + Hash + Sized + Sync + Send + 'static,
     {
-        PackedNode::new(self)
+        LayoutNode::new(self)
     }
 }
 
@@ -75,31 +76,26 @@ impl<'a> LayoutContext<'a> {
 }
 
 /// A type-erased layouting node with a precomputed hash.
-#[derive(Clone)]
-pub struct PackedNode {
-    /// The type-erased node.
-    node: Arc<dyn Bounds>,
-    /// A precomputed hash for the node.
-    #[cfg(feature = "layout-cache")]
-    hash: u64,
-}
+#[derive(Clone, Hash)]
+pub struct LayoutNode(Arc<Prehashed<dyn Bounds>>);
 
-impl PackedNode {
+impl LayoutNode {
     /// Pack any layoutable node.
     pub fn new<T>(node: T) -> Self
     where
         T: Layout + Debug + Hash + Sync + Send + 'static,
     {
-        Self {
-            #[cfg(feature = "layout-cache")]
-            hash: node.hash64(),
-            node: Arc::new(node),
-        }
+        Self(Arc::new(Prehashed::new(node)))
     }
 
     /// Check whether the contained node is a specific layout node.
     pub fn is<T: 'static>(&self) -> bool {
-        self.node.as_any().is::<T>()
+        self.0.as_any().is::<T>()
+    }
+
+    /// The type id of this node.
+    pub fn id(&self) -> TypeId {
+        self.0.as_any().type_id()
     }
 
     /// Try to downcast to a specific layout node.
@@ -107,7 +103,7 @@ impl PackedNode {
     where
         T: Layout + Debug + Hash + 'static,
     {
-        self.node.as_any().downcast_ref()
+        self.0.as_any().downcast_ref()
     }
 
     /// Force a size for this node.
@@ -165,7 +161,7 @@ impl PackedNode {
     }
 }
 
-impl Layout for PackedNode {
+impl Layout for LayoutNode {
     #[track_caller]
     fn layout(
         &self,
@@ -173,7 +169,7 @@ impl Layout for PackedNode {
         regions: &Regions,
         styles: StyleChain,
     ) -> Vec<Constrained<Arc<Frame>>> {
-        let styles = styles.barred(self.node.as_any().type_id());
+        let styles = styles.barred(self.id());
 
         #[cfg(not(feature = "layout-cache"))]
         return self.node.layout(ctx, regions, styles);
@@ -193,14 +189,14 @@ impl Layout for PackedNode {
             frames
         } else {
             ctx.level += 1;
-            let frames = self.node.layout(ctx, regions, styles);
+            let frames = self.0.layout(ctx, regions, styles);
             ctx.level -= 1;
 
             let entry = FramesEntry::new(frames.clone(), ctx.level);
 
             #[cfg(debug_assertions)]
             if !entry.check(regions) {
-                eprintln!("node: {:#?}", self.node);
+                eprintln!("node: {:#?}", self.0);
                 eprintln!("regions: {regions:#?}");
                 eprintln!(
                     "constraints: {:#?}",
@@ -214,44 +210,34 @@ impl Layout for PackedNode {
         }
     }
 
-    fn pack(self) -> PackedNode {
+    fn pack(self) -> LayoutNode {
         self
     }
 }
 
-impl Default for PackedNode {
+impl Default for LayoutNode {
     fn default() -> Self {
         EmptyNode.pack()
     }
 }
 
-impl Debug for PackedNode {
+impl Debug for LayoutNode {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        self.node.fmt(f)
+        self.0.fmt(f)
     }
 }
 
-impl PartialEq for PackedNode {
+impl PartialEq for LayoutNode {
     fn eq(&self, other: &Self) -> bool {
         // We cast to thin pointers for comparison because we don't want to
         // compare vtables (which can be different across codegen units).
         std::ptr::eq(
-            Arc::as_ptr(&self.node) as *const (),
-            Arc::as_ptr(&other.node) as *const (),
+            Arc::as_ptr(&self.0) as *const (),
+            Arc::as_ptr(&other.0) as *const (),
         )
     }
 }
 
-impl Hash for PackedNode {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        // Hash the node.
-        #[cfg(feature = "layout-cache")]
-        state.write_u64(self.hash);
-        #[cfg(not(feature = "layout-cache"))]
-        state.write_u64(self.hash64());
-    }
-}
-
 trait Bounds: Layout + Debug + Sync + Send + 'static {
     fn as_any(&self) -> &dyn Any;
     fn hash64(&self) -> u64;
@@ -275,6 +261,12 @@ where
     }
 }
 
+impl Hash for dyn Bounds {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_u64(self.hash64());
+    }
+}
+
 /// A layout node that produces an empty frame.
 ///
 /// The packed version of this is returned by [`PackedNode::default`].
@@ -301,7 +293,7 @@ struct SizedNode {
     /// How to size the node horizontally and vertically.
     sizing: Spec<Option<Linear>>,
     /// The node to be sized.
-    child: PackedNode,
+    child: LayoutNode,
 }
 
 impl Layout for SizedNode {
@@ -355,7 +347,7 @@ struct FillNode {
     /// How to fill the frames resulting from the `child`.
     fill: Paint,
     /// The node to fill.
-    child: PackedNode,
+    child: LayoutNode,
 }
 
 impl Layout for FillNode {
@@ -380,7 +372,7 @@ struct StrokeNode {
     /// How to stroke the frames resulting from the `child`.
     stroke: Stroke,
     /// The node to stroke.
-    child: PackedNode,
+    child: LayoutNode,
 }
 
 impl Layout for StrokeNode {
diff --git a/src/library/align.rs b/src/library/align.rs
index 5d89dcb6..5dc12938 100644
--- a/src/library/align.rs
+++ b/src/library/align.rs
@@ -9,14 +9,14 @@ pub struct AlignNode {
     /// How to align the node horizontally and vertically.
     pub aligns: Spec<Option<Align>>,
     /// The node to be aligned.
-    pub child: PackedNode,
+    pub child: LayoutNode,
 }
 
 #[class]
 impl AlignNode {
     fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
         let aligns: Spec<_> = args.find().unwrap_or_default();
-        let body: PackedNode = args.expect("body")?;
+        let body: LayoutNode = args.expect("body")?;
         Ok(Template::block(body.aligned(aligns)))
     }
 }
diff --git a/src/library/columns.rs b/src/library/columns.rs
index 9e696b49..98989c5a 100644
--- a/src/library/columns.rs
+++ b/src/library/columns.rs
@@ -10,7 +10,7 @@ pub struct ColumnsNode {
     pub columns: NonZeroUsize,
     /// The child to be layouted into the columns. Most likely, this should be a
     /// flow or stack node.
-    pub child: PackedNode,
+    pub child: LayoutNode,
 }
 
 #[class]
@@ -24,11 +24,6 @@ impl ColumnsNode {
             child: args.expect("body")?,
         }))
     }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        styles.set_opt(Self::GUTTER, args.named("gutter")?);
-        Ok(())
-    }
 }
 
 impl Layout for ColumnsNode {
diff --git a/src/library/container.rs b/src/library/container.rs
index d2a4f481..143bddfc 100644
--- a/src/library/container.rs
+++ b/src/library/container.rs
@@ -10,7 +10,7 @@ impl BoxNode {
     fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
         let width = args.named("width")?;
         let height = args.named("height")?;
-        let body: PackedNode = args.find().unwrap_or_default();
+        let body: LayoutNode = args.find().unwrap_or_default();
         Ok(Template::inline(body.sized(Spec::new(width, height))))
     }
 }
diff --git a/src/library/deco.rs b/src/library/deco.rs
index ec2235bc..40ef4e73 100644
--- a/src/library/deco.rs
+++ b/src/library/deco.rs
@@ -4,57 +4,67 @@ use super::prelude::*;
 use super::TextNode;
 
 /// Typeset underline, striken-through or overlined text.
-pub struct DecoNode<L: LineKind>(pub L);
+#[derive(Debug, Hash)]
+pub struct DecoNode<L: LineKind> {
+    /// The kind of line.
+    pub kind: L,
+    /// The decorated contents.
+    pub body: Template,
+}
 
 #[class]
 impl<L: LineKind> 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 EvalContext, args: &mut Args) -> TypResult<Template> {
-        let deco = Decoration {
+        Ok(Template::show(Self {
+            kind: L::default(),
+            body: args.expect::<Template>("body")?,
+        }))
+    }
+}
+
+impl<L: LineKind> Show for DecoNode<L> {
+    fn show(&self, styles: StyleChain) -> Template {
+        self.body.clone().styled(TextNode::LINES, vec![Decoration {
             line: L::LINE,
-            stroke: args.named("stroke")?.or_else(|| args.find()),
-            thickness: args.named::<Linear>("thickness")?.or_else(|| args.find()),
-            offset: args.named("offset")?,
-            extent: args.named("extent")?.unwrap_or_default(),
-            evade: args.named("evade")?.unwrap_or(true),
-        };
-        Ok(args.expect::<Template>("body")?.styled(TextNode::LINES, vec![deco]))
+            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 {
-    /// Which line to draw.
     pub line: DecoLine,
-    /// Stroke color of the line, defaults to the text color if `None`.
     pub stroke: Option<Paint>,
-    /// Thickness of the line's strokes (dependent on scaled font size), read
-    /// from the font tables if `None`.
     pub thickness: Option<Linear>,
-    /// Position of the line relative to the baseline (dependent on scaled font
-    /// size), read from the font tables if `None`.
     pub offset: Option<Linear>,
-    /// Amount that the line will be longer or shorter than its associated text
-    /// (dependent on scaled font size).
     pub extent: Linear,
-    /// Whether the line skips sections in which it would collide
-    /// with the glyphs. Does not apply to strikethrough.
     pub evade: bool,
 }
 
-impl From<DecoLine> for Decoration {
-    fn from(line: DecoLine) -> Self {
-        Self {
-            line,
-            stroke: None,
-            thickness: None,
-            offset: None,
-            extent: Linear::zero(),
-            evade: true,
-        }
-    }
-}
-
 /// The kind of decorative line.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub enum DecoLine {
@@ -67,7 +77,7 @@ pub enum DecoLine {
 }
 
 /// Different kinds of decorative lines for text.
-pub trait LineKind {
+pub trait LineKind: Debug + Default + Hash + Sync + Send + 'static {
     const LINE: DecoLine;
 }
 
diff --git a/src/library/flow.rs b/src/library/flow.rs
index bba296a0..ca554033 100644
--- a/src/library/flow.rs
+++ b/src/library/flow.rs
@@ -13,6 +13,8 @@ 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.
@@ -20,7 +22,7 @@ pub enum FlowChild {
     /// Vertical spacing between other children.
     Spacing(SpacingKind),
     /// An arbitrary block-level node.
-    Node(PackedNode),
+    Node(LayoutNode),
 }
 
 impl Layout for FlowNode {
@@ -35,10 +37,17 @@ impl Layout for FlowNode {
         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 amount = styles.get(ParNode::SPACING).resolve(em);
-                    layouter.layout_spacing(SpacingKind::Linear(amount.into()));
+                    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();
@@ -72,6 +81,7 @@ impl Debug for FlowNode {
 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),
@@ -93,8 +103,6 @@ pub struct FlowLayouter {
     used: Size,
     /// The sum of fractional ratios in the current region.
     fr: Fractional,
-    /// Whether to add leading before the next node.
-    leading: bool,
     /// Spacing and layouted nodes.
     items: Vec<FlowItem>,
     /// Finished frames for previous regions.
@@ -129,7 +137,6 @@ impl FlowLayouter {
             full,
             used: Size::zero(),
             fr: Fractional::zero(),
-            leading: false,
             items: vec![],
             finished: vec![],
         }
@@ -149,7 +156,6 @@ impl FlowLayouter {
             SpacingKind::Fractional(v) => {
                 self.items.push(FlowItem::Fractional(v));
                 self.fr += v;
-                self.leading = false;
             }
         }
     }
@@ -158,7 +164,7 @@ impl FlowLayouter {
     pub fn layout_node(
         &mut self,
         ctx: &mut LayoutContext,
-        node: &PackedNode,
+        node: &LayoutNode,
         styles: StyleChain,
     ) {
         // Don't even try layouting into a full region.
@@ -168,9 +174,7 @@ impl FlowLayouter {
 
         // Placed nodes that are out of flow produce placed items which aren't
         // aligned later.
-        let mut is_placed = false;
         if let Some(placed) = node.downcast::<PlaceNode>() {
-            is_placed = true;
             if placed.out_of_flow() {
                 let frame = node.layout(ctx, &self.regions, styles).remove(0);
                 self.items.push(FlowItem::Placed(frame.item));
@@ -178,13 +182,6 @@ impl FlowLayouter {
             }
         }
 
-        // Add leading.
-        if self.leading {
-            let em = styles.get(TextNode::SIZE).abs;
-            let amount = styles.get(ParNode::LEADING).resolve(em);
-            self.layout_spacing(SpacingKind::Linear(amount.into()));
-        }
-
         // How to align the node.
         let aligns = Spec::new(
             // For non-expanding paragraphs it is crucial that we align the
@@ -210,8 +207,6 @@ impl FlowLayouter {
                 self.finish_region();
             }
         }
-
-        self.leading = !is_placed;
     }
 
     /// Finish the frame for one region.
@@ -264,7 +259,6 @@ impl FlowLayouter {
         self.full = self.regions.current;
         self.used = Size::zero();
         self.fr = Fractional::zero();
-        self.leading = false;
         self.finished.push(output.constrain(cts));
     }
 
diff --git a/src/library/grid.rs b/src/library/grid.rs
index 59fe8486..f85e5d56 100644
--- a/src/library/grid.rs
+++ b/src/library/grid.rs
@@ -10,7 +10,7 @@ pub struct GridNode {
     /// 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<PackedNode>,
+    pub children: Vec<LayoutNode>,
 }
 
 #[class]
@@ -92,7 +92,7 @@ castable! {
 /// Performs grid layout.
 pub struct GridLayouter<'a> {
     /// The  grid cells.
-    cells: &'a [PackedNode],
+    cells: &'a [LayoutNode],
     /// The column tracks including gutter tracks.
     cols: Vec<TrackSizing>,
     /// The row tracks including gutter tracks.
@@ -136,7 +136,7 @@ impl<'a> GridLayouter<'a> {
     pub fn new(
         tracks: Spec<&[TrackSizing]>,
         gutter: Spec<&[TrackSizing]>,
-        cells: &'a [PackedNode],
+        cells: &'a [LayoutNode],
         regions: &Regions,
         styles: StyleChain<'a>,
     ) -> Self {
@@ -606,7 +606,7 @@ impl<'a> GridLayouter<'a> {
     ///
     /// Returns `None` if it's a gutter cell.
     #[track_caller]
-    fn cell(&self, x: usize, y: usize) -> Option<&'a PackedNode> {
+    fn cell(&self, x: usize, y: usize) -> Option<&'a LayoutNode> {
         assert!(x < self.cols.len());
         assert!(y < self.rows.len());
 
diff --git a/src/library/heading.rs b/src/library/heading.rs
index ab0864e7..00a48021 100644
--- a/src/library/heading.rs
+++ b/src/library/heading.rs
@@ -9,8 +9,8 @@ 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 node that produces the heading's contents.
-    pub child: PackedNode,
+    /// The heading's contents.
+    pub body: Template,
 }
 
 #[class]
@@ -23,70 +23,76 @@ impl HeadingNode {
     /// The fill color of text in the heading. Just the surrounding text color
     /// if `auto`.
     pub const FILL: Smart<Paint> = Smart::Auto;
+    /// Whether text in the heading is strengthend.
+    pub const STRONG: bool = true;
+    /// Whether text in the heading is emphasized.
+    pub const EMPH: bool = false;
+    /// Whether the heading is underlined.
+    pub const UNDERLINE: bool = false;
     /// The extra padding above the heading.
     pub const ABOVE: Length = Length::zero();
     /// The extra padding below the heading.
     pub const BELOW: Length = Length::zero();
 
     fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
-        Ok(Template::block(Self {
-            child: args.expect("body")?,
+        Ok(Template::show(Self {
+            body: args.expect("body")?,
             level: args.named("level")?.unwrap_or(1),
         }))
     }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        styles.set_opt(Self::FAMILY, args.named("family")?);
-        styles.set_opt(Self::SIZE, args.named("size")?);
-        styles.set_opt(Self::FILL, args.named("fill")?);
-        styles.set_opt(Self::ABOVE, args.named("above")?);
-        styles.set_opt(Self::BELOW, args.named("below")?);
-        Ok(())
-    }
 }
 
-impl Layout for HeadingNode {
-    fn layout(
-        &self,
-        ctx: &mut LayoutContext,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> Vec<Constrained<Arc<Frame>>> {
-        let upscale = (1.6 - 0.1 * self.level as f64).max(0.75);
+impl Show for HeadingNode {
+    fn show(&self, styles: StyleChain) -> Template {
+        let mut map = StyleMap::new();
 
-        let mut passed = StyleMap::new();
-        passed.set(TextNode::STRONG, true);
-        passed.set(
+        let upscale = (1.6 - 0.1 * self.level as f64).max(0.75);
+        map.set(
             TextNode::SIZE,
             styles.get(Self::SIZE).unwrap_or(Relative::new(upscale).into()),
         );
 
         if let Smart::Custom(family) = styles.get_ref(Self::FAMILY) {
-            passed.set(
-                TextNode::FAMILY_LIST,
+            map.set(
+                TextNode::FAMILY,
                 std::iter::once(family)
-                    .chain(styles.get_ref(TextNode::FAMILY_LIST))
+                    .chain(styles.get_ref(TextNode::FAMILY))
                     .cloned()
                     .collect(),
             );
         }
 
         if let Smart::Custom(fill) = styles.get(Self::FILL) {
-            passed.set(TextNode::FILL, fill);
+            map.set(TextNode::FILL, fill);
+        }
+
+        if styles.get(Self::STRONG) {
+            map.set(TextNode::STRONG, true);
+        }
+
+        if styles.get(Self::EMPH) {
+            map.set(TextNode::EMPH, true);
+        }
+
+        let mut body = self.body.clone();
+        if styles.get(Self::UNDERLINE) {
+            body = body.underlined();
         }
 
-        let mut frames = self.child.layout(ctx, regions, passed.chain(&styles));
+        let mut seq = vec![];
 
         let above = styles.get(Self::ABOVE);
-        let below = styles.get(Self::BELOW);
+        if !above.is_zero() {
+            seq.push(Template::Vertical(above.into()));
+        }
+
+        seq.push(body);
 
-        // FIXME: Constraints and region size.
-        for Constrained { item: frame, .. } in &mut frames {
-            let frame = Arc::make_mut(frame);
-            frame.size.y += above + below;
-            frame.translate(Point::with_y(above));
+        let below = styles.get(Self::BELOW);
+        if !below.is_zero() {
+            seq.push(Template::Vertical(below.into()));
         }
 
-        frames
+        Template::block(Template::sequence(seq).styled_with_map(map))
     }
 }
diff --git a/src/library/hide.rs b/src/library/hide.rs
index cfef8f73..72d8e52b 100644
--- a/src/library/hide.rs
+++ b/src/library/hide.rs
@@ -4,7 +4,7 @@ use super::prelude::*;
 
 /// Hide a node without affecting layout.
 #[derive(Debug, Hash)]
-pub struct HideNode(pub PackedNode);
+pub struct HideNode(pub LayoutNode);
 
 #[class]
 impl HideNode {
diff --git a/src/library/image.rs b/src/library/image.rs
index 309ffad3..59e30364 100644
--- a/src/library/image.rs
+++ b/src/library/image.rs
@@ -31,11 +31,6 @@ impl ImageNode {
             ImageNode(id).pack().sized(Spec::new(width, height)),
         ))
     }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        styles.set_opt(Self::FIT, args.named("fit")?);
-        Ok(())
-    }
 }
 
 impl Layout for ImageNode {
diff --git a/src/library/link.rs b/src/library/link.rs
index a27908c7..a43c5290 100644
--- a/src/library/link.rs
+++ b/src/library/link.rs
@@ -5,10 +5,22 @@ use super::TextNode;
 use crate::util::EcoString;
 
 /// Link text and other elements to an URL.
-pub struct LinkNode;
+#[derive(Debug, Hash)]
+pub struct LinkNode {
+    /// The url the link points to.
+    pub url: EcoString,
+    /// How the link is represented.
+    pub body: 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 EvalContext, args: &mut Args) -> TypResult<Template> {
         let url = args.expect::<EcoString>("url")?;
         let body = args.find().unwrap_or_else(|| {
@@ -20,6 +32,24 @@ impl LinkNode {
             Template::Text(if shorter { text.into() } else { url.clone() })
         });
 
-        Ok(body.styled(TextNode::LINK, Some(url)))
+        Ok(Template::show(Self { url, body }))
+    }
+}
+
+impl Show for LinkNode {
+    fn show(&self, styles: StyleChain) -> Template {
+        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);
+        }
+
+        let mut body = self.body.clone();
+        if styles.get(Self::UNDERLINE) {
+            body = body.underlined();
+        }
+
+        body.styled_with_map(map)
     }
 }
diff --git a/src/library/list.rs b/src/library/list.rs
index 639b5715..0c0e61ad 100644
--- a/src/library/list.rs
+++ b/src/library/list.rs
@@ -5,15 +5,15 @@ use super::{GridNode, TextNode, TrackSizing};
 
 /// An unordered or ordered list.
 #[derive(Debug, Hash)]
-pub struct ListNode<L: ListKind> {
-    /// The list labelling style -- unordered or ordered.
-    pub kind: L,
+pub struct ListNode<L: ListLabel> {
+    /// The list label -- unordered or ordered with index.
+    pub label: L,
     /// The node that produces the item's body.
-    pub child: PackedNode,
+    pub child: LayoutNode,
 }
 
 #[class]
-impl<L: ListKind> ListNode<L> {
+impl<L: ListLabel> ListNode<L> {
     /// The indentation of each item's label.
     pub const LABEL_INDENT: Linear = Relative::new(0.0).into();
     /// The space between the label and the body of each item.
@@ -22,29 +22,19 @@ impl<L: ListKind> ListNode<L> {
     fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
         Ok(args
             .all()
-            .map(|child: PackedNode| Template::block(Self { kind: L::default(), child }))
+            .enumerate()
+            .map(|(i, child)| Template::show(Self { label: L::new(1 + i), child }))
             .sum())
     }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        styles.set_opt(Self::LABEL_INDENT, args.named("label-indent")?);
-        styles.set_opt(Self::BODY_INDENT, args.named("body-indent")?);
-        Ok(())
-    }
 }
 
-impl<L: ListKind> Layout for ListNode<L> {
-    fn layout(
-        &self,
-        ctx: &mut LayoutContext,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> Vec<Constrained<Arc<Frame>>> {
+impl<L: ListLabel> Show for ListNode<L> {
+    fn show(&self, styles: StyleChain) -> Template {
         let em = styles.get(TextNode::SIZE).abs;
         let label_indent = styles.get(Self::LABEL_INDENT).resolve(em);
         let body_indent = styles.get(Self::BODY_INDENT).resolve(em);
 
-        let grid = GridNode {
+        Template::block(GridNode {
             tracks: Spec::with_x(vec![
                 TrackSizing::Linear(label_indent.into()),
                 TrackSizing::Auto,
@@ -53,19 +43,20 @@ impl<L: ListKind> Layout for ListNode<L> {
             ]),
             gutter: Spec::default(),
             children: vec![
-                PackedNode::default(),
-                Template::Text(self.kind.label()).pack(),
-                PackedNode::default(),
+                LayoutNode::default(),
+                Template::Text(self.label.label()).pack(),
+                LayoutNode::default(),
                 self.child.clone(),
             ],
-        };
-
-        grid.layout(ctx, regions, styles)
+        })
     }
 }
 
 /// How to label a list.
-pub trait ListKind: Debug + Default + Hash + Sync + Send + 'static {
+pub trait ListLabel: Debug + Default + Hash + Sync + Send + 'static {
+    /// Create a new list label.
+    fn new(number: usize) -> Self;
+
     /// Return the item's label.
     fn label(&self) -> EcoString;
 }
@@ -74,7 +65,11 @@ pub trait ListKind: Debug + Default + Hash + Sync + Send + 'static {
 #[derive(Debug, Default, Hash)]
 pub struct Unordered;
 
-impl ListKind for Unordered {
+impl ListLabel for Unordered {
+    fn new(_: usize) -> Self {
+        Self
+    }
+
     fn label(&self) -> EcoString {
         '•'.into()
     }
@@ -84,7 +79,11 @@ impl ListKind for Unordered {
 #[derive(Debug, Default, Hash)]
 pub struct Ordered(pub Option<usize>);
 
-impl ListKind for Ordered {
+impl ListLabel for Ordered {
+    fn new(number: usize) -> Self {
+        Self(Some(number))
+    }
+
     fn label(&self) -> EcoString {
         format_eco!("{}.", self.0.unwrap_or(1))
     }
diff --git a/src/library/math.rs b/src/library/math.rs
new file mode 100644
index 00000000..c75cdea8
--- /dev/null
+++ b/src/library/math.rs
@@ -0,0 +1,32 @@
+//! 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 EvalContext, 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, _: StyleChain) -> Template {
+        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 ef0fa016..b2cb8698 100644
--- a/src/library/mod.rs
+++ b/src/library/mod.rs
@@ -14,18 +14,20 @@ pub mod hide;
 pub mod image;
 pub mod link;
 pub mod list;
+pub mod math;
 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 text;
 pub mod transform;
-pub mod utility;
 
+pub mod utility;
 pub use self::image::*;
 pub use align::*;
 pub use columns::*;
@@ -37,10 +39,12 @@ pub use heading::*;
 pub use hide::*;
 pub use link::*;
 pub use list::*;
+pub use math::*;
 pub use pad::*;
 pub use page::*;
 pub use par::*;
 pub use place::*;
+pub use raw::*;
 pub use shape::*;
 pub use spacing::*;
 pub use stack::*;
@@ -68,13 +72,13 @@ prelude! {
 
     pub use crate::diag::{At, TypResult};
     pub use crate::eval::{
-        Args, Construct, EvalContext, Merge, Property, Scope, Set, Smart, StyleChain,
-        StyleMap, StyleVec, Template, Value,
+        Args, Construct, EvalContext, Merge, Property, Scope, Set, Show, ShowNode, Smart,
+        StyleChain, StyleMap, StyleVec, Template, Value,
     };
     pub use crate::frame::*;
     pub use crate::geom::*;
     pub use crate::layout::{
-        Constrain, Constrained, Constraints, Layout, LayoutContext, PackedNode, Regions,
+        Constrain, Constrained, Constraints, Layout, LayoutContext, LayoutNode, Regions,
     };
     pub use crate::syntax::{Span, Spanned};
     pub use crate::util::{EcoString, OptionExt};
@@ -95,6 +99,8 @@ pub fn new() -> Scope {
     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");
@@ -207,9 +213,9 @@ castable! {
 castable! {
     NonZeroUsize,
     Expected: "positive integer",
-    Value::Int(int) => int
+    Value::Int(int) => Value::Int(int)
+        .cast::<usize>()?
         .try_into()
-        .and_then(usize::try_into)
         .map_err(|_| "must be positive")?,
 }
 
@@ -226,7 +232,7 @@ castable! {
 }
 
 castable! {
-    PackedNode,
+    LayoutNode,
     Expected: "template",
     Value::Template(template) => template.pack(),
 }
diff --git a/src/library/pad.rs b/src/library/pad.rs
index af570659..b65057dc 100644
--- a/src/library/pad.rs
+++ b/src/library/pad.rs
@@ -8,7 +8,7 @@ pub struct PadNode {
     /// The amount of padding.
     pub padding: Sides<Linear>,
     /// The child node whose sides to pad.
-    pub child: PackedNode,
+    pub child: LayoutNode,
 }
 
 #[class]
@@ -19,7 +19,7 @@ impl PadNode {
         let top = args.named("top")?;
         let right = args.named("right")?;
         let bottom = args.named("bottom")?;
-        let body: PackedNode = args.expect("body")?;
+        let body: LayoutNode = args.expect("body")?;
         let padding = Sides::new(
             left.or(all).unwrap_or_default(),
             top.or(all).unwrap_or_default(),
diff --git a/src/library/page.rs b/src/library/page.rs
index cdb78cc1..d54fefb0 100644
--- a/src/library/page.rs
+++ b/src/library/page.rs
@@ -8,16 +8,14 @@ use super::ColumnsNode;
 
 /// Layouts its child onto one or multiple pages.
 #[derive(Clone, PartialEq, Hash)]
-pub struct PageNode(pub PackedNode);
+pub struct PageNode(pub LayoutNode);
 
 #[class]
 impl PageNode {
     /// The unflipped width of the page.
-    pub const WIDTH: Smart<Length> = Smart::Custom(Paper::default().width());
+    pub const WIDTH: Smart<Length> = Smart::Custom(Paper::A4.width());
     /// The unflipped height of the page.
-    pub const HEIGHT: Smart<Length> = Smart::Custom(Paper::default().height());
-    /// The class of paper. Defines the default margins.
-    pub const CLASS: PaperClass = Paper::default().class();
+    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.
@@ -39,20 +37,12 @@ impl PageNode {
 
     fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
         if let Some(paper) = args.named::<Paper>("paper")?.or_else(|| args.find()) {
-            styles.set(Self::CLASS, paper.class());
             styles.set(Self::WIDTH, Smart::Custom(paper.width()));
             styles.set(Self::HEIGHT, Smart::Custom(paper.height()));
         }
 
-        if let Some(width) = args.named("width")? {
-            styles.set(Self::CLASS, PaperClass::Custom);
-            styles.set(Self::WIDTH, width);
-        }
-
-        if let Some(height) = args.named("height")? {
-            styles.set(Self::CLASS, PaperClass::Custom);
-            styles.set(Self::HEIGHT, height);
-        }
+        styles.set_opt(Self::WIDTH, args.named("width")?);
+        styles.set_opt(Self::HEIGHT, args.named("height")?);
 
         let margins = args.named("margins")?;
         styles.set_opt(Self::LEFT, args.named("left")?.or(margins));
@@ -80,14 +70,18 @@ impl PageNode {
             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 class = styles.get(Self::CLASS);
-        let default = class.default_margins();
+        let default = Linear::from(0.1190 * min);
         let padding = Sides {
-            left: styles.get(Self::LEFT).unwrap_or(default.left),
-            right: styles.get(Self::RIGHT).unwrap_or(default.right),
-            top: styles.get(Self::TOP).unwrap_or(default.top),
-            bottom: styles.get(Self::BOTTOM).unwrap_or(default.bottom),
+            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();
@@ -138,8 +132,6 @@ impl PagebreakNode {
 /// Specification of a paper.
 #[derive(Debug, Copy, Clone)]
 pub struct Paper {
-    /// The broad class this paper belongs to.
-    class: PaperClass,
     /// The width of the paper in millimeters.
     width: f64,
     /// The height of the paper in millimeters.
@@ -147,11 +139,6 @@ pub struct Paper {
 }
 
 impl Paper {
-    /// The class of the paper.
-    pub fn class(self) -> PaperClass {
-        self.class
-    }
-
     /// The width of the paper.
     pub fn width(self) -> Length {
         Length::mm(self.width)
@@ -163,24 +150,14 @@ impl Paper {
     }
 }
 
-impl Default for Paper {
-    fn default() -> Self {
-        Paper::A4
-    }
-}
-
 /// Defines paper constants and a paper parsing implementation.
 macro_rules! papers {
-    ($(($var:ident: $class:ident, $width:expr, $height: expr, $($pats:tt)*))*) => {
+    ($(($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 {
-                class: PaperClass::$class,
-                width: $width,
-                height: $height,
-            };)*
+            $(pub const $var: Self = Self { width: $width, height: $height };)*
         }
 
         impl FromStr for Paper {
@@ -206,149 +183,149 @@ macro_rules! papers {
 papers! {
     // ---------------------------------------------------------------------- //
     // ISO 216 A Series
-    (A0:  Base, 841.0, 1189.0, "a0")
-    (A1:  Base, 594.0,  841.0, "a1")
-    (A2:  Base, 420.0,  594.0, "a2")
-    (A3:  Base, 297.0,  420.0, "a3")
-    (A4:  Base, 210.0,  297.0, "a4")
-    (A5:  Base, 148.0,  210.0, "a5")
-    (A6:  Book, 105.0,  148.0, "a6")
-    (A7:  Base,  74.0,  105.0, "a7")
-    (A8:  Base,  52.0,   74.0, "a8")
-    (A9:  Base,  37.0,   52.0, "a9")
-    (A10: Base,  26.0,   37.0, "a10")
-    (A11: Base,  18.0,   26.0, "a11")
+    (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: Base, 707.0, 1000.0, "iso-b1")
-    (ISO_B2: Base, 500.0, 707.0,  "iso-b2")
-    (ISO_B3: Base, 353.0, 500.0,  "iso-b3")
-    (ISO_B4: Base, 250.0, 353.0,  "iso-b4")
-    (ISO_B5: Book, 176.0, 250.0,  "iso-b5")
-    (ISO_B6: Book, 125.0, 176.0,  "iso-b6")
-    (ISO_B7: Base,  88.0, 125.0,  "iso-b7")
-    (ISO_B8: Base,  62.0,  88.0,  "iso-b8")
+    (ISO_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: Base, 324.0, 458.0, "iso-c3")
-    (ISO_C4: Base, 229.0, 324.0, "iso-c4")
-    (ISO_C5: Base, 162.0, 229.0, "iso-c5")
-    (ISO_C6: Base, 114.0, 162.0, "iso-c6")
-    (ISO_C7: Base,  81.0, 114.0, "iso-c7")
-    (ISO_C8: Base,  57.0,  81.0, "iso-c8")
+    (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: Base, 272.0, 385.0, "din-d3")
-    (DIN_D4: Base, 192.0, 272.0, "din-d4")
-    (DIN_D5: Base, 136.0, 192.0, "din-d5")
-    (DIN_D6: Base,  96.0, 136.0, "din-d6")
-    (DIN_D7: Base,  68.0,  96.0, "din-d7")
-    (DIN_D8: Base,  48.0,  68.0, "din-d8")
+    (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: Base, 169.0, 239.0, "sis-g5")
-    (SIS_E5: Base, 115.0, 220.0, "sis-e5")
+    (SIS_G5: 169.0, 239.0, "sis-g5")
+    (SIS_E5: 115.0, 220.0, "sis-e5")
 
     // ANSI Extensions
-    (ANSI_A: Base, 216.0,  279.0, "ansi-a")
-    (ANSI_B: Base, 279.0,  432.0, "ansi-b")
-    (ANSI_C: Base, 432.0,  559.0, "ansi-c")
-    (ANSI_D: Base, 559.0,  864.0, "ansi-d")
-    (ANSI_E: Base, 864.0, 1118.0, "ansi-e")
+    (ANSI_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:  Base, 229.0,  305.0, "arch-a")
-    (ARCH_B:  Base, 305.0,  457.0, "arch-b")
-    (ARCH_C:  Base, 457.0,  610.0, "arch-c")
-    (ARCH_D:  Base, 610.0,  914.0, "arch-d")
-    (ARCH_E1: Base, 762.0, 1067.0, "arch-e1")
-    (ARCH_E:  Base, 914.0, 1219.0, "arch-e")
+    (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:  Base, 1030.0, 1456.0, "jis-b0")
-    (JIS_B1:  Base,  728.0, 1030.0, "jis-b1")
-    (JIS_B2:  Base,  515.0,  728.0, "jis-b2")
-    (JIS_B3:  Base,  364.0,  515.0, "jis-b3")
-    (JIS_B4:  Base,  257.0,  364.0, "jis-b4")
-    (JIS_B5:  Base,  182.0,  257.0, "jis-b5")
-    (JIS_B6:  Base,  128.0,  182.0, "jis-b6")
-    (JIS_B7:  Base,   91.0,  128.0, "jis-b7")
-    (JIS_B8:  Base,   64.0,   91.0, "jis-b8")
-    (JIS_B9:  Base,   45.0,   64.0, "jis-b9")
-    (JIS_B10: Base,   32.0,   45.0, "jis-b10")
-    (JIS_B11: Base,   22.0,   32.0, "jis-b11")
+    (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: Base, 764.0, 1064.0, "sac-d0")
-    (SAC_D1: Base, 532.0,  760.0, "sac-d1")
-    (SAC_D2: Base, 380.0,  528.0, "sac-d2")
-    (SAC_D3: Base, 264.0,  376.0, "sac-d3")
-    (SAC_D4: Base, 188.0,  260.0, "sac-d4")
-    (SAC_D5: Base, 130.0,  184.0, "sac-d5")
-    (SAC_D6: Base,  92.0,  126.0, "sac-d6")
+    (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: Base, 85.6, 53.98, "iso-id-1")
-    (ISO_ID_2: Base, 74.0, 105.0, "iso-id-2")
-    (ISO_ID_3: Base, 88.0, 125.0, "iso-id-3")
+    (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: Base, 210.0, 330.0, "asia-f4")
+    (ASIA_F4: 210.0, 330.0, "asia-f4")
 
     // Japan
-    (JP_SHIROKU_BAN_4: Base, 264.0, 379.0, "jp-shiroku-ban-4")
-    (JP_SHIROKU_BAN_5: Base, 189.0, 262.0, "jp-shiroku-ban-5")
-    (JP_SHIROKU_BAN_6: Base, 127.0, 188.0, "jp-shiroku-ban-6")
-    (JP_KIKU_4:        Base, 227.0, 306.0, "jp-kiku-4")
-    (JP_KIKU_5:        Base, 151.0, 227.0, "jp-kiku-5")
-    (JP_BUSINESS_CARD: Base,  91.0,  55.0, "jp-business-card")
+    (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: Base, 90.0, 54.0, "cn-business-card")
+    (CN_BUSINESS_CARD: 90.0, 54.0, "cn-business-card")
 
     // Europe
-    (EU_BUSINESS_CARD: Base, 85.0, 55.0, "eu-business-card")
+    (EU_BUSINESS_CARD: 85.0, 55.0, "eu-business-card")
 
     // French Traditional (AFNOR)
-    (FR_TELLIERE:          Base, 340.0, 440.0, "fr-tellière")
-    (FR_COURONNE_ECRITURE: Base, 360.0, 460.0, "fr-couronne-écriture")
-    (FR_COURONNE_EDITION:  Base, 370.0, 470.0, "fr-couronne-édition")
-    (FR_RAISIN:            Base, 500.0, 650.0, "fr-raisin")
-    (FR_CARRE:             Base, 450.0, 560.0, "fr-carré")
-    (FR_JESUS:             Base, 560.0, 760.0, "fr-jésus")
+    (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:    Base, 406.4, 342.9, "uk-brief")
-    (UK_DRAFT:    Base, 254.0, 406.4, "uk-draft")
-    (UK_FOOLSCAP: Base, 203.2, 330.2, "uk-foolscap")
-    (UK_QUARTO:   Base, 203.2, 254.0, "uk-quarto")
-    (UK_CROWN:    Base, 508.0, 381.0, "uk-crown")
-    (UK_BOOK_A:   Book, 111.0, 178.0, "uk-book-a")
-    (UK_BOOK_B:   Book, 129.0, 198.0, "uk-book-b")
+    (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:         US,   215.9,  279.4, "us-letter")
-    (US_LEGAL:          US,   215.9,  355.6, "us-legal")
-    (US_TABLOID:        US,   279.4,  431.8, "us-tabloid")
-    (US_EXECUTIVE:      US,  184.15,  266.7, "us-executive")
-    (US_FOOLSCAP_FOLIO: US,   215.9,  342.9, "us-foolscap-folio")
-    (US_STATEMENT:      US,   139.7,  215.9, "us-statement")
-    (US_LEDGER:         US,   431.8,  279.4, "us-ledger")
-    (US_OFICIO:         US,   215.9, 340.36, "us-oficio")
-    (US_GOV_LETTER:     US,   203.2,  266.7, "us-gov-letter")
-    (US_GOV_LEGAL:      US,   215.9,  330.2, "us-gov-legal")
-    (US_BUSINESS_CARD:  Base,  88.9,   50.8, "us-business-card")
-    (US_DIGEST:         Book, 139.7,  215.9, "us-digest")
-    (US_TRADE:          Book, 152.4,  228.6, "us-trade")
+    (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:    Newspaper, 280.0, 430.0,    "newspaper-compact")
-    (NEWSPAPER_BERLINER:   Newspaper, 315.0, 470.0,    "newspaper-berliner")
-    (NEWSPAPER_BROADSHEET: Newspaper, 381.0, 578.0,    "newspaper-broadsheet")
-    (PRESENTATION_16_9:    Base,      297.0, 167.0625, "presentation-16-9")
-    (PRESENTATION_4_3:     Base,      280.0, 210.0,    "presentation-4-3")
+    (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! {
@@ -357,31 +334,6 @@ castable! {
     Value::Str(string) => Paper::from_str(&string).map_err(|e| e.to_string())?,
 }
 
-/// Defines default margins for a class of related papers.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub enum PaperClass {
-    Custom,
-    Base,
-    US,
-    Newspaper,
-    Book,
-}
-
-impl PaperClass {
-    /// The default margins for this page class.
-    fn default_margins(self) -> Sides<Linear> {
-        let f = |r| Relative::new(r).into();
-        let s = |l, t, r, b| Sides::new(f(l), f(t), f(r), f(b));
-        match self {
-            Self::Custom => s(0.1190, 0.0842, 0.1190, 0.0842),
-            Self::Base => s(0.1190, 0.0842, 0.1190, 0.0842),
-            Self::US => s(0.1760, 0.1092, 0.1760, 0.0910),
-            Self::Newspaper => s(0.0455, 0.0587, 0.0455, 0.0294),
-            Self::Book => s(0.1200, 0.0852, 0.1500, 0.0965),
-        }
-    }
-}
-
 /// The error when parsing a [`Paper`] from a string fails.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub struct PaperError;
diff --git a/src/library/par.rs b/src/library/par.rs
index 962834f2..2a4b4d08 100644
--- a/src/library/par.rs
+++ b/src/library/par.rs
@@ -22,7 +22,7 @@ pub enum ParChild {
     /// Horizontal spacing between other children.
     Spacing(SpacingKind),
     /// An arbitrary inline-level node.
-    Node(PackedNode),
+    Node(LayoutNode),
 }
 
 #[class]
diff --git a/src/library/place.rs b/src/library/place.rs
index d7b98c16..ee5ee2c9 100644
--- a/src/library/place.rs
+++ b/src/library/place.rs
@@ -5,7 +5,7 @@ use super::AlignNode;
 
 /// Place a node at an absolute position.
 #[derive(Debug, Hash)]
-pub struct PlaceNode(pub PackedNode);
+pub struct PlaceNode(pub LayoutNode);
 
 #[class]
 impl PlaceNode {
@@ -13,7 +13,7 @@ impl PlaceNode {
         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: PackedNode = args.expect("body")?;
+        let body: LayoutNode = args.expect("body")?;
         Ok(Template::block(Self(
             body.moved(Point::new(tx, ty)).aligned(aligns),
         )))
diff --git a/src/library/raw.rs b/src/library/raw.rs
new file mode 100644
index 00000000..e2ae259b
--- /dev/null
+++ b/src/library/raw.rs
@@ -0,0 +1,117 @@
+//! 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 EvalContext, 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, styles: StyleChain) -> Template {
+        let lang = styles.get_ref(Self::LANG).as_ref();
+        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());
+        }
+
+        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
index 8ac9956f..95e3e288 100644
--- a/src/library/shape.rs
+++ b/src/library/shape.rs
@@ -11,7 +11,7 @@ pub struct ShapeNode<S: ShapeKind> {
     /// Which shape to place the child into.
     pub kind: S,
     /// The child node to place into the shape, if any.
-    pub child: Option<PackedNode>,
+    pub child: Option<LayoutNode>,
 }
 
 #[class]
@@ -50,14 +50,6 @@ impl<S: ShapeKind> ShapeNode<S> {
                 .sized(Spec::new(width, height)),
         ))
     }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        styles.set_opt(Self::FILL, args.named("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<S: ShapeKind> Layout for ShapeNode<S> {
diff --git a/src/library/spacing.rs b/src/library/spacing.rs
index feadf7f3..3e26cb3c 100644
--- a/src/library/spacing.rs
+++ b/src/library/spacing.rs
@@ -38,6 +38,12 @@ impl SpacingKind {
     }
 }
 
+impl From<Length> for SpacingKind {
+    fn from(length: Length) -> Self {
+        Self::Linear(length.into())
+    }
+}
+
 castable! {
     SpacingKind,
     Expected: "linear or fractional",
diff --git a/src/library/stack.rs b/src/library/stack.rs
index 0ff8e973..bccd552f 100644
--- a/src/library/stack.rs
+++ b/src/library/stack.rs
@@ -64,7 +64,7 @@ pub enum StackChild {
     /// Spacing between other nodes.
     Spacing(SpacingKind),
     /// An arbitrary node.
-    Node(PackedNode),
+    Node(LayoutNode),
 }
 
 impl Debug for StackChild {
@@ -166,7 +166,7 @@ impl StackLayouter {
     pub fn layout_node(
         &mut self,
         ctx: &mut LayoutContext,
-        node: &PackedNode,
+        node: &LayoutNode,
         styles: StyleChain,
     ) {
         if self.regions.is_full() {
diff --git a/src/library/table.rs b/src/library/table.rs
index 33fa68cd..c40a117b 100644
--- a/src/library/table.rs
+++ b/src/library/table.rs
@@ -11,7 +11,7 @@ pub struct TableNode {
     /// 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<PackedNode>,
+    pub children: Vec<LayoutNode>,
 }
 
 #[class]
@@ -33,7 +33,7 @@ impl TableNode {
         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 {
+        Ok(Template::show(Self {
             tracks: Spec::new(columns, rows),
             gutter: Spec::new(
                 column_gutter.unwrap_or_else(|| base_gutter.clone()),
@@ -54,13 +54,8 @@ impl TableNode {
     }
 }
 
-impl Layout for TableNode {
-    fn layout(
-        &self,
-        ctx: &mut LayoutContext,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> Vec<Constrained<Arc<Frame>>> {
+impl Show for TableNode {
+    fn show(&self, styles: StyleChain) -> Template {
         let primary = styles.get(Self::PRIMARY);
         let secondary = styles.get(Self::SECONDARY);
         let thickness = styles.get(Self::THICKNESS);
@@ -90,12 +85,10 @@ impl Layout for TableNode {
             })
             .collect();
 
-        let grid = GridNode {
+        Template::block(GridNode {
             tracks: self.tracks.clone(),
             gutter: self.gutter.clone(),
             children,
-        };
-
-        grid.layout(ctx, regions, styles)
+        })
     }
 }
diff --git a/src/library/text.rs b/src/library/text.rs
index fb0f7e08..1ccbb1c6 100644
--- a/src/library/text.rs
+++ b/src/library/text.rs
@@ -24,13 +24,14 @@ pub struct TextNode;
 #[class]
 impl TextNode {
     /// A prioritized sequence of font families.
-    pub const FAMILY_LIST: Vec<FontFamily> = vec![FontFamily::SansSerif];
+    #[variadic]
+    pub const FAMILY: Vec<FontFamily> = vec![FontFamily::SansSerif];
     /// The serif font family/families.
-    pub const SERIF_LIST: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Serif")];
+    pub const SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Serif")];
     /// The sans-serif font family/families.
-    pub const SANS_SERIF_LIST: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Sans")];
+    pub const SANS_SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Sans")];
     /// The monospace font family/families.
-    pub const MONOSPACE_LIST: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Mono")];
+    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;
@@ -41,23 +42,12 @@ impl TextNode {
     pub const WEIGHT: FontWeight = FontWeight::REGULAR;
     /// The width of the glyphs.
     pub const STRETCH: FontStretch = FontStretch::NORMAL;
-    /// Whether the font weight should be increased by 300.
-    #[fold(bool::bitxor)]
-    pub const STRONG: bool = false;
-    /// Whether the the font style should be inverted.
-    #[fold(bool::bitxor)]
-    pub const EMPH: bool = false;
-    /// Whether a monospace font should be preferred.
-    pub const MONOSPACE: bool = false;
     /// The glyph fill color.
+    #[shorthand]
     pub const FILL: Paint = Color::BLACK.into();
-    /// Decorative lines.
-    #[fold(|a, b| a.into_iter().chain(b).collect())]
-    pub const LINES: Vec<Decoration> = vec![];
-    /// An URL the text should link to.
-    pub const LINK: Option<EcoString> = None;
 
     /// 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.
@@ -94,73 +84,64 @@ impl TextNode {
     /// 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;
+    /// 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 EvalContext, 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")
     }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        let list = args.named("family")?.or_else(|| {
-            let families: Vec<_> = args.all().collect();
-            (!families.is_empty()).then(|| families)
-        });
-
-        styles.set_opt(Self::FAMILY_LIST, list);
-        styles.set_opt(Self::SERIF_LIST, args.named("serif")?);
-        styles.set_opt(Self::SANS_SERIF_LIST, args.named("sans-serif")?);
-        styles.set_opt(Self::MONOSPACE_LIST, args.named("monospace")?);
-        styles.set_opt(Self::FALLBACK, args.named("fallback")?);
-        styles.set_opt(Self::STYLE, args.named("style")?);
-        styles.set_opt(Self::WEIGHT, args.named("weight")?);
-        styles.set_opt(Self::STRETCH, args.named("stretch")?);
-        styles.set_opt(Self::FILL, args.named("fill")?.or_else(|| args.find()));
-        styles.set_opt(Self::SIZE, args.named("size")?.or_else(|| args.find()));
-        styles.set_opt(Self::TRACKING, args.named("tracking")?.map(Em::new));
-        styles.set_opt(Self::TOP_EDGE, args.named("top-edge")?);
-        styles.set_opt(Self::BOTTOM_EDGE, args.named("bottom-edge")?);
-        styles.set_opt(Self::KERNING, args.named("kerning")?);
-        styles.set_opt(Self::SMALLCAPS, args.named("smallcaps")?);
-        styles.set_opt(Self::ALTERNATES, args.named("alternates")?);
-        styles.set_opt(Self::STYLISTIC_SET, args.named("stylistic-set")?);
-        styles.set_opt(Self::LIGATURES, args.named("ligatures")?);
-        styles.set_opt(
-            Self::DISCRETIONARY_LIGATURES,
-            args.named("discretionary-ligatures")?,
-        );
-        styles.set_opt(
-            Self::HISTORICAL_LIGATURES,
-            args.named("historical-ligatures")?,
-        );
-        styles.set_opt(Self::NUMBER_TYPE, args.named("number-type")?);
-        styles.set_opt(Self::NUMBER_WIDTH, args.named("number-width")?);
-        styles.set_opt(Self::NUMBER_POSITION, args.named("number-position")?);
-        styles.set_opt(Self::SLASHED_ZERO, args.named("slashed-zero")?);
-        styles.set_opt(Self::FRACTIONS, args.named("fractions")?);
-        styles.set_opt(Self::FEATURES, args.named("features")?);
-
-        Ok(())
-    }
 }
 
 /// Strong text, rendered in boldface.
-pub struct StrongNode;
+#[derive(Debug, Hash)]
+pub struct StrongNode(pub Template);
 
 #[class]
 impl StrongNode {
     fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
-        Ok(args.expect::<Template>("body")?.styled(TextNode::STRONG, true))
+        Ok(Template::show(Self(args.expect("body")?)))
+    }
+}
+
+impl Show for StrongNode {
+    fn show(&self, _: StyleChain) -> Template {
+        self.0.clone().styled(TextNode::STRONG, true)
     }
 }
 
 /// Emphasized text, rendered with an italic face.
-pub struct EmphNode;
+#[derive(Debug, Hash)]
+pub struct EmphNode(pub Template);
 
 #[class]
 impl EmphNode {
     fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
-        Ok(args.expect::<Template>("body")?.styled(TextNode::EMPH, true))
+        Ok(Template::show(Self(args.expect("body")?)))
+    }
+}
+
+impl Show for EmphNode {
+    fn show(&self, _: StyleChain) -> Template {
+        self.0.clone().styled(TextNode::EMPH, true)
     }
 }
 
@@ -274,6 +255,12 @@ castable! {
     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",
@@ -644,18 +631,18 @@ fn variant(styles: StyleChain) -> FontVariant {
 
 /// Resolve a prioritized iterator over the font families.
 fn families(styles: StyleChain) -> impl Iterator<Item = &str> + Clone {
-    let head = if styles.get(TextNode::MONOSPACE) {
-        styles.get_ref(TextNode::MONOSPACE_LIST).as_slice()
+    let head = if styles.get(TextNode::MONOSPACED) {
+        styles.get_ref(TextNode::MONOSPACE).as_slice()
     } else {
         &[]
     };
 
-    let core = styles.get_ref(TextNode::FAMILY_LIST).iter().flat_map(move |family| {
+    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_LIST),
-            FontFamily::SansSerif => styles.get_ref(TextNode::SANS_SERIF_LIST),
-            FontFamily::Monospace => styles.get_ref(TextNode::MONOSPACE_LIST),
+            FontFamily::Serif => styles.get_ref(TextNode::SERIF),
+            FontFamily::SansSerif => styles.get_ref(TextNode::SANS_SERIF),
+            FontFamily::Monospace => styles.get_ref(TextNode::MONOSPACE),
         }
     });
 
diff --git a/src/library/transform.rs b/src/library/transform.rs
index 9d04071d..de053a9d 100644
--- a/src/library/transform.rs
+++ b/src/library/transform.rs
@@ -9,7 +9,7 @@ pub struct TransformNode<T: TransformKind> {
     /// Transformation to apply to the contents.
     pub kind: T,
     /// The node whose contents should be transformed.
-    pub child: PackedNode,
+    pub child: LayoutNode,
 }
 
 #[class]
@@ -23,11 +23,6 @@ impl<T: TransformKind> TransformNode<T> {
             child: args.expect("body")?,
         }))
     }
-
-    fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
-        styles.set_opt(Self::ORIGIN, args.named("origin")?);
-        Ok(())
-    }
 }
 
 impl<T: TransformKind> Layout for TransformNode<T> {
diff --git a/src/util/mod.rs b/src/util/mod.rs
index 32ec8dc4..84bd1aa1 100644
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -3,9 +3,11 @@
 #[macro_use]
 mod eco_string;
 mod mac_roman;
+mod prehashed;
 
 pub use eco_string::EcoString;
 pub use mac_roman::decode_mac_roman;
+pub use prehashed::Prehashed;
 
 use std::cell::RefMut;
 use std::cmp::Ordering;
diff --git a/src/util/prehashed.rs b/src/util/prehashed.rs
new file mode 100644
index 00000000..bab1c8f8
--- /dev/null
+++ b/src/util/prehashed.rs
@@ -0,0 +1,72 @@
+use std::any::Any;
+use std::fmt::{self, Debug, Formatter};
+use std::hash::{Hash, Hasher};
+use std::ops::Deref;
+
+/// A wrapper around a type that precomputes its hash.
+#[derive(Copy, Clone)]
+pub struct Prehashed<T: ?Sized> {
+    /// The precomputed hash.
+    #[cfg(feature = "layout-cache")]
+    hash: u64,
+    /// The wrapped item.
+    item: T,
+}
+
+impl<T: Hash + 'static> Prehashed<T> {
+    /// Compute an item's hash and wrap it.
+    pub fn new(item: T) -> Self {
+        Self {
+            #[cfg(feature = "layout-cache")]
+            hash: {
+                // Also hash the TypeId because the type might be converted
+                // through an unsized coercion.
+                let mut state = fxhash::FxHasher64::default();
+                item.type_id().hash(&mut state);
+                item.hash(&mut state);
+                state.finish()
+            },
+            item,
+        }
+    }
+
+    /// Return the wrapped value.
+    pub fn into_iter(self) -> T {
+        self.item
+    }
+}
+
+impl<T: ?Sized> Deref for Prehashed<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.item
+    }
+}
+
+impl<T: Debug + ?Sized> Debug for Prehashed<T> {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        self.item.fmt(f)
+    }
+}
+
+impl<T: Hash + ?Sized> Hash for Prehashed<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        // Hash the node.
+        #[cfg(feature = "layout-cache")]
+        state.write_u64(self.hash);
+        #[cfg(not(feature = "layout-cache"))]
+        self.item.hash(state);
+    }
+}
+
+impl<T: Eq + ?Sized> Eq for Prehashed<T> {}
+
+impl<T: PartialEq + ?Sized> PartialEq for Prehashed<T> {
+    fn eq(&self, other: &Self) -> bool {
+        #[cfg(feature = "layout-cache")]
+        return self.hash == other.hash;
+        #[cfg(not(feature = "layout-cache"))]
+        self.item.eq(&other.item)
+    }
+}
-- 
cgit v1.2.3