//! Types and methods used to describe the style of an application.

//!

//! This module defines the core CSS data model:

//!

//! - [`Css`] contains one or more [`Stylesheet`]s, each holding [`CssRuleBlock`]s.

//! - A [`CssRuleBlock`] pairs a [`CssPath`] (selector) with [`CssDeclaration`]s (properties).

//! - [`CssPropertyValue<T>`] wraps individual property values with CSS keywords

//!   (`auto`, `inherit`, `initial`, etc.).

//! - [`BoxOrStatic<T>`] is a smart-pointer enum for heap-allocated or static CSS values.

//! - [`NodeTypeTag`] enumerates all recognized HTML/SVG element types for selector matching.

use alloc::{string::String, vec::Vec};

use core::fmt;

use crate::{

    corety::OptionString,

    dynamic_selector::DynamicSelectorVec,

    props::property::{CssProperty, CssPropertyType},

    AzString,

};

/// Css stylesheet - contains a parsed CSS stylesheet in "rule blocks",

/// i.e. blocks of key-value pairs associated with a selector path.

///

/// Layer separation (UA / system / author / inline / runtime) is encoded

/// per-rule via `CssRuleBlock::priority`; see [`rule_priority`] for the

/// slot allocation. There is no separate `Stylesheet` wrapper — to merge

/// two CSS sources, concatenate their `rules` and re-sort.

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

#[repr(C)]

pub struct Css {

    /// All rule blocks, in source order. Sort by `(priority, specificity)`

    /// via `sort_by_specificity` to put them in cascade order.

    pub rules: CssRuleBlockVec,

    /// Every `@keyframes` block in this stylesheet, in source order. Web

    /// compatibility sugar: internally each named track compiles to an

    /// animation-function invocation (`animation` / `-azul-animation-in` /

    /// `-azul-animation-out` reference these by name).

    pub keyframes: KeyframesVec,

}

/// One stop of a `@keyframes` block (`from` = 0, `to` = 1000, `12.5%` = 125).

///

/// Permille rather than an f32 percentage so the type stays `Eq`-capable —

/// `Css` must remain `Eq`/`Ord` (`NodeData` carries it), and 0.1% resolution is

/// beyond anything a keyframe needs.

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

#[repr(C)]

pub struct KeyframeStop {

    /// 0..=1000 position of this stop.

    pub permille: u16,

    /// The property values at this stop.

    pub props: crate::props::property::CssPropertyVec,

}

/// A named `@keyframes` block: `@keyframes flyOutRight { from {..} to {..} }`.

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

#[repr(C)]

pub struct Keyframes {

    pub name: AzString,

    /// Sorted by `permille` ascending at parse time.

    pub stops: KeyframeStopVec,

}

crate::impl_vec!(

    KeyframeStop,

    KeyframeStopVec,

    KeyframeStopVecDestructor,

    KeyframeStopVecDestructorType,

    KeyframeStopVecSlice,

    OptionKeyframeStop

);

crate::impl_vec_mut!(KeyframeStop, KeyframeStopVec);

crate::impl_vec_debug!(KeyframeStop, KeyframeStopVec);

crate::impl_vec_clone!(KeyframeStop, KeyframeStopVec, KeyframeStopVecDestructor);

crate::impl_vec_partialeq!(KeyframeStop, KeyframeStopVec);

crate::impl_vec_eq!(KeyframeStop, KeyframeStopVec);

crate::impl_option!(

    KeyframeStop,

    OptionKeyframeStop,

    copy = false,

    [Debug, Clone, PartialEq, Eq]

);

crate::impl_vec!(

    Keyframes,

    KeyframesVec,

    KeyframesVecDestructor,

    KeyframesVecDestructorType,

    KeyframesVecSlice,

    OptionKeyframes

);

crate::impl_vec_mut!(Keyframes, KeyframesVec);

crate::impl_vec_debug!(Keyframes, KeyframesVec);

crate::impl_vec_clone!(Keyframes, KeyframesVec, KeyframesVecDestructor);

crate::impl_vec_partialeq!(Keyframes, KeyframesVec);

crate::impl_vec_eq!(Keyframes, KeyframesVec);

crate::impl_option!(

    Keyframes,

    OptionKeyframes,

    copy = false,

    [Debug, Clone, PartialEq, Eq]

);

impl_option!(

    Css,

    OptionCss,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd]

);

impl_vec!(Css, CssVec, CssVecDestructor, CssVecDestructorType, CssVecSlice, OptionCss);

impl_vec_mut!(Css, CssVec);

impl_vec_debug!(Css, CssVec);

impl_vec_partialord!(Css, CssVec);

impl_vec_clone!(Css, CssVec, CssVecDestructor);

impl_vec_partialeq!(Css, CssVec);

impl_vec!(CssRuleBlock, CssRuleBlockVec, CssRuleBlockVecDestructor, CssRuleBlockVecDestructorType, CssRuleBlockVecSlice, OptionCssRuleBlock);

impl_vec_mut!(CssRuleBlock, CssRuleBlockVec);

impl_vec_debug!(CssRuleBlock, CssRuleBlockVec);

impl_vec_partialord!(CssRuleBlock, CssRuleBlockVec);

impl_vec_clone!(CssRuleBlock, CssRuleBlockVec, CssRuleBlockVecDestructor);

impl_vec_partialeq!(CssRuleBlock, CssRuleBlockVec);

impl Css {

    /// The viewport-size thresholds (widths, heights, logical px) at which

    /// any `@media (min-/max-width/height)` rule in this stylesheet can flip.

    /// Sorted, deduplicated by bit pattern. Used by the engine's resize

    /// decision instead of a hardcoded breakpoint list.

    #[must_use]

    #[cfg(feature = "parser")]

    // takes the owned C-ABI `AzString` by value by FFI ownership-transfer convention,

    // even though only a string slice is read here.

    #[allow(clippy::needless_pass_by_value)]

    /// Parse inline-style CSS (bare properties, pseudo blocks, @-rule blocks)

    /// and return a `Css` whose rules carry `rule_priority::INLINE`.

    ///

    /// Wraps the input in `* { ... }` so the main CSS parser can handle bare

    /// properties at the top level. Pseudo and at-rule blocks like

    /// `:hover { color: red; }` or `@os(linux) { font-size: 14px; }` work

    /// directly via CSS nesting.

    #[cfg(feature = "parser")]

        use alloc::string::ToString;

        // A `}` in `style` closes the `* {` wrapper early, so the remainder is parsed as

        // a free-standing rule with a caller-controlled selector (selector injection).

        // Every rule an inline style produces MUST stay rooted at the `*` wrapper, so

        // drop any that isn't Global-rooted. Legitimate pseudo/at-rule nesting stays a

        // child of `*` (still Global-rooted per push_front_scope), so it is kept.

                None | Some(CssPathSelector::Global)

            )

    #[cfg(feature = "parser")]

    // takes the owned C-ABI `AzString` by value by FFI ownership-transfer convention,

    // even though only a string slice is read here.

    #[allow(clippy::needless_pass_by_value)]

        (

        )

}

impl From<Vec<CssRuleBlock>> for Css {

}

// NodeData derives Eq + Ord and carries `Css` as its inline style. Provide

// length-based ordering so the derives keep working — the same pattern the

// previous `CssPropertyWithConditionsVec` used.

impl Eq for Css {}

// PartialOrd delegates to the length-based Ord so the two agree (the derived

// field-wise PartialOrd diverged from this manual Ord).

impl PartialOrd for Css {

}

impl Ord for Css {

}

impl Eq for CssRuleBlock {}

impl Ord for CssRuleBlock {

        // Match the existing PartialOrd: path first, then declarations.

        // Priority is intentionally not in the sort key — it's a layer label,

        // not a comparison primitive for callers.

}

/// Convert a flat list of `CssPropertyWithConditions` (the legacy inline-CSS form)

/// into a `Css`. Each property becomes a single-declaration `CssRuleBlock` with

/// `priority = INLINE`, an empty path (implicitly `:scope` — applies to the node it

/// lives on), and the original conditions intact.

///

/// This bridge lets widget code that built `&[CssPropertyWithConditions]` arrays

/// keep working through `.into()` while the storage on `NodeData` is the unified

/// `Css` type.

impl From<crate::dynamic_selector::CssPropertyWithConditionsVec> for Css {

        // Build via an explicit push loop rather than `.into_iter().map(|p| CssRuleBlock {

        // declarations: vec![...], ... }).collect()`. On the web/remill lift, constructing a

        // complex struct with nested Vecs *inside* a mapped+collected closure drops every

        // element (AzButton's inline container style came back with 0 rules even though the

        // source Vec had props), whereas the identical construction in a plain loop body lifts

        // correctly — same pattern `NodeData::add_css_property` already relies on. Native

        // behavior is byte-identical.

}

/// Contains one parsed `key: value` pair, static or dynamic

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

#[repr(C, u8)]

pub enum CssDeclaration {

    /// Static key-value pair, such as `width: 500px`

    Static(CssProperty),

    /// Dynamic key-value pair with default value, such as `width: [[ my_id | 500px ]]`

    Dynamic(DynamicCssProperty),

}

impl_option!(

    CssDeclaration,

    OptionCssDeclaration,

    copy = false,

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

);

impl CssDeclaration {

    /// Returns the type of the property (i.e. the CSS key as a typed enum)

        use self::CssDeclaration::{Static, Dynamic};

        }

    /// Determines if the property will be inherited (applied to the children)

    /// during the recursive application of the style on the DOM tree

        use self::CssDeclaration::{Static, Dynamic};

        }

    /// Returns whether this rule affects only styling properties or layout

    /// properties (that could trigger a re-layout)

        use self::CssDeclaration::{Static, Dynamic};

        }

        use self::CssDeclaration::{Static, Dynamic};

        }

}

/// A `DynamicCssProperty` is a type of css property that can be changed on possibly

/// every frame by the Rust code - for example to implement an `On::Hover` behaviour.

///

/// The syntax for such a property looks like this:

///

/// ```no_run,ignore

/// #my_div {

///    padding: var(--my_dynamic_property_id, 400px);

/// }

/// ```

///

/// Azul will register a dynamic property with the key "`my_dynamic_property_id`"

/// and the default value of 400px. If the property gets overridden during one frame,

/// the overridden property takes precedence.

///

/// At runtime the style is immutable (which is a performance optimization - if we

/// can assume that the property never changes at runtime), we can do some optimizations on it.

/// Dynamic style properties can also be used for animations and conditional styles

/// (i.e. `hover`, `focus`, etc.), thereby leading to cleaner code, since all of these

/// special cases now use one single API.

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

#[repr(C)]

pub struct DynamicCssProperty {

    /// The stringified ID of this property, i.e. the `"my_id"` in `width: var(--my_id, 500px)`.

    pub dynamic_id: AzString,

    /// Default values for this properties - one single value can control multiple properties!

    pub default_value: CssProperty,

}

/// A value that is either heap-allocated (parsed at runtime) or a compile-time

/// static reference.

///

/// Used to reduce enum size for large CSS property payloads

/// by storing them behind a pointer instead of inline.

///

/// - Size: 1 (tag) + 7 (padding) + 8 (pointer) = **16 bytes** on 64-bit

/// - `Static` variant: no allocation, just a `*const T` pointer to static data

/// - `Boxed` variant: heap-allocated via `Box::into_raw`, freed on Drop

#[repr(C, u8)]

pub enum BoxOrStatic<T> {

    /// Heap-allocated (parsed at runtime). Owned — freed on Drop.

    Boxed(*mut T),

    /// Compile-time constant (e.g. from `const` CSS defaults). Not freed.

    Static(*const T),

}

impl<T> BoxOrStatic<T> {

    /// Allocate `value` on the heap and return a `Boxed` variant.

    #[inline]

    /// Return a reference to the inner value.

    ///

    /// # Safety invariant

    /// The inner pointer must be non-null. This is guaranteed by [`heap`](Self::heap)

    /// and the `Static` constructor (which should always point to valid data).

    #[inline]

            },

            },

        }

    /// Return a mutable reference to the inner value (only for Boxed).

    ///

    /// # Panics

    ///

    /// Panics if called on a `Static` variant: static values are immutable

    /// and cannot hand out a `&mut`.

    #[inline]

        }

    /// Consume self and return the inner value.

    #[inline]

        // Clone the inner value, then let `self` drop normally so `Drop` frees the

        // heap box (for the Boxed variant). The old `mem::forget(self)` LEAKED that

        // box on every call — the clone is an independent value, so there is no

        // double-free to guard against.

}

impl<T> Drop for BoxOrStatic<T> {

}

impl<T: Clone> Clone for BoxOrStatic<T> {

            }

        }

}

impl<T: fmt::Debug> fmt::Debug for BoxOrStatic<T> {

}

impl<T: fmt::Display> fmt::Display for BoxOrStatic<T> {

}

impl<T: PartialEq> PartialEq for BoxOrStatic<T> {

}

impl<T: Eq> Eq for BoxOrStatic<T> {}

impl<T: core::hash::Hash> core::hash::Hash for BoxOrStatic<T> {

}

impl<T: PartialOrd> PartialOrd for BoxOrStatic<T> {

}

impl<T: Ord> Ord for BoxOrStatic<T> {

}

impl<T> core::ops::Deref for BoxOrStatic<T> {

    type Target = T;

    #[inline]

}

impl<T: Default> Default for BoxOrStatic<T> {

}

impl<T: PrintAsCssValue> PrintAsCssValue for BoxOrStatic<T> {

}

// Safety: BoxOrStatic<T> is Send if T is Send

unsafe impl<T: Send + 'static> Send for BoxOrStatic<T> {}

// Safety: BoxOrStatic<T> is Sync if T is Sync

unsafe impl<T: Sync + 'static> Sync for BoxOrStatic<T> {}

/// Type alias: `BoxOrStatic<StyleBoxShadow>` — used by codegen for FFI monomorphization.

pub type BoxOrStaticStyleBoxShadow = BoxOrStatic<crate::props::style::box_shadow::StyleBoxShadow>;

/// Type alias: `BoxOrStatic<AzString>` — used by `NodeType::Text` and `NodeType::Icon`.

pub type BoxOrStaticString = BoxOrStatic<AzString>;

/// A CSS property value that may be an explicit value or a CSS-wide keyword

/// (`auto`, `none`, `initial`, `inherit`, `revert`, `unset`).

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

#[repr(C, u8)] // necessary for ABI stability

pub enum CssPropertyValue<T> {

    Auto,

    None,

    Initial,

    Inherit,

    Revert,

    Unset,

    Exact(T),

}

/// Trait for types that can format themselves as a CSS property value string.

pub trait PrintAsCssValue {

    fn print_as_css_value(&self) -> String;

}

impl<T: PrintAsCssValue> CssPropertyValue<T> {

        }

}

impl<T: fmt::Display> fmt::Display for CssPropertyValue<T> {

        use self::CssPropertyValue::{Auto, None, Initial, Inherit, Revert, Unset, Exact};

        }

}

impl<T> From<T> for CssPropertyValue<T> {

}

impl<T> CssPropertyValue<T> {

    /// Transforms a `CssPropertyValue<T>` into a `CssPropertyValue<U>` by applying a mapping

    /// function

    #[inline]

        }

    #[inline]

        }

    #[inline]

        }

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

    #[inline]

}

impl<T: Default> CssPropertyValue<T> {

    #[inline]

        }

}

impl<T: Default> Default for CssPropertyValue<T> {

    #[inline]

}

impl DynamicCssProperty {

        // Dynamic style properties should not be inheritable,

        // since that could lead to bugs - you set a property in Rust, suddenly

        // the wrong UI component starts to react because it was inherited.

}

/// Layer priority for `CssRuleBlock`. Lower numbers cascade first;

/// higher numbers override earlier layers at the same specificity.

///

/// `u8` leaves 256 slots, so a new layer can be inserted between any

/// two existing slots without renumbering consumers. The gaps between

/// named slots are intentional — fill them with custom intermediate

/// layers if/when `@layer` lands.

pub mod rule_priority {

    /// User-Agent / framework defaults. Widget code that emits its

    /// own default CSS uses this. Lowest priority — anything else

    /// overrides it.

    pub const UA: u8 = 0;

    /// Stylesheets the host system reports (system fonts, theme CSS

    /// derived from `SystemStyle`). One step above UA so they win

    /// against framework defaults but lose against anything the app

    /// author writes.

    pub const SYSTEM: u8 = 10;

    /// Default for parser-produced rules: the app author's CSS.

    /// Everything coming out of `Css::from_string` lives here.

    pub const AUTHOR: u8 = 20;

    /// Inline `style="..."` / `NodeData::set_css(...)` rules — used

    /// once the inline-vs-component unification (separate plan) folds

    /// inline storage into the same Vec.

    pub const INLINE: u8 = 30;

    /// Reserved for direct-rule runtime overrides.

    ///

    /// Today the

    /// `prop_cache` handles runtime overrides via

    /// `user_overridden_properties`; this slot is reserved so a

    /// future "push a `CssRuleBlock` at runtime" path stays above

    /// inline. Used only when a callback writes a full rule, not a

    /// single property.

    pub const RUNTIME: u8 = 50;

}

/// One block of rules that applies a bunch of rules to a "path" in the style, i.e.

/// `div#myid.myclass -> { ("justify-content", "center") }`

///

/// The `conditions` field contains @media/@lang/etc. conditions that must ALL be

/// satisfied for this rule block to apply (from enclosing @-rule blocks).

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

#[repr(C)]

pub struct CssRuleBlock {

    /// The css path (full selector) of the style ruleset

    pub path: CssPath,

    /// `"justify-content: center"` =>

    /// `CssDeclaration::Static(CssProperty::JustifyContent(LayoutJustifyContent::Center))`

    pub declarations: CssDeclarationVec,

    /// Conditions from enclosing @-rules (@media, @lang, etc.) that must ALL be

    /// satisfied for this rule block to apply. Empty = unconditional.

    pub conditions: DynamicSelectorVec,

    /// Layer priority. See [`rule_priority`] for slot allocation.

    /// `0` = UA / framework, `20` = author CSS (default), higher = wins.

    /// Sort key combined with selector specificity in `sort_by_specificity`.

    pub priority: u8,

}

impl_option!(

    CssRuleBlock,

    OptionCssRuleBlock,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd]

);

impl PartialOrd for CssRuleBlock {

        // Compare by path and declarations only, conditions are not ordered

        }

}

impl_vec!(CssDeclaration, CssDeclarationVec, CssDeclarationVecDestructor, CssDeclarationVecDestructorType, CssDeclarationVecSlice, OptionCssDeclaration);

impl_vec_mut!(CssDeclaration, CssDeclarationVec);

impl_vec_debug!(CssDeclaration, CssDeclarationVec);

impl_vec_partialord!(CssDeclaration, CssDeclarationVec);

impl_vec_ord!(CssDeclaration, CssDeclarationVec);

impl_vec_clone!(

    CssDeclaration,

    CssDeclarationVec,

    CssDeclarationVecDestructor

);

impl_vec_partialeq!(CssDeclaration, CssDeclarationVec);

impl_vec_eq!(CssDeclaration, CssDeclarationVec);

impl_vec_hash!(CssDeclaration, CssDeclarationVec);

impl CssRuleBlock {

}

/// A group of CSS path selectors, used during selector matching.

pub type CssContentGroup<'a> = Vec<&'a CssPathSelector>;

/// Signifies the type of a DOM node without carrying any associated data

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

#[repr(C)]

pub enum NodeTypeTag {

    // Document structure

    Html,

    Head,

    Body,

    // Block-level elements

    Div,

    P,

    Article,

    Section,

    Nav,

    Aside,

    Header,

    Footer,

    Main,

    Figure,

    FigCaption,

    // Headings

    H1,

    H2,

    H3,

    H4,

    H5,

    H6,

    // Inline text

    Br,

    Hr,

    Pre,

    BlockQuote,

    Address,

    Details,

    Summary,

    Dialog,

    // Lists

    Ul,

    Ol,

    Li,

    Dl,

    Dt,

    Dd,

    Menu,

    MenuItem,

    Dir,

    // Tables

    Table,

    Caption,

    THead,

    TBody,

    TFoot,

    Tr,

    Th,

    Td,

    ColGroup,

    Col,

    // Forms

    Form,

    FieldSet,

    Legend,

    Label,

    Input,

    Button,

    Select,

    OptGroup,

    SelectOption,

    TextArea,

    Output,

    Progress,

    Meter,

    DataList,

    // Inline elements

    Span,

    A,

    Em,

    Strong,

    B,

    I,

    U,

    S,

    Mark,

    Del,

    Ins,

    Code,

    Samp,

    Kbd,

    Var,

    Cite,

    Dfn,

    Abbr,

    Acronym,

    Q,

    Time,

    Sub,

    Sup,

    Small,

    Big,

    Bdo,

    Bdi,

    Wbr,

    Ruby,

    Rt,

    Rtc,

    Rp,

    Data,

    // Embedded content

    Canvas,

    Object,

    Param,

    Embed,

    Audio,

    Video,

    Source,

    Track,

    Map,

    Area,

    Svg,

    /// SVG `<path>` element.

    SvgPath,

    /// SVG `<circle>` element.

    SvgCircle,

    /// SVG `<rect>` element.

    SvgRect,

    /// SVG `<ellipse>` element.

    SvgEllipse,

    /// SVG `<line>` element.

    SvgLine,

    /// SVG `<polygon>` element.

    SvgPolygon,

    /// SVG `<polyline>` element.

    SvgPolyline,

    /// SVG `<g>` group element.

    SvgG,

    // SVG container elements

    /// SVG `<defs>` element.

    SvgDefs,

    /// SVG `<symbol>` element.

    SvgSymbol,

    /// SVG `<use>` element.

    SvgUse,

    /// SVG `<switch>` element.

    SvgSwitch,

    // SVG text elements

    /// SVG `<text>` element.

    SvgText,

    /// SVG `<tspan>` element.

    SvgTspan,

    /// SVG `<textPath>` element.

    SvgTextPath,

    // SVG paint server elements

    /// SVG `<linearGradient>` element.

    SvgLinearGradient,

    /// SVG `<radialGradient>` element.

    SvgRadialGradient,

    /// SVG `<stop>` element.

    SvgStop,

    /// SVG `<pattern>` element.

    SvgPattern,

    // SVG clipping/masking elements

    /// SVG `<clipPath>` element.

    SvgClipPathElement,

    /// SVG `<mask>` element.

    SvgMask,

    // SVG filter elements

    /// SVG `<filter>` element.

    SvgFilter,

    /// SVG `<feBlend>` element.

    SvgFeBlend,

    /// SVG `<feColorMatrix>` element.

    SvgFeColorMatrix,

    /// SVG `<feComponentTransfer>` element.

    SvgFeComponentTransfer,

    /// SVG `<feComposite>` element.

    SvgFeComposite,

    /// SVG `<feConvolveMatrix>` element.

    SvgFeConvolveMatrix,

    /// SVG `<feDiffuseLighting>` element.

    SvgFeDiffuseLighting,

    /// SVG `<feDisplacementMap>` element.

    SvgFeDisplacementMap,

    /// SVG `<feDistantLight>` element.

    SvgFeDistantLight,

    /// SVG `<feDropShadow>` element.

    SvgFeDropShadow,

    /// SVG `<feFlood>` element.

    SvgFeFlood,

    /// SVG `<feFuncR>` element.

    SvgFeFuncR,

    /// SVG `<feFuncG>` element.

    SvgFeFuncG,

    /// SVG `<feFuncB>` element.

    SvgFeFuncB,

    /// SVG `<feFuncA>` element.

    SvgFeFuncA,

    /// SVG `<feGaussianBlur>` element.

    SvgFeGaussianBlur,

    /// SVG `<feImage>` element.

    SvgFeImage,

    /// SVG `<feMerge>` element.

    SvgFeMerge,

    /// SVG `<feMergeNode>` element.

    SvgFeMergeNode,

    /// SVG `<feMorphology>` element.

    SvgFeMorphology,

    /// SVG `<feOffset>` element.

    SvgFeOffset,

    /// SVG `<fePointLight>` element.

    SvgFePointLight,

    /// SVG `<feSpecularLighting>` element.

    SvgFeSpecularLighting,

    /// SVG `<feSpotLight>` element.

    SvgFeSpotLight,

    /// SVG `<feTile>` element.

    SvgFeTile,

    /// SVG `<feTurbulence>` element.

    SvgFeTurbulence,

    // SVG marker/image elements

    /// SVG `<marker>` element.

    SvgMarker,

    /// SVG `<image>` element.

    SvgImage,

    /// SVG `<foreignObject>` element.

    SvgForeignObject,

    // SVG descriptive elements

    /// SVG `<title>` element.

    SvgTitle,

    /// SVG `<desc>` element.

    SvgDesc,

    /// SVG `<metadata>` element.

    SvgMetadata,

    /// SVG `<a>` element.

    SvgA,

    /// SVG `<view>` element.

    SvgView,

    /// SVG `<style>` element.

    SvgStyle,

    /// SVG `<script>` element.

    SvgScript,

    // SVG animation elements

    /// SVG `<animate>` element.

    SvgAnimate,

    /// SVG `<animateMotion>` element.

    SvgAnimateMotion,

    /// SVG `<animateTransform>` element.

    SvgAnimateTransform,

    /// SVG `<set>` element.

    SvgSet,

    /// SVG `<mpath>` element.

    SvgMpath,

    // Metadata

    Title,

    Meta,

    Link,

    Script,

    Style,

    Base,

    // Special

    Text,

    Img,

    VirtualView,

    /// Icon element - resolved to actual content by `IconProvider`

    Icon,

    /// Invisible probe — `NodeType::GeolocationProbe`. Zero-size in

    /// layout, skipped in the display list. CSS tag: `geolocation-probe`.

    GeolocationProbe,

    // Pseudo-elements

    Before,

    After,

    Marker,

    Placeholder,

    /// THE canonical page-break element (`<pagebreak/>` /

    /// `Dom::create_page_break()`): an empty block with UA

    /// `break-before: page`. CSS tag: `pagebreak`.

    PageBreak,

}

/// Error returned when a CSS tag name string cannot be mapped to a [`NodeTypeTag`].

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

pub enum NodeTypeTagParseError<'a> {

    Invalid(&'a str),

}

impl fmt::Display for NodeTypeTagParseError<'_> {

        }

}

/// Owned version of [`NodeTypeTagParseError`] for storage across lifetime boundaries.

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

#[repr(C, u8)]

pub enum NodeTypeTagParseErrorOwned {

    Invalid(AzString),

}

impl NodeTypeTagParseError<'_> {

        }

}

impl NodeTypeTagParseErrorOwned {

        }

}

/// Parses the node type from a CSS string such as `"div"` => `NodeTypeTag::Div`

impl NodeTypeTag {

    #[allow(clippy::too_many_lines)] // large but cohesive: single-purpose CSS parser/formatter/dispatch table (one branch per property/variant)

    /// # Errors

    ///

    /// Returns an error if `css_key` is not a recognized HTML node-type tag.

            // Document structure

            // Block-level elements

            // Headings

            // Inline text

            // Lists

            // Tables

            // Forms

            // Inline elements

            // Embedded content

            // SVG shape elements

            // SVG container elements

            // SVG text elements

            // SVG paint server elements

            // SVG clipping/masking elements

            // SVG filter elements