Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / layout / flex_formatting_context_6.lucb

#==============================================================================================
#
#   flex_formatting_context_6 - Layout::FlexFormattingContext: automatic sizes, cross-size
#                               contributions, intrinsic item sizes and static positions
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/FlexFormattingContext.cpp (lines 2070-2449): when main/cross sizes
#       are treated as auto and max sizes as none, the cross-size min/max-content contributions
#       of an item, the width used to find an item's intrinsic height, the intrinsic and
#       fit-content main and cross sizes of an item, stretched items, the computed main and
#       cross sizes, cross-axis auto margins, align-content: stretch, the static-position
#       rectangle of an absolutely positioned child, a flex line's sums of flex factors, and
#       the main and cross gaps.
#
#       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: Auto sizes and max sizes as none ========================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2070 Web::Layout::FlexFormattingContext::should_treat_main_size_as_auto.
func layout_flex_formatting_context_should_treat_main_size_as_auto(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    let space = layout_flex_formatting_context_available_space_for_items(this).space
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return layout_formatting_context_should_treat_width_as_auto(this.layout_formatting_context(), box, space)
    return layout_formatting_context_should_treat_height_as_auto(this.layout_formatting_context(), box, space)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2077 Web::Layout::FlexFormattingContext::should_treat_cross_size_as_auto.
func layout_flex_formatting_context_should_treat_cross_size_as_auto(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    let space = layout_flex_formatting_context_available_space_for_items(this).space
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        return layout_formatting_context_should_treat_width_as_auto(this.layout_formatting_context(), box, space)
    return layout_formatting_context_should_treat_height_as_auto(this.layout_formatting_context(), box, space)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2084 Web::Layout::FlexFormattingContext::should_treat_main_max_size_as_none.
func layout_flex_formatting_context_should_treat_main_max_size_as_none(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    let space = layout_flex_formatting_context_available_space_for_items(this).space
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return layout_formatting_context_should_treat_max_width_as_none(this.layout_formatting_context(), box, space.width)
    return layout_formatting_context_should_treat_max_height_as_none(this.layout_formatting_context(), box, space.height)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2091 Web::Layout::FlexFormattingContext::should_treat_cross_max_size_as_none.
func layout_flex_formatting_context_should_treat_cross_max_size_as_none(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> bool:
    let space = layout_flex_formatting_context_available_space_for_items(this).space
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        return layout_formatting_context_should_treat_max_width_as_none(this.layout_formatting_context(), box, space.width)
    return layout_formatting_context_should_treat_max_height_as_none(this.layout_formatting_context(), box, space.height)

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

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2098 Web::Layout::FlexFormattingContext::calculate_cross_min_content_contribution.
func layout_flex_formatting_context_calculate_cross_min_content_contribution(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*, resolve_percentage_min_max_sizes: bool) -> gfx.CssPixels:
    let cross_size_auto = layout_flex_formatting_context_should_treat_cross_size_as_auto(this, item.box)
    var size: gfx.CssPixels
    if cross_size_auto:
        size = layout_flex_formatting_context_calculate_min_content_cross_size(this, item)
    elif layout_flex_formatting_context_cross_axis_is_horizontal(this):
        size = layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))
    else:
        size = layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))

    if cross_size_auto and layout_box_has_preferred_aspect_ratio(item.box):
        size = layout_flex_formatting_context_adjust_cross_size_through_aspect_ratio_for_main_size_min_max_constraints(this, item.box, size, layout_flex_formatting_context_computed_main_min_size(this, item.box), layout_flex_formatting_context_computed_main_max_size(this, item.box))

    let computed_min_size = layout_flex_formatting_context_computed_cross_min_size(this, item.box)
    let computed_max_size = layout_flex_formatting_context_computed_cross_max_size(this, item.box)

    let clamp_min = layout_flex_formatting_context_specified_cross_min_size(this, item) if (not css_size_is_auto(&computed_min_size) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_min_size))) else layout_zero_px()
    let clamp_max = layout_flex_formatting_context_specified_cross_max_size(this, item) if (not layout_flex_formatting_context_should_treat_cross_max_size_as_none(this, item.box) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_max_size))) else gfx.css_pixels_max()

    let clamped_inner_size = layout_css_clamp(size, clamp_min, clamp_max)

    return layout_flex_formatting_context_flex_item_add_cross_margin_box_sizes(item, clamped_inner_size)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2121 Web::Layout::FlexFormattingContext::calculate_cross_max_content_contribution.
func layout_flex_formatting_context_calculate_cross_max_content_contribution(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*, resolve_percentage_min_max_sizes: bool) -> gfx.CssPixels:
    let cross_size_auto = layout_flex_formatting_context_should_treat_cross_size_as_auto(this, item.box)
    var size: gfx.CssPixels
    if cross_size_auto:
        size = layout_flex_formatting_context_calculate_max_content_cross_size(this, item)
    elif layout_flex_formatting_context_cross_axis_is_horizontal(this):
        size = layout_flex_formatting_context_get_pixel_width(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))
    else:
        size = layout_flex_formatting_context_get_pixel_height(this, item, layout_flex_formatting_context_computed_cross_size(this, item.box))

    if cross_size_auto and layout_box_has_preferred_aspect_ratio(item.box):
        size = layout_flex_formatting_context_adjust_cross_size_through_aspect_ratio_for_main_size_min_max_constraints(this, item.box, size, layout_flex_formatting_context_computed_main_min_size(this, item.box), layout_flex_formatting_context_computed_main_max_size(this, item.box))

    let computed_min_size = layout_flex_formatting_context_computed_cross_min_size(this, item.box)
    let computed_max_size = layout_flex_formatting_context_computed_cross_max_size(this, item.box)

    let clamp_min = layout_flex_formatting_context_specified_cross_min_size(this, item) if (not css_size_is_auto(&computed_min_size) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_min_size))) else layout_zero_px()
    let clamp_max = layout_flex_formatting_context_specified_cross_max_size(this, item) if (not layout_flex_formatting_context_should_treat_cross_max_size_as_none(this, item.box) and (resolve_percentage_min_max_sizes or not css_size_contains_percentage(&computed_max_size))) else gfx.css_pixels_max()

    let clamped_inner_size = layout_css_clamp(size, clamp_min, clamp_max)

    return layout_flex_formatting_context_flex_item_add_cross_margin_box_sizes(item, clamped_inner_size)

# mark: Intrinsic sizes of an item ==============================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2144 Web::Layout::FlexFormattingContext::calculate_width_to_use_when_determining_intrinsic_height_of_item.
func layout_flex_formatting_context_calculate_width_to_use_when_determining_intrinsic_height_of_item(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    let box = item.box
    let base = this.layout_formatting_context()
    let computed_values = layout_box_computed(box)
    let computed_width = css_computed_values_width(computed_values)
    let computed_min_width = css_computed_values_min_width(computed_values)
    let computed_max_width = css_computed_values_max_width(computed_values)
    let space = layout_flex_formatting_context_available_space_for_items(this).space

    # We can resolve percentage min/max-width if the available width is definite.
    let can_resolve_percentages = layout_available_size_is_definite(&space.width)

    let clamp_min = layout_flex_formatting_context_get_pixel_width(this, item, computed_min_width) if (not css_size_is_auto(&computed_min_width) and (not css_size_contains_percentage(&computed_min_width) or can_resolve_percentages)) else layout_zero_px()
    let clamp_max = layout_flex_formatting_context_get_pixel_width(this, item, computed_max_width) if (not layout_formatting_context_should_treat_max_width_as_none(base, box, space.width) and (not css_size_contains_percentage(&computed_max_width) or can_resolve_percentages)) else gfx.css_pixels_max()

    var width: gfx.CssPixels
    if layout_formatting_context_should_treat_width_as_auto(base, box, space) or css_size_is_fit_content(&computed_width):
        width = layout_formatting_context_calculate_fit_content_width(base, box, space)
    elif css_size_is_min_content(&computed_width):
        width = layout_formatting_context_calculate_min_content_width(base, box)
    elif css_size_is_max_content(&computed_width):
        width = layout_formatting_context_calculate_max_content_width(base, box)

    return layout_css_clamp(width, clamp_min, clamp_max)

## `item.used_values.available_inner_space_or_constraints_from(m_available_space_for_items->space)` with an indefinite
## width replaced by the width to use when determining the item's intrinsic height (the common part of
## calculate_{min,max}_content_{main,cross}_size when the size is a height).
func layout_flex_formatting_context_available_space_for_intrinsic_height(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> LayoutAvailableSpace:
    var available_space = layout_state_used_values_available_inner_space_or_constraints_from(item.used_values, layout_flex_formatting_context_available_space_for_items(this).space)
    if layout_available_size_is_indefinite(&available_space.width):
        available_space.width = layout_available_size_make_definite(layout_flex_formatting_context_calculate_width_to_use_when_determining_intrinsic_height_of_item(this, item))
    return available_space

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2168 Web::Layout::FlexFormattingContext::calculate_min_content_main_size.
func layout_flex_formatting_context_calculate_min_content_main_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return layout_formatting_context_calculate_min_content_width(this.layout_formatting_context(), item.box)
    let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
    return layout_formatting_context_calculate_min_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2180 Web::Layout::FlexFormattingContext::calculate_max_content_main_size.
func layout_flex_formatting_context_calculate_max_content_main_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return layout_formatting_context_calculate_max_content_width(this.layout_formatting_context(), item.box)
    let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
    return layout_formatting_context_calculate_max_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2192 Web::Layout::FlexFormattingContext::calculate_fit_content_main_size.
func layout_flex_formatting_context_calculate_fit_content_main_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    let space = layout_flex_formatting_context_available_space_for_items(this).space
    if layout_flex_formatting_context_main_axis_is_horizontal(this):
        return layout_formatting_context_calculate_fit_content_width(this.layout_formatting_context(), item.box, space)
    return layout_formatting_context_calculate_fit_content_height(this.layout_formatting_context(), item.box, space)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2199 Web::Layout::FlexFormattingContext::calculate_fit_content_cross_size.
pub func layout_flex_formatting_context_calculate_fit_content_cross_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    let space = layout_flex_formatting_context_available_space_for_items(this).space
    if layout_flex_formatting_context_cross_axis_is_horizontal(this):
        return layout_formatting_context_calculate_fit_content_width(this.layout_formatting_context(), item.box, space)
    return layout_formatting_context_calculate_fit_content_height(this.layout_formatting_context(), item.box, space)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2206 Web::Layout::FlexFormattingContext::calculate_min_content_cross_size.
func layout_flex_formatting_context_calculate_min_content_cross_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if not layout_flex_formatting_context_cross_axis_is_horizontal(this):
        let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
        return layout_formatting_context_calculate_min_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))
    return layout_formatting_context_calculate_min_content_width(this.layout_formatting_context(), item.box)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2218 Web::Layout::FlexFormattingContext::calculate_max_content_cross_size.
func layout_flex_formatting_context_calculate_max_content_cross_size(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> gfx.CssPixels:
    if not layout_flex_formatting_context_cross_axis_is_horizontal(this):
        let available_space = layout_flex_formatting_context_available_space_for_intrinsic_height(this, item)
        return layout_formatting_context_calculate_max_content_height(this.layout_formatting_context(), item.box, layout_available_size_to_px_or_zero(&available_space.width))
    return layout_formatting_context_calculate_max_content_width(this.layout_formatting_context(), item.box)

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2231 Web::Layout::FlexFormattingContext::flex_item_is_stretched.
# https://drafts.csswg.org/css-flexbox-1/#stretched
func layout_flex_formatting_context_flex_item_is_stretched(this: LayoutFlexFormattingContext*, item: const LayoutFlexFormattingContextFlexItem*) -> bool:
    let alignment = layout_flex_formatting_context_alignment_for_item(this, item.box)
    if alignment != css_data.AlignItems.stretch and alignment != css_data.AlignItems.normal:
        return false
    # If the cross size property of the flex item computes to auto, and neither of the cross-axis margins are auto, the flex item is stretched.
    let computed_cross_size = layout_flex_formatting_context_computed_cross_size(this, item.box)
    return css_size_is_auto(&computed_cross_size) and not item.margins.cross_before_is_auto and not item.margins.cross_after_is_auto

# mark: Computed sizes ==========================================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2241 Web::Layout::FlexFormattingContext::computed_main_size.
func layout_flex_formatting_context_computed_main_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
    return css_computed_values_width(layout_box_computed(box)) if layout_flex_formatting_context_main_axis_is_horizontal(this) else css_computed_values_height(layout_box_computed(box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2246 Web::Layout::FlexFormattingContext::computed_main_min_size.
func layout_flex_formatting_context_computed_main_min_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
    return css_computed_values_min_width(layout_box_computed(box)) if layout_flex_formatting_context_main_axis_is_horizontal(this) else css_computed_values_min_height(layout_box_computed(box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2251 Web::Layout::FlexFormattingContext::computed_main_max_size.
func layout_flex_formatting_context_computed_main_max_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
    return css_computed_values_max_width(layout_box_computed(box)) if layout_flex_formatting_context_main_axis_is_horizontal(this) else css_computed_values_max_height(layout_box_computed(box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2256 Web::Layout::FlexFormattingContext::computed_cross_size.
func layout_flex_formatting_context_computed_cross_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
    return css_computed_values_width(layout_box_computed(box)) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else css_computed_values_height(layout_box_computed(box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2261 Web::Layout::FlexFormattingContext::computed_cross_min_size.
func layout_flex_formatting_context_computed_cross_min_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
    return css_computed_values_min_width(layout_box_computed(box)) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else css_computed_values_min_height(layout_box_computed(box))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2266 Web::Layout::FlexFormattingContext::computed_cross_max_size.
func layout_flex_formatting_context_computed_cross_max_size(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> CssSize:
    return css_computed_values_max_width(layout_box_computed(box)) if layout_flex_formatting_context_cross_axis_is_horizontal(this) else css_computed_values_max_height(layout_box_computed(box))

# mark: Cross-axis auto margins and align-content: stretch ======================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2272 Web::Layout::FlexFormattingContext::resolve_cross_axis_auto_margins.
# https://drafts.csswg.org/css-flexbox-1/#algo-cross-margins
func layout_flex_formatting_context_resolve_cross_axis_auto_margins(this: LayoutFlexFormattingContext*):
    let lines = ak.vector_span(&this.m_flex_lines)
    for line in &lines:
        for item in ak.vector_span(&line.items):
            #  If a flex item has auto cross-axis margins:
            if not item.margins.cross_before_is_auto and not item.margins.cross_after_is_auto:
                continue

            # If its outer cross size (treating those auto margins as zero) is less than the cross size of its flex line,
            # distribute the difference in those sizes equally to the auto margins.
            # NB: Auto cross-axis margins are stored as 0, so including them here treats them as zero while keeping
            #     non-auto cross-axis margins in the outer cross size.
            let cross_size = item.cross_size else trap("VERIFY: the item's cross size is determined")
            let outer_cross_size = cross_size.add(item.padding.cross_before).add(item.padding.cross_after).add(item.borders.cross_before).add(item.borders.cross_after).add(item.margins.cross_before).add(item.margins.cross_after)

            if outer_cross_size.lt(line.cross_size):
                let remainder = line.cross_size.sub(outer_cross_size)
                if item.margins.cross_before_is_auto and item.margins.cross_after_is_auto:
                    item.margins.cross_before = layout_div_int(remainder, 2)
                    item.margins.cross_after = layout_div_int(remainder, 2)
                elif item.margins.cross_before_is_auto:
                    item.margins.cross_before = remainder
                else:
                    item.margins.cross_after = remainder
            else:
                # FIXME: Otherwise, if the block-start or inline-start margin (whichever is in the cross axis) is auto, set it to zero.
                #        Set the opposite margin so that the outer cross size of the item equals the cross size of its flex line.
                _ = 0

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2308 Web::Layout::FlexFormattingContext::handle_align_content_stretch.
# https://drafts.csswg.org/css-flexbox-1/#algo-line-stretch
func layout_flex_formatting_context_handle_align_content_stretch(this: LayoutFlexFormattingContext*):
    # If the flex container has a definite cross size,
    if not layout_flex_formatting_context_has_definite_cross_size_layout_state_used_values(this, this.m_flex_container_state):
        return

    # align-content is stretch,
    let align_content = css_computed_values_align_content(layout_box_computed(layout_flex_formatting_context_flex_container(this)))
    if align_content != css_data.AlignContent.stretch and align_content != css_data.AlignContent.normal:
        return

    # and the sum of the flex lines' cross sizes is less than the flex container’s inner cross size,
    let lines = ak.vector_span(&this.m_flex_lines)
    var sum_of_flex_line_cross_sizes = layout_zero_px()
    for summed_line in lines:
        sum_of_flex_line_cross_sizes = sum_of_flex_line_cross_sizes.add(summed_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))

    if sum_of_flex_line_cross_sizes.ge(layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state)):
        return

    # increase the cross size of each flex line by equal amounts
    # such that the sum of their cross sizes exactly equals the flex container’s inner cross size.
    let remainder = layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state).sub(sum_of_flex_line_cross_sizes)
    let extra_per_line = layout_div_int(remainder, (i64)lines.length)

    for line in &lines:
        line.cross_size = line.cross_size.add(extra_per_line)

# mark: Absolutely positioned children ==========================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2339 Web::Layout::FlexFormattingContext::calculate_static_position_rect.
# https://drafts.csswg.org/css-flexbox-1/#abspos-items
pub func layout_flex_formatting_context_calculate_static_position_rect(this: LayoutFlexFormattingContext*, box: LayoutBox*) -> LayoutStaticPositionRect:
    # The cross-axis edges of the static-position rectangle of an absolutely-positioned child
    # of a flex container are the content edges of the flex container.

    var cross_axis_alignment = LayoutStaticPositionRectAlignment.start
    match layout_flex_formatting_context_alignment_for_item(this, box):
        .baseline, .flex_start, .stretch, .normal:
            # (Baseline:) FIXME: Implement this
            #  Fallthrough
            cross_axis_alignment = LayoutStaticPositionRectAlignment.end if layout_flex_formatting_context_cross_axis_is_reverse(this) else LayoutStaticPositionRectAlignment.start
        .flex_end:
            cross_axis_alignment = LayoutStaticPositionRectAlignment.start if layout_flex_formatting_context_cross_axis_is_reverse(this) else LayoutStaticPositionRectAlignment.end
        .start, .self_start:
            cross_axis_alignment = LayoutStaticPositionRectAlignment.start
        .end, .self_end:
            cross_axis_alignment = LayoutStaticPositionRectAlignment.end
        .center:
            cross_axis_alignment = LayoutStaticPositionRectAlignment.center
        _:
            _ = 0

    # The main-axis edges of the static-position rectangle are where the margin edges of the child
    # would be positioned if it were the sole flex item in the flex container,
    # assuming both the child and the flex container were fixed-size boxes of their used size.
    # (For this purpose, auto margins are treated as zero.

    var main_axis_alignment = LayoutStaticPositionRectAlignment.start
    match css_computed_values_justify_content(layout_box_computed(layout_flex_formatting_context_flex_container(this))):
        .start, .left:
            main_axis_alignment = LayoutStaticPositionRectAlignment.start
        .stretch, .normal, .flex_start, .space_between:
            main_axis_alignment = LayoutStaticPositionRectAlignment.end if layout_flex_formatting_context_is_direction_reverse(this) else LayoutStaticPositionRectAlignment.start
        .end:
            main_axis_alignment = LayoutStaticPositionRectAlignment.end
        .right:
            main_axis_alignment = LayoutStaticPositionRectAlignment.end
        .flex_end:
            main_axis_alignment = LayoutStaticPositionRectAlignment.end if not layout_flex_formatting_context_is_direction_reverse(this) else LayoutStaticPositionRectAlignment.start
        .center, .space_around, .space_evenly:
            main_axis_alignment = LayoutStaticPositionRectAlignment.center
        _:
            # The C++ switch has no default: other values keep Start.
            _ = 0

    let main_axis_is_horizontal = layout_flex_formatting_context_main_axis_is_horizontal(this)
    let flex_container_width = layout_flex_formatting_context_inner_main_size_layout_state_used_values(this, this.m_flex_container_state) if main_axis_is_horizontal else layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state)
    let flex_container_height = layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state) if main_axis_is_horizontal else layout_flex_formatting_context_inner_main_size_layout_state_used_values(this, this.m_flex_container_state)

    var static_position_rect = LayoutStaticPositionRect()
    static_position_rect.rect = gfx.CssPixelRect(gfx.CssPixelPoint(layout_zero_px(), layout_zero_px()), gfx.CssPixelSize(flex_container_width, flex_container_height))
    static_position_rect.horizontal_alignment = main_axis_alignment if main_axis_is_horizontal else cross_axis_alignment
    static_position_rect.vertical_alignment = cross_axis_alignment if main_axis_is_horizontal else main_axis_alignment
    return static_position_rect

# mark: Flex lines and gaps =====================================================================

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2415 Web::Layout::FlexFormattingContext::FlexLine::sum_of_flex_factor_of_unfrozen_items.
func layout_flex_formatting_context_flex_line_sum_of_flex_factor_of_unfrozen_items(this: const LayoutFlexFormattingContextFlexLine*) -> f64:
    var sum = 0.0
    for item in ak.vector_span_const(&this.items):
        if not item.frozen:
            sum += item.flex_factor else trap("VERIFY: the item has a flex factor")
    return sum

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2425 Web::Layout::FlexFormattingContext::FlexLine::sum_of_scaled_flex_shrink_factor_of_unfrozen_items.
func layout_flex_formatting_context_flex_line_sum_of_scaled_flex_shrink_factor_of_unfrozen_items(this: const LayoutFlexFormattingContextFlexLine*) -> f64:
    var sum = 0.0
    for item in ak.vector_span_const(&this.items):
        if not item.frozen:
            sum += item.scaled_flex_shrink_factor
    return sum

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2435 Web::Layout::FlexFormattingContext::main_gap.
func layout_flex_formatting_context_main_gap(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
    let computed_values = layout_box_computed(layout_flex_formatting_context_flex_container(this))
    let gap = css_computed_values_column_gap(computed_values) if layout_flex_formatting_context_is_row_layout(this) else css_computed_values_row_gap(computed_values)
    return layout_formatting_context_gap_to_px(this.layout_formatting_context(), gap, layout_flex_formatting_context_inner_main_size_layout_state_used_values(this, this.m_flex_container_state))

## Ported from Libraries/LibWeb/Layout/FlexFormattingContext.cpp:2442 Web::Layout::FlexFormattingContext::cross_gap.
func layout_flex_formatting_context_cross_gap(this: LayoutFlexFormattingContext*) -> gfx.CssPixels:
    let computed_values = layout_box_computed(layout_flex_formatting_context_flex_container(this))
    let gap = css_computed_values_row_gap(computed_values) if layout_flex_formatting_context_is_row_layout(this) else css_computed_values_column_gap(computed_values)
    return layout_formatting_context_gap_to_px(this.layout_formatting_context(), gap, layout_flex_formatting_context_inner_cross_size_layout_state_used_values(this, this.m_flex_container_state))