use agg_rust::{

    basics::{FillingRule, PATH_FLAGS_NONE},

    color::Rgba8,

    conv_stroke::ConvStroke,

    conv_transform::ConvTransform,

    path_storage::PathStorage,

    trans_affine::TransAffine,

};

use azul_core::resources::ImageRef;

#[allow(clippy::wildcard_imports)]

// widget/render module pulls in the css property/value types it builds with

use super::*;

/// Render raw SVG bytes to a PNG image ON AN OPAQUE WHITE BACKGROUND.

///

/// Parses the SVG XML, walks the element tree, extracts path geometry +

/// fill/stroke attributes, and rasterizes via agg-rust directly (no CSS

/// layout involved).

///

/// An SVG has no background of its own, so "white" is this function's

/// CHOICE - fine for a document preview, wrong for an icon, which has to

/// composite over whatever is behind it. Use

/// [`render_svg_to_png_over`] to say what the backdrop is.

#[cfg(all(feature = "std", feature = "xml"))]

/// # Errors

///

/// Returns an error string if the SVG cannot be parsed or rendered.

    )

/// [`render_svg_to_png`] over an explicit backdrop.

///

/// `background = None` renders onto TRANSPARENT pixels, which is what an SVG

/// actually has and what any icon needs: filled white, a themed window-control

/// icon arrives as a white tile sitting in the titlebar instead of a glyph on

/// it. `Some((r, g, b, a))` fills first, for the callers that want a page.

#[cfg(all(feature = "std", feature = "xml"))]

/// # Errors

///

/// Returns an error string if the SVG cannot be parsed or rendered.

    // Find the <svg> root

                } else {

                }

            } else {

            }

    // Parse viewBox for coordinate mapping

    // `None` leaves the pixmap at its zeroed (fully transparent) state.

/// Like [`render_svg_to_png`] but returns the rendered pixmap as an [`ImageRef`]

/// (RGBA8) directly — no PNG round-trip.

///

/// The `MapWidget` uses this to render each

/// decoded tile SVG to a colour image node: `SvgNodeData::Path` in the DOM only

/// produces a clip mask (not a filled shape), so reuse the same `render_svg_group`

/// rasteriser the tiger uses (which reads SVG fill/stroke attrs) and embed the

/// result as an image.

/// # Errors

///

/// Returns an error string if the SVG cannot be parsed or rendered.

                } else {

                }

            } else {

            }

    // Transparent background so the tile container shows through any gaps.

#[cfg(all(feature = "std", feature = "xml"))]

    } else {

    }

/// Inherited SVG style (fill, stroke, stroke-width) that cascades from parent groups.

#[cfg(all(feature = "std", feature = "xml"))]

#[derive(Clone, Default)]

struct SvgInheritedStyle {

    fill: Option<String>,   // None = not set (inherit default black)

    stroke: Option<String>, // None = not set (inherit default none)

    stroke_width: Option<f64>,

}

#[cfg(all(feature = "std", feature = "xml"))]

    );

/// One presentation property of an element, `style="..."` first.

///

/// SVG lets the same property be written two ways - as an XML attribute

/// (`fill="#fff"`) or as a declaration inside `style` (`style="fill:#fff"`) -

/// and CSS says the `style` one wins. Reading only the attribute is not a

/// partial implementation, it is a WRONG one: an element that states its paint

/// only in `style` reads as unstated and falls through to the SVG default

/// (opaque black). Every Breeze icon is authored that way

/// (`style="fill:currentColor;fill-opacity:1;stroke:none"`), so every themed

/// icon came out black regardless of the palette it was tinted with.

///

/// A hand-written scan rather than the CSS parser: this is a semicolon list of

/// `name:value` with no selectors, nesting or at-rules, and the rasteriser

/// runs before any cascade exists.

#[cfg(all(feature = "std", feature = "xml"))]

    }

/// [`style_property`], falling back to the plain XML attribute.

#[cfg(all(feature = "std", feature = "xml"))]

#[cfg(all(feature = "std", feature = "xml"))]

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded graphics/coord/font/fixed-point/debug-marker cast

#[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine

                                 // (one branch per case)

    use agg_rust::math_stroke::{LineCap, LineJoin};

    use azul_core::xml::{XmlNode, XmlNodeChild};

    // Inherit style from this group's attributes

    };

        };

                };

                // Flatten bezier curves into line segments for the rasterizer

                // Per-element transform

                // Fill: element overrides group

                };

                    };

                // Stroke: element overrides group

                };

            }

        }

    }

/// Build an agg `PathStorage` from an SVG shape element's attributes.

#[cfg(all(feature = "std", feature = "xml"))]

#[allow(clippy::cast_possible_truncation)] // bounded graphics/coord/font/fixed-point/debug-marker

                                           // cast

    const KAPPA: f64 = 0.552_284_749_8;

        }

        }

            );

        }

            // Use circle path with scaling

            // Scale ellipse: we'll just build it directly instead

        }

        }

        }

    }

#[cfg(all(feature = "std", feature = "xml"))]

    // Clamp to a finite range far beyond any real SVG coordinate. A pathological

    // attribute (r="1e308", width="1e400", NaN) otherwise flows into geometry as ±inf

    // and hangs AGG's adaptive Bézier/arc flattening, which subdivides forever trying to

    // meet a flatness tolerance it can never reach. Real coordinates are untouched.

    } else {

    }

/// Convert `SvgMultiPolygon` to agg `PathStorage`.

#[cfg(all(feature = "std", feature = "xml"))]

                }

                    );

                }

                    );

                }

            }

        }

    }

/// Parse SVG transform attribute (supports matrix, translate, scale, rotate).

#[cfg(all(feature = "std", feature = "xml"))]

    {

/// Parse SVG color string (#RRGGBB, #RGB, named colors).

#[cfg(all(feature = "std", feature = "xml"))]

        // The arms below index `hex` at fixed BYTE offsets, but `hex.len()` is a byte

        // count: a multibyte char (e.g. "#€123", € = 3 bytes) makes the byte length hit

        // the 6/3 arm while the slice boundary lands mid-character and panics. Valid hex

        // is ASCII, so reject anything else up front.

            6 => {

            }

            3 => {

            }

        };

    }

#[cfg(all(test, feature = "std", feature = "xml"))]

#[allow(clippy::float_cmp)] // exact f64 compares are the point here: they assert parse fidelity, not arithmetic

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // pixel-index math in assertions

mod autotest_generated {

    use azul_core::{

        window::{AzStringPair, StringPairVec},

        xml::{XmlAttributeMap, XmlNode, XmlNodeChild, XmlNodeChildVec},

    };

    use super::*;

    use crate::cpurender::AzulPixmap;

    // ------------------------------------------------------------------

    // helpers

    // ------------------------------------------------------------------

    /// Build an `XmlNode` with the given tag + attributes and no children.

    fn el(tag: &str, pairs: &[(&str, &str)]) -> XmlNode {

        el_with(tag, pairs, Vec::new())

    }

    /// Build an `XmlNode` with the given tag, attributes and element children.

    fn el_with(tag: &str, pairs: &[(&str, &str)], children: Vec<XmlNode>) -> XmlNode {

        XmlNode {

            node_type: tag.into(),

            attributes: XmlAttributeMap {

                inner: StringPairVec::from_vec(

                    pairs

                        .iter()

                        .map(|(k, v)| AzStringPair {

                            key: (*k).into(),

                            value: (*v).into(),

                        })

                        .collect::<Vec<_>>(),

                ),

            },

            children: XmlNodeChildVec::from_vec(

                children.into_iter().map(XmlNodeChild::Element).collect(),

            ),

        }

    }

    fn pixmap(w: u32, h: u32) -> AzulPixmap {

        AzulPixmap::new(w, h).expect("pixmap alloc")

    }

    /// RGBA of pixel (x, y).

    fn px(p: &AzulPixmap, x: u32, y: u32) -> [u8; 4] {

        let i = ((y * p.width() + x) * 4) as usize;

        let d = p.data();

        [d[i], d[i + 1], d[i + 2], d[i + 3]]

    }

    fn is_all_white(p: &AzulPixmap) -> bool {

        p.data().iter().all(|&b| b == 255)

    }

    const RED: Rgba8 = Rgba8 {

        r: 255,

        g: 0,

        b: 0,

        a: 255,

    };

    const BLACK: Rgba8 = Rgba8 {

        r: 0,

        g: 0,

        b: 0,

        a: 255,

    };

    /// 16x16 red square — the positive control for the two public entry points.

    const MINIMAL_SVG: &[u8] =

        br#"<svg viewBox="0 0 16 16"><rect x="0" y="0" width="16" height="16" fill="red"/></svg>"#;

    // ==================================================================

    // parse_svg_color  (parser)

    // ==================================================================

    #[test]

    fn parse_svg_color_empty_and_whitespace_are_none() {

        assert_eq!(parse_svg_color(""), None);

        assert_eq!(parse_svg_color("   "), None);

        assert_eq!(parse_svg_color("\t\n\r "), None);

        assert_eq!(parse_svg_color("#"), None);

    }

    #[test]

    fn parse_svg_color_valid_minimal_six_digit_hex() {

        assert_eq!(

            parse_svg_color("#ff0000"),

            Some(RED),

            "#ff0000 is the positive control"

        );

        assert_eq!(parse_svg_color("#000000"), Some(BLACK));

    }

    #[test]

    fn parse_svg_color_six_digit_hex_is_case_insensitive() {

        assert_eq!(parse_svg_color("#FF0000"), parse_svg_color("#ff0000"));

        assert_eq!(parse_svg_color("#AbCdEf"), parse_svg_color("#abcdef"));

    }

    #[test]

    fn parse_svg_color_three_digit_hex_expands_by_seventeen() {

        // #abc -> a*17=170, b*17=187, c*17=204 (and must not overflow: f*17 == 255)

        assert_eq!(

            parse_svg_color("#abc"),

            Some(Rgba8 {

                r: 170,

                g: 187,

                b: 204,

                a: 255

            })

        );

        assert_eq!(

            parse_svg_color("#fff"),

            Some(Rgba8 {

                r: 255,

                g: 255,

                b: 255,

                a: 255

            }),

            "the *17 expansion must land on exactly 255, not wrap"

        );

        assert_eq!(parse_svg_color("#000"), Some(BLACK));

        assert_eq!(parse_svg_color("#f00"), Some(RED));

    }

    #[test]

    fn parse_svg_color_wrong_hex_lengths_are_none() {

        // note: 8-digit #RRGGBBAA is valid CSS but unsupported here

        for s in ["#f", "#ff", "#ffff", "#fffff", "#fffffff", "#ffffffff"] {

            assert_eq!(parse_svg_color(s), None, "{s} must be rejected");

        }

    }

    #[test]

    fn parse_svg_color_non_hex_digits_are_none() {

        assert_eq!(parse_svg_color("#gggggg"), None);

        assert_eq!(parse_svg_color("#00ff0g"), None);

        assert_eq!(parse_svg_color("#zzz"), None);

        assert_eq!(parse_svg_color("#0x0000"), None);

        assert_eq!(parse_svg_color("#-10000"), None); // 7 bytes -> rejected on length

        assert_eq!(parse_svg_color("#-1-1-1"), None, "negative hex components");

    }

    #[test]

    fn parse_svg_color_leading_trailing_whitespace_is_trimmed() {

        assert_eq!(parse_svg_color("  #ff0000  "), Some(RED));

        assert_eq!(parse_svg_color("\n\tred\r\n"), Some(RED));

    }

    #[test]

    fn parse_svg_color_named_colors_are_case_insensitive() {

        assert_eq!(parse_svg_color("RED"), Some(RED));

        assert_eq!(parse_svg_color("Red"), Some(RED));

        assert_eq!(parse_svg_color("black"), Some(BLACK));

        assert_eq!(

            parse_svg_color("green"),

            Some(Rgba8 {

                r: 0,

                g: 128,

                b: 0,

                a: 255

            }),

            "SVG `green` is 008000, not 00ff00"

        );

        assert_eq!(

            parse_svg_color("gold"),

            Some(Rgba8 {

                r: 255,

                g: 215,

                b: 0,

                a: 255

            })

        );

    }

    #[test]

    fn parse_svg_color_unsupported_named_colors_are_none() {

        // Only 8 names are in the table; every other CSS keyword silently falls

        // back to None (the caller then paints nothing).

        for s in [

            "gray",

            "grey",

            "cyan",

            "magenta",

            "transparent",

            "currentColor",

        ] {

            assert_eq!(parse_svg_color(s), None, "{s} is not in the named table");

        }

    }

    #[test]

    fn parse_svg_color_leading_trailing_junk_is_rejected() {

        assert_eq!(parse_svg_color("red;garbage"), None);

        assert_eq!(parse_svg_color("#ff0000;"), None);

        assert_eq!(

            parse_svg_color("rgb(255,0,0)"),

            None,

            "rgb() is unsupported"

        );

        assert_eq!(parse_svg_color("url(#grad)"), None, "paint servers -> None");

    }

    #[test]

    fn parse_svg_color_garbage_bytes_never_panic() {

        for s in [

            "!!!",

            "\u{0}\u{1}\u{2}",

            "########",

            "#\u{0}\u{0}\u{0}",

            "%%%",

        ] {

            let _ = parse_svg_color(s);

        }

    }

    #[test]

    fn parse_svg_color_extremely_long_input_is_none_and_does_not_hang() {

        let long_hex = format!("#{}", "f".repeat(1_000_000));

        assert_eq!(parse_svg_color(&long_hex), None);

        let long_name = "a".repeat(1_000_000);

        assert_eq!(parse_svg_color(&long_name), None);

    }

    #[test]

    fn parse_svg_color_unicode_is_none_not_panic() {

        // Emoji (4-byte) and CJK (3-byte) chars land on byte lengths that never

        // reach the 3/6-byte hex arms, so they are safely rejected.

        assert_eq!(parse_svg_color("\u{1F600}"), None);

        assert_eq!(parse_svg_color("#\u{1F600}"), None); // hex byte-len 4

        assert_eq!(parse_svg_color("\u{4F60}\u{597D}"), None);

        assert_eq!(parse_svg_color("e\u{301}"), None); // combining acute

        assert_eq!(

            parse_svg_color("#\u{e9}\u{e9}12"),

            None,

            "2-byte chars keep bytes 2/4 on char boundaries -> Err -> None"

        );

    }

    #[test]

    fn parse_svg_color_plus_prefixed_hex_components_do_not_panic() {

        // `u8::from_str_radix` accepts a leading '+', so "#+1+2+3" is 6 bytes of

        // "valid" hex and parses as rgb(1, 2, 3) even though it is not legal

        // SVG. Not a safety bug — only assert it is deterministic and total.

        let quirk = parse_svg_color("#+1+2+3");

        assert!(

            quirk.is_none()

                || quirk

                    == Some(Rgba8 {

                        r: 1,

                        g: 2,

                        b: 3,

                        a: 255

                    }),

            "lenient '+' hex must be rejected or rgb(1,2,3), got {quirk:?}"

        );

    }

    #[test]

    fn red_parse_svg_color_multibyte_hex_must_not_panic() {

        // BUG: the 3/6 arms slice `hex` by *byte* index (`&hex[0..2]`,

        // `&hex[0..1]`) after only checking `hex.len()`, which is a byte length.

        //

        // U+20AC EURO SIGN is 3 UTF-8 bytes, so:

        //   "#\u{20AC}123" -> hex = "\u{20AC}123", byte len 6 -> `&hex[0..2]`

        //   "#\u{20AC}"    -> hex = "\u{20AC}",    byte len 3 -> `&hex[0..1]`

        // Both slice *inside* the euro sign -> "byte index N is not a char

        // boundary" panic. An attacker-supplied `fill="#<3-byte char>123"`

        // crashes the renderer instead of falling back to no-paint.

        //

        // Correct behaviour: None. Fix = index `hex.as_bytes()` / reject

        // non-ASCII before slicing.

        assert_eq!(parse_svg_color("#\u{20AC}123"), None);

        assert_eq!(parse_svg_color("#\u{20AC}"), None);

    }

    // ==================================================================

    // parse_svg_transform  (parser)

    // ==================================================================

    fn assert_identity(t: &TransAffine) {

        assert_eq!(

            (t.sx, t.shy, t.shx, t.sy, t.tx, t.ty),

            (1.0, 0.0, 0.0, 1.0, 0.0, 0.0)

        );

    }

    #[test]

    fn parse_svg_transform_empty_and_whitespace_are_identity() {

        assert_identity(&parse_svg_transform(""));

        assert_identity(&parse_svg_transform("   "));

        assert_identity(&parse_svg_transform("\t\n\r "));

    }

    #[test]

    fn parse_svg_transform_valid_minimal_matrix() {

        let t = parse_svg_transform("matrix(1,2,3,4,5,6)");

        assert_eq!(

            (t.sx, t.shy, t.shx, t.sy, t.tx, t.ty),

            (1.0, 2.0, 3.0, 4.0, 5.0, 6.0)

        );

    }

    #[test]

    fn parse_svg_transform_matrix_accepts_space_separated_numbers() {

        let t = parse_svg_transform("matrix( 1 0 0 1 10 20 )");

        assert_eq!(

            (t.sx, t.shy, t.shx, t.sy, t.tx, t.ty),

            (1.0, 0.0, 0.0, 1.0, 10.0, 20.0)

        );

    }

    #[test]

    fn parse_svg_transform_matrix_with_wrong_arity_is_identity() {

        assert_identity(&parse_svg_transform("matrix(1,2,3)"));

        assert_identity(&parse_svg_transform("matrix(1,2,3,4,5,6,7)"));

        assert_identity(&parse_svg_transform("matrix()"));

    }

    #[test]

    fn parse_svg_transform_translate_defaults_missing_ty_to_zero() {

        let t = parse_svg_transform("translate(10)");

        assert_eq!((t.tx, t.ty), (10.0, 0.0));

        let t = parse_svg_transform("translate(10, 20)");

        assert_eq!((t.tx, t.ty), (10.0, 20.0));

        assert_identity(&parse_svg_transform("translate()"));

    }

    #[test]

    fn parse_svg_transform_scale_defaults_sy_to_sx() {

        let t = parse_svg_transform("scale(2)");

        assert_eq!((t.sx, t.sy), (2.0, 2.0), "uniform scale when sy is omitted");

        let t = parse_svg_transform("scale(2,3)");

        assert_eq!((t.sx, t.sy), (2.0, 3.0));

        assert_identity(&parse_svg_transform("scale()"));

    }

    #[test]

    fn parse_svg_transform_scale_zero_is_degenerate_but_not_a_panic() {

        let t = parse_svg_transform("scale(0)");

        assert_eq!((t.sx, t.sy), (0.0, 0.0));

    }

    #[test]

    fn parse_svg_transform_rotate_90_degrees() {

        let t = parse_svg_transform("rotate(90)");

        assert!((t.sx - 0.0).abs() < 1e-9, "cos(90deg) ~ 0, got {}", t.sx);

        assert!((t.shy - 1.0).abs() < 1e-9, "sin(90deg) == 1, got {}", t.shy);

        assert!(

            (t.shx + 1.0).abs() < 1e-9,

            "-sin(90deg) == -1, got {}",

            t.shx

        );

        assert!((t.sy - 0.0).abs() < 1e-9);

        assert_eq!((t.tx, t.ty), (0.0, 0.0));

        assert_identity(&parse_svg_transform("rotate(0)"));

    }

    #[test]

    fn parse_svg_transform_rotate_with_center_ignores_the_center() {

        // `rotate(angle cx cy)` is legal SVG; the extra args are silently dropped

        // and the rotation happens around the origin instead of (cx, cy).

        let with_center = parse_svg_transform("rotate(90 50 50)");

        let without = parse_svg_transform("rotate(90)");

        assert_eq!((with_center.tx, with_center.ty), (0.0, 0.0));

        assert_eq!(with_center.sx, without.sx);

    }

    #[test]

    fn parse_svg_transform_unclosed_paren_is_identity() {

        assert_identity(&parse_svg_transform("translate(10"));

        assert_identity(&parse_svg_transform("matrix(1,2,3,4,5,6"));

        assert_identity(&parse_svg_transform("scale(2"));

    }

    #[test]

    fn parse_svg_transform_is_case_sensitive() {

        // Uppercase function names are not SVG-legal, so identity is acceptable —

        // pinned so that adding a lowercasing pass is a deliberate change.

        assert_identity(&parse_svg_transform("TRANSLATE(10,20)"));

        assert_identity(&parse_svg_transform("Scale(2)"));

    }

    #[test]

    fn parse_svg_transform_leading_trailing_junk() {

        // Leading/trailing *whitespace* is trimmed...

        let t = parse_svg_transform("  translate(10,20)  ");

        assert_eq!((t.tx, t.ty), (10.0, 20.0));

        // ...but trailing junk breaks the `)` suffix match -> identity.

        assert_identity(&parse_svg_transform("translate(10,20);garbage"));

        assert_identity(&parse_svg_transform("junk translate(10,20)"));

    }

    #[test]

    fn parse_svg_transform_transform_list_keeps_only_the_first_function() {

        // SVG allows a whitespace-separated transform *list*. This parser only

        // understands a single function: for "translate(10,20) scale(2)" the

        // strip_suffix(')') leaves "10,20) scale(2" as the argument text, whose

        // only parseable number is 10 -> ty and the whole scale() are dropped.

        //

        // Characterization, not an endorsement — see the report: a transform

        // list renders *wrong* (ty lost, scale ignored) rather than crashing.

        let t = parse_svg_transform("translate(10,20) scale(2)");

        assert_eq!((t.sx, t.sy), (1.0, 1.0), "scale() silently dropped");

        assert_eq!((t.tx, t.ty), (10.0, 0.0), "translate ty silently dropped");

    }

    #[test]

    fn parse_svg_transform_garbage_is_identity_never_panics() {

        for s in [

            "!!!",

            "()",

            "(((",

            ")))",

            "matrix",

            "translate",

            "\u{0}\u{1}",

            "matrix(,,,,,)",

            "scale(,)",

        ] {

            let t = parse_svg_transform(s);

            assert!(t.sx.is_finite(), "{s} produced a non-finite sx");

        }

    }

    #[test]

    fn parse_svg_transform_boundary_numbers_saturate_not_panic() {

        let t = parse_svg_transform("translate(1e400, -1e400)");

        assert!(t.tx.is_infinite() && t.tx > 0.0, "1e400 -> +inf");

        assert!(t.ty.is_infinite() && t.ty < 0.0, "-1e400 -> -inf");

        let t = parse_svg_transform("scale(NaN)");

        assert!(t.sx.is_nan() && t.sy.is_nan(), "NaN propagates, no panic");

        let t = parse_svg_transform("rotate(NaN)");

        assert!(t.sx.is_nan() && t.shy.is_nan());

        let t = parse_svg_transform("scale(inf)");

        assert!(t.sx.is_infinite());

        let t = parse_svg_transform("translate(-0, 9223372036854775807)");

        assert!(t.tx.is_sign_negative() && t.tx == 0.0, "-0 stays -0.0");

        assert!(t.ty.is_finite(), "i64::MAX fits in f64");

        let t = parse_svg_transform("matrix(1e308,1e308,1e308,1e308,1e308,1e308)");

        assert!(t.sx.is_finite());

    }

    #[test]

    fn parse_svg_transform_unicode_args_are_dropped_not_panic() {

        let t = parse_svg_transform("translate(\u{1F600},\u{1F600})");

        assert_eq!((t.tx, t.ty), (0.0, 0.0));

        assert_identity(&parse_svg_transform("\u{1F600}"));

        // rotate() with an unparseable angle defaults to 0 -> cos 1 / sin 0.

        assert_identity(&parse_svg_transform("rotate(\u{4F60}\u{597D})"));

    }

    #[test]

    fn parse_svg_transform_deeply_nested_input_does_not_stack_overflow() {

        // 10_000 nested "translate(" — the parser is flat (strip_prefix + split),

        // so this must stay linear, never recursive.

        const DEPTH: usize = 10_000;

        let s = format!("{}1{}", "translate(".repeat(DEPTH), ")".repeat(DEPTH));

        let t = parse_svg_transform(&s);

        // The inner text has no separators, so it is one unparseable token.

        assert_eq!((t.tx, t.ty), (0.0, 0.0));

        assert_eq!((t.sx, t.sy), (1.0, 1.0));

    }

    #[test]

    fn parse_svg_transform_extremely_long_arg_list_does_not_hang() {

        let inner = "1,".repeat(200_000);

        let s = format!("translate({inner}1)");

        let t = parse_svg_transform(&s);

        assert_eq!((t.tx, t.ty), (1.0, 1.0), "only the first two args are used");

    }

    // ==================================================================

    // parse_viewbox  (parser)

    // ==================================================================

    #[test]

    fn parse_viewbox_missing_attribute_is_none() {

        assert_eq!(parse_viewbox(&el("svg", &[])), None);

        assert_eq!(parse_viewbox(&el("svg", &[("width", "10")])), None);

    }

    #[test]

    fn parse_viewbox_valid_minimal_both_spellings() {

        // Real SVG uses camelCase `viewBox`; the lowercase key is the fallback

        // for lowercasing XML parsers. Both must work.

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", "0 0 100 50")])),

            Some((0.0, 0.0, 100.0, 50.0))

        );

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewbox", "0 0 100 50")])),

            Some((0.0, 0.0, 100.0, 50.0))

        );

    }

    #[test]

    fn parse_viewbox_accepts_comma_and_mixed_separators() {

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", "0,0,100,50")])),

            Some((0.0, 0.0, 100.0, 50.0))

        );

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", " -1 , -2\t3.5\n4.5 ")])),

            Some((-1.0, -2.0, 3.5, 4.5))

        );

    }

    #[test]

    fn parse_viewbox_wrong_arity_is_none() {

        for v in ["", "   ", "0", "0 0", "0 0 100", "0 0 100 50 25"] {

            assert_eq!(

                parse_viewbox(&el("svg", &[("viewBox", v)])),

                None,

                "viewBox={v:?} must require exactly 4 numbers"

            );

        }

    }

    #[test]

    fn parse_viewbox_garbage_tokens_are_silently_dropped() {

        // filter_map(parse) drops unparseable tokens *before* the len == 4 check,

        // so junk in the middle of an otherwise-valid viewBox is ignored rather

        // than rejected. Characterization: lenient, not unsafe.

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", "0 0 junk 100 50")])),

            Some((0.0, 0.0, 100.0, 50.0))

        );

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", "0 0 100 50 trailing")])),

            Some((0.0, 0.0, 100.0, 50.0))

        );

        // ...but if nothing parses at all it is correctly None.

        assert_eq!(parse_viewbox(&el("svg", &[("viewBox", "a b c d")])), None);

        assert_eq!(parse_viewbox(&el("svg", &[("viewBox", "###")])), None);

    }

    #[test]

    fn parse_viewbox_unit_suffixes_are_rejected() {

        // "0 0 100px 50px" -> the px tokens do not parse -> only 2 numbers -> None.

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", "0 0 100px 50px")])),

            None

        );

    }

    #[test]

    fn parse_viewbox_boundary_numbers() {

        let vb = parse_viewbox(&el("svg", &[("viewBox", "NaN 0 100 50")])).expect("4 numbers");

        assert!(vb.0.is_nan(), "NaN parses and propagates, no panic");

        let vb = parse_viewbox(&el("svg", &[("viewBox", "0 0 1e400 -1e400")])).expect("4 numbers");

        assert!(vb.2.is_infinite() && vb.2 > 0.0);

        assert!(vb.3.is_infinite() && vb.3 < 0.0);

        let vb = parse_viewbox(&el("svg", &[("viewBox", "-0 0 0 0")])).expect("4 numbers");

        assert!(vb.0.is_sign_negative() && vb.0 == 0.0, "-0 stays -0.0");

        assert_eq!((vb.2, vb.3), (0.0, 0.0), "a zero-area viewBox is accepted");

        let vb = parse_viewbox(&el(

            "svg",

            &[("viewBox", "9223372036854775807 -9223372036854775808 1 1")],

        ))

        .expect("4 numbers");

        assert!(

            vb.0.is_finite() && vb.1.is_finite(),

            "i64 bounds fit in f64"

        );

        let vb = parse_viewbox(&el("svg", &[("viewBox", "0 0 inf inf")])).expect("4 numbers");

        assert!(vb.2.is_infinite());

    }

    #[test]

    fn parse_viewbox_unicode_is_none_not_panic() {

        assert_eq!(

            parse_viewbox(&el(

                "svg",

                &[("viewBox", "\u{1F600} \u{1F600} \u{1F600} \u{1F600}")]

            )),

            None

        );

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", "\u{4F60}\u{597D}")])),

            None

        );

    }

    #[test]

    fn parse_viewbox_extremely_long_value_does_not_hang() {

        let huge = "1 ".repeat(200_000);

        assert_eq!(

            parse_viewbox(&el("svg", &[("viewBox", huge.as_str())])),

            None,

            "200k numbers != 4 -> None, and it must not hang getting there"

        );

    }

    // ==================================================================

    // attr_f64

    // ==================================================================

    #[test]

    fn attr_f64_missing_key_is_zero() {

        assert_eq!(attr_f64(&el("rect", &[]), "width"), 0.0);

        assert_eq!(attr_f64(&el("rect", &[("height", "5")]), "width"), 0.0);

    }

    #[test]

    fn attr_f64_valid_minimal() {

        assert_eq!(attr_f64(&el("rect", &[("width", "42.5")]), "width"), 42.5);

        assert_eq!(attr_f64(&el("rect", &[("x", "-3")]), "x"), -3.0);

        assert_eq!(attr_f64(&el("rect", &[("x", "1e3")]), "x"), 1000.0);

    }

    #[test]

    fn attr_f64_key_lookup_is_case_sensitive() {

        assert_eq!(attr_f64(&el("rect", &[("Width", "10")]), "width"), 0.0);

    }

    #[test]

    fn attr_f64_unparseable_values_fall_back_to_zero() {

        // NOTE: `f64::from_str` neither trims whitespace nor accepts CSS units,

        // so both of these collapse to 0.0 — which downstream means "no width"

        // and the shape is skipped entirely. See the report.

        assert_eq!(attr_f64(&el("rect", &[("width", "100px")]), "width"), 0.0);

        assert_eq!(attr_f64(&el("rect", &[("width", " 100 ")]), "width"), 0.0);

        assert_eq!(attr_f64(&el("rect", &[("width", "50%")]), "width"), 0.0);

        assert_eq!(attr_f64(&el("rect", &[("width", "")]), "width"), 0.0);

        assert_eq!(attr_f64(&el("rect", &[("width", "abc")]), "width"), 0.0);

        assert_eq!(

            attr_f64(&el("rect", &[("width", "\u{1F600}")]), "width"),

            0.0

        );

    }

    #[test]

    fn attr_f64_boundary_numbers_are_sanitized_to_finite() {

        // attr_f64 now clamps to a finite range (NaN -> 0, ±inf/huge -> ±1e6) so

        // pathological attributes cannot flow into geometry and hang the flattener.

        assert_eq!(attr_f64(&el("rect", &[("width", "NaN")]), "width"), 0.0);

        assert_eq!(attr_f64(&el("rect", &[("width", "inf")]), "width"), 1.0e6);

        assert_eq!(attr_f64(&el("rect", &[("width", "1e400")]), "width"), 1.0e6);

        assert_eq!(attr_f64(&el("rect", &[("width", "1e-400")]), "width"), 0.0);

        let neg_zero = attr_f64(&el("rect", &[("x", "-0")]), "x");

        assert!(neg_zero.is_sign_negative() && neg_zero == 0.0);

        let big = attr_f64(&el("rect", &[("x", "9223372036854775807")]), "x");