fleuron/

style.rs

//! The style tree: resolved styling.
//!
//! Styling enters as CSS. A built-in user-agent stylesheet supplies
//! the defaults; author CSS cascades over it. What comes out is one
//! computed style per content node and one page master per situation
//! a page can be in, and that is the whole of what layout is told.
//!
//! ```text
//! content tree + CSS ─► style tree ─► box tree ─► …
//! ```
//!
//! Font faces reach the registry here too: `@font-face` names a
//! source, the host loader hands back bytes, and every node's face is
//! an id by the time layout sees it.

mod element;
mod inspect;
mod properties;
mod sheet;
pub mod subset;
mod substitution;

use std::collections::BTreeMap;

use cssparser::ToCss;
use selectors::context::{
    MatchingForInvalidation, MatchingMode, NeedsSelectorFlags, QuirksMode, SelectorCaches,
};
use selectors::matching::{MatchingContext, matches_selector};
use serde::Serialize;

use crate::Warning;
use crate::content::{
    Alignment, Attributes, Block, Book, Inline, NodeId, PseudoElement, block_attributes,
    block_position, inline_attributes, inline_position, origin, rows,
};
use crate::fonts::{FaceAttributes, FontError, FontRegistry, FontSource};
use crate::lines::{FirstLine, InlineBox, InlineStyles, ParagraphStyle};
use crate::pages::Side;

pub(crate) use inspect::element_of;
pub use inspect::{Ancestor, InspectedDeclaration, Inspection, MatchedRule};
pub use properties::{
    Align, AlignContent, Background, BackgroundPosition, BackgroundRepeat, BackgroundSize, Band,
    Border, BorderCollapse, BorderRadius, BorderStyle, BoxDecorationBreak, Break, Color,
    ColumnRule, ColumnSpan, Columns, ComputedStyle, Content, ContentPiece, Coord, Corner,
    CornerRadius, CounterStyle, DecorationLine, DecorationStyle, Edge, Edges, Family, Figures,
    FontStyle, FontVariantAlternates, FontVariantCaps, FontVariantLigatures, FontVariantNumeric,
    Fractions, Hyphens, Inset, Length, LineHeight, ListStyleType, MarginBox, NumericSpacing,
    PageGeometry, Position, ShapeOutside, ShapePoint, ShapeSource, SizeSource, StringPiece,
    StringSet, Target, TextAlign, TextDecoration, TextJustify, TextTransform, Url, Width, WrapFlow,
};
pub use sheet::{FontFace, Origin, SheetPosition, Source, Src, Written};

use element::{BLOCK_ELEMENTS, ElementTree, INLINE_ELEMENTS};
use properties::{Custom, Declaration};
use sheet::{Importance, MarginDeclaration, PageDeclaration, PageRule, Sheet};

/// The defaults, as a stylesheet. There are no style constants in the
/// engine; this file is where the trade paperback lives.
pub const USER_AGENT_CSS: &str = include_str!("style/ua.css");

/// Resolves `@font-face` sources to font bytes.
///
/// The engine reads no paths of its own. Whatever string the sheet
/// writes in `url()` is handed over as it is: it never has to be a
/// real URL, and a host that resolves nothing is a host with no
/// author fonts.
pub trait FontLoader {
    /// The bytes behind one `src` url, or `None` when the host cannot
    /// resolve it.
    fn load(&self, url: &str) -> Option<Vec<u8>>;
}

/// A loader that resolves nothing.
pub struct NoFonts;

impl FontLoader for NoFonts {
    fn load(&self, _url: &str) -> Option<Vec<u8>> {
        None
    }
}

/// One node's place in the tree: what it is, and which style it got.
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct NodeStyle {
    /// The content node this style belongs to.
    pub id: u32,
    /// The element name selectors matched against.
    pub element: &'static str,
    /// Index into the tree's distinct styles.
    pub style: u32,
    /// Index of the style `::first-letter` computed for this node,
    /// when a rule named one.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub first_letter: Option<u32>,
    /// Index of the style `::first-line` computed for this node, when
    /// a rule named one.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub first_line: Option<u32>,
    /// Index of the style `::before` computed for this node, when it
    /// generates text.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub before: Option<u32>,
    /// Index of the style `::after` computed for this node, when it
    /// generates text.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub after: Option<u32>,
}

/// The situation a page finds itself in, which is what `@page`
/// selects on beyond the page's name.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum Situation {
    /// The page a page group opens on: `@page :first`.
    First(Side),
    /// Any later page of the group.
    Body(Side),
    /// A page inserted to square the sheet: `@page :blank`.
    Blank,
}

impl Situation {
    /// The side of the spread this situation falls on. Blanks are
    /// versos: a book never opens a leaf to a blank right-hand page.
    pub fn side(self) -> Side {
        match self {
            Situation::First(side) | Situation::Body(side) => side,
            Situation::Blank => Side::Verso,
        }
    }
}

/// Which page a `@page` lookup is about.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PageQuery<'a> {
    /// The named page in force, from the `page` property.
    pub name: Option<&'a str>,
    /// Which page of the group, and which side.
    pub situation: Situation,
}

/// One resolved page master: the page box, and what its margin boxes
/// paint.
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct PageStyle {
    /// Trim size and margins.
    pub geometry: PageGeometry,
    /// What is painted behind the whole page box, margins included.
    #[serde(skip_serializing_if = "properties::no_background")]
    pub background: Background,
    /// The margin boxes the page's rules mentioned, in CSS order.
    pub boxes: Vec<MarginBoxStyle>,
}

impl PageStyle {
    /// The margin box `which`, when it paints anything.
    pub fn margin_box(&self, which: MarginBox) -> Option<&MarginBoxStyle> {
        self.boxes
            .iter()
            .find(|box_| box_.which == which && box_.content != Content::None)
    }
}

/// One page margin box: what it paints and the style it paints with.
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct MarginBoxStyle {
    /// Which of the sixteen boxes.
    pub which: MarginBox,
    /// What it paints.
    pub content: Content,
    /// The box's own text style, inherited from the book's root the
    /// way a block's would be.
    pub style: ComputedStyle,
}

/// One page master, named and situated.
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct PageMaster {
    /// The named page, or `None` for the unnamed default.
    pub page: Option<String>,
    /// The situation this master answers.
    pub situation: Situation,
    /// The page box and its margin boxes.
    pub style: PageStyle,
}

/// The compiled styling of one book.
#[derive(Debug, Clone, Serialize)]
pub struct StyleTree {
    /// The distinct computed styles this book uses. Nodes index into
    /// it: a book has thousands of nodes and a handful of styles.
    styles: Vec<ComputedStyle>,
    /// Every element, in document order.
    nodes: Vec<NodeStyle>,
    /// Every master a page of this book can take.
    masters: Vec<PageMaster>,
    /// Style index by raw node id. Index 0 is the root, which is also
    /// what an unassigned node resolves to.
    #[serde(skip)]
    by_node: Vec<u32>,
    /// `::first-letter` style index by raw node id, where there is one.
    #[serde(skip)]
    initial_by_node: Vec<Option<u32>>,
    /// `::first-line` style index by raw node id, where there is one.
    #[serde(skip)]
    first_line_by_node: Vec<Option<u32>>,
    /// `::before` style index by raw node id, where it generates text.
    #[serde(skip)]
    before_by_node: Vec<Option<u32>>,
    /// `::after` style index by raw node id, where it generates text.
    #[serde(skip)]
    after_by_node: Vec<Option<u32>>,
    /// Whether generated text prints the page an element lands on.
    #[serde(skip)]
    counts_pages: bool,
    /// Whether generated text names another element at all.
    #[serde(skip)]
    refers: bool,
    /// The footnote area, which no content node stands behind.
    #[serde(skip)]
    notes: NodeId,
    warnings: Vec<Warning>,
}

impl StyleTree {
    /// The computed style of one content node, or of one
    /// pseudo-element. An id the tree does not know — an unassigned
    /// one, or a node from another book — gets the root style, which
    /// is the book's own defaults.
    pub fn style(&self, id: NodeId) -> &ComputedStyle {
        if let Some((element, which)) = id.pseudo_element() {
            return self
                .pseudo_style(element, which)
                .unwrap_or_else(|| self.style(NodeId::UNASSIGNED));
        }
        let index = self
            .by_node
            .get(id.get() as usize)
            .copied()
            .unwrap_or_default();
        &self.styles[index as usize]
    }

    /// The node the footnote area is styled by: the `notes` element,
    /// which stands for the foot of every page.
    pub fn notes_area(&self) -> NodeId {
        self.notes
    }

    /// Everything line layout needs about one node.
    pub fn paragraph(&self, id: NodeId) -> ParagraphStyle {
        self.style(id).paragraph()
    }

    /// The style `::first-letter` computed for one node, when a rule
    /// named one. This is where a drop cap's size and face come from.
    pub fn first_letter(&self, id: NodeId) -> Option<&ComputedStyle> {
        let index = (*self.initial_by_node.get(id.get() as usize)?)?;
        Some(&self.styles[index as usize])
    }

    /// The style `::first-line` computed for one node, when a rule
    /// named one. Line layout reads it as what the opening line
    /// changes about the paragraph around it.
    pub fn first_line(&self, id: NodeId) -> Option<&ComputedStyle> {
        let index = (*self.first_line_by_node.get(id.get() as usize)?)?;
        Some(&self.styles[index as usize])
    }

    /// What `::first-line` changes about one node's own style, which
    /// is what line layout applies to the opening line.
    pub fn opening_line(&self, id: NodeId) -> Option<FirstLine> {
        Some(self.first_line(id)?.first_line_over(self.style(id)))
    }

    /// The style `::before` computed for one node, when its `content`
    /// generates anything. On an inline that is text inside the line.
    /// On a block it is a box, the first child of the block.
    pub fn before(&self, id: NodeId) -> Option<&ComputedStyle> {
        let index = (*self.before_by_node.get(id.get() as usize)?)?;
        Some(&self.styles[index as usize])
    }

    /// The same for `::after`.
    pub fn after(&self, id: NodeId) -> Option<&ComputedStyle> {
        let index = (*self.after_by_node.get(id.get() as usize)?)?;
        Some(&self.styles[index as usize])
    }

    /// The id of one pseudo-element of `element`, where a rule styles
    /// it. On a block, `::before` and `::after` are boxes. On an
    /// inline element, they are text inside the line. The id comes
    /// from the element and the pseudo-element alone, so it is the
    /// same in every layout of the same book and sheets, and no
    /// content node has it. `style` answers for it.
    pub fn pseudo_element(&self, element: NodeId, which: PseudoElement) -> Option<NodeId> {
        self.pseudo_style(element, which)
            .map(|_| element.pseudo(which))
    }

    fn pseudo_style(&self, element: NodeId, which: PseudoElement) -> Option<&ComputedStyle> {
        match which {
            PseudoElement::Before => self.before(element),
            PseudoElement::After => self.after(element),
            PseudoElement::FirstLetter => self.first_letter(element),
            PseudoElement::FirstLine => self.first_line(element),
        }
    }

    /// Whether any generated text prints the page another element
    /// lands on. Such a book is laid out twice: once to find the
    /// pages, and once to print them.
    pub fn counts_pages(&self) -> bool {
        self.counts_pages
    }

    /// Whether any generated text names another element, for its
    /// page or for its text.
    pub fn refers(&self) -> bool {
        self.refers
    }

    /// The style of the book itself: the root of inheritance.
    pub fn root(&self) -> &ComputedStyle {
        &self.styles[0]
    }

    /// The distinct computed styles, in the order nodes index them.
    pub fn styles(&self) -> &[ComputedStyle] {
        &self.styles
    }

    /// Every element, in document order.
    pub fn nodes(&self) -> &[NodeStyle] {
        &self.nodes
    }

    /// What compilation had to complain about.
    pub fn warnings(&self) -> &[Warning] {
        &self.warnings
    }

    /// The page master one page resolves to. A named page with no
    /// master of its own falls back to the unnamed one.
    pub fn page(&self, query: PageQuery<'_>) -> &PageStyle {
        self.master(query.name, query.situation)
            .or_else(|| self.master(None, query.situation))
            .expect("every situation has an unnamed master")
    }

    /// The default page: an unnamed body recto. The measure every
    /// paragraph breaks to comes from here.
    pub fn default_page(&self) -> &PageStyle {
        self.page(PageQuery {
            name: None,
            situation: Situation::Body(Side::Recto),
        })
    }

    /// Every master this book can put on a page: one per named page
    /// and situation, in a stable order.
    pub fn masters(&self) -> &[PageMaster] {
        &self.masters
    }

    fn master(&self, name: Option<&str>, situation: Situation) -> Option<&PageStyle> {
        self.masters
            .iter()
            .find(|master| master.page.as_deref() == name && master.situation == situation)
            .map(|master| &master.style)
    }
}

/// Resolves every master the book can use: the unnamed default, plus
/// each named page, in each situation a page can be in.
fn resolve_masters(
    pages: &[(u8, PageRule)],
    styles: &[ComputedStyle],
    root: &ComputedStyle,
    registry: &FontRegistry,
    warnings: &mut Vec<Warning>,
) -> Vec<PageMaster> {
    let mut names: Vec<Option<String>> = vec![None];
    for style in styles {
        if let Some(name) = &style.page
            && !names.iter().any(|known| known.as_deref() == Some(name))
        {
            names.push(Some(name.clone()));
        }
    }
    let situations = [
        Situation::First(Side::Recto),
        Situation::First(Side::Verso),
        Situation::Body(Side::Recto),
        Situation::Body(Side::Verso),
        Situation::Blank,
    ];
    let mut masters = Vec::new();
    for name in names {
        for situation in situations {
            masters.push(PageMaster {
                page: name.clone(),
                situation,
                style: resolve_page(
                    pages,
                    PageQuery {
                        name: name.as_deref(),
                        situation,
                    },
                    root,
                    registry,
                    warnings,
                ),
            });
        }
    }
    masters
}

/// One page master: every `@page` rule that selects it, applied in
/// specificity then source order.
fn resolve_page(
    pages: &[(u8, PageRule)],
    query: PageQuery<'_>,
    root: &ComputedStyle,
    registry: &FontRegistry,
    warnings: &mut Vec<Warning>,
) -> PageStyle {
    let mut matching: Vec<&(u8, PageRule)> = pages
        .iter()
        .filter(|(_, rule)| selects(rule, query))
        .collect();
    // `@page` cascades like any other rule: origin first, then
    // specificity. The rules are already in source order, and a stable
    // sort leaves the later of two equal rules on top.
    matching.sort_by_key(|(level, rule)| (*level, rule.specificity()));

    let root_size = root.font_size;
    // `column-gap: normal` is one em of the book's own size, and the
    // page box is not text, so the em it means is the root's.
    let mut geometry = PageGeometry {
        width: 612.0,
        height: 792.0,
        margin: Edges::all(0.0),
        columns: Columns::undivided(root_size),
        align_content: AlignContent::Start,
    };
    let initial = geometry;
    let mut background = Background::NONE;
    let mut boxes: BTreeMap<MarginBox, MarginBoxStyle> = BTreeMap::new();
    for (_, rule) in matching {
        for declaration in &rule.declarations {
            let PageDeclaration::Pending(pending) = declaration else {
                apply_page(&mut geometry, &mut background, declaration, root_size);
                continue;
            };
            let read = sheet::read_pending_page;
            match substitution::substituted(pending, &root.custom, read, warnings) {
                Some(declarations) => {
                    for declaration in &declarations {
                        apply_page(&mut geometry, &mut background, declaration, root_size);
                    }
                }
                None => {
                    for like in sheet::page_longhands(&pending.property) {
                        reset_page(&mut geometry, &mut background, &like, &initial);
                    }
                }
            }
        }
        for margin in &rule.boxes {
            let entry = boxes.entry(margin.which).or_insert_with(|| MarginBoxStyle {
                which: margin.which,
                content: Content::None,
                style: root.inherit(),
            });
            for declaration in &margin.declarations {
                let MarginDeclaration::Pending(pending) = declaration else {
                    apply_margin(entry, declaration, root_size);
                    continue;
                };
                let read = sheet::read_pending_margin;
                match substitution::substituted(pending, &root.custom, read, warnings) {
                    Some(declarations) => {
                        for declaration in &declarations {
                            apply_margin(entry, declaration, root_size);
                        }
                    }
                    None => {
                        let base = root.inherit();
                        for like in sheet::margin_longhands(&pending.property) {
                            match like {
                                MarginDeclaration::Style(like) => entry.style.reset(&like, &base),
                                _ => entry.content = Content::None,
                            }
                        }
                    }
                }
            }
            let (font_id, warning) = resolve_face(&entry.style, registry);
            entry.style.font_id = font_id;
            report(warnings, warning);
        }
    }
    PageStyle {
        geometry,
        background,
        boxes: boxes.into_values().collect(),
    }
}

/// Applies one declaration of a `@page` body.
fn apply_page(
    geometry: &mut PageGeometry,
    background: &mut Background,
    declaration: &PageDeclaration,
    root_size: f32,
) {
    match declaration {
        PageDeclaration::Size(width, height) => {
            geometry.width = *width;
            geometry.height = *height;
        }
        PageDeclaration::Margin(edge, length) => {
            *geometry.margin.edge(*edge) = length.to_points(root_size, root_size)
        }
        PageDeclaration::BackgroundColor(color) => background.color = *color,
        PageDeclaration::BackgroundImage(url) => background.image = url.clone(),
        PageDeclaration::BackgroundRepeat(repeat) => background.repeat = *repeat,
        PageDeclaration::BackgroundSize(size) => {
            background.size = properties::computed_size(*size, root_size, root_size)
        }
        PageDeclaration::BackgroundPosition(x, y) => {
            background.position = BackgroundPosition {
                x: Coord::of(*x, root_size, root_size),
                y: Coord::of(*y, root_size, root_size),
            }
        }
        PageDeclaration::ColumnCount(count) => geometry.columns.count = *count,
        PageDeclaration::ColumnWidth(width) => {
            geometry.columns.width = width.map(|width| width.to_points(root_size, root_size))
        }
        PageDeclaration::ColumnGap(gap) => {
            geometry.columns.gap = gap
                .map(|gap| gap.to_points(root_size, root_size))
                .unwrap_or(root_size)
                .max(0.0)
        }
        PageDeclaration::ColumnRuleWidth(width) => {
            geometry.columns.rule.width = width.to_points(root_size, root_size)
        }
        PageDeclaration::ColumnRuleStyle(style) => geometry.columns.rule.style = *style,
        PageDeclaration::AlignContent(align) => geometry.align_content = *align,
        PageDeclaration::Pending(_) => {}
    }
}

/// Sets what `like` declares on a page back to its initial value.
fn reset_page(
    geometry: &mut PageGeometry,
    background: &mut Background,
    like: &PageDeclaration,
    initial: &PageGeometry,
) {
    match like {
        PageDeclaration::Size(..) => {
            geometry.width = initial.width;
            geometry.height = initial.height;
        }
        PageDeclaration::Margin(edge, _) => {
            *geometry.margin.edge(*edge) = initial.margin.get(*edge)
        }
        PageDeclaration::BackgroundColor(_) => background.color = Background::NONE.color,
        PageDeclaration::BackgroundImage(_) => background.image = None,
        PageDeclaration::BackgroundRepeat(_) => background.repeat = Background::NONE.repeat,
        PageDeclaration::BackgroundSize(_) => background.size = Background::NONE.size,
        PageDeclaration::BackgroundPosition(..) => background.position = Background::NONE.position,
        PageDeclaration::ColumnCount(_) => geometry.columns.count = initial.columns.count,
        PageDeclaration::ColumnWidth(_) => geometry.columns.width = initial.columns.width,
        PageDeclaration::ColumnGap(_) => geometry.columns.gap = initial.columns.gap,
        PageDeclaration::ColumnRuleWidth(_) => {
            geometry.columns.rule.width = initial.columns.rule.width
        }
        PageDeclaration::ColumnRuleStyle(_) => {
            geometry.columns.rule.style = initial.columns.rule.style
        }
        PageDeclaration::AlignContent(_) => geometry.align_content = initial.align_content,
        PageDeclaration::Pending(_) => {}
    }
}

/// Applies one declaration of a page margin box.
fn apply_margin(entry: &mut MarginBoxStyle, declaration: &MarginDeclaration, root_size: f32) {
    match declaration {
        MarginDeclaration::Content(content) => entry.content = content.clone(),
        MarginDeclaration::Style(style) => entry.style.apply(style, root_size, root_size),
        MarginDeclaration::Pending(_) => {}
    }
}

impl InlineStyles for StyleTree {
    fn style(&self, id: NodeId, block: &ParagraphStyle) -> ParagraphStyle {
        match self.by_node.get(id.get() as usize) {
            Some(index) => self.styles[*index as usize].paragraph(),
            None => block.clone(),
        }
    }

    fn inline_box(&self, id: NodeId) -> Option<InlineBox> {
        let index = self.by_node.get(id.get() as usize)?;
        self.styles[*index as usize].inline_box()
    }
}

/// Whether one `@page` rule selects the page a query describes.
fn selects(rule: &PageRule, query: PageQuery<'_>) -> bool {
    if rule.name.is_some() && rule.name.as_deref() != query.name {
        return false;
    }
    if rule.first && !matches!(query.situation, Situation::First(_)) {
        return false;
    }
    if rule.blank && query.situation != Situation::Blank {
        return false;
    }
    match rule.side {
        Some(side) => side == query.situation.side(),
        None => true,
    }
}

/// Parsed stylesheets: the built-in sheet, then whatever the host
/// added, ready to compile against a book.
///
/// Parsing is separate from compiling because a run styles several
/// books from one set of sheets, and separate from font loading
/// because loading is the one step that reaches outside the engine.
#[derive(Debug)]
pub struct Stylesheets {
    sheets: Vec<Sheet>,
    /// What parsing said, then what font loading said.
    warnings: Vec<Warning>,
    /// How many of `warnings` parsing raised.
    parsed: usize,
}

impl Stylesheets {
    /// Parses the built-in sheet, then `sources` in the order given.
    pub fn parse(sources: &[Source<'_>]) -> Stylesheets {
        let built_in = Source::user_agent("user-agent.css", USER_AGENT_CSS);
        let mut sheets = Vec::new();
        let mut warnings = Vec::new();
        for source in std::iter::once(&built_in).chain(sources) {
            let (sheet, mut sheet_warnings) = sheet::parse(source);
            warnings.append(&mut sheet_warnings);
            sheets.push(sheet);
        }
        let parsed = warnings.len();
        Stylesheets {
            sheets,
            warnings,
            parsed,
        }
    }

    /// Registers every `@font-face` the loader resolves, under the
    /// family the sheet gave it rather than the one inside the file:
    /// a stylesheet's name for a face is the one its selectors use.
    ///
    /// Run this before compiling — a face the registry does not have
    /// is a face no computed style can resolve to. Running it again
    /// replaces what the last run warned about.
    pub fn load_fonts(&mut self, registry: &mut FontRegistry, loader: &dyn FontLoader) {
        let warnings = self
            .sheets
            .iter()
            .flat_map(|sheet| &sheet.faces)
            .flat_map(|face| register_face(face, registry, loader))
            .collect();
        self.set_font_warnings(warnings);
    }

    /// What the last font loading warned about.
    pub(crate) fn font_warnings(&self) -> &[Warning] {
        &self.warnings[self.parsed..]
    }

    /// Replaces what font loading warned about, for sheets whose faces
    /// a session already registered from an earlier copy of them.
    pub(crate) fn set_font_warnings(&mut self, warnings: Vec<Warning>) {
        self.warnings.truncate(self.parsed);
        self.warnings.extend(warnings);
    }

    /// Hashes every `@font-face` the sheets declare, and what `file`
    /// says about the bytes behind each url: two sheets that hash the
    /// same register the same faces.
    pub(crate) fn hash_faces(
        &self,
        h: &mut impl std::hash::Hasher,
        file: impl Fn(&str) -> Option<u64>,
    ) {
        use std::hash::Hash;
        for face in self.sheets.iter().flat_map(|sheet| &sheet.faces) {
            face.family.hash(h);
            face.style.hash(h);
            face.weight.hash(h);
            for src in &face.src {
                match src {
                    Src::Url(url) => (url, file(url)).hash(h),
                    Src::Local(name) => name.hash(h),
                }
            }
        }
    }

    /// What parsing and font loading had to complain about.
    pub fn warnings(&self) -> &[Warning] {
        &self.warnings
    }

    /// Every sheet as it was written, the built-in sheet first: what
    /// a writer reads that hands the CSS to a renderer of its own
    /// rather than laying it out.
    ///
    /// Only what the parser accepted is here. A rule or a declaration
    /// outside the subset is in [`Stylesheets::warnings`] instead.
    pub fn written(&self) -> Vec<WrittenSheet> {
        self.sheets
            .iter()
            .map(|sheet| WrittenSheet {
                origin: sheet.origin,
                rules: sheet
                    .rules
                    .iter()
                    .map(|rule| WrittenRule {
                        selectors: rule
                            .selectors
                            .slice()
                            .iter()
                            .map(|selector| selector.to_css_string())
                            .collect(),
                        declarations: rule.written.clone(),
                        position: rule.position.clone(),
                    })
                    .collect(),
                pages: sheet
                    .pages
                    .iter()
                    .map(|page| WrittenPage {
                        selector: page.selector.clone(),
                        position: page.position.clone(),
                    })
                    .collect(),
                faces: sheet.faces.clone(),
            })
            .collect()
    }

    /// Compiles one book's styling against the faces in the registry.
    pub fn compile(&self, book: &Book, registry: &FontRegistry) -> StyleTree {
        cascade(book, &self.sheets, registry, self.warnings.clone())
    }
}

/// One sheet as it was written. See [`Stylesheets::written`].
#[derive(Debug, Clone, PartialEq)]
pub struct WrittenSheet {
    /// Which origin the sheet cascades at.
    pub origin: Origin,
    /// The style rules, in the order they were written.
    pub rules: Vec<WrittenRule>,
    /// The `@page` rules, in the order they were written.
    pub pages: Vec<WrittenPage>,
    /// The `@font-face` rules, in the order they were written.
    pub faces: Vec<FontFace>,
}

/// One style rule as it was written.
#[derive(Debug, Clone, PartialEq)]
pub struct WrittenRule {
    /// Each selector of the list, as CSS.
    pub selectors: Vec<String>,
    /// The declarations the parser accepted, in the order they were
    /// written.
    pub declarations: Vec<Written>,
    /// Where the rule begins.
    pub position: SheetPosition,
}

/// One `@page` rule as it was written.
#[derive(Debug, Clone, PartialEq)]
pub struct WrittenPage {
    /// The prelude, `@page` included.
    pub selector: String,
    /// Where the rule begins.
    pub position: SheetPosition,
}

/// One book's styling under the built-in sheet alone.
pub fn defaults(book: &Book, registry: &FontRegistry) -> StyleTree {
    Stylesheets::parse(&[]).compile(book, registry)
}

/// Registers one `@font-face`, or says why it could not be.
fn register_face(
    face: &FontFace,
    registry: &mut FontRegistry,
    loader: &dyn FontLoader,
) -> Vec<Warning> {
    let mut warnings = Vec::new();
    for src in &face.src {
        let Src::Url(url) = src else {
            continue;
        };
        let Some(bytes) = loader.load(url) else {
            continue;
        };
        match FontSource::from_bytes(bytes) {
            Ok(mut source) => {
                source.family = face.family.to_lowercase();
                source.declared = declared(face);
                return match registry.add(source) {
                    Ok(_) => warnings,
                    Err(error) => {
                        warnings.push(Warning {
                            message: face_failure(&face.family, &error),
                            origin: Some(url.clone()),
                        });
                        warnings
                    }
                };
            }
            Err(error) => warnings.push(Warning {
                message: face_failure(&face.family, &error),
                origin: Some(url.clone()),
            }),
        }
    }
    warnings.push(Warning {
        message: format!("No src url loaded for {}. {FALLBACK}", face.family),
        origin: None,
    });
    warnings
}

/// What happens to text that asked for a face the registry has not
/// got.
const FALLBACK: &str = "Falling back to another registered font.";

/// Why one `@font-face` file did not register. The two causes read
/// apart, because the fix for each one is different.
fn face_failure(family: &str, error: &FontError) -> String {
    match error {
        FontError::MissingName => {
            format!("{family} has no family name and was not registered. {FALLBACK}")
        }
        FontError::Parse => format!("{family} could not be read as a font. {FALLBACK}"),
    }
}

/// What a `@font-face` declared its source to be. A sheet that
/// declares neither slope nor weight is naming a family, not a cut,
/// and the file names the cuts.
fn declared(face: &FontFace) -> Option<FaceAttributes> {
    let (style, weight) = (face.style, face.weight);
    (style.is_some() || weight.is_some()).then(|| FaceAttributes {
        italic: style == Some(FontStyle::Italic),
        weight: weight.unwrap_or(FaceAttributes::REGULAR.weight),
    })
}

/// Matching and the cascade: every element gets the declarations that
/// match it, in cascade order, applied over what it inherited.
fn cascade(
    book: &Book,
    sheets: &[Sheet],
    registry: &FontRegistry,
    mut warnings: Vec<Warning>,
) -> StyleTree {
    let elements = ElementTree::build(book);
    warnings.extend(repeated_ids(book));
    let mut caches = SelectorCaches::default();

    let mut styles: Vec<ComputedStyle> = Vec::new();
    let mut nodes = Vec::new();
    let mut computed: Vec<u32> = Vec::with_capacity(elements.nodes().len());
    let mut first_letters: Vec<Option<u32>> = Vec::with_capacity(elements.nodes().len());
    let mut first_lines: Vec<Option<u32>> = Vec::with_capacity(elements.nodes().len());
    let mut befores: Vec<Option<u32>> = Vec::with_capacity(elements.nodes().len());
    let mut afters: Vec<Option<u32>> = Vec::with_capacity(elements.nodes().len());
    let mut max_id = 0u32;
    // Most sheets name neither, and a pass that no rule can match is
    // a pass over every rule for every element.
    let named = |which: &PseudoElement| {
        sheets.iter().any(|sheet| {
            sheet.rules.iter().any(|rule| {
                rule.selectors
                    .slice()
                    .iter()
                    .any(|selector| selector.pseudo_element() == Some(which))
            })
        })
    };
    let (wants_before, wants_after) = (named(&PseudoElement::Before), named(&PseudoElement::After));

    for (index, node) in elements.nodes().iter().enumerate() {
        let parent = node
            .parent
            .map(|parent| styles[computed[parent] as usize].clone())
            .unwrap_or_else(ComputedStyle::initial);
        let mut style = parent.inherit();

        let matched = applicable(sheets, &elements, index, &mut caches, None);
        let root_size = styles.first().map(|style| style.font_size);
        let parent_size = parent.font_size;
        let hint = node.align.map(align_hint);
        apply_all(
            &mut style,
            sheets,
            &matched,
            hint.as_ref(),
            parent_size,
            root_size,
            &mut warnings,
        );
        let (font_id, warning) = resolve_face(&style, registry);
        style.font_id = font_id;
        report(&mut warnings, warning);
        report(&mut warnings, synthesized_small_caps(&style, registry));
        report_all(&mut warnings, missing_features(&style, registry));

        // A pseudo-element cascades over the style of the element it
        // belongs to, so each is a second matching pass rather than a
        // second element.
        let mut pseudo_style = |which, warnings: &mut Vec<Warning>| {
            let matched = applicable(sheets, &elements, index, &mut caches, Some(which));
            (!matched.is_empty()).then(|| {
                let mut pseudo = style.inherit();
                apply_all(
                    &mut pseudo,
                    sheets,
                    &matched,
                    None,
                    style.font_size,
                    root_size,
                    warnings,
                );
                let (font_id, warning) = resolve_face(&pseudo, registry);
                pseudo.font_id = font_id;
                report(warnings, warning);
                report(warnings, synthesized_small_caps(&pseudo, registry));
                report_all(warnings, missing_features(&pseudo, registry));
                pseudo
            })
        };
        let first_letter = pseudo_style(&PseudoElement::FirstLetter, &mut warnings);
        let first_line = pseudo_style(&PseudoElement::FirstLine, &mut warnings);
        let before = wants_before
            .then(|| pseudo_style(&PseudoElement::Before, &mut warnings))
            .flatten();
        let after = wants_after
            .then(|| pseudo_style(&PseudoElement::After, &mut warnings))
            .flatten();
        // `content: none`, the initial value, generates nothing.
        let [before, after] = [(before, "::before"), (after, "::after")].map(|(pseudo, name)| {
            let pseudo = pseudo.filter(|pseudo| pseudo.content != Content::None)?;
            if INLINE_ELEMENTS.contains(&node.name) || BLOCK_ELEMENTS.contains(&node.name) {
                return Some(pseudo);
            }
            let message = format!(
                "Unsupported pseudo-element `{name}` on `{}`. Nothing is generated.",
                node.name
            );
            if !warnings.iter().any(|seen| seen.message == message) {
                warnings.push(Warning {
                    message,
                    origin: None,
                });
            }
            None
        });

        let index_of_style = intern(&mut styles, style);
        let index_of_initial = first_letter.map(|initial| intern(&mut styles, initial));
        let index_of_line = first_line.map(|line| intern(&mut styles, line));
        let index_of_before = before.map(|before| intern(&mut styles, before));
        let index_of_after = after.map(|after| intern(&mut styles, after));
        computed.push(index_of_style);
        first_letters.push(index_of_initial);
        first_lines.push(index_of_line);
        befores.push(index_of_before);
        afters.push(index_of_after);
        nodes.push(NodeStyle {
            id: node.id.get(),
            element: node.name,
            style: index_of_style,
            first_letter: index_of_initial,
            first_line: index_of_line,
            before: index_of_before,
            after: index_of_after,
        });
        max_id = max_id.max(node.id.get());
    }

    // A paragraph with no element of its own takes the style of an
    // anonymous box inside its item: what the item passes on, and
    // nothing of its own.
    let mut anonymous = Vec::with_capacity(elements.anonymous().len());
    for (id, item) in elements.anonymous() {
        let inherited = styles[computed[*item] as usize].inherit();
        anonymous.push((id.get() as usize, intern(&mut styles, inherited)));
        max_id = max_id.max(id.get());
    }

    let root = computed.first().copied().unwrap_or(0);
    let mut by_node = vec![root; max_id as usize + 1];
    let mut initial_by_node = vec![None; max_id as usize + 1];
    let mut first_line_by_node = vec![None; max_id as usize + 1];
    let mut before_by_node = vec![None; max_id as usize + 1];
    let mut after_by_node = vec![None; max_id as usize + 1];
    for (index, node) in elements.nodes().iter().enumerate() {
        let id = node.id.get() as usize;
        by_node[id] = computed[index];
        initial_by_node[id] = first_letters[index];
        first_line_by_node[id] = first_lines[index];
        before_by_node[id] = befores[index];
        after_by_node[id] = afters[index];
    }
    for (id, style) in anonymous {
        by_node[id] = style;
    }
    by_node[0] = root;
    let generated = || {
        befores
            .iter()
            .chain(&afters)
            .flatten()
            .map(|index| &styles[*index as usize].content)
    };
    let counts_pages = generated().any(Content::counts_pages);
    let refers = generated().any(|content| matches!(content, Content::Pieces(_)));

    if styles.is_empty() {
        styles.push(ComputedStyle::initial());
    }
    let pages: Vec<(u8, PageRule)> = sheets
        .iter()
        .flat_map(|sheet| {
            let level = level(sheet.origin, Importance::Normal);
            sheet.pages.iter().cloned().map(move |rule| (level, rule))
        })
        .collect();
    let masters = resolve_masters(
        &pages,
        &styles,
        &styles[root as usize].clone(),
        registry,
        &mut warnings,
    );

    StyleTree {
        styles,
        nodes,
        masters,
        by_node,
        initial_by_node,
        first_line_by_node,
        before_by_node,
        after_by_node,
        counts_pages,
        refers,
        notes: elements.notes(),
        warnings,
    }
}

/// Reports every id a book gives to a second element.
///
/// An id names one element. Both still match.
fn repeated_ids(book: &Book) -> Vec<Warning> {
    let mut first: BTreeMap<&str, String> = BTreeMap::new();
    let mut warnings = Vec::new();
    for section in &book.sections {
        let source = section.source.as_deref();
        named_blocks(&section.blocks, source, &mut first, &mut warnings);
    }
    warnings
}

/// The ids of these blocks and everything inside them, in document
/// order, warning on each id already taken.
fn named_blocks<'a>(
    blocks: &'a [Block],
    source: Option<&str>,
    first: &mut BTreeMap<&'a str, String>,
    warnings: &mut Vec<Warning>,
) {
    for block in blocks {
        claim(
            block_attributes(block),
            origin(source, block_position(block)),
            first,
            warnings,
        );
        match block {
            Block::Heading { inlines, .. } | Block::Paragraph { inlines, .. } => {
                named_inlines(inlines, source, first, warnings)
            }
            Block::Blockquote { blocks, .. } => named_blocks(blocks, source, first, warnings),
            Block::List { items, .. } => {
                for item in items {
                    claim(
                        &item.attributes,
                        origin(source, item.position),
                        first,
                        warnings,
                    );
                    named_blocks(&item.blocks, source, first, warnings);
                }
            }
            Block::Table { head, body, .. } => {
                for row in rows(head, body) {
                    claim(
                        &row.attributes,
                        origin(source, row.position),
                        first,
                        warnings,
                    );
                    for cell in &row.cells {
                        claim(
                            &cell.attributes,
                            origin(source, cell.position),
                            first,
                            warnings,
                        );
                        named_blocks(&cell.blocks, source, first, warnings);
                    }
                }
            }
            Block::CodeBlock { .. }
            | Block::ThematicBreak { .. }
            | Block::PageBreak { .. }
            | Block::ColumnBreak { .. }
            | Block::Image { .. } => {}
        }
    }
}

/// The same, over the inlines of one block.
fn named_inlines<'a>(
    inlines: &'a [Inline],
    source: Option<&str>,
    first: &mut BTreeMap<&'a str, String>,
    warnings: &mut Vec<Warning>,
) {
    for inline in inlines {
        claim(
            inline_attributes(inline),
            origin(source, inline_position(inline)),
            first,
            warnings,
        );
        match inline {
            Inline::Text { .. } | Inline::Code { .. } | Inline::Break { .. } => {}
            Inline::Note { blocks, .. } => named_blocks(blocks, source, first, warnings),
            Inline::Emphasis { children, .. }
            | Inline::Strong { children, .. }
            | Inline::Link { children, .. }
            | Inline::Strikethrough { children, .. }
            | Inline::Span { children, .. } => named_inlines(children, source, first, warnings),
        }
    }
}

/// Takes one node's id, or reports the element that has it already.
fn claim<'a>(
    attributes: &'a Attributes,
    at: String,
    first: &mut BTreeMap<&'a str, String>,
    warnings: &mut Vec<Warning>,
) {
    let Some(id) = attributes.id.as_deref() else {
        return;
    };
    match first.get(id) {
        Some(taken) => warnings.push(Warning {
            message: format!("Id `{id}` is duplicated. Applied at {taken}."),
            origin: Some(at),
        }),
        None => {
            first.insert(id, at);
        }
    }
}

/// Where one applicable declaration lives, sorted into cascade order:
/// origin and importance, then specificity, then source order.
type Applicable = (u8, u32, usize, usize, usize);

/// Every declaration that matches one element, in cascade order.
/// `pseudo` selects the pass: `None` matches the element itself,
/// `Some(_)` matches only rules ending in that pseudo-element.
fn applicable(
    sheets: &[Sheet],
    elements: &ElementTree,
    index: usize,
    caches: &mut SelectorCaches,
    pseudo: Option<&PseudoElement>,
) -> Vec<Applicable> {
    let mode = match pseudo {
        Some(_) => MatchingMode::ForStatelessPseudoElement,
        None => MatchingMode::Normal,
    };
    let mut applicable = Vec::new();
    for (sheet_index, sheet) in sheets.iter().enumerate() {
        for (rule_index, rule) in sheet.rules.iter().enumerate() {
            let specificity = rule
                .selectors
                .slice()
                .iter()
                .filter(|selector| selector.pseudo_element() == pseudo)
                .filter(|selector| {
                    let mut context = MatchingContext::new(
                        mode,
                        None,
                        caches,
                        QuirksMode::NoQuirks,
                        NeedsSelectorFlags::No,
                        MatchingForInvalidation::No,
                    );
                    matches_selector(selector, 0, None, &elements.at(index), &mut context)
                })
                .map(|selector| selector.specificity())
                .max();
            let Some(specificity) = specificity else {
                continue;
            };
            for (order, (_, importance)) in rule.declarations.iter().enumerate() {
                applicable.push((
                    level(sheet.origin, *importance),
                    specificity,
                    sheet_index,
                    rule_index,
                    order,
                ));
            }
        }
    }
    applicable.sort_unstable();
    applicable
}

/// Applies matched declarations in cascade order.
///
/// `hint` is what the source wrote on the element itself, as HTML's
/// `align` is written on a cell. It goes in after the built-in sheet
/// and before every rule of the author's, whatever its specificity.
fn apply_all(
    style: &mut ComputedStyle,
    sheets: &[Sheet],
    applicable: &[Applicable],
    hint: Option<&properties::Declaration>,
    parent_size: f32,
    root_size: Option<f32>,
    warnings: &mut Vec<Warning>,
) {
    let root_size = root_size.unwrap_or(parent_size);
    let declaration = |(_, _, sheet, rule, order): &Applicable| {
        &sheets[*sheet].rules[*rule].declarations[*order].0
    };
    // Custom properties resolve first, because a declaration anywhere
    // in the cascade can read one declared after it.
    let declared: Vec<&Custom> = applicable
        .iter()
        .filter_map(|at| match declaration(at) {
            Declaration::Custom(custom) => Some(custom),
            _ => None,
        })
        .collect();
    if !declared.is_empty() {
        style.custom = substitution::resolve(&style.custom, &declared, warnings);
    }
    let base = applicable
        .iter()
        .any(|at| matches!(declaration(at), Declaration::Pending(_)))
        .then(|| style.clone());
    let mut hint = hint;
    for at in applicable {
        if at.0 > 0
            && let Some(declaration) = hint.take()
        {
            style.apply(declaration, parent_size, root_size);
        }
        match (declaration(at), &base) {
            (Declaration::Pending(pending), Some(base)) => {
                substitution::apply(style, pending, base, parent_size, root_size, warnings)
            }
            (declaration, _) => style.apply(declaration, parent_size, root_size),
        }
    }
    if let Some(declaration) = hint {
        style.apply(declaration, parent_size, root_size);
    }
}

/// The `text-align` a table's delimiter row wrote on a cell's column.
fn align_hint(align: Alignment) -> properties::Declaration {
    properties::Declaration::TextAlign(match align {
        Alignment::Left => TextAlign::Left,
        Alignment::Center => TextAlign::Center,
        Alignment::Right => TextAlign::Right,
    })
}

/// Where one declaration sits in the cascade, before specificity is
/// consulted: author CSS beats the built-in sheet, and `!important`
/// turns that round for the origin that used it.
fn level(origin: Origin, importance: Importance) -> u8 {
    match (origin, importance) {
        (Origin::UserAgent, Importance::Normal) => 0,
        (Origin::Author, Importance::Normal) => 1,
        (Origin::Author, Importance::Important) => 2,
        (Origin::UserAgent, Importance::Important) => 3,
    }
}

/// The index of a style in the table, adding it if it is new. Books
/// have thousands of nodes and a handful of styles.
fn intern(styles: &mut Vec<ComputedStyle>, style: ComputedStyle) -> u32 {
    match styles.iter().position(|known| *known == style) {
        Some(index) => index as u32,
        None => {
            styles.push(style);
            (styles.len() - 1) as u32
        }
    }
}

/// Records a face diagnostic once. Thousands of nodes share a
/// handful of styles, and a font stack that cannot be honoured is a
/// fact about the stack, not about each node that used it.
fn report(warnings: &mut Vec<Warning>, warning: Option<Warning>) {
    let Some(warning) = warning else {
        return;
    };
    if !warnings.iter().any(|seen| seen.message == warning.message) {
        warnings.push(warning);
    }
}

/// Records each of a list of diagnostics once.
fn report_all(warnings: &mut Vec<Warning>, found: Vec<Warning>) {
    for warning in found {
        report(warnings, Some(warning));
    }
}

/// The face a computed style shapes with: the first family in the
/// registry, at the nearest slope and weight it has.
///
/// A family the registry does not have is skipped — that is what a
/// font stack is for — but a stack that resolves nothing, or a
/// family with no cut at the slope asked for, falls back to a face
/// that is visibly not the one requested. Both say so.
fn resolve_face(style: &ComputedStyle, registry: &FontRegistry) -> (u16, Option<Warning>) {
    let want = FaceAttributes {
        italic: style.font_style == FontStyle::Italic,
        weight: style.font_weight,
    };
    for family in &style.font_family {
        let name = match family {
            Family::Named(name) => Some(name.clone()),
            Family::Generic(generic) => registry
                .generic(*generic)
                .and_then(|id| registry.font_ref(id).map(|entry| entry.family.clone())),
        };
        let Some(found) = name.as_deref().and_then(|name| registry.select(name, want)) else {
            continue;
        };
        let warning = (found.attributes.italic != want.italic).then(|| Warning {
            message: format!(
                "{} has no {} face. {} text falls back to {}.",
                name.unwrap_or_default(),
                slope(want.italic),
                sentence(slope(want.italic)),
                slope(found.attributes.italic),
            ),
            origin: None,
        });
        return (found.id, warning);
    }
    (
        0,
        Some(Warning {
            message: format!(
                "No registered font matches {}. The first registered font is used instead.",
                stack(&style.font_family),
            ),
            origin: None,
        }),
    )
}

/// The diagnostic for a face with no small capitals of its own, one
/// per style that asks for them: an author who picked the face can
/// pick another one.
fn synthesized_small_caps(style: &ComputedStyle, registry: &FontRegistry) -> Option<Warning> {
    let asked = style.font_variant_caps == FontVariantCaps::SmallCaps;
    (asked && !registry.has_small_caps(style.font_id)).then(|| Warning {
        message: format!(
            "{} has no small capitals. Falling back to reduced capitals.",
            registry
                .font_ref(style.font_id)
                .map(|entry| entry.family.clone())
                .unwrap_or_else(|| stack(&style.font_family)),
        ),
        origin: None,
    })
}

/// The diagnostic for a face that carries none of a feature the
/// sheet asked for, one per style that asks for it. The run is set
/// without the feature; nothing is synthesized.
///
/// A setting of zero asks for a feature to be left off, which a face
/// that has nothing for it already does.
fn missing_features(style: &ComputedStyle, registry: &FontRegistry) -> Vec<Warning> {
    let family = || {
        registry
            .font_ref(style.font_id)
            .map(|entry| entry.family.clone())
            .unwrap_or_else(|| stack(&style.font_family))
    };
    style
        .features()
        .iter()
        .filter(|setting| setting.value != 0)
        .filter(|setting| !registry.has_feature(style.font_id, setting.tag))
        .map(|setting| Warning {
            message: format!(
                "{} has no `{}` feature. The text is set without it.",
                family(),
                String::from_utf8_lossy(&setting.tag),
            ),
            origin: None,
        })
        .collect()
}

/// A slope as a stylesheet names it.
/// A slope at the head of a sentence.
fn sentence(slope: &str) -> String {
    let mut opens = slope.chars();
    match opens.next() {
        Some(first) => first.to_uppercase().collect::<String>() + opens.as_str(),
        None => String::new(),
    }
}

fn slope(italic: bool) -> &'static str {
    if italic { "italic" } else { "upright" }
}

/// A font stack as the sheet wrote it, for a diagnostic to quote.
fn stack(families: &[Family]) -> String {
    families
        .iter()
        .map(|family| match family {
            Family::Named(name) => name.clone(),
            Family::Generic(generic) => generic.keyword().to_string(),
        })
        .collect::<Vec<_>>()
        .join(", ")
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::content::{Attributes, Block, HeadingLevel, Inline, Metadata, Section, SourcePos};
    use crate::fonts::{
        BUNDLED_FONT, FaceAttributes, FeatureSetting, GenericFamily, bundled_registry,
    };
    use crate::lines::{HangEnd, HangingPunctuation};

    fn registry() -> &'static FontRegistry {
        static REGISTRY: std::sync::OnceLock<FontRegistry> = std::sync::OnceLock::new();
        REGISTRY.get_or_init(|| bundled_registry().expect("bundled font parses"))
    }

    /// A sheet reads back as it was written: selectors as CSS, the
    /// declarations the parser kept with their positions, and the
    /// at-rules. What the parser refused is a warning and not here.
    #[test]
    fn a_sheet_reads_back_as_it_was_written() {
        let css = "@page :left { margin: 1in }\n\
                   h1 + p, NOTE::first-letter {\n  color: red;\n  float: left;\n  --x: 1pt;\n}\n\
                   @font-face { font-family: Author; src: url(a.otf), local(\"B\") }";
        let sheets = Stylesheets::parse(&[Source::author("a.css", css)]);
        let written = sheets.written();
        assert_eq!(written.len(), 2);
        assert_eq!(written[0].origin, Origin::UserAgent);

        let author = &written[1];
        assert_eq!(author.origin, Origin::Author);
        assert_eq!(author.pages[0].selector, "@page :left");
        assert_eq!(author.pages[0].position.to_string(), "a.css:1:1");
        let rule = &author.rules[0];
        assert_eq!(rule.selectors, ["h1 + p", "NOTE::first-letter"]);
        assert_eq!(rule.position.to_string(), "a.css:2:1");
        let kept: Vec<(&str, &str, String)> = rule
            .declarations
            .iter()
            .map(|d| (&*d.property, &*d.value, d.position.to_string()))
            .collect();
        assert_eq!(
            kept,
            [
                ("color", "red", "a.css:3:3".to_string()),
                ("--x", "1pt", "a.css:5:3".to_string()),
            ]
        );
        assert!(
            sheets
                .warnings()
                .iter()
                .any(|w| w.origin.as_deref() == Some("a.css:4:3")),
            "{:?}",
            sheets.warnings()
        );
        assert_eq!(author.faces[0].family, "Author");
        assert_eq!(
            author.faces[0].src,
            [Src::Url("a.otf".into()), Src::Local("B".into())]
        );
    }

    fn text(value: &str) -> Inline {
        Inline::Text {
            id: NodeId::UNASSIGNED,
            value: value.into(),
            attributes: Attributes::default(),
            position: None,
            span: None,
        }
    }

    /// A chapter: a heading, a paragraph opening with emphasis, a
    /// paragraph of plain prose, and a blockquote.
    fn sample() -> Book {
        let mut book = Book {
            metadata: Metadata::default(),
            sections: vec![Section {
                attributes: Default::default(),
                id: NodeId::UNASSIGNED,
                source: Some("chapter-01.md".into()),
                title: None,
                blocks: vec![
                    Block::Heading {
                        id: NodeId::UNASSIGNED,
                        level: HeadingLevel::H1,
                        inlines: vec![text("Chapter One")],
                        attributes: Attributes::default(),
                        position: None,
                        span: None,
                    },
                    Block::Paragraph {
                        id: NodeId::UNASSIGNED,
                        inlines: vec![
                            Inline::Emphasis {
                                id: NodeId::UNASSIGNED,
                                children: vec![text("In which")],
                                attributes: Attributes::default(),
                                position: None,
                                span: None,
                            },
                            text(" a drawer is opened."),
                        ],
                        attributes: Attributes::default(),
                        position: None,
                        span: None,
                    },
                    Block::Paragraph {
                        id: NodeId::UNASSIGNED,
                        inlines: vec![text("It was the kind of morning.")],
                        attributes: Attributes::default(),
                        position: None,
                        span: None,
                    },
                    Block::Blockquote {
                        id: NodeId::UNASSIGNED,
                        blocks: vec![Block::Paragraph {
                            id: NodeId::UNASSIGNED,
                            inlines: vec![text("\"Nobody's early here.\"")],
                            attributes: Attributes::default(),
                            position: None,
                            span: None,
                        }],
                        attributes: Attributes::default(),
                        position: None,
                        span: None,
                    },
                ],
                position: None,
                span: None,
            }],
        };
        book.assign_node_ids();
        book
    }

    /// The tree, with `css` cascading over the built-in sheet.
    fn compile(book: &Book, css: &str) -> StyleTree {
        Stylesheets::parse(&[Source::author("author.css", css)]).compile(book, registry())
    }

    /// The computed style of the nth element with a given name.
    fn nth(tree: &StyleTree, element: &str, index: usize) -> ComputedStyle {
        let node = tree
            .nodes()
            .iter()
            .filter(|node| node.element == element)
            .nth(index)
            .unwrap_or_else(|| panic!("no {element} #{index}"));
        tree.styles()[node.style as usize].clone()
    }

    fn first(tree: &StyleTree, element: &str) -> ComputedStyle {
        nth(tree, element, 0)
    }

    /// Two chapters of the sample, the first named `front` and
    /// `preface`, the second `body`.
    fn named_sections() -> Book {
        let mut book = sample();
        let mut body = book.sections[0].clone();
        body.source = Some("chapter-02.md".into());
        body.attributes.classes = vec!["body".into()];
        book.sections[0].attributes = Attributes {
            id: Some("preface".into()),
            classes: vec!["front".into()],
        };
        book.sections.push(body);
        book.assign_node_ids();
        book
    }

    /// Acceptance: the page-name and page-counter examples on the
    /// subset page reach the sections they name, and no other.
    #[test]
    fn the_subset_page_section_examples_match() {
        let tree = compile(
            &named_sections(),
            "section.front { page: front }
             section.body { counter-reset: page 1 }",
        );
        let (front, body) = (nth(&tree, "section", 0), nth(&tree, "section", 1));
        assert_eq!(front.page.as_deref(), Some("front"));
        assert_ne!(body.page.as_deref(), Some("front"));
        assert_eq!(body.counter_reset, Some(1));
        assert_eq!(front.counter_reset, None);
    }

    /// Acceptance: a section's class and id match in the cascade, and
    /// `:is()` and a descendant selector see them.
    #[test]
    fn a_section_class_and_id_match_in_every_selector_form() {
        let tree = compile(
            &named_sections(),
            "section#preface { page: by-id }
             :is(section.body) { page: by-is }
             section.front p { page: below-front }
             :is(section.body) > h1 { page: below-body }",
        );
        assert_eq!(nth(&tree, "section", 0).page.as_deref(), Some("by-id"));
        assert_eq!(nth(&tree, "section", 1).page.as_deref(), Some("by-is"));
        // Each chapter of the sample holds three paragraphs.
        assert_eq!(nth(&tree, "p", 2).page.as_deref(), Some("below-front"));
        assert_ne!(nth(&tree, "p", 3).page.as_deref(), Some("below-front"));
        assert_ne!(nth(&tree, "h1", 0).page.as_deref(), Some("below-body"));
        assert_eq!(nth(&tree, "h1", 1).page.as_deref(), Some("below-body"));
    }

    /// A book of two images, the first of them named.
    fn images() -> Book {
        let image = |named: Attributes| Block::Image {
            id: NodeId::UNASSIGNED,
            url: "plate.jpg".into(),
            alt: "a map".into(),
            attributes: named,
            position: None,
            span: None,
        };
        let mut book = Book {
            metadata: Metadata::default(),
            sections: vec![Section {
                attributes: Default::default(),
                id: NodeId::UNASSIGNED,
                source: Some("chapter-01.md".into()),
                title: None,
                blocks: vec![
                    image(Attributes {
                        id: Some("frontispiece".into()),
                        classes: vec!["map".into()],
                    }),
                    image(Attributes::default()),
                ],
                position: None,
                span: None,
            }],
        };
        book.assign_node_ids();
        book
    }

    /// A table of a header row and three body rows, its second column
    /// written centered.
    fn table() -> Book {
        use crate::content::{Alignment, Cell, Row};
        let cell = |value: &str, align: Option<Alignment>| Cell {
            blocks: vec![Block::Paragraph {
                id: NodeId::UNASSIGNED,
                inlines: vec![text(value)],
                attributes: Attributes::default(),
                position: None,
                span: None,
            }],
            align,
            ..Cell::default()
        };
        let row = |left: &str, right: &str| Row {
            cells: vec![cell(left, None), cell(right, Some(Alignment::Center))],
            ..Row::default()
        };
        let mut book = Book {
            metadata: Metadata::default(),
            sections: vec![Section {
                attributes: Default::default(),
                id: NodeId::UNASSIGNED,
                source: Some("chapter-01.md".into()),
                title: None,
                blocks: vec![Block::Table {
                    id: NodeId::UNASSIGNED,
                    head: vec![row("Pocket", "Found")],
                    body: vec![
                        row("Right", "A handkerchief"),
                        row("Left", "A snuff-box"),
                        row("Fob", "A watch"),
                    ],
                    attributes: Attributes::default(),
                    position: None,
                    span: None,
                }],
                position: None,
                span: None,
            }],
        };
        book.assign_node_ids();
        book
    }

    /// Acceptance: `z-index` is the layer a block paints in. It is a
    /// block's own: a child of a raised block is not raised with it,
    /// and `auto` is layer 0.
    #[test]
    fn a_block_takes_the_layer_it_names_and_a_child_takes_none_of_it() {
        let tree = compile(
            &sample(),
            "blockquote { z-index: 10 }
             h1 { z-index: -1 }
             p { z-index: auto }",
        );
        assert_eq!(first(&tree, "blockquote").z_index, 10);
        assert_eq!(first(&tree, "h1").z_index, -1);
        // The paragraph inside the blockquote is the last of them.
        assert_eq!(nth(&tree, "p", 2).z_index, 0);
        assert_eq!(first(&tree, "section").z_index, 0);
    }

    /// Acceptance: `tbody tr:nth-child(odd)` counts the rows of the
    /// body, so it reaches the first and the third of them and not
    /// the header row.
    #[test]
    fn a_body_row_counts_among_the_rows_of_the_body() {
        let tint = Some(Color::rgb(0xe3, 0xe3, 0xe3));
        let tree = compile(
            &table(),
            "tbody tr:nth-child(odd) { background-color: #e3e3e3 }",
        );
        let rows: Vec<Option<Color>> = (0..4)
            .map(|index| nth(&tree, "tr", index).background.color)
            .collect();
        assert_eq!(rows, [None, tint, None, tint]);
        assert_eq!(first(&tree, "thead").background.color, None);
    }

    /// Acceptance: the alignment the delimiter row wrote beats the
    /// built-in sheet and reaches the prose in the cell. Any rule of
    /// the author's beats it, even one with no specificity.
    #[test]
    fn the_alignment_a_table_wrote_sits_under_every_author_rule() {
        let book = table();
        let tree = defaults(&book, registry());
        assert_eq!(nth(&tree, "td", 0).text_align, TextAlign::Left);
        assert_eq!(nth(&tree, "td", 1).text_align, TextAlign::Center);
        assert_eq!(nth(&tree, "th", 1).text_align, TextAlign::Center);
        // The header row holds the first two paragraphs, so the first
        // body row's second cell holds the fourth.
        assert_eq!(nth(&tree, "p", 3).text_align, TextAlign::Center);

        let tree = compile(&book, "td { text-align: right }");
        assert_eq!(nth(&tree, "td", 1).text_align, TextAlign::Right);
        assert_eq!(nth(&tree, "th", 1).text_align, TextAlign::Center);

        let tree = compile(&book, "* { text-align: justify }");
        assert_eq!(nth(&tree, "td", 1).text_align, TextAlign::Justify);
    }

    /// `width` computes to points, or stays a percentage of a table
    /// the cascade has not sized. `border-collapse` inherits, so the
    /// cells of a collapsed table are collapsed too.
    #[test]
    fn width_and_border_collapse_compute() {
        let book = table();
        let tree = compile(&book, "th:first-of-type { width: 8em }");
        let header = first(&tree, "th");
        assert_eq!(header.width, Width::Points(8.0 * header.font_size));
        assert_eq!(nth(&tree, "th", 1).width, Width::Auto);
        assert_eq!(
            first(&tree, "td").width,
            Width::Auto,
            "width does not inherit"
        );

        let tree = compile(&book, "th { width: 25% }");
        assert_eq!(first(&tree, "th").width, Width::Percent(25.0));

        let tree = defaults(&book, registry());
        assert_eq!(
            first(&tree, "table").border_collapse,
            BorderCollapse::Collapse
        );
        assert_eq!(first(&tree, "td").border_collapse, BorderCollapse::Collapse);
        let tree = compile(&book, "table { border-collapse: separate }");
        assert_eq!(first(&tree, "td").border_collapse, BorderCollapse::Separate);
    }

    /// `column-span` is `none` until a sheet says otherwise, and it
    /// does not inherit: the cells of a spanning table are set in
    /// the table, not across the page a second time.
    #[test]
    fn column_span_computes_and_does_not_inherit() {
        let book = table();
        let tree = defaults(&book, registry());
        assert_eq!(first(&tree, "table").column_span, ColumnSpan::None);

        let tree = compile(&book, "table { column-span: all }");
        assert_eq!(first(&tree, "table").column_span, ColumnSpan::All);
        assert_eq!(first(&tree, "td").column_span, ColumnSpan::None);
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());

        let tree = compile(
            &book,
            "table { column-span: all } table { column-span: none }",
        );
        assert_eq!(first(&tree, "table").column_span, ColumnSpan::None);
    }

    /// A class names one element out of a kind of them: the image
    /// that carries it is set, and the image beside it is not.
    #[test]
    fn a_class_reaches_the_element_that_carries_it_and_no_other() {
        let book = images();
        let tree = compile(&book, ".map { text-align: right }");
        assert_eq!(nth(&tree, "img", 0).text_align, TextAlign::Right);
        assert_eq!(nth(&tree, "img", 1).text_align, TextAlign::Left);
    }

    /// An id names one element and nothing else, and outranks the
    /// class on the same element.
    #[test]
    fn an_id_reaches_the_element_that_carries_it_and_outranks_a_class() {
        let book = images();
        let tree = compile(
            &book,
            ".map { break-before: page } #frontispiece { break-before: recto }",
        );
        assert_eq!(nth(&tree, "img", 0).break_before, Break::Side(Side::Recto));
        assert_eq!(nth(&tree, "img", 1).break_before, Break::Auto);
    }

    /// An id names one element, so a second element under it is a
    /// mistake. Both still match: the sheet reaches two, the origin
    /// is the second, and the message names the first.
    #[test]
    fn an_id_written_twice_warns_naming_both_places() {
        let mut book = images();
        let Block::Image {
            attributes,
            position,
            ..
        } = &mut book.sections[0].blocks[1]
        else {
            panic!("expected an image");
        };
        attributes.id = Some("frontispiece".into());
        *position = Some(SourcePos {
            line: 12,
            column: 1,
        });
        let Block::Image { position, .. } = &mut book.sections[0].blocks[0] else {
            panic!("expected an image");
        };
        *position = Some(SourcePos { line: 3, column: 1 });

        let tree = compile(&book, "#frontispiece { break-before: recto }");
        assert_eq!(nth(&tree, "img", 0).break_before, Break::Side(Side::Recto));
        assert_eq!(nth(&tree, "img", 1).break_before, Break::Side(Side::Recto));
        let repeated: Vec<&Warning> = tree
            .warnings()
            .iter()
            .filter(|warning| warning.message.contains("frontispiece"))
            .collect();
        assert_eq!(repeated.len(), 1, "{:?}", tree.warnings());
        assert_eq!(
            repeated[0].message,
            "Id `frontispiece` is duplicated. Applied at chapter-01.md:3:1.",
        );
        assert_eq!(repeated[0].origin.as_deref(), Some("chapter-01.md:12:1"));
    }

    /// The built-in sheet sets the body, chapter and folio styles, and
    /// the trade-paperback page.
    #[test]
    fn the_built_in_sheet_sets_the_defaults() {
        let book = sample();
        let tree = defaults(&book, registry());

        let body = first(&tree, "p");
        assert_eq!(body.font_size, 11.0);
        assert_eq!(body.line_height, 1.4);
        assert_eq!(body.font_id, 0);
        assert_eq!(body.hyphens, Hyphens::None);
        assert_eq!(first(&tree, "h1").font_size, 18.0);

        let recto = tree.page(PageQuery {
            name: Some("chapter"),
            situation: Situation::Body(Side::Recto),
        });
        assert_eq!(recto.geometry.width, 432.0);
        assert_eq!(recto.geometry.height, 648.0);
        assert_eq!(recto.geometry.content_size(), (336.0, 540.0));
        let folio = recto
            .margin_box(MarginBox::BottomCenter)
            .expect("the folio is a margin box");
        assert_eq!(folio.content, Content::Counter(CounterStyle::Decimal));
        assert_eq!(folio.style.font_size, 9.0);
        assert_eq!(folio.style.line_height, 1.4);
    }

    /// The four background properties compute on a block: a url the
    /// sheet wrote, and how it is drawn.
    #[test]
    fn the_background_properties_compute_on_a_block() {
        let tree = compile(
            &sample(),
            "p {\n  background-color: #f4f1ea;\n  background-image: url(\"scan.webp\");\n  \
             background-repeat: no-repeat;\n  background-size: cover;\n  \
             background-position: right bottom;\n}",
        );
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());
        let background = first(&tree, "p").background;
        assert_eq!(background.color, Some(Color::rgb(0xf4, 0xf1, 0xea)));
        assert_eq!(
            background.image.as_ref().map(|url| url.value.as_str()),
            Some("scan.webp"),
        );
        assert_eq!(background.repeat, BackgroundRepeat::NoRepeat);
        assert_eq!(background.size, BackgroundSize::Cover);
        assert_eq!(background.position.x, Coord::Percent(100.0));
        assert_eq!(background.position.y, Coord::Percent(100.0));
        assert!(!first(&tree, "blockquote").background.paints());
    }

    /// A url carries where it was written, so a warning about it can
    /// name the line and column long after the sheet was parsed.
    #[test]
    fn a_background_url_carries_where_the_sheet_wrote_it() {
        let tree = compile(&sample(), "p {\n  background-image: url(scan.webp);\n}");
        let url = first(&tree, "p")
            .background
            .image
            .expect("the url reached the style");
        assert_eq!(url.origin.as_deref(), Some("author.css:2:3"));
    }

    /// `background-size` and `background-position` take their length
    /// forms, and the cascade resolves `em` against the font size in
    /// force while a percentage stays one.
    #[test]
    fn background_lengths_compute_and_percentages_stay() {
        let tree = compile(
            &sample(),
            "p {\n  font-size: 10pt;\n  background-size: 2em 50%;\n  \
             background-position: 1em 25%;\n}",
        );
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());
        let background = first(&tree, "p").background;
        assert_eq!(
            background.size,
            BackgroundSize::Fixed {
                width: Some(Coord::Points(20.0)),
                height: Some(Coord::Percent(50.0)),
            },
        );
        assert_eq!(background.position.x, Coord::Points(10.0));
        assert_eq!(background.position.y, Coord::Percent(25.0));
    }

    /// A background does not inherit: a rule on the quotation leaves
    /// the paragraph inside it painting nothing.
    #[test]
    fn a_background_does_not_reach_the_children_of_the_box() {
        let tree = compile(&sample(), "blockquote { background-image: url(scan.webp) }");
        assert!(first(&tree, "blockquote").background.paints());
        assert!(!first(&tree, "p").background.paints());
    }

    /// Each side of the spread takes its own scan, and `@page` reads
    /// the same four properties a block does.
    #[test]
    fn each_side_of_the_spread_takes_its_own_background() {
        let tree = compile(
            &sample(),
            "@page :left { background-image: url(verso.webp); background-size: cover }\n\
             @page :right { background-image: url(recto.webp); background-size: contain }",
        );
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());
        let named = |side| {
            tree.page(PageQuery {
                name: Some("chapter"),
                situation: Situation::Body(side),
            })
            .background
            .clone()
        };
        let verso = named(Side::Verso);
        assert_eq!(
            verso.image.as_ref().map(|url| url.value.as_str()),
            Some("verso.webp"),
        );
        assert_eq!(verso.size, BackgroundSize::Cover);
        let recto = named(Side::Recto);
        assert_eq!(
            recto.image.as_ref().map(|url| url.value.as_str()),
            Some("recto.webp"),
        );
        assert_eq!(recto.size, BackgroundSize::Contain);
    }

    /// Part: `align-content` on `@page` reaches the page box of the
    /// pages the rule selects, and a page that names nothing keeps its
    /// content at the top.
    #[test]
    fn align_content_reaches_the_page_box() {
        use crate::style::AlignContent;
        let book = sample();
        let css = "@page chapter:first { align-content: center } \
                   @page :left { align-content: end }";
        let align = |css: &str, situation: Situation| {
            compile(&book, css)
                .page(PageQuery {
                    name: Some("chapter"),
                    situation,
                })
                .geometry
                .align_content
        };
        assert_eq!(align("", Situation::Body(Side::Recto)), AlignContent::Start);
        assert_eq!(
            align(css, Situation::First(Side::Recto)),
            AlignContent::Center
        );
        assert_eq!(align(css, Situation::Body(Side::Verso)), AlignContent::End);
        assert_eq!(
            align(css, Situation::Body(Side::Recto)),
            AlignContent::Start
        );
    }

    /// The column properties resolve to points against the page's
    /// content box: a count divides it, a width takes as many columns
    /// of that width as fit, the two together take the smaller
    /// answer, and `normal` is one em of the book's own size.
    #[test]
    fn columns_divide_the_content_box() {
        let book = sample();
        let page = |css: &str| {
            compile(&book, css)
                .page(PageQuery {
                    name: Some("chapter"),
                    situation: Situation::Body(Side::Recto),
                })
                .geometry
        };

        let plain = page("");
        assert_eq!(plain.column_count(), 1);
        assert_eq!(plain.measure(), 336.0);
        assert_eq!(plain.columns.gap, compile(&book, "").root().font_size);

        let two = page("@page { column-count: 2; column-gap: 16pt }");
        assert_eq!(two.column_count(), 2);
        assert_eq!(two.measure(), 160.0);
        assert_eq!(two.column_origin(0), (54.0, 54.0));
        assert_eq!(two.column_origin(1), (230.0, 54.0));

        // 336 points of content box takes three 100pt columns with
        // 16pt gutters between them, and the columns widen to fill
        // what is left over.
        let by_width = page("@page { column-width: 100pt; column-gap: 16pt }");
        assert_eq!(by_width.column_count(), 3);
        assert_eq!(by_width.measure(), (336.0 - 32.0) / 3.0);

        // A count declared beside a width is the ceiling on it.
        let both = page("@page { column-count: 2; column-width: 100pt; column-gap: 16pt }");
        assert_eq!(both.column_count(), 2);

        // A width nothing fits still leaves one column.
        assert_eq!(page("@page { column-width: 900pt }").column_count(), 1);

        let ruled = page("@page { column-count: 2; column-rule-style: solid }");
        assert_eq!(ruled.columns.rule.used(), crate::style::Border::NONE.width);
        assert_eq!(
            page("@page { column-rule-width: thin }")
                .columns
                .rule
                .used(),
            0.0,
            "a rule with no style is not drawn",
        );
    }

    /// Selectors run against the content tree: type, descendant,
    /// child, `:first-child` and `:is()` all pick out the elements a
    /// reader of the markdown would expect.
    #[test]
    fn selectors_match_the_content_tree() {
        let book = sample();
        let tree = compile(
            &book,
            "section > p { text-indent: 12pt }
             blockquote p { text-indent: 3pt }
             :is(h1, h2):first-child { text-indent: 6pt }
             :is(em, strong) { font-weight: 700 }",
        );
        // The section's own paragraphs are indented; the one inside
        // the blockquote is not a child of the section, so only the
        // descendant rule reaches it.
        assert_eq!(nth(&tree, "p", 0).text_indent, 12.0);
        assert_eq!(nth(&tree, "p", 1).text_indent, 12.0);
        assert_eq!(nth(&tree, "p", 2).text_indent, 3.0);
        // The heading opens the section, so it is a first child.
        assert_eq!(first(&tree, "h1").text_indent, 6.0);
        assert_eq!(first(&tree, "em").font_weight, 700);

        // Siblings, negation, counting and `:has()` all reach the
        // same tree.
        let tree = compile(
            &book,
            "h1 + p { text-indent: 1pt }
             h1 ~ p { widows: 3 }
             p:not(:first-child) { orphans: 4 }
             section:has(blockquote) > p:nth-child(3) { text-indent: 2pt }",
        );
        assert_eq!(nth(&tree, "p", 0).text_indent, 1.0);
        assert_eq!(nth(&tree, "p", 1).text_indent, 2.0);
        assert_eq!(nth(&tree, "p", 0).widows, 3);
        assert_eq!(nth(&tree, "p", 0).orphans, 4);
        assert_eq!(first(&tree, "h1").orphans, 2);
    }

    /// Author CSS overrides the built-in sheet, and specificity and
    /// source order decide between author rules.
    #[test]
    fn author_css_overrides_the_built_in_sheet() {
        let book = sample();
        // The built-in sheet's `book { font-size: 11pt }` is more
        // specific than nothing, and still loses to the author.
        let tree = compile(&book, "* { font-size: 13pt } p { font-size: 12pt }");
        assert_eq!(first(&tree, "p").font_size, 12.0);
        // Equal specificity: the later rule wins.
        let tree = compile(&book, "p { font-size: 12pt } p { font-size: 14pt }");
        assert_eq!(first(&tree, "p").font_size, 14.0);
        // `!important` in the built-in sheet would outrank the
        // author, and nothing in it uses one.
        let tree = compile(
            &book,
            "p { font-size: 12pt !important } p { font-size: 14pt }",
        );
        assert_eq!(first(&tree, "p").font_size, 12.0);
    }

    /// An unsupported property is a diagnostic naming its source
    /// position, and the rest of the rule still applies.
    #[test]
    fn unsupported_properties_warn_and_the_run_continues() {
        let book = sample();
        let tree = compile(
            &book,
            "p {\n  text-shadow: 0 0 2px black;\n  font-size: 13pt;\n}\n",
        );
        let warning = tree
            .warnings()
            .iter()
            .find(|warning| warning.message.contains("text-shadow"))
            .expect("text-shadow is outside the subset");
        assert_eq!(
            warning.message,
            "Unsupported property `text-shadow`. The declaration is ignored."
        );
        assert_eq!(warning.origin.as_deref(), Some("author.css:2:3"));
        assert_eq!(
            first(&tree, "p").font_size,
            13.0,
            "the declaration after the bad one was dropped"
        );
    }

    /// A sheet that breaks the subset every way it can. Each warning
    /// is a sentence, and says what happened to the declaration or to
    /// the rule.
    #[test]
    fn every_css_warning_names_what_was_ignored() {
        let css = "p { text-shadow: 0 0 2px black }\n\
                   p { text-align: bananas }\n\
                   p::first-line { font-family: serif }\n\
                   @media print { p { color: red } }\n\
                   @page :nth(2) { size: a4 }\n\
                   p:hover { color: red }\n\
                   p { color: }\n";
        let sheets = Stylesheets::parse(&[Source::author("author.css", css)]);
        let warnings = sheets.warnings();
        assert!(warnings.len() >= 6, "{warnings:?}");
        for warning in warnings {
            let message = &warning.message;
            assert!(
                message.starts_with(|opens: char| opens.is_uppercase()),
                "{message}",
            );
            assert!(!message.contains(';'), "{message}");
            assert!(
                message.ends_with("The declaration is ignored.")
                    || message.ends_with("The rule is ignored."),
                "{message}",
            );
        }
    }

    /// A font file that will not parse and a font with no family name
    /// are different mistakes, so they read apart.
    #[test]
    fn the_two_font_face_failures_read_apart() {
        assert_eq!(
            face_failure("Sabon", &FontError::Parse),
            "Sabon could not be read as a font. Falling back to another registered font.",
        );
        assert_eq!(
            face_failure("Sabon", &FontError::MissingName),
            "Sabon has no family name and was not registered. \
             Falling back to another registered font.",
        );
    }

    /// The rest of the subset's edges: an at-rule, a selector and a
    /// value the engine does not know each warn where they were
    /// written, and the sheet keeps parsing.
    #[test]
    fn unsupported_at_rules_selectors_and_values_warn() {
        let book = sample();
        let tree = compile(
            &book,
            "@media print { p { font-size: 30pt } }\n\
             p:hover { font-size: 40pt }\n\
             p { text-align: sideways }\n\
             p { hanging-punctuation: sideways }\n\
             p { font-size: 15pt }\n",
        );
        let messages: Vec<&str> = tree
            .warnings()
            .iter()
            .map(|warning| warning.message.as_str())
            .collect();
        assert!(
            messages.contains(&"Unsupported at-rule `@media`. The rule is ignored."),
            "{messages:?}"
        );
        assert!(
            messages.contains(&"Unsupported selector `:hover`. The rule is ignored."),
            "{messages:?}"
        );
        assert!(
            messages.contains(&"Unsupported value for `text-align`. The declaration is ignored."),
            "{messages:?}"
        );
        assert!(
            messages.contains(
                &"Unsupported value for `hanging-punctuation`. The declaration is ignored."
            ),
            "{messages:?}"
        );
        assert!(
            tree.warnings()
                .iter()
                .all(|warning| warning.origin.is_some()),
            "a diagnostic with no position: {:?}",
            tree.warnings()
        );
        assert_eq!(first(&tree, "p").font_size, 15.0);
    }

    /// `@page :first` and `:left`/`:right` select different masters
    /// for the same book: a chapter opening runs a blind folio, and
    /// the spread's margins mirror.
    #[test]
    fn page_pseudo_classes_select_different_masters() {
        let book = sample();
        let tree = defaults(&book, registry());
        let chapter = |situation| {
            tree.page(PageQuery {
                name: Some("chapter"),
                situation,
            })
        };
        let opening = chapter(Situation::First(Side::Recto));
        let body = chapter(Situation::Body(Side::Recto));
        let verso = chapter(Situation::Body(Side::Verso));
        let blank = chapter(Situation::Blank);

        assert!(opening.margin_box(MarginBox::BottomCenter).is_none());
        // A blank's master is a master like any other; that nothing
        // paints on a blank is the flow's rule, not the sheet's.
        assert_eq!(blank.geometry, verso.geometry);
        assert_eq!(
            body.margin_box(MarginBox::BottomCenter)
                .map(|box_| &box_.content),
            Some(&Content::Counter(CounterStyle::Decimal))
        );
        assert_eq!(body.geometry.margin.left, 54.0);
        assert_eq!(body.geometry.margin.right, 42.0);
        assert_eq!(verso.geometry.margin.left, 42.0);
        assert_eq!(verso.geometry.margin.right, 54.0);
        // Every situation of every named page has a master.
        assert_eq!(tree.masters().len(), 10);
    }

    /// Part: the `text-decoration` shorthand sets all four
    /// longhands, and puts back to its initial value every one it
    /// leaves out.
    #[test]
    fn the_text_decoration_shorthand_sets_every_longhand() {
        let book = sample();
        let tree = compile(
            &book,
            "p { text-decoration: underline double #808080 1.5pt }
             em { text-decoration: line-through }",
        );
        let paragraph = first(&tree, "p");
        assert_eq!(
            paragraph.text_decoration_line,
            DecorationLine {
                under: true,
                over: false,
                through: false,
            },
        );
        assert_eq!(paragraph.text_decoration_style, DecorationStyle::Double);
        assert_eq!(
            paragraph.text_decoration_color,
            Some(Color::rgb(128, 128, 128)),
        );
        assert_eq!(paragraph.text_decoration_thickness, Some(1.5));

        // The emphasis is inside the paragraph, so it inherits all
        // four and then the shorthand puts back the three it does
        // not name.
        let emphasis = first(&tree, "em");
        assert_eq!(
            emphasis.text_decoration_line,
            DecorationLine {
                under: false,
                over: false,
                through: true,
            },
        );
        assert_eq!(emphasis.text_decoration_style, DecorationStyle::Solid);
        assert_eq!(emphasis.text_decoration_color, None);
        assert_eq!(emphasis.text_decoration_thickness, None);

        // The longhands inherit on their own: an emphasis the
        // shorthand does not reach keeps what the paragraph drew.
        let inherited = compile(&book, "p { text-decoration: underline }");
        assert_eq!(
            first(&inherited, "em").text_decoration_line,
            first(&inherited, "p").text_decoration_line,
        );
    }

    /// The furniture grammar: what an element sets a running string
    /// to, where the folio restarts, and what a margin box resolves
    /// its content from.
    #[test]
    fn string_set_counter_reset_and_margin_box_content_compile() {
        let book = sample();
        let tree = compile(
            &book,
            "h1 { string-set: chapter \"— \" content() }
             section { counter-reset: page 7 }
             @page :left { @top-left { content: string(chapter) } }
             @page :right { @top-right { content: counter(page, upper-roman) } }",
        );

        assert_eq!(
            first(&tree, "h1").string_set,
            vec![StringSet {
                name: "chapter".into(),
                value: vec![StringPiece::Text("— ".into()), StringPiece::Content],
            }],
        );
        // `content(text)` is the other spelling of the same thing,
        // and an argument the engine has no answer for is not.
        let spelled = compile(
            &book,
            "h1 { string-set: chapter content(text) }
             p { string-set: stanza content(before) }",
        );
        assert_eq!(
            first(&spelled, "h1").string_set,
            vec![StringSet {
                name: "chapter".into(),
                value: vec![StringPiece::Content],
            }],
        );
        assert!(first(&spelled, "p").string_set.is_empty());
        assert_eq!(spelled.warnings().len(), 1, "{:?}", spelled.warnings());

        assert_eq!(first(&tree, "section").counter_reset, Some(7));
        // Not inherited: a paragraph inside the section restarts
        // nothing and sets nothing.
        assert_eq!(first(&tree, "p").counter_reset, None);
        assert!(first(&tree, "p").string_set.is_empty());

        let box_content = |situation, which| {
            tree.page(PageQuery {
                name: Some("chapter"),
                situation,
            })
            .margin_box(which)
            .map(|box_| box_.content.clone())
        };
        assert_eq!(
            box_content(Situation::Body(Side::Verso), MarginBox::TopLeft),
            Some(Content::String("chapter".into())),
        );
        assert_eq!(
            box_content(Situation::Body(Side::Recto), MarginBox::TopRight),
            Some(Content::Counter(CounterStyle::UpperRoman)),
        );
    }

    /// A counter style outside the subset is a diagnostic, not a
    /// silently decimal folio.
    #[test]
    fn an_unsupported_counter_style_warns() {
        let book = sample();
        let tree = compile(
            &book,
            "@page { @bottom-center { content: counter(page, georgian) } }",
        );
        assert!(
            tree.warnings().iter().any(|warning| warning.message
                == "Unsupported value for `content`. The declaration is ignored."),
            "{:?}",
            tree.warnings(),
        );
    }

    /// The `@page` grammar: named pages, sheet sizes, margins, and a
    /// margin box set to a literal.
    #[test]
    fn page_grammar_sets_size_margins_and_margin_boxes() {
        let book = sample();
        let tree = compile(
            &book,
            "section { page: chapter }
             @page { size: a5; margin: 2cm }
             @page chapter { margin-left: 3cm }
             @page chapter:first { @top-center { content: \"❦\"; font-size: 14pt } }",
        );
        let a5 = (148.0 * 72.0 / 25.4, 210.0 * 72.0 / 25.4);
        let body = tree.page(PageQuery {
            name: Some("chapter"),
            situation: Situation::Body(Side::Recto),
        });
        assert!((body.geometry.width - a5.0).abs() < 1e-3);
        assert!((body.geometry.height - a5.1).abs() < 1e-3);
        assert!((body.geometry.margin.top - 2.0 * 72.0 / 2.54).abs() < 1e-3);
        assert!((body.geometry.margin.left - 3.0 * 72.0 / 2.54).abs() < 1e-3);

        let opening = tree.page(PageQuery {
            name: Some("chapter"),
            situation: Situation::First(Side::Recto),
        });
        let ornament = opening
            .margin_box(MarginBox::TopCenter)
            .expect("the opening page has an ornament");
        assert_eq!(ornament.content, Content::Text("❦".into()));
        assert_eq!(ornament.style.font_size, 14.0);
        // An unnamed page never picked up the named rule's margin.
        let unnamed = tree.page(PageQuery {
            name: None,
            situation: Situation::Body(Side::Recto),
        });
        assert!((unnamed.geometry.margin.left - 2.0 * 72.0 / 2.54).abs() < 1e-3);
    }

    /// `@font-face` resolves its `src` through the host loader, and
    /// the family the sheet declared is the one selectors use.
    #[test]
    fn font_face_src_resolves_through_the_host_loader() {
        struct OneFace;
        impl FontLoader for OneFace {
            fn load(&self, url: &str) -> Option<Vec<u8>> {
                (url == "faces/garamond.ttf").then(|| BUNDLED_FONT.to_vec())
            }
        }

        let book = sample();
        let mut registry = bundled_registry().expect("bundled font parses");
        let css = "@font-face {
                     font-family: \"Author Serif\";
                     src: url(\"faces/garamond.ttf\") format(\"truetype\");
                   }
                   @font-face {
                     font-family: \"Missing\";
                     src: url(\"faces/nowhere.ttf\");
                   }
                   p { font-family: \"Author Serif\", serif }
                   h1 { font-family: \"Missing\", serif }";
        let mut sheets = Stylesheets::parse(&[Source::author("author.css", css)]);
        sheets.load_fonts(&mut registry, &OneFace);
        let tree = sheets.compile(&book, &registry);

        let author = registry
            .by_family("author serif")
            .expect("the loaded face joined the registry");
        assert_eq!(registry.len(), bundled_registry().unwrap().len() + 5);
        assert_eq!(first(&tree, "p").font_id, author);
        // A face nothing resolved falls back to the next family.
        assert_eq!(first(&tree, "h1").font_id, 0);
        assert!(
            tree.warnings()
                .iter()
                .any(|warning| warning.message.contains("Missing")),
            "an unresolved face should say so: {:?}",
            tree.warnings()
        );
    }

    /// The engine opens nothing itself: with a loader that resolves
    /// nothing, `@font-face` adds no face and says why.
    #[test]
    fn without_a_loader_no_font_face_resolves() {
        let book = sample();
        let mut registry = bundled_registry().expect("bundled font parses");
        let css = "@font-face { font-family: \"Author Serif\"; src: url(\"anywhere.ttf\") }";
        let mut sheets = Stylesheets::parse(&[Source::author("author.css", css)]);
        sheets.load_fonts(&mut registry, &NoFonts);
        let tree = sheets.compile(&book, &registry);
        assert_eq!(registry.len(), bundled_registry().unwrap().len());
        assert!(
            tree.warnings()
                .iter()
                .any(|w| w.message.contains("No src url loaded"))
        );
    }

    /// Relative lengths compute against what CSS says they do:
    /// `em` in `font-size` against the parent, `rem` against the
    /// root, `em` elsewhere against the element's own size.
    #[test]
    fn relative_lengths_resolve_against_their_reference() {
        let book = sample();
        let tree = compile(
            &book,
            "book { font-size: 10pt }
             p { font-size: 1.2em; text-indent: 2em; margin-left: 1rem }
             em { font-size: 50% }",
        );
        let paragraph = first(&tree, "p");
        assert!((paragraph.font_size - 12.0).abs() < 1e-4);
        assert!((paragraph.text_indent - 24.0).abs() < 1e-4);
        assert!((paragraph.margin.left - 10.0).abs() < 1e-4);
        assert!((first(&tree, "em").font_size - 6.0).abs() < 1e-4);
    }

    /// Line height computes to a multiple whatever it was written as.
    #[test]
    fn line_height_computes_to_a_multiple() {
        let book = sample();
        let tree = compile(
            &book,
            "p { font-size: 10pt; line-height: 15pt }
             h1 { line-height: 150% }
             em { line-height: normal }",
        );
        assert!((first(&tree, "p").line_height - 1.5).abs() < 1e-4);
        assert!((first(&tree, "h1").line_height - 1.5).abs() < 1e-4);
        assert!((first(&tree, "em").line_height - 1.2).abs() < 1e-4);
    }

    /// Inheritance: text properties reach descendants, box properties
    /// do not.
    #[test]
    fn text_properties_inherit_and_box_properties_do_not() {
        let book = sample();
        let tree = compile(
            &book,
            "section { text-align: justify; margin-left: 20pt; hyphens: auto }",
        );
        let paragraph = first(&tree, "p");
        assert_eq!(paragraph.text_align, TextAlign::Justify);
        assert_eq!(paragraph.hyphens, Hyphens::Auto);
        assert_eq!(paragraph.margin.left, 0.0);
        assert_eq!(first(&tree, "section").margin.left, 20.0);
    }

    /// The `inherited` flag on each row of the property table is what
    /// the cascade does: set on `section`, an inherited property
    /// reaches the paragraph under it and a box property does not.
    #[test]
    fn the_property_table_says_what_inherits() {
        let book = sample();
        let baseline = first(&compile(&book, ""), "p");
        for spec in sheet::PROPERTIES {
            let reached = spec.examples.iter().any(|example| {
                let css = format!("section {{ {}: {example} }}", spec.name);
                first(&compile(&book, &css), "p") != baseline
            });
            assert_eq!(reached, spec.inherited, "{}", spec.name);
        }
    }

    /// The border shorthands compute onto the four edges: `border`
    /// sets all of them, a per-edge longhand one, and the per-value
    /// longhands one component of each. What a shorthand leaves out
    /// goes back to its initial value, so `border: solid` after a
    /// colour drops the colour.
    #[test]
    fn the_border_shorthands_reach_the_four_edges() {
        let book = sample();
        let tree = compile(
            &book,
            "p { border: 2pt solid crimson; border-left: 6pt solid }\n             blockquote { border-style: solid none; border-width: 1pt; border-color: teal }",
        );
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());
        let paragraph = first(&tree, "p");
        assert_eq!(paragraph.border.top.width, 2.0);
        assert_eq!(paragraph.border.top.style, BorderStyle::Solid);
        assert_eq!(paragraph.border.top.color, Some(Color::rgb(220, 20, 60)));
        assert_eq!(paragraph.border.left.width, 6.0);
        assert_eq!(paragraph.border.left.color, None);
        assert_eq!(paragraph.border.widths().inline(), 8.0);

        let quote = first(&tree, "blockquote");
        assert_eq!(quote.border.widths().top, 1.0);
        assert_eq!(quote.border.widths().right, 0.0);
        assert_eq!(quote.border.left.color, Some(Color::rgb(0, 128, 128)));
    }

    /// An edge `border-style` leaves at `none` takes no width in the
    /// flow, whatever `border-width` said, and one written with no
    /// width at all is `medium`.
    #[test]
    fn an_undrawn_edge_takes_no_width() {
        let book = sample();
        let tree = compile(
            &book,
            "p { border-width: 4pt }\nblockquote { border: solid }",
        );
        assert_eq!(first(&tree, "p").border.widths(), Edges::all(0.0));
        assert_eq!(first(&tree, "blockquote").border.widths(), Edges::all(2.25));
    }

    /// `padding` reads the one-to-four value shorthand the way
    /// `margin` does, and its longhands overwrite what it set.
    #[test]
    fn padding_reads_the_shorthand_and_its_longhands() {
        let book = sample();
        let tree = compile(&book, "p { padding: 6pt 12pt; padding-bottom: 0 }");
        let padding = first(&tree, "p").padding;
        assert_eq!(padding.top, 6.0);
        assert_eq!(padding.right, 12.0);
        assert_eq!(padding.bottom, 0.0);
        assert_eq!(padding.left, 12.0);
    }

    /// `text-justify` and `hanging-punctuation` read as CSS writes
    /// them: the first a keyword, the second a set of them in any
    /// order.
    #[test]
    fn justification_and_hanging_marks_read_as_css_writes_them() {
        let book = sample();
        let tree = compile(
            &book,
            "book { text-justify: inter-character;\
                    hanging-punctuation: last first allow-end }",
        );
        let paragraph = first(&tree, "p");
        assert_eq!(paragraph.text_justify, TextJustify::InterCharacter);
        assert_eq!(
            paragraph.hanging_punctuation,
            HangingPunctuation {
                first: true,
                end: HangEnd::Allow,
                last: true,
            },
        );
        let plain = compile(&book, "book { hanging-punctuation: none }");
        assert_eq!(
            first(&plain, "p").hanging_punctuation,
            HangingPunctuation::NONE,
        );
    }

    /// Generic families resolve through the registry's bindings, and
    /// slope and weight pick the nearest face in a family.
    #[test]
    fn families_resolve_through_the_registry() {
        let book = sample();
        let tree = compile(&book, "p { font-family: \"Nowhere\", monospace }");
        let paragraph = first(&tree, "p");
        assert_eq!(
            paragraph.font_family,
            vec![
                Family::Named("Nowhere".into()),
                Family::Generic(GenericFamily::Monospace),
            ]
        );
        assert_eq!(
            paragraph.font_id,
            registry().generic(GenericFamily::Monospace).unwrap()
        );
    }

    /// A book of one paragraph, a scene break and a quotation: the
    /// blocks whose defaults the built-in sheet has opinions about.
    fn furnished() -> Book {
        let mut book = Book {
            metadata: Metadata::default(),
            sections: vec![Section {
                attributes: Default::default(),
                blocks: vec![
                    Block::Paragraph {
                        id: NodeId::UNASSIGNED,
                        inlines: vec![text("Before the break.")],
                        attributes: Attributes::default(),
                        position: None,
                        span: None,
                    },
                    Block::ThematicBreak {
                        id: NodeId::UNASSIGNED,
                        attributes: Attributes::default(),
                        position: None,
                        span: None,
                    },
                    Block::Blockquote {
                        id: NodeId::UNASSIGNED,
                        blocks: vec![Block::Paragraph {
                            id: NodeId::UNASSIGNED,
                            inlines: vec![text("Quoted.")],
                            attributes: Attributes::default(),
                            position: None,
                            span: None,
                        }],
                        attributes: Attributes::default(),
                        position: None,
                        span: None,
                    },
                ],
                ..Default::default()
            }],
        };
        book.assign_node_ids();
        book
    }

    /// The built-in sheet sets a scene break in an ornament, centred,
    /// and keeps it off both ends of a page. An author sets it in
    /// something else, or in space.
    #[test]
    fn a_thematic_break_takes_its_ornament_from_the_cascade() {
        let book = furnished();
        let tree = defaults(&book, registry());
        let rule = first(&tree, "hr");
        assert_eq!(rule.content, Content::Text("\u{2766}".into()));
        assert_eq!(rule.text_align, TextAlign::Center);
        assert_eq!(rule.break_before, Break::Avoid);
        assert_eq!(rule.break_after, Break::Avoid);
        assert_eq!(rule.margin.top, 11.0);

        assert_eq!(
            first(&compile(&book, "hr { content: none }"), "hr").content,
            Content::None,
        );
        assert_eq!(
            first(&compile(&book, "hr { content: \"* * *\" }"), "hr").content,
            Content::Text("* * *".into()),
        );
    }

    /// A quotation is indented on both sides and set off above and
    /// below, and the indent is a multiple of its own size.
    #[test]
    fn a_blockquote_is_indented_by_the_built_in_sheet() {
        let book = furnished();
        let tree = defaults(&book, registry());
        let quote = first(&tree, "blockquote");
        assert_eq!(quote.margin.left, 2.0 * quote.font_size);
        assert_eq!(quote.margin.right, 2.0 * quote.font_size);
        assert_eq!(quote.margin.top, quote.font_size);
        // The paragraph inside has no indent of its own: the
        // quotation's box is what moves it.
        assert_eq!(nth(&tree, "p", 1).margin.left, 0.0);
    }

    /// `::first-letter` is a second pass over the element it belongs
    /// to: it starts from that element's own computed style, cascades
    /// the rules that named it over the top, and resolves a face of
    /// its own. Rules that name no pseudo-element never reach it, and
    /// it never reaches the element.
    #[test]
    fn first_letter_cascades_over_the_element_it_belongs_to() {
        let book = sample();
        let tree = compile(
            &book,
            "p { font-size: 12pt; line-height: 1.8 }
             p::first-letter { initial-letter: 3; font-family: monospace }",
        );
        let Block::Paragraph { id, .. } = &book.sections[0].blocks[1] else {
            panic!("the second block is a paragraph");
        };
        let initial = tree
            .first_letter(*id)
            .expect("a rule named the paragraph's first letter");
        assert_eq!(initial.initial_letter, 3);
        assert_eq!(initial.font_size, 12.0, "the element's size is inherited");
        assert_eq!(initial.line_height, 1.8);
        assert_eq!(
            initial.font_id,
            registry().generic(GenericFamily::Monospace).unwrap(),
            "the pseudo-element resolves its own face",
        );

        // The element keeps its own style, and an element no rule
        // named has no first-letter style at all.
        assert_eq!(first(&tree, "p").initial_letter, 0);
        let Block::Heading { id, .. } = &book.sections[0].blocks[0] else {
            panic!("the first block is a heading");
        };
        assert!(tree.first_letter(*id).is_none());
        assert!(defaults(&book, registry()).first_letter(*id).is_none());

        // Selectors in front of the pseudo-element still have to
        // match: only the paragraph after the heading is picked out.
        let tree = compile(&book, "h1 + p::first-letter { initial-letter: 2 }");
        assert!(tree.first_letter(*id).is_none());
        let Block::Paragraph { id: second, .. } = &book.sections[0].blocks[2] else {
            panic!("the third block is a paragraph");
        };
        assert!(tree.first_letter(*second).is_none());
    }

    /// A pseudo-element outside the subset is a diagnostic, and the
    /// sheet keeps parsing.
    #[test]
    fn an_unsupported_pseudo_element_warns() {
        let book = sample();
        let tree = compile(
            &book,
            "p::marker { content: \"x\" }\np { font-size: 15pt }\n",
        );
        assert!(
            tree.warnings()
                .iter()
                .any(|warning| warning.message
                    == "Unsupported selector `:marker`. The rule is ignored."),
            "{:?}",
            tree.warnings(),
        );
        assert_eq!(first(&tree, "p").font_size, 15.0);
    }

    /// A chapter heading named `the-hunter`, and a paragraph with a
    /// link to it.
    fn linked() -> Book {
        let mut book = sample();
        let blocks = &mut book.sections[0].blocks;
        if let Block::Heading { attributes, .. } = &mut blocks[0] {
            attributes.id = Some("the-hunter".into());
        }
        blocks.push(Block::Paragraph {
            id: NodeId::UNASSIGNED,
            inlines: vec![
                text("See "),
                Inline::Link {
                    id: NodeId::UNASSIGNED,
                    url: "#the-hunter".into(),
                    children: vec![text("the hunter")],
                    attributes: Attributes::default(),
                    position: None,
                    span: None,
                },
                text("."),
            ],
            attributes: Attributes::default(),
            position: None,
            span: None,
        });
        book.assign_node_ids();
        book
    }

    /// The id of the first element of one name.
    fn id_of(tree: &StyleTree, element: &str) -> NodeId {
        let node = tree
            .nodes()
            .iter()
            .find(|node| node.element == element)
            .unwrap_or_else(|| panic!("no {element}"));
        NodeId::new(node.id)
    }

    /// `content` on a pseudo-element reads literals and references in
    /// the order they are written. Literals side by side are one.
    #[test]
    fn content_reads_references_between_literals() {
        let book = linked();
        let after = |css: &str| {
            let tree = compile(&book, &format!("a::after {{ content: {css} }}"));
            assert!(tree.warnings().is_empty(), "{css}: {:?}", tree.warnings());
            tree.after(id_of(&tree, "a"))
                .map(|style| style.content.clone())
        };
        assert_eq!(
            after("\" (page \" target-counter(attr(href url), page) \")\""),
            Some(Content::Pieces(vec![
                ContentPiece::Text(" (page ".into()),
                ContentPiece::TargetCounter {
                    target: Target::Href,
                    style: CounterStyle::Decimal,
                },
                ContentPiece::Text(")".into()),
            ])),
        );
        assert_eq!(
            after("target-counter(\"#the-hunter\", page, upper-roman)"),
            Some(Content::Pieces(vec![ContentPiece::TargetCounter {
                target: Target::Url("#the-hunter".into()),
                style: CounterStyle::UpperRoman,
            }])),
        );
        assert_eq!(
            after("\"see \" target-text(attr(href))"),
            Some(Content::Pieces(vec![
                ContentPiece::Text("see ".into()),
                ContentPiece::TargetText {
                    target: Target::Href,
                },
            ])),
        );
        assert_eq!(after("\"a\" \"b\""), Some(Content::Text("ab".into())));
        assert_eq!(after("none"), None, "`none` generates nothing");
    }

    /// `page` is the only counter a reference can print, and a
    /// function outside the subset is a diagnostic on `content`.
    #[test]
    fn a_reference_outside_the_subset_warns() {
        let book = linked();
        for css in [
            "a::after { content: target-counter(attr(href url), chapter) }",
            "a::after { content: target-counters(attr(href url), page, \".\") }",
            "a::after { content: target-counter(attr(title), page) }",
            "a::after { content: counter(page) }",
        ] {
            let tree = compile(&book, css);
            assert!(
                tree.warnings().iter().any(|warning| warning.message
                    == "Unsupported value for `content`. The declaration is ignored."),
                "{css}: {:?}",
                tree.warnings(),
            );
            assert!(tree.after(id_of(&tree, "a")).is_none(), "{css}");
        }
    }

    /// A pseudo-element starts from the style of the element it
    /// belongs to, and a rule that names it outranks what it
    /// inherited.
    #[test]
    fn a_pseudo_element_inherits_from_its_element() {
        let book = linked();
        let tree = compile(
            &book,
            "a { font-size: 9pt; font-family: monospace; color: #336699 }
             a::before { content: \"[\" }
             a::after { content: \"]\"; color: #d6075e; font-size: 7pt }",
        );
        let link = id_of(&tree, "a");
        let before = tree.before(link).expect("`::before` generates text");
        assert_eq!(before.content, Content::Text("[".into()));
        assert_eq!(before.font_size, 9.0);
        assert_eq!(before.color, Color::rgb(0x33, 0x66, 0x99));
        assert_eq!(
            before.font_id,
            registry().generic(GenericFamily::Monospace).unwrap(),
        );
        let after = tree.after(link).expect("`::after` generates text");
        assert_eq!(after.font_size, 7.0);
        assert_eq!(after.color, Color::rgb(0xd6, 0x07, 0x5e));

        // The element keeps its own style, and generates nothing
        // itself.
        assert_eq!(tree.style(link).content, Content::None);
        assert_eq!(tree.style(link).font_size, 9.0);
    }

    /// `content: none` is the initial value, so a rule that names a
    /// pseudo-element and sets no `content` generates nothing.
    #[test]
    fn a_pseudo_element_with_no_content_generates_nothing() {
        let book = linked();
        let tree = compile(
            &book,
            "a::after { color: red } em::before { content: none } \
             p::after { height: 2pt } h1::before { content: none; height: 2pt }",
        );
        assert!(tree.after(id_of(&tree, "a")).is_none());
        assert!(tree.before(id_of(&tree, "em")).is_none());
        assert!(tree.after(id_of(&tree, "p")).is_none());
        assert!(tree.before(id_of(&tree, "h1")).is_none());
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());
    }

    /// Part: `::before` and `::after` parse and match on a block, and
    /// the cascade computes a style for each.
    #[test]
    fn a_pseudo_element_on_a_block_matches_and_computes_a_style() {
        let book = linked();
        let tree = compile(
            &book,
            "p::before { content: \"x\"; color: red }\np { font-size: 15pt }\n\
             h1::after { content: \"\"; height: 2pt }",
        );
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());
        let before = tree
            .before(id_of(&tree, "p"))
            .expect("`p::before` generates");
        assert_eq!(before.content, Content::Text("x".into()));
        assert_eq!(before.color, Color::rgb(0xff, 0, 0));
        let after = tree
            .after(id_of(&tree, "h1"))
            .expect("`h1::after` generates");
        assert_eq!(after.content, Content::Text(String::new()));
        assert_eq!(after.height, Width::Points(2.0));
        assert!(tree.after(id_of(&tree, "p")).is_none());
        assert_eq!(first(&tree, "p").content, Content::None);
    }

    /// Part: the style tree gives `::first-letter`, `::first-line`,
    /// `::before` and `::after` an id that no content node can have.
    /// The same book and stylesheet give the same ids.
    #[test]
    fn a_pseudo_element_has_an_id_no_content_node_has() {
        let book = linked();
        let css = "p::before { content: \"x\" } h1::after { content: \"\"; height: 2pt } \
                   p::first-letter { initial-letter: 3 } \
                   p::first-line { font-variant-caps: small-caps }";
        let tree = compile(&book, css);
        let p = id_of(&tree, "p");
        let before = tree
            .pseudo_element(p, PseudoElement::Before)
            .expect("`p::before` generates");
        assert_eq!(tree.pseudo_element(p, PseudoElement::After), None);
        assert_eq!(before.pseudo_element(), Some((p, PseudoElement::Before)));
        assert_eq!(before.element(), p);
        assert_eq!(p.pseudo_element(), None);
        assert_eq!(p.element(), p);
        assert_eq!(book.subtree(before), None, "the book holds no such node");
        assert!(tree.nodes().iter().all(|node| node.id != before.get()));
        assert_eq!(tree.style(before).content, Content::Text("x".into()));

        let h1 = id_of(&tree, "h1");
        let after = tree
            .pseudo_element(h1, PseudoElement::After)
            .expect("`h1::after` generates");
        assert_ne!(after, before);
        assert_eq!(tree.style(after).height, Width::Points(2.0));

        let letter = tree
            .pseudo_element(p, PseudoElement::FirstLetter)
            .expect("`p::first-letter` is styled");
        let line = tree
            .pseudo_element(p, PseudoElement::FirstLine)
            .expect("`p::first-line` is styled");
        assert_eq!(tree.pseudo_element(h1, PseudoElement::FirstLetter), None);
        let ids = [before, after, letter, line];
        for id in ids {
            assert_eq!(ids.iter().filter(|other| **other == id).count(), 1);
            assert_eq!(book.subtree(id), None, "the book holds no such node");
            assert!(tree.nodes().iter().all(|node| node.id != id.get()));
        }
        assert_eq!(letter.element(), p);
        assert_eq!(line.element(), p);
        assert!(std::ptr::eq(
            tree.style(letter),
            tree.first_letter(p).unwrap()
        ));
        assert!(std::ptr::eq(tree.style(line), tree.first_line(p).unwrap()));

        let again = compile(&book, css);
        assert_eq!(again.pseudo_element(p, PseudoElement::Before), Some(before));
        assert_eq!(again.pseudo_element(h1, PseudoElement::After), Some(after));
        assert_eq!(
            again.pseudo_element(p, PseudoElement::FirstLetter),
            Some(letter)
        );
        assert_eq!(
            again.pseudo_element(p, PseudoElement::FirstLine),
            Some(line)
        );
    }

    /// Part: `::before` and `::after` on an inline element have an id,
    /// the same as on a block.
    #[test]
    fn an_inline_pseudo_element_has_an_id_as_a_block_does() {
        let book = linked();
        let tree = compile(&book, "a::after { content: \" (link)\" }");
        let a = id_of(&tree, "a");
        let after = tree
            .pseudo_element(a, PseudoElement::After)
            .expect("`a::after` generates text");
        assert_eq!(after.pseudo_element(), Some((a, PseudoElement::After)));
        assert_eq!(after.element(), a);
        assert_eq!(tree.pseudo_element(a, PseudoElement::Before), None);
        assert_eq!(tree.style(after).content, Content::Text(" (link)".into()));
    }

    /// An element with no box of its own takes no generated box. A
    /// sheet that asks for one is told so once, and the element is
    /// styled as though the rule were not there.
    #[test]
    fn a_pseudo_element_on_the_book_warns_and_generates_nothing() {
        let book = linked();
        let tree = compile(
            &book,
            "book::before { content: \"x\" }\nbook { font-size: 15pt }",
        );
        let told: Vec<&str> = tree
            .warnings()
            .iter()
            .map(|warning| warning.message.as_str())
            .collect();
        assert_eq!(
            told,
            ["Unsupported pseudo-element `::before` on `book`. Nothing is generated."],
        );
        assert!(tree.before(id_of(&tree, "book")).is_none());
        assert_eq!(first(&tree, "book").font_size, 15.0);
    }

    /// Acceptance: a pseudo-element inherits the element's family and
    /// size, and a rule naming the pseudo-element beats it, however
    /// specific the rule on the element is.
    #[test]
    fn a_block_pseudo_element_inherits_and_its_own_rule_beats_the_element() {
        let book = linked();
        let tree = compile(
            &book,
            "section > h1#the-hunter { font-size: 20pt; font-family: monospace }\n\
             h1::before { content: \"x\" }\nh1::after { content: \"y\"; font-size: 8pt }",
        );
        let h1 = id_of(&tree, "h1");
        let mono = registry().generic(GenericFamily::Monospace).unwrap();
        let before = tree.before(h1).expect("`::before` generates");
        assert_eq!(before.font_size, 20.0);
        assert_eq!(before.font_id, mono);
        let after = tree.after(h1).expect("`::after` generates");
        assert_eq!(after.font_size, 8.0);
        assert_eq!(after.font_id, mono);
    }

    /// Only a reference to a page asks for a second layout pass. The
    /// text of the target is in the book before anything is laid out.
    #[test]
    fn only_a_page_reference_counts_pages() {
        let book = linked();
        for (css, counts) in [
            ("", false),
            ("a::after { content: \" (see below)\" }", false),
            (
                "a::after { content: \" \" target-text(attr(href url)) }",
                false,
            ),
            (
                "a::after { content: \" \" target-counter(attr(href url), page) }",
                true,
            ),
            (
                "p::after { content: target-counter(\"#the-hunter\", page) }",
                true,
            ),
            ("p::after { content: target-text(\"#the-hunter\") }", false),
        ] {
            assert_eq!(compile(&book, css).counts_pages(), counts, "{css}");
        }
    }

    /// `::first-line` cascades over the element the way
    /// `::first-letter` does, and what line layout reads back is what
    /// it changed rather than the whole computed style.
    #[test]
    fn first_line_cascades_over_the_element_it_belongs_to() {
        let book = sample();
        let tree = compile(
            &book,
            "p { font-size: 12pt; color: #112233 }
             h1 + p::first-line { font-variant-caps: small-caps; letter-spacing: 0.5pt }",
        );
        let Block::Paragraph { id, .. } = &book.sections[0].blocks[1] else {
            panic!("the second block is a paragraph");
        };
        let line = tree
            .first_line(*id)
            .expect("a rule named the paragraph's first line");
        assert_eq!(line.font_variant_caps, FontVariantCaps::SmallCaps);
        assert_eq!(line.font_size, 12.0, "the element's size is inherited");
        assert_eq!(line.color, first(&tree, "p").color);

        let opening = tree.opening_line(*id).expect("the opening line's overlay");
        assert_eq!(opening.caps, Some(FontVariantCaps::SmallCaps));
        assert_eq!(opening.letter_spacing, Some(0.5));
        assert_eq!(opening.size, None, "nothing the rule left alone is set");
        assert_eq!(opening.color, None);
        assert_eq!(opening.transform, None);

        // The element keeps its own style, and the sibling selector
        // in front of the pseudo-element still has to match.
        assert_eq!(first(&tree, "p").font_variant_caps, FontVariantCaps::Normal);
        let Block::Paragraph { id: second, .. } = &book.sections[0].blocks[2] else {
            panic!("the third block is a paragraph");
        };
        assert!(tree.first_line(*second).is_none());
        assert!(tree.opening_line(*second).is_none());
    }

    /// `::first-line` takes the properties that change a run's width
    /// and its colour. Anything else warns naming the property, is
    /// dropped, and leaves the rest of the rule standing.
    #[test]
    fn a_property_outside_the_first_line_set_warns_and_is_dropped() {
        let book = sample();
        let tree = compile(
            &book,
            "p::first-line { line-height: 2; text-transform: uppercase }",
        );
        assert!(
            tree.warnings().iter().any(|warning| {
                warning.message
                    == "Unsupported property `line-height` on `::first-line`. \
                        The declaration is ignored."
            }),
            "{:?}",
            tree.warnings(),
        );
        let Block::Paragraph { id, .. } = &book.sections[0].blocks[1] else {
            panic!("the second block is a paragraph");
        };
        let opening = tree.opening_line(*id).expect("the opening line's overlay");
        assert_eq!(opening.transform, Some(TextTransform::Uppercase));
        assert_eq!(
            tree.first_line(*id).unwrap().line_height,
            first(&tree, "p").line_height,
            "the line height the rule asked for was dropped",
        );
    }

    /// Acceptance: `font-family`, `font-style` and `font-weight` on
    /// `::first-line` warn about none of themselves, and each one
    /// reaches the overlay line layout reads.
    #[test]
    fn the_font_properties_set_on_a_first_line() {
        let book = sample();
        let mut registry = bundled_registry().expect("bundled font parses");
        let mut display =
            crate::fonts::FontSource::from_bytes(crate::fonts::BUNDLED_ITALIC.to_vec())
                .expect("the face parses");
        display.family = "display".into();
        registry.add(display).expect("the face registers");
        let css = "p { font-family: \"EB Garamond\" }
                   p::first-line { font-family: display; font-style: italic;
                                   font-weight: bold }";
        let tree =
            Stylesheets::parse(&[Source::author("author.css", css)]).compile(&book, &registry);
        assert_eq!(
            tree.warnings()
                .iter()
                .filter(|warning| warning.message.contains("`::first-line`"))
                .collect::<Vec<_>>(),
            Vec::<&Warning>::new(),
        );

        let Block::Paragraph { id, .. } = &book.sections[0].blocks[1] else {
            panic!("the second block is a paragraph");
        };
        let face = tree
            .opening_line(*id)
            .expect("the opening line's overlay")
            .face
            .expect("the rule asked for another face");
        assert_eq!(face.italic, Some(true));
        assert_eq!(face.weight, Some(700));
        assert_eq!(
            registry
                .font_ref(face.family.expect("the rule named a family"))
                .map(|entry| entry.family.as_str()),
            Some("display"),
        );
    }

    /// A book whose one paragraph nests `strong` inside `em`.
    fn nested() -> Book {
        let mut book = Book {
            metadata: Metadata::default(),
            sections: vec![Section {
                attributes: Default::default(),
                blocks: vec![Block::Paragraph {
                    id: NodeId::UNASSIGNED,
                    inlines: vec![
                        text("She said "),
                        Inline::Emphasis {
                            id: NodeId::UNASSIGNED,
                            children: vec![
                                text("never "),
                                Inline::Strong {
                                    id: NodeId::UNASSIGNED,
                                    children: vec![text("again")],
                                    attributes: Attributes::default(),
                                    position: None,
                                    span: None,
                                },
                            ],
                            attributes: Attributes::default(),
                            position: None,
                            span: None,
                        },
                        text("."),
                    ],
                    attributes: Attributes::default(),
                    position: None,
                    span: None,
                }],
                ..Default::default()
            }],
        };
        book.assign_node_ids();
        book
    }

    /// Slope and weight reach the face through the cascade: `em` and
    /// `strong` set properties like any other rule, and `strong`
    /// inside `em` inherits the slope on its way to a bold italic
    /// face.
    #[test]
    fn emphasis_and_strong_resolve_to_their_own_faces() {
        let book = nested();
        let tree = defaults(&book, registry());
        let face = |italic, weight| {
            registry()
                .select("eb garamond", FaceAttributes { italic, weight })
                .unwrap()
                .id
        };
        assert_eq!(first(&tree, "p").font_id, face(false, 400));
        assert_eq!(first(&tree, "em").font_id, face(true, 400));
        assert_eq!(first(&tree, "strong").font_id, face(true, 700));
        // The cascade, not the element name: an author who unsets
        // the slope gets the upright bold cut under the same markup.
        let tree = compile(&book, "em { font-style: normal }");
        assert_eq!(first(&tree, "strong").font_id, face(false, 700));
    }

    /// A face the registry cannot supply is a diagnostic and the
    /// nearest cut, once, however many nodes asked for it.
    #[test]
    fn a_face_the_registry_lacks_warns_and_lays_out_anyway() {
        let mut upright = FontRegistry::new();
        upright
            .add(crate::fonts::FontSource::from_bytes(BUNDLED_FONT.to_vec()).unwrap())
            .unwrap();
        upright
            .map_generic(GenericFamily::Serif, "eb garamond")
            .unwrap();
        let book = nested();
        let tree = Stylesheets::parse(&[]).compile(&book, &upright);
        assert_eq!(
            first(&tree, "em").font_id,
            first(&tree, "p").font_id,
            "there is no italic cut, so emphasis takes the upright one",
        );
        let complaints: Vec<&str> = tree
            .warnings()
            .iter()
            .map(|warning| warning.message.as_str())
            .filter(|message| message.contains("italic"))
            .collect();
        assert_eq!(
            complaints,
            vec!["eb garamond has no italic face. Italic text falls back to upright."],
        );

        // A stack that resolves nothing at all says so, and the book
        // still lays out on the first registered face.
        let tree = compile(&book, "p { font-family: \"Nowhere\", \"Nor here\" }");
        assert_eq!(first(&tree, "p").font_id, 0);
        assert!(
            tree.warnings().iter().any(|warning| {
                warning.message
                    == "No registered font matches Nowhere, Nor here. \
                        The first registered font is used instead."
            }),
            "{:?}",
            tree.warnings(),
        );
    }

    /// The display-typography properties parse, cascade and inherit:
    /// a rule on the book reaches the paragraph inside it, a rule on
    /// the paragraph overrides it, and `em` inside picks up what the
    /// paragraph set without being named.
    #[test]
    fn display_typography_parses_cascades_and_inherits() {
        let book = nested();
        let tree = compile(
            &book,
            "book { letter-spacing: 0.1em; font-variant-caps: small-caps;
                    text-transform: uppercase }
             p { letter-spacing: 2pt }",
        );
        let paragraph = first(&tree, "p");
        assert_eq!(paragraph.letter_spacing, 2.0, "the closer rule lost");
        assert_eq!(paragraph.font_variant_caps, FontVariantCaps::SmallCaps);
        assert_eq!(paragraph.text_transform, TextTransform::Uppercase);
        let emphasis = first(&tree, "em");
        assert_eq!(
            (
                emphasis.letter_spacing,
                emphasis.font_variant_caps,
                emphasis.text_transform,
            ),
            (2.0, FontVariantCaps::SmallCaps, TextTransform::Uppercase,),
            "emphasis did not inherit what the paragraph set",
        );

        // `em` is a multiple of the element's own size, `normal` and
        // `none` are the initial values written out, and the defaults
        // are what a book gets when nothing says otherwise.
        let tree = compile(
            &book,
            "book { letter-spacing: 0.1em; text-transform: uppercase }
             p { font-size: 20pt; letter-spacing: 0.1em }
             em { letter-spacing: normal; text-transform: none;
                  font-variant-caps: normal }",
        );
        assert_eq!(first(&tree, "p").letter_spacing, 2.0);
        assert_eq!(first(&tree, "em").letter_spacing, 0.0);
        assert_eq!(first(&tree, "em").text_transform, TextTransform::None);
        let plain = first(&defaults(&book, registry()), "p");
        assert_eq!(plain.letter_spacing, 0.0);
        assert_eq!(plain.font_variant_caps, FontVariantCaps::Normal);
        assert_eq!(plain.text_transform, TextTransform::None);

        // A value none of the three has is a diagnostic, not a rule.
        let tree = compile(&book, "p { text-transform: full-width }");
        assert!(
            tree.warnings().iter().any(|warning| {
                warning.message
                    == "Unsupported value for `text-transform`. The declaration is ignored."
            }),
            "{:?}",
            tree.warnings(),
        );
    }

    /// Part: `font-feature-settings` reads a tag and a value, in
    /// each of the three ways a value is written, and it inherits.
    #[test]
    fn font_feature_settings_read_a_tag_and_a_value_and_inherit() {
        let book = nested();
        let tree = compile(
            &book,
            "book { font-feature-settings: \"ss01\" 1, \"liga\" off, \"onum\" }",
        );
        let asked = [
            FeatureSetting::new(*b"ss01", 1),
            FeatureSetting::new(*b"liga", 0),
            FeatureSetting::new(*b"onum", 1),
        ];
        assert_eq!(first(&tree, "p").font_feature_settings, asked);
        assert_eq!(
            first(&tree, "em").font_feature_settings,
            asked,
            "emphasis did not inherit what the book asked for",
        );
        assert!(
            first(&defaults(&book, registry()), "p")
                .font_feature_settings
                .is_empty(),
            "a book that asks for nothing asks for nothing",
        );

        let tree = compile(&book, "p { font-feature-settings: normal }");
        assert!(first(&tree, "p").font_feature_settings.is_empty());

        let tree = compile(&book, "p { font-feature-settings: ss01 }");
        assert!(
            tree.warnings().iter().any(|warning| warning.message
                == "Unsupported value for `font-feature-settings`. The declaration is ignored."),
            "{:?}",
            tree.warnings(),
        );
    }

    /// Part: the `font-variant` longhands name a feature without
    /// spelling its tag, and the computed list merges over what the
    /// engine asks for, `font-feature-settings` last.
    #[test]
    fn the_font_variant_longhands_name_the_features_they_stand_for() {
        let book = nested();
        let tree = compile(
            &book,
            "p { font-variant-numeric: oldstyle-nums tabular-nums;
                 font-variant-ligatures: no-common-ligatures discretionary-ligatures;
                 font-variant-alternates: historical-forms;
                 font-feature-settings: \"onum\" 0, \"ss01\" 1 }",
        );
        let paragraph = first(&tree, "p");
        assert_eq!(
            paragraph.features(),
            [
                FeatureSetting::new(*b"liga", 0),
                FeatureSetting::new(*b"clig", 0),
                FeatureSetting::new(*b"dlig", 1),
                FeatureSetting::new(*b"onum", 1),
                FeatureSetting::new(*b"tnum", 1),
                FeatureSetting::new(*b"hist", 1),
                FeatureSetting::new(*b"onum", 0),
                FeatureSetting::new(*b"ss01", 1),
            ],
            "the sheet's own settings are read after the named forms",
        );

        let plain = first(&defaults(&book, registry()), "p");
        assert!(plain.features().is_empty());
    }

    /// Part: a face that carries none of a feature the sheet asked
    /// for is named once, and a feature turned off is not.
    #[test]
    fn a_face_without_a_requested_feature_is_named() {
        let book = nested();
        let tree = compile(
            &book,
            "book { font-feature-settings: \"zero\" 1 }
             p { font-feature-settings: \"zero\" 1, \"ss01\" 1 }",
        );
        let named: Vec<&str> = tree
            .warnings()
            .iter()
            .map(|warning| warning.message.as_str())
            .filter(|message| message.contains("feature"))
            .collect();
        assert_eq!(
            named,
            ["eb garamond has no `zero` feature. The text is set without it."],
            "{:?}",
            tree.warnings(),
        );

        let quiet = compile(&book, "p { font-feature-settings: \"zero\" 0 }");
        assert!(
            !quiet
                .warnings()
                .iter()
                .any(|warning| warning.message.contains("feature")),
            "a feature asked to stay off is one the face need not carry: {:?}",
            quiet.warnings(),
        );
    }

    /// `color` reads in each of the four forms the subset takes, and
    /// a form outside it is a diagnostic rather than a rule.
    #[test]
    fn colour_reads_in_every_form_the_subset_takes() {
        let book = sample();
        let tree = compile(
            &book,
            "h1 { color: darkred }
             p { color: #036 }
             blockquote { color: #b41e1e }
             em { color: rgb(0% 20% 100%) }",
        );
        assert_eq!(first(&tree, "h1").color, Color::rgb(139, 0, 0));
        assert_eq!(first(&tree, "p").color, Color::rgb(0, 51, 102));
        assert_eq!(first(&tree, "blockquote").color, Color::rgb(180, 30, 30));
        assert_eq!(first(&tree, "em").color, Color::rgb(0, 51, 255));
        assert_eq!(
            first(&defaults(&book, registry()), "p").color,
            Color::BLACK,
            "a book nothing coloured is set in black",
        );

        // A name no colour has, and channels written half as
        // numbers and half as percentages, neither of which CSS
        // allows.
        for css in ["p { color: octarine }", "p { color: rgb(10, 20%, 30) }"] {
            let tree = compile(&book, css);
            assert!(
                tree.warnings().iter().any(|warning| warning.message
                    == "Unsupported value for `color`. The declaration is ignored."),
                "{css}: {:?}",
                tree.warnings(),
            );
        }
    }

    /// Colour inherits: a rule on the section reaches the prose under
    /// it, and a rule on the heading beats what it inherited.
    #[test]
    fn a_colour_on_a_section_reaches_the_prose_under_it() {
        let book = sample();
        let tree = compile(
            &book,
            "section { color: #444444 }
             h1 { color: rgb(180 30 30) }",
        );
        assert_eq!(first(&tree, "p").color, Color::rgb(68, 68, 68));
        assert_eq!(first(&tree, "em").color, Color::rgb(68, 68, 68));
        assert_eq!(first(&tree, "h1").color, Color::rgb(180, 30, 30));
    }

    /// `color` is the ink a box is set in and `background-color` is
    /// what is painted behind it. The text colour inherits and the
    /// background does not, so the emphasis inside a tinted paragraph
    /// takes the ink and leaves the tint.
    #[test]
    fn colour_inherits_where_a_background_does_not() {
        let book = nested();
        let tree = compile(
            &book,
            "p {\n  color: teal;\n  background-color: #f4f1ea;\n}\n",
        );
        assert!(tree.warnings().is_empty(), "{:?}", tree.warnings());
        assert_eq!(first(&tree, "p").color, Color::rgb(0, 128, 128));
        assert_eq!(
            first(&tree, "p").background.color,
            Some(Color::rgb(0xf4, 0xf1, 0xea))
        );
        assert_eq!(first(&tree, "em").color, Color::rgb(0, 128, 128));
        assert_eq!(first(&tree, "em").background.color, None);
    }

    /// A face with no small capitals of its own is reported once,
    /// however many nodes asked for them, and the book is set anyway.
    /// A face that has them is not reported at all.
    #[test]
    fn a_face_without_small_capitals_says_so() {
        let book = nested();
        let bare = crate::fonts::registry_without_substitutions();
        let css = "p, em, strong { font-variant-caps: small-caps }";
        let tree = Stylesheets::parse(&[Source::author("author.css", css)]).compile(&book, &bare);
        let complaints: Vec<&str> = tree
            .warnings()
            .iter()
            .map(|warning| warning.message.as_str())
            .filter(|message| message.contains("small capitals"))
            .collect();
        assert_eq!(
            complaints,
            vec!["eb garamond has no small capitals. Falling back to reduced capitals."],
        );

        let tree = compile(&book, css);
        assert!(
            !tree
                .warnings()
                .iter()
                .any(|warning| warning.message.contains("small capitals")),
            "the bundled face has small capitals: {:?}",
            tree.warnings(),
        );
    }

    /// Styles are interned: a book of thousands of nodes computes a
    /// handful of distinct styles, and every node points at one.
    #[test]
    fn styles_are_shared_between_nodes() {
        let book = sample();
        let tree = defaults(&book, registry());
        assert!(
            tree.styles().len() < tree.nodes().len(),
            "{} styles for {} nodes",
            tree.styles().len(),
            tree.nodes().len()
        );
        for node in tree.nodes() {
            assert!((node.style as usize) < tree.styles().len());
        }
        // A real node id resolves to the style its element got: the
        // section is the second element, after the book itself.
        assert_eq!(
            tree.style(book.sections[0].id),
            &tree.styles()[tree.nodes()[1].style as usize]
        );
    }
}