Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / layout / flex_formatting_context_5.lucb

#==============================================================================================
#
#   flex_formatting_context_5 - Layout::FlexFormattingContext: aligning the flex lines,
#                               committing the items' boxes and the container's intrinsic sizes
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/FlexFormattingContext.cpp (lines 1645-2068): aligning the flex
#       lines per align-content, copying the items' used sizes, offsets and box model into
#       their used values, the intrinsic main and cross sizes of the flex container
#       (https://drafts.csswg.org/css-flexbox-1/#intrinsic-sizes: desired flex fractions,
#       chosen flex fractions per line) and the main-size min/max-content contributions of an
#       item.
#
#       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: Aligning the flex lines =================================================================

## The `place_items` lambda of FlexFormattingContext::align_all_flex_lines (its captures are the parameters;
## `start_of_current_line` is updated in place).
func layout_flex_formatting_context_place_items(this: LayoutFlexFormattingContext*, flex_line: LayoutFlexFormattingContextFlexLine*, place_items_backwards: bool, gap_size: gfx.CssPixels, start_of_current_line: gfx.CssPixels*):
    if place_items_backwards:
        let center_of_current_line = start_of_current_line.sub(layout_div_int(flex_line.cross_size, 2))
        for backwards_item in ak.vector_span(&flex_line.items):
            backwards_item.cross_offset = backwards_item.cross_offset.add(center_of_current_line)
        *start_of_current_line = start_of_current_line.sub(flex_line.cross_size.add(gap_size))
        # CSS-FLEXBOX-2: Account for gap between flex lines.
        *start_of_current_line = start_of_current_line.sub(layout_flex_formatting_context_cross_gap(this))
    else:
        let center_of_current_line = start_of_current_line.add(layout_div_int(flex_line.cross_size, 2))
        for item in ak.vector_span(&flex_line.items):
            item.cross_offset = item.cross_offset.add(center_of_current_line)
        *start_of_current_line = start_of_current_line.add(flex_line.cross_size.add(gap_size))
        # CSS-FLEXBOX-2: Account for gap between flex lines.
        *start_of_current_line = start_of_current_line.add(layout_flex_formatting_context_cross_gap(this))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:1646 Web::Layout::FlexFormattingContext::align_all_flex_lines.
# https://drafts.csswg.org/css-flexbox-1/#algo-line-align
func layout_flex_formatting_context_align_all_flex_lines(this: LayoutFlexFormattingContext*):
    # Align all flex lines per align-content.

    if ak.vector_is_empty(&this.m_flex_lines):
        return

    let reverse_cross_axis = layout_flex_formatting_context_cross_axis_is_reverse(this)
    var place_items_backwards = false
    var iterate_lines_backwards = false

    let cross_size_of_flex_container = layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state)

    if layout_flex_formatting_context_is_single_line(this):
        # For single-line flex containers, we only need to center the line along the cross axis.
        let flex_line = ak.vector_at(&this.m_flex_lines, 0)
        let center_of_line = layout_div_int(cross_size_of_flex_container, 2)
        for item in ak.vector_span(&flex_line.items):
            item.cross_offset = item.cross_offset.add(center_of_line)
        return

    let lines = ak.vector_span(&this.m_flex_lines)
    var sum_of_flex_line_cross_sizes = layout_zero_px()
    for line in lines:
        sum_of_flex_line_cross_sizes = sum_of_flex_line_cross_sizes.add(line.cross_size)

    # CSS-FLEXBOX-2: Account for gap between flex lines.
    sum_of_flex_line_cross_sizes = sum_of_flex_line_cross_sizes.add(layout_flex_formatting_context_mul_count(layout_flex_formatting_context_cross_gap(this), lines.length -% 1))

    var start_of_current_line = layout_zero_px()
    var gap_size = layout_zero_px()
    match css_computed_values_align_content(layout_box_computed(layout_flex_formatting_context_flex_container(this))):
        .start:
            start_of_current_line = layout_zero_px()
            iterate_lines_backwards = reverse_cross_axis
        .end:
            start_of_current_line = cross_size_of_flex_container
            place_items_backwards = true
            iterate_lines_backwards = not reverse_cross_axis
        .flex_start:
            if reverse_cross_axis:
                start_of_current_line = cross_size_of_flex_container
                place_items_backwards = true
            else:
                start_of_current_line = layout_zero_px()
        .flex_end:
            iterate_lines_backwards = true
            if reverse_cross_axis:
                start_of_current_line = layout_zero_px()
            else:
                start_of_current_line = cross_size_of_flex_container
                place_items_backwards = true
        .center:
            iterate_lines_backwards = reverse_cross_axis
            start_of_current_line = layout_div_int(cross_size_of_flex_container, 2).sub(layout_div_int(sum_of_flex_line_cross_sizes, 2))
        .space_between:
            if reverse_cross_axis:
                start_of_current_line = cross_size_of_flex_container
                place_items_backwards = true
            else:
                start_of_current_line = layout_zero_px()

            let leftover_free_space = cross_size_of_flex_container.sub(sum_of_flex_line_cross_sizes)
            let leftover_flex_lines_size = lines.length
            if leftover_free_space.ge(layout_zero_px()) and leftover_flex_lines_size > 1:
                let gap_count = (i32)leftover_flex_lines_size - 1
                gap_size = layout_div_int(leftover_free_space, (i64)gap_count)
        .space_around:
            iterate_lines_backwards = reverse_cross_axis
            let leftover_free_space = cross_size_of_flex_container.sub(sum_of_flex_line_cross_sizes)
            if leftover_free_space.lt(layout_zero_px()):
                # If the leftover free-space is negative this value is identical to center.
                start_of_current_line = layout_div_int(cross_size_of_flex_container, 2).sub(layout_div_int(sum_of_flex_line_cross_sizes, 2))
            else:
                gap_size = layout_div_int(leftover_free_space, (i64)lines.length)

                # The spacing between the first/last lines and the flex container edges is half the size of the spacing between flex lines.
                start_of_current_line = layout_div_int(gap_size, 2)
        .space_evenly:
            iterate_lines_backwards = reverse_cross_axis
            let leftover_free_space = cross_size_of_flex_container.sub(sum_of_flex_line_cross_sizes)
            if leftover_free_space.lt(layout_zero_px()):
                # If the leftover free-space is negative this value is identical to center.
                start_of_current_line = layout_div_int(cross_size_of_flex_container, 2).sub(layout_div_int(sum_of_flex_line_cross_sizes, 2))
            else:
                gap_size = layout_div_int(leftover_free_space, (i64)(lines.length + 1))

                # The spacing between the first/last lines and the flex container edges is the size of the spacing between flex lines.
                start_of_current_line = gap_size
        .normal, .stretch:
            if reverse_cross_axis:
                start_of_current_line = cross_size_of_flex_container
                place_items_backwards = true
            else:
                start_of_current_line = layout_zero_px()
        _:
            # The C++ switch has no default: other values leave the line positions alone.
            _ = 0

    # (place_items is layout_flex_formatting_context_place_items.)
    if iterate_lines_backwards:
        var index = lines.length
        while index > 0:
            index -= 1
            layout_flex_formatting_context_place_items(this, &lines[index], place_items_backwards, gap_size, &start_of_current_line)
    else:
        for flex_line in &lines:
            layout_flex_formatting_context_place_items(this, flex_line, place_items_backwards, gap_size, &start_of_current_line)

# mark: Committing the items ====================================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:1798 Web::Layout::FlexFormattingContext::copy_dimensions_from_flex_items_to_boxes.
func layout_flex_formatting_context_copy_dimensions_from_flex_items_to_boxes(this: LayoutFlexFormattingContext*):
    let items = ak.vector_span(&this.m_flex_items)
    for item in &items:
        let box = item.box
        let node = box.layout_node()
        let computed_values = layout_box_computed(box)
        let margin = css_computed_values_margin(computed_values)
        let margin_left = css_length_box_left_const(&margin)
        let margin_right = css_length_box_right_const(&margin)
        let margin_top = css_length_box_top_const(&margin)
        let margin_bottom = css_length_box_bottom_const(&margin)

        item.used_values.margin_left = css_length_percentage_or_auto_to_px_or_zero(&margin_left, node, layout_state_used_values_content_width(this.m_flex_container_state))
        item.used_values.margin_right = css_length_percentage_or_auto_to_px_or_zero(&margin_right, node, layout_state_used_values_content_width(this.m_flex_container_state))
        item.used_values.margin_top = css_length_percentage_or_auto_to_px_or_zero(&margin_top, node, layout_state_used_values_content_width(this.m_flex_container_state))
        item.used_values.margin_bottom = css_length_percentage_or_auto_to_px_or_zero(&margin_bottom, node, layout_state_used_values_content_width(this.m_flex_container_state))

        item.used_values.border_left = css_computed_values_border_left(computed_values).width
        item.used_values.border_right = css_computed_values_border_right(computed_values).width
        item.used_values.border_top = css_computed_values_border_top(computed_values).width
        item.used_values.border_bottom = css_computed_values_border_bottom(computed_values).width

        layout_flex_formatting_context_set_main_size_layout_flex_formatting_context(this, item, item.main_size else trap("VERIFY: the item's main size is determined"))
        layout_flex_formatting_context_set_cross_size_layout_flex_formatting_context(this, item, item.cross_size else trap("VERIFY: the item's cross size is determined"))
        layout_flex_formatting_context_set_offset(this, item, item.main_offset, item.cross_offset)

# mark: Intrinsic sizes of the flex container ===================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:1820 Web::Layout::FlexFormattingContext::determine_intrinsic_size_of_flex_container.
# https://drafts.csswg.org/css-flexbox-1/#intrinsic-sizes
func layout_flex_formatting_context_determine_intrinsic_size_of_flex_container(this: LayoutFlexFormattingContext*):
    let available_space_for_items = layout_flex_formatting_context_available_space_for_items(this)
    if layout_available_size_is_intrinsic_sizing_constraint(&available_space_for_items.main):
        let main_size = layout_flex_formatting_context_calculate_intrinsic_main_size_of_flex_container(this)
        layout_flex_formatting_context_set_main_size_layout_box(this, layout_flex_formatting_context_flex_container(this), main_size)
    if layout_available_size_is_intrinsic_sizing_constraint(&available_space_for_items.cross):
        let cross_size = layout_flex_formatting_context_calculate_intrinsic_cross_size_of_flex_container(this)
        layout_flex_formatting_context_set_cross_size_layout_box(this, layout_flex_formatting_context_flex_container(this), cross_size)

## The `determine_main_size` lambda of FlexFormattingContext::calculate_intrinsic_main_size_of_flex_container.
func layout_flex_formatting_context_determine_main_size(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
    var largest_sum = layout_zero_px()
    let lines = ak.vector_span(&this.m_flex_lines)
    for flex_line in &lines:
        # 4. Add each item’s flex base size to the product of its flex grow factor (scaled flex shrink factor, if shrinking)
        #    and the chosen flex fraction, then clamp that result by the max main size floored by the min main size.
        var sum = layout_zero_px()
        for item in ak.vector_span(&flex_line.items):
            var product = 0.0
            if item.desired_flex_fraction > 0.0:
                product = flex_line.chosen_flex_fraction * (f64)css_computed_values_flex_grow(layout_box_computed(item.box))
            elif item.desired_flex_fraction < 0.0:
                product = flex_line.chosen_flex_fraction * item.scaled_flex_shrink_factor
            var result = item.flex_base_size.add(gfx.css_pixels_nearest_value_for_f64(product))

            let computed_min_size = layout_flex_formatting_context_computed_main_min_size(this, item.box)
            let computed_max_size = layout_flex_formatting_context_computed_main_max_size(this, item.box)

            let clamp_min = layout_flex_formatting_context_specified_main_min_size(this, item) if (not css_size_is_auto(&computed_min_size) and not css_size_contains_percentage(&computed_min_size)) else layout_flex_formatting_context_automatic_minimum_size(this, item)
            let clamp_max = layout_flex_formatting_context_specified_main_max_size(this, item) if (not layout_flex_formatting_context_should_treat_main_max_size_as_none(this, item.box) and not css_size_contains_percentage(&computed_max_size)) else gfx.css_pixels_max()

            result = layout_css_clamp(result, clamp_min, clamp_max)

            # NOTE: The spec doesn't mention anything about the *outer* size here, but if we don't add the margin box,
            #       flex items with non-zero padding/border/margin in the main axis end up overflowing the container.
            result = layout_flex_formatting_context_flex_item_add_main_margin_box_sizes(item, result)

            sum = sum.add(result)
        # CSS-FLEXBOX-2: Account for gap between flex items.
        sum = sum.add(layout_flex_formatting_context_mul_count(layout_flex_formatting_context_main_gap(this), ak.vector_size(&flex_line.items) -% 1))
        largest_sum = ak.max(largest_sum, sum)
    # 5. The flex container’s max-content size is the largest sum (among all the lines) of the afore-calculated sizes of all items within a single line.
    return largest_sum

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:1833 Web::Layout::FlexFormattingContext::calculate_intrinsic_main_size_of_flex_container.
# https://drafts.csswg.org/css-flexbox-1/#intrinsic-main-sizes
func layout_flex_formatting_context_calculate_intrinsic_main_size_of_flex_container(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
    let available_main = layout_flex_formatting_context_available_space_for_items(this).main
    let items = ak.vector_span(&this.m_flex_items)

    # The min-content main size of a single-line flex container is calculated identically to the max-content main size,
    # except that the flex items’ min-content contributions are used instead of their max-content contributions.
    # However, for a multi-line container, it is simply the largest min-content contribution of all the non-collapsed flex items in the flex container.
    if not layout_flex_formatting_context_is_single_line(this) and layout_available_size_is_min_content(&available_main):
        var largest_contribution = layout_zero_px()
        for contributing_item in &items:
            # FIXME: Skip collapsed flex items.
            largest_contribution = ak.max(largest_contribution, layout_flex_formatting_context_calculate_main_min_content_contribution(this, contributing_item))
        return largest_contribution

    # The max-content main size of a flex container is, fundamentally, the smallest size the flex container
    # can take such that when flex layout is run with that container size, each flex item ends up at least
    # as large as its max-content contribution, to the extent allowed by the items’ flexibility.
    # It is calculated, considering only non-collapsed flex items, by:

    # 1. For each flex item, subtract its outer flex base size from its max-content contribution size.
    #    If that result is positive, divide it by the item’s flex grow factor if the flex grow factor is ≥ 1,
    #    or multiply it by the flex grow factor if the flex grow factor is < 1; if the result is negative,
    #    divide it by the item’s scaled flex shrink factor (if dividing by zero, treat the result as negative infinity).
    #    This is the item’s desired flex fraction.

    for item in &items:
        var contribution = layout_zero_px()
        if layout_available_size_is_min_content(&available_main):
            contribution = layout_flex_formatting_context_calculate_main_min_content_contribution(this, item)
        elif layout_available_size_is_max_content(&available_main):
            contribution = layout_flex_formatting_context_calculate_main_max_content_contribution(this, item)

        let outer_flex_base_size = item.flex_base_size.add(item.margins.main_before).add(item.margins.main_after).add(item.borders.main_before).add(item.borders.main_after).add(item.padding.main_before).add(item.padding.main_after)

        var result = contribution.sub(outer_flex_base_size)
        if gfx.gt_css_pixels_int(result, 0):
            let flex_grow = css_computed_values_flex_grow(layout_box_computed(item.box))
            if flex_grow >= 1.0:
                _ = gfx.css_pixels_scale_by_f32(&result, 1.0 / flex_grow)
            else:
                _ = gfx.css_pixels_scale_by_f32(&result, flex_grow)
        elif gfx.lt_int(result, 0):
            if item.scaled_flex_shrink_factor == 0.0:
                result = gfx.css_pixels_min()
            else:
                _ = gfx.css_pixels_scale_by_f64(&result, 1.0 / item.scaled_flex_shrink_factor)

        item.desired_flex_fraction = result.to_double()

    # 2. Place all flex items into lines of infinite length.
    ak.vector_clear(&this.m_flex_lines)
    if not ak.vector_is_empty(&this.m_flex_items):
        ak.vector_append_t(&this.m_flex_lines, LayoutFlexFormattingContextFlexLine())
    for line_item in &items:
        # FIXME: Honor breaking requests.
        ak.vector_append_t(&ak.vector_last(&this.m_flex_lines).items, line_item)

    #    Within each line, find the greatest (most positive) desired flex fraction among all the flex items.
    #    This is the line’s chosen flex fraction.
    let lines = ak.vector_span(&this.m_flex_lines)
    for flex_line in &lines:
        var greatest_desired_flex_fraction: f32 = 0.0
        var sum_of_flex_grow_factors: f32 = 0.0
        var sum_of_flex_shrink_factors: f32 = 0.0
        for fraction_item in ak.vector_span(&flex_line.items):
            greatest_desired_flex_fraction = ak.max(greatest_desired_flex_fraction, (f32)fraction_item.desired_flex_fraction)
            let computed_values = layout_box_computed(fraction_item.box)
            sum_of_flex_grow_factors += css_computed_values_flex_grow(computed_values)
            sum_of_flex_shrink_factors += css_computed_values_flex_shrink(computed_values)
        var chosen_flex_fraction = greatest_desired_flex_fraction

        # 3. If the chosen flex fraction is positive, and the sum of the line’s flex grow factors is less than 1,
        #    divide the chosen flex fraction by that sum.
        if chosen_flex_fraction > 0.0 and sum_of_flex_grow_factors < 1.0:
            chosen_flex_fraction /= sum_of_flex_grow_factors

        # If the chosen flex fraction is negative, and the sum of the line’s flex shrink factors is less than 1,
        # multiply the chosen flex fraction by that sum.
        if chosen_flex_fraction < 0.0 and sum_of_flex_shrink_factors < 1.0:
            chosen_flex_fraction *= sum_of_flex_shrink_factors

        flex_line.chosen_flex_fraction = (f64)chosen_flex_fraction

    # (determine_main_size is layout_flex_formatting_context_determine_main_size.)
    let main_size = layout_flex_formatting_context_determine_main_size(this)
    layout_flex_formatting_context_set_main_size_layout_box(this, layout_flex_formatting_context_flex_container(this), main_size)
    return main_size

## The `calculate_largest_contribution` lambda of FlexFormattingContext::calculate_intrinsic_cross_size_of_flex_container
## for a single-line container: the min-content or max-content contribution, as the cross axis is sized.
func layout_flex_formatting_context_calculate_largest_contribution(this: LayoutFlexFormattingContext*, resolve_percentage_min_max_sizes: bool) -> gfx.CssPixels:
    let available_cross = layout_flex_formatting_context_available_space_for_items(this).cross
    var largest_contribution = layout_zero_px()
    let items = ak.vector_span(&this.m_flex_items)
    for item in &items:
        var contribution = layout_zero_px()
        if layout_available_size_is_min_content(&available_cross):
            contribution = layout_flex_formatting_context_calculate_cross_min_content_contribution(this, item, resolve_percentage_min_max_sizes)
        elif layout_available_size_is_max_content(&available_cross):
            contribution = layout_flex_formatting_context_calculate_cross_max_content_contribution(this, item, resolve_percentage_min_max_sizes)
        largest_contribution = ak.max(largest_contribution, contribution)
    return largest_contribution

## The `calculate_largest_contribution` lambda of FlexFormattingContext::calculate_intrinsic_cross_size_of_flex_container
## for a multi-line column container under a min-content constraint.
func layout_flex_formatting_context_calculate_largest_min_content_contribution(this: LayoutFlexFormattingContext*, resolve_percentage_min_max_sizes: bool) -> gfx.CssPixels:
    var largest_contribution = layout_zero_px()
    let items = ak.vector_span(&this.m_flex_items)
    for item in &items:
        let contribution = layout_flex_formatting_context_calculate_cross_min_content_contribution(this, item, resolve_percentage_min_max_sizes)
        largest_contribution = ak.max(largest_contribution, contribution)
    return largest_contribution

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:1961 Web::Layout::FlexFormattingContext::calculate_intrinsic_cross_size_of_flex_container.
# https://drafts.csswg.org/css-flexbox-1/#intrinsic-cross-sizes
func layout_flex_formatting_context_calculate_intrinsic_cross_size_of_flex_container(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
    # The min-content/max-content cross size of a single-line flex container
    # is the largest min-content contribution/max-content contribution (respectively) of its flex items.
    if layout_flex_formatting_context_is_single_line(this):
        # (calculate_largest_contribution is layout_flex_formatting_context_calculate_largest_contribution.)
        let first_pass_largest_contribution = layout_flex_formatting_context_calculate_largest_contribution(this, false)
        layout_flex_formatting_context_set_cross_size_layout_box(this, layout_flex_formatting_context_flex_container(this), first_pass_largest_contribution)
        let second_pass_largest_contribution = layout_flex_formatting_context_calculate_largest_contribution(this, true)
        return second_pass_largest_contribution

    if layout_flex_formatting_context_is_row_layout(this):
        # row multi-line flex container cross-size

        # The min-content/max-content cross size is the sum of the flex line cross sizes resulting from
        # sizing the flex container under a cross-axis min-content constraint/max-content constraint (respectively).

        # NOTE: We fall through to the ad-hoc section below.
        _ = 0
    else:
        # column multi-line flex container cross-size

        # The min-content cross size is the largest min-content contribution among all of its flex items.
        let available_cross = layout_flex_formatting_context_available_space_for_items(this).cross
        if layout_available_size_is_min_content(&available_cross):
            # (calculate_largest_contribution is layout_flex_formatting_context_calculate_largest_min_content_contribution.)
            let first_pass_largest_contribution = layout_flex_formatting_context_calculate_largest_min_content_contribution(this, false)
            layout_flex_formatting_context_set_cross_size_layout_box(this, layout_flex_formatting_context_flex_container(this), first_pass_largest_contribution)
            let second_pass_largest_contribution = layout_flex_formatting_context_calculate_largest_min_content_contribution(this, true)
            return second_pass_largest_contribution

        # The max-content cross size is the sum of the flex line cross sizes resulting from
        # sizing the flex container under a cross-axis max-content constraint,
        # using the largest max-content cross-size contribution among the flex items
        # as the available space in the cross axis for each of the flex items during layout.

        # NOTE: We fall through to the ad-hoc section below.

    var sum_of_flex_line_cross_sizes = layout_zero_px()
    let lines = ak.vector_span(&this.m_flex_lines)
    for flex_line in lines:
        sum_of_flex_line_cross_sizes = sum_of_flex_line_cross_sizes.add(flex_line.cross_size)
    # CSS-FLEXBOX-2: Account for gap between flex lines.
    sum_of_flex_line_cross_sizes = sum_of_flex_line_cross_sizes.add(layout_flex_formatting_context_mul_count(layout_flex_formatting_context_cross_gap(this), lines.length -% 1))
    return sum_of_flex_line_cross_sizes

# mark: Main-size contributions of an item ======================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2030 Web::Layout::FlexFormattingContext::calculate_main_min_content_contribution.
# https://drafts.csswg.org/css-flexbox-1/#intrinsic-item-contributions
func layout_flex_formatting_context_calculate_main_min_content_contribution(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    # The main-size min-content contribution of a flex item is the larger of its outer min-content size and outer
    # preferred size if that is not auto, clamped by its min/max main size.
    var larger_size = layout_flex_formatting_context_calculate_min_content_main_size(this, item)
    let computed_main_size = layout_flex_formatting_context_computed_main_size(this, item.box)
    if not css_size_is_auto(&computed_main_size):
        let inner_preferred_size = layout_flex_formatting_context_get_pixel_width(this, item, computed_main_size) if layout_flex_formatting_context_main_axis_is_horizontal(this) else layout_flex_formatting_context_get_pixel_height(this, item, computed_main_size)
        larger_size = ak.max(larger_size, inner_preferred_size)

    let clamp_min = layout_flex_formatting_context_specified_main_min_size(this, item) if layout_flex_formatting_context_has_main_min_size(this, item.box) else layout_flex_formatting_context_automatic_minimum_size(this, item)
    let clamp_max = layout_flex_formatting_context_specified_main_max_size(this, item) if layout_flex_formatting_context_has_main_max_size(this, item.box) else gfx.css_pixels_max()
    let clamped_inner_size = layout_css_clamp(larger_size, clamp_min, clamp_max)

    return layout_flex_formatting_context_flex_item_add_main_margin_box_sizes(item, clamped_inner_size)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2050 Web::Layout::FlexFormattingContext::calculate_main_max_content_contribution.
# https://drafts.csswg.org/css-flexbox-1/#intrinsic-item-contributions
func layout_flex_formatting_context_calculate_main_max_content_contribution(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    # The main-size max-content contribution of a flex item is
    # the larger of its outer max-content size and outer preferred size if that is not auto,
    # clamped by its min/max main size.
    var larger_size = layout_flex_formatting_context_calculate_max_content_main_size(this, item)
    let computed_main_size = layout_flex_formatting_context_computed_main_size(this, item.box)
    if not css_size_is_auto(&computed_main_size):
        let inner_preferred_size = layout_flex_formatting_context_get_pixel_width(this, item, computed_main_size) if layout_flex_formatting_context_main_axis_is_horizontal(this) else layout_flex_formatting_context_get_pixel_height(this, item, computed_main_size)
        larger_size = ak.max(larger_size, inner_preferred_size)

    let clamp_min = layout_flex_formatting_context_specified_main_min_size(this, item) if layout_flex_formatting_context_has_main_min_size(this, item.box) else layout_flex_formatting_context_automatic_minimum_size(this, item)
    let clamp_max = layout_flex_formatting_context_specified_main_max_size(this, item) if layout_flex_formatting_context_has_main_max_size(this, item.box) else gfx.css_pixels_max()
    let clamped_inner_size = layout_css_clamp(larger_size, clamp_min, clamp_max)

    return layout_flex_formatting_context_flex_item_add_main_margin_box_sizes(item, clamped_inner_size)