From 5ac7eb3860ebd3247f6486c227e816894cb8fd91 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Fri, 11 Mar 2022 12:59:55 +0100
Subject: Rename template to content

---
 src/eval/array.rs    |   2 +-
 src/eval/capture.rs  |   4 +-
 src/eval/class.rs    |  19 +-
 src/eval/content.rs  | 581 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/eval/layout.rs   |   2 +-
 src/eval/mod.rs      |  68 +++---
 src/eval/module.rs   |   4 +-
 src/eval/ops.rs      |  25 +--
 src/eval/show.rs     |   8 +-
 src/eval/styles.rs   |   4 +-
 src/eval/template.rs | 587 ---------------------------------------------------
 src/eval/value.rs    |  36 ++--
 12 files changed, 668 insertions(+), 672 deletions(-)
 create mode 100644 src/eval/content.rs
 delete mode 100644 src/eval/template.rs

(limited to 'src/eval')

diff --git a/src/eval/array.rs b/src/eval/array.rs
index 7ff5fb74..294d2871 100644
--- a/src/eval/array.rs
+++ b/src/eval/array.rs
@@ -89,7 +89,7 @@ impl Array {
             a.partial_cmp(b).unwrap_or_else(|| {
                 if result.is_ok() {
                     result = Err(format!(
-                        "cannot compare {} with {}",
+                        "cannot order {} and {}",
                         a.type_name(),
                         b.type_name(),
                     ));
diff --git a/src/eval/capture.rs b/src/eval/capture.rs
index b27aceb7..4e8d7604 100644
--- a/src/eval/capture.rs
+++ b/src/eval/capture.rs
@@ -49,8 +49,8 @@ impl<'a> CapturesVisitor<'a> {
             // through the expressions that contain them).
             Some(Expr::Ident(ident)) => self.capture(ident),
 
-            // Blocks and templates create a scope.
-            Some(Expr::Code(_) | Expr::Template(_)) => {
+            // Code and content blocks create a scope.
+            Some(Expr::Code(_) | Expr::Content(_)) => {
                 self.internal.enter();
                 for child in node.children() {
                     self.visit(child);
diff --git a/src/eval/class.rs b/src/eval/class.rs
index 2cced74d..05191667 100644
--- a/src/eval/class.rs
+++ b/src/eval/class.rs
@@ -2,24 +2,25 @@ use std::any::TypeId;
 use std::fmt::{self, Debug, Formatter, Write};
 use std::hash::{Hash, Hasher};
 
-use super::{Args, Func, StyleMap, Template, Value};
+use super::{Args, Content, Func, StyleMap, Value};
 use crate::diag::TypResult;
 use crate::Context;
 
 /// A class of nodes.
 ///
 /// You can [construct] an instance of a class in Typst code by invoking the
-/// class as a callable. This always produces a template value, but not
+/// class as a callable. This always produces a content value, but not
 /// necessarily a simple inline or block node. For example, the `text`
 /// constructor does not actually create a [`TextNode`]. Instead it applies
-/// styling to whatever node you pass in and returns it structurally unchanged.
+/// styling to whatever content you pass in and returns it structurally
+/// unchanged.
 ///
 /// The arguments you can pass to a class constructor fall into two categories:
 /// Data that is inherent to the instance (e.g. the text/content of a heading)
 /// and style properties (e.g. the fill color of a heading). As the latter are
 /// often shared by many instances throughout a document, they can also be
 /// conveniently configured through class's [`set`] rule. Then, they apply to
-/// all nodes that are instantiated into the template where the `set` was
+/// all nodes that are instantiated into the content block where the `set` was
 /// executed.
 ///
 /// ```typst
@@ -55,8 +56,8 @@ impl Class {
             construct: |ctx, args| {
                 let mut styles = StyleMap::new();
                 T::set(args, &mut styles)?;
-                let template = T::construct(ctx, args)?;
-                Ok(Value::Template(template.styled_with_map(styles.scoped())))
+                let content = T::construct(ctx, args)?;
+                Ok(Value::Content(content.styled_with_map(styles.scoped())))
             },
             set: T::set,
         }
@@ -80,8 +81,8 @@ impl Class {
     /// Construct an instance of the class.
     ///
     /// This parses both property and data arguments (in this order), styles the
-    /// template constructed from the data with the style properties and wraps
-    /// it in a value.
+    /// content constructed from the data with the style properties and wraps it
+    /// in a value.
     pub fn construct(&self, ctx: &mut Context, mut args: Args) -> TypResult<Value> {
         let value = (self.construct)(ctx, &mut args)?;
         args.finish()?;
@@ -126,7 +127,7 @@ pub trait Construct {
     ///
     /// This is passed only the arguments that remain after execution of the
     /// class's set rule.
-    fn construct(ctx: &mut Context, args: &mut Args) -> TypResult<Template>;
+    fn construct(ctx: &mut Context, args: &mut Args) -> TypResult<Content>;
 }
 
 /// Set style properties of a class.
diff --git a/src/eval/content.rs b/src/eval/content.rs
new file mode 100644
index 00000000..b6d60957
--- /dev/null
+++ b/src/eval/content.rs
@@ -0,0 +1,581 @@
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::iter::Sum;
+use std::ops::{Add, AddAssign};
+
+use typed_arena::Arena;
+
+use super::{
+    CollapsingBuilder, Interruption, Layout, LayoutNode, Property, Show, ShowNode,
+    StyleMap, StyleVecBuilder,
+};
+use crate::diag::StrResult;
+use crate::library::layout::{FlowChild, FlowNode, PageNode, PlaceNode, SpacingKind};
+use crate::library::prelude::*;
+use crate::library::structure::{ListItem, ListKind, ListNode, ORDERED, UNORDERED};
+use crate::library::text::{DecoNode, ParChild, ParNode, TextNode, UNDERLINE};
+use crate::util::EcoString;
+
+/// Composable representation of styled content.
+///
+/// This results from:
+/// - anything written between square brackets in Typst
+/// - any node constructor
+///
+/// Content is represented as a tree of nodes. There are two nodes of special
+/// interest:
+///
+/// 1. A `Styled` node attaches a style map to other content. For example, a
+///    single bold word could be represented as a `Styled(Text("Hello"),
+///    [TextNode::STRONG: true])` node.
+
+/// 2. A `Sequence` node content combines other arbitrary content and is the
+///    representation of a "flow" of other nodes. So, when you write `[Hi] +
+///    [you]` in Typst, this type's [`Add`] implementation is invoked and the
+///    two [`Text`](Self::Text) nodes are combined into a single
+///    [`Sequence`](Self::Sequence) node. A sequence may contain nested
+///    sequences.
+#[derive(PartialEq, Clone, Hash)]
+pub enum Content {
+    /// A word space.
+    Space,
+    /// A line break.
+    Linebreak,
+    /// Horizontal spacing.
+    Horizontal(SpacingKind),
+    /// Plain text.
+    Text(EcoString),
+    /// An inline-level node.
+    Inline(LayoutNode),
+    /// A paragraph break.
+    Parbreak,
+    /// A column break.
+    Colbreak,
+    /// Vertical spacing.
+    Vertical(SpacingKind),
+    /// A block-level node.
+    Block(LayoutNode),
+    /// An item in an unordered list.
+    List(ListItem),
+    /// An item in an ordered list.
+    Enum(ListItem),
+    /// A page break.
+    Pagebreak,
+    /// A page node.
+    Page(PageNode),
+    /// A node that can be realized with styles.
+    Show(ShowNode),
+    /// Content with attached styles.
+    Styled(Arc<(Self, StyleMap)>),
+    /// A sequence of multiple nodes.
+    Sequence(Arc<Vec<Self>>),
+}
+
+impl Content {
+    /// Create empty content.
+    pub fn new() -> Self {
+        Self::sequence(vec![])
+    }
+
+    /// Create content from an inline-level node.
+    pub fn inline<T>(node: T) -> Self
+    where
+        T: Layout + Debug + Hash + Sync + Send + 'static,
+    {
+        Self::Inline(node.pack())
+    }
+
+    /// Create content from a block-level node.
+    pub fn block<T>(node: T) -> Self
+    where
+        T: Layout + Debug + Hash + Sync + Send + 'static,
+    {
+        Self::Block(node.pack())
+    }
+
+    /// Create content 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 content with a single style property.
+    pub fn styled<P: Property>(mut self, key: P, value: P::Value) -> Self {
+        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 content with a full style map.
+    pub fn styled_with_map(mut self, styles: StyleMap) -> Self {
+        if styles.is_empty() {
+            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 content in monospace.
+    pub fn monospaced(self) -> Self {
+        self.styled(TextNode::MONOSPACED, true)
+    }
+
+    /// Underline this content.
+    pub fn underlined(self) -> Self {
+        Self::show(DecoNode::<UNDERLINE>(self))
+    }
+
+    /// Create a new sequence nodes from multiples nodes.
+    pub fn sequence(seq: Vec<Self>) -> Self {
+        if seq.len() == 1 {
+            seq.into_iter().next().unwrap()
+        } else {
+            Self::Sequence(Arc::new(seq))
+        }
+    }
+
+    /// Repeat this content `n` times.
+    pub fn repeat(&self, n: i64) -> StrResult<Self> {
+        let count = usize::try_from(n)
+            .map_err(|_| format!("cannot repeat this content {} times", n))?;
+
+        Ok(Self::sequence(vec![self.clone(); count]))
+    }
+
+    /// Layout this content into a collection of pages.
+    pub fn layout(&self, ctx: &mut Context) -> TypResult<Vec<Arc<Frame>>> {
+        let sya = Arena::new();
+        let tpa = Arena::new();
+
+        let styles = ctx.styles.clone();
+        let styles = StyleChain::new(&styles);
+
+        let mut builder = Builder::new(&sya, &tpa, true);
+        builder.process(ctx, self, styles)?;
+        builder.finish(ctx, styles)?;
+
+        let mut frames = vec![];
+        let (pages, shared) = builder.pages.unwrap().finish();
+
+        for (page, map) in pages.iter() {
+            let number = 1 + frames.len();
+            frames.extend(page.layout(ctx, number, map.chain(&shared))?);
+        }
+
+        Ok(frames)
+    }
+}
+
+impl Default for Content {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Add for Content {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self::Sequence(match (self, rhs) {
+            (Self::Sequence(mut lhs), Self::Sequence(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) => {
+                Arc::make_mut(&mut lhs).push(rhs);
+                lhs
+            }
+            (lhs, Self::Sequence(mut rhs)) => {
+                Arc::make_mut(&mut rhs).insert(0, lhs);
+                rhs
+            }
+            (lhs, rhs) => Arc::new(vec![lhs, rhs]),
+        })
+    }
+}
+
+impl AddAssign for Content {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = std::mem::take(self) + rhs;
+    }
+}
+
+impl Sum for Content {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        Self::sequence(iter.collect())
+    }
+}
+
+impl Layout for Content {
+    fn layout(
+        &self,
+        ctx: &mut Context,
+        regions: &Regions,
+        styles: StyleChain,
+    ) -> TypResult<Vec<Arc<Frame>>> {
+        let sya = Arena::new();
+        let tpa = Arena::new();
+
+        let mut builder = Builder::new(&sya, &tpa, false);
+        builder.process(ctx, self, styles)?;
+        builder.finish(ctx, styles)?;
+
+        let (flow, shared) = builder.flow.finish();
+        FlowNode(flow).layout(ctx, regions, shared)
+    }
+
+    fn pack(self) -> LayoutNode {
+        match self {
+            Content::Block(node) => node,
+            other => LayoutNode::new(other),
+        }
+    }
+}
+
+/// Builds a flow or page nodes from content.
+struct Builder<'a> {
+    /// An arena where intermediate style chains are stored.
+    sya: &'a Arena<StyleChain<'a>>,
+    /// An arena where intermediate content resulting from show rules is stored.
+    tpa: &'a Arena<Content>,
+    /// The already built page runs.
+    pages: Option<StyleVecBuilder<'a, PageNode>>,
+    /// The currently built list.
+    list: Option<ListBuilder<'a>>,
+    /// The currently built flow.
+    flow: CollapsingBuilder<'a, FlowChild>,
+    /// The currently built paragraph.
+    par: CollapsingBuilder<'a, ParChild>,
+    /// Whether to keep the next page even if it is empty.
+    keep_next: bool,
+}
+
+impl<'a> Builder<'a> {
+    /// Prepare the builder.
+    fn new(sya: &'a Arena<StyleChain<'a>>, tpa: &'a Arena<Content>, top: bool) -> Self {
+        Self {
+            sya,
+            tpa,
+            pages: top.then(|| StyleVecBuilder::new()),
+            flow: CollapsingBuilder::new(),
+            list: None,
+            par: CollapsingBuilder::new(),
+            keep_next: true,
+        }
+    }
+
+    /// Process content.
+    fn process(
+        &mut self,
+        ctx: &mut Context,
+        content: &'a Content,
+        styles: StyleChain<'a>,
+    ) -> TypResult<()> {
+        if let Some(builder) = &mut self.list {
+            match content {
+                Content::Space => {
+                    builder.staged.push((content, styles));
+                    return Ok(());
+                }
+                Content::Parbreak => {
+                    builder.staged.push((content, styles));
+                    return Ok(());
+                }
+                Content::List(item) if builder.kind == UNORDERED => {
+                    builder.wide |=
+                        builder.staged.iter().any(|&(t, _)| *t == Content::Parbreak);
+                    builder.staged.clear();
+                    builder.items.push(item.clone());
+                    return Ok(());
+                }
+                Content::Enum(item) if builder.kind == ORDERED => {
+                    builder.wide |=
+                        builder.staged.iter().any(|&(t, _)| *t == Content::Parbreak);
+                    builder.staged.clear();
+                    builder.items.push(item.clone());
+                    return Ok(());
+                }
+                _ => self.finish_list(ctx)?,
+            }
+        }
+
+        match content {
+            Content::Space => {
+                self.par.weak(ParChild::Text(' '.into()), 0, styles);
+            }
+            Content::Linebreak => {
+                self.par.destructive(ParChild::Text('\n'.into()), styles);
+            }
+            Content::Horizontal(kind) => {
+                let child = ParChild::Spacing(*kind);
+                if kind.is_fractional() {
+                    self.par.destructive(child, styles);
+                } else {
+                    self.par.ignorant(child, styles);
+                }
+            }
+            Content::Text(text) => {
+                self.par.supportive(ParChild::Text(text.clone()), styles);
+            }
+            Content::Inline(node) => {
+                self.par.supportive(ParChild::Node(node.clone()), styles);
+            }
+            Content::Parbreak => {
+                self.finish_par(styles);
+                self.flow.weak(FlowChild::Parbreak, 1, styles);
+            }
+            Content::Colbreak => {
+                self.finish_par(styles);
+                self.flow.destructive(FlowChild::Colbreak, styles);
+            }
+            Content::Vertical(kind) => {
+                self.finish_par(styles);
+                let child = FlowChild::Spacing(*kind);
+                if kind.is_fractional() {
+                    self.flow.destructive(child, styles);
+                } else {
+                    self.flow.ignorant(child, styles);
+                }
+            }
+            Content::Block(node) => {
+                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);
+            }
+            Content::List(item) => {
+                self.list = Some(ListBuilder {
+                    styles,
+                    kind: UNORDERED,
+                    items: vec![item.clone()],
+                    wide: false,
+                    staged: vec![],
+                });
+            }
+            Content::Enum(item) => {
+                self.list = Some(ListBuilder {
+                    styles,
+                    kind: ORDERED,
+                    items: vec![item.clone()],
+                    wide: false,
+                    staged: vec![],
+                });
+            }
+            Content::Pagebreak => {
+                self.finish_page(ctx, true, true, styles)?;
+            }
+            Content::Page(page) => {
+                self.finish_page(ctx, false, false, styles)?;
+                if let Some(pages) = &mut self.pages {
+                    pages.push(page.clone(), styles);
+                }
+            }
+            Content::Show(node) => {
+                let id = node.id();
+                let content = node.show(ctx, styles)?;
+                let stored = self.tpa.alloc(content);
+                self.process(ctx, stored, styles.unscoped(id))?;
+            }
+            Content::Styled(styled) => {
+                let (sub, map) = styled.as_ref();
+                let stored = self.sya.alloc(styles);
+                let styles = map.chain(stored);
+
+                let interruption = map.interruption();
+                match interruption {
+                    Some(Interruption::Page) => {
+                        self.finish_page(ctx, false, true, styles)?
+                    }
+                    Some(Interruption::Par) => self.finish_par(styles),
+                    None => {}
+                }
+
+                self.process(ctx, sub, styles)?;
+
+                match interruption {
+                    Some(Interruption::Page) => {
+                        self.finish_page(ctx, true, false, styles)?
+                    }
+                    Some(Interruption::Par) => self.finish_par(styles),
+                    None => {}
+                }
+            }
+            Content::Sequence(seq) => {
+                for sub in seq.iter() {
+                    self.process(ctx, sub, styles)?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Finish the currently built paragraph.
+    fn finish_par(&mut self, styles: StyleChain<'a>) {
+        let (mut par, shared) = std::mem::take(&mut self.par).finish();
+        if !par.is_empty() {
+            // Paragraph indent should only apply if the paragraph starts with
+            // text and follows directly after another paragraph.
+            let indent = shared.get(ParNode::INDENT);
+            if !indent.is_zero()
+                && par
+                    .items()
+                    .find_map(|child| match child {
+                        ParChild::Spacing(_) => None,
+                        ParChild::Text(_) => Some(true),
+                        ParChild::Node(_) => Some(false),
+                    })
+                    .unwrap_or_default()
+                && self
+                    .flow
+                    .items()
+                    .rev()
+                    .find_map(|child| match child {
+                        FlowChild::Leading => None,
+                        FlowChild::Parbreak => None,
+                        FlowChild::Node(node) => Some(node.is::<ParNode>()),
+                        FlowChild::Spacing(_) => Some(false),
+                        FlowChild::Colbreak => Some(false),
+                    })
+                    .unwrap_or_default()
+            {
+                par.push_front(ParChild::Spacing(SpacingKind::Linear(indent)))
+            }
+
+            let node = ParNode(par).pack();
+            self.flow.supportive(FlowChild::Node(node), shared);
+        }
+        self.flow.weak(FlowChild::Leading, 0, styles);
+    }
+
+    /// Finish the currently built list.
+    fn finish_list(&mut self, ctx: &mut Context) -> TypResult<()> {
+        let ListBuilder { styles, kind, items, wide, staged } = match self.list.take() {
+            Some(list) => list,
+            None => return Ok(()),
+        };
+
+        let content = match kind {
+            UNORDERED => Content::show(ListNode::<UNORDERED> { start: 1, wide, items }),
+            ORDERED | _ => Content::show(ListNode::<ORDERED> { start: 1, wide, items }),
+        };
+
+        let stored = self.tpa.alloc(content);
+        self.process(ctx, stored, styles)?;
+        for (content, styles) in staged {
+            self.process(ctx, content, styles)?;
+        }
+
+        Ok(())
+    }
+
+    /// Finish the currently built page run.
+    fn finish_page(
+        &mut self,
+        ctx: &mut Context,
+        keep_last: bool,
+        keep_next: bool,
+        styles: StyleChain<'a>,
+    ) -> TypResult<()> {
+        self.finish_list(ctx)?;
+        self.finish_par(styles);
+        if let Some(pages) = &mut self.pages {
+            let (flow, shared) = std::mem::take(&mut self.flow).finish();
+            if !flow.is_empty() || (keep_last && self.keep_next) {
+                let styles = if flow.is_empty() { styles } else { shared };
+                let node = PageNode(FlowNode(flow).pack());
+                pages.push(node, styles);
+            }
+        }
+        self.keep_next = keep_next;
+        Ok(())
+    }
+
+    /// Finish everything.
+    fn finish(&mut self, ctx: &mut Context, styles: StyleChain<'a>) -> TypResult<()> {
+        self.finish_page(ctx, true, false, styles)
+    }
+}
+
+/// Builds an unordered or ordered list from items.
+struct ListBuilder<'a> {
+    styles: StyleChain<'a>,
+    kind: ListKind,
+    items: Vec<ListItem>,
+    wide: bool,
+    staged: Vec<(&'a Content, StyleChain<'a>)>,
+}
+
+impl Debug for Content {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::Space => f.pad("Space"),
+            Self::Linebreak => f.pad("Linebreak"),
+            Self::Horizontal(kind) => write!(f, "Horizontal({kind:?})"),
+            Self::Text(text) => write!(f, "Text({text:?})"),
+            Self::Inline(node) => {
+                f.write_str("Inline(")?;
+                node.fmt(f)?;
+                f.write_str(")")
+            }
+            Self::Parbreak => f.pad("Parbreak"),
+            Self::Colbreak => f.pad("Colbreak"),
+            Self::Vertical(kind) => write!(f, "Vertical({kind:?})"),
+            Self::Block(node) => {
+                f.write_str("Block(")?;
+                node.fmt(f)?;
+                f.write_str(")")
+            }
+            Self::List(item) => {
+                f.write_str("- ")?;
+                item.body.fmt(f)
+            }
+            Self::Enum(item) => {
+                if let Some(number) = item.number {
+                    write!(f, "{}", number)?;
+                }
+                f.write_str(". ")?;
+                item.body.fmt(f)
+            }
+            Self::Pagebreak => f.pad("Pagebreak"),
+            Self::Page(page) => page.fmt(f),
+            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.iter()).finish(),
+        }
+    }
+}
diff --git a/src/eval/layout.rs b/src/eval/layout.rs
index 135e5e04..94375c61 100644
--- a/src/eval/layout.rs
+++ b/src/eval/layout.rs
@@ -19,7 +19,7 @@ use crate::Context;
 /// Layout return one frame per used region alongside constraints that define
 /// whether the result is reusable in other regions.
 pub trait Layout {
-    /// Layout the node into the given regions, producing constrained frames.
+    /// Layout this node into the given regions, producing constrained frames.
     fn layout(
         &self,
         ctx: &mut Context,
diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 6a918dbd..79c0ad83 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -11,6 +11,7 @@ mod styles;
 mod capture;
 mod class;
 mod collapse;
+mod content;
 mod control;
 mod func;
 mod layout;
@@ -18,12 +19,12 @@ mod module;
 mod ops;
 mod scope;
 mod show;
-mod template;
 
 pub use array::*;
 pub use capture::*;
 pub use class::*;
 pub use collapse::*;
+pub use content::*;
 pub use control::*;
 pub use dict::*;
 pub use func::*;
@@ -32,7 +33,6 @@ pub use module::*;
 pub use scope::*;
 pub use show::*;
 pub use styles::*;
-pub use template::*;
 pub use value::*;
 
 use unicode_segmentation::UnicodeSegmentation;
@@ -58,7 +58,7 @@ pub trait Eval {
 pub type EvalResult<T> = Result<T, Control>;
 
 impl Eval for Markup {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
         eval_markup(ctx, scp, &mut self.nodes())
@@ -70,7 +70,7 @@ fn eval_markup(
     ctx: &mut Context,
     scp: &mut Scopes,
     nodes: &mut impl Iterator<Item = MarkupNode>,
-) -> EvalResult<Template> {
+) -> EvalResult<Content> {
     let mut seq = Vec::with_capacity(nodes.size_hint().1.unwrap_or_default());
 
     while let Some(node) = nodes.next() {
@@ -92,18 +92,18 @@ fn eval_markup(
         });
     }
 
-    Ok(Template::sequence(seq))
+    Ok(Content::sequence(seq))
 }
 
 impl Eval for MarkupNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
         Ok(match self {
-            Self::Space => Template::Space,
-            Self::Linebreak => Template::Linebreak,
-            Self::Parbreak => Template::Parbreak,
-            Self::Text(text) => Template::Text(text.clone()),
+            Self::Space => Content::Space,
+            Self::Linebreak => Content::Linebreak,
+            Self::Parbreak => Content::Parbreak,
+            Self::Text(text) => Content::Text(text.clone()),
             Self::Strong(strong) => strong.eval(ctx, scp)?,
             Self::Emph(emph) => emph.eval(ctx, scp)?,
             Self::Raw(raw) => raw.eval(ctx, scp)?,
@@ -117,45 +117,45 @@ impl Eval for MarkupNode {
 }
 
 impl Eval for StrongNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::text::StrongNode(
+        Ok(Content::show(library::text::StrongNode(
             self.body().eval(ctx, scp)?,
         )))
     }
 }
 
 impl Eval for EmphNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::text::EmphNode(
+        Ok(Content::show(library::text::EmphNode(
             self.body().eval(ctx, scp)?,
         )))
     }
 }
 
 impl Eval for RawNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, _: &mut Context, _: &mut Scopes) -> EvalResult<Self::Output> {
-        let template = Template::show(library::text::RawNode {
+        let content = Content::show(library::text::RawNode {
             text: self.text.clone(),
             block: self.block,
         });
         Ok(match self.lang {
-            Some(_) => template.styled(library::text::RawNode::LANG, self.lang.clone()),
-            None => template,
+            Some(_) => content.styled(library::text::RawNode::LANG, self.lang.clone()),
+            None => content,
         })
     }
 }
 
 impl Eval for MathNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, _: &mut Context, _: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::math::MathNode {
+        Ok(Content::show(library::math::MathNode {
             formula: self.formula.clone(),
             display: self.display,
         }))
@@ -163,10 +163,10 @@ impl Eval for MathNode {
 }
 
 impl Eval for HeadingNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::show(library::structure::HeadingNode {
+        Ok(Content::show(library::structure::HeadingNode {
             body: self.body().eval(ctx, scp)?,
             level: self.level(),
         }))
@@ -174,10 +174,10 @@ impl Eval for HeadingNode {
 }
 
 impl Eval for ListNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::List(library::structure::ListItem {
+        Ok(Content::List(library::structure::ListItem {
             number: None,
             body: Box::new(self.body().eval(ctx, scp)?),
         }))
@@ -185,10 +185,10 @@ impl Eval for ListNode {
 }
 
 impl Eval for EnumNode {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
-        Ok(Template::Enum(library::structure::ListItem {
+        Ok(Content::Enum(library::structure::ListItem {
             number: self.number(),
             body: Box::new(self.body().eval(ctx, scp)?),
         }))
@@ -203,7 +203,7 @@ impl Eval for Expr {
             Self::Lit(v) => v.eval(ctx, scp),
             Self::Ident(v) => v.eval(ctx, scp),
             Self::Code(v) => v.eval(ctx, scp),
-            Self::Template(v) => v.eval(ctx, scp).map(Value::Template),
+            Self::Content(v) => v.eval(ctx, scp).map(Value::Content),
             Self::Array(v) => v.eval(ctx, scp).map(Value::Array),
             Self::Dict(v) => v.eval(ctx, scp).map(Value::Dict),
             Self::Group(v) => v.eval(ctx, scp),
@@ -222,7 +222,7 @@ impl Eval for Expr {
             Self::While(v) => v.eval(ctx, scp),
             Self::For(v) => v.eval(ctx, scp),
             Self::Import(v) => v.eval(ctx, scp),
-            Self::Include(v) => v.eval(ctx, scp).map(Value::Template),
+            Self::Include(v) => v.eval(ctx, scp).map(Value::Content),
             Self::Break(v) => v.eval(ctx, scp),
             Self::Continue(v) => v.eval(ctx, scp),
             Self::Return(v) => v.eval(ctx, scp),
@@ -276,14 +276,14 @@ impl Eval for CodeBlock {
     }
 }
 
-impl Eval for TemplateBlock {
-    type Output = Template;
+impl Eval for ContentBlock {
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
         scp.enter();
-        let template = self.body().eval(ctx, scp)?;
+        let content = self.body().eval(ctx, scp)?;
         scp.exit();
-        Ok(template)
+        Ok(content)
     }
 }
 
@@ -716,13 +716,13 @@ impl Eval for ImportExpr {
 }
 
 impl Eval for IncludeExpr {
-    type Output = Template;
+    type Output = Content;
 
     fn eval(&self, ctx: &mut Context, scp: &mut Scopes) -> EvalResult<Self::Output> {
         let span = self.path().span();
         let path = self.path().eval(ctx, scp)?.cast::<EcoString>().at(span)?;
         let module = import(ctx, &path, span)?;
-        Ok(module.template.clone())
+        Ok(module.content.clone())
     }
 }
 
diff --git a/src/eval/module.rs b/src/eval/module.rs
index 478c76b7..4460caec 100644
--- a/src/eval/module.rs
+++ b/src/eval/module.rs
@@ -1,4 +1,4 @@
-use super::{Scope, Template};
+use super::{Content, Scope};
 use crate::source::{SourceId, SourceStore};
 
 /// An evaluated module, ready for importing or layouting.
@@ -7,7 +7,7 @@ pub struct Module {
     /// The top-level definitions that were bound in this module.
     pub scope: Scope,
     /// The module's layoutable contents.
-    pub template: Template,
+    pub content: Content,
     /// The source file revisions this module depends on.
     pub deps: Vec<(SourceId, usize)>,
 }
diff --git a/src/eval/ops.rs b/src/eval/ops.rs
index acceb626..04a13fd1 100644
--- a/src/eval/ops.rs
+++ b/src/eval/ops.rs
@@ -19,11 +19,11 @@ pub fn join(lhs: Value, rhs: Value) -> StrResult<Value> {
         (a, None) => a,
         (None, b) => b,
         (Str(a), Str(b)) => Str(a + b),
+        (Str(a), Content(b)) => Content(super::Content::Text(a) + b),
+        (Content(a), Str(b)) => Content(a + super::Content::Text(b)),
+        (Content(a), Content(b)) => Content(a + b),
         (Array(a), Array(b)) => Array(a + b),
         (Dict(a), Dict(b)) => Dict(a + b),
-        (Template(a), Template(b)) => Template(a + b),
-        (Template(a), Str(b)) => Template(a + super::Template::Text(b)),
-        (Str(a), Template(b)) => Template(super::Template::Text(a) + b),
         (a, b) => mismatch!("cannot join {} with {}", a, b),
     })
 }
@@ -81,15 +81,16 @@ pub fn add(lhs: Value, rhs: Value) -> StrResult<Value> {
         (Fractional(a), Fractional(b)) => Fractional(a + b),
 
         (Str(a), Str(b)) => Str(a + b),
+
+        (Content(a), None) => Content(a),
+        (None, Content(b)) => Content(b),
+        (Content(a), Content(b)) => Content(a + b),
+        (Content(a), Str(b)) => Content(a + super::Content::Text(b)),
+        (Str(a), Content(b)) => Content(super::Content::Text(a) + b),
+
         (Array(a), Array(b)) => Array(a + b),
         (Dict(a), Dict(b)) => Dict(a + b),
 
-        (Template(a), None) => Template(a),
-        (None, Template(b)) => Template(b),
-        (Template(a), Template(b)) => Template(a + b),
-        (Template(a), Str(b)) => Template(a + super::Template::Text(b)),
-        (Str(a), Template(b)) => Template(super::Template::Text(a) + b),
-
         (a, b) => {
             if let (Dyn(a), Dyn(b)) = (&a, &b) {
                 // 1D alignments can be summed into 2D alignments.
@@ -177,8 +178,8 @@ pub fn mul(lhs: Value, rhs: Value) -> StrResult<Value> {
         (Int(a), Str(b)) => Str(repeat_str(b, a)?),
         (Array(a), Int(b)) => Array(a.repeat(b)?),
         (Int(a), Array(b)) => Array(b.repeat(a)?),
-        (Template(a), Int(b)) => Template(a.repeat(b)?),
-        (Int(a), Template(b)) => Template(b.repeat(a)?),
+        (Content(a), Int(b)) => Content(a.repeat(b)?),
+        (Int(a), Content(b)) => Content(b.repeat(a)?),
 
         (a, b) => mismatch!("cannot multiply {} with {}", a, b),
     })
@@ -293,9 +294,9 @@ pub fn equal(lhs: &Value, rhs: &Value) -> bool {
         (Fractional(a), Fractional(b)) => a == b,
         (Color(a), Color(b)) => a == b,
         (Str(a), Str(b)) => a == b,
+        (Content(a), Content(b)) => a == b,
         (Array(a), Array(b)) => a == b,
         (Dict(a), Dict(b)) => a == b,
-        (Template(a), Template(b)) => a == b,
         (Func(a), Func(b)) => a == b,
         (Dyn(a), Dyn(b)) => a == b,
 
diff --git a/src/eval/show.rs b/src/eval/show.rs
index b0fb8172..e85903d2 100644
--- a/src/eval/show.rs
+++ b/src/eval/show.rs
@@ -3,15 +3,15 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::Hash;
 use std::sync::Arc;
 
-use super::{StyleChain, Template};
+use super::{Content, StyleChain};
 use crate::diag::TypResult;
 use crate::util::Prehashed;
 use crate::Context;
 
 /// A node that can be realized given some styles.
 pub trait Show {
-    /// Realize the template in the given styles.
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template>;
+    /// Realize this node in the given styles.
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Content>;
 
     /// Convert to a packed show node.
     fn pack(self) -> ShowNode
@@ -42,7 +42,7 @@ impl ShowNode {
 }
 
 impl Show for ShowNode {
-    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Template> {
+    fn show(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Content> {
         self.0.show(ctx, styles)
     }
 
diff --git a/src/eval/styles.rs b/src/eval/styles.rs
index 5a8371a9..20c36ae2 100644
--- a/src/eval/styles.rs
+++ b/src/eval/styles.rs
@@ -3,7 +3,7 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
-use super::{Args, Func, Span, Template, Value};
+use super::{Args, Content, Func, Span, Value};
 use crate::diag::{At, TypResult};
 use crate::library::layout::PageNode;
 use crate::library::text::ParNode;
@@ -414,7 +414,7 @@ impl<'a> StyleChain<'a> {
         node: &dyn Any,
         ctx: &mut Context,
         values: impl IntoIterator<Item = Value>,
-    ) -> TypResult<Option<Template>> {
+    ) -> TypResult<Option<Content>> {
         Ok(if let Some(recipe) = self.recipes(node.type_id()).next() {
             let args = Args::from_values(recipe.span, values);
             Some(recipe.func.call(ctx, args)?.cast().at(recipe.span)?)
diff --git a/src/eval/template.rs b/src/eval/template.rs
deleted file mode 100644
index 3e88b6d7..00000000
--- a/src/eval/template.rs
+++ /dev/null
@@ -1,587 +0,0 @@
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::iter::Sum;
-use std::ops::{Add, AddAssign};
-
-use typed_arena::Arena;
-
-use super::{
-    CollapsingBuilder, Interruption, Layout, LayoutNode, Property, Show, ShowNode,
-    StyleMap, StyleVecBuilder,
-};
-use crate::diag::StrResult;
-use crate::library::layout::{FlowChild, FlowNode, PageNode, PlaceNode, SpacingKind};
-use crate::library::prelude::*;
-use crate::library::structure::{ListItem, ListKind, ListNode, ORDERED, UNORDERED};
-use crate::library::text::{DecoNode, ParChild, ParNode, TextNode, UNDERLINE};
-use crate::util::EcoString;
-
-/// Composable representation of styled content.
-///
-/// This results from:
-/// - anything written between square brackets in Typst
-/// - any class constructor
-///
-/// This enum has two notable variants:
-///
-/// 1. A `Styled` template attaches a style map to a template. This map affects
-///    the whole subtemplate. For example, a single bold word could be
-///    represented as a `Styled(Text("Hello"), [TextNode::STRONG: true])`
-///    template.
-///
-/// 2. A `Sequence` template combines multiple arbitrary templates and is the
-///    representation of a "flow" of content. So, when you write `[Hi] + [you]`
-///    in Typst, this type's [`Add`] implementation is invoked and the two
-///    [`Text`](Self::Text) templates are combined into a single
-///    [`Sequence`](Self::Sequence) template.
-///
-///    A sequence may contain nested sequences (meaning this variant effectively
-///    allows templates to form trees). All nested sequences can equivalently be
-///    represented as a single flat sequence, but allowing nesting doesn't hurt
-///    since we can just recurse into the nested sequences. Also, in theory,
-///    this allows better complexity when adding large sequence nodes just like
-///    for something like a text rope.
-#[derive(PartialEq, Clone, Hash)]
-pub enum Template {
-    /// A word space.
-    Space,
-    /// A line break.
-    Linebreak,
-    /// Horizontal spacing.
-    Horizontal(SpacingKind),
-    /// Plain text.
-    Text(EcoString),
-    /// An inline-level node.
-    Inline(LayoutNode),
-    /// A paragraph break.
-    Parbreak,
-    /// A column break.
-    Colbreak,
-    /// Vertical spacing.
-    Vertical(SpacingKind),
-    /// A block-level node.
-    Block(LayoutNode),
-    /// An item in an unordered list.
-    List(ListItem),
-    /// An item in an ordered list.
-    Enum(ListItem),
-    /// 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(Arc<(Self, StyleMap)>),
-    /// A sequence of multiple subtemplates.
-    Sequence(Arc<Vec<Self>>),
-}
-
-impl Template {
-    /// Create an empty template.
-    pub fn new() -> Self {
-        Self::sequence(vec![])
-    }
-
-    /// Create a template from an inline-level node.
-    pub fn inline<T>(node: T) -> Self
-    where
-        T: Layout + Debug + Hash + Sync + Send + 'static,
-    {
-        Self::Inline(node.pack())
-    }
-
-    /// Create a template from a block-level node.
-    pub fn block<T>(node: T) -> Self
-    where
-        T: Layout + Debug + Hash + Sync + Send + 'static,
-    {
-        Self::Block(node.pack())
-    }
-
-    /// 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(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() {
-            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::MONOSPACED, true)
-    }
-
-    /// Underline this template.
-    pub fn underlined(self) -> Self {
-        Self::show(DecoNode::<UNDERLINE>(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.
-    pub fn repeat(&self, n: i64) -> StrResult<Self> {
-        let count = usize::try_from(n)
-            .map_err(|_| format!("cannot repeat this template {} times", n))?;
-
-        Ok(Self::sequence(vec![self.clone(); count]))
-    }
-
-    /// Layout this template into a collection of pages.
-    pub fn layout(&self, ctx: &mut Context) -> TypResult<Vec<Arc<Frame>>> {
-        let sya = Arena::new();
-        let tpa = Arena::new();
-
-        let styles = ctx.styles.clone();
-        let styles = StyleChain::new(&styles);
-
-        let mut builder = Builder::new(&sya, &tpa, true);
-        builder.process(ctx, self, styles)?;
-        builder.finish(ctx, styles)?;
-
-        let mut frames = vec![];
-        let (pages, shared) = builder.pages.unwrap().finish();
-
-        for (page, map) in pages.iter() {
-            let number = 1 + frames.len();
-            frames.extend(page.layout(ctx, number, map.chain(&shared))?);
-        }
-
-        Ok(frames)
-    }
-}
-
-impl Default for Template {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Add for Template {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self::Sequence(match (self, rhs) {
-            (Self::Sequence(mut lhs), Self::Sequence(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) => {
-                Arc::make_mut(&mut lhs).push(rhs);
-                lhs
-            }
-            (lhs, Self::Sequence(mut rhs)) => {
-                Arc::make_mut(&mut rhs).insert(0, lhs);
-                rhs
-            }
-            (lhs, rhs) => Arc::new(vec![lhs, rhs]),
-        })
-    }
-}
-
-impl AddAssign for Template {
-    fn add_assign(&mut self, rhs: Self) {
-        *self = std::mem::take(self) + rhs;
-    }
-}
-
-impl Sum for Template {
-    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
-        Self::sequence(iter.collect())
-    }
-}
-
-impl Layout for Template {
-    fn layout(
-        &self,
-        ctx: &mut Context,
-        regions: &Regions,
-        styles: StyleChain,
-    ) -> TypResult<Vec<Arc<Frame>>> {
-        let sya = Arena::new();
-        let tpa = Arena::new();
-
-        let mut builder = Builder::new(&sya, &tpa, false);
-        builder.process(ctx, self, styles)?;
-        builder.finish(ctx, styles)?;
-
-        let (flow, shared) = builder.flow.finish();
-        FlowNode(flow).layout(ctx, regions, shared)
-    }
-
-    fn pack(self) -> LayoutNode {
-        match self {
-            Template::Block(node) => node,
-            other => LayoutNode::new(other),
-        }
-    }
-}
-
-/// Builds a flow or page nodes from a template.
-struct Builder<'a> {
-    /// An arena where intermediate style chains are stored.
-    sya: &'a Arena<StyleChain<'a>>,
-    /// An arena where intermediate templates are stored.
-    tpa: &'a Arena<Template>,
-    /// The already built page runs.
-    pages: Option<StyleVecBuilder<'a, PageNode>>,
-    /// The currently built list.
-    list: Option<ListBuilder<'a>>,
-    /// The currently built flow.
-    flow: CollapsingBuilder<'a, FlowChild>,
-    /// The currently built paragraph.
-    par: CollapsingBuilder<'a, ParChild>,
-    /// Whether to keep the next page even if it is empty.
-    keep_next: bool,
-}
-
-impl<'a> Builder<'a> {
-    /// Prepare the builder.
-    fn new(sya: &'a Arena<StyleChain<'a>>, tpa: &'a Arena<Template>, top: bool) -> Self {
-        Self {
-            sya,
-            tpa,
-            pages: top.then(|| StyleVecBuilder::new()),
-            flow: CollapsingBuilder::new(),
-            list: None,
-            par: CollapsingBuilder::new(),
-            keep_next: true,
-        }
-    }
-
-    /// Process a template.
-    fn process(
-        &mut self,
-        ctx: &mut Context,
-        template: &'a Template,
-        styles: StyleChain<'a>,
-    ) -> TypResult<()> {
-        if let Some(builder) = &mut self.list {
-            match template {
-                Template::Space => {
-                    builder.staged.push((template, styles));
-                    return Ok(());
-                }
-                Template::Parbreak => {
-                    builder.staged.push((template, styles));
-                    return Ok(());
-                }
-                Template::List(item) if builder.kind == UNORDERED => {
-                    builder.wide |=
-                        builder.staged.iter().any(|&(t, _)| *t == Template::Parbreak);
-                    builder.staged.clear();
-                    builder.items.push(item.clone());
-                    return Ok(());
-                }
-                Template::Enum(item) if builder.kind == ORDERED => {
-                    builder.wide |=
-                        builder.staged.iter().any(|&(t, _)| *t == Template::Parbreak);
-                    builder.staged.clear();
-                    builder.items.push(item.clone());
-                    return Ok(());
-                }
-                _ => self.finish_list(ctx)?,
-            }
-        }
-
-        match template {
-            Template::Space => {
-                self.par.weak(ParChild::Text(' '.into()), 0, styles);
-            }
-            Template::Linebreak => {
-                self.par.destructive(ParChild::Text('\n'.into()), styles);
-            }
-            Template::Horizontal(kind) => {
-                let child = ParChild::Spacing(*kind);
-                if kind.is_fractional() {
-                    self.par.destructive(child, styles);
-                } else {
-                    self.par.ignorant(child, styles);
-                }
-            }
-            Template::Text(text) => {
-                self.par.supportive(ParChild::Text(text.clone()), styles);
-            }
-            Template::Inline(node) => {
-                self.par.supportive(ParChild::Node(node.clone()), styles);
-            }
-            Template::Parbreak => {
-                self.finish_par(styles);
-                self.flow.weak(FlowChild::Parbreak, 1, styles);
-            }
-            Template::Colbreak => {
-                self.finish_par(styles);
-                self.flow.destructive(FlowChild::Colbreak, styles);
-            }
-            Template::Vertical(kind) => {
-                self.finish_par(styles);
-                let child = FlowChild::Spacing(*kind);
-                if kind.is_fractional() {
-                    self.flow.destructive(child, styles);
-                } else {
-                    self.flow.ignorant(child, styles);
-                }
-            }
-            Template::Block(node) => {
-                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::List(item) => {
-                self.list = Some(ListBuilder {
-                    styles,
-                    kind: UNORDERED,
-                    items: vec![item.clone()],
-                    wide: false,
-                    staged: vec![],
-                });
-            }
-            Template::Enum(item) => {
-                self.list = Some(ListBuilder {
-                    styles,
-                    kind: ORDERED,
-                    items: vec![item.clone()],
-                    wide: false,
-                    staged: vec![],
-                });
-            }
-            Template::Pagebreak => {
-                self.finish_page(ctx, true, true, styles)?;
-            }
-            Template::Page(page) => {
-                self.finish_page(ctx, false, false, styles)?;
-                if let Some(pages) = &mut self.pages {
-                    pages.push(page.clone(), styles);
-                }
-            }
-            Template::Show(node) => {
-                let id = node.id();
-                let template = node.show(ctx, styles)?;
-                let stored = self.tpa.alloc(template);
-                self.process(ctx, stored, styles.unscoped(id))?;
-            }
-            Template::Styled(styled) => {
-                let (sub, map) = styled.as_ref();
-                let stored = self.sya.alloc(styles);
-                let styles = map.chain(stored);
-
-                let interruption = map.interruption();
-                match interruption {
-                    Some(Interruption::Page) => {
-                        self.finish_page(ctx, false, true, styles)?
-                    }
-                    Some(Interruption::Par) => self.finish_par(styles),
-                    None => {}
-                }
-
-                self.process(ctx, sub, styles)?;
-
-                match interruption {
-                    Some(Interruption::Page) => {
-                        self.finish_page(ctx, true, false, styles)?
-                    }
-                    Some(Interruption::Par) => self.finish_par(styles),
-                    None => {}
-                }
-            }
-            Template::Sequence(seq) => {
-                for sub in seq.iter() {
-                    self.process(ctx, sub, styles)?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Finish the currently built paragraph.
-    fn finish_par(&mut self, styles: StyleChain<'a>) {
-        let (mut par, shared) = std::mem::take(&mut self.par).finish();
-        if !par.is_empty() {
-            // Paragraph indent should only apply if the paragraph starts with
-            // text and follows directly after another paragraph.
-            let indent = shared.get(ParNode::INDENT);
-            if !indent.is_zero()
-                && par
-                    .items()
-                    .find_map(|child| match child {
-                        ParChild::Spacing(_) => None,
-                        ParChild::Text(_) => Some(true),
-                        ParChild::Node(_) => Some(false),
-                    })
-                    .unwrap_or_default()
-                && self
-                    .flow
-                    .items()
-                    .rev()
-                    .find_map(|child| match child {
-                        FlowChild::Leading => None,
-                        FlowChild::Parbreak => None,
-                        FlowChild::Node(node) => Some(node.is::<ParNode>()),
-                        FlowChild::Spacing(_) => Some(false),
-                        FlowChild::Colbreak => Some(false),
-                    })
-                    .unwrap_or_default()
-            {
-                par.push_front(ParChild::Spacing(SpacingKind::Linear(indent)))
-            }
-
-            let node = ParNode(par).pack();
-            self.flow.supportive(FlowChild::Node(node), shared);
-        }
-        self.flow.weak(FlowChild::Leading, 0, styles);
-    }
-
-    /// Finish the currently built list.
-    fn finish_list(&mut self, ctx: &mut Context) -> TypResult<()> {
-        let ListBuilder { styles, kind, items, wide, staged } = match self.list.take() {
-            Some(list) => list,
-            None => return Ok(()),
-        };
-
-        let template = match kind {
-            UNORDERED => Template::show(ListNode::<UNORDERED> { start: 1, wide, items }),
-            ORDERED | _ => Template::show(ListNode::<ORDERED> { start: 1, wide, items }),
-        };
-
-        let stored = self.tpa.alloc(template);
-        self.process(ctx, stored, styles)?;
-        for (template, styles) in staged {
-            self.process(ctx, template, styles)?;
-        }
-
-        Ok(())
-    }
-
-    /// Finish the currently built page run.
-    fn finish_page(
-        &mut self,
-        ctx: &mut Context,
-        keep_last: bool,
-        keep_next: bool,
-        styles: StyleChain<'a>,
-    ) -> TypResult<()> {
-        self.finish_list(ctx)?;
-        self.finish_par(styles);
-        if let Some(pages) = &mut self.pages {
-            let (flow, shared) = std::mem::take(&mut self.flow).finish();
-            if !flow.is_empty() || (keep_last && self.keep_next) {
-                let styles = if flow.is_empty() { styles } else { shared };
-                let node = PageNode(FlowNode(flow).pack());
-                pages.push(node, styles);
-            }
-        }
-        self.keep_next = keep_next;
-        Ok(())
-    }
-
-    /// Finish everything.
-    fn finish(&mut self, ctx: &mut Context, styles: StyleChain<'a>) -> TypResult<()> {
-        self.finish_page(ctx, true, false, styles)
-    }
-}
-
-/// Builds an unordered or ordered list from items.
-struct ListBuilder<'a> {
-    styles: StyleChain<'a>,
-    kind: ListKind,
-    items: Vec<ListItem>,
-    wide: bool,
-    staged: Vec<(&'a Template, StyleChain<'a>)>,
-}
-
-impl Debug for Template {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::Space => f.pad("Space"),
-            Self::Linebreak => f.pad("Linebreak"),
-            Self::Horizontal(kind) => write!(f, "Horizontal({kind:?})"),
-            Self::Text(text) => write!(f, "Text({text:?})"),
-            Self::Inline(node) => {
-                f.write_str("Inline(")?;
-                node.fmt(f)?;
-                f.write_str(")")
-            }
-            Self::Parbreak => f.pad("Parbreak"),
-            Self::Colbreak => f.pad("Colbreak"),
-            Self::Vertical(kind) => write!(f, "Vertical({kind:?})"),
-            Self::Block(node) => {
-                f.write_str("Block(")?;
-                node.fmt(f)?;
-                f.write_str(")")
-            }
-            Self::List(item) => {
-                f.write_str("- ")?;
-                item.body.fmt(f)
-            }
-            Self::Enum(item) => {
-                if let Some(number) = item.number {
-                    write!(f, "{}", number)?;
-                }
-                f.write_str(". ")?;
-                item.body.fmt(f)
-            }
-            Self::Pagebreak => f.pad("Pagebreak"),
-            Self::Page(page) => page.fmt(f),
-            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.iter()).finish(),
-        }
-    }
-}
diff --git a/src/eval/value.rs b/src/eval/value.rs
index 7d41bff5..48b2139f 100644
--- a/src/eval/value.rs
+++ b/src/eval/value.rs
@@ -4,7 +4,7 @@ use std::fmt::{self, Debug, Formatter};
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 
-use super::{ops, Args, Array, Class, Dict, Func, Layout, Template};
+use super::{ops, Args, Array, Class, Content, Dict, Func, Layout};
 use crate::diag::{with_alternative, StrResult};
 use crate::geom::{Angle, Color, Fractional, Length, Linear, Relative, RgbaColor};
 use crate::syntax::Spanned;
@@ -37,12 +37,12 @@ pub enum Value {
     Color(Color),
     /// A string: `"string"`.
     Str(EcoString),
+    /// A content value: `[*Hi* there]`.
+    Content(Content),
     /// An array of values: `(1, "hi", 12cm)`.
     Array(Array),
     /// A dictionary value: `(color: #f79143, pattern: dashed)`.
     Dict(Dict),
-    /// A template value: `[*Hi* there]`.
-    Template(Template),
     /// An executable function.
     Func(Func),
     /// Captured arguments to a function.
@@ -54,20 +54,20 @@ pub enum Value {
 }
 
 impl Value {
-    /// Create a template value from an inline-level node.
+    /// Create a content value from an inline-level node.
     pub fn inline<T>(node: T) -> Self
     where
         T: Layout + Debug + Hash + Sync + Send + 'static,
     {
-        Self::Template(Template::inline(node))
+        Self::Content(Content::inline(node))
     }
 
-    /// Create a template value from a block-level node.
+    /// Create a content value from a block-level node.
     pub fn block<T>(node: T) -> Self
     where
         T: Layout + Debug + Hash + Sync + Send + 'static,
     {
-        Self::Template(Template::block(node))
+        Self::Content(Content::block(node))
     }
 
     /// The name of the stored value's type.
@@ -85,9 +85,9 @@ impl Value {
             Self::Fractional(_) => Fractional::TYPE_NAME,
             Self::Color(_) => Color::TYPE_NAME,
             Self::Str(_) => EcoString::TYPE_NAME,
+            Self::Content(_) => Content::TYPE_NAME,
             Self::Array(_) => Array::TYPE_NAME,
             Self::Dict(_) => Dict::TYPE_NAME,
-            Self::Template(_) => Template::TYPE_NAME,
             Self::Func(_) => Func::TYPE_NAME,
             Self::Args(_) => Args::TYPE_NAME,
             Self::Class(_) => Class::TYPE_NAME,
@@ -111,16 +111,16 @@ impl Value {
     }
 
     /// Return the display representation of the value.
-    pub fn display(self) -> Template {
+    pub fn display(self) -> Content {
         match self {
-            Value::None => Template::new(),
-            Value::Int(v) => Template::Text(format_eco!("{}", v)),
-            Value::Float(v) => Template::Text(format_eco!("{}", v)),
-            Value::Str(v) => Template::Text(v),
-            Value::Template(v) => v,
+            Value::None => Content::new(),
+            Value::Int(v) => Content::Text(format_eco!("{}", v)),
+            Value::Float(v) => Content::Text(format_eco!("{}", v)),
+            Value::Str(v) => Content::Text(v),
+            Value::Content(v) => v,
             // For values which can't be shown "naturally", we print the
             // representation in monospace.
-            v => Template::Text(v.repr()).monospaced(),
+            v => Content::Text(v.repr()).monospaced(),
         }
     }
 }
@@ -146,9 +146,9 @@ impl Debug for Value {
             Self::Fractional(v) => Debug::fmt(v, f),
             Self::Color(v) => Debug::fmt(v, f),
             Self::Str(v) => Debug::fmt(v, f),
+            Self::Content(_) => f.pad("<content>"),
             Self::Array(v) => Debug::fmt(v, f),
             Self::Dict(v) => Debug::fmt(v, f),
-            Self::Template(_) => f.pad("<template>"),
             Self::Func(v) => Debug::fmt(v, f),
             Self::Args(v) => Debug::fmt(v, f),
             Self::Class(v) => Debug::fmt(v, f),
@@ -185,9 +185,9 @@ impl Hash for Value {
             Self::Fractional(v) => v.hash(state),
             Self::Color(v) => v.hash(state),
             Self::Str(v) => v.hash(state),
+            Self::Content(v) => v.hash(state),
             Self::Array(v) => v.hash(state),
             Self::Dict(v) => v.hash(state),
-            Self::Template(v) => v.hash(state),
             Self::Func(v) => v.hash(state),
             Self::Args(v) => v.hash(state),
             Self::Class(v) => v.hash(state),
@@ -441,9 +441,9 @@ primitive! { Linear: "relative length", Linear, Length(v) => v.into(), Relative(
 primitive! { Fractional: "fractional length", Fractional }
 primitive! { Color: "color", Color }
 primitive! { EcoString: "string", Str }
+primitive! { Content: "content", Content, None => Content::new() }
 primitive! { Array: "array", Array }
 primitive! { Dict: "dictionary", Dict }
-primitive! { Template: "template", Template, None => Template::new() }
 primitive! { Func: "function", Func, Class(v) => v.constructor() }
 primitive! { Args: "arguments", Args }
 primitive! { Class: "class", Class }
-- 
cgit v1.2.3