//! Intrinsic and used size calculations for layout nodes

use std::{

    collections::BTreeSet,

    sync::Arc,

};

use azul_core::{

    dom::{FormattingContext, NodeId, NodeType},

    geom::LogicalSize,

    resources::RendererResources,

    styled_dom::{StyledDom, StyledNodeState},

};

use azul_css::{

    css::CssPropertyValue,

    props::{

        basic::PixelValue,

        layout::{LayoutDisplay, LayoutFlexDirection, LayoutFlexWrap, LayoutFloat, LayoutHeight, LayoutPosition, LayoutWidth, LayoutWritingMode},

        property::{CssProperty, CssPropertyType},

    },

    LayoutDebugMessage,

};

use rust_fontconfig::FcFontCache;

#[cfg(feature = "text_layout")]

use crate::text3;

use crate::{

    font::parsed::ParsedFont,

    font_traits::{

        AvailableSpace, FontLoaderTrait, FontManager, ImageSource, InlineContent, InlineImage,

        InlineShape, LayoutCache, LayoutFragment, ObjectFit, ParsedFontTrait, ShapeDefinition,

        StyleProperties, UnifiedConstraints,

    },

    solver3::{

        fc::split_text_for_whitespace,

        geometry::{BoxProps, BoxSizing, IntrinsicSizes, WritingModeContext},

        getters::{

            get_css_box_sizing, get_css_height, get_css_width, get_display_property,

            get_direction_property, get_element_font_size, get_flex_direction, get_float,

            get_style_properties, get_text_orientation_property, get_writing_mode, MultiValue,

        },

        layout_tree::{LayoutNodeHot, LayoutTree, get_display_type},

        positioning::get_position_type,

        LayoutContext, LayoutError, Result,

    },

};

/// Resolves a percentage value against the containing block dimension.

///

/// Per CSS 2.1 Section 10.2, percentages resolve directly against the containing

/// block's width or height. The margin/border/padding parameters are accepted for

/// call-site convenience but are intentionally unused — percentage resolution does

/// not subtract box-model extras in content-box sizing.

///

/// Returns `(containing_block_dimension * percentage).max(0.0)`.

// +spec:containing-block:43c719 - percentages resolved against containing block width/height

// +spec:containing-block:723eee - Percentages specify sizing with respect to the containing block

// +spec:containing-block:8ad6f4 - Percentage resolution against containing block (editorial note: transferred percentages)

// +spec:containing-block:257f3b - Block-axis percentages resolve against containing block size

// +spec:containing-block:f1344e - percentage min/max-width resolved against containing block width; negative CB width yields zero

    // +spec:containing-block:b3388b - percentage resolved against containing block size without re-resolution (css-sizing-3 §5.2.1)

    // CSS 2.1 Section 10.2: percentages resolve against containing block,

    // not available space after margins/borders/padding

/// Returns true if the DOM subtree rooted at `dom_id` contains any `NodeType::Text`.

///

/// Used when deciding whether a `FormattingContext::Inline` node should measure

/// its inline content (it acts as an IFC root when nested inlines eventually

/// hold text) versus returning zero (pure inline wrapper with no text reaches).

/// Phase 2a: Calculate intrinsic sizes (bottom-up pass)

/// // +spec:display-contents:f12d4e - intrinsic sizing: size determined by contents, not context

    // Pre-compute the "ancestor closure" of dirty_nodes: every dirty

    // node AND each of its ancestors up to root. A node not in this

    // set (and whose `intrinsic_sizes` is already populated) can

    // reuse its cached intrinsic — we skip its entire subtree walk.

    // Before this, `calculate_intrinsic_recursive` walked the full

    // tree from root regardless, costing ~2 ms per warm render on

    // excel.html even when only 3 nodes were actually dirty.

    // Fix C (re-enabled §58 Win #3): skip intrinsic computation for subtrees

    // whose values will never be consumed. `tree.subtree_needs_intrinsic` is a

    // static-DOM bitmap precomputed at tree-build time — true if this node or

    // any descendant establishes a shrink-to-fit context. When both the

    // caller and the subtree are non-STF, no one reads the intrinsic, so the

    // whole descent is pure waste.

    //

    // The previous attempt (7667d13e, reverted in bd9ad36d) wrote default

    // (zero) intrinsics and broke auto-height rendering because

    // calculate_used_size_for_node read intrinsic.max_content_height as the

    // height:auto fallback. 97c3d3db refactored that dependency away: for

    // block-level auto-height, used_size.height is 0 pre-layout and

    // apply_content_based_height fills it from the laid-out content size.

    // With that gone, skipping intrinsic is safe.

        }

    }

struct IntrinsicSizeCalculator<'a, 'b, 'c, T: ParsedFontTrait> {

    ctx: &'a mut LayoutContext<'b, T>,

    /// Shared text shaping cache, threaded through from the caller so

    /// stages 1–3 of the inline layout pipeline (logical / BiDi / shaping)

    /// are cache-hits across the sizing pass's min/max-content measurements

    /// AND the subsequent real layout pass. Previously each pass held its

    /// own `LayoutCache`, so identical text was shaped three times per

    /// root_layout_pass — once per min-content measurement, once per

    /// max-content measurement, once at final layout.

    text_cache: &'c mut LayoutCache,

    /// If `Some`, only nodes in this set (the ancestor-closure of

    /// dirty nodes) need recomputation. A clean node whose

    /// `warm.intrinsic_sizes` is already populated reuses the

    /// cached value and skips its entire subtree descent.

    dirty_closure: Option<std::collections::HashSet<usize>>,

}

impl<'a, 'b, 'c, T: ParsedFontTrait> IntrinsicSizeCalculator<'a, 'b, 'c, T> {

        // Fast path: if this subtree has no dirty nodes AND we

        // already have a cached intrinsic, return the cached value

        // and skip the whole descent. Caller is the ancestor-closure

        // computation in `calculate_intrinsic_sizes` — anything not

        // in that set is guaranteed clean through every descendant.

                {

        // Fix C static-DOM short-circuit: if no ancestor needs this intrinsic

        // (none are STF) AND no descendant in this subtree is STF, nobody

        // will ever read the value. Write a default and skip the recursion.

        // `subtree_needs_intrinsic` is precomputed at tree-build time from

        // the DOM's display/position/float properties, so this is a constant

        // lookup with no per-pass work.

        {

        // Previously cloned the full LayoutNode to sidestep borrow conflicts

        // with the `&mut tree` recursive calls below, but we only need the

        // DOM id here — a `Copy` scalar. The clone was allocating a

        // Vec<usize> for children and a TaffyCache on every recursion

        // (~300x on excel.html).

            .dom_node_id;

        // Out-of-flow elements do not contribute to their parent's intrinsic size.

        // Copy child indices before recursive calls (which need &mut tree).

        // Stack buffer for the common case (≤32 children); heap only for huge nodes.

        let heap_buf: Vec<usize>;

        } else {

        };

        // Propagate STF flag: children inherit `ancestor_is_stf=true` if any

        // ancestor up to and including self is STF.

                )

        }

        // Then calculate this node's intrinsic size based on its children

        // +spec:min-max-sizing:970fef - if min-width/min-height is a <length>, use as floor for intrinsic sizes

            use azul_css::props::basic::{pixel::{DEFAULT_FONT_SIZE, PT_TO_PX}, SizeMetric};

            use crate::solver3::getters::{get_css_min_width, get_css_min_height, MultiValue};

                };

                };

        // +spec:block-formatting-context:30def2 - replaced elements use physical 300x150 default, not re-oriented by writing-mode

        // +spec:display-property:015c41 - replaced elements default to 300x150 intrinsic size per css-sizing-3 §5.1

        // +spec:display-property:2c6af3 - replaced elements with auto width/height use max-content size

        // +spec:replaced-elements:6d6030 - Intrinsic sizes for replaced elements (images, virtual views)

        // VirtualViews are replaced elements with a default intrinsic size of 300x150px

        // (same as virtualized view elements)

            // +spec:containing-block:bb5a12 - replaced element intrinsic sizes using initial containing block

            // +spec:display-property:7127f9 - intrinsic sizes of replaced elements without natural sizes (300x150 fallback, aspect ratio)

            // +spec:display-property:f9cede - replaced elements derive intrinsic size from natural dimensions

            // +spec:writing-modes:b18121 - stretch fit inline size from available space, calculate block size via aspect ratio

                // +spec:containing-block:1da6dc - use initial CB inline size for replaced elements with aspect ratio but no intrinsic size

                // Per css-sizing-3 §5.1: "use an inline size matching the corresponding dimension

                // of the initial containing block and calculate the other dimension using the aspect ratio"

                    // Has intrinsic height but no width — use initial CB inline dimension

                } else {

                    // +spec:replaced-elements:43376b - 300px fallback with 2:1 ratio for replaced elements

                    // No intrinsic dimensions — cap at 300x150 per CSS 2.2 §10.3.2

                    // +spec:width-calculation:3b0efe - auto width fallback: 300px capped to device width

                    // +spec:width-calculation:16c305 - auto height fallback: 2:1 ratio, max 150px

                };

            FormattingContext::Block { .. } => {

                // Check if this block establishes an Inline Formatting Context (IFC).

                // Per CSS 2.2 §9.2.1.1: A block container with mixed block-level and

                // inline-level children creates anonymous block boxes to wrap the inline

                // content. So we only treat as IFC root if there are NO block-level children.

                //

                // We check the actual CSS display property, NOT formatting_context,

                // because a display:block element with only inline children gets

                // FormattingContext::Inline (meaning "establishes IFC for its children"),

                // which is different from being an inline element itself.

                            // Text nodes are inline-level

                                LayoutDisplay::Inline

                                | LayoutDisplay::InlineBlock

                                | LayoutDisplay::InlineFlex

                                | LayoutDisplay::InlineGrid

                                | LayoutDisplay::InlineTable

                            )

                // IFC root only if there are inline children and NO block children.

                // If there are block children, text nodes get anonymous block wrappers.

                // Also check if this block has direct text content (text nodes in DOM)

                // but ONLY if there are no block-level layout children

                    } else {

                    }

                } else {

                };

                    // This block is an IFC root - measure all inline content ONCE

                } else {

                    // This is a BFC root (only block children) - aggregate child sizes

                }

            }

            FormattingContext::Inline => {

                // There are THREE cases for FormattingContext::Inline:

                // 1. A Text node (NodeType::Text) - this IS the text content itself

                //    -> Needs to measure itself as an atomic inline unit

                // 2. An IFC root - a block with only inline children (has text child nodes)

                //    -> Should measure its inline content

                // 3. A true inline element (display: inline, e.g., <span>) with no text

                //    -> Returns default(0,0), measured by parent IFC root

                //

                // We distinguish by:

                // - Checking if THIS node is a Text node (case 1)

                // - Checking if this subtree contains any text (case 2)

                //

                // Why descendants, not just direct children: for `<span><a>text</a></span>`,

                // the `<span>` is a layout-tree IFC root (layout_ifc is called on it), but

                // its direct DOM children are inline elements, not text. Restricting the

                // check to direct text children would zero out the span's intrinsic width

                // even though the cell content width depends on it.

                } else {

                };

                } else {

                };

                    // Case 1 or 2: Text node or IFC root - measure inline content

                } else {

                    // Case 3: True inline element - measured by parent IFC root

                }

            }

            FormattingContext::InlineBlock => {

                // Inline-block IS an atomic inline - it needs its own intrinsic size.

                // Check layout tree children AND direct DOM text children (text nodes

                // are not in the layout tree, only in the DOM).

                } else {

                };

                    // InlineBlock with inline children - measure as IFC root.

                    // Returns content-level intrinsic sizes (no margin/padding/border).

                    // The parent adds box-model extras via calculate_block_intrinsic_sizes,

                    // and calculate_used_size_for_node adds padding+border for border-box.

                } else {

                    // InlineBlock with block children - aggregate like block

                }

            }

            FormattingContext::Table => {

            }

            FormattingContext::Flex => {

            }

        }

    // +spec:intrinsic-sizing:ea2c2c - §5.1 min-content size = size as float with auto; max-content = no wrapping

    /// Calculate intrinsic sizes for an IFC root (a block containing inline content).

    /// This collects ALL inline descendants' text and measures it ONCE.

    // +spec:intrinsic-sizing:8f3c0c - hanging glyphs must be excluded from intrinsic size measurement

        // Collect all inline content from this IFC root and its inline descendants

        // Get pre-loaded fonts from font manager

        // +spec:intrinsic-sizing:ae8beb - min-content = zero-width CB, max-content = infinite-width CB

        // +spec:intrinsic-sizing:8c94e2 - min-content/max-content intrinsic size determination via constrained layout

        // Use `measure_intrinsic_widths` instead of two `layout_flow` passes (fix B):

        // it runs stages 1–4 of the pipeline once (logical → BiDi → shape → orient)

        // and derives min/max-content by scanning the shaped items directly. This

        // avoids the BreakCursor line-breaking loop entirely — that loop clones

        // every ShapedCluster it inspects via `peek_next_unit` and accounted for

        // 24% of total CPU on the text_2000 stress fixture. Shaping is cached

        // at the per-item level (keyed on text+style), so the subsequent real

        // layout_flow call for this content gets pure cache hits for stages 1–3.

            Err(_) => {

            }

        };

        // +spec:display-property:c587fd - min-content block size equals max-content block size for block containers, tables, inline boxes

        // +spec:intrinsic-sizing:02eedc - min-content block size equals max-content block size for block containers

        // For a single-line max-content layout the height is one line box;

        // `measure_intrinsic_widths` returns exactly that.

        // NOTE(writing-modes): min_content_width / max_content_width are named for

        // the physical axis. In vertical writing modes the "inline" axis is vertical,

        // so these are swapped by calculate_block_intrinsic_sizes when computing

        // the parent's intrinsic sizes. The physical naming is intentional here.

    // +spec:containing-block:bb0658 - percentage block-sizes behave as auto during intrinsic computation (no CSS height resolution here)

    // +spec:display-contents:84fe7f - cyclic percentage contributions: percentage-sized children use auto during intrinsic sizing

    // +spec:min-max-sizing:411904 - percentage block-sizes treated as auto during intrinsic sizing (content-sized CB)

    // +spec:min-max-sizing:737e62 - percentage heights don't resolve inside content-sized containing blocks

        } else {

        };

        // NOTE: Text content detection is now handled in calculate_node_intrinsic_sizes

        // which calls calculate_ifc_root_intrinsic_sizes for blocks with inline content.

        // This function now only handles pure block containers (BFC roots).

        // +spec:height-calculation:d9ca8d - cyclic percentage contributions: percentage min-height/max-height on children should behave as auto when computing intrinsic contributions (not yet implemented)

        // Track margins for CSS 2.2 §8.3.1 collapsing in the block direction.

        // Block margins collapse between siblings (max instead of sum) and

        // parent-child margins can escape (first/last child).

                // +spec:intrinsic-sizing:ed72bb - intrinsic contributions based on outer size, auto margins as zero

                        }

                    } else {

                    };

                };

                // CSS 2.2 §8.3.1 margin collapsing for intrinsic sizing:

                // - First child's margin-start can escape (don't add to total)

                // - Between siblings: collapsed gap = max(prev_end, curr_start)

                // - Last child's margin-end can escape (don't add to total)

        }

        // Last child's margin-end may escape — don't add it to total_main_size

        };

    // The max-content main size is the sum of items' max-content contributions.

    // The min-content main size of a single-line flex container is the sum of items'

    // min-content contributions. For multi-line, it is the largest min-content contribution.

    // Auto margins on flex items are treated as 0 for this computation.

        // Determine flex-direction to know if main axis is horizontal or vertical

            }

        } else {

        };

                } else {

                };

                // For multi-line min-content, track the largest single item

                // Cross axis: largest child determines the container's cross size

        }

        // For single-line (nowrap), min-content = sum; for multi-line (wrap), min-content = max

        // Default flex-wrap is nowrap (single-line)

            );

                    LayoutFlexWrap::NoWrap

                ),

            }

        } else {

        };

        } else {

        }

    /// Calculate intrinsic sizes for a table element by aggregating cell content

    /// widths per column and row heights.

    /// +spec:table-layout:93b13c - shrink-to-fit for tables uses intrinsic sizing

        // Collect per-column min/max widths and total row heights.

        // Table structure: table > row-group? > row > cell

        // Iterate rows — children may be row groups (thead/tbody/tfoot) or direct rows

                FormattingContext::TableRowGroup => {

                    // Row group contains rows

                    }

                }

            }

        }

                // Also check if cell has IFC content we can measure

                } else {

                    // Try to measure cell content via IFC

                };

                // Add cell box-model extras

            }

        }

}

/// Gathers all inline content for the intrinsic sizing pass.

///

/// This function recursively collects text and inline-level content according to

/// CSS Sizing Level 3, Section 4.1: "Intrinsic Sizes"

/// https://www.w3.org/TR/css-sizing-3/#intrinsic-sizes

///

/// For inline formatting contexts, we need to gather:

/// 1. Text nodes (inline content)

/// 2. Inline-level boxes (display: inline, inline-block, etc.)

/// 3. Atomic inline-level elements (replaced elements like images)

///

/// The key difference from `collect_and_measure_inline_content` in fc.rs is that

/// this version is used for intrinsic sizing (calculating min/max-content widths)

/// before the actual layout pass, so it must recursively gather content from

/// inline descendants without laying them out first.

    // Recursively collect inline content from this node and its inline descendants

/// Recursive helper for collecting inline content.

///

/// According to CSS Sizing Level 3, the intrinsic size of an inline formatting context

/// is based on all inline-level content, including text in nested inline elements.

///

/// This function:

/// - Collects text from the current node if it's a text node

/// - Collects text from DOM children (text nodes may not be in layout tree)

/// - Recursively collects from inline children (display: inline)

/// - Treats non-inline children as atomic inline-level boxes

    // CRITICAL FIX: Text nodes may exist in the DOM but not as separate layout nodes!

    // We need to check the DOM children for text content.

        // No DOM ID means this is a synthetic node, skip text extraction

    };

    // First check if THIS node is a text node

    // CRITICAL: Also check DOM children for text nodes!

    // Text nodes are often not represented as separate layout nodes.

    // However, we must SKIP children that already have a layout tree entry,

    // because those will be handled by process_layout_children() below.

    // Without this guard, text nodes present in both DOM and layout tree

    // get collected twice, causing inline-block containers to be ~2x too wide.

        // Skip DOM children that have layout tree nodes - they will be

        // processed via process_layout_children -> collect_inline_content_recursive

        // Check if this DOM child is a text node

    }

/// Helper to process layout tree children for inline content collection

    use azul_css::props::basic::SizeMetric;

    use azul_css::props::layout::{LayoutHeight, LayoutWidth};

    // Process layout tree children (these are elements with layout properties)

        };

        // CSS Sizing Level 3: Inline-level boxes participate in the IFC

            // Recursively collect content from inline children

            // This is CRITICAL for proper intrinsic width calculation!

        } else {

            // Non-inline children are treated as atomic inline-level boxes

            // (e.g., inline-block, images, floats)

            // Their intrinsic size must have been calculated in the bottom-up pass

            // CSS 2.2 § 10.3.9: For inline-block elements with explicit CSS width/height,

            // use the CSS-defined values instead of intrinsic sizes.

            // Resolve CSS width - use explicit value if set, otherwise fall back to intrinsic

                    // Convert PixelValue to f32

                    use azul_css::props::basic::pixel::{DEFAULT_FONT_SIZE, PT_TO_PX};

                        // +spec:containing-block:495930 - percentages in intrinsic sizing fall back to intrinsic contribution (css-sizing-3 §5.2.1)

                        // For percentages and viewport units, fall back to intrinsic

                        // +spec:containing-block:5246c0 - cyclic percentage: when containing block size depends on this box's intrinsic contribution, percentages fall back to intrinsic size

                        // +spec:containing-block:598124 - cyclic percentage contributions use intrinsic size

                        // +spec:height-calculation:ca9f19 - percentage-sized boxes use intrinsic size as contribution during intrinsic sizing

                        // +spec:width-calculation:7a384a - percentage-sized boxes behave as width:auto for intrinsic contributions (cyclic percentage)

                    }

                }

                MultiValue::Exact(LayoutWidth::FitContent(_)) => {

                    // During intrinsic sizing, fit-content resolves to max-content

                }

                // For Auto or other values, use intrinsic size

            };

            // +spec:containing-block:5145c5 - percentage block-size ignored in content-sized containing blocks during intrinsic sizing

            // Resolve CSS height - use explicit value if set, otherwise fall back to intrinsic

                    use azul_css::props::basic::pixel::{DEFAULT_FONT_SIZE, PT_TO_PX};

                        // +spec:containing-block:7d5e79 - percentages behave as auto when containing block height is auto (cyclic percentage contribution)

                        // +spec:height-calculation:7d807b - css-sizing-3 §5.2.1: percentage heights behave as auto during intrinsic sizing (cyclic percentage contribution)

                        // Percentages and viewport units fall back to intrinsic (treated as auto)

                    }

                }

                // is equivalent to automatic size

                // is equivalent to automatic size

            };

            // Represent as a rectangular shape with the resolved dimensions

        }

    }

// Keep old name as an alias for backward compatibility

// +spec:height-calculation:1c899b - width and height properties specify the preferred size of the box

/// Calculates the used size of a single node based on its CSS properties and

/// the available space provided by its containing block.

///

/// // +spec:display-contents:71ccde - extrinsic sizing: size determined by context (containing block), not contents

///

/// This implementation correctly handles writing modes and percentage-based sizes

/// according to the CSS specification:

/// 1. `width` and `height` CSS properties are resolved to pixel values. Percentages are calculated

///    based on the containing block's PHYSICAL dimensions (`width` for `width`, `height` for

///    `height`), regardless of writing mode.

/// 2. The resolved physical `width` is then mapped to the node's logical CROSS size.

/// 3. The resolved physical `height` is then mapped to the node's logical MAIN size.

/// 4. A final `LogicalSize` is constructed from these logical dimensions.

// +spec:overflow:3c4f25 - auto box sizes: four auto-determined size types resolved here

// +spec:width-calculation:fb0629 - width/margin used values depend on box type, auto replaced by suitable value

/// M12.7: out-of-line auto-width-block inline size — `(cb.width - margins - borders -

/// padding).max(0.0)`. Extracted from calc_used_size's auto-width Block arm so the

/// `.max(0.0)` runs in a small fn (proven to lift correctly), with a FRESH pointer

/// deref (the huge calc_used_size body hoists/spills cb.width and the remill lift then

/// reads it back 0). Returns by f32 (D0/V0 — the standard scalar return), NOT an out-ptr:

/// the out-ptr version computed 800 correctly but the caller's reload was opt-forwarded

/// to the init 0.0 across the opaque call (the helper's `*out` lowers to a direct

/// linear-mem store not modeled as aliasing the caller's slot). The f32 return is the

/// call's SSA result, which opt cannot replace. (The earlier "f32-return mis-lift" worry

/// was the 2×f32 *struct* HFA — a single scalar f32 return is fine.)

#[inline(never)]

        // Anonymous boxes:

        // CSS 2.2 § 9.2.1.1: Anonymous boxes inherit from their enclosing box.

        // The inline dimension fills the containing block's inline size,

        // and the block dimension is auto (content-based).

        // In horizontal-tb: inline=width, block=height.

        // In vertical modes: inline=height, block=width.

        //

        // Since anonymous boxes don't have a DOM node, we default to horizontal-tb.

        // The parent's writing mode is already reflected in containing_block_size.

            } else {

                // Auto height - will be resolved from content

            },

        ));

    };

    // Construct the full WritingModeContext from resolved styles.

    // This determines how logical dimensions (inline/block) map to physical (width/height).

    );

    // +spec:display-property:06e0b1 - form controls (non-image) treated as non-replaced

    // Determine if this element is a replaced element (images, virtual views)

    // +spec:width-calculation:79cdf8 - inline non-replaced: width property does not apply

    // +spec:width-calculation:972e86 - §10.3.1: width property does not apply to inline non-replaced elements

    // For inline non-replaced elements, override any explicit width to Auto.

    {

    } else {

    };

    // +spec:box-model:1197a5 - height does not apply to non-replaced inline elements

    // +spec:display-property:9cb33d - height does not apply to inline boxes

    // +spec:height-calculation:c03717 - height does not apply to inline non-replaced elements

    // CSS 2.2 §10.6.1 / CSS Inline 3 §6.4: height property does not apply to

    // inline, non-replaced elements. Override any explicit height to Auto.

    {

    } else {

    };

    // Remember if width/height were auto before consuming them

    // +spec:intrinsic-sizing:9e1c9d - non-quantitative values (auto, min-content, max-content) are not influenced by box-sizing

        MultiValue::Exact(LayoutWidth::Px(_) | LayoutWidth::FitContent(_) | LayoutWidth::Calc(_))

    );

        MultiValue::Exact(LayoutHeight::Px(_) | LayoutHeight::FitContent(_) | LayoutHeight::Calc(_))

    );

    // +spec:width-calculation:50d67a - automatic sizing concepts (width/height auto resolution)

    // +spec:width-calculation:564315 - §10.3 width calculation dispatch for all box types

    // Step 1: Resolve the CSS `width` property into a concrete pixel value.

    // CSS `width` always refers to the physical horizontal dimension, regardless of writing mode.

    // Percentage values resolve against the containing block's physical width.

    // In horizontal-tb: width = inline size. In vertical modes: width = block size.

    // The physical-to-logical mapping happens in Step 5 below.

    // Percentage values for `width` are resolved against the containing block's width.

    // +spec:width-calculation:febf0c - width/height "behaves as auto" when computed auto or percentage resolves against indefinite

        LayoutWidth::Auto => {

            // +spec:width-calculation:ed6a34 - auto width on replaced element uses intrinsic width

            // CSS 2.2 §10.3.2: If 'width' has a computed value of 'auto', and the element

            // has an intrinsic width, then that intrinsic width is the used value of 'width'.

            // +spec:replaced-elements:992ea5 - block-level replaced elements use inline replaced width rules

            // §10.3.4: "The used value of 'width' is determined as for inline replaced elements."

            // +spec:replaced-elements:36de3e - §10.3.2/§10.3.4: auto width for inline/block replaced elements uses intrinsic width

            // +spec:replaced-elements:b9a780 - §10.3.2: inline replaced auto width = intrinsic width (conditions resolved during intrinsic size calc)

                // +spec:width-calculation:b41dbe - floating/inline replaced: auto width = intrinsic width

                // +spec:width-calculation:c62d35 - §10.3.2: auto width for replaced elements uses intrinsic width

                // +spec:width-calculation:d87ca4 - abs-replaced: auto width+height uses intrinsic width

                // For replaced elements (inline or block-level), auto width = intrinsic width.

                // The intrinsic sizes were already computed with the 300px fallback per §10.3.2.

            }

            // +spec:intrinsic-sizing:560697 - shrink-to-fit = clamp(min-content, stretch-fit, max-content)

                // +spec:width-calculation:8d7047 - shrink-to-fit width per CSS2.1§10.3.5