ironpress 1.4.4

Pure Rust HTML/CSS/Markdown to PDF converter with layout engine, LaTeX math, tables, images, custom fonts, and streaming output. No browser, no system dependencies.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use super::*;

/// A flow-relative side before the element's writing mode maps it to the page.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum LogicalSide {
    BlockStart,
    BlockEnd,
    InlineStart,
    InlineEnd,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum LogicalAxis {
    Block,
    Inline,
}

impl LogicalAxis {
    pub(super) const fn sides(self) -> [LogicalSide; 2] {
        match self {
            Self::Block => [LogicalSide::BlockStart, LogicalSide::BlockEnd],
            Self::Inline => [LogicalSide::InlineStart, LogicalSide::InlineEnd],
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum LogicalCorner {
    StartStart,
    StartEnd,
    EndStart,
    EndEnd,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum PhysicalCorner {
    TopLeft,
    TopRight,
    BottomRight,
    BottomLeft,
}

/// Complete element-relative mapping used by every logical border family.
#[derive(Debug, Clone, Copy)]
pub(super) struct FlowMapping {
    mode: WritingMode,
    rtl: bool,
}

impl FlowMapping {
    pub(super) fn from_style(style: &ComputedStyle) -> Self {
        let mode = style.writing_mode;
        let rtl = style.direction_rtl && !(mode.is_vertical() && style.text_orientation_upright);
        Self { mode, rtl }
    }

    pub(super) const fn side(self, side: LogicalSide) -> PhysicalSide {
        match (self.mode, side, self.rtl) {
            (WritingMode::HorizontalTb, LogicalSide::BlockStart, _) => PhysicalSide::Top,
            (WritingMode::HorizontalTb, LogicalSide::BlockEnd, _) => PhysicalSide::Bottom,
            (WritingMode::HorizontalTb, LogicalSide::InlineStart, false) => PhysicalSide::Left,
            (WritingMode::HorizontalTb, LogicalSide::InlineStart, true) => PhysicalSide::Right,
            (WritingMode::HorizontalTb, LogicalSide::InlineEnd, false) => PhysicalSide::Right,
            (WritingMode::HorizontalTb, LogicalSide::InlineEnd, true) => PhysicalSide::Left,

            (WritingMode::VerticalRl | WritingMode::SidewaysRl, LogicalSide::BlockStart, _) => {
                PhysicalSide::Right
            }
            (WritingMode::VerticalRl | WritingMode::SidewaysRl, LogicalSide::BlockEnd, _) => {
                PhysicalSide::Left
            }
            (WritingMode::VerticalLr | WritingMode::SidewaysLr, LogicalSide::BlockStart, _) => {
                PhysicalSide::Left
            }
            (WritingMode::VerticalLr | WritingMode::SidewaysLr, LogicalSide::BlockEnd, _) => {
                PhysicalSide::Right
            }

            (
                WritingMode::VerticalRl | WritingMode::VerticalLr | WritingMode::SidewaysRl,
                LogicalSide::InlineStart,
                false,
            )
            | (WritingMode::SidewaysLr, LogicalSide::InlineStart, true) => PhysicalSide::Top,
            (
                WritingMode::VerticalRl | WritingMode::VerticalLr | WritingMode::SidewaysRl,
                LogicalSide::InlineStart,
                true,
            )
            | (WritingMode::SidewaysLr, LogicalSide::InlineStart, false) => PhysicalSide::Bottom,
            (
                WritingMode::VerticalRl | WritingMode::VerticalLr | WritingMode::SidewaysRl,
                LogicalSide::InlineEnd,
                false,
            )
            | (WritingMode::SidewaysLr, LogicalSide::InlineEnd, true) => PhysicalSide::Bottom,
            (
                WritingMode::VerticalRl | WritingMode::VerticalLr | WritingMode::SidewaysRl,
                LogicalSide::InlineEnd,
                true,
            )
            | (WritingMode::SidewaysLr, LogicalSide::InlineEnd, false) => PhysicalSide::Top,
        }
    }

    pub(super) const fn corner(self, corner: LogicalCorner) -> PhysicalCorner {
        let (block_start, inline_start) = match corner {
            LogicalCorner::StartStart => (true, true),
            LogicalCorner::StartEnd => (true, false),
            LogicalCorner::EndStart => (false, true),
            LogicalCorner::EndEnd => (false, false),
        };
        let (top, left) = match self.mode {
            WritingMode::HorizontalTb => (block_start, inline_start != self.rtl),
            WritingMode::VerticalRl | WritingMode::SidewaysRl => {
                (inline_start != self.rtl, !block_start)
            }
            WritingMode::VerticalLr => (inline_start != self.rtl, block_start),
            WritingMode::SidewaysLr => (inline_start == self.rtl, block_start),
        };
        match (top, left) {
            (true, true) => PhysicalCorner::TopLeft,
            (true, false) => PhysicalCorner::TopRight,
            (false, false) => PhysicalCorner::BottomRight,
            (false, true) => PhysicalCorner::BottomLeft,
        }
    }
}