Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / layout / grid_formatting_context_5.lucb

#==============================================================================================
#
#   grid_formatting_context_5 - Layout::GridFormattingContext: item alignment and sizes,
#                               gutters, box metrics, collapsed auto-fit tracks and grid areas
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/GridFormattingContext.cpp (lines 1613-2056): the alignment of an
#       item in either axis (justify-self / align-self, with `auto` taken from the container's
#       justify-items / align-items), the used size and margins of every item in its grid area
#       (auto margins, alignment, stretching, min and max sizes, replaced elements and aspect
#       ratios), the gutters' sizes under justify-content / align-content, the items' padding,
#       margins and borders, collapsing empty auto-fit tracks, and the rectangle of an item's
#       grid area (or of the augmented grid's padding edges for an absolutely positioned item).
#
#       Copyright (c) 2023-2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       Copyright (c) 2022-2023, Martin Falisse <mfalisse@outlook.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Item alignment ==========================================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1613 Web::Layout::GridFormattingContext::alignment_for_item.
func layout_grid_formatting_context_alignment_for_item(this: LayoutGridFormattingContext*, box: LayoutBox*, dimension: LayoutGridDimension) -> LayoutAlignment:
    let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    if dimension == LayoutGridDimension.column:
        match css_computed_values_justify_self(layout_box_computed(box)):
            .auto: return layout_to_alignment_justify_items(css_computed_values_justify_items(grid_computed_values))
            .end: return LayoutAlignment.end
            .normal: return LayoutAlignment.normal
            .self_start: return LayoutAlignment.self_start
            .self_end: return LayoutAlignment.self_end
            .flex_start: return LayoutAlignment.start
            .flex_end: return LayoutAlignment.end
            .center: return LayoutAlignment.center
            .baseline: return LayoutAlignment.baseline
            .start: return LayoutAlignment.start
            .stretch: return LayoutAlignment.stretch
            .safe: return LayoutAlignment.safe
            .unsafe: return LayoutAlignment.unsafe
            .left: return LayoutAlignment.start
            .right: return LayoutAlignment.end
            _: trap("VERIFY_NOT_REACHED")
    match css_computed_values_align_self(layout_box_computed(box)):
        .auto: return layout_to_alignment_align_items(css_computed_values_align_items(grid_computed_values))
        .end: return LayoutAlignment.end
        .normal: return LayoutAlignment.normal
        .self_start: return LayoutAlignment.self_start
        .self_end: return LayoutAlignment.self_end
        .flex_start: return LayoutAlignment.start
        .flex_end: return LayoutAlignment.end
        .center: return LayoutAlignment.center
        .baseline: return LayoutAlignment.baseline
        .start: return LayoutAlignment.start
        .stretch: return LayoutAlignment.stretch
        .safe: return LayoutAlignment.safe
        .unsafe: return LayoutAlignment.unsafe
        _: trap("VERIFY_NOT_REACHED")

# mark: Item sizes ==============================================================================

## resolve_grid_item_sizes' local `struct ItemAlignment`.
struct LayoutGridFormattingContextItemAlignment:
    var margin_start: gfx.CssPixels
    var margin_end: gfx.CssPixels
    var size: gfx.CssPixels

## The `try_compute_size` lambda of resolve_grid_item_sizes (it captures the item, its containing block size, its
## alignment and the dimension).
func layout_grid_formatting_context_try_compute_size(item: const LayoutGridItem*, containing_block_size: gfx.CssPixels, alignment: LayoutAlignment, dimension: LayoutGridDimension, a_size: gfx.CssPixels, css_size: const CssSize*) -> LayoutGridFormattingContextItemAlignment:
    var result = LayoutGridFormattingContextItemAlignment(margin_start = layout_grid_item_used_margin_start(item, dimension), margin_end = layout_grid_item_used_margin_end(item, dimension), size = a_size)

    # Auto margins absorb positive free space prior to alignment via the box alignment properties.
    let free_space_left_for_margins = containing_block_size.sub(result.size).sub(layout_grid_item_used_margin_box_start(item, dimension)).sub(layout_grid_item_used_margin_box_end(item, dimension))
    let margin_start = layout_grid_item_margin_start(item, dimension)
    let margin_end = layout_grid_item_margin_end(item, dimension)
    if css_length_percentage_or_auto_is_auto(&margin_start) and css_length_percentage_or_auto_is_auto(&margin_end):
        result.margin_start = layout_div_int(free_space_left_for_margins, 2)
        result.margin_end = layout_div_int(free_space_left_for_margins, 2)
    elif css_length_percentage_or_auto_is_auto(&margin_start):
        result.margin_start = free_space_left_for_margins
    elif css_length_percentage_or_auto_is_auto(&margin_end):
        result.margin_end = free_space_left_for_margins
    elif css_size_is_auto(css_size) and not layout_node_is_replaced_box(item.box.layout_node()):
        result.size = result.size.add(free_space_left_for_margins)

    let free_space_left_for_alignment = containing_block_size.sub(a_size).sub(layout_grid_item_used_margin_box_start(item, dimension)).sub(layout_grid_item_used_margin_box_end(item, dimension))
    match alignment:
        .normal, .stretch:
            _ = alignment
        .center:
            result.margin_start = result.margin_start.add(layout_div_int(free_space_left_for_alignment, 2))
            result.margin_end = result.margin_end.add(layout_div_int(free_space_left_for_alignment, 2))
            result.size = a_size
        .baseline, .start:
            result.margin_end = result.margin_end.add(free_space_left_for_alignment)
            result.size = a_size
        .end:
            result.margin_start = result.margin_start.add(free_space_left_for_alignment)
            result.size = a_size
        _:
            _ = alignment

    return result

## The `calculate_inner_size` lambda of resolve_grid_item_sizes.
func layout_grid_formatting_context_calculate_inner_size(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension, available_space: LayoutAvailableSpace, size: CssSize) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return layout_formatting_context_calculate_inner_width(this.layout_formatting_context(), item.box, available_space.width, size)
    return layout_formatting_context_calculate_inner_height(this.layout_formatting_context(), item.box, available_space, size)

## The `tentative_size_for_replaced_element` lambda of resolve_grid_item_sizes.
func layout_grid_formatting_context_tentative_size_for_replaced_element(this: LayoutGridFormattingContext*, item: const LayoutGridItem*, dimension: LayoutGridDimension, available_space: LayoutAvailableSpace, size: CssSize) -> gfx.CssPixels:
    if dimension == LayoutGridDimension.column:
        return layout_formatting_context_tentative_width_for_replaced_element(this.layout_formatting_context(), item.box, size, available_space)
    return layout_formatting_context_tentative_height_for_replaced_element(this.layout_formatting_context(), item.box, size, available_space)

## `*box.preferred_aspect_ratio() != 0`.
func layout_grid_formatting_context_preferred_aspect_ratio_is_not_zero(box: LayoutBox*) -> bool:
    let preferred_aspect_ratio = layout_box_preferred_aspect_ratio(box) else trap("VERIFY: the box has a preferred aspect ratio")
    return gfx.css_pixel_fraction_cmp_int(&preferred_aspect_ratio, 0) != 0

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1683 Web::Layout::GridFormattingContext::resolve_grid_item_sizes.
func layout_grid_formatting_context_resolve_grid_item_sizes(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
    let base = this.layout_formatting_context()
    let items = ak.vector_span(&this.m_grid_items)
    for item in &items:
        let containing_block_size = layout_grid_formatting_context_containing_block_size_for_item(this, item, dimension)
        let alignment = layout_grid_formatting_context_alignment_for_item(this, item.box, dimension)

        let preferred_size = layout_grid_item_preferred_size(item, dimension)

        # (struct ItemAlignment is LayoutGridFormattingContextItemAlignment; try_compute_size is
        # layout_grid_formatting_context_try_compute_size.)

        let available_space = LayoutAvailableSpace(
            width = layout_available_size_make_definite(layout_clamp_to_max_dimension_value(layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.column))),
            height = layout_available_size_make_definite(layout_clamp_to_max_dimension_value(layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.row))))

        # (calculate_inner_size and tentative_size_for_replaced_element are layout_grid_formatting_context_calculate_inner_size
        # and layout_grid_formatting_context_tentative_size_for_replaced_element.)

        var used_alignment: LayoutGridFormattingContextItemAlignment
        let hint = layout_box_auto_content_box_size(item.box)
        var has_replaced_size_hint_in_this_axis = false
        if dimension == LayoutGridDimension.column:
            has_replaced_size_hint_in_this_axis = css_size_with_aspect_ratio_has_width(&hint) or (css_size_with_aspect_ratio_has_height(&hint) and layout_box_has_preferred_aspect_ratio(item.box))
        else:
            has_replaced_size_hint_in_this_axis = css_size_with_aspect_ratio_has_height(&hint) or (css_size_with_aspect_ratio_has_width(&hint) and layout_box_has_preferred_aspect_ratio(item.box))

        if layout_node_is_replaced_box(item.box.layout_node()) and has_replaced_size_hint_in_this_axis:
            let tentative_size = layout_grid_formatting_context_tentative_size_for_replaced_element(this, item, dimension, available_space, preferred_size)
            let item_preferred_size = layout_grid_item_preferred_size(item, dimension)
            used_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, tentative_size, &item_preferred_size)
        else:
            # OPTIMIZATION: For auto-sized items with stretch/normal alignment and no auto margins, the item stretches
            #               to fill the containing block. We can compute this directly without the expensive
            #               calculate_fit_content_width/height calls that trigger intrinsic sizing.
            # NB: Final grid item alignment works with the resolved grid area size. Percentage preferred sizes
            #     must resolve against that definite area instead of being reclassified as auto from the outer
            #     grid container's own definiteness.
            let margin_start = layout_grid_item_margin_start(item, dimension)
            let margin_end = layout_grid_item_margin_end(item, dimension)
            let can_stretch_directly = css_size_is_auto(&preferred_size) and (alignment == LayoutAlignment.stretch or alignment == LayoutAlignment.normal) and not css_length_percentage_or_auto_is_auto(&margin_start) and not css_length_percentage_or_auto_is_auto(&margin_end)
            if can_stretch_directly:
                let stretched_size = containing_block_size.sub(layout_grid_item_used_margin_box_start(item, dimension)).sub(layout_grid_item_used_margin_box_end(item, dimension))
                used_alignment = LayoutGridFormattingContextItemAlignment(margin_start = layout_grid_item_used_margin_start(item, dimension), margin_end = layout_grid_item_used_margin_end(item, dimension), size = stretched_size)
            elif css_size_is_auto(&preferred_size) or css_size_is_fit_content(&preferred_size):
                var fit_content_size: gfx.CssPixels
                if dimension == LayoutGridDimension.column:
                    fit_content_size = layout_formatting_context_calculate_fit_content_width(base, item.box, available_space)
                elif css_size_is_auto(&preferred_size) and layout_box_has_preferred_aspect_ratio(item.box) and layout_grid_formatting_context_preferred_aspect_ratio_is_not_zero(item.box) and layout_state_used_values_has_definite_width(item.used_values):
                    # NB: When the item has a preferred aspect ratio and a definite width, resolve the
                    #     height through the aspect ratio instead of using fit-content sizing, which would
                    #     incorrectly use the available width (grid area width) instead of the item's width.
                    fit_content_size = layout_state_used_values_content_width(item.used_values).div_fraction(layout_box_preferred_aspect_ratio(item.box) else trap("VERIFY: the item has a preferred aspect ratio"))
                else:
                    fit_content_size = layout_formatting_context_calculate_fit_content_height(base, item.box, available_space)
                used_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, fit_content_size, &preferred_size)
            else:
                let size_px = layout_grid_formatting_context_calculate_inner_size(this, item, dimension, available_space, preferred_size)
                used_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, size_px, &preferred_size)

        let should_treat_maximum_size_as_none = layout_formatting_context_should_treat_max_width_as_none(base, item.box, available_space.width) if dimension == LayoutGridDimension.column else layout_formatting_context_should_treat_max_height_as_none(base, item.box, available_space.height)
        if not should_treat_maximum_size_as_none:
            let maximum_size = layout_grid_item_maximum_size(item, dimension)
            let max_size_px = layout_grid_formatting_context_calculate_inner_size(this, item, dimension, available_space, maximum_size)
            let max_width_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, max_size_px, &maximum_size)
            if used_alignment.size.gt(max_width_alignment.size):
                used_alignment = max_width_alignment

        let minimum_size = layout_grid_item_minimum_size(item, dimension)
        if not css_size_is_auto(&minimum_size):
            let min_size_alignment = layout_grid_formatting_context_try_compute_size(item, containing_block_size, alignment, dimension, layout_grid_formatting_context_calculate_inner_size(this, item, dimension, available_space, minimum_size), &minimum_size)
            if used_alignment.size.lt(min_size_alignment.size):
                used_alignment = min_size_alignment

        if dimension == LayoutGridDimension.column:
            item.used_values.margin_left = used_alignment.margin_start
            item.used_values.margin_right = used_alignment.margin_end
            layout_state_used_values_set_content_width(item.used_values, used_alignment.size)
        else:
            item.used_values.margin_top = used_alignment.margin_start
            item.used_values.margin_bottom = used_alignment.margin_end
            layout_state_used_values_set_content_height(item.used_values, used_alignment.size)

# mark: Gutters and box metrics =================================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1839 Web::Layout::GridFormattingContext::resolve_track_spacing.
func layout_grid_formatting_context_resolve_track_spacing(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
    let is_column_dimension = dimension == LayoutGridDimension.column

    let available_space = layout_grid_formatting_context_available_space(this)
    var total_gap_space = layout_available_size_to_px_or_zero(&available_space.width) if is_column_dimension else layout_available_size_to_px_or_zero(&available_space.height)

    let grid_tracks = ak.vector_span(&this.m_grid_columns if is_column_dimension else &this.m_grid_rows)
    for track in &grid_tracks:
        total_gap_space = total_gap_space.sub(track.base_size)
    total_gap_space = ak.max(total_gap_space, layout_zero_px())

    let gap_track_count = ak.vector_size(&this.m_column_gap_tracks) if is_column_dimension else ak.vector_size(&this.m_row_gap_tracks)
    if gap_track_count == 0:
        return

    var space_between_tracks = layout_zero_px()
    var alignment: LayoutAlignment
    let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    if is_column_dimension:
        alignment = layout_to_alignment_justify_content(css_computed_values_justify_content(computed_values))
    else:
        alignment = layout_to_alignment_align_content(css_computed_values_align_content(computed_values))

    match alignment:
        .space_between:
            space_between_tracks = layout_grid_formatting_context_div_count(total_gap_space, gap_track_count)
        .space_around:
            space_between_tracks = layout_grid_formatting_context_div_count(total_gap_space, gap_track_count + 1)
        .space_evenly:
            space_between_tracks = layout_grid_formatting_context_div_count(total_gap_space, gap_track_count + 2)
        _:
            # Normal, Stretch, Start, End, Center and the rest.
            _ = alignment

    let computed_gap = css_computed_values_column_gap(computed_values) if is_column_dimension else css_computed_values_row_gap(computed_values)
    let available_size = layout_available_size_to_px_or_zero(&available_space.width) if is_column_dimension else layout_available_size_to_px_or_zero(&available_space.height)
    space_between_tracks = ak.max(space_between_tracks, layout_formatting_context_gap_to_px(this.layout_formatting_context(), computed_gap, available_size))

    let gap_tracks = ak.vector_span(&this.m_column_gap_tracks if is_column_dimension else &this.m_row_gap_tracks)
    for gap_track in &gap_tracks:
        gap_track.base_size = space_between_tracks

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1892 Web::Layout::GridFormattingContext::resolve_items_box_metrics.
func layout_grid_formatting_context_resolve_items_box_metrics(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
    let grid_container = layout_grid_formatting_context_grid_container(this).layout_node()
    let items = ak.vector_span(&this.m_grid_items)
    for item in &items:
        let computed_values = layout_box_computed(item.box)
        let padding = css_computed_values_padding(computed_values)
        let margin = css_computed_values_margin(computed_values)

        let containing_block_width = layout_grid_formatting_context_containing_block_size_for_item(this, item, LayoutGridDimension.column)
        if dimension == LayoutGridDimension.column:
            let padding_right = css_length_box_right_const(&padding)
            let padding_left = css_length_box_left_const(&padding)
            item.used_values.padding_right = css_length_percentage_or_auto_to_px_or_zero(&padding_right, grid_container, containing_block_width)
            item.used_values.padding_left = css_length_percentage_or_auto_to_px_or_zero(&padding_left, grid_container, containing_block_width)

            let margin_right = css_length_box_right_const(&margin)
            let margin_left = css_length_box_left_const(&margin)
            item.used_values.margin_right = css_length_percentage_or_auto_to_px_or_zero(&margin_right, grid_container, containing_block_width)
            item.used_values.margin_left = css_length_percentage_or_auto_to_px_or_zero(&margin_left, grid_container, containing_block_width)

            item.used_values.border_right = css_computed_values_border_right(computed_values).width
            item.used_values.border_left = css_computed_values_border_left(computed_values).width
        else:
            let padding_top = css_length_box_top_const(&padding)
            let padding_bottom = css_length_box_bottom_const(&padding)
            item.used_values.padding_top = css_length_percentage_or_auto_to_px_or_zero(&padding_top, grid_container, containing_block_width)
            item.used_values.padding_bottom = css_length_percentage_or_auto_to_px_or_zero(&padding_bottom, grid_container, containing_block_width)

            let margin_top = css_length_box_top_const(&margin)
            let margin_bottom = css_length_box_bottom_const(&margin)
            item.used_values.margin_top = css_length_percentage_or_auto_to_px_or_zero(&margin_top, grid_container, containing_block_width)
            item.used_values.margin_bottom = css_length_percentage_or_auto_to_px_or_zero(&margin_bottom, grid_container, containing_block_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

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1920 Web::Layout::GridFormattingContext::collapse_auto_fit_tracks_if_needed.
func layout_grid_formatting_context_collapse_auto_fit_tracks_if_needed(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
    # https://www.w3.org/TR/css-grid-2/#auto-repeat
    # The auto-fit keyword behaves the same as auto-fill, except that after grid item placement any
    # empty repeated tracks are collapsed. An empty track is one with no in-flow grid items placed into
    # or spanning across it. (This can result in all tracks being collapsed, if they’re all empty.)
    let tracks = ak.vector_span(layout_grid_formatting_context_tracks(this, dimension))
    for track_index in 0..<tracks.length:
        if not tracks[track_index].is_auto_fit:
            continue
        # `is_occupied(int column_index, int row_index)`: the size_t index converted to int.
        let column_index: i32 = (i32)track_index if dimension == LayoutGridDimension.column else 0
        let row_index: i32 = (i32)track_index if dimension == LayoutGridDimension.row else 0
        if layout_occupation_grid_is_occupied(&this.m_occupation_grid, column_index, row_index):
            continue

        # NOTE: A collapsed track is treated as having a fixed track sizing function of 0px
        tracks[track_index].min_track_sizing_function = layout_grid_formatting_context_px_grid_size(layout_zero_px())
        tracks[track_index].max_track_sizing_function = layout_grid_formatting_context_px_grid_size(layout_zero_px())

# mark: Grid areas ==============================================================================

## The `place_into_track` lambda of get_grid_area_rect.
func layout_grid_formatting_context_place_into_track(this: LayoutGridFormattingContext*, grid_item: const LayoutGridItem*, area_rect: gfx.CssPixelRect*, dimension: LayoutGridDimension):
    let tracks_and_gaps = ak.vector_span(layout_grid_formatting_context_tracks_and_gaps(this, dimension))

    let resolved_span = layout_grid_item_span(grid_item, dimension) * 2
    let gap_adjusted_position = layout_grid_item_gap_adjusted_position(grid_item, dimension)

    let start: i32 = gap_adjusted_position
    # `start + resolved_span` (int + size_t) converted to int.
    let end: i32 = layout_grid_formatting_context_int_plus_size(start, resolved_span)
    assert(start <= end)

    let grid_container_size = layout_grid_formatting_context_available_size(this, dimension)

    var sum_of_base_sizes_including_gaps = layout_zero_px()
    for summed_track in tracks_and_gaps:
        sum_of_base_sizes_including_gaps = sum_of_base_sizes_including_gaps.add(summed_track.base_size)

    var alignment: LayoutAlignment
    let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    if dimension == LayoutGridDimension.column:
        alignment = layout_to_alignment_justify_content(css_computed_values_justify_content(computed_values))
    else:
        alignment = layout_to_alignment_align_content(css_computed_values_align_content(computed_values))
    var start_offset = layout_zero_px()
    var end_offset = layout_zero_px()
    if alignment == LayoutAlignment.center or alignment == LayoutAlignment.space_around or alignment == LayoutAlignment.space_evenly:
        var free_space = layout_available_size_to_px_or_zero(&grid_container_size).sub(sum_of_base_sizes_including_gaps)
        free_space = ak.max(free_space, layout_zero_px())
        start_offset = layout_div_int(free_space, 2)
        end_offset = layout_div_int(free_space, 2)
    elif alignment == LayoutAlignment.end:
        let free_space = layout_available_size_to_px_or_zero(&grid_container_size).sub(sum_of_base_sizes_including_gaps)
        start_offset = free_space
        end_offset = free_space

    # `min(start, tracks_and_gaps.size())` is AK::min<int>.
    let track_count = (i32)tracks_and_gaps.length
    for i in 0..<ak.min[i32](start, track_count):
        start_offset = start_offset.add(tracks_and_gaps[(usize)i].base_size)
    for i in 0..<ak.min[i32](end, track_count):
        end_offset = end_offset.add(tracks_and_gaps[(usize)i].base_size)

    if dimension == LayoutGridDimension.column:
        gfx.css_pixel_rect_set_x(area_rect, start_offset)
        gfx.css_pixel_rect_set_width(area_rect, end_offset.sub(start_offset))
    else:
        gfx.css_pixel_rect_set_y(area_rect, start_offset)
        gfx.css_pixel_rect_set_height(area_rect, end_offset.sub(start_offset))

## The `place_into_track_formed_by_last_line_and_grid_container_padding_edge` lambda of get_grid_area_rect.
func layout_grid_formatting_context_place_into_track_formed_by_last_line_and_grid_container_padding_edge(this: LayoutGridFormattingContext*, grid_item: const LayoutGridItem*, area_rect: gfx.CssPixelRect*, dimension: LayoutGridDimension):
    assert(layout_node_is_absolutely_positioned(grid_item.box.layout_node()))
    var offset = layout_zero_px()
    for row_track in ak.vector_span(layout_grid_formatting_context_tracks_and_gaps(this, dimension)):
        offset = offset.add(row_track.base_size)
    let size = this.m_grid_container_used_values.padding_right if dimension == LayoutGridDimension.column else this.m_grid_container_used_values.padding_bottom
    if dimension == LayoutGridDimension.column:
        gfx.css_pixel_rect_set_x(area_rect, offset)
        gfx.css_pixel_rect_set_width(area_rect, size)
    else:
        gfx.css_pixel_rect_set_y(area_rect, offset)
        gfx.css_pixel_rect_set_height(area_rect, size)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:1939 Web::Layout::GridFormattingContext::get_grid_area_rect.
func layout_grid_formatting_context_get_grid_area_rect(this: LayoutGridFormattingContext*, grid_item: const LayoutGridItem*) -> gfx.CssPixelRect:
    var area_rect: gfx.CssPixelRect

    # (place_into_track and place_into_track_formed_by_last_line_and_grid_container_padding_edge are
    # layout_grid_formatting_context_place_into_track and ..._place_into_track_formed_by_last_line_and_grid_container_padding_edge.)

    let available_space = layout_grid_formatting_context_available_space(this)
    if let row = grid_item.row:
        if row == (i32)ak.vector_size(&this.m_grid_rows):
            layout_grid_formatting_context_place_into_track_formed_by_last_line_and_grid_container_padding_edge(this, grid_item, &area_rect, LayoutGridDimension.row)
        else:
            layout_grid_formatting_context_place_into_track(this, grid_item, &area_rect, LayoutGridDimension.row)
    else:
        # https://www.w3.org/TR/css-grid-2/#abspos-items
        # Instead of auto-placement, an auto value for a grid-placement property contributes a special line to the placement whose position
        # is that of the corresponding padding edge of the grid container (the padding edge of the scrollable area, if the grid container
        # overflows). These lines become the first and last lines (0th and -0th) of the augmented grid used for positioning absolutely-positioned items.
        var height = layout_zero_px()
        if layout_available_size_is_definite(&available_space.height):
            height = layout_available_size_to_px_or_zero(&available_space.height)
        else:
            for row_track in ak.vector_span(&this.m_grid_rows_and_gaps):
                height = height.add(row_track.base_size)
        height = height.add(this.m_grid_container_used_values.padding_top).add(this.m_grid_container_used_values.padding_bottom)

        gfx.css_pixel_rect_set_height(&area_rect, height)
        gfx.css_pixel_rect_set_y(&area_rect, this.m_grid_container_used_values.padding_top.neg())

    if let column = grid_item.column:
        if column == (i32)ak.vector_size(&this.m_grid_columns):
            layout_grid_formatting_context_place_into_track_formed_by_last_line_and_grid_container_padding_edge(this, grid_item, &area_rect, LayoutGridDimension.column)
        else:
            layout_grid_formatting_context_place_into_track(this, grid_item, &area_rect, LayoutGridDimension.column)
    else:
        var width = layout_zero_px()
        if layout_available_size_is_definite(&available_space.width):
            width = layout_available_size_to_px_or_zero(&available_space.width)
        else:
            for col_track in ak.vector_span(&this.m_grid_columns_and_gaps):
                width = width.add(col_track.base_size)
        width = width.add(this.m_grid_container_used_values.padding_left).add(this.m_grid_container_used_values.padding_right)

        gfx.css_pixel_rect_set_width(&area_rect, width)
        gfx.css_pixel_rect_set_x(&area_rect, this.m_grid_container_used_values.padding_left.neg())

    return area_rect