Skip to content

armgit / moli

Public Imported from GitHub
0

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

27.1 KB
Raw Blame
mod geometry;
mod helpers;
mod length;
mod matrix;
mod path;
mod transform;

pub use geometry::{
    SvgFillRule, SvgGeometryBox, SvgGeometryElement, SvgGeometryPoint, SvgGeometrySegment,
    bounding_box_for_element, bounding_box_for_segments, bounding_box_for_transformed_element,
    is_point_in_fill, is_point_in_fill_with_rule, point_at_length, segments_for_element,
};
pub use length::{
    SvgLength, SvgLengthUnit, parse_length, parse_length_list, parse_number, parse_number_list,
    parse_point_list,
};
pub use matrix::{SvgMatrixComponents, serialize_number};
pub use transform::{
    SvgTransform, SvgTransformKind, consolidate_transform_matrices, parse_transform_attribute,
    serialize_transform_list,
};

#[cfg(test)]
mod tests {
    use crate::{
        SvgGeometryElement, SvgGeometryPoint, SvgGeometrySegment, SvgLengthUnit,
        SvgMatrixComponents, SvgTransform, SvgTransformKind, bounding_box_for_element,
        bounding_box_for_segments, bounding_box_for_transformed_element,
        consolidate_transform_matrices, is_point_in_fill, parse_length, parse_length_list,
        parse_number, parse_number_list, parse_point_list, parse_transform_attribute,
        point_at_length, segments_for_element, serialize_number, serialize_transform_list,
    };

    #[test]
    fn length_units_are_ascii_case_insensitive_in_scalars_and_lists() {
        assert_eq!(parse_length(" 1pX ").unwrap().serialize(), "1px");
        assert_eq!(parse_length("2EM").unwrap().unit, crate::SvgLengthUnit::Ems);
        let values = parse_length_list("1pX, 2EM 3cM").unwrap();
        assert_eq!(
            values
                .iter()
                .map(|value| value.serialize())
                .collect::<Vec<_>>(),
            ["1px", "2em", "3cm"]
        );
        assert!(parse_length("1PXjunk").is_none());
        assert!(parse_length_list("1PX 2not-a-unit").is_none());
    }

    fn path_segments(raw: &str) -> Vec<SvgGeometrySegment> {
        segments_for_element(SvgGeometryElement::Path { d: raw.to_owned() })
    }

    #[test]
    fn svg_transform_serialization_preserves_function_and_rotation_center() {
        for value in [
            SvgTransform::matrix(SvgMatrixComponents {
                a: 2.0,
                b: 3.0,
                c: 4.0,
                d: 5.0,
                e: 1e20,
                f: -1e20,
            }),
            SvgTransform::translate(0.1, 1e20),
            SvgTransform::scale(2.5, 3.5),
            SvgTransform::rotate(0.0, 13.0, 17.0),
            SvgTransform::rotate(90.0, 13.0, 17.0),
            SvgTransform::skew_x(45.0),
            SvgTransform::skew_y(-45.0),
        ] {
            let parsed = parse_transform_attribute(&value.serialize()).unwrap();
            assert_eq!(parsed, vec![value]);
        }
    }

    #[test]
    fn point_list_parser_rejects_invalid_tokens_and_truncates_incomplete_pairs() {
        assert_eq!(
            parse_point_list("0,0 100,0 100,100 0,100"),
            Some(vec![(0.0, 0.0), (100.0, 0.0), (100.0, 100.0), (0.0, 100.0)])
        );
        assert_eq!(
            parse_point_list("0,0 100,0 20"),
            Some(vec![(0.0, 0.0), (100.0, 0.0)])
        );
        assert_eq!(
            parse_point_list("0,0 100,0 20,"),
            Some(vec![(0.0, 0.0), (100.0, 0.0)])
        );
        assert_eq!(parse_point_list("0,0 100,0 INVALID"), None);
    }

    fn polyline_segments(raw: &str) -> Vec<SvgGeometrySegment> {
        segments_for_element(SvgGeometryElement::Polyline {
            points: raw.to_owned(),
        })
    }

    #[test]
    fn degenerate_shapes_keep_distance_paths_without_rendered_bounds() {
        for (element, length, endpoint) in [
            (
                SvgGeometryElement::Rect {
                    x: 7.0,
                    y: 9.0,
                    width: 0.0,
                    height: 10.0,
                    rx: 0.0,
                    ry: 0.0,
                },
                20.0,
                SvgGeometryPoint::new(7.0, 9.0),
            ),
            (
                SvgGeometryElement::Rect {
                    x: 7.0,
                    y: 9.0,
                    width: 10.0,
                    height: 0.0,
                    rx: 0.0,
                    ry: 0.0,
                },
                20.0,
                SvgGeometryPoint::new(7.0, 9.0),
            ),
            (
                SvgGeometryElement::Ellipse {
                    cx: 7.0,
                    cy: 9.0,
                    rx: 0.0,
                    ry: 10.0,
                },
                40.0,
                SvgGeometryPoint::new(7.0, 9.0),
            ),
            (
                SvgGeometryElement::Ellipse {
                    cx: 7.0,
                    cy: 9.0,
                    rx: 10.0,
                    ry: 0.0,
                },
                40.0,
                SvgGeometryPoint::new(17.0, 9.0),
            ),
        ] {
            assert!(bounding_box_for_element(&element).is_none());
            let segments = segments_for_element(element);
            assert_near(
                segments.iter().map(SvgGeometrySegment::length).sum(),
                length,
                1e-6,
            );
            let point = point_at_length(&segments, 300.0);
            assert_close(point.x, endpoint.x);
            assert_close(point.y, endpoint.y);
        }
        for element in [
            SvgGeometryElement::Rect {
                x: 7.0,
                y: 9.0,
                width: 0.0,
                height: 0.0,
                rx: 0.0,
                ry: 0.0,
            },
            SvgGeometryElement::Ellipse {
                cx: 7.0,
                cy: 9.0,
                rx: 0.0,
                ry: 0.0,
            },
            SvgGeometryElement::Circle {
                cx: 7.0,
                cy: 9.0,
                r: 0.0,
            },
            SvgGeometryElement::Path { d: String::new() },
        ] {
            assert!(segments_for_element(element).is_empty());
        }
        for (rx, ry, points) in [
            (
                0.0,
                10.0,
                [(7.0, 9.0), (7.0, 19.0), (7.0, 9.0), (7.0, -1.0), (7.0, 9.0)],
            ),
            (
                10.0,
                0.0,
                [
                    (17.0, 9.0),
                    (7.0, 9.0),
                    (-3.0, 9.0),
                    (7.0, 9.0),
                    (17.0, 9.0),
                ],
            ),
        ] {
            let segments = segments_for_element(SvgGeometryElement::Ellipse {
                cx: 7.0,
                cy: 9.0,
                rx,
                ry,
            });
            for (distance, (x, y)) in [0.0, 10.0, 20.0, 30.0, 40.0].into_iter().zip(points) {
                let point = point_at_length(&segments, distance);
                assert_close(point.x, x);
                assert_close(point.y, y);
            }
        }
    }

    fn assert_close(actual: f64, expected: f64) {
        assert!(
            (actual - expected).abs() < 1e-9,
            "expected {actual} to be close to {expected}"
        );
    }

    fn assert_near(actual: f64, expected: f64, epsilon: f64) {
        assert!(
            (actual - expected).abs() < epsilon,
            "expected {actual} to be within {epsilon} of {expected}"
        );
    }

    #[test]
    fn path_geometry_handles_line_commands_and_points() {
        let segments = path_segments("M 0 0 L 3 4 H 7 V 1");
        let total = segments.iter().map(|segment| segment.length()).sum::<f64>();
        assert_close(total, 12.0);

        let point = point_at_length(&segments, 7.0);
        assert_close(point.x, 5.0);
        assert_close(point.y, 4.0);

        let compact = path_segments("M10-20l30.1.5.1-20z");
        let compact_end = point_at_length(&compact, 10_000.0);
        assert_close(compact_end.x, 10.0);
        assert_close(compact_end.y, -20.0);
    }

    #[test]
    fn move_only_path_preserves_its_zero_length_point() {
        let segments = path_segments("M 1e2,-2E1");
        assert_eq!(segments.len(), 1);
        assert_close(segments[0].length(), 0.0);

        let point = point_at_length(&segments, 0.0);
        assert_close(point.x, 100.0);
        assert_close(point.y, -20.0);
    }

    #[test]
    fn path_geometry_preserves_complete_segments_before_a_parse_error() {
        let invalid_command = path_segments("M 10 10 L 30 10 X 50 10");
        assert_eq!(invalid_command.len(), 1);
        assert_close(invalid_command[0].length(), 20.0);

        let incomplete_curve = path_segments("M 10 10 L 30 10 C 40 0 50 20");
        assert_eq!(incomplete_curve.len(), 1);
        assert_close(incomplete_curve[0].length(), 20.0);
    }

    #[test]
    fn path_geometry_rejects_numbers_with_trailing_decimal_points() {
        let separate_command = path_segments("M 0 0 L 10 10 L 20.,30");
        assert_eq!(separate_command.len(), 1);
        let end = point_at_length(&separate_command, f64::INFINITY);
        assert_close(end.x, 10.0);
        assert_close(end.y, 10.0);

        let compound_command = path_segments("M 0 0 L 10 10 20.,30");
        assert_eq!(compound_command.len(), 1);
        let end = point_at_length(&compound_command, f64::INFINITY);
        assert_close(end.x, 10.0);
        assert_close(end.y, 10.0);

        let first_coordinate = path_segments("M 0 0 L 15. 20");
        assert_close(first_coordinate[0].length(), 0.0);
        let end = point_at_length(&first_coordinate, f64::INFINITY);
        assert_close(end.x, 0.0);
        assert_close(end.y, 0.0);
    }

    #[test]
    fn path_geometry_handles_relative_commands_and_close_path() {
        let segments = path_segments("m 1 1 l 3 0 v 4 h -3 z");
        let total = segments.iter().map(|segment| segment.length()).sum::<f64>();
        assert_close(total, 14.0);

        let point = point_at_length(&segments, 12.0);
        assert_close(point.x, 1.0);
        assert_close(point.y, 3.0);
    }

    #[test]
    fn path_geometry_preserves_cubic_and_quadratic_curves() {
        let cubic = path_segments("M 0 0 C 0 10 10 10 10 0");
        assert!(cubic.iter().map(|segment| segment.length()).sum::<f64>() > 19.0);
        let cubic_end = point_at_length(&cubic, 10_000.0);
        assert_close(cubic_end.x, 10.0);
        assert_close(cubic_end.y, 0.0);

        let quadratic = path_segments("M 0 0 Q 5 10 10 0 T 20 0");
        assert!(
            quadratic
                .iter()
                .map(|segment| segment.length())
                .sum::<f64>()
                > 22.0
        );
        let quadratic_end = point_at_length(&quadratic, 10_000.0);
        assert_close(quadratic_end.x, 20.0);
        assert_close(quadratic_end.y, 0.0);
    }

    #[test]
    fn path_geometry_converts_svg_arcs_to_bezier_curves() {
        let arc = path_segments("M 0 0 A 10 10 0 0 1 20 0");
        let total = arc.iter().map(|segment| segment.length()).sum::<f64>();
        assert_near(total, std::f64::consts::PI * 10.0, 0.1);
        let arc_end = point_at_length(&arc, 10_000.0);
        assert_close(arc_end.x, 20.0);
        assert_close(arc_end.y, 0.0);

        let relative_arc = path_segments("M 10 10 a 5 5 0 0 0 10 0");
        let relative_end = point_at_length(&relative_arc, 10_000.0);
        assert_close(relative_end.x, 20.0);
        assert_close(relative_end.y, 10.0);
    }

    #[test]
    fn bounding_box_covers_shape_and_path_segments() {
        let rect = segments_for_element(SvgGeometryElement::Rect {
            x: 10.0,
            y: 20.0,
            width: 30.0,
            height: 40.0,
            rx: 0.0,
            ry: 0.0,
        });
        let rect_box = bounding_box_for_segments(&rect).unwrap();
        assert_close(rect_box.x, 10.0);
        assert_close(rect_box.y, 20.0);
        assert_close(rect_box.width, 30.0);
        assert_close(rect_box.height, 40.0);

        let path = path_segments("M 0 0 L 3 4 H 7 V 1");
        let path_box = bounding_box_for_segments(&path).unwrap();
        assert_close(path_box.x, 0.0);
        assert_close(path_box.y, 0.0);
        assert_close(path_box.width, 7.0);
        assert_close(path_box.height, 4.0);
    }

    #[test]
    fn element_bounding_box_preserves_move_to_only_geometry() {
        let path = SvgGeometryElement::Path {
            d: "M 40 20".to_owned(),
        };
        let bbox = bounding_box_for_element(&path).unwrap();
        assert_close(bbox.x, 40.0);
        assert_close(bbox.y, 20.0);
        assert_close(bbox.width, 0.0);
        assert_close(bbox.height, 0.0);

        let polyline = SvgGeometryElement::Polyline {
            points: "10,20".to_owned(),
        };
        let bbox = bounding_box_for_element(&polyline).unwrap();
        assert_close(bbox.x, 10.0);
        assert_close(bbox.y, 20.0);
        assert_close(bbox.width, 0.0);
        assert_close(bbox.height, 0.0);
    }

    #[test]
    fn transformed_element_bounding_box_uses_kurbo_path_geometry() {
        let path = SvgGeometryElement::Path {
            d: "M 0 0 L 10 20".to_owned(),
        };
        let bbox =
            bounding_box_for_transformed_element(&path, SvgMatrixComponents::translate(30.0, 40.0))
                .unwrap();
        assert_close(bbox.x, 30.0);
        assert_close(bbox.y, 40.0);
        assert_close(bbox.width, 10.0);
        assert_close(bbox.height, 20.0);
    }

    #[test]
    fn negative_ellipse_radius_falls_back_to_the_valid_radius() {
        let rx_invalid = bounding_box_for_element(&SvgGeometryElement::Ellipse {
            cx: 1.0,
            cy: 12.0,
            rx: -5.0,
            ry: 10.0,
        })
        .unwrap();
        assert_close(rx_invalid.x, -9.0);
        assert_close(rx_invalid.y, 2.0);
        assert_close(rx_invalid.width, 20.0);
        assert_close(rx_invalid.height, 20.0);

        let ry_invalid = bounding_box_for_element(&SvgGeometryElement::Ellipse {
            cx: 6.0,
            cy: 2.0,
            rx: 5.0,
            ry: -10.0,
        })
        .unwrap();
        assert_close(ry_invalid.x, 1.0);
        assert_close(ry_invalid.y, -3.0);
        assert_close(ry_invalid.width, 10.0);
        assert_close(ry_invalid.height, 10.0);
    }

    #[test]
    fn rounded_rect_geometry_uses_elliptical_corner_arcs() {
        let rect = segments_for_element(SvgGeometryElement::Rect {
            x: 0.0,
            y: 0.0,
            width: 200.0,
            height: 300.0,
            rx: 50.0,
            ry: 50.0,
        });
        let length = rect.iter().map(SvgGeometrySegment::length).sum::<f64>();
        assert_near(length, 600.0 + std::f64::consts::PI * 100.0, 0.1);
        let bbox = bounding_box_for_segments(&rect).unwrap();
        assert_close(bbox.x, 0.0);
        assert_close(bbox.y, 0.0);
        assert_close(bbox.width, 200.0);
        assert_close(bbox.height, 300.0);

        let clamped = segments_for_element(SvgGeometryElement::Rect {
            x: 0.0,
            y: 0.0,
            width: 20.0,
            height: 10.0,
            rx: 50.0,
            ry: 50.0,
        });
        let clamped_length = clamped.iter().map(SvgGeometrySegment::length).sum::<f64>();
        assert_near(clamped_length, 48.4, 0.2);
    }

    #[test]
    fn fill_containment_covers_basic_svg_geometry() {
        let rect = SvgGeometryElement::Rect {
            x: 10.0,
            y: 20.0,
            width: 30.0,
            height: 40.0,
            rx: 0.0,
            ry: 0.0,
        };
        assert!(is_point_in_fill(&rect, SvgGeometryPoint::new(25.0, 30.0)));
        assert!(is_point_in_fill(&rect, SvgGeometryPoint::new(10.0, 30.0)));
        assert!(is_point_in_fill(&rect, SvgGeometryPoint::new(40.0, 30.0)));
        assert!(is_point_in_fill(&rect, SvgGeometryPoint::new(25.0, 20.0)));
        assert!(is_point_in_fill(&rect, SvgGeometryPoint::new(25.0, 60.0)));
        assert!(!is_point_in_fill(&rect, SvgGeometryPoint::new(0.0, 0.0)));

        let line = SvgGeometryElement::Line {
            x1: 0.0,
            y1: 0.0,
            x2: 10.0,
            y2: 10.0,
        };
        assert!(!is_point_in_fill(&line, SvgGeometryPoint::new(5.0, 5.0)));

        let rounded_rect = SvgGeometryElement::Rect {
            x: 0.0,
            y: 0.0,
            width: 100.0,
            height: 100.0,
            rx: 25.0,
            ry: 25.0,
        };
        assert!(is_point_in_fill(
            &rounded_rect,
            SvgGeometryPoint::new(50.0, 5.0)
        ));
        assert!(!is_point_in_fill(
            &rounded_rect,
            SvgGeometryPoint::new(5.0, 5.0)
        ));

        let circle = SvgGeometryElement::Circle {
            cx: 5.0,
            cy: 6.0,
            r: 10.0,
        };
        assert!(is_point_in_fill(&circle, SvgGeometryPoint::new(5.0, 6.0)));
        assert!(!is_point_in_fill(&circle, SvgGeometryPoint::new(20.0, 6.0)));

        let polygon = SvgGeometryElement::Polygon {
            points: "0 0 10 0 10 10 0 10".to_owned(),
        };
        assert!(is_point_in_fill(&polygon, SvgGeometryPoint::new(4.0, 4.0)));
        assert!(!is_point_in_fill(
            &polygon,
            SvgGeometryPoint::new(12.0, 4.0)
        ));

        let path = SvgGeometryElement::Path {
            d: "M 0 0 L 10 0 L 10 10 Z".to_owned(),
        };
        assert!(is_point_in_fill(&path, SvgGeometryPoint::new(8.0, 2.0)));
        assert!(!is_point_in_fill(&path, SvgGeometryPoint::new(2.0, 8.0)));
    }

    #[test]
    fn fill_containment_uses_nonzero_winding_and_closes_each_subpath() {
        let same_direction_rings = SvgGeometryElement::Path {
            d: "M0 0H10V10H0Z M2 2H8V8H2Z".to_owned(),
        };
        assert!(is_point_in_fill(
            &same_direction_rings,
            SvgGeometryPoint::new(5.0, 5.0)
        ));

        let open_subpaths = SvgGeometryElement::Path {
            d: "M0 0L10 0L10 10 M20 0L30 0L30 10".to_owned(),
        };
        assert!(is_point_in_fill(
            &open_subpaths,
            SvgGeometryPoint::new(8.0, 2.0)
        ));
        assert!(is_point_in_fill(
            &open_subpaths,
            SvgGeometryPoint::new(28.0, 2.0)
        ));
    }

    #[test]
    fn curve_bounding_box_uses_bezier_extrema() {
        let path = path_segments("M0 0 C100 100 100-100 200 0");
        let bounds = bounding_box_for_segments(&path).unwrap();
        let y_extent = 50.0 / 3.0 * 3.0_f64.sqrt();
        assert_near(bounds.x, 0.0, 1e-9);
        assert_near(bounds.y, -y_extent, 1e-9);
        assert_near(bounds.width, 200.0, 1e-9);
        assert_near(bounds.height, y_extent * 2.0, 1e-9);
    }

    #[test]
    fn poly_points_geometry_rejects_odd_coordinates() {
        assert!(polyline_segments("0 0 10").is_empty());
        let compact = polyline_segments("0,0 10-5 20.5.5");
        assert_eq!(compact.len(), 2);
        let compact_end = point_at_length(&compact, 10_000.0);
        assert_close(compact_end.x, 20.5);
        assert_close(compact_end.y, 0.5);
    }

    #[test]
    fn svg_scalar_and_list_parsers_use_svgtypes_boundaries() {
        let length = parse_length(" 1.5em ").unwrap();
        assert_close(length.value, 1.5);
        assert_eq!(length.unit, SvgLengthUnit::Ems);
        assert_eq!(length.serialize(), "1.5em");
        assert_eq!(parse_length("1pX").unwrap().unit, SvgLengthUnit::Px);
        assert_eq!(serialize_number(3.0), "3");
        assert_eq!(serialize_number(3.25), "3.25");
        assert!(parse_length("1 px").is_none());

        let lengths = parse_length_list("1 2px,3% 4-5").unwrap();
        assert_eq!(lengths.len(), 5);
        assert_close(lengths[3].value, 4.0);
        assert_eq!(lengths[3].unit, SvgLengthUnit::Number);
        assert_close(lengths[4].value, -5.0);
        assert!(parse_length_list("1px nope 2px").is_none());

        let modern = parse_length_list("10cap, 2rlh 3vw-4q").unwrap();
        assert_eq!(modern.len(), 4);
        assert_eq!(modern[0].unit, SvgLengthUnit::Cap);
        assert_eq!(modern[1].unit, SvgLengthUnit::Rlh);
        assert_eq!(modern[2].unit, SvgLengthUnit::Vw);
        assert_close(modern[3].value, -4.0);
        assert_eq!(modern[3].unit, SvgLengthUnit::Q);
        assert_eq!(modern[0].serialize(), "10cap");
        assert_eq!(parse_length_list(" 10cap ").unwrap().len(), 1);
        assert!(parse_length_list("10cap,").is_none());
        assert!(parse_length_list("10cap nope").is_none());

        assert_close(parse_number(" .5 ").unwrap(), 0.5);
        assert_eq!(
            parse_number_list("10 20,30-40").unwrap(),
            vec![10.0, 20.0, 30.0, -40.0]
        );
        assert!(parse_number_list("10 nope 20").is_none());
    }

    #[test]
    fn serialized_svg_numbers_round_trip_large_finite_values_and_signed_zero() {
        for value in [
            1e20_f64,
            -1e20,
            f64::MAX,
            f64::MIN_POSITIVE,
            f64::from(f32::MAX),
            f64::from(f32::from_bits(1)),
            -0.0,
        ] {
            let serialized = serialize_number(value);
            assert_eq!(
                serialized.parse::<f64>().unwrap().to_bits(),
                value.to_bits(),
                "{serialized} must preserve {value}"
            );
        }
    }

    #[test]
    fn circle_and_ellipse_geometry_are_bezier_paths() {
        let circle = segments_for_element(SvgGeometryElement::Circle {
            cx: 0.0,
            cy: 0.0,
            r: 10.0,
        });
        let circle_length = circle.iter().map(|segment| segment.length()).sum::<f64>();
        assert_near(circle_length, std::f64::consts::TAU * 10.0, 0.1);
        let start = point_at_length(&circle, 0.0);
        assert_close(start.x, 10.0);
        assert_close(start.y, 0.0);

        let ellipse = segments_for_element(SvgGeometryElement::Ellipse {
            cx: 5.0,
            cy: 6.0,
            rx: 10.0,
            ry: 4.0,
        });
        assert!(ellipse.iter().map(|segment| segment.length()).sum::<f64>() > 44.0);
    }

    #[test]
    fn svg_transform_attribute_parses_affine_css_and_svg_forms() {
        let transforms =
            parse_transform_attribute("translate(10 20) scale(2, 3) rotate(90 5 5) skewX(45)")
                .unwrap();

        assert_eq!(transforms.len(), 4);
        assert_eq!(transforms[0].kind, SvgTransformKind::Translate);
        assert_close(transforms[0].matrix.e, 10.0);
        assert_close(transforms[0].matrix.f, 20.0);
        assert_eq!(transforms[1].kind, SvgTransformKind::Scale);
        assert_close(transforms[1].matrix.a, 2.0);
        assert_close(transforms[1].matrix.d, 3.0);
        assert_eq!(transforms[2].kind, SvgTransformKind::Rotate);
        assert_close(transforms[2].angle, 90.0);
        assert_eq!(transforms[3].kind, SvgTransformKind::SkewX);
    }

    #[test]
    fn svg_transform_constructors_set_kind_angle_and_matrix() {
        let matrix = SvgTransform::matrix(SvgMatrixComponents::translate(1.0, 2.0));
        assert_eq!(matrix.kind, SvgTransformKind::Matrix);
        assert_close(matrix.angle, 0.0);
        assert_eq!(matrix.matrix, SvgMatrixComponents::translate(1.0, 2.0));

        let translate = SvgTransform::translate(10.0, 20.0);
        assert_eq!(translate.kind, SvgTransformKind::Translate);
        assert_eq!(translate.matrix, SvgMatrixComponents::translate(10.0, 20.0));

        let scale = SvgTransform::scale(2.0, 3.0);
        assert_eq!(scale.kind, SvgTransformKind::Scale);
        assert_eq!(scale.matrix, SvgMatrixComponents::scale(2.0, 3.0));

        let rotate = SvgTransform::rotate(45.0, 5.0, 6.0);
        assert_eq!(rotate.kind, SvgTransformKind::Rotate);
        assert_close(rotate.angle, 45.0);
        assert_eq!(
            rotate.matrix,
            SvgMatrixComponents::rotate_around(45.0, 5.0, 6.0)
        );

        let skew_x = SvgTransform::skew_x(15.0);
        assert_eq!(skew_x.kind, SvgTransformKind::SkewX);
        assert_close(skew_x.angle, 15.0);
        assert_eq!(skew_x.matrix, SvgMatrixComponents::skew_x(15.0));

        let skew_y = SvgTransform::skew_y(20.0);
        assert_eq!(skew_y.kind, SvgTransformKind::SkewY);
        assert_close(skew_y.angle, 20.0);
        assert_eq!(skew_y.matrix, SvgMatrixComponents::skew_y(20.0));
    }

    #[test]
    fn svg_transform_attribute_rejects_non_affine_3d_tail() {
        assert!(parse_transform_attribute("translate3d(1px, 2px, 3px)").is_none());
        assert!(parse_transform_attribute("scale3d(1, 2, 3)").is_none());
        assert!(parse_transform_attribute("matrix(1 0 0 1 0 0,)").is_none());
    }

    #[test]
    fn svg_matrix_components_multiply_and_inverse_round_trip() {
        let matrix = SvgMatrixComponents::translate(10.0, 20.0)
            .multiply(SvgMatrixComponents::scale(2.0, 3.0))
            .multiply(SvgMatrixComponents::rotate(30.0));
        assert!(matrix.is_invertible());
        assert!(matrix.serialize_transform_matrix().starts_with("matrix("));

        let consolidated = consolidate_transform_matrices([
            SvgMatrixComponents::translate(10.0, 20.0),
            SvgMatrixComponents::scale(2.0, 3.0),
        ])
        .unwrap();
        assert_eq!(
            consolidated,
            SvgMatrixComponents::translate(10.0, 20.0)
                .multiply(SvgMatrixComponents::scale(2.0, 3.0))
        );
        assert!(consolidate_transform_matrices([]).is_none());
        assert_eq!(
            serialize_transform_list(&[
                SvgMatrixComponents::translate(10.0, 20.0),
                SvgMatrixComponents::scale(2.0, 3.0),
            ]),
            "matrix(1 0 0 1 10 20) matrix(2 0 0 3 0 0)"
        );

        let product = matrix.multiply(matrix.inverse());

        assert_close(product.a, 1.0);
        assert_close(product.b, 0.0);
        assert_close(product.c, 0.0);
        assert_close(product.d, 1.0);
        assert_close(product.e, 0.0);
        assert_close(product.f, 0.0);
    }

    #[test]
    fn svg_matrix_components_affine_operation_helpers_post_multiply() {
        let current = SvgMatrixComponents::translate(10.0, 20.0);
        assert_eq!(
            current.then_translate(3.0, 4.0),
            current.multiply(SvgMatrixComponents::translate(3.0, 4.0))
        );
        assert_eq!(
            current.then_scale(2.0),
            current.multiply(SvgMatrixComponents::scale(2.0, 2.0))
        );
        assert_eq!(
            current.then_scale_non_uniform(2.0, 3.0),
            current.multiply(SvgMatrixComponents::scale(2.0, 3.0))
        );
        assert_eq!(
            current.then_flip_x(),
            current.multiply(SvgMatrixComponents::scale(-1.0, 1.0))
        );
        assert_eq!(
            current.then_flip_y(),
            current.multiply(SvgMatrixComponents::scale(1.0, -1.0))
        );
        assert_eq!(
            current.then_skew_x(15.0),
            current.multiply(SvgMatrixComponents::skew_x(15.0))
        );
        assert_eq!(
            current.then_skew_y(20.0),
            current.multiply(SvgMatrixComponents::skew_y(20.0))
        );
        assert!(current.then_rotate_from_vector(0.0, 1.0).is_none());

        let rotated = current.then_rotate_from_vector(1.0, 1.0).unwrap();
        assert_eq!(rotated, current.multiply(SvgMatrixComponents::rotate(45.0)));
    }

    #[test]
    fn svg_matrix_components_treat_non_finite_values_as_non_invertible() {
        let matrix = SvgMatrixComponents {
            a: f64::NAN,
            ..SvgMatrixComponents::identity()
        };

        assert!(!matrix.has_finite_components());
        assert!(!matrix.is_invertible());
        assert!(matrix.inverse().a.is_nan());
    }
}