Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / layout / flex_formatting_context_2.lucb

#==============================================================================================
#
#   flex_formatting_context_2 - Layout::FlexFormattingContext: the flex items, main and cross
#                               sizes, the used flex basis and aspect ratios
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/FlexFormattingContext.cpp (lines 349-653): sifting the flex
#       container's children into flex items in `order`, definite and inner main/cross sizes,
#       specified min/max sizes, setting sizes, offsets and margins along the axes, the
#       available space for the items, the used flex-basis, and the conversions through a
#       preferred aspect ratio (with its min/max constraints).
#
#       Copyright (c) 2021-2025, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
#       Copyright (c) 2025, Jelle Raaijmakers <jelle@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Flex items ==============================================================================

## The `quick_sort` comparator `a > b` of FlexFormattingContext::generate_anonymous_flex_items.
func layout_flex_formatting_context_order_greater_than(context: void*?, a: const i32*, b: const i32*) -> bool:
    _ = context
    return *a > *b

## The `quick_sort` comparator `a < b` of FlexFormattingContext::generate_anonymous_flex_items.
func layout_flex_formatting_context_order_less_than(context: void*?, a: const i32*, b: const i32*) -> bool:
    _ = context
    return *a < *b

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:350 Web::Layout::FlexFormattingContext::generate_anonymous_flex_items.
# https://www.w3.org/TR/css-flexbox-1/#flex-items
func layout_flex_formatting_context_generate_anonymous_flex_items(this: LayoutFlexFormattingContext*):
    # More like, sift through the already generated items.
    # After this step no items are to be added or removed from flex_items!
    # It holds every item we need to consider and there should be nothing in the following
    # calculations that could change that.
    # This is particularly important since we take references to the items stored in flex_items
    # later, whose addresses won't be stable if we added or removed any items.
    var order_item_bucket: ak.HashMap[i32, ak.Vector[LayoutFlexFormattingContextFlexItem], ak.I32Traits]

    var child_or_none = tree_node_first_child_of_type(layout_flex_formatting_context_flex_container(this).layout_node(), &layout_box_class)
    while let child = child_or_none:
        child_or_none = tree_node_next_sibling_of_type(child, &layout_box_class)
        let child_box = (LayoutBox*)child
        if layout_formatting_context_can_skip_is_anonymous_text_run(this.layout_formatting_context(), child_box):
            continue

        # Skip any "out-of-flow" children
        if layout_node_is_out_of_flow_layout_formatting_context(child_box.layout_node(), this.layout_formatting_context()):
            continue

        layout_node_set_flex_item(child_box.layout_node(), true)
        var item = LayoutFlexFormattingContextFlexItem(box = child_box, used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()))
        layout_flex_formatting_context_populate_specified_margins(this, &item, this.m_flex_direction)

        let order_bucket = ak.hash_map_ensure(&order_item_bucket, css_computed_values_order(layout_box_computed(child_box)))
        ak.vector_append_t(order_bucket, item)

    var keys = ak.hash_map_keys(&order_item_bucket)

    if layout_flex_formatting_context_is_direction_reverse(this):
        ak.quick_sort_t_collection_t_less_than(ak.vector_span(&keys), ak.Function2[const i32*, const i32*, bool](call = layout_flex_formatting_context_order_greater_than, context = none))
    else:
        ak.quick_sort_t_collection_t_less_than(ak.vector_span(&keys), ak.Function2[const i32*, const i32*, bool](call = layout_flex_formatting_context_order_less_than, context = none))

    for key in ak.vector_span(&keys):
        if let order_bucket = ak.hash_map_get_k(&order_item_bucket, key):
            for bucket_item in ak.vector_span(order_bucket):
                ak.vector_append_t(&this.m_flex_items, bucket_item)

# mark: Main and cross sizes ====================================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:397 Web::Layout::FlexFormattingContext::has_definite_main_size.
func layout_flex_formatting_context_has_definite_main_size_layout_state_used_values(this: LayoutFlexFormattingContext*, used_values: const LayoutStateUsedValues*) -> bool:
    return layout_state_used_values_has_definite_width(used_values) if layout_flex_formatting_context_main_axis_is_horizontal(this) else layout_state_used_values_has_definite_height(used_values)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:402 Web::Layout::FlexFormattingContext::inner_main_size.
func layout_flex_formatting_context_inner_main_size_layout_state_used_values(this: LayoutFlexFormattingContext*, used_values: const LayoutStateUsedValues*) -> gfx.CssPixels:
    return layout_state_used_values_content_width(used_values) if layout_flex_formatting_context_main_axis_is_horizontal(this) else layout_state_used_values_content_height(used_values)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:407 Web::Layout::FlexFormattingContext::inner_cross_size.
func layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this: LayoutFlexFormattingContext*, used_values: const LayoutStateUsedValues*) -> gfx.CssPixels:
    return layout_state_used_values_content_width(used_values) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else layout_state_used_values_content_height(used_values)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:412 Web::Layout::FlexFormattingContext::has_main_min_size.
func layout_flex_formatting_context_has_main_min_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    let value = layout_flex_formatting_context_computed_main_min_size(this, box)
    return not css_size_is_auto(&value)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:418 Web::Layout::FlexFormattingContext::has_cross_min_size.
func layout_flex_formatting_context_has_cross_min_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    let value = layout_flex_formatting_context_computed_cross_min_size(this, box)
    return not css_size_is_auto(&value)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:424 Web::Layout::FlexFormattingContext::has_definite_cross_size.
func layout_flex_formatting_context_has_definite_cross_size_layout_state_used_values(this: LayoutFlexFormattingContext*, used_values: const LayoutStateUsedValues*) -> bool:
    return layout_state_used_values_has_definite_width(used_values) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else layout_state_used_values_has_definite_height(used_values)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:429 Web::Layout::FlexFormattingContext::specified_main_min_size.
func layout_flex_formatting_context_specified_main_min_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_main_min_size(this, item.box))
    return layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_main_min_size(this, item.box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:436 Web::Layout::FlexFormattingContext::specified_cross_min_size.
func layout_flex_formatting_context_specified_cross_min_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        return layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_cross_min_size(this, item.box))
    return layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_cross_min_size(this, item.box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:443 Web::Layout::FlexFormattingContext::calculate_inner_flex_container_cross_min_size.
func layout_flex_formatting_context_calculate_inner_flex_container_cross_min_size(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
    let flex_container = layout_flex_formatting_context_flex_container(this)
    let available_space = layout_flex_formatting_context_available_space(this)
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        return layout_formatting_context_calculate_inner_width(this.layout_formatting_context(), flex_container, available_space.width, layout_flex_formatting_context_computed_cross_min_size(this, flex_container))
    return layout_formatting_context_calculate_inner_height(this.layout_formatting_context(), flex_container, available_space, layout_flex_formatting_context_computed_cross_min_size(this, flex_container))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:450 Web::Layout::FlexFormattingContext::calculate_inner_flex_container_cross_max_size.
func layout_flex_formatting_context_calculate_inner_flex_container_cross_max_size(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
    let flex_container = layout_flex_formatting_context_flex_container(this)
    let available_space = layout_flex_formatting_context_available_space(this)
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        return layout_formatting_context_calculate_inner_width(this.layout_formatting_context(), flex_container, available_space.width, layout_flex_formatting_context_computed_cross_max_size(this, flex_container))
    return layout_formatting_context_calculate_inner_height(this.layout_formatting_context(), flex_container, available_space, layout_flex_formatting_context_computed_cross_max_size(this, flex_container))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:457 Web::Layout::FlexFormattingContext::has_main_max_size.
func layout_flex_formatting_context_has_main_max_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    return not layout_flex_formatting_context_should_treat_main_max_size_as_none(this, box)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:462 Web::Layout::FlexFormattingContext::has_cross_max_size.
func layout_flex_formatting_context_has_cross_max_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    return not layout_flex_formatting_context_should_treat_cross_max_size_as_none(this, box)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:467 Web::Layout::FlexFormattingContext::specified_main_max_size.
func layout_flex_formatting_context_specified_main_max_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_main_max_size(this, item.box))
    return layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_main_max_size(this, item.box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:474 Web::Layout::FlexFormattingContext::specified_cross_max_size.
func layout_flex_formatting_context_specified_cross_max_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        return layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_cross_max_size(this, item.box))
    return layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_cross_max_size(this, item.box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:481 Web::Layout::FlexFormattingContext::is_cross_auto.
func layout_flex_formatting_context_is_cross_auto(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    let cross_length = layout_flex_formatting_context_computed_cross_size(this, box)
    return css_size_is_auto(&cross_length)

# mark: Setting sizes, offsets and margins ======================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:487 Web::Layout::FlexFormattingContext::set_has_definite_main_size.
func layout_flex_formatting_context_set_has_definite_main_size(this: LayoutFlexFormattingContext*, item: LayoutFlexFormattingContextFlexItem*):
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        layout_state_used_values_set_has_definite_width(item.used_values, true)
    else:
        layout_state_used_values_set_has_definite_height(item.used_values, true)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:495 Web::Layout::FlexFormattingContext::set_has_definite_cross_size.
func layout_flex_formatting_context_set_has_definite_cross_size(this: LayoutFlexFormattingContext*, item: LayoutFlexFormattingContextFlexItem*):
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        layout_state_used_values_set_has_definite_width(item.used_values, true)
    else:
        layout_state_used_values_set_has_definite_height(item.used_values, true)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:503 Web::Layout::FlexFormattingContext::set_main_size (of a Box).
func layout_flex_formatting_context_set_main_size_layout_box(this: LayoutFlexFormattingContext*, box: LayoutBox*, size: gfx.CssPixels):
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        layout_state_used_values_set_content_width(layout_state_get_mutable(this.formatting_context.m_state, box.layout_node_with_style()), size)
    else:
        layout_state_used_values_set_content_height(layout_state_get_mutable(this.formatting_context.m_state, box.layout_node_with_style()), size)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:511 Web::Layout::FlexFormattingContext::set_cross_size (of a Box).
func layout_flex_formatting_context_set_cross_size_layout_box(this: LayoutFlexFormattingContext*, box: LayoutBox*, size: gfx.CssPixels):
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        layout_state_used_values_set_content_width(layout_state_get_mutable(this.formatting_context.m_state, box.layout_node_with_style()), size)
    else:
        layout_state_used_values_set_content_height(layout_state_get_mutable(this.formatting_context.m_state, box.layout_node_with_style()), size)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:519 Web::Layout::FlexFormattingContext::set_main_size (of a FlexItem).
func layout_flex_formatting_context_set_main_size_layout_flex_formatting_context(this: LayoutFlexFormattingContext*, item: LayoutFlexFormattingContextFlexItem*, size: gfx.CssPixels):
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        layout_state_used_values_set_content_width(item.used_values, size)
    else:
        layout_state_used_values_set_content_height(item.used_values, size)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:527 Web::Layout::FlexFormattingContext::set_cross_size (of a FlexItem).
func layout_flex_formatting_context_set_cross_size_layout_flex_formatting_context(this: LayoutFlexFormattingContext*, item: LayoutFlexFormattingContextFlexItem*, size: gfx.CssPixels):
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        layout_state_used_values_set_content_width(item.used_values, size)
    else:
        layout_state_used_values_set_content_height(item.used_values, size)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:535 Web::Layout::FlexFormattingContext::set_offset.
func layout_flex_formatting_context_set_offset(this: LayoutFlexFormattingContext*, item: LayoutFlexFormattingContextFlexItem*, main_offset: gfx.CssPixels, cross_offset: gfx.CssPixels):
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        layout_state_used_values_set_content_offset(item.used_values, gfx.CssPixelPoint(main_offset, cross_offset))
    else:
        layout_state_used_values_set_content_offset(item.used_values, gfx.CssPixelPoint(cross_offset, main_offset))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:543 Web::Layout::FlexFormattingContext::set_main_axis_first_margin.
func layout_flex_formatting_context_set_main_axis_first_margin(this: LayoutFlexFormattingContext*, item: LayoutFlexFormattingContextFlexItem*, margin: gfx.CssPixels):
    item.margins.main_before = margin
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        item.used_values.margin_left = margin
    else:
        item.used_values.margin_top = margin

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:552 Web::Layout::FlexFormattingContext::set_main_axis_second_margin.
func layout_flex_formatting_context_set_main_axis_second_margin(this: LayoutFlexFormattingContext*, item: LayoutFlexFormattingContextFlexItem*, margin: gfx.CssPixels):
    item.margins.main_after = margin
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        item.used_values.margin_right = margin
    else:
        item.used_values.margin_bottom = margin

# mark: Available space and the used flex basis =================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:562 Web::Layout::FlexFormattingContext::determine_available_space_for_items.
# https://drafts.csswg.org/css-flexbox-1/#algo-available
func layout_flex_formatting_context_determine_available_space_for_items(this: LayoutFlexFormattingContext*, available_space: LayoutAvailableSpace):
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        this.m_available_space_for_items = LayoutFlexFormattingContextAxisAgnosticAvailableSpace(
            main = available_space.width,
            cross = available_space.height,
            space = LayoutAvailableSpace(width = available_space.width, height = available_space.height),
        )
    else:
        this.m_available_space_for_items = LayoutFlexFormattingContextAxisAgnosticAvailableSpace(
            main = available_space.height,
            cross = available_space.width,
            space = LayoutAvailableSpace(width = available_space.width, height = available_space.height),
        )

## `flex_basis.get_pointer<CSS::Size>()`: the size a flex-basis holds, if it is not `content`.
func layout_flex_formatting_context_flex_basis_size(flex_basis: CssFlexBasis) -> CssSize?:
    match flex_basis:
        .css_size(size):
            return size
        .css_flex_basis_content:
            return none

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:580 Web::Layout::FlexFormattingContext::used_flex_basis_for_item.
# https://drafts.csswg.org/css-flexbox-1/#propdef-flex-basis
func layout_flex_formatting_context_used_flex_basis_for_item(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> CssFlexBasis:
    var flex_basis = css_computed_values_flex_basis(layout_box_computed(item.box))

    if let auto_size = layout_flex_formatting_context_flex_basis_size(flex_basis):
        if css_size_is_auto(&auto_size):
            # https://drafts.csswg.org/css-flexbox-1/#valdef-flex-basis-auto
            # When specified on a flex item, the auto keyword retrieves the value of the main size property as the used flex-basis.
            # If that value is itself auto, then the used value is content.
            let main_size = layout_flex_formatting_context_computed_main_size(this, item.box)

            if css_size_is_auto(&main_size):
                flex_basis = CssFlexBasis.css_flex_basis_content(CssFlexBasisContent())
            else:
                flex_basis = CssFlexBasis.css_size(main_size)

    # For example, percentage values of flex-basis are resolved against the flex item’s containing block
    # (i.e. its flex container); and if that containing block’s size is indefinite,
    # the used value for flex-basis is content.
    if let percentage_size = layout_flex_formatting_context_flex_basis_size(flex_basis):
        if css_size_is_percentage(&percentage_size) and not layout_flex_formatting_context_has_definite_main_size_layout_state_used_values(this, this.m_flex_container_state):
            flex_basis = CssFlexBasis.css_flex_basis_content(CssFlexBasisContent())

    return flex_basis

# mark: Aspect ratios ===========================================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:609 Web::Layout::FlexFormattingContext::calculate_main_size_from_cross_size_and_aspect_ratio.
func layout_flex_formatting_context_calculate_main_size_from_cross_size_and_aspect_ratio(this: LayoutFlexFormattingContext*, cross_size: gfx.CssPixels, aspect_ratio: gfx.CssPixelFraction) -> gfx.CssPixels:
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return cross_size.mul_fraction(aspect_ratio)
    return cross_size.div_fraction(aspect_ratio)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:616 Web::Layout::FlexFormattingContext::calculate_cross_size_from_main_size_and_aspect_ratio.
func layout_flex_formatting_context_calculate_cross_size_from_main_size_and_aspect_ratio(this: LayoutFlexFormattingContext*, main_size: gfx.CssPixels, aspect_ratio: gfx.CssPixelFraction) -> gfx.CssPixels:
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return main_size.div_fraction(aspect_ratio)
    return main_size.mul_fraction(aspect_ratio)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:625 Web::Layout::FlexFormattingContext::adjust_main_size_through_aspect_ratio_for_cross_size_min_max_constraints.
# This function takes a size in the main axis and adjusts it according to the aspect ratio of the box
# if the min/max constraints in the cross axis forces us to come up with a new main axis size.
func layout_flex_formatting_context_adjust_main_size_through_aspect_ratio_for_cross_size_min_max_constraints(this: LayoutFlexFormattingContext*, box: LayoutBox*, main_size: gfx.CssPixels, min_cross_size: CssSize, max_cross_size: CssSize) -> gfx.CssPixels:
    var adjusted_main_size = main_size
    let reference_value = layout_state_used_values_content_width(this.m_flex_container_state) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else layout_state_used_values_content_height(this.m_flex_container_state)
    if not layout_flex_formatting_context_should_treat_cross_max_size_as_none(this, box):
        let max_cross_size_px = css_size_to_px(&max_cross_size, box.layout_node(), reference_value)
        let aspect_ratio = layout_box_preferred_aspect_ratio(box) else trap("VERIFY: the box has a preferred aspect ratio")
        adjusted_main_size = ak.min(adjusted_main_size, layout_flex_formatting_context_calculate_main_size_from_cross_size_and_aspect_ratio(this, max_cross_size_px, aspect_ratio))

    if not css_size_is_auto(&min_cross_size):
        let min_cross_size_px = css_size_to_px(&min_cross_size, box.layout_node(), reference_value)
        let aspect_ratio = layout_box_preferred_aspect_ratio(box) else trap("VERIFY: the box has a preferred aspect ratio")
        adjusted_main_size = ak.max(adjusted_main_size, layout_flex_formatting_context_calculate_main_size_from_cross_size_and_aspect_ratio(this, min_cross_size_px, aspect_ratio))

    return adjusted_main_size

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:640 Web::Layout::FlexFormattingContext::adjust_cross_size_through_aspect_ratio_for_main_size_min_max_constraints.
func layout_flex_formatting_context_adjust_cross_size_through_aspect_ratio_for_main_size_min_max_constraints(this: LayoutFlexFormattingContext*, box: LayoutBox*, cross_size: gfx.CssPixels, min_main_size: CssSize, max_main_size: CssSize) -> gfx.CssPixels:
    var adjusted_cross_size = cross_size
    let reference_value = layout_state_used_values_content_width(this.m_flex_container_state) if layout_flex_formatting_context_main_axis_is_horizontal(this) else layout_state_used_values_content_height(this.m_flex_container_state)
    if not layout_flex_formatting_context_should_treat_main_max_size_as_none(this, box):
        let max_main_size_px = css_size_to_px(&max_main_size, box.layout_node(), reference_value)
        let aspect_ratio = layout_box_preferred_aspect_ratio(box) else trap("VERIFY: the box has a preferred aspect ratio")
        adjusted_cross_size = ak.min(adjusted_cross_size, layout_flex_formatting_context_calculate_cross_size_from_main_size_and_aspect_ratio(this, max_main_size_px, aspect_ratio))

    if not css_size_is_auto(&min_main_size):
        let min_main_size_px = css_size_to_px(&min_main_size, box.layout_node(), reference_value)
        let aspect_ratio = layout_box_preferred_aspect_ratio(box) else trap("VERIFY: the box has a preferred aspect ratio")
        adjusted_cross_size = ak.max(adjusted_cross_size, layout_flex_formatting_context_calculate_cross_size_from_main_size_and_aspect_ratio(this, min_main_size_px, aspect_ratio))

    return adjusted_cross_size