Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

16.7 KB
Raw Blame
pub const DOM_MATRIX_COMPONENT_COUNT: usize = 16;

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct DomMatrixComponents {
    pub m11: f64,
    pub m12: f64,
    pub m13: f64,
    pub m14: f64,
    pub m21: f64,
    pub m22: f64,
    pub m23: f64,
    pub m24: f64,
    pub m31: f64,
    pub m32: f64,
    pub m33: f64,
    pub m34: f64,
    pub m41: f64,
    pub m42: f64,
    pub m43: f64,
    pub m44: f64,
}

impl DomMatrixComponents {
    pub fn identity() -> Self {
        Self {
            m11: 1.0,
            m12: 0.0,
            m13: 0.0,
            m14: 0.0,
            m21: 0.0,
            m22: 1.0,
            m23: 0.0,
            m24: 0.0,
            m31: 0.0,
            m32: 0.0,
            m33: 1.0,
            m34: 0.0,
            m41: 0.0,
            m42: 0.0,
            m43: 0.0,
            m44: 1.0,
        }
    }

    pub fn nan() -> Self {
        let nan = f64::NAN;
        Self {
            m11: nan,
            m12: nan,
            m13: nan,
            m14: nan,
            m21: nan,
            m22: nan,
            m23: nan,
            m24: nan,
            m31: nan,
            m32: nan,
            m33: nan,
            m34: nan,
            m41: nan,
            m42: nan,
            m43: nan,
            m44: nan,
        }
    }

    pub fn rotation(cos: f64, sin: f64) -> Self {
        Self {
            m11: cos,
            m12: sin,
            m21: -sin,
            m22: cos,
            ..Self::identity()
        }
    }

    pub fn rotation_axis_angle(x: f64, y: f64, z: f64, degrees: f64) -> Self {
        let length = (x * x + y * y + z * z).sqrt();
        if length == 0.0 {
            return Self::identity();
        }

        let x = x / length;
        let y = y / length;
        let z = z / length;
        let radians = degrees.to_radians();
        let cos = radians.cos();
        let sin = radians.sin();
        let one_minus_cos = 1.0 - cos;

        Self {
            m11: one_minus_cos * x * x + cos,
            m12: one_minus_cos * x * y + sin * z,
            m13: one_minus_cos * x * z - sin * y,
            m21: one_minus_cos * x * y - sin * z,
            m22: one_minus_cos * y * y + cos,
            m23: one_minus_cos * y * z + sin * x,
            m31: one_minus_cos * x * z + sin * y,
            m32: one_minus_cos * y * z - sin * x,
            m33: one_minus_cos * z * z + cos,
            ..Self::identity()
        }
    }

    pub fn perspective(distance: f64) -> Self {
        Self {
            m34: -1.0 / distance,
            ..Self::identity()
        }
    }

    pub fn translation(tx: f64, ty: f64, tz: f64) -> Self {
        Self {
            m41: tx,
            m42: ty,
            m43: tz,
            ..Self::identity()
        }
    }

    pub fn scale(sx: f64, sy: f64, sz: f64) -> Self {
        Self {
            m11: sx,
            m22: sy,
            m33: sz,
            ..Self::identity()
        }
    }

    pub fn skew_x(tan: f64) -> Self {
        Self {
            m21: tan,
            ..Self::identity()
        }
    }

    pub fn skew_y(tan: f64) -> Self {
        Self {
            m12: tan,
            ..Self::identity()
        }
    }

    pub fn multiply(self, other: Self) -> Self {
        Self {
            m11: self.m11 * other.m11
                + self.m21 * other.m12
                + self.m31 * other.m13
                + self.m41 * other.m14,
            m12: self.m12 * other.m11
                + self.m22 * other.m12
                + self.m32 * other.m13
                + self.m42 * other.m14,
            m13: self.m13 * other.m11
                + self.m23 * other.m12
                + self.m33 * other.m13
                + self.m43 * other.m14,
            m14: self.m14 * other.m11
                + self.m24 * other.m12
                + self.m34 * other.m13
                + self.m44 * other.m14,
            m21: self.m11 * other.m21
                + self.m21 * other.m22
                + self.m31 * other.m23
                + self.m41 * other.m24,
            m22: self.m12 * other.m21
                + self.m22 * other.m22
                + self.m32 * other.m23
                + self.m42 * other.m24,
            m23: self.m13 * other.m21
                + self.m23 * other.m22
                + self.m33 * other.m23
                + self.m43 * other.m24,
            m24: self.m14 * other.m21
                + self.m24 * other.m22
                + self.m34 * other.m23
                + self.m44 * other.m24,
            m31: self.m11 * other.m31
                + self.m21 * other.m32
                + self.m31 * other.m33
                + self.m41 * other.m34,
            m32: self.m12 * other.m31
                + self.m22 * other.m32
                + self.m32 * other.m33
                + self.m42 * other.m34,
            m33: self.m13 * other.m31
                + self.m23 * other.m32
                + self.m33 * other.m33
                + self.m43 * other.m34,
            m34: self.m14 * other.m31
                + self.m24 * other.m32
                + self.m34 * other.m33
                + self.m44 * other.m34,
            m41: self.m11 * other.m41
                + self.m21 * other.m42
                + self.m31 * other.m43
                + self.m41 * other.m44,
            m42: self.m12 * other.m41
                + self.m22 * other.m42
                + self.m32 * other.m43
                + self.m42 * other.m44,
            m43: self.m13 * other.m41
                + self.m23 * other.m42
                + self.m33 * other.m43
                + self.m43 * other.m44,
            m44: self.m14 * other.m41
                + self.m24 * other.m42
                + self.m34 * other.m43
                + self.m44 * other.m44,
        }
    }

    pub fn translated(mut self, tx: f64, ty: f64, tz: f64) -> Self {
        self.m41 += self.m11 * tx + self.m21 * ty + self.m31 * tz;
        self.m42 += self.m12 * tx + self.m22 * ty + self.m32 * tz;
        self.m43 += self.m13 * tx + self.m23 * ty + self.m33 * tz;
        self.m44 += self.m14 * tx + self.m24 * ty + self.m34 * tz;
        self
    }

    pub fn scaled_2d(mut self, scale_x: f64, scale_y: f64) -> Self {
        self.m11 *= scale_x;
        self.m12 *= scale_x;
        self.m13 *= scale_x;
        self.m14 *= scale_x;
        self.m21 *= scale_y;
        self.m22 *= scale_y;
        self.m23 *= scale_y;
        self.m24 *= scale_y;
        self
    }

    pub fn scaled_3d(mut self, scale_x: f64, scale_y: f64, scale_z: f64) -> Self {
        self.m11 *= scale_x;
        self.m12 *= scale_x;
        self.m13 *= scale_x;
        self.m14 *= scale_x;
        self.m21 *= scale_y;
        self.m22 *= scale_y;
        self.m23 *= scale_y;
        self.m24 *= scale_y;
        self.m31 *= scale_z;
        self.m32 *= scale_z;
        self.m33 *= scale_z;
        self.m34 *= scale_z;
        self
    }

    pub fn scaled_with_origin(
        mut self,
        scale_x: f64,
        scale_y: f64,
        scale_z: f64,
        origin_x: f64,
        origin_y: f64,
        origin_z: f64,
    ) -> Self {
        let has_origin = origin_x != 0.0 || origin_y != 0.0 || origin_z != 0.0;
        if has_origin {
            self = self.translated(origin_x, origin_y, origin_z);
        }
        self = self.scaled_3d(scale_x, scale_y, scale_z);
        if has_origin {
            self = self.translated(-origin_x, -origin_y, -origin_z);
        }
        self
    }

    pub fn rotated(mut self, rot_x: f64, rot_y: f64, rot_z: f64) -> Self {
        if rot_z != 0.0 {
            self = self.rotated_z(rot_z);
        }
        if rot_y != 0.0 {
            self = self.rotated_axis_angle(0.0, 1.0, 0.0, rot_y);
        }
        if rot_x != 0.0 {
            self = self.rotated_axis_angle(1.0, 0.0, 0.0, rot_x);
        }
        self
    }

    pub fn rotated_z(self, degrees: f64) -> Self {
        let radians = degrees.to_radians();
        self.multiply(Self::rotation(radians.cos(), radians.sin()))
    }

    pub fn rotated_axis_angle(self, x: f64, y: f64, z: f64, degrees: f64) -> Self {
        let length = (x * x + y * y + z * z).sqrt();
        if length == 0.0 {
            return self;
        }
        self.multiply(Self::rotation_axis_angle(x, y, z, degrees))
    }

    pub fn skewed_x(self, degrees: f64) -> Self {
        self.multiply(Self::skew_x(degrees.to_radians().tan()))
    }

    pub fn skewed_y(self, degrees: f64) -> Self {
        self.multiply(Self::skew_y(degrees.to_radians().tan()))
    }

    pub fn inverse(self) -> Self {
        if let Some(inverse) = self.inverse_2d() {
            return inverse;
        }
        if let Some(inverse) = self.affine_inverse() {
            return inverse;
        }

        let mut matrix = [
            [self.m11, self.m21, self.m31, self.m41],
            [self.m12, self.m22, self.m32, self.m42],
            [self.m13, self.m23, self.m33, self.m43],
            [self.m14, self.m24, self.m34, self.m44],
        ];
        let mut inverse = [
            [1.0, 0.0, 0.0, 0.0],
            [0.0, 1.0, 0.0, 0.0],
            [0.0, 0.0, 1.0, 0.0],
            [0.0, 0.0, 0.0, 1.0],
        ];

        for column in 0..4 {
            let Some(pivot_row) = (column..4).max_by(|left, right| {
                matrix[*left][column]
                    .abs()
                    .total_cmp(&matrix[*right][column].abs())
            }) else {
                return Self::nan();
            };
            let pivot = matrix[pivot_row][column];
            if pivot == 0.0 || !pivot.is_finite() {
                return Self::nan();
            }

            matrix.swap(column, pivot_row);
            inverse.swap(column, pivot_row);

            for index in 0..4 {
                matrix[column][index] /= pivot;
                inverse[column][index] /= pivot;
            }

            for row in 0..4 {
                if row == column {
                    continue;
                }
                let factor = matrix[row][column];
                for index in 0..4 {
                    matrix[row][index] -= factor * matrix[column][index];
                    inverse[row][index] -= factor * inverse[column][index];
                }
            }
        }

        if inverse.iter().flatten().any(|value| !value.is_finite()) {
            return Self::nan();
        }

        Self {
            m11: inverse[0][0],
            m21: inverse[0][1],
            m31: inverse[0][2],
            m41: inverse[0][3],
            m12: inverse[1][0],
            m22: inverse[1][1],
            m32: inverse[1][2],
            m42: inverse[1][3],
            m13: inverse[2][0],
            m23: inverse[2][1],
            m33: inverse[2][2],
            m43: inverse[2][3],
            m14: inverse[3][0],
            m24: inverse[3][1],
            m34: inverse[3][2],
            m44: inverse[3][3],
        }
    }

    fn inverse_2d(self) -> Option<Self> {
        if !self.is_2d() {
            return None;
        }

        let determinant = self.m11 * self.m22 - self.m12 * self.m21;
        if determinant == 0.0 || !determinant.is_finite() {
            return None;
        }
        let inverse_determinant = 1.0 / determinant;
        let inverse = Self {
            m11: self.m22 * inverse_determinant,
            m12: -self.m12 * inverse_determinant,
            m21: -self.m21 * inverse_determinant,
            m22: self.m11 * inverse_determinant,
            m41: (self.m21 * self.m42 - self.m22 * self.m41) * inverse_determinant,
            m42: (self.m12 * self.m41 - self.m11 * self.m42) * inverse_determinant,
            ..Self::identity()
        };
        let values = [
            inverse.m11,
            inverse.m12,
            inverse.m21,
            inverse.m22,
            inverse.m41,
            inverse.m42,
        ];

        values
            .iter()
            .all(|value| value.is_finite())
            .then_some(inverse)
    }

    fn affine_inverse(self) -> Option<Self> {
        if self.m14 != 0.0 || self.m24 != 0.0 || self.m34 != 0.0 || self.m44 != 1.0 {
            return None;
        }

        let a = self.m11;
        let b = self.m21;
        let c = self.m31;
        let d = self.m12;
        let e = self.m22;
        let f = self.m32;
        let g = self.m13;
        let h = self.m23;
        let i = self.m33;
        let determinant = a * (e * i - f * h) - b * (d * i - f * g) + c * (d * h - e * g);
        if determinant == 0.0 || !determinant.is_finite() {
            return None;
        }
        let inverse_determinant = 1.0 / determinant;

        let m11 = (e * i - f * h) * inverse_determinant;
        let m21 = (c * h - b * i) * inverse_determinant;
        let m31 = (b * f - c * e) * inverse_determinant;
        let m12 = (f * g - d * i) * inverse_determinant;
        let m22 = (a * i - c * g) * inverse_determinant;
        let m32 = (c * d - a * f) * inverse_determinant;
        let m13 = (d * h - e * g) * inverse_determinant;
        let m23 = (b * g - a * h) * inverse_determinant;
        let m33 = (a * e - b * d) * inverse_determinant;
        let inverse = Self {
            m11,
            m12,
            m13,
            m14: 0.0,
            m21,
            m22,
            m23,
            m24: 0.0,
            m31,
            m32,
            m33,
            m34: 0.0,
            m41: -(m11 * self.m41 + m21 * self.m42 + m31 * self.m43),
            m42: -(m12 * self.m41 + m22 * self.m42 + m32 * self.m43),
            m43: -(m13 * self.m41 + m23 * self.m42 + m33 * self.m43),
            m44: 1.0,
        };
        let values = [
            inverse.m11,
            inverse.m12,
            inverse.m13,
            inverse.m21,
            inverse.m22,
            inverse.m23,
            inverse.m31,
            inverse.m32,
            inverse.m33,
            inverse.m41,
            inverse.m42,
            inverse.m43,
        ];

        values
            .iter()
            .all(|value| value.is_finite())
            .then_some(inverse)
    }

    pub fn is_2d(self) -> bool {
        self.m13 == 0.0
            && self.m14 == 0.0
            && self.m23 == 0.0
            && self.m24 == 0.0
            && self.m31 == 0.0
            && self.m32 == 0.0
            && self.m33 == 1.0
            && self.m34 == 0.0
            && self.m43 == 0.0
            && self.m44 == 1.0
    }

    pub fn is_identity(self) -> bool {
        self == Self::identity()
    }

    pub fn css_text(self) -> Option<String> {
        self.text(css_number)
    }

    pub fn dom_matrix_text(self) -> Option<String> {
        self.text(ecmascript_number)
    }

    fn text(self, serialize_number: fn(f64) -> String) -> Option<String> {
        if self.is_2d() {
            let values = [self.m11, self.m12, self.m21, self.m22, self.m41, self.m42];
            if !values.iter().all(|value| value.is_finite()) {
                return None;
            }
            return Some(format!(
                "matrix({}, {}, {}, {}, {}, {})",
                serialize_number(self.m11),
                serialize_number(self.m12),
                serialize_number(self.m21),
                serialize_number(self.m22),
                serialize_number(self.m41),
                serialize_number(self.m42)
            ));
        }

        let values = [
            self.m11, self.m12, self.m13, self.m14, self.m21, self.m22, self.m23, self.m24,
            self.m31, self.m32, self.m33, self.m34, self.m41, self.m42, self.m43, self.m44,
        ];
        if !values.iter().all(|value| value.is_finite()) {
            return None;
        }
        Some(format!(
            "matrix3d({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {})",
            serialize_number(self.m11),
            serialize_number(self.m12),
            serialize_number(self.m13),
            serialize_number(self.m14),
            serialize_number(self.m21),
            serialize_number(self.m22),
            serialize_number(self.m23),
            serialize_number(self.m24),
            serialize_number(self.m31),
            serialize_number(self.m32),
            serialize_number(self.m33),
            serialize_number(self.m34),
            serialize_number(self.m41),
            serialize_number(self.m42),
            serialize_number(self.m43),
            serialize_number(self.m44)
        ))
    }
}

fn ecmascript_number(value: f64) -> String {
    dragonbox_ecma::Buffer::new()
        .format_finite(value)
        .to_owned()
}

fn css_number(value: f64) -> String {
    if value == 0.0 {
        "0".to_owned()
    } else if value.abs() < 0.000001 {
        trim_fraction_trailing_zeros(format!("{value:.22}"))
    } else {
        value.to_string()
    }
}

fn trim_fraction_trailing_zeros(mut serialized: String) -> String {
    if serialized.contains('.') {
        while serialized.ends_with('0') {
            serialized.pop();
        }
        if serialized.ends_with('.') {
            serialized.pop();
        }
    }
    serialized
}