Skip to content

armgit / moli

Public Imported from GitHub
0

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

17.4 KB
Raw Blame
mod blit;
mod encode;
mod pixel;
mod rect;
mod text;
mod types;

pub use blit::{blit_draw_image, blit_draw_image_filtered, blit_image_data, extract_image_data};
pub use encode::{
    data_image_intrinsic_dimensions, data_image_rgba8_pixels, encode_data_url,
    image_dimensions_from_bytes, image_intrinsic_dimensions_from_bytes,
};
pub use pixel::{
    copy_rgba8_rect, flip_y_rgba8_in_place, multiply_u8_color, premultiply_rgba8_in_place,
    scale_rgba8, scale_rgba8_bilinear, scale_rgba8_nearest,
};
pub use rect::{canonicalize_fill_style, fill_style_rgba, normalize_rect, paint_rect};
pub use text::{draw_text, measure_text_width};
pub use types::{
    CanvasRect, DEFAULT_FILL_STYLE, DEFAULT_FONT, DrawImageBlit, ImageDataRect,
    MAX_RGBA8_BYTE_LENGTH, Rgba8Rect, ScaleFilter, byte_len,
};

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

    const ONE_BY_ONE_GIF: &str = "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7";

    fn decode_png_dimensions_from_data_url(data_url: &str) -> (u32, u32) {
        let encoded = data_url
            .strip_prefix("data:image/png;base64,")
            .expect("png data url prefix");
        let bytes = base64::Engine::decode(&base64::engine::general_purpose::STANDARD, encoded)
            .expect("valid base64 png");
        moli_image::raster_image_dimensions(&bytes).expect("png metadata should parse")
    }

    #[test]
    fn fill_style_canonicalization_matches_canvas_surface() {
        assert_eq!(canonicalize_fill_style("black").as_deref(), Some("#000000"));
        assert_eq!(canonicalize_fill_style("#abc").as_deref(), Some("#aabbcc"));
        assert_eq!(
            canonicalize_fill_style("#ff000080").as_deref(),
            Some("rgba(255, 0, 0, 0.50)")
        );
        assert_eq!(
            canonicalize_fill_style("#112233ff").as_deref(),
            Some("#112233")
        );
        assert_eq!(canonicalize_fill_style("#ggg"), None);
        assert_eq!(canonicalize_fill_style("#zzzzzz"), None);
        assert_eq!(canonicalize_fill_style("#112233gg"), None);
        assert_eq!(canonicalize_fill_style("bad"), None);
    }

    #[test]
    fn hex_alpha_canonicalization_round_trips_every_byte() {
        for alpha in 0..=255_u8 {
            let raw = format!("#12ab34{alpha:02x}");
            let canonical = canonicalize_fill_style(&raw).expect("valid eight-digit hex");
            assert_eq!(
                fill_style_rgba(&canonical),
                [0x12, 0xab, 0x34, alpha],
                "{raw}: {canonical}"
            );
        }
        for alpha in 0..16_u8 {
            let raw = format!("#0f0{alpha:x}");
            let canonical = canonicalize_fill_style(&raw).expect("valid four-digit hex");
            assert_eq!(fill_style_rgba(&canonical), [0, 255, 0, alpha * 17]);
        }
    }

    #[test]
    fn malformed_hex_colors_cannot_panic_or_install_a_style() {
        for raw in ["#", "#12", "#12345", "#gggg", "#💚", "#éé", "#0000000x"] {
            assert_eq!(canonicalize_fill_style(raw), None, "{raw}");
            assert_eq!(fill_style_rgba(raw), [0, 0, 0, 255], "{raw}");
        }
    }

    #[test]
    fn data_url_zero_and_png_dimensions_are_stable() {
        assert_eq!(encode_data_url(&[], 0, 0).as_deref(), Some("data:,"));

        let bytes = vec![0; byte_len(17, 9).expect("buffer len")];
        let url = encode_data_url(&bytes, 17, 9).expect("png data url");
        assert_eq!(decode_png_dimensions_from_data_url(&url), (17, 9));
        assert_eq!(encode_data_url(&bytes[..bytes.len() - 1], 17, 9), None);
    }

    #[test]
    fn data_image_rgba8_pixels_decodes_canvas_png_data_urls() {
        let bytes = vec![0, 0, 0, 255, 255, 0, 0, 128];
        let url = encode_data_url(&bytes, 2, 1).expect("png data url");

        assert_eq!(data_image_rgba8_pixels(&url), Some((bytes, 2, 1)));
        assert_eq!(
            data_image_rgba8_pixels("data:text/plain,not an image"),
            None
        );
        assert_eq!(
            data_image_rgba8_pixels("data:image/png-bad;base64,iVBORw0KGgo="),
            None
        );
    }

    #[test]
    fn data_image_intrinsic_dimensions_accepts_mime_parameters() {
        assert_eq!(
            data_image_intrinsic_dimensions(&format!(
                "data:IMAGE/GIF ; charset=utf-8; base64,{ONE_BY_ONE_GIF}"
            )),
            Some((1, 1))
        );
    }

    #[test]
    fn data_image_intrinsic_dimensions_uses_data_url_processor_for_plain_bodies() {
        assert_eq!(
            data_image_intrinsic_dimensions(
                "data:image/gif,GIF89a%01%00%01%00%80%00%00%00%00%00%ff%ff%ff%21%f9%04%01%00%00%00%00%2c%00%00%00%00%01%00%01%00%00%02%01D%00%3b#ignored"
            ),
            Some((1, 1))
        );
    }

    #[test]
    fn data_image_intrinsic_dimensions_sniffs_mislabelled_image_bytes() {
        assert_eq!(
            data_image_intrinsic_dimensions(
                "data:text/plain,GIF89a%01%00%01%00%80%00%00%00%00%00%ff%ff%ff%21%f9%04%01%00%00%00%00%2c%00%00%00%00%01%00%01%00%00%02%01D%00%3b"
            ),
            Some((1, 1))
        );
    }

    #[test]
    fn data_image_intrinsic_dimensions_reads_svg_size_attributes() {
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg"/>"#
            ),
            Some((300, 150))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="500" height="400"/>"#
            ),
            Some((500, 400))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg data-note="1 > 0" width="12" height="8"/>"#
            ),
            Some((12, 8))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg data-note='1 > 0' width="13" height="9"/>"#
            ),
            Some((13, 9))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="500"/>"#
            ),
            Some((500, 150))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="500" height="100%"/>"#
            ),
            Some((500, 150))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000"/>"#
            ),
            Some((150, 150))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml-bad,<svg xmlns="http://www.w3.org/2000/svg" width="3" height="4"/>"#
            ),
            None
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="400" viewBox="0 0 800 600"/>"#
            ),
            Some((400, 300))
        );
        assert_eq!(
            data_image_intrinsic_dimensions(
                r#"data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" height="300" viewBox="0 0 800 600"/>"#
            ),
            Some((400, 300))
        );
    }

    #[test]
    fn data_image_intrinsic_dimensions_rejects_non_image_mime() {
        assert_eq!(
            data_image_intrinsic_dimensions("data:application/octet-stream;base64,aGVsbG8="),
            None
        );
    }

    #[test]
    fn rgba8_byte_len_matches_servo_allocation_guard() {
        assert_eq!(byte_len(1, 1), Some(4));
        assert_eq!(byte_len(23_170, 23_170), Some(2_147_395_600));
        assert_eq!(byte_len(23_171, 23_171), None);
        assert_eq!(byte_len(u32::MAX, u32::MAX), None);
    }

    #[test]
    fn servo_pixel_helpers_premultiply_and_flip_rows() {
        let mut pixels = vec![
            100, 50, 25, 128, 10, 20, 30, 255, //
            1, 2, 3, 0, 40, 80, 120, 255,
        ];

        assert_eq!(premultiply_rgba8_in_place(&mut pixels), Some(false));
        assert_eq!(
            pixels,
            vec![
                50, 25, 13, 128, 10, 20, 30, 255, //
                0, 0, 0, 0, 40, 80, 120, 255,
            ]
        );

        flip_y_rgba8_in_place(&mut pixels, 2, 2).expect("valid surface");
        assert_eq!(
            pixels,
            vec![
                0, 0, 0, 0, 40, 80, 120, 255, //
                50, 25, 13, 128, 10, 20, 30, 255,
            ]
        );
    }

    #[test]
    fn copy_rgba8_rect_copies_rows_and_rejects_invalid_surfaces() {
        let source = vec![
            1, 0, 0, 255, 2, 0, 0, 255, 3, 0, 0, 255, //
            4, 0, 0, 255, 5, 0, 0, 255, 6, 0, 0, 255,
        ];
        let mut dest = vec![0; byte_len(4, 3).expect("buffer len")];

        copy_rgba8_rect(
            &source,
            3,
            2,
            Rgba8Rect::new(1, 0, 2, 2).expect("valid rect"),
            &mut dest,
            4,
            3,
            1,
            1,
        )
        .expect("copy should fit");

        assert_eq!(
            extract_image_data(&dest, 4, 3, ImageDataRect::new(1, 1, 2, 2)),
            vec![
                2, 0, 0, 255, 3, 0, 0, 255, //
                5, 0, 0, 255, 6, 0, 0, 255,
            ]
        );
        assert_eq!(
            copy_rgba8_rect(
                &source[..source.len() - 1],
                3,
                2,
                Rgba8Rect::new(0, 0, 1, 1).expect("valid rect"),
                &mut dest,
                4,
                3,
                0,
                0,
            ),
            None
        );
    }

    #[test]
    fn scale_rgba8_nearest_rasterizes_visible_draw_image_region() {
        let source = vec![
            255, 0, 0, 255, 0, 255, 0, 255, //
            0, 0, 255, 255, 255, 255, 0, 255,
        ];
        let scaled = scale_rgba8_nearest(
            &source,
            2,
            2,
            DrawImageBlit::new(0.0, 0.0, 2.0, 2.0, -1.0, 0.0, 2.0, 2.0).expect("valid blit"),
            0,
            0,
            1,
            2,
        )
        .expect("scale should fit");

        assert_eq!(
            scaled,
            vec![
                0, 255, 0, 255, //
                255, 255, 0, 255,
            ]
        );
    }

    #[test]
    fn scale_rgba8_bilinear_interpolates_visible_region() {
        let source = vec![255, 0, 0, 255, 0, 255, 0, 255];
        let scaled = scale_rgba8(
            &source,
            2,
            1,
            DrawImageBlit::new(0.0, 0.0, 2.0, 1.0, 0.0, 0.0, 3.0, 1.0).expect("valid blit"),
            0,
            0,
            3,
            1,
            ScaleFilter::Bilinear,
        )
        .expect("scale should fit");

        assert_eq!(
            scaled,
            vec![
                255, 0, 0, 255, //
                85, 170, 0, 255, //
                0, 255, 0, 255,
            ]
        );
    }

    #[test]
    fn paint_rect_clips_to_canvas_bounds() {
        let mut pixels = vec![0; byte_len(4, 4).expect("buffer len")];
        paint_rect(&mut pixels, 4, 4, (2, 1, 6, 3), [255, 0, 0, 255]);

        let hot = pixels
            .as_chunks::<4>()
            .0
            .iter()
            .filter(|px| px[0] == 255 && px[3] == 255)
            .count();
        assert_eq!(hot, 4);
    }

    #[test]
    fn measure_text_scales_with_font_size_and_draw_text_changes_pixels() {
        let small = measure_text_width("Hi", "10px sans-serif");
        let large = measure_text_width("Hi", "24px sans-serif");
        assert!(large > small);

        let mut pixels = vec![0; byte_len(96, 48).expect("buffer len")];
        draw_text(
            &mut pixels,
            96,
            48,
            "Moli",
            4.0,
            24.0,
            "16px sans-serif",
            fill_style_rgba("#ff0000"),
        );
        assert!(pixels.iter().any(|&value| value != 0));
    }

    #[test]
    fn draw_image_blit_validation_and_normalized_rect_cover_invalid_inputs() {
        assert!(
            DrawImageBlit::new(0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0).is_some(),
            "positive finite blit should be accepted"
        );
        assert!(
            DrawImageBlit::new(f64::NAN, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0).is_none(),
            "non-finite source coordinate should be rejected"
        );
        assert!(
            DrawImageBlit::new(0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0).is_none(),
            "non-positive source width should be rejected"
        );
        assert!(
            DrawImageBlit::new(0.0, 0.0, 1.0, 1.0, 0.0, 0.0, -1.0, 1.0).is_none(),
            "non-positive destination width should be rejected"
        );

        assert_eq!(normalize_rect(5.0, 7.0, -2.0, -3.0), Some((3, 4, 5, 7)));
        assert_eq!(normalize_rect(1.1, 2.2, 3.3, 4.4), Some((1, 2, 5, 7)));
        assert_eq!(normalize_rect(f64::INFINITY, 0.0, 1.0, 1.0), None);
    }

    #[test]
    fn extract_and_put_image_data_round_trip_pixels() {
        let mut dst = vec![0; byte_len(2, 2).expect("buffer len")];
        let src = vec![
            255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255, 255, 255, 0, 255,
        ];

        blit_image_data(
            &mut dst,
            2,
            2,
            &src,
            2,
            2,
            0,
            0,
            ImageDataRect::new(0, 0, 2, 2),
        );
        assert_eq!(
            extract_image_data(&dst, 2, 2, ImageDataRect::new(0, 0, 2, 2)),
            src
        );
    }

    #[test]
    fn extract_image_data_out_of_bounds_fills_transparent_black() {
        let pixels = vec![255, 0, 0, 255];
        assert_eq!(
            extract_image_data(&pixels, 1, 1, ImageDataRect::new(-1, -1, 2, 2)),
            vec![
                0, 0, 0, 0, 0, 0, 0, 0, //
                0, 0, 0, 0, 255, 0, 0, 255,
            ]
        );
    }

    #[test]
    fn image_data_extreme_rectangles_clip_without_wrapping() {
        let source = vec![255, 0, 0, 255, 0, 255, 0, 255];
        let mut target = vec![0; 8];
        blit_image_data(
            &mut target,
            2,
            1,
            &source,
            2,
            1,
            0,
            0,
            ImageDataRect::new(1, 0, i32::MIN, 1),
        );
        assert_eq!(target, [255, 0, 0, 255, 0, 0, 0, 0]);
        assert_eq!(
            extract_image_data(&source, 2, 1, ImageDataRect::new(2, 1, -2, -1)),
            source,
        );
        assert_eq!(
            extract_image_data(&source, 2, 1, ImageDataRect::new(i32::MIN, 0, -2, 1)),
            [0; 8],
        );
        blit_image_data(
            &mut target,
            2,
            1,
            &source,
            2,
            1,
            i32::MAX,
            0,
            ImageDataRect::new(i32::MIN, 0, i32::MIN, 1),
        );
        assert_eq!(target, [255, 0, 0, 255, 0, 0, 0, 0]);
    }

    #[test]
    fn blit_image_data_honors_dirty_rect_and_destination_clipping() {
        let source = vec![
            255, 0, 0, 255, 0, 255, 0, 255, //
            0, 0, 255, 255, 255, 255, 0, 255,
        ];

        let mut dst = vec![0; byte_len(2, 2).expect("buffer len")];
        blit_image_data(
            &mut dst,
            2,
            2,
            &source,
            2,
            2,
            0,
            0,
            ImageDataRect::new(1, 0, 1, 2),
        );
        assert_eq!(
            dst,
            vec![
                0, 0, 0, 0, 0, 255, 0, 255, //
                0, 0, 0, 0, 255, 255, 0, 255,
            ]
        );

        let mut clipped = vec![0; byte_len(1, 2).expect("buffer len")];
        blit_image_data(
            &mut clipped,
            1,
            2,
            &source,
            2,
            2,
            -1,
            0,
            ImageDataRect::new(0, 0, 2, 2),
        );
        assert_eq!(
            clipped,
            vec![
                0, 255, 0, 255, //
                255, 255, 0, 255,
            ]
        );

        let mut negative_destination = vec![0; byte_len(1, 2).expect("buffer len")];
        blit_image_data(
            &mut negative_destination,
            1,
            2,
            &source,
            2,
            2,
            -1,
            0,
            ImageDataRect::new(0, 0, 2, 2),
        );
        assert_eq!(
            negative_destination,
            vec![
                0, 255, 0, 255, //
                255, 255, 0, 255,
            ]
        );
    }

    #[test]
    fn draw_image_supports_scaling_and_cropping() {
        let source = vec![
            255, 0, 0, 255, 0, 255, 0, 255, //
            0, 0, 255, 255, 255, 255, 0, 255,
        ];

        let mut scaled = vec![0; byte_len(4, 4).expect("buffer len")];
        blit_draw_image(
            &mut scaled,
            4,
            4,
            &source,
            2,
            2,
            DrawImageBlit::new(0.0, 0.0, 2.0, 2.0, 1.0, 1.0, 2.0, 2.0).expect("valid blit"),
        );
        let scaled_crop = extract_image_data(&scaled, 4, 4, ImageDataRect::new(1, 1, 2, 2));
        assert_eq!(
            scaled_crop,
            vec![
                255, 0, 0, 255, 0, 255, 0, 255, //
                0, 0, 255, 255, 255, 255, 0, 255,
            ]
        );

        let mut cropped = vec![0; byte_len(1, 2).expect("buffer len")];
        blit_draw_image(
            &mut cropped,
            1,
            2,
            &source,
            2,
            2,
            DrawImageBlit::new(1.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0, 2.0).expect("valid crop"),
        );
        assert_eq!(cropped, vec![0, 255, 0, 255, 255, 255, 0, 255]);
    }
}