//! CSS properties for visual effects (opacity, blending, cursor), box sizing

//! (object-fit, object-position, aspect-ratio), and text orientation.

use alloc::string::{String, ToString};

use core::fmt;

#[cfg(feature = "parser")]

use crate::props::basic::{

    error::{InvalidValueErr, InvalidValueErrOwned},

    length::parse_percentage_value,

};

use crate::props::{

    basic::length::{PercentageParseError, PercentageValue},

    formatter::PrintAsCssValue,

};

// -- Opacity --

/// Represents an `opacity` attribute, a value from 0.0 to 1.0.

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct StyleOpacity {

    pub inner: PercentageValue,

}

impl Default for StyleOpacity {

}

impl PrintAsCssValue for StyleOpacity {

}

#[cfg(feature = "parser")]

impl_percentage_value!(StyleOpacity);

// -- Visibility --

/// Represents a `visibility` attribute, controlling element visibility.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum StyleVisibility {

    #[default]

    Visible,

    Hidden,

    Collapse,

}

impl PrintAsCssValue for StyleVisibility {

        })

}

// -- Mix Blend Mode --

/// Represents a `mix-blend-mode` attribute, which determines how an element's

/// content should blend with the content of the element's parent.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum StyleMixBlendMode {

    #[default]

    Normal,

    Multiply,

    Screen,

    Overlay,

    Darken,

    Lighten,

    ColorDodge,

    ColorBurn,

    HardLight,

    SoftLight,

    Difference,

    Exclusion,

    Hue,

    Saturation,

    Color,

    Luminosity,

}

impl fmt::Display for StyleMixBlendMode {

            }

        )

}

impl PrintAsCssValue for StyleMixBlendMode {

}

// -- Cursor --

/// Represents a `cursor` attribute, defining the mouse cursor to be displayed

/// when pointing over an element.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum StyleCursor {

    Alias,

    AllScroll,

    Cell,

    ColResize,

    ContextMenu,

    Copy,

    Crosshair,

    #[default]

    Default,

    EResize,

    EwResize,

    Grab,

    Grabbing,

    Help,

    Move,

    NResize,

    NsResize,

    NeswResize,

    NwseResize,

    Pointer,

    Progress,

    RowResize,

    SResize,

    SeResize,

    Text,

    Unset,

    VerticalText,

    WResize,

    Wait,

    ZoomIn,

    ZoomOut,

}

impl PrintAsCssValue for StyleCursor {

        })

}

// --- PARSERS ---

#[cfg(feature = "parser")]

pub mod parsers {

    #[allow(clippy::wildcard_imports)] // parser submodule reuses the parent module's value types

    use super::*;

    use crate::corety::AzString;

    use crate::props::basic::error::{InvalidValueErr, InvalidValueErrOwned};

    // -- Opacity Parser --

    #[derive(Clone, PartialEq, Eq)]

    pub enum OpacityParseError<'a> {

        ParsePercentage(PercentageParseError, &'a str),

        OutOfRange(&'a str),

    }

    impl_debug_as_display!(OpacityParseError<'a>);

    impl_display! { OpacityParseError<'a>, {

        ParsePercentage(e, s) => format!("Invalid opacity value \"{}\": {}", s, e),

        OutOfRange(s) => format!("Invalid opacity value \"{}\": must be between 0 and 1", s),

    }}

    /// Wrapper for `PercentageParseError` with input string.

    #[derive(Debug, Clone, PartialEq, Eq)]

    #[repr(C)]

    pub struct PercentageParseErrorWithInput {

        pub error: PercentageParseError,

        pub input: AzString,

    }

    #[derive(Debug, Clone, PartialEq, Eq)]

    #[repr(C, u8)]

    pub enum OpacityParseErrorOwned {

        ParsePercentage(PercentageParseErrorWithInput),

        OutOfRange(AzString),

    }

    impl OpacityParseError<'_> {

                }

            }

    }

    impl OpacityParseErrorOwned {

                }

            }

    }

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `opacity` value.

    // -- Visibility Parser --

    #[derive(Clone, PartialEq, Eq)]

    pub enum StyleVisibilityParseError<'a> {

        InvalidValue(InvalidValueErr<'a>),

    }

    impl_debug_as_display!(StyleVisibilityParseError<'a>);

    impl_display! { StyleVisibilityParseError<'a>, {

        InvalidValue(e) => format!("Invalid visibility value: \"{}\"", e.0),

    }}

    impl_from!(InvalidValueErr<'a>, StyleVisibilityParseError::InvalidValue);

    #[derive(Debug, Clone, PartialEq, Eq)]

    #[repr(C, u8)]

    pub enum StyleVisibilityParseErrorOwned {

        InvalidValue(InvalidValueErrOwned),

    }

    impl StyleVisibilityParseError<'_> {

                }

            }

    }

    impl StyleVisibilityParseErrorOwned {

            }

    }

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `visibility` value.

        }

    // -- Mix Blend Mode Parser --

    #[derive(Clone, PartialEq, Eq)]

    pub enum MixBlendModeParseError<'a> {

        InvalidValue(InvalidValueErr<'a>),

    }

    impl_debug_as_display!(MixBlendModeParseError<'a>);

    impl_display! { MixBlendModeParseError<'a>, {

        InvalidValue(e) => format!("Invalid mix-blend-mode value: \"{}\"", e.0),

    }}

    impl_from!(InvalidValueErr<'a>, MixBlendModeParseError::InvalidValue);

    #[derive(Debug, Clone, PartialEq, Eq)]

    #[repr(C, u8)]

    pub enum MixBlendModeParseErrorOwned {

        InvalidValue(InvalidValueErrOwned),

    }

    impl MixBlendModeParseError<'_> {

                }

            }

    }

    impl MixBlendModeParseErrorOwned {

            }

    }

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `mix-blend-mode` value.

        }

    // -- Cursor Parser --

    #[derive(Clone, PartialEq, Eq)]

    pub enum CursorParseError<'a> {

        InvalidValue(InvalidValueErr<'a>),

    }

    impl_debug_as_display!(CursorParseError<'a>);

    impl_display! { CursorParseError<'a>, {

        InvalidValue(e) => format!("Invalid cursor value: \"{}\"", e.0),

    }}

    impl_from!(InvalidValueErr<'a>, CursorParseError::InvalidValue);

    #[derive(Debug, Clone, PartialEq, Eq)]

    #[repr(C, u8)]

    pub enum CursorParseErrorOwned {

        InvalidValue(InvalidValueErrOwned),

    }

    impl CursorParseError<'_> {

            }

    }

    impl CursorParseErrorOwned {

            }

    }

    /// # Errors

    ///

    /// Returns an error if `input` is not a valid CSS `cursor` value.

        }

}

#[cfg(feature = "parser")]

pub use self::parsers::*;

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

mod tests {

    // Tests assert that parsed values equal the exact source literals.

    #![allow(clippy::float_cmp)]

    use super::*;

    #[test]

            0.75

        );

    #[test]

            StyleMixBlendMode::Multiply

        );

            StyleMixBlendMode::Screen

        );

            StyleMixBlendMode::ColorDodge

        );

    #[test]

            StyleVisibility::Visible

        );

            StyleVisibility::Hidden

        );

            StyleVisibility::Collapse

        );

            StyleVisibility::Visible

        );

    #[test]

            StyleCursor::ColResize

        );

    #[test]

    #[test]

    #[test]

        use crate::props::style::background::{BackgroundPositionHorizontal, BackgroundPositionVertical};

    #[test]

            StyleAspectRatio::Ratio(AspectRatioValue { width: 16000, height: 9000 })

        );

            StyleAspectRatio::Ratio(AspectRatioValue { width: 16000, height: 9000 })

        );

            StyleAspectRatio::Ratio(AspectRatioValue { width: 1500, height: 1000 })

        );

            StyleAspectRatio::Ratio(AspectRatioValue { width: 4000, height: 3000 })

        );

}

// -- StyleObjectFit --

/// CSS object-fit property: how replaced element content is fitted to its box.

/// CSS Images Level 3 §5.5

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum StyleObjectFit {

    #[default]

    Fill,

    Contain,

    Cover,

    None,

    ScaleDown,

}

crate::impl_option!(StyleObjectFit, OptionStyleObjectFit, [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

impl PrintAsCssValue for StyleObjectFit {

        })

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum StyleObjectFitParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

crate::impl_debug_as_display!(StyleObjectFitParseError<'a>);

#[cfg(feature = "parser")]

crate::impl_display! { StyleObjectFitParseError<'a>, {

    InvalidValue(val) => format!("Invalid object-fit value: \"{}\"", val),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum StyleObjectFitParseErrorOwned {

    InvalidValue(crate::AzString),

}

#[cfg(feature = "parser")]

impl StyleObjectFitParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl StyleObjectFitParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `object-fit` value.

    }

// -- StyleTextOrientation --

/// CSS text-orientation property for vertical writing modes.

/// CSS Writing Modes Level 4 §5.1

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

#[derive(Default)]

pub enum StyleTextOrientation {

    #[default]

    Mixed,

    Upright,

    Sideways,

}

crate::impl_option!(StyleTextOrientation, OptionStyleTextOrientation, [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

impl PrintAsCssValue for StyleTextOrientation {

        })

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum StyleTextOrientationParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

crate::impl_debug_as_display!(StyleTextOrientationParseError<'a>);

#[cfg(feature = "parser")]

crate::impl_display! { StyleTextOrientationParseError<'a>, {

    InvalidValue(val) => format!("Invalid text-orientation value: \"{}\"", val),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum StyleTextOrientationParseErrorOwned {

    InvalidValue(crate::AzString),

}

#[cfg(feature = "parser")]

impl StyleTextOrientationParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl StyleTextOrientationParseErrorOwned {

        }

}

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `text-orientation` value.

    }

// -- StyleObjectPosition --

/// CSS object-position property: position of replaced element content within its box.

/// CSS Images Level 3 §5.6 — default: `50% 50%` (centered)

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct StyleObjectPosition {

    pub horizontal: crate::props::style::background::BackgroundPositionHorizontal,

    pub vertical: crate::props::style::background::BackgroundPositionVertical,

}

impl Default for StyleObjectPosition {

        use crate::props::basic::pixel::PixelValue;

}

crate::impl_option!(StyleObjectPosition, OptionStyleObjectPosition, [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

impl PrintAsCssValue for StyleObjectPosition {

        )

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum StyleObjectPositionParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

crate::impl_debug_as_display!(StyleObjectPositionParseError<'a>);

#[cfg(feature = "parser")]

crate::impl_display! { StyleObjectPositionParseError<'a>, {

    InvalidValue(val) => format!("Invalid object-position value: \"{}\"", val),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum StyleObjectPositionParseErrorOwned {

    InvalidValue(crate::AzString),

}

#[cfg(feature = "parser")]

impl StyleObjectPositionParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl StyleObjectPositionParseErrorOwned {

        }

}

/// Parse object-position: accepts keyword pairs or percentage/length values.

/// Examples: "center", "left top", "50% 50%", "10px 20px"

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `object-position` value.

    use crate::props::style::background::{

        BackgroundPositionHorizontal, BackgroundPositionVertical,

    };

    use crate::props::basic::pixel::parse_pixel_value;

        1 => {

                _ => {

                }

            }

        }

        2 => {

            // <position>: [left|center|right|<len>] || [top|center|bottom|<len>].

            // The `||` combinator lets two *keywords* appear in either order, so

            // canonicalize to (horizontal, vertical) first. A length in either

            // slot forces positional order (first = horizontal, second = vertical).

                }

            };

                }

            };

        }

    };

// -- StyleAspectRatio --

/// Width/height ratio stored as fixed-point (value * 1000).

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C)]

pub struct AspectRatioValue {

    pub width: u32,

    pub height: u32,

}

impl AspectRatioValue {

    /// Format one fixed-point component (`value * 1000`) back to its CSS number,

    /// dropping the scale and any trailing fractional zeros: 16000 -> "16",

    /// 1500 -> "1.5". Used by `PrintAsCssValue` so a printed ratio re-parses to

    /// the same value (integer math, no lossy f32 cast).

        } else {

        }

}

#[allow(variant_size_differences)] // repr(C,u8) FFI enum: boxing the large variant would change the C ABI (api.json bindings); size disparity accepted

/// CSS aspect-ratio property: preferred aspect ratio for the box.

/// CSS Box Sizing Level 4 §6 — values: `auto | <ratio>` (initial: `auto`)

///

/// Stored as width/height ratio. Auto means no preferred ratio.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

#[repr(C, u8)]

#[derive(Default)]

pub enum StyleAspectRatio {

    /// No preferred aspect ratio

    #[default]

    Auto,

    /// Fixed ratio (width / height), stored as fixed-point (value * 1000)

    Ratio(AspectRatioValue),

}

crate::impl_option!(StyleAspectRatio, OptionStyleAspectRatio, [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]);

impl PrintAsCssValue for StyleAspectRatio {

            ),

        }

}

#[cfg(feature = "parser")]

#[derive(Clone, PartialEq, Eq)]

pub enum StyleAspectRatioParseError<'a> {

    InvalidValue(&'a str),

}

#[cfg(feature = "parser")]

crate::impl_debug_as_display!(StyleAspectRatioParseError<'a>);

#[cfg(feature = "parser")]

crate::impl_display! { StyleAspectRatioParseError<'a>, {

    InvalidValue(val) => format!("Invalid aspect-ratio value: \"{}\"", val),

}}

#[cfg(feature = "parser")]

#[derive(Debug, Clone, PartialEq, Eq)]

#[repr(C, u8)]

pub enum StyleAspectRatioParseErrorOwned {

    InvalidValue(crate::AzString),

}

#[cfg(feature = "parser")]

impl StyleAspectRatioParseError<'_> {

        }

}

#[cfg(feature = "parser")]

impl StyleAspectRatioParseErrorOwned {

        }

}

/// Truncating `f32` → `u32` for aspect-ratio values (callers validate the input

/// is positive and bounded, so the value always fits). Rust's `as u32` saturates

/// out-of-range floats; this isolates the one unavoidable float→int cast.

#[cfg(feature = "parser")]

#[inline]

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]

/// Validate two ratio components and encode them into the fixed-point

/// [`AspectRatioValue`]. The positive-range checks are written as

/// `!(x > 0.0 && x <= MAX)` so NaN — which is false for every ordered

/// comparison — is rejected instead of sailing through the guards. A component

/// whose fixed-point encoding rounds to 0 (magnitude below ~0.0005) is a

/// degenerate divide-by-zero ratio and is rejected as well.

#[cfg(feature = "parser")]

/// Parse aspect-ratio: "auto", "16 / 9", "1.5", "4/3"

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `aspect-ratio` value.

    // Try "w / h" or "w/h" format

    // A single number is the "<w> / 1" ratio.

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

#[allow(

    clippy::float_cmp,

    clippy::unreadable_literal,

    clippy::too_many_lines,

    clippy::cast_precision_loss

)]

mod autotest_generated {

    use super::*;

    use crate::{

        props::{

            basic::{

                error::ParseFloatError as CssParseFloatError, pixel::PixelValue,

            },

            formatter::PrintAsCssValue,

            style::background::{BackgroundPositionHorizontal, BackgroundPositionVertical},

        },

    };

    const ALL_VISIBILITY: [StyleVisibility; 3] = [

        StyleVisibility::Visible,

        StyleVisibility::Hidden,

        StyleVisibility::Collapse,

    ];

    const ALL_BLEND_MODES: [StyleMixBlendMode; 16] = [

        StyleMixBlendMode::Normal,

        StyleMixBlendMode::Multiply,

        StyleMixBlendMode::Screen,

        StyleMixBlendMode::Overlay,

        StyleMixBlendMode::Darken,

        StyleMixBlendMode::Lighten,

        StyleMixBlendMode::ColorDodge,

        StyleMixBlendMode::ColorBurn,

        StyleMixBlendMode::HardLight,

        StyleMixBlendMode::SoftLight,

        StyleMixBlendMode::Difference,

        StyleMixBlendMode::Exclusion,

        StyleMixBlendMode::Hue,

        StyleMixBlendMode::Saturation,

        StyleMixBlendMode::Color,

        StyleMixBlendMode::Luminosity,

    ];

    const ALL_CURSORS: [StyleCursor; 30] = [

        StyleCursor::Alias,

        StyleCursor::AllScroll,

        StyleCursor::Cell,

        StyleCursor::ColResize,

        StyleCursor::ContextMenu,

        StyleCursor::Copy,

        StyleCursor::Crosshair,

        StyleCursor::Default,

        StyleCursor::EResize,

        StyleCursor::EwResize,

        StyleCursor::Grab,

        StyleCursor::Grabbing,

        StyleCursor::Help,

        StyleCursor::Move,

        StyleCursor::NResize,

        StyleCursor::NsResize,

        StyleCursor::NeswResize,

        StyleCursor::NwseResize,

        StyleCursor::Pointer,

        StyleCursor::Progress,

        StyleCursor::RowResize,

        StyleCursor::SResize,

        StyleCursor::SeResize,

        StyleCursor::Text,

        StyleCursor::Unset,

        StyleCursor::VerticalText,

        StyleCursor::WResize,

        StyleCursor::Wait,

        StyleCursor::ZoomIn,

        StyleCursor::ZoomOut,

    ];

    const ALL_OBJECT_FIT: [StyleObjectFit; 5] = [

        StyleObjectFit::Fill,

        StyleObjectFit::Contain,

        StyleObjectFit::Cover,

        StyleObjectFit::None,

        StyleObjectFit::ScaleDown,

    ];

    const ALL_TEXT_ORIENTATION: [StyleTextOrientation; 3] = [

        StyleTextOrientation::Mixed,

        StyleTextOrientation::Upright,

        StyleTextOrientation::Sideways,

    ];

    /// Inputs no keyword parser may ever accept, and none may panic on.

    /// Deliberately mixes empty / whitespace / punctuation / multibyte input.

    const HOSTILE_KEYWORDS: [&str; 14] = [

        "",

        " ",

        "\t\n\r",

        "\u{a0}",           // NBSP — `str::trim` treats it as whitespace

        ";",

        "{}",

        "/*",

        "0",

        "-1",

        "NaN",

        "inf",

        "\u{1F600}",        // emoji

        "e\u{0301}",        // combining acute accent

        "\u{0665}",         // ARABIC-INDIC DIGIT FIVE (multibyte, `is_numeric`)

    ];

    // ------------------------------------------------ StyleMixBlendMode::fmt ---

    #[test]

    fn blend_mode_display_is_well_formed_for_every_variant() {

        for mode in ALL_BLEND_MODES {

            let shown = mode.to_string();

            assert!(!shown.is_empty(), "{mode:?} renders as an empty string");

            assert!(

                shown

                    .chars()

                    .all(|c| c.is_ascii_lowercase() || c == '-'),

                "{mode:?} renders as {shown:?}, which is not a CSS ident"

            );

            // `PrintAsCssValue` delegates to `Display`; pin them together so a

            // future divergence has to be deliberate.

            assert_eq!(shown, mode.print_as_css_value());

        }

    }

    #[test]

    fn blend_mode_display_of_default_is_normal() {

        assert_eq!(StyleMixBlendMode::default().to_string(), "normal");

        assert_eq!(StyleMixBlendMode::default(), StyleMixBlendMode::Normal);

    }

    #[test]

    fn blend_mode_display_survives_width_and_precision_flags() {

        // The impl forwards through `write!(f, "{}", ..)` instead of `f.pad(..)`,

        // so the caller's width/precision/fill flags are dropped rather than

        // applied. Not a panic, but pin it: `{:>10}` does NOT pad.

        assert_eq!(format!("{:>10}", StyleMixBlendMode::Normal), "normal");

        assert_eq!(format!("{:.2}", StyleMixBlendMode::Multiply), "multiply");

        assert_eq!(format!("{:*^30}", StyleMixBlendMode::ColorDodge), "color-dodge");

    }

    // ----------------------------------------------------- parse_style_opacity ---

    #[test]

    fn opacity_rejects_empty_and_whitespace_only_input() {

        for input in ["", " ", "   ", "\t\n", "\r\n\t ", "\u{a0}"] {

            assert!(

                parse_style_opacity(input).is_err(),

                "{input:?} must not parse as an opacity"

            );

        }

    }

    #[test]

    fn opacity_rejects_garbage() {

        for input in [

            "auto", "abc", "%", ";;;", "50%%", "#0.5", "0.5;garbage", "1 2", "rgb(0,0,0)",

            "0,5", "--", "..", "-", ".",

        ] {

            assert!(

                parse_style_opacity(input).is_err(),

                "{input:?} must not parse as an opacity"

            );

        }

    }

    #[test]

    fn opacity_boundary_numbers() {

        // In range.

        assert_eq!(parse_style_opacity("0").unwrap().inner.normalized(), 0.0);

        assert_eq!(parse_style_opacity("1").unwrap().inner.normalized(), 1.0);

        assert_eq!(parse_style_opacity("0%").unwrap().inner.normalized(), 0.0);

        assert_eq!(parse_style_opacity("100%").unwrap().inner.normalized(), 1.0);

        // `-0.0 == 0.0` under IEEE-754, so the `0.0..=1.0` guard accepts it.

        assert_eq!(parse_style_opacity("-0").unwrap().inner.normalized(), 0.0);

        assert_eq!(parse_style_opacity("-0%").unwrap().inner.normalized(), 0.0);

        // Below the fixed-point resolution: quantized to 0, still in range.

        assert!(parse_style_opacity("0.0000001").is_ok());

        // Out of range.

        for input in ["1.001", "1.1", "2", "101%", "-0.001", "-1", "-100%"] {

            assert!(

                matches!(

                    parse_style_opacity(input),

                    Err(OpacityParseError::OutOfRange(_))

                ),

                "{input:?} should be rejected as out-of-range"

            );

        }

        // Float extremes: `str::parse::<f32>` maps 1e39 to +inf, which must not

        // panic through the fixed-point cast and must land out of range.

        for input in ["1e39", "3.5e38", "9223372036854775807", "1e30"] {

            assert!(

                parse_style_opacity(input).is_err(),

                "{input:?} should be rejected as out-of-range"

            );

        }

        // `NaN` / `inf` contain no numeric char, so the scanner bails out first.

        for input in ["NaN", "nan", "inf", "infinity", "-inf", "-NaN"] {

            assert!(

                parse_style_opacity(input).is_err(),

                "{input:?} should be rejected"

            );

        }

    }

    #[test]

    fn opacity_trims_but_rejects_trailing_junk() {

        assert_eq!(

            parse_style_opacity("  0.5  ").unwrap().inner.normalized(),

            0.5

        );

        assert_eq!(

            parse_style_opacity("\t50%\n").unwrap().inner.normalized(),

            0.5

        );

        for input in ["0.5;", "0.5 !important", "0.5px", "0.5 0.5"] {

            assert!(

                parse_style_opacity(input).is_err(),

                "{input:?} must not parse as an opacity"

            );

        }

        // Lax, pinned: the unit is trimmed *after* being split off the number, so

        // an internal space between value and unit is accepted even though CSS

        // forbids it.

        assert_eq!(parse_style_opacity("50 %").unwrap().inner.normalized(), 0.5);

    }

    #[test]

    fn opacity_non_numeric_unicode_does_not_panic() {

        // Multibyte input whose *last* numeric char is ASCII (or which has no

        // numeric char at all) must be rejected without slicing mid-codepoint.

        // See `known_bug_opacity_multibyte_numeric_char_panics` for the case

        // that does not hold.

        for input in [

            "\u{1F600}",         // emoji only

            "\u{1F600}0.5",      // emoji then ASCII digits

            "0.5\u{0301}",       // digits then a combining acute accent

            "\u{2603}%",         // snowman + percent sign

            "\u{4F60}\u{597D}",  // CJK

            "\u{202E}0.5",       // RTL override