Simpler alignment resolving

src/geom/align.rs

@@ -38,12 +38,12 @@ impl Align {
         }
     }
 
-    /// Returns the position of this alignment in the given range.
+    /// Returns the position of this alignment in the given length.
-    pub fn resolve(self, range: Range<Length>) -> Length {
+    pub fn resolve(self, length: Length) -> Length {
         match self {
-            Self::Left | Self::Top => range.start,
+            Self::Left | Self::Top => Length::zero(),
-            Self::Center | Self::Horizon => (range.start + range.end) / 2.0,
+            Self::Center | Self::Horizon => length / 2.0,
-            Self::Right | Self::Bottom => range.end,
+            Self::Right | Self::Bottom => length,
         }
     }
 }

src/library/align.rs

@@ -45,8 +45,8 @@ impl Layout for AlignNode {
 
             let aligns = self.aligns.unwrap_or(Spec::new(Align::Left, Align::Top));
             let offset = Point::new(
-                aligns.x.resolve(Length::zero() .. canvas.w - frame.size.w),
+                aligns.x.resolve(canvas.w - frame.size.w),
-                aligns.y.resolve(Length::zero() .. canvas.h - frame.size.h),
+                aligns.y.resolve(canvas.h - frame.size.h),
             );
 
             let frame = Rc::make_mut(frame);

src/library/flow.rs

@@ -236,8 +236,8 @@ impl<'a> FlowLayouter<'a> {
                     ruler = ruler.max(aligns.y);
 
                     // Align horizontally and vertically.
-                    let x = aligns.x.resolve(Length::zero() .. size.w - frame.size.w);
+                    let x = aligns.x.resolve(size.w - frame.size.w);
-                    let y = ruler.resolve(before .. before + size.h - self.used.h);
+                    let y = before + ruler.resolve(size.h - self.used.h);
                     let pos = Point::new(x, y);
                     before += frame.size.h;
 

src/library/par.rs

@@ -499,7 +499,7 @@ impl<'a> LineLayout<'a> {
                     }
                 }
 
-                let x = self.par.align.resolve(offset .. remaining + offset);
+                let x = offset + self.par.align.resolve(remaining);
                 let y = self.baseline - frame.baseline;
                 offset += frame.size.w;
 

src/library/stack.rs

@@ -230,19 +230,21 @@ impl<'a> StackLayouter<'a> {
                     before += v.resolve(self.fr, remaining);
                 }
                 StackItem::Frame(frame, align) => {
-                    ruler = ruler.max(align);
+                    if self.stack.dir.is_positive() {
+                        ruler = ruler.max(align);
+                    } else {
+                        ruler = ruler.min(align);
+                    }
 
                     // Align along the block axis.
                     let parent = size.get(self.axis);
                     let child = frame.size.get(self.axis);
-                    let block = ruler.resolve(if self.stack.dir.is_positive() {
+                    let block = ruler.resolve(parent - self.used.block)
-                        let after = self.used.block - before;
+                        + if self.stack.dir.is_positive() {
-                        before .. parent - after
+                            before
-                    } else {
+                        } else {
-                        let before_with_self = before + child;
+                            self.used.block - child - before
-                        let after = self.used.block - before_with_self;
+                        };
-                        after .. parent - before_with_self
-                    });
 
                     let pos = Gen::new(Length::zero(), block).to_point(self.axis);
                     before += child;

tests/typ/layout/stack-1.typ

@@ -18,6 +18,16 @@
 #page(width: 50pt, margins: 0pt)
 #stack(dir: btt, ..items)
 
+---
+// Test RTL alignment.
+#page(width: 50pt, margins: 5pt)
+#font(8pt)
+#stack(dir: rtl,
+  align(center, [A]),
+  align(left, [B]),
+  [C],
+)
+
 ---
 // Test spacing.
 #page(width: 50pt, margins: 0pt)