Rework style chain access

16 files changed, 105 insertions, 111 deletions

diff --git a/library/src/layout/align.rs b/library/src/layout/align.rs
index e0df0436..fdd4d0ea 100644
--- a/library/src/layout/align.rs
+++ b/library/src/layout/align.rs
@@ -16,8 +16,7 @@ use crate::prelude::*;
 /// Category: layout
 #[node(Show)]
 #[set({
-    let aligns: Axes<Option<GenAlign>> = args.find()?.unwrap_or_default();
-    styles.set(Self::ALIGNMENT, aligns);
+    styles.set(Self::set_alignment(args.find()?.unwrap_or_default()));
 })]
 pub struct AlignNode {
     /// The alignment along both axes.
diff --git a/library/src/layout/columns.rs b/library/src/layout/columns.rs
index 94c04509..27339628 100644
--- a/library/src/layout/columns.rs
+++ b/library/src/layout/columns.rs
@@ -68,7 +68,7 @@ impl Layout for ColumnsNode {
 
         // Determine the width of the gutter and each column.
         let columns = self.count().get();
-        let gutter = styles.get(Self::GUTTER).relative_to(regions.base().x);
+        let gutter = Self::gutter_in(styles).relative_to(regions.base().x);
         let width = (regions.size.x - gutter * (columns - 1) as f64) / columns as f64;
 
         let backlog: Vec<_> = std::iter::once(&regions.size.y)
@@ -90,7 +90,7 @@ impl Layout for ColumnsNode {
         let mut frames = body.layout(vt, styles, pod)?.into_iter();
         let mut finished = vec![];
 
-        let dir = styles.get(TextNode::DIR);
+        let dir = TextNode::dir_in(styles);
         let total_regions = (frames.len() as f32 / columns as f32).ceil() as usize;
 
         // Stitch together the columns for each region.
diff --git a/library/src/layout/container.rs b/library/src/layout/container.rs
index 8f5d69cc..bdce1922 100644
--- a/library/src/layout/container.rs
+++ b/library/src/layout/container.rs
@@ -134,7 +134,7 @@ impl Layout for BoxNode {
 
         // Apply inset.
         let mut body = self.body().unwrap_or_default();
-        let inset = styles.get(Self::INSET);
+        let inset = Self::inset_in(styles);
         if inset.iter().any(|v| !v.is_zero()) {
             body = body.padded(inset.map(|side| side.map(Length::from)));
         }
@@ -145,21 +145,20 @@ impl Layout for BoxNode {
         let mut frame = body.layout(vt, styles, pod)?.into_frame();
 
         // Apply baseline shift.
-        let shift = styles.get(Self::BASELINE).relative_to(frame.height());
+        let shift = Self::baseline_in(styles).relative_to(frame.height());
         if !shift.is_zero() {
             frame.set_baseline(frame.baseline() - shift);
         }
 
         // Prepare fill and stroke.
-        let fill = styles.get(Self::FILL);
-        let stroke = styles
-            .get(Self::STROKE)
-            .map(|s| s.map(PartialStroke::unwrap_or_default));
+        let fill = Self::fill_in(styles);
+        let stroke =
+            Self::stroke_in(styles).map(|s| s.map(PartialStroke::unwrap_or_default));
 
         // Add fill and/or stroke.
         if fill.is_some() || stroke.iter().any(Option::is_some) {
-            let outset = styles.get(Self::OUTSET);
-            let radius = styles.get(Self::RADIUS);
+            let outset = Self::outset_in(styles);
+            let radius = Self::radius_in(styles);
             frame.fill_and_stroke(fill, stroke, outset, radius);
         }
 
@@ -220,16 +219,16 @@ impl Layout for BoxNode {
 #[set({
     let spacing = args.named("spacing")?;
     styles.set_opt(
-        Self::ABOVE,
         args.named("above")?
             .map(VNode::block_around)
-            .or_else(|| spacing.map(VNode::block_spacing)),
+            .or_else(|| spacing.map(VNode::block_spacing))
+            .map(Self::set_above),
     );
     styles.set_opt(
-        Self::BELOW,
         args.named("below")?
             .map(VNode::block_around)
-            .or_else(|| spacing.map(VNode::block_spacing)),
+            .or_else(|| spacing.map(VNode::block_spacing))
+            .map(Self::set_below),
     );
 })]
 pub struct BlockNode {
@@ -361,7 +360,7 @@ impl Layout for BlockNode {
     ) -> SourceResult<Fragment> {
         // Apply inset.
         let mut body = self.body().unwrap_or_default();
-        let inset = styles.get(Self::INSET);
+        let inset = Self::inset_in(styles);
         if inset.iter().any(|v| !v.is_zero()) {
             body = body.clone().padded(inset.map(|side| side.map(Length::from)));
         }
@@ -376,7 +375,7 @@ impl Layout for BlockNode {
             .unwrap_or(regions.base());
 
         // Layout the child.
-        let mut frames = if styles.get(Self::BREAKABLE) {
+        let mut frames = if Self::breakable_in(styles) {
             // Measure to ensure frames for all regions have the same width.
             if sizing.x == Smart::Auto {
                 let pod = Regions::one(size, Axes::splat(false));
@@ -414,10 +413,9 @@ impl Layout for BlockNode {
         };
 
         // Prepare fill and stroke.
-        let fill = styles.get(Self::FILL);
-        let stroke = styles
-            .get(Self::STROKE)
-            .map(|s| s.map(PartialStroke::unwrap_or_default));
+        let fill = Self::fill_in(styles);
+        let stroke =
+            Self::stroke_in(styles).map(|s| s.map(PartialStroke::unwrap_or_default));
 
         // Add fill and/or stroke.
         if fill.is_some() || stroke.iter().any(Option::is_some) {
@@ -426,8 +424,8 @@ impl Layout for BlockNode {
                 skip = first.is_empty() && rest.iter().any(|frame| !frame.is_empty());
             }
 
-            let outset = styles.get(Self::OUTSET);
-            let radius = styles.get(Self::RADIUS);
+            let outset = Self::outset_in(styles);
+            let radius = Self::radius_in(styles);
             for frame in frames.iter_mut().skip(skip as usize) {
                 frame.fill_and_stroke(fill, stroke, outset, radius);
             }
diff --git a/library/src/layout/enum.rs b/library/src/layout/enum.rs
index 853a7a67..4876b616 100644
--- a/library/src/layout/enum.rs
+++ b/library/src/layout/enum.rs
@@ -187,21 +187,20 @@ impl Layout for EnumNode {
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let numbering = styles.get(Self::NUMBERING);
-        let indent = styles.get(Self::INDENT);
-        let body_indent = styles.get(Self::BODY_INDENT);
+        let numbering = Self::numbering_in(styles);
+        let indent = Self::indent_in(styles);
+        let body_indent = Self::body_indent_in(styles);
         let gutter = if self.tight() {
-            styles.get(ParNode::LEADING).into()
+            ParNode::leading_in(styles).into()
         } else {
-            styles
-                .get(Self::SPACING)
-                .unwrap_or_else(|| styles.get(BlockNode::BELOW).amount())
+            Self::spacing_in(styles)
+                .unwrap_or_else(|| BlockNode::below_in(styles).amount())
         };
 
         let mut cells = vec![];
         let mut number = NonZeroUsize::new(1).unwrap();
-        let mut parents = styles.get(Self::PARENTS);
-        let full = styles.get(Self::FULL);
+        let mut parents = Self::parents_in(styles);
+        let full = Self::full_in(styles);
 
         for item in self.children() {
             number = item.number().unwrap_or(number);
@@ -223,7 +222,7 @@ impl Layout for EnumNode {
             cells.push(Content::empty());
             cells.push(resolved);
             cells.push(Content::empty());
-            cells.push(item.body().styled(Self::PARENTS, Parent(number)));
+            cells.push(item.body().styled(Self::set_parents(Parent(number))));
             number = number.saturating_add(1);
         }
 
diff --git a/library/src/layout/flow.rs b/library/src/layout/flow.rs
index 8554bd98..5d679570 100644
--- a/library/src/layout/flow.rs
+++ b/library/src/layout/flow.rs
@@ -134,8 +134,8 @@ impl<'a> FlowLayouter<'a> {
         par: &ParNode,
         styles: StyleChain,
     ) -> SourceResult<()> {
-        let aligns = styles.get(AlignNode::ALIGNMENT).resolve(styles);
-        let leading = styles.get(ParNode::LEADING);
+        let aligns = AlignNode::alignment_in(styles).resolve(styles);
+        let leading = ParNode::leading_in(styles);
         let consecutive = self.last_was_par;
         let frames = par
             .layout(vt, styles, consecutive, self.regions.base(), self.regions.expand.x)?
@@ -180,8 +180,8 @@ impl<'a> FlowLayouter<'a> {
         content: &Content,
         styles: StyleChain,
     ) -> SourceResult<()> {
-        let aligns = styles.get(AlignNode::ALIGNMENT).resolve(styles);
-        let sticky = styles.get(BlockNode::STICKY);
+        let aligns = AlignNode::alignment_in(styles).resolve(styles);
+        let sticky = BlockNode::sticky_in(styles);
         let pod = Regions::one(self.regions.base(), Axes::splat(false));
         let layoutable = content.with::<dyn Layout>().unwrap();
         let frame = layoutable.layout(vt, styles, pod)?.into_frame();
@@ -208,10 +208,10 @@ impl<'a> FlowLayouter<'a> {
         }
 
         // How to align the block.
-        let aligns = styles.get(AlignNode::ALIGNMENT).resolve(styles);
+        let aligns = AlignNode::alignment_in(styles).resolve(styles);
 
         // Layout the block itself.
-        let sticky = styles.get(BlockNode::STICKY);
+        let sticky = BlockNode::sticky_in(styles);
         let fragment = block.layout(vt, styles, self.regions)?;
         for (i, frame) in fragment.into_iter().enumerate() {
             if i > 0 {
diff --git a/library/src/layout/grid.rs b/library/src/layout/grid.rs
index b6465e1c..5d465f86 100644
--- a/library/src/layout/grid.rs
+++ b/library/src/layout/grid.rs
@@ -262,7 +262,7 @@ impl<'a, 'v> GridLayouter<'a, 'v> {
         }
 
         // Reverse for RTL.
-        let is_rtl = styles.get(TextNode::DIR) == Dir::RTL;
+        let is_rtl = TextNode::dir_in(styles) == Dir::RTL;
         if is_rtl {
             cols.reverse();
         }
diff --git a/library/src/layout/hide.rs b/library/src/layout/hide.rs
index 5ba7dea4..43d9a2a8 100644
--- a/library/src/layout/hide.rs
+++ b/library/src/layout/hide.rs
@@ -25,6 +25,6 @@ pub struct HideNode {
 
 impl Show for HideNode {
     fn show(&self, _: &mut Vt, _: &Content, _: StyleChain) -> SourceResult<Content> {
-        Ok(self.body().styled(MetaNode::DATA, vec![Meta::Hidden]))
+        Ok(self.body().styled(MetaNode::set_data(vec![Meta::Hidden])))
     }
 }
diff --git a/library/src/layout/list.rs b/library/src/layout/list.rs
index 5ba6b9b0..e6e42263 100644
--- a/library/src/layout/list.rs
+++ b/library/src/layout/list.rs
@@ -127,25 +127,24 @@ impl Layout for ListNode {
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let indent = styles.get(Self::INDENT);
-        let body_indent = styles.get(Self::BODY_INDENT);
+        let indent = Self::indent_in(styles);
+        let body_indent = Self::body_indent_in(styles);
         let gutter = if self.tight() {
-            styles.get(ParNode::LEADING).into()
+            ParNode::leading_in(styles).into()
         } else {
-            styles
-                .get(Self::SPACING)
-                .unwrap_or_else(|| styles.get(BlockNode::BELOW).amount())
+            Self::spacing_in(styles)
+                .unwrap_or_else(|| BlockNode::below_in(styles).amount())
         };
 
-        let depth = styles.get(Self::DEPTH);
-        let marker = styles.get(Self::MARKER).resolve(vt.world(), depth)?;
+        let depth = Self::depth_in(styles);
+        let marker = Self::marker_in(styles).resolve(vt.world(), depth)?;
 
         let mut cells = vec![];
         for item in self.children() {
             cells.push(Content::empty());
             cells.push(marker.clone());
             cells.push(Content::empty());
-            cells.push(item.body().styled(Self::DEPTH, Depth));
+            cells.push(item.body().styled(Self::set_depth(Depth)));
         }
 
         let layouter = GridLayouter::new(
diff --git a/library/src/layout/mod.rs b/library/src/layout/mod.rs
index 96d16ec8..6d57912f 100644
--- a/library/src/layout/mod.rs
+++ b/library/src/layout/mod.rs
@@ -450,13 +450,13 @@ impl<'a> FlowBuilder<'a> {
             };
 
             if !last_was_parbreak && is_tight_list {
-                let leading = styles.get(ParNode::LEADING);
+                let leading = ParNode::leading_in(styles);
                 let spacing = VNode::list_attach(leading.into());
                 self.0.push(spacing.pack(), styles);
             }
 
-            let above = styles.get(BlockNode::ABOVE);
-            let below = styles.get(BlockNode::BELOW);
+            let above = BlockNode::above_in(styles);
+            let below = BlockNode::below_in(styles);
             self.0.push(above.clone().pack(), styles);
             self.0.push(content.clone(), styles);
             self.0.push(below.clone().pack(), styles);
diff --git a/library/src/layout/page.rs b/library/src/layout/page.rs
index 3b557981..0c3de30c 100644
--- a/library/src/layout/page.rs
+++ b/library/src/layout/page.rs
@@ -30,8 +30,8 @@ use crate::prelude::*;
 #[node]
 #[set({
     if let Some(paper) = args.named_or_find::<Paper>("paper")? {
-        styles.set(Self::WIDTH, Smart::Custom(paper.width().into()));
-        styles.set(Self::HEIGHT, Smart::Custom(paper.height().into()));
+        styles.set(Self::set_width(Smart::Custom(paper.width().into())));
+        styles.set(Self::set_height(Smart::Custom(paper.height().into())));
     }
 })]
 pub struct PageNode {
@@ -260,10 +260,10 @@ impl PageNode {
     ) -> SourceResult<Fragment> {
         // When one of the lengths is infinite the page fits its content along
         // that axis.
-        let width = styles.get(Self::WIDTH).unwrap_or(Abs::inf());
-        let height = styles.get(Self::HEIGHT).unwrap_or(Abs::inf());
+        let width = Self::width_in(styles).unwrap_or(Abs::inf());
+        let height = Self::height_in(styles).unwrap_or(Abs::inf());
         let mut size = Size::new(width, height);
-        if styles.get(Self::FLIPPED) {
+        if Self::flipped_in(styles) {
             std::mem::swap(&mut size.x, &mut size.y);
         }
 
@@ -274,12 +274,12 @@ impl PageNode {
 
         // Determine the margins.
         let default = Rel::from(0.1190 * min);
-        let padding = styles.get(Self::MARGIN).map(|side| side.unwrap_or(default));
+        let padding = Self::margin_in(styles).map(|side| side.unwrap_or(default));
 
         let mut child = self.body();
 
         // Realize columns.
-        let columns = styles.get(Self::COLUMNS);
+        let columns = Self::columns_in(styles);
         if columns.get() > 1 {
             child = ColumnsNode::new(columns, child).pack();
         }
@@ -291,11 +291,11 @@ impl PageNode {
         let regions = Regions::repeat(size, size.map(Abs::is_finite));
         let mut fragment = child.layout(vt, styles, regions)?;
 
-        let fill = styles.get(Self::FILL);
-        let header = styles.get(Self::HEADER);
-        let footer = styles.get(Self::FOOTER);
-        let foreground = styles.get(Self::FOREGROUND);
-        let background = styles.get(Self::BACKGROUND);
+        let fill = Self::fill_in(styles);
+        let header = Self::header_in(styles);
+        let footer = Self::footer_in(styles);
+        let foreground = Self::foreground_in(styles);
+        let background = Self::background_in(styles);
 
         // Realize overlays.
         for frame in &mut fragment {
diff --git a/library/src/layout/par.rs b/library/src/layout/par.rs
index 2564940c..10388f88 100644
--- a/library/src/layout/par.rs
+++ b/library/src/layout/par.rs
@@ -2,7 +2,7 @@ use unicode_bidi::{BidiInfo, Level as BidiLevel};
 use unicode_script::{Script, UnicodeScript};
 use xi_unicode::LineBreakIterator;
 
-use typst::model::{Key, StyledNode};
+use typst::model::StyledNode;
 
 use super::{BoxNode, HNode, Sizing, Spacing};
 use crate::layout::AlignNode;
@@ -495,7 +495,7 @@ fn collect<'a>(
     let mut iter = children.iter().peekable();
 
     if consecutive {
-        let indent = styles.get(ParNode::INDENT);
+        let indent = ParNode::indent_in(*styles);
         if !indent.is_zero()
             && children
                 .iter()
@@ -530,7 +530,7 @@ fn collect<'a>(
             Segment::Text(1)
         } else if let Some(node) = child.to::<TextNode>() {
             let prev = full.len();
-            if let Some(case) = styles.get(TextNode::CASE) {
+            if let Some(case) = TextNode::case_in(styles) {
                 full.push_str(&case.apply(&node.text()));
             } else {
                 full.push_str(&node.text());
@@ -545,9 +545,9 @@ fn collect<'a>(
             Segment::Text(c.len_utf8())
         } else if let Some(node) = child.to::<SmartQuoteNode>() {
             let prev = full.len();
-            if styles.get(SmartQuoteNode::ENABLED) {
-                let lang = styles.get(TextNode::LANG);
-                let region = styles.get(TextNode::REGION);
+            if SmartQuoteNode::enabled_in(styles) {
+                let lang = TextNode::lang_in(styles);
+                let region = TextNode::region_in(styles);
                 let quotes = Quotes::from_lang(lang, region);
                 let peeked = iter.peek().and_then(|child| {
                     if let Some(node) = child.to::<TextNode>() {
@@ -613,7 +613,7 @@ fn prepare<'a>(
 ) -> SourceResult<Preparation<'a>> {
     let bidi = BidiInfo::new(
         text,
-        match styles.get(TextNode::DIR) {
+        match TextNode::dir_in(styles) {
             Dir::LTR => Some(BidiLevel::ltr()),
             Dir::RTL => Some(BidiLevel::rtl()),
             _ => None,
@@ -642,7 +642,7 @@ fn prepare<'a>(
             Segment::Formula(formula) => {
                 let pod = Regions::one(region, Axes::splat(false));
                 let mut frame = formula.layout(vt, styles, pod)?.into_frame();
-                frame.translate(Point::with_y(styles.get(TextNode::BASELINE)));
+                frame.translate(Point::with_y(TextNode::baseline_in(styles)));
                 items.push(Item::Frame(frame));
             }
             Segment::Box(node) => {
@@ -651,7 +651,7 @@ fn prepare<'a>(
                 } else {
                     let pod = Regions::one(region, Axes::splat(false));
                     let mut frame = node.layout(vt, styles, pod)?.into_frame();
-                    frame.translate(Point::with_y(styles.get(TextNode::BASELINE)));
+                    frame.translate(Point::with_y(TextNode::baseline_in(styles)));
                     items.push(Item::Frame(frame));
                 }
             }
@@ -664,10 +664,10 @@ fn prepare<'a>(
         bidi,
         items,
         styles,
-        hyphenate: shared_get(styles, children, TextNode::HYPHENATE),
-        lang: shared_get(styles, children, TextNode::LANG),
-        align: styles.get(AlignNode::ALIGNMENT).x.resolve(styles),
-        justify: styles.get(ParNode::JUSTIFY),
+        hyphenate: shared_get(styles, children, TextNode::hyphenate_in),
+        lang: shared_get(styles, children, TextNode::lang_in),
+        align: AlignNode::alignment_in(styles).x.resolve(styles),
+        justify: ParNode::justify_in(styles),
     })
 }
 
@@ -727,22 +727,23 @@ fn is_compatible(a: Script, b: Script) -> bool {
 
 /// Get a style property, but only if it is the same for all children of the
 /// paragraph.
-fn shared_get<'a, K: Key>(
+fn shared_get<'a, T: PartialEq>(
     styles: StyleChain<'a>,
     children: &[Content],
-    key: K,
-) -> Option<K::Output> {
+    getter: fn(StyleChain) -> T,
+) -> Option<T> {
+    let value = getter(styles);
     children
         .iter()
         .filter_map(|child| child.to::<StyledNode>())
-        .all(|node| !node.map().contains(key))
-        .then(|| styles.get(key))
+        .all(|node| getter(styles.chain(&node.map())) == value)
+        .then(|| value)
 }
 
 /// Find suitable linebreaks.
 fn linebreak<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<Line<'a>> {
-    let linebreaks = p.styles.get(ParNode::LINEBREAKS).unwrap_or_else(|| {
-        if p.styles.get(ParNode::JUSTIFY) {
+    let linebreaks = ParNode::linebreaks_in(p.styles).unwrap_or_else(|| {
+        if ParNode::justify_in(p.styles) {
             Linebreaks::Optimized
         } else {
             Linebreaks::Simple
@@ -840,7 +841,7 @@ fn linebreak_optimized<'a>(vt: &Vt, p: &'a Preparation<'a>, width: Abs) -> Vec<L
         line: line(vt, p, 0..0, false, false),
     }];
 
-    let em = p.styles.get(TextNode::SIZE);
+    let em = TextNode::size_in(p.styles);
 
     for (end, mandatory, hyphen) in breakpoints(p) {
         let k = table.len();
@@ -1005,7 +1006,7 @@ impl Breakpoints<'_> {
             .hyphenate
             .or_else(|| {
                 let shaped = self.p.find(offset)?.text()?;
-                Some(shaped.styles.get(TextNode::HYPHENATE))
+                Some(TextNode::hyphenate_in(shaped.styles))
             })
             .unwrap_or(false)
     }
@@ -1014,7 +1015,7 @@ impl Breakpoints<'_> {
     fn lang(&self, offset: usize) -> Option<hypher::Lang> {
         let lang = self.p.lang.or_else(|| {
             let shaped = self.p.find(offset)?.text()?;
-            Some(shaped.styles.get(TextNode::LANG))
+            Some(TextNode::lang_in(shaped.styles))
         })?;
 
         let bytes = lang.as_str().as_bytes().try_into().ok()?;
@@ -1155,7 +1156,7 @@ fn finalize(
         .collect::<SourceResult<_>>()?;
 
     // Prevent orphans.
-    let leading = p.styles.get(ParNode::LEADING);
+    let leading = ParNode::leading_in(p.styles);
     if frames.len() >= 2 && !frames[1].is_empty() {
         let second = frames.remove(1);
         let first = &mut frames[0];
@@ -1199,7 +1200,7 @@ fn commit(
     if let Some(Item::Text(text)) = reordered.first() {
         if let Some(glyph) = text.glyphs.first() {
             if !text.dir.is_positive()
-                && text.styles.get(TextNode::OVERHANG)
+                && TextNode::overhang_in(text.styles)
                 && (reordered.len() > 1 || text.glyphs.len() > 1)
             {
                 let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
@@ -1213,7 +1214,7 @@ fn commit(
     if let Some(Item::Text(text)) = reordered.last() {
         if let Some(glyph) = text.glyphs.last() {
             if text.dir.is_positive()
-                && text.styles.get(TextNode::OVERHANG)
+                && TextNode::overhang_in(text.styles)
                 && (reordered.len() > 1 || text.glyphs.len() > 1)
             {
                 let amount = overhang(glyph.c) * glyph.x_advance.at(text.size);
@@ -1257,7 +1258,7 @@ fn commit(
                     let region = Size::new(amount, full);
                     let pod = Regions::one(region, Axes::new(true, false));
                     let mut frame = node.layout(vt, *styles, pod)?.into_frame();
-                    frame.translate(Point::with_y(styles.get(TextNode::BASELINE)));
+                    frame.translate(Point::with_y(TextNode::baseline_in(*styles)));
                     push(&mut offset, frame);
                 } else {
                     offset += amount;
diff --git a/library/src/layout/repeat.rs b/library/src/layout/repeat.rs
index 67dca285..0fd9ad83 100644
--- a/library/src/layout/repeat.rs
+++ b/library/src/layout/repeat.rs
@@ -40,7 +40,7 @@ impl Layout for RepeatNode {
     ) -> SourceResult<Fragment> {
         let pod = Regions::one(regions.size, Axes::new(false, false));
         let piece = self.body().layout(vt, styles, pod)?.into_frame();
-        let align = styles.get(AlignNode::ALIGNMENT).x.resolve(styles);
+        let align = AlignNode::alignment_in(styles).x.resolve(styles);
 
         let fill = regions.size.x;
         let width = piece.width();
diff --git a/library/src/layout/stack.rs b/library/src/layout/stack.rs
index 430af715..f4e4ab2c 100644
--- a/library/src/layout/stack.rs
+++ b/library/src/layout/stack.rs
@@ -201,10 +201,9 @@ impl<'a> StackLayouter<'a> {
 
         // Block-axis alignment of the `AlignNode` is respected
         // by the stack node.
-        let aligns = if let Some(styled) = block.to::<StyledNode>() {
-            styles.chain(&styled.map()).get(AlignNode::ALIGNMENT)
-        } else {
-            styles.get(AlignNode::ALIGNMENT)
+        let aligns = match block.to::<StyledNode>() {
+            Some(styled) => AlignNode::alignment_in(styles.chain(&styled.map())),
+            None => AlignNode::alignment_in(styles),
         };
 
         let aligns = aligns.resolve(styles);
diff --git a/library/src/layout/table.rs b/library/src/layout/table.rs
index 0083a7bf..1bd47df0 100644
--- a/library/src/layout/table.rs
+++ b/library/src/layout/table.rs
@@ -128,8 +128,8 @@ impl Layout for TableNode {
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let inset = styles.get(Self::INSET);
-        let align = styles.get(Self::ALIGN);
+        let inset = Self::inset_in(styles);
+        let align = Self::align_in(styles);
 
         let tracks = Axes::new(self.columns().0, self.rows().0);
         let gutter = Axes::new(self.column_gutter().0, self.row_gutter().0);
@@ -144,15 +144,15 @@ impl Layout for TableNode {
                 let x = i % cols;
                 let y = i / cols;
                 if let Smart::Custom(alignment) = align.resolve(vt, x, y)? {
-                    child = child.styled(AlignNode::ALIGNMENT, alignment)
+                    child = child.styled(AlignNode::set_alignment(alignment));
                 }
 
                 Ok(child)
             })
             .collect::<SourceResult<_>>()?;
 
-        let fill = styles.get(Self::FILL);
-        let stroke = styles.get(Self::STROKE).map(PartialStroke::unwrap_or_default);
+        let fill = Self::fill_in(styles);
+        let stroke = Self::stroke_in(styles).map(PartialStroke::unwrap_or_default);
 
         // Prepare grid layout by unifying content and gutter tracks.
         let layouter = GridLayouter::new(
diff --git a/library/src/layout/terms.rs b/library/src/layout/terms.rs
index 2933ea20..d859a447 100644
--- a/library/src/layout/terms.rs
+++ b/library/src/layout/terms.rs
@@ -90,14 +90,13 @@ impl Layout for TermsNode {
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let indent = styles.get(Self::INDENT);
-        let body_indent = styles.get(Self::HANGING_INDENT);
+        let indent = Self::indent_in(styles);
+        let body_indent = Self::hanging_indent_in(styles);
         let gutter = if self.tight() {
-            styles.get(ParNode::LEADING).into()
+            ParNode::leading_in(styles).into()
         } else {
-            styles
-                .get(Self::SPACING)
-                .unwrap_or_else(|| styles.get(BlockNode::BELOW).amount())
+            Self::spacing_in(styles)
+                .unwrap_or_else(|| BlockNode::below_in(styles).amount())
         };
 
         let mut cells = vec![];
diff --git a/library/src/layout/transform.rs b/library/src/layout/transform.rs
index b71cfa9f..41d3d120 100644
--- a/library/src/layout/transform.rs
+++ b/library/src/layout/transform.rs
@@ -122,7 +122,7 @@ impl Layout for RotateNode {
     ) -> SourceResult<Fragment> {
         let pod = Regions::one(regions.base(), Axes::splat(false));
         let mut frame = self.body().layout(vt, styles, pod)?.into_frame();
-        let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
+        let origin = Self::origin_in(styles).unwrap_or(Align::CENTER_HORIZON);
         let Axes { x, y } = origin.zip(frame.size()).map(|(o, s)| o.position(s));
         let ts = Transform::translate(x, y)
             .pre_concat(Transform::rotate(self.angle()))
@@ -199,7 +199,7 @@ impl Layout for ScaleNode {
     ) -> SourceResult<Fragment> {
         let pod = Regions::one(regions.base(), Axes::splat(false));
         let mut frame = self.body().layout(vt, styles, pod)?.into_frame();
-        let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
+        let origin = Self::origin_in(styles).unwrap_or(Align::CENTER_HORIZON);
         let Axes { x, y } = origin.zip(frame.size()).map(|(o, s)| o.position(s));
         let transform = Transform::translate(x, y)
             .pre_concat(Transform::scale(self.x(), self.y()))