swc_css_minifier/compressor/
transform_function.rs

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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
use swc_common::Spanned;
use swc_css_ast::*;

use super::Compressor;

impl Compressor {
    pub(super) fn compress_transform_function(&self, component_value: &mut ComponentValue) {
        match component_value {
            ComponentValue::Function(function)
                if function.name == "translate" && function.value.len() == 3 =>
            {
                match (function.value.first(), function.value.get(2)) {
                    (Some(first), Some(ComponentValue::Integer(second))) if second.value == 0 => {
                        function.value = vec![first.clone()];
                    }
                    (Some(ComponentValue::Integer(first)), Some(second)) if first.value == 0 => {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "translatey".into(),
                            raw: None,
                        });
                        function.value = vec![second.clone()];
                    }
                    _ => {}
                }
            }
            ComponentValue::Function(function)
                if function.name == "translate3d" && function.value.len() == 5 =>
            {
                match (
                    function.value.first(),
                    function.value.get(2),
                    function.value.get(4),
                ) {
                    (
                        Some(ComponentValue::Integer(first)),
                        Some(ComponentValue::Integer(second)),
                        Some(third),
                    ) if first.value == 0 && second.value == 0 => {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "translatez".into(),
                            raw: None,
                        });
                        function.value = vec![third.clone()];
                    }
                    _ => {}
                }
            }
            ComponentValue::Function(function)
                if function.name == "scale" && function.value.len() == 3 =>
            {
                match (function.value.first(), function.value.get(2)) {
                    (
                        Some(first @ ComponentValue::Integer(first_number)),
                        Some(ComponentValue::Integer(second_number)),
                    ) if first_number.value == second_number.value => {
                        function.value = vec![first.clone()];
                    }
                    (Some(first), Some(ComponentValue::Integer(second_number)))
                        if second_number.value == 1 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "scalex".into(),
                            raw: None,
                        });
                        function.value = vec![first.clone()];
                    }
                    (Some(ComponentValue::Integer(first_number)), Some(second))
                        if first_number.value == 1 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "scaley".into(),
                            raw: None,
                        });
                        function.value = vec![second.clone()];
                    }
                    _ => {}
                }
            }
            ComponentValue::Function(function)
                if function.name == "scale3d" && function.value.len() == 5 =>
            {
                match (
                    function.value.first(),
                    function.value.get(2),
                    function.value.get(4),
                ) {
                    (
                        Some(first),
                        Some(ComponentValue::Integer(second_number)),
                        Some(ComponentValue::Integer(third_number)),
                    ) if second_number.value == 1 && third_number.value == 1 => {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "scalex".into(),
                            raw: None,
                        });
                        function.value = vec![first.clone()];
                    }
                    (
                        Some(ComponentValue::Integer(first_number)),
                        Some(second),
                        Some(ComponentValue::Integer(third_number)),
                    ) if first_number.value == 1 && third_number.value == 1 => {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "scaley".into(),
                            raw: None,
                        });
                        function.value = vec![second.clone()];
                    }
                    (
                        Some(ComponentValue::Integer(first_number)),
                        Some(ComponentValue::Integer(second_number)),
                        Some(third),
                    ) if first_number.value == 1 && second_number.value == 1 => {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "scalez".into(),
                            raw: None,
                        });
                        function.value = vec![third.clone()];
                    }
                    _ => {}
                }
            }
            ComponentValue::Function(function)
                if function.name == "matrix3d" && function.value.len() == 31 =>
            {
                match (
                    function.value.first(),
                    function.value.get(1),
                    function.value.get(2),
                    function.value.get(3),
                    function.value.get(4),
                    function.value.get(6),
                    function.value.get(8),
                    function.value.get(9),
                    function.value.get(10),
                    function.value.get(11),
                    function.value.get(12),
                    function.value.get(14),
                    function.value.get(16),
                    function.value.get(18),
                    function.value.get(20),
                    function.value.get(22),
                    function.value.get(24),
                    function.value.get(25),
                    function.value.get(26),
                    function.value.get(28),
                    function.value.get(30),
                ) {
                    (
                        Some(first),
                        Some(first_comma),
                        Some(second),
                        Some(second_comma),
                        Some(ComponentValue::Integer(third_number)),
                        Some(ComponentValue::Integer(fourth_number)),
                        Some(fifth),
                        Some(fifth_comma),
                        Some(sixth),
                        Some(sixth_comma),
                        Some(ComponentValue::Integer(seventh_number)),
                        Some(ComponentValue::Integer(eighth_number)),
                        Some(ComponentValue::Integer(ninth_number)),
                        Some(ComponentValue::Integer(tenth_number)),
                        Some(ComponentValue::Integer(eleventh_number)),
                        Some(ComponentValue::Integer(twelfth_number)),
                        Some(thirteenth),
                        Some(thirteenth_comma),
                        Some(fourteenth),
                        Some(ComponentValue::Integer(fifteenth_number)),
                        Some(ComponentValue::Integer(sixteenth_number)),
                    ) if third_number.value == 0
                        && fourth_number.value == 0
                        && seventh_number.value == 0
                        && eighth_number.value == 0
                        && ninth_number.value == 0
                        && tenth_number.value == 0
                        && eleventh_number.value == 1
                        && twelfth_number.value == 0
                        && fifteenth_number.value == 0
                        && sixteenth_number.value == 1 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "matrix".into(),
                            raw: None,
                        });
                        function.value = vec![
                            first.clone(),
                            first_comma.clone(),
                            second.clone(),
                            second_comma.clone(),
                            fifth.clone(),
                            fifth_comma.clone(),
                            sixth.clone(),
                            sixth_comma.clone(),
                            thirteenth.clone(),
                            thirteenth_comma.clone(),
                            fourteenth.clone(),
                        ];
                    }
                    _ => {}
                }
            }
            ComponentValue::Function(function)
                if function.name == "rotate3d" && function.value.len() == 7 =>
            {
                match (
                    function.value.first(),
                    function.value.get(2),
                    function.value.get(4),
                    function.value.get(6),
                ) {
                    (
                        Some(ComponentValue::Integer(first_number)),
                        Some(ComponentValue::Integer(second_number)),
                        Some(ComponentValue::Integer(third_number)),
                        Some(fourth_value),
                    ) if first_number.value == 1
                        && second_number.value == 0
                        && third_number.value == 0 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "rotatex".into(),
                            raw: None,
                        });
                        function.value = vec![fourth_value.clone()];
                    }
                    (
                        Some(ComponentValue::Integer(first_number)),
                        Some(ComponentValue::Integer(second_number)),
                        Some(ComponentValue::Integer(third_number)),
                        Some(fourth_value),
                    ) if first_number.value == 0
                        && second_number.value == 1
                        && third_number.value == 0 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "rotatey".into(),
                            raw: None,
                        });
                        function.value = vec![fourth_value.clone()];
                    }
                    (
                        Some(ComponentValue::Integer(first_number)),
                        Some(ComponentValue::Integer(second_number)),
                        Some(ComponentValue::Integer(third_number)),
                        Some(fourth_value),
                    ) if first_number.value == 0
                        && second_number.value == 0
                        && third_number.value == 1 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "rotate".into(),
                            raw: None,
                        });
                        function.value = vec![fourth_value.clone()];
                    }
                    _ => {}
                }
            }
            ComponentValue::Function(function)
                if function.name == "rotatez" && function.value.len() == 1 =>
            {
                function.name = FunctionName::Ident(Ident {
                    span: function.name.span(),
                    value: "rotate".into(),
                    raw: None,
                });
            }

            ComponentValue::Function(function)
                if function.name == "skew" && function.value.len() == 3 =>
            {
                match (function.value.first(), function.value.get(2)) {
                    (Some(first), Some(ComponentValue::Integer(second_number)))
                        if second_number.value == 0 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "skewx".into(),
                            raw: None,
                        });
                        function.value = vec![first.clone()];
                    }

                    (Some(ComponentValue::Integer(first_number)), Some(second))
                        if first_number.value == 0 =>
                    {
                        function.name = FunctionName::Ident(Ident {
                            span: function.name.span(),
                            value: "skewy".into(),
                            raw: None,
                        });
                        function.value = vec![second.clone()];
                    }
                    _ => {}
                }
            }
            _ => {}
        }
    }
}