//! `StyledDom` — the result of applying CSS styles to a DOM tree.

//!

//! This module contains [`StyledDom`], which is produced by combining a [`Dom`]

//! with a [`Css`] stylesheet via [`StyledDom::create`]. It stores the flattened

//! node hierarchy, per-node styled states, cascade information, and the CSS

//! property cache. Restyle operations (`restyle_nodes_hover`, etc.) allow

//! incremental updates when pseudo-class states change at runtime.

//!

//! `StyledDom` is the primary input to the layout engine.

use alloc::{boxed::Box, collections::btree_map::BTreeMap, string::String, vec::Vec};

use core::{

    fmt,

    hash::{Hash, Hasher},

};

use azul_css::{

    css::Css,

    props::{

        basic::{StyleFontFamily, StyleFontFamilyVec, StyleFontSize},

        property::{

            BoxDecorationBreakValue, BreakInsideValue, CaretAnimationDurationValue,

            CaretColorValue, ColumnCountValue, ColumnFillValue, ColumnRuleColorValue,

            ColumnRuleStyleValue, ColumnRuleWidthValue, ColumnSpanValue, ColumnWidthValue,

            ContentValue, CounterIncrementValue, CounterResetValue, CssProperty, CssPropertyType,

            RelayoutScope,

            FlowFromValue, FlowIntoValue, LayoutAlignContentValue, LayoutAlignItemsValue,

            LayoutAlignSelfValue, LayoutBorderBottomWidthValue, LayoutBorderLeftWidthValue,

            LayoutBorderRightWidthValue, LayoutBorderTopWidthValue, LayoutBoxSizingValue,

            LayoutClearValue, LayoutColumnGapValue, LayoutDisplayValue, LayoutFlexBasisValue,

            LayoutFlexDirectionValue, LayoutFlexGrowValue, LayoutFlexShrinkValue,

            LayoutFlexWrapValue, LayoutFloatValue, LayoutGapValue, LayoutGridAutoColumnsValue,

            LayoutGridAutoFlowValue, LayoutGridAutoRowsValue, LayoutGridColumnValue,

            LayoutGridRowValue, LayoutGridTemplateColumnsValue, LayoutGridTemplateRowsValue,

            LayoutHeightValue, LayoutInsetBottomValue, LayoutJustifyContentValue,

            LayoutJustifyItemsValue, LayoutJustifySelfValue, LayoutLeftValue,

            LayoutMarginBottomValue, LayoutMarginLeftValue, LayoutMarginRightValue,

            LayoutMarginTopValue, LayoutMaxHeightValue, LayoutMaxWidthValue, LayoutMinHeightValue,

            LayoutMinWidthValue, LayoutOverflowValue, LayoutPaddingBottomValue,

            LayoutPaddingLeftValue, LayoutPaddingRightValue, LayoutPaddingTopValue,

            LayoutPositionValue, LayoutRightValue, LayoutRowGapValue, LayoutScrollbarWidthValue,

            LayoutTextJustifyValue, LayoutTopValue, LayoutWidthValue, LayoutWritingModeValue,

            LayoutZIndexValue, OrphansValue, PageBreakValue,

            SelectionBackgroundColorValue, SelectionColorValue, ShapeImageThresholdValue,

            ShapeMarginValue, ShapeOutsideValue, StringSetValue, StyleBackfaceVisibilityValue,

            StyleBackgroundContentVecValue, StyleBackgroundPositionVecValue,

            StyleBackgroundRepeatVecValue, StyleBackgroundSizeVecValue,

            StyleBorderBottomColorValue, StyleBorderBottomLeftRadiusValue,

            StyleBorderBottomRightRadiusValue, StyleBorderBottomStyleValue,

            StyleBorderLeftColorValue, StyleBorderLeftStyleValue, StyleBorderRightColorValue,

            StyleBorderRightStyleValue, StyleBorderTopColorValue, StyleBorderTopLeftRadiusValue,

            StyleBorderTopRightRadiusValue, StyleBorderTopStyleValue, StyleBoxShadowValue,

            StyleCursorValue, StyleDirectionValue, StyleFilterVecValue, StyleFontFamilyVecValue,

            StyleFontSizeValue, StyleFontValue, StyleHyphensValue, StyleLetterSpacingValue,

            StyleLineHeightValue, StyleMixBlendModeValue, StyleOpacityValue,

            StylePerspectiveOriginValue, StyleScrollbarColorValue, StyleTabSizeValue,

            StyleTextAlignValue, StyleTextColorValue, StyleTransformOriginValue,

            StyleTransformVecValue, StyleVisibilityValue, StyleWhiteSpaceValue,

            StyleWordSpacingValue, WidowsValue,

        },

        style::StyleTextColor,

    },

    AzString,

};

use crate::{

    callbacks::Update,

    dom::{Dom, DomId, NodeData, NodeDataVec, OptionTabIndex, TabIndex, TagId},

    events::{RelayoutNodes, RestyleNodes},

    id::{

        Node, NodeDataContainer, NodeDataContainerRef, NodeDataContainerRefMut, NodeHierarchy,

        NodeId,

    },

    menu::Menu,

    prop_cache::{CssPropertyCache, CssPropertyCachePtr},

    refany::RefAny,

    resources::{Au, ImageCache, ImageRef, ImmediateFontId, RendererResources},

    style::{

        construct_html_cascade_tree, matches_html_element, rule_ends_with, CascadeInfo,

        CascadeInfoVec,

    },

    FastBTreeSet, OrderedMap,

};

#[repr(C)]

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

pub struct ChangedCssProperty {

    pub previous_state: StyledNodeState,

    pub previous_prop: CssProperty,

    pub current_state: StyledNodeState,

    pub current_prop: CssProperty,

}

impl_option!(

    ChangedCssProperty,

    OptionChangedCssProperty,

    copy = false,

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

);

impl_vec!(ChangedCssProperty, ChangedCssPropertyVec, ChangedCssPropertyVecDestructor, ChangedCssPropertyVecDestructorType, ChangedCssPropertyVecSlice, OptionChangedCssProperty);

impl_vec_debug!(ChangedCssProperty, ChangedCssPropertyVec);

impl_vec_partialord!(ChangedCssProperty, ChangedCssPropertyVec);

impl_vec_clone!(

    ChangedCssProperty,

    ChangedCssPropertyVec,

    ChangedCssPropertyVecDestructor

);

impl_vec_partialeq!(ChangedCssProperty, ChangedCssPropertyVec);

/// Focus state change for restyle operations

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

pub struct FocusChange {

    /// Node that lost focus (if any)

    pub lost_focus: Option<NodeId>,

    /// Node that gained focus (if any)

    pub gained_focus: Option<NodeId>,

}

/// Hover state change for restyle operations

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

pub struct HoverChange {

    /// Nodes that the mouse left

    pub left_nodes: Vec<NodeId>,

    /// Nodes that the mouse entered

    pub entered_nodes: Vec<NodeId>,

}

/// Active (mouse down) state change for restyle operations

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

pub struct ActiveChange {

    /// Nodes that were deactivated (mouse up)

    pub deactivated: Vec<NodeId>,

    /// Nodes that were activated (mouse down)

    pub activated: Vec<NodeId>,

}

/// Result of a restyle operation, indicating what needs to be updated

#[derive(Debug, Clone, Default)]

pub struct RestyleResult {

    /// Nodes whose CSS properties changed, with details of the changes

    pub changed_nodes: RestyleNodes,

    /// Whether layout needs to be recalculated (layout properties changed)

    pub needs_layout: bool,

    /// Whether display list needs regeneration (visual properties changed)

    pub needs_display_list: bool,

    /// Whether only GPU-level properties changed (opacity, transform)

    /// If true and `needs_display_list` is false, we can update via GPU without display list rebuild

    pub gpu_only_changes: bool,

    /// The highest `RelayoutScope` seen across all property changes.

    ///

    /// This enables the IFC incremental layout optimization (Phase 2):

    /// - `None`      → repaint only, zero layout work

    /// - `IfcOnly`   → only the affected IFC needs re-shaping/repositioning

    /// - `SizingOnly`→ this node's size changed, parent repositions siblings

    /// - `Full`      → full subtree relayout

    ///

    /// When `max_relayout_scope <= IfcOnly`, the layout engine can skip

    /// full `calculate_layout_for_subtree` and use the IFC fast path instead.

    pub max_relayout_scope: RelayoutScope,

}

impl RestyleResult {

    /// Returns true if any changes occurred

    /// Merge another `RestyleResult` into this one

        // Keep the highest (most expensive) scope

}

/// NOTE: multiple states can be active at the same time

///

/// Tracks all CSS pseudo-class states for a node.

/// Each flag is independent - a node can be both :hover and :focus simultaneously.

#[repr(C)]

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

pub struct StyledNodeState {

    /// Element is being hovered (:hover)

    pub hover: bool,

    /// Element is active/being clicked (:active)

    pub active: bool,

    /// Element has focus (:focus)

    pub focused: bool,

    /// Element is disabled (:disabled)

    pub disabled: bool,

    /// Element is checked/selected (:checked)

    pub checked: bool,

    /// Element or descendant has focus (:focus-within)

    pub focus_within: bool,

    /// Link has been visited (:visited)

    pub visited: bool,

    /// Window is not focused (:backdrop) - GTK compatibility

    pub backdrop: bool,

    /// Element is currently being dragged (:dragging)

    pub dragging: bool,

    /// A dragged element is over this drop target (:drag-over)

    pub drag_over: bool,

}

impl fmt::Debug for StyledNodeState {

}

impl StyledNodeState {

    /// Creates a new state with all states set to false (normal state).

    /// Check if a specific pseudo-state is active

        }

    /// Returns true if no special state is active (just normal)

    /// Create from `PseudoStateFlags`

}

/// A styled Dom node

// Per-DOM-node hot type passed by reference throughout the layout/style

// pipeline; kept non-Copy on purpose so it isn't silently bulk-copied and to

// avoid trivially_copy_pass_by_ref churn across the many &StyledNode callers.

#[allow(missing_copy_implementations)]

#[repr(C)]

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

pub struct StyledNode {

    /// Current state of this styled node (used later for caching the style / layout)

    pub styled_node_state: StyledNodeState,

}

impl_option!(

    StyledNode,

    OptionStyledNode,

    copy = false,

    [Debug, Clone, PartialEq, Eq, PartialOrd]

);

impl_vec!(StyledNode, StyledNodeVec, StyledNodeVecDestructor, StyledNodeVecDestructorType, StyledNodeVecSlice, OptionStyledNode);

impl_vec_mut!(StyledNode, StyledNodeVec);

impl_vec_debug!(StyledNode, StyledNodeVec);

impl_vec_partialord!(StyledNode, StyledNodeVec);

impl_vec_clone!(StyledNode, StyledNodeVec, StyledNodeVecDestructor);

impl_vec_partialeq!(StyledNode, StyledNodeVec);

impl StyledNodeVec {

    /// Returns an immutable container reference for indexed access.

    /// Returns a mutable container reference for indexed access.

}

#[test]

#[allow(clippy::used_underscore_binding)] // intentional `_`-prefix (FFI/api.json pub field, or cfg-gated binding); access is deliberate

                )

        );

/// Regression test for the calc.c "frame ≥2 loses all backgrounds" bug:

/// `recompute_inheritance_and_compact_cache()` must reproduce the

/// `hot_flags` that `create_from_compact_dom` produced on frame 1. If the

/// recompute path silently drops to the getters-only `build_compact_cache`

/// variant, `HOT_FLAG_HAS_BACKGROUND` is never written, the renderer's

/// `has_any_background()` negative fast-path returns false for every node,

/// and every painted background vanishes on the next layout pass.

#[test]

    use azul_css::compact_cache::HOT_FLAG_HAS_BACKGROUND;

    );

    // Frame 1: find the painted node by walking its hot_flags.

    };

    );

    // Frame 2+: simulate regenerate_layout rebuilding the compact cache.

    // This is the path the calculator hit on every resize tick, and the

    // one that had silently regressed to the getter-only builder.

    };

    );

/// Calculated hash of a font-family

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

pub struct StyleFontFamilyHash(pub u64);

impl ::core::fmt::Debug for StyleFontFamilyHash {

}

impl StyleFontFamilyHash {

    /// Computes a 64-bit hash of a font family for cache lookups.

        use core::hash::Hasher;

}

/// Calculated hash of a font-family

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

pub struct StyleFontFamiliesHash(pub u64);

impl ::core::fmt::Debug for StyleFontFamiliesHash {

}

impl StyleFontFamiliesHash {

    /// Computes a 64-bit hash of multiple font families for cache lookups.

        use core::hash::Hasher;

        // Prefix with the length so that e.g. `[A, B]` and `[AB]` (or any two

        // family lists whose concatenated element hashes coincide) cannot

        // collide into the same cache key.

}

/// FFI-safe representation of `Option<NodeId>` as a single `usize`.

///

/// # Encoding (1-based)

///

/// - `inner = 0` → `None` (no node)

/// - `inner = n > 0` → `Some(NodeId(n - 1))`

///

/// This type exists because C/C++ cannot use Rust's `Option` type.

/// Use [`NodeHierarchyItemId::into_crate_internal`] to decode and

/// [`NodeHierarchyItemId::from_crate_internal`] to encode.

///

/// # Difference from `NodeId`

///

/// - **`NodeId`**: A 0-based array index. `NodeId::new(0)` refers to the first node.

///   Use directly for array indexing: `nodes[node_id.index()]`.

///

/// - **`NodeHierarchyItemId`**: A 1-based encoded `Option<NodeId>`.

///   `inner = 0` means `None`, `inner = 1` means `Some(NodeId(0))`.

///   **Never use `inner` as an array index!** Always decode first.

///

/// # Warning

///

/// The `inner` field uses **1-based encoding**, not a direct index!

/// Never use `inner` directly as an array index - always decode first.

///

/// # Example

///

/// ```ignore

/// // Encoding: Option<NodeId> -> NodeHierarchyItemId

/// let opt = NodeHierarchyItemId::from_crate_internal(Some(NodeId::new(5)));

/// assert_eq!(opt.into_raw(), 6);  // 5 + 1 = 6

///

/// // Decoding: NodeHierarchyItemId -> Option<NodeId>

/// let decoded = opt.into_crate_internal();

/// assert_eq!(decoded, Some(NodeId::new(5)));

///

/// // None case

/// let none = NodeHierarchyItemId::NONE;

/// assert_eq!(none.into_raw(), 0);

/// assert_eq!(none.into_crate_internal(), None);

/// ```

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

#[repr(C)]

pub struct NodeHierarchyItemId {

    // Uses 1-based encoding: 0 = None, n > 0 = Some(NodeId(n-1))

    // Do NOT use directly as an array index!

    inner: usize,

}

impl fmt::Debug for NodeHierarchyItemId {

        }

}

impl fmt::Display for NodeHierarchyItemId {

}

impl NodeHierarchyItemId {

    /// Represents `None` (no node). Encoded as `inner = 0`.

    pub const NONE: Self = Self { inner: 0 };

    /// Creates an `NodeHierarchyItemId` from a raw 1-based encoded value.

    ///

    /// # Warning

    ///

    /// The value must use 1-based encoding (0 = None, n = NodeId(n-1)).

    /// Prefer using [`NodeHierarchyItemId::from_crate_internal`] instead.

    #[inline]

    /// Returns the raw 1-based encoded value.

    ///

    /// # Warning

    ///

    /// The returned value uses 1-based encoding. Do NOT use as an array index!

    #[inline]

}

impl_option!(

    NodeHierarchyItemId,

    OptionNodeHierarchyItemId,

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

);

impl_vec!(NodeHierarchyItemId, NodeHierarchyItemIdVec, NodeHierarchyItemIdVecDestructor, NodeHierarchyItemIdVecDestructorType, NodeHierarchyItemIdVecSlice, OptionNodeHierarchyItemId);

impl_vec_mut!(NodeHierarchyItemId, NodeHierarchyItemIdVec);

impl_vec_debug!(NodeHierarchyItemId, NodeHierarchyItemIdVec);

impl_vec_ord!(NodeHierarchyItemId, NodeHierarchyItemIdVec);

impl_vec_eq!(NodeHierarchyItemId, NodeHierarchyItemIdVec);

impl_vec_hash!(NodeHierarchyItemId, NodeHierarchyItemIdVec);

impl_vec_partialord!(NodeHierarchyItemId, NodeHierarchyItemIdVec);

impl_vec_clone!(NodeHierarchyItemId, NodeHierarchyItemIdVec, NodeHierarchyItemIdVecDestructor);

impl_vec_partialeq!(NodeHierarchyItemId, NodeHierarchyItemIdVec);

impl NodeHierarchyItemId {

    /// Decodes to `Option<NodeId>` (0 = None, n > 0 = Some(NodeId(n-1))).

    #[inline]

    /// Encodes from `Option<NodeId>` (None → 0, Some(NodeId(n)) → n+1).

    #[inline]

}

impl From<Option<NodeId>> for NodeHierarchyItemId {

    #[inline]

}

impl From<NodeHierarchyItemId> for Option<NodeId> {

    #[inline]

}

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

#[repr(C)]

pub struct NodeHierarchyItem {

    pub parent: usize,

    pub previous_sibling: usize,

    pub next_sibling: usize,

    pub last_child: usize,

}

impl_option!(

    NodeHierarchyItem,

    OptionNodeHierarchyItem,

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

);

impl NodeHierarchyItem {

    /// Creates a zeroed hierarchy item (no parent, siblings, or children).

}

impl From<Node> for NodeHierarchyItem {

}

impl NodeHierarchyItem {

    /// Returns the parent node ID, if any.

    /// Returns the previous sibling node ID, if any.

    /// Returns the next sibling node ID, if any.

    /// Returns the first child node ID (`current_node_id` + 1 if has children).

    /// Returns the last child node ID, if any.

}

impl_vec!(NodeHierarchyItem, NodeHierarchyItemVec, NodeHierarchyItemVecDestructor, NodeHierarchyItemVecDestructorType, NodeHierarchyItemVecSlice, OptionNodeHierarchyItem);

impl_vec_mut!(NodeHierarchyItem, NodeHierarchyItemVec);

impl_vec_debug!(AzNode, NodeHierarchyItemVec);

impl_vec_partialord!(AzNode, NodeHierarchyItemVec);

impl_vec_clone!(

    NodeHierarchyItem,

    NodeHierarchyItemVec,

    NodeHierarchyItemVecDestructor

);

impl_vec_partialeq!(AzNode, NodeHierarchyItemVec);

impl NodeHierarchyItemVec {

    /// Returns an immutable container reference for indexed access.

    /// Returns a mutable container reference for indexed access.

}

impl NodeDataContainerRef<'_, NodeHierarchyItem> {

    /// Returns the number of descendant nodes under the given parent.

    #[inline]

        // saturating: a malformed FastDom can leave next_sibling <= parent,

        // which would underflow-panic the subtraction.

}

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

#[repr(C)]

pub struct ParentWithNodeDepth {

    pub depth: usize,

    pub node_id: NodeHierarchyItemId,

}

impl_option!(

    ParentWithNodeDepth,

    OptionParentWithNodeDepth,

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

);

impl fmt::Debug for ParentWithNodeDepth {

            self.depth,

        )

}

impl_vec!(ParentWithNodeDepth, ParentWithNodeDepthVec, ParentWithNodeDepthVecDestructor, ParentWithNodeDepthVecDestructorType, ParentWithNodeDepthVecSlice, OptionParentWithNodeDepth);

impl_vec_mut!(ParentWithNodeDepth, ParentWithNodeDepthVec);

impl_vec_debug!(ParentWithNodeDepth, ParentWithNodeDepthVec);

impl_vec_partialord!(ParentWithNodeDepth, ParentWithNodeDepthVec);

impl_vec_clone!(

    ParentWithNodeDepth,

    ParentWithNodeDepthVec,

    ParentWithNodeDepthVecDestructor

);

impl_vec_partialeq!(ParentWithNodeDepth, ParentWithNodeDepthVec);

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

#[repr(C)]

pub struct TagIdToNodeIdMapping {

    // Hit-testing tag ID (not all nodes have a tag, only nodes that are hit-testable)

    pub tag_id: TagId,

    /// Node ID of the node that has a tag

    pub node_id: NodeHierarchyItemId,

    /// Whether this node has a tab-index field

    pub tab_index: OptionTabIndex,

}

impl_option!(

    TagIdToNodeIdMapping,

    OptionTagIdToNodeIdMapping,

    copy = false,

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

);

impl_vec!(TagIdToNodeIdMapping, TagIdToNodeIdMappingVec, TagIdToNodeIdMappingVecDestructor, TagIdToNodeIdMappingVecDestructorType, TagIdToNodeIdMappingVecSlice, OptionTagIdToNodeIdMapping);

impl_vec_mut!(TagIdToNodeIdMapping, TagIdToNodeIdMappingVec);

impl_vec_debug!(TagIdToNodeIdMapping, TagIdToNodeIdMappingVec);

impl_vec_partialord!(TagIdToNodeIdMapping, TagIdToNodeIdMappingVec);

impl_vec_clone!(

    TagIdToNodeIdMapping,

    TagIdToNodeIdMappingVec,

    TagIdToNodeIdMappingVecDestructor

);

impl_vec_partialeq!(TagIdToNodeIdMapping, TagIdToNodeIdMappingVec);

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

#[repr(C)]

pub struct ContentGroup {

    /// The parent of the current node group, i.e. either the root node (0)

    /// or the last positioned node ()

    pub root: NodeHierarchyItemId,

    /// Node ids in order of drawing

    pub children: ContentGroupVec,

}

impl_option!(

    ContentGroup,

    OptionContentGroup,

    copy = false,

    [Debug, Clone, PartialEq, PartialOrd]

);

impl_vec!(ContentGroup, ContentGroupVec, ContentGroupVecDestructor, ContentGroupVecDestructorType, ContentGroupVecSlice, OptionContentGroup);

impl_vec_mut!(ContentGroup, ContentGroupVec);

impl_vec_debug!(ContentGroup, ContentGroupVec);

impl_vec_partialord!(ContentGroup, ContentGroupVec);

impl_vec_clone!(ContentGroup, ContentGroupVec, ContentGroupVecDestructor);

impl_vec_partialeq!(ContentGroup, ContentGroupVec);

#[derive(Debug, PartialEq, Clone)]

#[repr(C)]

pub struct StyledDom {

    pub root: NodeHierarchyItemId,

    pub node_hierarchy: NodeHierarchyItemVec,

    pub node_data: NodeDataVec,

    pub styled_nodes: StyledNodeVec,

    pub cascade_info: CascadeInfoVec,

    pub nodes_with_window_callbacks: NodeHierarchyItemIdVec,

    pub nodes_with_datasets: NodeHierarchyItemIdVec,

    pub tag_ids_to_node_ids: TagIdToNodeIdMappingVec,

    pub non_leaf_nodes: ParentWithNodeDepthVec,

    pub css_property_cache: CssPropertyCachePtr,

    /// The ID of this DOM in the layout tree (for multi-DOM support with `VirtualViews`)

    pub dom_id: DomId,

}

impl_option!(

    StyledDom,

    OptionStyledDom,

    copy = false,

    [Debug, Clone, PartialEq]

);

impl Default for StyledDom {

}

/// Per-field heap-byte breakdown of a `StyledDom`.

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

pub struct StyledDomMemoryReport {

    pub node_count: usize,

    pub node_hierarchy_bytes: usize,

    pub node_data_bytes: usize,

    pub styled_nodes_bytes: usize,

    pub cascade_info_bytes: usize,

    pub tag_ids_bytes: usize,

    pub non_leaf_nodes_bytes: usize,

    pub callback_vecs_bytes: usize,

    pub css_property_cache: crate::prop_cache::CssPropertyCacheBreakdown,

}

impl StyledDomMemoryReport {

}

impl StyledDom {

    /// Approximate heap bytes retained by this `StyledDom`, broken out by field.

        StyledDomMemoryReport {

            node_data_bytes: {

                // NodeData contains inline Vecs (callbacks, css_props, datasets)

                // that have their own heap allocations. Approximate:

            },

            callback_vecs_bytes:

        }

    /// Creates a new `StyledDom` by applying CSS styles to a DOM tree.

    ///

    /// NOTE: After calling this function, the DOM will be reset to an empty DOM.

    // This is for memory optimization, so that the DOM does not need to be cloned.

    //

    // The CSS will be left in-place, but will be re-ordered

        use core::mem;

    /// Creates a `StyledDom` from a `FastDom` (arena-based DOM).

    ///

    /// This skips the `convert_dom_into_compact_dom` tree→arena conversion

    /// entirely since `FastDom` already has flat `NodeHierarchyItemVec` and

    /// `NodeDataVec`. CSS is collected from `CssWithNodeIdVec`.

        use azul_css::css::Css;

        // 1. Merge CSS from CssWithNodeIdVec into a single Css, scoping each

        //    node-attached stylesheet to its owner's subtree (#47): push_front a

        //    Root([owner, owner+subtree_len]) selector so inline/XML css can't leak

        //    globally — the same scoping the recursive create_from_dom path applies

        //    via scope_inline_css. `node_id` is the owner's flat id (0 = root).

        {

                // Keyframes are name-global (no scoping): collect before the

                // rules are consumed. Later definitions win at resolve time.

                } else {

                };

            }

        }

        } else {

        };

        // 2. Convert NodeHierarchyItemVec → NodeHierarchy (Vec<Node>)

        //    for cascade tree computation

        // 3. Build CompactDom from the flat arenas (no conversion needed)

        // 4. Delegate to create() which handles cascade, UA CSS, etc.

        //    We need a mutable Dom to pass to create(), but we already have CompactDom.

        //    Instead, inline the cascade logic from create() with our CompactDom.

    /// Internal: creates `StyledDom` from a `CompactDom` + CSS + pre-built hierarchy items.

    /// Shared by both the Slow path (create → `convert_dom_into_compact_dom` → this)

    /// and the Fast path (`create_from_fast_dom` → this).

    #[allow(clippy::similar_names)] // domain-standard coordinate/control-point names

    #[allow(clippy::too_many_lines)] // large but cohesive: single-purpose parser/builder/dispatch (one branch per input variant)

        use crate::dom::EventFilter;

        static CASCADE_BREAKDOWN: crate::sync::OnceLock<bool> = crate::sync::OnceLock::new();

        ];

        );

        );

        // Retain the author stylesheet on the cache (this used to `drop(css)` to

        // save ~500 KiB, but that made runtime-inserted nodes unstyleable: the

        // rules were gone, so nothing could ever re-run the cascade for them —

        // see e2e/bug-inserted-node-no-author-css.json).

        // Apply UA defaults + compute inherited values so consumers that

        // read `css_property_cache.computed_values` (the web/HTML

        // renderer in `dll/src/web/html_render.rs`) see resolved

        // properties. The compact cache below stores the same info in

        // a different layout for the desktop renderer; computed_values

        // is the "tall" form that the web renderer's CSS emitter

        // (`emit_css_from_cache`) walks per node.

        );

        );

        );

        // Collect callback/dataset nodes in a single pass (avoids 3 separate 50K scans).

        // For XHTML-parsed DOMs with no callbacks, this early-exits immediately.

                }

            }

        } else {

        };

        #[cfg(feature = "table_layout")]

        if let Err(_e) = crate::dom_table::generate_anonymous_table_elements(&mut styled_dom) {

        }

    /// Creates a `StyledDom` from a recursive Dom tree with deferred CSS.

    ///

    /// This is the Phase 7.2 entry point: the layout callback returns a recursive

    /// `Dom` with `css: Vec<Css>` on each node. This function:

    ///

    /// 1. Collects all CSS objects from the recursive tree

    /// 2. Flattens the Dom into contiguous arrays (`CompactDom`)

    /// 3. Merges all CSS objects and runs a single cascade pass

    /// 4. Runs `apply_ua_css` → `compute_inherited_values` → `build_compact_cache`

    /// 5. Generates anonymous table elements

        use azul_css::css::Css;

        // #47: scope each node's inline css to its subtree BEFORE collecting, so a

        // non-root node's with_css cannot leak to the whole tree. Uses the same

        // pre-order ids the flatten (convert_dom_into_compact_dom) will assign;

        // needs estimated_total_children populated first.

        // 1. Collect all CSS objects from the recursive Dom tree (now scoped)

        // 2. Merge all CSS objects into one combined Css

        } else {

        };

        // 3. Strip CSS from all Dom nodes before flattening

        //    (CSS is already collected, don't need it in the flat tree)

        // 4. Use existing StyledDom::create to flatten + cascade

    /// Appends another `StyledDom` as a child to the `self.root`

    /// without re-styling the DOM itself

    /// Optimized version of `append_child` that takes the child index directly

    /// instead of counting existing children (O(1) instead of O(n))

        // shift all the node ids in other by self.len()

        // Use provided index instead of counting children

        // adjust node hierarchy

        }

        // Tag IDs are globally unique (AtomicUsize counter) and never collide,

        // so we only shift node_id (which changes when DOMs are merged).