//! CSS length and pixel value types, parsing, and unit resolution.

//!

//! Defines `PixelValue` (a numeric value + CSS unit like px, em, rem, %),

//! `ResolutionContext` (contextual information for resolving relative units),

//! and `PropertyContext` (which property is being resolved, affecting % and em semantics).

//!

//! **Resolution paths:**

//! - `resolve_with_context()` — the correct method for new code; properly distinguishes

//!   em vs rem, and resolves % based on property type per the CSS spec.

//! - `to_pixels_internal()` — legacy fallback used by `prop_cache.rs`; does not

//!   distinguish rem from em. Marked `#[doc(hidden)]`.

use core::fmt;

use std::num::ParseFloatError;

use crate::corety::AzString;

use crate::props::{

    basic::{error::ParseFloatErrorWithInput, FloatValue, SizeMetric},

    formatter::FormatAsCssValue,

};

/// Default font size in pixels (16px), matching the CSS "medium" keyword

/// and all major browser defaults (CSS 2.1 §15.7).

pub const DEFAULT_FONT_SIZE: f32 = 16.0;

/// Conversion factor from points to pixels (1pt = 1/72 inch, 1in = 96px, therefore 1pt = 96/72 px)

pub const PT_TO_PX: f32 = 96.0 / 72.0;

/// A normalized percentage value (0.0 = 0%, 1.0 = 100%)

///

/// This type prevents double-division bugs by making it explicit that the value

/// is already normalized to the 0.0-1.0 range. When you have a `NormalizedPercentage`,

/// you should multiply it directly with the containing block size, NOT divide by 100 again.

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

#[repr(transparent)]

pub struct NormalizedPercentage(f32);

impl NormalizedPercentage {

    /// Create a new percentage value from a normalized float (0.0-1.0)

    ///

    /// # Arguments

    /// * `value` - A normalized percentage where 0.0 = 0% and 1.0 = 100%

    #[inline]

    /// Create a percentage from an unnormalized value (0-100 scale)

    ///

    /// This divides by 100 internally, so you should use this when converting

    /// from CSS percentage syntax like "50%" which is stored as 50.0.

    #[inline]

    /// Get the raw normalized value (0.0-1.0)

    #[inline]

    /// Resolve this percentage against a containing block size

    ///

    /// This multiplies the normalized percentage by the containing block size.

    /// For example, 50% (0.5) of 640px = 320px.

    #[inline]

}

impl fmt::Display for NormalizedPercentage {

}

/// Logical size in CSS logical coordinate system

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

#[repr(C)]

pub struct CssLogicalSize {

    /// Inline-axis size (width in horizontal writing mode)

    pub inline_size: f32,

    /// Block-axis size (height in horizontal writing mode)

    pub block_size: f32,

}

impl CssLogicalSize {

    #[inline]

    /// Convert to physical size (width, height) in horizontal writing mode

    #[inline]

}

/// Physical size (always width x height, regardless of writing mode)

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

#[repr(C)]

pub struct PhysicalSize {

    pub width: f32,

    pub height: f32,

}

impl PhysicalSize {

    #[inline]

    /// Convert to logical size in horizontal writing mode

    #[inline]

}

/// Context information needed to properly resolve CSS units (em, rem, %) to pixels.

///

/// This struct contains all the contextual information that `PixelValue::resolve()`

/// needs to correctly convert relative units according to the CSS specification:

///

/// - **em** units: For most properties, em refers to the element's own computed font-size. For the

///   font-size property itself, em refers to the parent's computed font-size.

///

/// - **rem** units: Always refer to the root element's computed font-size.

///

/// - **%** units: Percentage resolution depends on the property:

///   - Width/height: relative to containing block dimensions

///   - Margin/padding: relative to containing block width (even top/bottom!)

///   - Border-radius: relative to element's own border box dimensions

///   - Font-size: relative to parent's font-size

#[derive(Debug, Copy, Clone)]

pub struct ResolutionContext {

    /// The computed font-size of the current element (for em in non-font properties)

    pub element_font_size: f32,

    /// The computed font-size of the parent element (for em in font-size property)

    pub parent_font_size: f32,

    /// The computed font-size of the root element (for rem units)

    pub root_font_size: f32,

    /// The containing block dimensions (for % in width/height/margins/padding)

    pub containing_block_size: PhysicalSize,

    /// The element's own border box size (for % in border-radius, transforms)

    /// May be None during first layout pass before size is determined

    pub element_size: Option<PhysicalSize>,

    /// Is the element in a VERTICAL writing mode (`vertical-rl`/`vertical-lr`)?

    /// css-writing-modes-4 §7.2: margin/padding percentages resolve against

    /// the containing block's INLINE size - the physical HEIGHT in vertical

    /// modes. Physical width/height percentages are unaffected.

    pub vertical_writing_mode: bool,

    /// The viewport size in CSS pixels (for vw, vh, vmin, vmax units)

    /// This is the layout viewport size, not physical screen size

    pub viewport_size: PhysicalSize,

}

impl Default for ResolutionContext {

}

impl ResolutionContext {

    /// Create a minimal context for testing or default resolution

    #[inline]

}

/// Specifies which property context we're resolving for, to determine correct reference values

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

pub enum PropertyContext {

    /// Resolving for the font-size property itself (em refers to parent)

    FontSize,

    /// Resolving for margin properties (% refers to containing block width)

    Margin,

    /// Resolving for padding properties (% refers to containing block width)

    Padding,

    /// Resolving for width or horizontal properties (% refers to containing block width)

    Width,

    /// Resolving for height or vertical properties (% refers to containing block height)

    Height,

    /// Resolving for border-width properties (only absolute lengths + em/rem, no % support)

    BorderWidth,

    /// Resolving for border-radius (% refers to element's own dimensions)

    BorderRadius,

    /// Resolving for transforms (% refers to element's own dimensions)

    Transform,

    /// Resolving for other properties (em refers to element font-size)

    Other,

}

/// A CSS length value consisting of a numeric value and a unit (px, em, rem, %, etc.).

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

#[repr(C)]

pub struct PixelValue {

    pub metric: SizeMetric,

    pub number: FloatValue,

}

impl PixelValue {

}

impl FormatAsCssValue for PixelValue {

}

impl crate::css::PrintAsCssValue for PixelValue {

}

impl crate::codegen::format::FormatAsRustCode for PixelValue {

            self.metric,

        )

}

// Manual Debug implementation, because the auto-generated one is nearly unreadable

impl fmt::Debug for PixelValue {

}

impl fmt::Display for PixelValue {

}

impl PixelValue {

    #[inline]

        const ZERO_PX: PixelValue = PixelValue::const_px(0);

    /// Same as `PixelValue::px()`, but only accepts whole numbers,

    /// since using `f32` in const fn is not yet stabilized.

    #[inline]

    /// Same as `PixelValue::em()`, but only accepts whole numbers,

    /// since using `f32` in const fn is not yet stabilized.

    #[inline]

    /// Creates an em value from a fractional number in const context.

    ///

    /// # Arguments

    /// * `pre_comma` - The integer part (e.g., 1 for 1.5em)

    /// * `post_comma` - The fractional part as digits (e.g., 5 for 0.5em, 83 for 0.83em)

    ///

    /// # Examples

    /// ```

    /// // 1.5em = const_em_fractional(1, 5)

    /// // 0.83em = const_em_fractional(0, 83)

    /// // 1.17em = const_em_fractional(1, 17)

    /// ```

    #[inline]

    /// Same as `PixelValue::pt()`, but only accepts whole numbers,

    /// since using `f32` in const fn is not yet stabilized.

    #[inline]

    /// Creates a pt value from a fractional number in const context.

    #[inline]

    /// Same as `PixelValue::percent()`, but only accepts whole numbers,

    /// since using `f32` in const fn is not yet stabilized.

    #[inline]

    /// Same as `PixelValue::in()`, but only accepts whole numbers,

    /// since using `f32` in const fn is not yet stabilized.

    #[inline]

    /// Same as `PixelValue::cm()`, but only accepts whole numbers,

    /// since using `f32` in const fn is not yet stabilized.

    #[inline]

    /// Same as `PixelValue::mm()`, but only accepts whole numbers,

    /// since using `f32` in const fn is not yet stabilized.

    #[inline]

    #[inline]

    /// Creates a `PixelValue` from a fractional number in const context.

    ///

    /// # Arguments

    /// * `metric` - The size metric (Px, Em, Pt, etc.)

    /// * `pre_comma` - The integer part

    /// * `post_comma` - The fractional part as digits

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[allow(clippy::suboptimal_flops)] // explicit FP; mul_add slower without +fma

        } else {

            // Interpolate between different metrics by converting to px

            // Note: Uses DEFAULT_FONT_SIZE for em/rem - acceptable for animation fallback

            )

        }

    /// Returns the value of the `SizeMetric` as a normalized percentage (0.0 = 0%, 1.0 = 100%)

    ///

    /// Returns `Some(NormalizedPercentage)` if this is a percentage value, `None` otherwise.

    /// The returned `NormalizedPercentage` is already normalized to 0.0-1.0 range,

    /// so you should multiply it directly with the containing block size.

    #[inline]

        }

    /// Internal fallback method for converting to pixels with manual % resolution.

    ///

    /// Used internally by prop_cache.rs resolve_property_dependency().

    ///

    /// **DO NOT USE directly!** Use `resolve_with_context()` instead for new code.

    #[doc(hidden)]

    #[inline]

            SizeMetric::Percent => {

            }

            // Viewport units: Cannot resolve without viewport context, return 0

            // These should use resolve_with_context() instead

        }

    /// Resolve this value to pixels using proper CSS context.

    ///

    /// This is the **CORRECT** way to resolve CSS units. It properly handles:

    /// - em units: Uses element's own font-size (or parent's for font-size property)

    /// - rem units: Uses root element's font-size

    /// - % units: Uses property-appropriate reference (containing block width/height, element size,

    ///   etc.)

    /// - Absolute units: px, pt, in, cm, mm (already correct)

    ///

    /// # Arguments

    /// * `context` - Resolution context with font sizes and dimensions

    /// * `property_context` - Which property we're resolving for (affects % and em resolution)

    #[inline]

            // Absolute units - already correct

            // Em units - CRITICAL: different resolution for font-size vs other properties

            SizeMetric::Em => {

                    // Em on font-size refers to parent's font-size (CSS 2.1 §15.7)

                } else {

                    // Em on other properties refers to element's own font-size (CSS 2.1 §10.5)

                };

            }

            // Rem units - ALWAYS refer to root font-size (CSS Values 3)

            // Viewport units - refer to viewport dimensions (CSS Values 3 §6.2)

            // 1vw = 1% of viewport width, 1vh = 1% of viewport height

            // vmin = smaller of vw or vh

            SizeMetric::Vmin => {

            }

            // vmax = larger of vw or vh

            SizeMetric::Vmax => {

            }

            // Percent units - reference depends on property type

            SizeMetric::Percent => {

                // Width and Other deliberately both resolve to containing-block width but are

                // kept as separate arms for documentation / likely future divergence.

                #[allow(clippy::match_same_arms)]

                    // Font-size %: refers to parent's font-size (CSS 2.1 §15.7)

                    // Width and horizontal properties: containing block width (CSS 2.1 §10.3)

                    // Height and vertical properties: containing block height (CSS 2.1 §10.5)

                    // +spec:box-model:66e123 - margin/padding % resolved against inline size (= width in horizontal-tb)

                    // +spec:width-calculation:bef810 - margin percentages refer to containing block width (even top/bottom)

                    // Margins: ALWAYS containing block WIDTH, even for top/bottom! (CSS 2.1 §8.3)

                    // +spec:width-calculation:d78514 - margin percentages refer to width of containing block

                    // Padding: ALWAYS containing block WIDTH, even for top/bottom! (CSS 2.1 §8.4)

                    PropertyContext::Margin | PropertyContext::Padding => {

                        // CSS3 (writing-modes-4 §7.2) upgrades CSS 2.1's

                        // "always width" to "the INLINE size": physical width

                        // in horizontal-tb, physical HEIGHT in vertical-rl/lr.

                        } else {

                        }

                    }

                    // Border-width: % is NOT valid per CSS spec (CSS Backgrounds 3 §4.1)

                    // Return 0.0 if someone tries to use % on border-width

                    // Border-radius: element's own dimensions (CSS Backgrounds 3 §5.1)

                    // Note: More complex - horizontal % uses width, vertical % uses height

                    // For now, use width as default

                    PropertyContext::BorderRadius => {

                    }

                    // Transforms: element's own dimensions (CSS Transforms §20.1)

                    PropertyContext::Transform => {

                    }

                    // Other properties: default to containing block width

                };

            }

        }

}

// border-width: thin / medium / thick keyword values

// These are the canonical CSS definitions and should be used consistently

// across parsing and resolution.

/// border-width: thin = 1px (per CSS spec)

pub const THIN_BORDER_THICKNESS: PixelValue = PixelValue {

    metric: SizeMetric::Px,

    number: FloatValue { number: 1000 },

};

/// border-width: medium = 3px (per CSS spec, default)

pub const MEDIUM_BORDER_THICKNESS: PixelValue = PixelValue {

    metric: SizeMetric::Px,

    number: FloatValue { number: 3000 },

};

/// border-width: thick = 5px (per CSS spec)

pub const THICK_BORDER_THICKNESS: PixelValue = PixelValue {

    metric: SizeMetric::Px,

    number: FloatValue { number: 5000 },

};

/// Same as `PixelValue`, but doesn't allow a "%" sign

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

#[repr(C)]

pub struct PixelValueNoPercent {

    pub inner: PixelValue,

}

impl PixelValueNoPercent {

}

impl_option!(

    PixelValueNoPercent,

    OptionPixelValueNoPercent,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl_option!(

    PixelValue,

    OptionPixelValue,

    [Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash]

);

impl fmt::Display for PixelValueNoPercent {

}

impl ::core::fmt::Debug for PixelValueNoPercent {

}

impl PixelValueNoPercent {

    /// Internal conversion to pixels (no percent support).

    ///

    /// Used internally by prop_cache.rs.

    ///

    /// **DO NOT USE directly!** Use `resolve_with_context()` on inner value instead.

    #[doc(hidden)]

    #[inline]

    #[inline]

        const ZERO_PXNP: PixelValueNoPercent = PixelValueNoPercent {

            inner: PixelValue::zero(),

        };

}

impl From<PixelValue> for PixelValueNoPercent {

}

#[derive(Clone, PartialEq, Eq)]

pub enum CssPixelValueParseError<'a> {

    EmptyString,

    NoValueGiven(&'a str, SizeMetric),

    ValueParseErr(ParseFloatError, &'a str),

    InvalidPixelValue(&'a str),

}

impl_debug_as_display!(CssPixelValueParseError<'a>);

impl_display! { CssPixelValueParseError<'a>, {

    EmptyString => format!("Missing [px / pt / em / %] value"),

    NoValueGiven(input, metric) => format!("Expected floating-point pixel value, got: \"{}{}\"", input, metric),

    ValueParseErr(err, number_str) => format!("Could not parse \"{}\" as floating-point value: \"{}\"", number_str, err),

    InvalidPixelValue(s) => format!("Invalid pixel value: \"{}\"", s),

}}

/// Wrapper for `NoValueGiven` error in pixel value parsing.

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

#[repr(C)]

pub struct PixelNoValueGivenError {

    pub value: AzString,

    pub metric: SizeMetric,

}

/// Owned version of `CssPixelValueParseError`.

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

#[repr(C, u8)]

pub enum CssPixelValueParseErrorOwned {

    EmptyString,

    NoValueGiven(PixelNoValueGivenError),

    ValueParseErr(ParseFloatErrorWithInput),

    InvalidPixelValue(AzString),

}

impl CssPixelValueParseError<'_> {

            }

            }

            }

        }

}

impl CssPixelValueParseErrorOwned {

            }

            }

            }

        }

}

/// parses an angle value like `30deg`, `1.64rad`, `100%`, etc.

                }

                }

            }

    }

    )

/// # Errors

///

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

    )

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `pixel-value-no-percent` value.

    Ok(PixelValueNoPercent {

    })

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

pub enum PixelValueWithAuto {

    None,

    Initial,

    Inherit,

    Auto,

    Exact(PixelValue),

}

/// Parses a pixel value, but also tries values like "auto", "initial", "inherit" and "none"

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `pixel-value-with-auto` value.

    }

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

// System Metric References (system:button-padding, system:button-radius, etc.)

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

/// Reference to a specific system metric value.

/// These are resolved at runtime based on the user's system preferences.

/// 

/// CSS syntax: `system:button-padding`, `system:button-radius`, `system:titlebar-height`, etc.

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

#[repr(C)]

#[derive(Default)]

pub enum SystemMetricRef {

    /// Button corner radius (system:button-radius)

    #[default]

    ButtonRadius,

    /// Button horizontal padding (system:button-padding-horizontal)

    ButtonPaddingHorizontal,

    /// Button vertical padding (system:button-padding-vertical)

    ButtonPaddingVertical,

    /// Button border width (system:button-border-width)

    ButtonBorderWidth,

    /// Titlebar height (system:titlebar-height)

    TitlebarHeight,

    /// Titlebar button area width (system:titlebar-button-width)

    TitlebarButtonWidth,

    /// Titlebar horizontal padding (system:titlebar-padding)

    TitlebarPadding,

    /// Safe area top inset for notched devices (system:safe-area-top)

    SafeAreaTop,

    /// Safe area bottom inset (system:safe-area-bottom)

    SafeAreaBottom,

    /// Safe area left inset (system:safe-area-left)

    SafeAreaLeft,

    /// Safe area right inset (system:safe-area-right)

    SafeAreaRight,

}

impl SystemMetricRef {

    /// Resolve this system metric reference against actual system metrics.

        }

    /// Returns the CSS string representation of this system metric reference.

        }

    /// Parse a system metric reference from a CSS string (without the "system:" prefix).

        }

}

impl fmt::Display for SystemMetricRef {

}

impl FormatAsCssValue for SystemMetricRef {

}

/// A pixel value reference that can be either a concrete value or a system metric.

/// System metrics are lazily evaluated at runtime based on the user's system theme.

/// 

/// CSS syntax: `10px`, `1.5em`, `system:button-padding`, etc.

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

#[repr(C, u8)]

pub enum PixelValueOrSystem {

    /// A concrete pixel value.

    Value(PixelValue),

    /// A reference to a system metric, resolved at runtime.

    System(SystemMetricRef),

}

impl Default for PixelValueOrSystem {

}

impl From<PixelValue> for PixelValueOrSystem {

}

impl PixelValueOrSystem {

    /// Create a new `PixelValueOrSystem` from a concrete value.

    /// Create a new `PixelValueOrSystem` from a system metric reference.

    /// Resolve the pixel value against a `SystemMetrics` struct.

    /// Returns the system metric if available, or falls back to the provided default.

        }

}

impl fmt::Display for PixelValueOrSystem {

        }

}

impl FormatAsCssValue for PixelValueOrSystem {

        }

}

/// Parse a pixel value that may include system metric references.

/// 

/// Accepts: `10px`, `1.5em`, `system:button-padding`, etc.

#[cfg(feature = "parser")]

/// # Errors

///

/// Returns an error if `input` is not a valid CSS `pixel-value-or-system` value.

    // Check for system metric reference

    // Parse as regular pixel value

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

mod tests {

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

    #![allow(clippy::float_cmp)]

    use super::*;

    #[test]

    #[test]

        // Element has font-size: 32px, margin: 0.67em

        // Margin em uses element's own font-size

        );

        // Font-size em uses parent's font-size

            32.0

        );

    #[test]

        // Root has font-size: 18px

        // Rem always uses root font-size, regardless of property

            36.0

        );

            27.0

        );

    #[test]

        // Margin % uses containing block WIDTH (even for top/bottom!)

            80.0

        ); // 10% of 800

    #[test]

        );

    #[test]

        );

            PixelValueWithAuto::Auto

        );

            PixelValueWithAuto::Initial

        );

            PixelValueWithAuto::Inherit

        );

            PixelValueWithAuto::None

        );

    #[test]

        // Modern CSS parsers can be liberal - unitless numbers treated as px

                                                  // This parser is liberal and trims whitespace, so "10 px" is accepted

}

#[cfg(test)]

#[allow(

    clippy::float_cmp,

    clippy::unreadable_literal,

    clippy::cast_precision_loss,

    clippy::too_many_lines,

    clippy::excessive_precision

)]

mod autotest_generated {

    use std::{

        collections::hash_map::DefaultHasher,

        hash::{Hash, Hasher},

    };

    use super::*;

    use crate::{

        codegen::format::FormatAsRustCode,

        css::PrintAsCssValue,

        props::{

            basic::length::{FloatValue, SizeMetric},

            formatter::FormatAsCssValue,

        },

        system::{SafeAreaInsets, SystemMetrics, TitlebarMetrics},

    };

    /// `FloatValue` stores `f32 * 1000` truncated into an `isize`, so every value

    /// is quantized to 1/1000 and every `get()` is finite by construction.

    const MULT: f32 = 1000.0;

    /// `const_new` multiplies by 1000 in `isize` space, so anything beyond this

    /// overflows the multiply (debug-panics / release-wraps). The `const_*`

    /// constructors are only usable up to here.

    const MAX_SAFE_CONST: isize = isize::MAX / 1000;

    const MIN_SAFE_CONST: isize = isize::MIN / 1000;

    const ALL_METRICS: [SizeMetric; 12] = [

        SizeMetric::Px,

        SizeMetric::Pt,

        SizeMetric::Em,

        SizeMetric::Rem,

        SizeMetric::In,

        SizeMetric::Cm,

        SizeMetric::Mm,

        SizeMetric::Percent,

        SizeMetric::Vw,

        SizeMetric::Vh,

        SizeMetric::Vmin,

        SizeMetric::Vmax,

    ];

    const ALL_PROPERTY_CONTEXTS: [PropertyContext; 9] = [

        PropertyContext::FontSize,

        PropertyContext::Margin,

        PropertyContext::Padding,

        PropertyContext::Width,

        PropertyContext::Height,

        PropertyContext::BorderWidth,

        PropertyContext::BorderRadius,

        PropertyContext::Transform,

        PropertyContext::Other,

    ];

    const ALL_SYSTEM_REFS: [SystemMetricRef; 11] = [

        SystemMetricRef::ButtonRadius,

        SystemMetricRef::ButtonPaddingHorizontal,

        SystemMetricRef::ButtonPaddingVertical,

        SystemMetricRef::ButtonBorderWidth,

        SystemMetricRef::TitlebarHeight,

        SystemMetricRef::TitlebarButtonWidth,

        SystemMetricRef::TitlebarPadding,

        SystemMetricRef::SafeAreaTop,

        SystemMetricRef::SafeAreaBottom,

        SystemMetricRef::SafeAreaLeft,

        SystemMetricRef::SafeAreaRight,

    ];

    /// The values that historically break fixed-point encoders.

    const EXTREME_F32: [f32; 13] = [

        0.0,

        -0.0,

        1.0,

        -1.0,

        f32::MIN_POSITIVE,

        -f32::MIN_POSITIVE,

        1e30,

        -1e30,

        f32::MAX,

        f32::MIN,

        f32::INFINITY,

        f32::NEG_INFINITY,

        f32::NAN,

    ];

    fn approx(a: f32, b: f32) -> bool {

        (a - b).abs() < 0.001

    }

    fn hash_of<T: Hash>(v: &T) -> u64 {

        let mut h = DefaultHasher::new();

        v.hash(&mut h);

        h.finish()

    }

    /// Renders anything through the `FormatAsCssValue` impl, which is otherwise

    /// only reachable with a live `Formatter`.

    struct CssVal<T>(T);

    impl<T: FormatAsCssValue> fmt::Display for CssVal<T> {

        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

            self.0.format_as_css_value(f)

        }

    }

    fn as_css_value<T: FormatAsCssValue>(v: T) -> String {

        CssVal(v).to_string()

    }

    /// A context whose every reference value is distinct, so a resolver that

    /// reads the wrong field cannot accidentally produce the right number.

    fn distinct_context() -> ResolutionContext {

        ResolutionContext {

            vertical_writing_mode: false,

            element_font_size: 32.0,

            parent_font_size: 8.0,

            root_font_size: 4.0,

            containing_block_size: PhysicalSize::new(800.0, 600.0),