ttf2woff2 0.11.1

A Pure Rust library and CLI for compressing TTF fonts to WOFF2 format.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use super::inline_bytes::InlineBytes;

/// Input for triplet encoding: (dx, dy, on_curve)
pub(super) struct TripletInput {
    pub dx: i16,
    pub dy: i16,
    pub on_curve: bool,
}

/// Encoded triplet result
pub(super) struct EncodedTriplet {
    pub flag: u8,
    pub data: InlineBytes<4>,
}

impl From<TripletInput> for EncodedTriplet {
    #[inline]
    fn from(input: TripletInput) -> Self {
        let TripletInput { dx: x, dy: y, on_curve } = input;
        let abs_x = x.unsigned_abs();
        let abs_y = y.unsigned_abs();
        let on_curve_bit: u8 = if on_curve { 0 } else { 128 };
        let x_sign: u8 = if x < 0 { 0 } else { 1 };
        let y_sign: u8 = if y < 0 { 0 } else { 1 };
        let xy_signs = x_sign + 2 * y_sign;

        // Case 1: x == 0 && abs_y < 1280
        if x == 0 && abs_y < 1280 {
            let flag = on_curve_bit + ((abs_y & 0xF00) >> 7) as u8 + y_sign;
            return EncodedTriplet {
                flag,
                data: InlineBytes::new([(abs_y & 0xFF) as u8, 0, 0, 0], 1),
            };
        }

        // Case 2: y == 0 && abs_x < 1280
        if y == 0 && abs_x < 1280 {
            let flag = on_curve_bit + 10 + ((abs_x & 0xF00) >> 7) as u8 + x_sign;
            return EncodedTriplet {
                flag,
                data: InlineBytes::new([(abs_x & 0xFF) as u8, 0, 0, 0], 1),
            };
        }

        // Case 3: abs_x in 1..65 && abs_y in 1..65
        if (1..65).contains(&abs_x) && (1..65).contains(&abs_y) {
            let flag = on_curve_bit
                + 20
                + (((abs_x - 1) & 0x30) as u8)
                + ((((abs_y - 1) & 0x30) >> 2) as u8)
                + xy_signs;
            let triplet = ((((abs_x - 1) & 0xF) << 4) | ((abs_y - 1) & 0xF)) as u8;
            return EncodedTriplet {
                flag,
                data: InlineBytes::new([triplet, 0, 0, 0], 1),
            };
        }

        // Case 4: abs_x in 1..769 && abs_y in 1..769
        if (1..769).contains(&abs_x) && (1..769).contains(&abs_y) {
            let flag = on_curve_bit
                + 84
                + (12 * (((abs_x - 1) & 0x300) >> 8)) as u8
                + ((((abs_y - 1) & 0x300) >> 6) as u8)
                + xy_signs;
            return EncodedTriplet {
                flag,
                data: InlineBytes::new(
                    [((abs_x - 1) & 0xFF) as u8, ((abs_y - 1) & 0xFF) as u8, 0, 0],
                    2,
                ),
            };
        }

        // Case 5: abs_x < 4096 && abs_y < 4096
        if abs_x < 4096 && abs_y < 4096 {
            let flag = on_curve_bit + 120 + xy_signs;
            return EncodedTriplet {
                flag,
                data: InlineBytes::new(
                    [
                        (abs_x >> 4) as u8,
                        (((abs_x & 0xF) << 4) | (abs_y >> 8)) as u8,
                        (abs_y & 0xFF) as u8,
                        0,
                    ],
                    3,
                ),
            };
        }

        // Case 6: Full 16-bit range
        let flag = on_curve_bit + 124 + xy_signs;
        EncodedTriplet {
            flag,
            data: InlineBytes::new(
                [
                    (abs_x >> 8) as u8,
                    (abs_x & 0xFF) as u8,
                    (abs_y >> 8) as u8,
                    (abs_y & 0xFF) as u8,
                ],
                4,
            ),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_case1_x_zero() {
        let encoded = EncodedTriplet::from(TripletInput { dx: 0, dy: 100, on_curve: true });
        assert_eq!(encoded.flag, 0 + 0 + 1);
        assert_eq!(encoded.data.as_slice(), &[100]);
    }

    #[test]
    fn test_case2_y_zero() {
        let encoded = EncodedTriplet::from(TripletInput { dx: 100, dy: 0, on_curve: true });
        assert_eq!(encoded.flag, 0 + 10 + 0 + 1);
        assert_eq!(encoded.data.as_slice(), &[100]);
    }

    #[test]
    fn test_case3_small_both() {
        let encoded = EncodedTriplet::from(TripletInput { dx: 10, dy: 20, on_curve: true });
        assert!(encoded.flag >= 20 && encoded.flag < 84);
        assert_eq!(encoded.data.as_slice().len(), 1);
    }

    #[test]
    fn test_case6_large() {
        let encoded = EncodedTriplet::from(TripletInput { dx: 5000, dy: 6000, on_curve: true });
        assert_eq!(encoded.flag, 124 + 3);
        assert_eq!(encoded.data.as_slice().len(), 4);
    }

    #[test]
    fn test_off_curve() {
        let encoded = EncodedTriplet::from(TripletInput { dx: 0, dy: 100, on_curve: false });
        assert!(encoded.flag & 128 != 0);
    }
}