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)