Skip to main content

rspack_lightningcss/properties/
transform.rs

1//! CSS properties related to 2D and 3D transforms.
2
3use super::{Property, PropertyId};
4use crate::context::PropertyHandlerContext;
5use crate::declaration::DeclarationList;
6use crate::error::{ParserError, PrinterError};
7use crate::macros::enum_property;
8use crate::prefixes::Feature;
9use crate::traits::{Parse, PropertyHandler, ToCss, Zero};
10use crate::values::number::NonNegative;
11use crate::values::{
12  angle::Angle,
13  length::{Length, LengthPercentage},
14  percentage::NumberOrPercentage,
15};
16use crate::vendor_prefix::VendorPrefix;
17#[cfg(feature = "visitor")]
18use crate::visitor::Visit;
19use cssparser::*;
20use std::f32::consts::PI;
21
22/// A value for the [transform](https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#propdef-transform) property.
23#[derive(Debug, Clone, PartialEq, Default)]
24#[cfg_attr(feature = "visitor", derive(Visit))]
25#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize), serde(transparent))]
26#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
27#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
28pub struct TransformList(pub Vec<Transform>);
29
30impl<'i> Parse<'i> for TransformList {
31  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
32    if input.try_parse(|input| input.expect_ident_matching("none")).is_ok() {
33      return Ok(TransformList(vec![]));
34    }
35
36    input.skip_whitespace();
37    let mut results = vec![Transform::parse(input)?];
38    loop {
39      input.skip_whitespace();
40      if let Ok(item) = input.try_parse(Transform::parse) {
41        results.push(item);
42      } else {
43        return Ok(TransformList(results));
44      }
45    }
46  }
47}
48
49impl ToCss for TransformList {
50  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
51    if self.0.is_empty() {
52      dest.write_str("none")?;
53      return Ok(());
54    }
55
56    // TODO: Re-enable with a better solution
57    //       See: https://github.com/parcel-bundler/lightningcss/issues/288
58    // if dest.options().minify {
59    //   // Combine transforms into a single matrix.
60    //   if let Some(matrix) = self.to_matrix() {
61    //     // Generate based on the original transforms.
62    //     let mut base = String::new();
63    //     self.to_css_base(&mut Printer::new(
64    //       &mut base,
65    //       PrinterOptions {
66    //         minify: true,
67    //         ..PrinterOptions::default()
68    //       },
69    //     ))?;
70    //
71    //     // Decompose the matrix into transform functions if possible.
72    //     // If the resulting length is shorter than the original, use it.
73    //     if let Some(d) = matrix.decompose() {
74    //       let mut decomposed = String::new();
75    //       d.to_css_base(&mut Printer::new(
76    //         &mut decomposed,
77    //         PrinterOptions {
78    //           minify: true,
79    //           ..PrinterOptions::default()
80    //         },
81    //       ))?;
82    //       if decomposed.len() < base.len() {
83    //         base = decomposed;
84    //       }
85    //     }
86    //
87    //     // Also generate a matrix() or matrix3d() representation and compare that.
88    //     let mut mat = String::new();
89    //     if let Some(matrix) = matrix.to_matrix2d() {
90    //       Transform::Matrix(matrix).to_css(&mut Printer::new(
91    //         &mut mat,
92    //         PrinterOptions {
93    //           minify: true,
94    //           ..PrinterOptions::default()
95    //         },
96    //       ))?
97    //     } else {
98    //       Transform::Matrix3d(matrix).to_css(&mut Printer::new(
99    //         &mut mat,
100    //         PrinterOptions {
101    //           minify: true,
102    //           ..PrinterOptions::default()
103    //         },
104    //       ))?
105    //     }
106    //
107    //     if mat.len() < base.len() {
108    //       dest.write_str(&mat)?;
109    //     } else {
110    //       dest.write_str(&base)?;
111    //     }
112    //
113    //     return Ok(());
114    //   }
115    // }
116
117    self.to_css_base(dest)
118  }
119}
120
121impl TransformList {
122  fn to_css_base<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
123    let mut first = true;
124    for item in &self.0 {
125      if first {
126        first = false;
127      } else {
128        dest.whitespace()?;
129      }
130      item.to_css(dest)?;
131    }
132    Ok(())
133  }
134
135  /// Converts the transform list to a 3D matrix if possible.
136  pub fn to_matrix(&self) -> Option<Matrix3d<f32>> {
137    let mut matrix = Matrix3d::identity();
138    for transform in &self.0 {
139      if let Some(m) = transform.to_matrix() {
140        matrix = m.multiply(&matrix);
141      } else {
142        return None;
143      }
144    }
145    Some(matrix)
146  }
147}
148
149/// An individual [transform function](https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#two-d-transform-functions).
150#[derive(Debug, Clone, PartialEq)]
151#[cfg_attr(feature = "visitor", derive(Visit))]
152#[cfg_attr(
153  feature = "serde",
154  derive(serde::Serialize, serde::Deserialize),
155  serde(tag = "type", content = "value", rename_all = "camelCase")
156)]
157#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
158#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
159pub enum Transform {
160  /// A 2D translation.
161  Translate(LengthPercentage, LengthPercentage),
162  /// A translation in the X direction.
163  TranslateX(LengthPercentage),
164  /// A translation in the Y direction.
165  TranslateY(LengthPercentage),
166  /// A translation in the Z direction.
167  TranslateZ(Length),
168  /// A 3D translation.
169  Translate3d(LengthPercentage, LengthPercentage, Length),
170  /// A 2D scale.
171  Scale(NumberOrPercentage, NumberOrPercentage),
172  /// A scale in the X direction.
173  ScaleX(NumberOrPercentage),
174  /// A scale in the Y direction.
175  ScaleY(NumberOrPercentage),
176  /// A scale in the Z direction.
177  ScaleZ(NumberOrPercentage),
178  /// A 3D scale.
179  Scale3d(NumberOrPercentage, NumberOrPercentage, NumberOrPercentage),
180  /// A 2D rotation.
181  Rotate(Angle),
182  /// A rotation around the X axis.
183  RotateX(Angle),
184  /// A rotation around the Y axis.
185  RotateY(Angle),
186  /// A rotation around the Z axis.
187  RotateZ(Angle),
188  /// A 3D rotation.
189  Rotate3d(f32, f32, f32, Angle),
190  /// A 2D skew.
191  Skew(Angle, Angle),
192  /// A skew along the X axis.
193  SkewX(Angle),
194  /// A skew along the Y axis.
195  SkewY(Angle),
196  /// A perspective transform.
197  Perspective(NonNegative<Length>),
198  /// A 2D matrix transform.
199  Matrix(Matrix<f32>),
200  /// A 3D matrix transform.
201  Matrix3d(Matrix3d<f32>),
202}
203
204/// A 2D matrix.
205#[derive(Debug, Clone, PartialEq)]
206#[cfg_attr(feature = "visitor", derive(Visit))]
207#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
208#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
209#[allow(missing_docs)]
210#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
211pub struct Matrix<T> {
212  pub a: T,
213  pub b: T,
214  pub c: T,
215  pub d: T,
216  pub e: T,
217  pub f: T,
218}
219
220impl Matrix<f32> {
221  /// Converts the matrix to a 3D matrix.
222  pub fn to_matrix3d(&self) -> Matrix3d<f32> {
223    Matrix3d {
224      m11: self.a,
225      m12: self.b,
226      m13: 0.0,
227      m14: 0.0,
228      m21: self.c,
229      m22: self.d,
230      m23: 0.0,
231      m24: 0.0,
232      m31: 0.0,
233      m32: 0.0,
234      m33: 1.0,
235      m34: 0.0,
236      m41: self.e,
237      m42: self.f,
238      m43: 0.0,
239      m44: 1.0,
240    }
241  }
242}
243
244/// A 3D matrix.
245#[derive(Debug, Clone, PartialEq)]
246#[cfg_attr(feature = "visitor", derive(Visit))]
247#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
248#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
249#[allow(missing_docs)]
250pub struct Matrix3d<T> {
251  pub m11: T,
252  pub m12: T,
253  pub m13: T,
254  pub m14: T,
255  pub m21: T,
256  pub m22: T,
257  pub m23: T,
258  pub m24: T,
259  pub m31: T,
260  pub m32: T,
261  pub m33: T,
262  pub m34: T,
263  pub m41: T,
264  pub m42: T,
265  pub m43: T,
266  pub m44: T,
267}
268
269// https://drafts.csswg.org/css-transforms-2/#mathematical-description
270impl Matrix3d<f32> {
271  /// Creates an identity matrix.
272  pub fn identity() -> Matrix3d<f32> {
273    Matrix3d {
274      m11: 1.0,
275      m12: 0.0,
276      m13: 0.0,
277      m14: 0.0,
278      m21: 0.0,
279      m22: 1.0,
280      m23: 0.0,
281      m24: 0.0,
282      m31: 0.0,
283      m32: 0.0,
284      m33: 1.0,
285      m34: 0.0,
286      m41: 0.0,
287      m42: 0.0,
288      m43: 0.0,
289      m44: 1.0,
290    }
291  }
292
293  /// Creates a translation matrix.
294  pub fn translate(x: f32, y: f32, z: f32) -> Matrix3d<f32> {
295    Matrix3d {
296      m11: 1.0,
297      m12: 0.0,
298      m13: 0.0,
299      m14: 0.0,
300      m21: 0.0,
301      m22: 1.0,
302      m23: 0.0,
303      m24: 0.0,
304      m31: 0.0,
305      m32: 0.0,
306      m33: 1.0,
307      m34: 0.0,
308      m41: x,
309      m42: y,
310      m43: z,
311      m44: 1.0,
312    }
313  }
314
315  /// Creates a scale matrix.
316  pub fn scale(x: f32, y: f32, z: f32) -> Matrix3d<f32> {
317    Matrix3d {
318      m11: x,
319      m12: 0.0,
320      m13: 0.0,
321      m14: 0.0,
322      m21: 0.0,
323      m22: y,
324      m23: 0.0,
325      m24: 0.0,
326      m31: 0.0,
327      m32: 0.0,
328      m33: z,
329      m34: 0.0,
330      m41: 0.0,
331      m42: 0.0,
332      m43: 0.0,
333      m44: 1.0,
334    }
335  }
336
337  /// Creates a rotation matrix.
338  pub fn rotate(x: f32, y: f32, z: f32, angle: f32) -> Matrix3d<f32> {
339    // Normalize the vector.
340    let length = (x * x + y * y + z * z).sqrt();
341    if length == 0.0 {
342      // A direction vector that cannot be normalized, such as [0,0,0], will cause the rotation to not be applied.
343      return Matrix3d::identity();
344    }
345
346    let x = x / length;
347    let y = y / length;
348    let z = z / length;
349
350    let half_angle = angle / 2.0;
351    let sin = half_angle.sin();
352    let sc = sin * half_angle.cos();
353    let sq = sin * sin;
354    let m11 = 1.0 - 2.0 * (y * y + z * z) * sq;
355    let m12 = 2.0 * (x * y * sq + z * sc);
356    let m13 = 2.0 * (x * z * sq - y * sc);
357    let m21 = 2.0 * (x * y * sq - z * sc);
358    let m22 = 1.0 - 2.0 * (x * x + z * z) * sq;
359    let m23 = 2.0 * (y * z * sq + x * sc);
360    let m31 = 2.0 * (x * z * sq + y * sc);
361    let m32 = 2.0 * (y * z * sq - x * sc);
362    let m33 = 1.0 - 2.0 * (x * x + y * y) * sq;
363    Matrix3d {
364      m11,
365      m12,
366      m13,
367      m14: 0.0,
368      m21,
369      m22,
370      m23,
371      m24: 0.0,
372      m31,
373      m32,
374      m33,
375      m34: 0.0,
376      m41: 0.0,
377      m42: 0.0,
378      m43: 0.0,
379      m44: 1.0,
380    }
381  }
382
383  /// Creates a skew matrix.
384  pub fn skew(a: f32, b: f32) -> Matrix3d<f32> {
385    Matrix3d {
386      m11: 1.0,
387      m12: b.tan(),
388      m13: 0.0,
389      m14: 0.0,
390      m21: a.tan(),
391      m22: 1.0,
392      m23: 0.0,
393      m24: 0.0,
394      m31: 0.0,
395      m32: 0.0,
396      m33: 1.0,
397      m34: 0.0,
398      m41: 0.0,
399      m42: 0.0,
400      m43: 0.0,
401      m44: 1.0,
402    }
403  }
404
405  /// Creates a perspective matrix.
406  pub fn perspective(d: f32) -> Matrix3d<f32> {
407    Matrix3d {
408      m11: 1.0,
409      m12: 0.0,
410      m13: 0.0,
411      m14: 0.0,
412      m21: 0.0,
413      m22: 1.0,
414      m23: 0.0,
415      m24: 0.0,
416      m31: 0.0,
417      m32: 0.0,
418      m33: 1.0,
419      m34: -1.0 / d,
420      m41: 0.0,
421      m42: 0.0,
422      m43: 0.0,
423      m44: 1.0,
424    }
425  }
426
427  /// Multiplies this matrix by another, returning a new matrix.
428  pub fn multiply(&self, other: &Self) -> Self {
429    Matrix3d {
430      m11: self.m11 * other.m11 + self.m12 * other.m21 + self.m13 * other.m31 + self.m14 * other.m41,
431      m12: self.m11 * other.m12 + self.m12 * other.m22 + self.m13 * other.m32 + self.m14 * other.m42,
432      m13: self.m11 * other.m13 + self.m12 * other.m23 + self.m13 * other.m33 + self.m14 * other.m43,
433      m14: self.m11 * other.m14 + self.m12 * other.m24 + self.m13 * other.m34 + self.m14 * other.m44,
434      m21: self.m21 * other.m11 + self.m22 * other.m21 + self.m23 * other.m31 + self.m24 * other.m41,
435      m22: self.m21 * other.m12 + self.m22 * other.m22 + self.m23 * other.m32 + self.m24 * other.m42,
436      m23: self.m21 * other.m13 + self.m22 * other.m23 + self.m23 * other.m33 + self.m24 * other.m43,
437      m24: self.m21 * other.m14 + self.m22 * other.m24 + self.m23 * other.m34 + self.m24 * other.m44,
438      m31: self.m31 * other.m11 + self.m32 * other.m21 + self.m33 * other.m31 + self.m34 * other.m41,
439      m32: self.m31 * other.m12 + self.m32 * other.m22 + self.m33 * other.m32 + self.m34 * other.m42,
440      m33: self.m31 * other.m13 + self.m32 * other.m23 + self.m33 * other.m33 + self.m34 * other.m43,
441      m34: self.m31 * other.m14 + self.m32 * other.m24 + self.m33 * other.m34 + self.m34 * other.m44,
442      m41: self.m41 * other.m11 + self.m42 * other.m21 + self.m43 * other.m31 + self.m44 * other.m41,
443      m42: self.m41 * other.m12 + self.m42 * other.m22 + self.m43 * other.m32 + self.m44 * other.m42,
444      m43: self.m41 * other.m13 + self.m42 * other.m23 + self.m43 * other.m33 + self.m44 * other.m43,
445      m44: self.m41 * other.m14 + self.m42 * other.m24 + self.m43 * other.m34 + self.m44 * other.m44,
446    }
447  }
448
449  /// Returns whether this matrix could be converted to a 2D matrix.
450  pub fn is_2d(&self) -> bool {
451    self.m31 == 0.0
452      && self.m32 == 0.0
453      && self.m13 == 0.0
454      && self.m23 == 0.0
455      && self.m43 == 0.0
456      && self.m14 == 0.0
457      && self.m24 == 0.0
458      && self.m34 == 0.0
459      && self.m33 == 1.0
460      && self.m44 == 1.0
461  }
462
463  /// Attempts to convert the matrix to 2D.
464  /// Returns `None` if the conversion is not possible.
465  pub fn to_matrix2d(&self) -> Option<Matrix<f32>> {
466    if self.is_2d() {
467      return Some(Matrix {
468        a: self.m11,
469        b: self.m12,
470        c: self.m21,
471        d: self.m22,
472        e: self.m41,
473        f: self.m42,
474      });
475    }
476    None
477  }
478
479  /// Scales the matrix by the given factor.
480  pub fn scale_by_factor(&mut self, scaling_factor: f32) {
481    self.m11 *= scaling_factor;
482    self.m12 *= scaling_factor;
483    self.m13 *= scaling_factor;
484    self.m14 *= scaling_factor;
485    self.m21 *= scaling_factor;
486    self.m22 *= scaling_factor;
487    self.m23 *= scaling_factor;
488    self.m24 *= scaling_factor;
489    self.m31 *= scaling_factor;
490    self.m32 *= scaling_factor;
491    self.m33 *= scaling_factor;
492    self.m34 *= scaling_factor;
493    self.m41 *= scaling_factor;
494    self.m42 *= scaling_factor;
495    self.m43 *= scaling_factor;
496    self.m44 *= scaling_factor;
497  }
498
499  /// Returns the determinant of the matrix.
500  pub fn determinant(&self) -> f32 {
501    self.m14 * self.m23 * self.m32 * self.m41
502      - self.m13 * self.m24 * self.m32 * self.m41
503      - self.m14 * self.m22 * self.m33 * self.m41
504      + self.m12 * self.m24 * self.m33 * self.m41
505      + self.m13 * self.m22 * self.m34 * self.m41
506      - self.m12 * self.m23 * self.m34 * self.m41
507      - self.m14 * self.m23 * self.m31 * self.m42
508      + self.m13 * self.m24 * self.m31 * self.m42
509      + self.m14 * self.m21 * self.m33 * self.m42
510      - self.m11 * self.m24 * self.m33 * self.m42
511      - self.m13 * self.m21 * self.m34 * self.m42
512      + self.m11 * self.m23 * self.m34 * self.m42
513      + self.m14 * self.m22 * self.m31 * self.m43
514      - self.m12 * self.m24 * self.m31 * self.m43
515      - self.m14 * self.m21 * self.m32 * self.m43
516      + self.m11 * self.m24 * self.m32 * self.m43
517      + self.m12 * self.m21 * self.m34 * self.m43
518      - self.m11 * self.m22 * self.m34 * self.m43
519      - self.m13 * self.m22 * self.m31 * self.m44
520      + self.m12 * self.m23 * self.m31 * self.m44
521      + self.m13 * self.m21 * self.m32 * self.m44
522      - self.m11 * self.m23 * self.m32 * self.m44
523      - self.m12 * self.m21 * self.m33 * self.m44
524      + self.m11 * self.m22 * self.m33 * self.m44
525  }
526
527  /// Returns the inverse of the matrix if possible.
528  pub fn inverse(&self) -> Option<Matrix3d<f32>> {
529    let mut det = self.determinant();
530    if det == 0.0 {
531      return None;
532    }
533
534    det = 1.0 / det;
535    Some(Matrix3d {
536      m11: det
537        * (self.m23 * self.m34 * self.m42 - self.m24 * self.m33 * self.m42 + self.m24 * self.m32 * self.m43
538          - self.m22 * self.m34 * self.m43
539          - self.m23 * self.m32 * self.m44
540          + self.m22 * self.m33 * self.m44),
541      m12: det
542        * (self.m14 * self.m33 * self.m42 - self.m13 * self.m34 * self.m42 - self.m14 * self.m32 * self.m43
543          + self.m12 * self.m34 * self.m43
544          + self.m13 * self.m32 * self.m44
545          - self.m12 * self.m33 * self.m44),
546      m13: det
547        * (self.m13 * self.m24 * self.m42 - self.m14 * self.m23 * self.m42 + self.m14 * self.m22 * self.m43
548          - self.m12 * self.m24 * self.m43
549          - self.m13 * self.m22 * self.m44
550          + self.m12 * self.m23 * self.m44),
551      m14: det
552        * (self.m14 * self.m23 * self.m32 - self.m13 * self.m24 * self.m32 - self.m14 * self.m22 * self.m33
553          + self.m12 * self.m24 * self.m33
554          + self.m13 * self.m22 * self.m34
555          - self.m12 * self.m23 * self.m34),
556      m21: det
557        * (self.m24 * self.m33 * self.m41 - self.m23 * self.m34 * self.m41 - self.m24 * self.m31 * self.m43
558          + self.m21 * self.m34 * self.m43
559          + self.m23 * self.m31 * self.m44
560          - self.m21 * self.m33 * self.m44),
561      m22: det
562        * (self.m13 * self.m34 * self.m41 - self.m14 * self.m33 * self.m41 + self.m14 * self.m31 * self.m43
563          - self.m11 * self.m34 * self.m43
564          - self.m13 * self.m31 * self.m44
565          + self.m11 * self.m33 * self.m44),
566      m23: det
567        * (self.m14 * self.m23 * self.m41 - self.m13 * self.m24 * self.m41 - self.m14 * self.m21 * self.m43
568          + self.m11 * self.m24 * self.m43
569          + self.m13 * self.m21 * self.m44
570          - self.m11 * self.m23 * self.m44),
571      m24: det
572        * (self.m13 * self.m24 * self.m31 - self.m14 * self.m23 * self.m31 + self.m14 * self.m21 * self.m33
573          - self.m11 * self.m24 * self.m33
574          - self.m13 * self.m21 * self.m34
575          + self.m11 * self.m23 * self.m34),
576      m31: det
577        * (self.m22 * self.m34 * self.m41 - self.m24 * self.m32 * self.m41 + self.m24 * self.m31 * self.m42
578          - self.m21 * self.m34 * self.m42
579          - self.m22 * self.m31 * self.m44
580          + self.m21 * self.m32 * self.m44),
581      m32: det
582        * (self.m14 * self.m32 * self.m41 - self.m12 * self.m34 * self.m41 - self.m14 * self.m31 * self.m42
583          + self.m11 * self.m34 * self.m42
584          + self.m12 * self.m31 * self.m44
585          - self.m11 * self.m32 * self.m44),
586      m33: det
587        * (self.m12 * self.m24 * self.m41 - self.m14 * self.m22 * self.m41 + self.m14 * self.m21 * self.m42
588          - self.m11 * self.m24 * self.m42
589          - self.m12 * self.m21 * self.m44
590          + self.m11 * self.m22 * self.m44),
591      m34: det
592        * (self.m14 * self.m22 * self.m31 - self.m12 * self.m24 * self.m31 - self.m14 * self.m21 * self.m32
593          + self.m11 * self.m24 * self.m32
594          + self.m12 * self.m21 * self.m34
595          - self.m11 * self.m22 * self.m34),
596      m41: det
597        * (self.m23 * self.m32 * self.m41 - self.m22 * self.m33 * self.m41 - self.m23 * self.m31 * self.m42
598          + self.m21 * self.m33 * self.m42
599          + self.m22 * self.m31 * self.m43
600          - self.m21 * self.m32 * self.m43),
601      m42: det
602        * (self.m12 * self.m33 * self.m41 - self.m13 * self.m32 * self.m41 + self.m13 * self.m31 * self.m42
603          - self.m11 * self.m33 * self.m42
604          - self.m12 * self.m31 * self.m43
605          + self.m11 * self.m32 * self.m43),
606      m43: det
607        * (self.m13 * self.m22 * self.m41 - self.m12 * self.m23 * self.m41 - self.m13 * self.m21 * self.m42
608          + self.m11 * self.m23 * self.m42
609          + self.m12 * self.m21 * self.m43
610          - self.m11 * self.m22 * self.m43),
611      m44: det
612        * (self.m12 * self.m23 * self.m31 - self.m13 * self.m22 * self.m31 + self.m13 * self.m21 * self.m32
613          - self.m11 * self.m23 * self.m32
614          - self.m12 * self.m21 * self.m33
615          + self.m11 * self.m22 * self.m33),
616    })
617  }
618
619  /// Transposes the matrix.
620  pub fn transpose(&self) -> Self {
621    Self {
622      m11: self.m11,
623      m12: self.m21,
624      m13: self.m31,
625      m14: self.m41,
626      m21: self.m12,
627      m22: self.m22,
628      m23: self.m32,
629      m24: self.m42,
630      m31: self.m13,
631      m32: self.m23,
632      m33: self.m33,
633      m34: self.m43,
634      m41: self.m14,
635      m42: self.m24,
636      m43: self.m34,
637      m44: self.m44,
638    }
639  }
640
641  /// Multiplies a vector by the matrix.
642  pub fn multiply_vector(&self, pin: &[f32; 4]) -> [f32; 4] {
643    [
644      pin[0] * self.m11 + pin[1] * self.m21 + pin[2] * self.m31 + pin[3] * self.m41,
645      pin[0] * self.m12 + pin[1] * self.m22 + pin[2] * self.m32 + pin[3] * self.m42,
646      pin[0] * self.m13 + pin[1] * self.m23 + pin[2] * self.m33 + pin[3] * self.m43,
647      pin[0] * self.m14 + pin[1] * self.m24 + pin[2] * self.m34 + pin[3] * self.m44,
648    ]
649  }
650
651  /// Decomposes the matrix into a list of transform functions if possible.
652  pub fn decompose(&self) -> Option<TransformList> {
653    // https://drafts.csswg.org/css-transforms-2/#decomposing-a-3d-matrix
654    // Combine 2 point.
655    let combine = |a: [f32; 3], b: [f32; 3], ascl: f32, bscl: f32| {
656      [
657        (ascl * a[0]) + (bscl * b[0]),
658        (ascl * a[1]) + (bscl * b[1]),
659        (ascl * a[2]) + (bscl * b[2]),
660      ]
661    };
662
663    // Dot product.
664    let dot = |a: [f32; 3], b: [f32; 3]| a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
665
666    // Cross product.
667    let cross = |row1: [f32; 3], row2: [f32; 3]| {
668      [
669        row1[1] * row2[2] - row1[2] * row2[1],
670        row1[2] * row2[0] - row1[0] * row2[2],
671        row1[0] * row2[1] - row1[1] * row2[0],
672      ]
673    };
674
675    if self.m44 == 0.0 {
676      return None;
677    }
678
679    let scaling_factor = self.m44;
680
681    // Normalize the matrix.
682    let mut matrix = self.clone();
683    matrix.scale_by_factor(1.0 / scaling_factor);
684
685    // perspective_matrix is used to solve for perspective, but it also provides
686    // an easy way to test for singularity of the upper 3x3 component.
687    let mut perspective_matrix = matrix.clone();
688    perspective_matrix.m14 = 0.0;
689    perspective_matrix.m24 = 0.0;
690    perspective_matrix.m34 = 0.0;
691    perspective_matrix.m44 = 1.0;
692
693    if perspective_matrix.determinant() == 0.0 {
694      return None;
695    }
696
697    let mut transforms = vec![];
698
699    // First, isolate perspective.
700    if matrix.m14 != 0.0 || matrix.m24 != 0.0 || matrix.m34 != 0.0 {
701      let right_hand_side: [f32; 4] = [matrix.m14, matrix.m24, matrix.m34, matrix.m44];
702
703      perspective_matrix = perspective_matrix.inverse().unwrap().transpose();
704      let perspective = perspective_matrix.multiply_vector(&right_hand_side);
705      if perspective[0] == 0.0 && perspective[1] == 0.0 && perspective[3] == 0.0 {
706        transforms.push(Transform::Perspective(NonNegative(Length::px(-1.0 / perspective[2]))))
707      } else {
708        return None;
709      }
710    }
711
712    // Next take care of translation (easy).
713    // let translate = Translate3D(matrix.m41, matrix.m42, matrix.m43);
714    if matrix.m41 != 0.0 || matrix.m42 != 0.0 || matrix.m43 != 0.0 {
715      transforms.push(Transform::Translate3d(
716        LengthPercentage::px(matrix.m41),
717        LengthPercentage::px(matrix.m42),
718        Length::px(matrix.m43),
719      ));
720    }
721
722    // Now get scale and shear. 'row' is a 3 element array of 3 component vectors
723    let mut row = [
724      [matrix.m11, matrix.m12, matrix.m13],
725      [matrix.m21, matrix.m22, matrix.m23],
726      [matrix.m31, matrix.m32, matrix.m33],
727    ];
728
729    // Compute X scale factor and normalize first row.
730    let row0len = (row[0][0] * row[0][0] + row[0][1] * row[0][1] + row[0][2] * row[0][2]).sqrt();
731    let mut scale_x = row0len;
732    row[0] = [row[0][0] / row0len, row[0][1] / row0len, row[0][2] / row0len];
733
734    // Compute XY shear factor and make 2nd row orthogonal to 1st.
735    let mut skew_x = dot(row[0], row[1]);
736    row[1] = combine(row[1], row[0], 1.0, -skew_x);
737
738    // Now, compute Y scale and normalize 2nd row.
739    let row1len = (row[1][0] * row[1][0] + row[1][1] * row[1][1] + row[1][2] * row[1][2]).sqrt();
740    let mut scale_y = row1len;
741    row[1] = [row[1][0] / row1len, row[1][1] / row1len, row[1][2] / row1len];
742    skew_x /= scale_y;
743
744    // Compute XZ and YZ shears, orthogonalize 3rd row
745    let mut skew_y = dot(row[0], row[2]);
746    row[2] = combine(row[2], row[0], 1.0, -skew_y);
747    let mut skew_z = dot(row[1], row[2]);
748    row[2] = combine(row[2], row[1], 1.0, -skew_z);
749
750    // Next, get Z scale and normalize 3rd row.
751    let row2len = (row[2][0] * row[2][0] + row[2][1] * row[2][1] + row[2][2] * row[2][2]).sqrt();
752    let mut scale_z = row2len;
753    row[2] = [row[2][0] / row2len, row[2][1] / row2len, row[2][2] / row2len];
754    skew_y /= scale_z;
755    skew_z /= scale_z;
756
757    if skew_z != 0.0 {
758      return None; // ???
759    }
760
761    // Round to 5 digits of precision, which is what we print.
762    macro_rules! round {
763      ($var: ident) => {
764        $var = ($var * 100000.0).round() / 100000.0;
765      };
766    }
767
768    round!(skew_x);
769    round!(skew_y);
770    round!(skew_z);
771
772    if skew_x != 0.0 || skew_y != 0.0 || skew_z != 0.0 {
773      transforms.push(Transform::Skew(Angle::Rad(skew_x), Angle::Rad(skew_y)));
774    }
775
776    // At this point, the matrix (in rows) is orthonormal.
777    // Check for a coordinate system flip.  If the determinant
778    // is -1, then negate the matrix and the scaling factors.
779    if dot(row[0], cross(row[1], row[2])) < 0.0 {
780      scale_x = -scale_x;
781      scale_y = -scale_y;
782      scale_z = -scale_z;
783      for i in 0..3 {
784        row[i][0] *= -1.0;
785        row[i][1] *= -1.0;
786        row[i][2] *= -1.0;
787      }
788    }
789
790    round!(scale_x);
791    round!(scale_y);
792    round!(scale_z);
793
794    if scale_x != 1.0 || scale_y != 1.0 || scale_z != 1.0 {
795      transforms.push(Transform::Scale3d(
796        NumberOrPercentage::Number(scale_x),
797        NumberOrPercentage::Number(scale_y),
798        NumberOrPercentage::Number(scale_z),
799      ))
800    }
801
802    // Now, get the rotations out.
803    let mut rotate_x = 0.5 * ((1.0 + row[0][0] - row[1][1] - row[2][2]).max(0.0)).sqrt();
804    let mut rotate_y = 0.5 * ((1.0 - row[0][0] + row[1][1] - row[2][2]).max(0.0)).sqrt();
805    let mut rotate_z = 0.5 * ((1.0 - row[0][0] - row[1][1] + row[2][2]).max(0.0)).sqrt();
806    let rotate_w = 0.5 * ((1.0 + row[0][0] + row[1][1] + row[2][2]).max(0.0)).sqrt();
807
808    if row[2][1] > row[1][2] {
809      rotate_x = -rotate_x
810    }
811
812    if row[0][2] > row[2][0] {
813      rotate_y = -rotate_y
814    }
815
816    if row[1][0] > row[0][1] {
817      rotate_z = -rotate_z
818    }
819
820    let len = (rotate_x * rotate_x + rotate_y * rotate_y + rotate_z * rotate_z).sqrt();
821    if len != 0.0 {
822      rotate_x /= len;
823      rotate_y /= len;
824      rotate_z /= len;
825    }
826    let a = 2.0 * len.atan2(rotate_w);
827
828    // normalize the vector so one of the values is 1
829    let max = rotate_x.max(rotate_y).max(rotate_z);
830    rotate_x /= max;
831    rotate_y /= max;
832    rotate_z /= max;
833
834    if a != 0.0 {
835      transforms.push(Transform::Rotate3d(rotate_x, rotate_y, rotate_z, Angle::Rad(a)))
836    }
837
838    if transforms.is_empty() {
839      return None;
840    }
841
842    Some(TransformList(transforms))
843  }
844}
845
846impl<'i> Parse<'i> for Transform {
847  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
848    let function = input.expect_function()?.clone();
849    input.parse_nested_block(|input| {
850      let location = input.current_source_location();
851      match_ignore_ascii_case! { &function,
852        "matrix" => {
853          let a = f32::parse(input)?;
854          input.expect_comma()?;
855          let b = f32::parse(input)?;
856          input.expect_comma()?;
857          let c = f32::parse(input)?;
858          input.expect_comma()?;
859          let d = f32::parse(input)?;
860          input.expect_comma()?;
861          let e = f32::parse(input)?;
862          input.expect_comma()?;
863          let f = f32::parse(input)?;
864          Ok(Transform::Matrix(Matrix { a, b, c, d, e, f }))
865        },
866        "matrix3d" => {
867          let m11 = f32::parse(input)?;
868          input.expect_comma()?;
869          let m12 = f32::parse(input)?;
870          input.expect_comma()?;
871          let m13 = f32::parse(input)?;
872          input.expect_comma()?;
873          let m14 = f32::parse(input)?;
874          input.expect_comma()?;
875          let m21 = f32::parse(input)?;
876          input.expect_comma()?;
877          let m22 = f32::parse(input)?;
878          input.expect_comma()?;
879          let m23 = f32::parse(input)?;
880          input.expect_comma()?;
881          let m24 = f32::parse(input)?;
882          input.expect_comma()?;
883          let m31 = f32::parse(input)?;
884          input.expect_comma()?;
885          let m32 = f32::parse(input)?;
886          input.expect_comma()?;
887          let m33 = f32::parse(input)?;
888          input.expect_comma()?;
889          let m34 = f32::parse(input)?;
890          input.expect_comma()?;
891          let m41 = f32::parse(input)?;
892          input.expect_comma()?;
893          let m42 = f32::parse(input)?;
894          input.expect_comma()?;
895          let m43 = f32::parse(input)?;
896          input.expect_comma()?;
897          let m44 = f32::parse(input)?;
898          Ok(Transform::Matrix3d(Matrix3d {
899            m11, m12, m13, m14,
900            m21, m22, m23, m24,
901            m31, m32, m33, m34,
902            m41, m42, m43, m44
903          }))
904        },
905        "translate" => {
906          let x = LengthPercentage::parse(input)?;
907          if input.try_parse(|input| input.expect_comma()).is_ok() {
908            let y = LengthPercentage::parse(input)?;
909            Ok(Transform::Translate(x, y))
910          } else {
911            Ok(Transform::Translate(x, LengthPercentage::zero()))
912          }
913        },
914        "translatex" => {
915          let x = LengthPercentage::parse(input)?;
916          Ok(Transform::TranslateX(x))
917        },
918        "translatey" => {
919          let y = LengthPercentage::parse(input)?;
920          Ok(Transform::TranslateY(y))
921        },
922        "translatez" => {
923          let z = Length::parse(input)?;
924          Ok(Transform::TranslateZ(z))
925        },
926        "translate3d" => {
927          let x = LengthPercentage::parse(input)?;
928          input.expect_comma()?;
929          let y = LengthPercentage::parse(input)?;
930          input.expect_comma()?;
931          let z = Length::parse(input)?;
932          Ok(Transform::Translate3d(x, y, z))
933        },
934        "scale" => {
935          let x = convert_percentage_to_number(input)?;
936          if input.try_parse(|input| input.expect_comma()).is_ok() {
937            let y = convert_percentage_to_number(input)?;
938            Ok(Transform::Scale(x, y))
939          } else {
940            Ok(Transform::Scale(x.clone(), x))
941          }
942        },
943        "scalex" => {
944          let x = convert_percentage_to_number(input)?;
945          Ok(Transform::ScaleX(x))
946        },
947        "scaley" => {
948          let y = convert_percentage_to_number(input)?;
949          Ok(Transform::ScaleY(y))
950        },
951        "scalez" => {
952          let z = convert_percentage_to_number(input)?;
953          Ok(Transform::ScaleZ(z))
954        },
955        "scale3d" => {
956          let x = convert_percentage_to_number(input)?;
957          input.expect_comma()?;
958          let y = convert_percentage_to_number(input)?;
959          input.expect_comma()?;
960          let z = convert_percentage_to_number(input)?;
961          Ok(Transform::Scale3d(x, y, z))
962        },
963        "rotate" => {
964          let angle = Angle::parse_with_unitless_zero(input)?;
965          Ok(Transform::Rotate(angle))
966        },
967        "rotatex" => {
968          let angle = Angle::parse_with_unitless_zero(input)?;
969          Ok(Transform::RotateX(angle))
970        },
971        "rotatey" => {
972          let angle = Angle::parse_with_unitless_zero(input)?;
973          Ok(Transform::RotateY(angle))
974        },
975        "rotatez" => {
976          let angle = Angle::parse_with_unitless_zero(input)?;
977          Ok(Transform::RotateZ(angle))
978        },
979        "rotate3d" => {
980          let x = f32::parse(input)?;
981          input.expect_comma()?;
982          let y = f32::parse(input)?;
983          input.expect_comma()?;
984          let z = f32::parse(input)?;
985          input.expect_comma()?;
986          let angle = Angle::parse_with_unitless_zero(input)?;
987          Ok(Transform::Rotate3d(x, y, z, angle))
988        },
989        "skew" => {
990          let x = Angle::parse_with_unitless_zero(input)?;
991          if input.try_parse(|input| input.expect_comma()).is_ok() {
992            let y = Angle::parse_with_unitless_zero(input)?;
993            Ok(Transform::Skew(x, y))
994          } else {
995            Ok(Transform::Skew(x, Angle::Deg(0.0)))
996          }
997        },
998        "skewx" => {
999          let angle = Angle::parse_with_unitless_zero(input)?;
1000          Ok(Transform::SkewX(angle))
1001        },
1002        "skewy" => {
1003          let angle = Angle::parse_with_unitless_zero(input)?;
1004          Ok(Transform::SkewY(angle))
1005        },
1006        "perspective" => {
1007          let len = NonNegative::<Length>::parse(input)?;
1008          Ok(Transform::Perspective(len))
1009        },
1010        _ => Err(location.new_unexpected_token_error(
1011          cssparser::Token::Ident(function.clone())
1012        ))
1013      }
1014    })
1015  }
1016}
1017
1018impl ToCss for Transform {
1019  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1020    use Transform::*;
1021    match self {
1022      Translate(x, y) => {
1023        if dest.options().minify && x.is_zero() && !y.is_zero() {
1024          dest.write_str("translateY(")?;
1025          y.to_css(dest)?
1026        } else {
1027          dest.write_str("translate(")?;
1028          x.to_css(dest)?;
1029          if !y.is_zero() {
1030            dest.delim(',', false)?;
1031            y.to_css(dest)?;
1032          }
1033        }
1034        dest.write_char(')')?;
1035        Ok(())
1036      }
1037      TranslateX(x) => {
1038        dest.write_str(if dest.options().minify {
1039          "translate("
1040        } else {
1041          "translateX("
1042        })?;
1043        x.to_css(dest)?;
1044        dest.write_char(')')?;
1045        Ok(())
1046      }
1047      TranslateY(y) => {
1048        dest.write_str("translateY(")?;
1049        y.to_css(dest)?;
1050        dest.write_char(')')?;
1051        Ok(())
1052      }
1053      TranslateZ(z) => {
1054        dest.write_str("translateZ(")?;
1055        z.to_css(dest)?;
1056        dest.write_char(')')?;
1057        Ok(())
1058      }
1059      Translate3d(x, y, z) => {
1060        if dest.options().minify && y.is_zero() && z.is_zero() {
1061          dest.write_str("translate(")?;
1062          x.to_css(dest)?;
1063        } else if dest.options().minify && x.is_zero() && !y.is_zero() && z.is_zero() {
1064          dest.write_str("translateY(")?;
1065          y.to_css(dest)?;
1066        } else if dest.options().minify && x.is_zero() && y.is_zero() && !z.is_zero() {
1067          dest.write_str("translateZ(")?;
1068          z.to_css(dest)?;
1069        } else if dest.options().minify && z.is_zero() {
1070          dest.write_str("translate(")?;
1071          x.to_css(dest)?;
1072          dest.delim(',', false)?;
1073          y.to_css(dest)?;
1074        } else {
1075          dest.write_str("translate3d(")?;
1076          x.to_css(dest)?;
1077          dest.delim(',', false)?;
1078          y.to_css(dest)?;
1079          dest.delim(',', false)?;
1080          z.to_css(dest)?;
1081        }
1082        dest.write_char(')')?;
1083        Ok(())
1084      }
1085      Scale(x, y) => {
1086        let x: f32 = x.into();
1087        let y: f32 = y.into();
1088        if dest.options().minify && x == 1.0 && y != 1.0 {
1089          dest.write_str("scaleY(")?;
1090          y.to_css(dest)?;
1091        } else if dest.options().minify && x != 1.0 && y == 1.0 {
1092          dest.write_str("scaleX(")?;
1093          x.to_css(dest)?;
1094        } else {
1095          dest.write_str("scale(")?;
1096          x.to_css(dest)?;
1097          if y != x {
1098            dest.delim(',', false)?;
1099            y.to_css(dest)?;
1100          }
1101        }
1102        dest.write_char(')')?;
1103        Ok(())
1104      }
1105      ScaleX(x) => {
1106        let x: f32 = x.into();
1107        dest.write_str("scaleX(")?;
1108        x.to_css(dest)?;
1109        dest.write_char(')')?;
1110        Ok(())
1111      }
1112      ScaleY(y) => {
1113        let y: f32 = y.into();
1114        dest.write_str("scaleY(")?;
1115        y.to_css(dest)?;
1116        dest.write_char(')')?;
1117        Ok(())
1118      }
1119      ScaleZ(z) => {
1120        let z: f32 = z.into();
1121        dest.write_str("scaleZ(")?;
1122        z.to_css(dest)?;
1123        dest.write_char(')')?;
1124        Ok(())
1125      }
1126      Scale3d(x, y, z) => {
1127        let x: f32 = x.into();
1128        let y: f32 = y.into();
1129        let z: f32 = z.into();
1130        if dest.options().minify && z == 1.0 && x == y {
1131          // scale3d(x, x, 1) => scale(x)
1132          dest.write_str("scale(")?;
1133          x.to_css(dest)?;
1134        } else if dest.options().minify && x != 1.0 && y == 1.0 && z == 1.0 {
1135          // scale3d(x, 1, 1) => scaleX(x)
1136          dest.write_str("scaleX(")?;
1137          x.to_css(dest)?;
1138        } else if dest.options().minify && x == 1.0 && y != 1.0 && z == 1.0 {
1139          // scale3d(1, y, 1) => scaleY(y)
1140          dest.write_str("scaleY(")?;
1141          y.to_css(dest)?;
1142        } else if dest.options().minify && x == 1.0 && y == 1.0 && z != 1.0 {
1143          // scale3d(1, 1, z) => scaleZ(z)
1144          dest.write_str("scaleZ(")?;
1145          z.to_css(dest)?;
1146        } else if dest.options().minify && z == 1.0 {
1147          // scale3d(x, y, 1) => scale(x, y)
1148          dest.write_str("scale(")?;
1149          x.to_css(dest)?;
1150          dest.delim(',', false)?;
1151          y.to_css(dest)?;
1152        } else {
1153          dest.write_str("scale3d(")?;
1154          x.to_css(dest)?;
1155          dest.delim(',', false)?;
1156          y.to_css(dest)?;
1157          dest.delim(',', false)?;
1158          z.to_css(dest)?;
1159        }
1160        dest.write_char(')')?;
1161        Ok(())
1162      }
1163      Rotate(angle) => {
1164        dest.write_str("rotate(")?;
1165        angle.to_css_with_unitless_zero(dest)?;
1166        dest.write_char(')')?;
1167        Ok(())
1168      }
1169      RotateX(angle) => {
1170        dest.write_str("rotateX(")?;
1171        angle.to_css_with_unitless_zero(dest)?;
1172        dest.write_char(')')?;
1173        Ok(())
1174      }
1175      RotateY(angle) => {
1176        dest.write_str("rotateY(")?;
1177        angle.to_css_with_unitless_zero(dest)?;
1178        dest.write_char(')')?;
1179        Ok(())
1180      }
1181      RotateZ(angle) => {
1182        dest.write_str(if dest.options().minify { "rotate(" } else { "rotateZ(" })?;
1183        angle.to_css_with_unitless_zero(dest)?;
1184        dest.write_char(')')?;
1185        Ok(())
1186      }
1187      Rotate3d(x, y, z, angle) => {
1188        if dest.options().minify && *x == 1.0 && *y == 0.0 && *z == 0.0 {
1189          // rotate3d(1, 0, 0, a) => rotateX(a)
1190          dest.write_str("rotateX(")?;
1191          angle.to_css_with_unitless_zero(dest)?;
1192        } else if dest.options().minify && *x == 0.0 && *y == 1.0 && *z == 0.0 {
1193          // rotate3d(0, 1, 0, a) => rotateY(a)
1194          dest.write_str("rotateY(")?;
1195          angle.to_css_with_unitless_zero(dest)?;
1196        } else if dest.options().minify && *x == 0.0 && *y == 0.0 && *z == 1.0 {
1197          // rotate3d(0, 0, 1, a) => rotate(a)
1198          dest.write_str("rotate(")?;
1199          angle.to_css_with_unitless_zero(dest)?;
1200        } else {
1201          dest.write_str("rotate3d(")?;
1202          x.to_css(dest)?;
1203          dest.delim(',', false)?;
1204          y.to_css(dest)?;
1205          dest.delim(',', false)?;
1206          z.to_css(dest)?;
1207          dest.delim(',', false)?;
1208          angle.to_css_with_unitless_zero(dest)?;
1209        }
1210        dest.write_char(')')?;
1211        Ok(())
1212      }
1213      Skew(x, y) => {
1214        if dest.options().minify && x.is_zero() && !y.is_zero() {
1215          dest.write_str("skewY(")?;
1216          y.to_css_with_unitless_zero(dest)?
1217        } else {
1218          dest.write_str("skew(")?;
1219          x.to_css(dest)?;
1220          if !y.is_zero() {
1221            dest.delim(',', false)?;
1222            y.to_css_with_unitless_zero(dest)?;
1223          }
1224        }
1225        dest.write_char(')')?;
1226        Ok(())
1227      }
1228      SkewX(angle) => {
1229        dest.write_str(if dest.options().minify { "skew(" } else { "skewX(" })?;
1230        angle.to_css_with_unitless_zero(dest)?;
1231        dest.write_char(')')?;
1232        Ok(())
1233      }
1234      SkewY(angle) => {
1235        dest.write_str("skewY(")?;
1236        angle.to_css_with_unitless_zero(dest)?;
1237        dest.write_char(')')?;
1238        Ok(())
1239      }
1240      Perspective(len) => {
1241        dest.write_str("perspective(")?;
1242        len.to_css(dest)?;
1243        dest.write_char(')')?;
1244        Ok(())
1245      }
1246      Matrix(super::transform::Matrix { a, b, c, d, e, f }) => {
1247        dest.write_str("matrix(")?;
1248        a.to_css(dest)?;
1249        dest.delim(',', false)?;
1250        b.to_css(dest)?;
1251        dest.delim(',', false)?;
1252        c.to_css(dest)?;
1253        dest.delim(',', false)?;
1254        d.to_css(dest)?;
1255        dest.delim(',', false)?;
1256        e.to_css(dest)?;
1257        dest.delim(',', false)?;
1258        f.to_css(dest)?;
1259        dest.write_char(')')?;
1260        Ok(())
1261      }
1262      Matrix3d(super::transform::Matrix3d {
1263        m11,
1264        m12,
1265        m13,
1266        m14,
1267        m21,
1268        m22,
1269        m23,
1270        m24,
1271        m31,
1272        m32,
1273        m33,
1274        m34,
1275        m41,
1276        m42,
1277        m43,
1278        m44,
1279      }) => {
1280        dest.write_str("matrix3d(")?;
1281        m11.to_css(dest)?;
1282        dest.delim(',', false)?;
1283        m12.to_css(dest)?;
1284        dest.delim(',', false)?;
1285        m13.to_css(dest)?;
1286        dest.delim(',', false)?;
1287        m14.to_css(dest)?;
1288        dest.delim(',', false)?;
1289        m21.to_css(dest)?;
1290        dest.delim(',', false)?;
1291        m22.to_css(dest)?;
1292        dest.delim(',', false)?;
1293        m23.to_css(dest)?;
1294        dest.delim(',', false)?;
1295        m24.to_css(dest)?;
1296        dest.delim(',', false)?;
1297        m31.to_css(dest)?;
1298        dest.delim(',', false)?;
1299        m32.to_css(dest)?;
1300        dest.delim(',', false)?;
1301        m33.to_css(dest)?;
1302        dest.delim(',', false)?;
1303        m34.to_css(dest)?;
1304        dest.delim(',', false)?;
1305        m41.to_css(dest)?;
1306        dest.delim(',', false)?;
1307        m42.to_css(dest)?;
1308        dest.delim(',', false)?;
1309        m43.to_css(dest)?;
1310        dest.delim(',', false)?;
1311        m44.to_css(dest)?;
1312        dest.write_char(')')?;
1313        Ok(())
1314      }
1315    }
1316  }
1317}
1318
1319impl Transform {
1320  /// Converts the transform to a 3D matrix.
1321  pub fn to_matrix(&self) -> Option<Matrix3d<f32>> {
1322    macro_rules! to_radians {
1323      ($angle: ident) => {{
1324        // If the angle is negative or more than a full circle, we cannot
1325        // safely convert to a matrix. Transforms are interpolated numerically
1326        // when types match, and this will have different results than
1327        // when interpolating matrices with large angles.
1328        // https://www.w3.org/TR/css-transforms-1/#matrix-interpolation
1329        let rad = $angle.to_radians();
1330        if rad < 0.0 || rad >= 2.0 * PI {
1331          return None;
1332        }
1333
1334        rad
1335      }};
1336    }
1337
1338    match &self {
1339      Transform::Translate(LengthPercentage::Dimension(x), LengthPercentage::Dimension(y)) => {
1340        if let (Some(x), Some(y)) = (x.to_px(), y.to_px()) {
1341          return Some(Matrix3d::translate(x, y, 0.0));
1342        }
1343      }
1344      Transform::TranslateX(LengthPercentage::Dimension(x)) => {
1345        if let Some(x) = x.to_px() {
1346          return Some(Matrix3d::translate(x, 0.0, 0.0));
1347        }
1348      }
1349      Transform::TranslateY(LengthPercentage::Dimension(y)) => {
1350        if let Some(y) = y.to_px() {
1351          return Some(Matrix3d::translate(0.0, y, 0.0));
1352        }
1353      }
1354      Transform::TranslateZ(z) => {
1355        if let Some(z) = z.to_px() {
1356          return Some(Matrix3d::translate(0.0, 0.0, z));
1357        }
1358      }
1359      Transform::Translate3d(LengthPercentage::Dimension(x), LengthPercentage::Dimension(y), z) => {
1360        if let (Some(x), Some(y), Some(z)) = (x.to_px(), y.to_px(), z.to_px()) {
1361          return Some(Matrix3d::translate(x, y, z));
1362        }
1363      }
1364      Transform::Scale(x, y) => return Some(Matrix3d::scale(x.into(), y.into(), 1.0)),
1365      Transform::ScaleX(x) => return Some(Matrix3d::scale(x.into(), 1.0, 1.0)),
1366      Transform::ScaleY(y) => return Some(Matrix3d::scale(1.0, y.into(), 1.0)),
1367      Transform::ScaleZ(z) => return Some(Matrix3d::scale(1.0, 1.0, z.into())),
1368      Transform::Scale3d(x, y, z) => return Some(Matrix3d::scale(x.into(), y.into(), z.into())),
1369      Transform::Rotate(angle) | Transform::RotateZ(angle) => {
1370        return Some(Matrix3d::rotate(0.0, 0.0, 1.0, to_radians!(angle)))
1371      }
1372      Transform::RotateX(angle) => return Some(Matrix3d::rotate(1.0, 0.0, 0.0, to_radians!(angle))),
1373      Transform::RotateY(angle) => return Some(Matrix3d::rotate(0.0, 1.0, 0.0, to_radians!(angle))),
1374      Transform::Rotate3d(x, y, z, angle) => return Some(Matrix3d::rotate(*x, *y, *z, to_radians!(angle))),
1375      Transform::Skew(x, y) => return Some(Matrix3d::skew(to_radians!(x), to_radians!(y))),
1376      Transform::SkewX(x) => return Some(Matrix3d::skew(to_radians!(x), 0.0)),
1377      Transform::SkewY(y) => return Some(Matrix3d::skew(0.0, to_radians!(y))),
1378      Transform::Perspective(len) => {
1379        if let Some(len) = len.0.to_px() {
1380          return Some(Matrix3d::perspective(len));
1381        }
1382      }
1383      Transform::Matrix(m) => return Some(m.to_matrix3d()),
1384      Transform::Matrix3d(m) => return Some(m.clone()),
1385      _ => {}
1386    }
1387    None
1388  }
1389}
1390
1391enum_property! {
1392  /// A value for the [transform-style](https://drafts.csswg.org/css-transforms-2/#transform-style-property) property.
1393  #[allow(missing_docs)]
1394  pub enum TransformStyle {
1395    Flat,
1396    Preserve3d,
1397  }
1398}
1399
1400enum_property! {
1401  /// A value for the [transform-box](https://drafts.csswg.org/css-transforms-1/#transform-box) property.
1402  pub enum TransformBox {
1403    /// Uses the content box as reference box.
1404    ContentBox,
1405    /// Uses the border box as reference box.
1406    BorderBox,
1407    /// Uses the object bounding box as reference box.
1408    FillBox,
1409    /// Uses the stroke bounding box as reference box.
1410    StrokeBox,
1411    /// Uses the nearest SVG viewport as reference box.
1412    ViewBox,
1413  }
1414}
1415
1416enum_property! {
1417  /// A value for the [backface-visibility](https://drafts.csswg.org/css-transforms-2/#backface-visibility-property) property.
1418  #[allow(missing_docs)]
1419  pub enum BackfaceVisibility {
1420    Visible,
1421    Hidden,
1422  }
1423}
1424
1425/// A value for the [perspective](https://drafts.csswg.org/css-transforms-2/#perspective-property) property.
1426#[derive(Debug, Clone, PartialEq, Parse, ToCss)]
1427#[cfg_attr(feature = "visitor", derive(Visit))]
1428#[cfg_attr(
1429  feature = "serde",
1430  derive(serde::Serialize, serde::Deserialize),
1431  serde(tag = "type", content = "value", rename_all = "kebab-case")
1432)]
1433#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1434#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1435pub enum Perspective {
1436  /// No perspective transform is applied.
1437  None,
1438  /// Distance to the center of projection.
1439  Length(NonNegative<Length>),
1440}
1441
1442/// A value for the [translate](https://drafts.csswg.org/css-transforms-2/#propdef-translate) property.
1443#[derive(Debug, Clone, PartialEq)]
1444#[cfg_attr(feature = "visitor", derive(Visit))]
1445#[cfg_attr(
1446  feature = "serde",
1447  derive(serde::Serialize, serde::Deserialize),
1448  serde(rename_all = "lowercase")
1449)]
1450#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1451#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1452pub enum Translate {
1453  /// The "none" keyword.
1454  None,
1455
1456  /// The x, y, and z translations.
1457  #[cfg_attr(feature = "serde", serde(untagged))]
1458  XYZ {
1459    /// The x translation.
1460    x: LengthPercentage,
1461    /// The y translation.
1462    y: LengthPercentage,
1463    /// The z translation.
1464    z: Length,
1465  },
1466}
1467
1468impl<'i> Parse<'i> for Translate {
1469  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
1470    if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
1471      return Ok(Translate::None);
1472    }
1473
1474    let x = LengthPercentage::parse(input)?;
1475    let y = input.try_parse(LengthPercentage::parse);
1476    let z = if y.is_ok() {
1477      input.try_parse(Length::parse).ok()
1478    } else {
1479      None
1480    };
1481
1482    Ok(Translate::XYZ {
1483      x,
1484      y: y.unwrap_or(LengthPercentage::zero()),
1485      z: z.unwrap_or(Length::zero()),
1486    })
1487  }
1488}
1489
1490impl ToCss for Translate {
1491  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1492    match self {
1493      Translate::None => {
1494        dest.write_str("none")?;
1495      }
1496      Translate::XYZ { x, y, z } => {
1497        x.to_css(dest)?;
1498        if !y.is_zero() || !z.is_zero() {
1499          dest.write_char(' ')?;
1500          y.to_css(dest)?;
1501          if !z.is_zero() {
1502            dest.write_char(' ')?;
1503            z.to_css(dest)?;
1504          }
1505        }
1506      }
1507    };
1508
1509    Ok(())
1510  }
1511}
1512
1513impl Translate {
1514  /// Converts the translation to a transform function.
1515  pub fn to_transform(&self) -> Transform {
1516    match self {
1517      Translate::None => {
1518        Transform::Translate3d(LengthPercentage::zero(), LengthPercentage::zero(), Length::zero())
1519      }
1520      Translate::XYZ { x, y, z } => Transform::Translate3d(x.clone(), y.clone(), z.clone()),
1521    }
1522  }
1523}
1524
1525/// A value for the [rotate](https://drafts.csswg.org/css-transforms-2/#propdef-rotate) property.
1526#[derive(Debug, Clone, PartialEq)]
1527#[cfg_attr(feature = "visitor", derive(Visit))]
1528#[cfg_attr(
1529  feature = "serde",
1530  derive(serde::Serialize, serde::Deserialize),
1531  serde(rename_all = "lowercase")
1532)]
1533#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1534#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1535pub enum Rotate {
1536  /// The `none` keyword.
1537  None,
1538
1539  /// Rotation on the x, y, and z axes.
1540  #[cfg_attr(feature = "serde", serde(untagged))]
1541  XYZ {
1542    /// Rotation around the x axis.
1543    x: f32,
1544    /// Rotation around the y axis.
1545    y: f32,
1546    /// Rotation around the z axis.
1547    z: f32,
1548    /// The angle of rotation.
1549    angle: Angle,
1550  },
1551}
1552
1553impl<'i> Parse<'i> for Rotate {
1554  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
1555    // CSS Transforms 2 §5.1:
1556    // "It must serialize as the keyword none if and only if none was originally specified."
1557    // Keep `none` explicit so identity rotations (e.g. `0deg`) do not round-trip to `none`.
1558    // https://drafts.csswg.org/css-transforms-2/#individual-transforms
1559    if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
1560      return Ok(Rotate::None);
1561    }
1562
1563    let angle = input.try_parse(Angle::parse);
1564    let (x, y, z) = input
1565      .try_parse(|input| {
1566        let location = input.current_source_location();
1567        let ident = input.expect_ident()?;
1568        match_ignore_ascii_case! { &*ident,
1569          "x" => Ok((1.0, 0.0, 0.0)),
1570          "y" => Ok((0.0, 1.0, 0.0)),
1571          "z" => Ok((0.0, 0.0, 1.0)),
1572          _ => Err(location.new_unexpected_token_error(
1573            cssparser::Token::Ident(ident.clone())
1574          ))
1575        }
1576      })
1577      .or_else(
1578        |_: ParseError<'i, ParserError<'i>>| -> Result<_, ParseError<'i, ParserError<'i>>> {
1579          input.try_parse(|input| Ok((f32::parse(input)?, f32::parse(input)?, f32::parse(input)?)))
1580        },
1581      )
1582      .unwrap_or((0.0, 0.0, 1.0));
1583    let angle = angle.or_else(|_| Angle::parse(input))?;
1584    Ok(Rotate::XYZ { x, y, z, angle })
1585  }
1586}
1587
1588impl ToCss for Rotate {
1589  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1590    match self {
1591      Rotate::None => {
1592        dest.write_str("none")?;
1593        Ok(())
1594      }
1595      Rotate::XYZ { x, y, z, angle } => {
1596        // CSS Transforms 2 §5.1:
1597        // "If the axis is parallel with the x or y axes, it must serialize as the appropriate keyword."
1598        // "If a rotation about the z axis ... must serialize as just an <angle>."
1599        // Normalize parallel vectors (including non-unit vectors); flip the angle for negative axis directions.
1600        // https://drafts.csswg.org/css-transforms-2/#individual-transforms
1601        if *y == 0.0 && *z == 0.0 && *x != 0.0 {
1602          let angle = if *x < 0.0 { angle.clone() * -1.0 } else { angle.clone() };
1603          dest.write_str("x ")?;
1604          angle.to_css(dest)
1605        } else if *x == 0.0 && *z == 0.0 && *y != 0.0 {
1606          let angle = if *y < 0.0 { angle.clone() * -1.0 } else { angle.clone() };
1607          dest.write_str("y ")?;
1608          angle.to_css(dest)
1609        } else if *x == 0.0 && *y == 0.0 && *z != 0.0 {
1610          let angle = if *z < 0.0 { angle.clone() * -1.0 } else { angle.clone() };
1611          angle.to_css(dest)
1612        } else {
1613          x.to_css(dest)?;
1614          dest.write_char(' ')?;
1615          y.to_css(dest)?;
1616          dest.write_char(' ')?;
1617          z.to_css(dest)?;
1618          dest.write_char(' ')?;
1619          angle.to_css(dest)
1620        }
1621      }
1622    }
1623  }
1624}
1625
1626impl Rotate {
1627  /// Converts the rotation to a transform function.
1628  pub fn to_transform(&self) -> Transform {
1629    match self {
1630      Rotate::None => Transform::Rotate3d(0.0, 0.0, 1.0, Angle::Deg(0.0)),
1631      Rotate::XYZ { x, y, z, angle } => Transform::Rotate3d(*x, *y, *z, angle.clone()),
1632    }
1633  }
1634}
1635
1636/// A value for the [scale](https://drafts.csswg.org/css-transforms-2/#propdef-scale) property.
1637#[derive(Debug, Clone, PartialEq)]
1638#[cfg_attr(feature = "visitor", derive(Visit))]
1639#[cfg_attr(
1640  feature = "serde",
1641  derive(serde::Serialize, serde::Deserialize),
1642  serde(rename_all = "lowercase")
1643)]
1644#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
1645#[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
1646pub enum Scale {
1647  /// The "none" keyword.
1648  None,
1649
1650  /// Scale on the x, y, and z axis.
1651  #[cfg_attr(feature = "serde", serde(untagged))]
1652  XYZ {
1653    /// Scale on the x axis.
1654    x: NumberOrPercentage,
1655    /// Scale on the y axis.
1656    y: NumberOrPercentage,
1657    /// Scale on the z axis.
1658    z: NumberOrPercentage,
1659  },
1660}
1661
1662fn convert_percentage_to_number<'i, 't>(
1663  input: &mut Parser<'i, 't>,
1664) -> Result<NumberOrPercentage, ParseError<'i, ParserError<'i>>> {
1665  Ok(match NumberOrPercentage::parse(input)? {
1666    NumberOrPercentage::Number(number) => NumberOrPercentage::Number(number),
1667    NumberOrPercentage::Percentage(percent) => NumberOrPercentage::Number(percent.0),
1668  })
1669}
1670
1671impl<'i> Parse<'i> for Scale {
1672  fn parse<'t>(input: &mut Parser<'i, 't>) -> Result<Self, ParseError<'i, ParserError<'i>>> {
1673    if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
1674      return Ok(Scale::None);
1675    }
1676
1677    let x = convert_percentage_to_number(input)?;
1678    let y = input.try_parse(convert_percentage_to_number);
1679    let z = if y.is_ok() {
1680      input.try_parse(convert_percentage_to_number).ok()
1681    } else {
1682      None
1683    };
1684
1685    Ok(Scale::XYZ {
1686      x: x.clone(),
1687      y: y.unwrap_or(x),
1688      z: z.unwrap_or(NumberOrPercentage::Number(1.0)),
1689    })
1690  }
1691}
1692
1693impl ToCss for Scale {
1694  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, dest: &mut PrinterT) -> Result<(), PrinterError> {
1695    match self {
1696      Scale::None => {
1697        dest.write_str("none")?;
1698      }
1699      Scale::XYZ { x, y, z } => {
1700        let x: f32 = x.into();
1701        let y: f32 = y.into();
1702        let z: f32 = z.into();
1703        x.to_css(dest)?;
1704        if y != x || z != 1.0 {
1705          dest.write_char(' ')?;
1706          y.to_css(dest)?;
1707          if z != 1.0 {
1708            dest.write_char(' ')?;
1709            z.to_css(dest)?;
1710          }
1711        }
1712      }
1713    }
1714
1715    Ok(())
1716  }
1717}
1718
1719impl Scale {
1720  /// Converts the scale to a transform function.
1721  pub fn to_transform(&self) -> Transform {
1722    match self {
1723      Scale::None => Transform::Scale3d(
1724        NumberOrPercentage::Number(1.0),
1725        NumberOrPercentage::Number(1.0),
1726        NumberOrPercentage::Number(1.0),
1727      ),
1728      Scale::XYZ { x, y, z } => Transform::Scale3d(x.clone(), y.clone(), z.clone()),
1729    }
1730  }
1731}
1732
1733#[derive(Default)]
1734pub(crate) struct TransformHandler {
1735  transform: Option<(TransformList, VendorPrefix)>,
1736  translate: Option<Translate>,
1737  rotate: Option<Rotate>,
1738  scale: Option<Scale>,
1739  has_any: bool,
1740}
1741
1742impl<'i> PropertyHandler<'i> for TransformHandler {
1743  fn handle_property(
1744    &mut self,
1745    property: &Property<'i>,
1746    dest: &mut DeclarationList<'i>,
1747    context: &mut PropertyHandlerContext<'i, '_>,
1748  ) -> bool {
1749    use Property::*;
1750
1751    macro_rules! individual_property {
1752      ($prop: ident, $val: ident) => {{
1753        // Individual transforms cascade independently of `transform`. Keep them
1754        // separate so declaration order cannot change their composition or resets.
1755        self.$prop = Some($val.clone());
1756        self.has_any = true;
1757      }};
1758    }
1759
1760    match property {
1761      Transform(val, vp) => {
1762        // If two vendor prefixes for the same property have different
1763        // values, we need to flush what we have immediately to preserve order.
1764        if let Some((cur, prefixes)) = &self.transform {
1765          if cur != val && !prefixes.contains(*vp) {
1766            self.flush(dest, context);
1767          }
1768        }
1769
1770        // Otherwise, update the value and add the prefix.
1771        if let Some((transform, prefixes)) = &mut self.transform {
1772          *transform = val.clone();
1773          *prefixes |= *vp;
1774        } else {
1775          self.transform = Some((val.clone(), *vp));
1776          self.has_any = true;
1777        }
1778      }
1779      Translate(val) => individual_property!(translate, val),
1780      Rotate(val) => individual_property!(rotate, val),
1781      Scale(val) => individual_property!(scale, val),
1782      Unparsed(val)
1783        if matches!(
1784          val.property_id,
1785          PropertyId::Transform(_) | PropertyId::Translate | PropertyId::Rotate | PropertyId::Scale
1786        ) =>
1787      {
1788        self.flush(dest, context);
1789        let prop = if matches!(val.property_id, PropertyId::Transform(_)) {
1790          Property::Unparsed(val.get_prefixed(context.targets, Feature::Transform))
1791        } else {
1792          property.clone()
1793        };
1794        dest.push(prop)
1795      }
1796      _ => return false,
1797    }
1798
1799    true
1800  }
1801
1802  fn finalize(&mut self, dest: &mut DeclarationList<'i>, context: &mut PropertyHandlerContext<'i, '_>) {
1803    self.flush(dest, context);
1804  }
1805}
1806
1807impl TransformHandler {
1808  fn flush<'i>(&mut self, dest: &mut DeclarationList<'i>, context: &mut PropertyHandlerContext<'i, '_>) {
1809    if !self.has_any {
1810      return;
1811    }
1812
1813    self.has_any = false;
1814
1815    let transform = std::mem::take(&mut self.transform);
1816    let translate = std::mem::take(&mut self.translate);
1817    let rotate = std::mem::take(&mut self.rotate);
1818    let scale = std::mem::take(&mut self.scale);
1819
1820    if let Some((transform, prefix)) = transform {
1821      let prefix = context.targets.prefixes(prefix, Feature::Transform);
1822      dest.push(Property::Transform(transform, prefix))
1823    }
1824
1825    if let Some(translate) = translate {
1826      dest.push(Property::Translate(translate))
1827    }
1828
1829    if let Some(rotate) = rotate {
1830      dest.push(Property::Rotate(rotate))
1831    }
1832
1833    if let Some(scale) = scale {
1834      dest.push(Property::Scale(scale))
1835    }
1836  }
1837}