Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / layout / grid_formatting_context_2.lucb

#==============================================================================================
#
#   grid_formatting_context_2 - Layout::GridFormattingContext: grid item placement and the
#                               grid's tracks and gutters
#
#   DESCRIPTION:
#       Port of LibWeb/Layout/GridFormattingContext.cpp (lines 271-659): resolving an item's
#       grid-placement properties into lines and spans (named lines and areas included),
#       placing items with a definite row and/or column or none
#       (https://drafts.csswg.org/css-grid/#auto-placement-algo, step by step), finding an
#       unoccupied area of the occupation grid, recording a placement, creating the explicit and
#       implicit tracks from grid-template-* and grid-auto-*, and the gutters
#       (https://www.w3.org/TR/css-grid-2/#gutters) as fixed-size tracks between them.
#
#       C++ mixes int and size_t here; the size_t arithmetic wraps and its result is converted
#       back to int, which `+%`/`-%` on usize and an `(i32)` cast reproduce.
#
#       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: Grid placement ==========================================================================

## `int + size_t` (or `int - size_t`) converted back to int: the size_t arithmetic wraps.
func layout_grid_formatting_context_int_plus_size(value: i32, size: usize) -> i32:
    return (i32)((usize)(i64)value +% size)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:271 Web::Layout::GridFormattingContext::resolve_grid_position.
func layout_grid_formatting_context_resolve_grid_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*, dimension: LayoutGridDimension) -> LayoutGridFormattingContextPlacementPosition:
    let computed_values = layout_box_computed(child_box)
    let placement_start = css_computed_values_grid_row_start(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_start(computed_values)
    let placement_end = css_computed_values_grid_row_end(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_end(computed_values)

    var placement_start_line_number: i32? = none
    if css_grid_track_placement_has_line_number(&placement_start):
        placement_start_line_number = css_int_from_style_value(css_grid_track_placement_line_number(&placement_start))
    var placement_end_line_number: i32? = none
    if css_grid_track_placement_has_line_number(&placement_end):
        placement_end_line_number = css_int_from_style_value(css_grid_track_placement_line_number(&placement_end))

    var result = LayoutGridFormattingContextPlacementPosition(start = 0, end = 0, span = 1)

    if let start_line_number = placement_start_line_number:
        if start_line_number > 0:
            result.start = start_line_number - 1
        else:
            let explicit_line_count = this.m_explicit_rows_line_count if dimension == LayoutGridDimension.row else this.m_explicit_columns_line_count
            # `explicit_line_count + placement_start_line_number.value()`: size_t arithmetic.
            result.start = (i32)(explicit_line_count +% (usize)(i64)start_line_number)
    if let end_line_number = placement_end_line_number:
        result.end = end_line_number - 1

    if result.end < 0:
        # `row_count() + result.end + 2`: size_t arithmetic.
        if dimension == LayoutGridDimension.row:
            result.end = (i32)(layout_occupation_grid_row_count(&this.m_occupation_grid) +% (usize)(i64)result.end +% 2)
        else:
            result.end = (i32)(layout_occupation_grid_column_count(&this.m_occupation_grid) +% (usize)(i64)result.end +% 2)

    # FIXME: If a name is given as a <custom-ident>, only lines with that name are counted. If not enough lines with
    #        that name exist, all implicit grid lines on the side of the explicit grid corresponding to the search
    #        direction are assumed to have that name for the purpose of counting this span.
    if css_grid_track_placement_is_span(&placement_end):
        result.span = (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_end))
    if css_grid_track_placement_is_span(&placement_start):
        result.span = (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_start))
        result.start = layout_grid_formatting_context_int_plus_size(result.end, 0 -% result.span)
        # FIXME: Remove me once have implemented spans overflowing into negative indexes, e.g., grid-row: span 2 / 1
        if result.start < 0:
            result.start = 0

    let explicit_line_count = this.m_explicit_rows_line_count if dimension == LayoutGridDimension.row else this.m_explicit_columns_line_count

    if css_grid_track_placement_has_identifier(&placement_end):
        let area_end_line_name = layout_grid_formatting_context_suffixed_name(css_grid_track_placement_identifier(&placement_end), "-end")
        let line_number = placement_end_line_number else 1
        if let area_end_line_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, area_end_line_name, line_number):
            result.end = area_end_line_index
        elif let line_name_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, css_grid_track_placement_identifier(&placement_end), line_number):
            result.end = line_name_index
        else:
            result.end = (i32)explicit_line_count
        if not css_grid_track_placement_has_line_number(&placement_start):
            result.start = result.end - 1

    if css_grid_track_placement_has_identifier(&placement_start):
        let area_start_line_name = layout_grid_formatting_context_suffixed_name(css_grid_track_placement_identifier(&placement_start), "-start")
        let line_number = placement_start_line_number else 1
        if let area_start_line_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, area_start_line_name, line_number):
            result.start = area_start_line_index
        elif let line_name_index = layout_grid_formatting_context_get_nth_line_index_by_line_name(this, dimension, css_grid_track_placement_identifier(&placement_start), line_number):
            result.start = line_name_index
        else:
            result.start = (i32)explicit_line_count

    if not css_grid_track_placement_is_positioned(&placement_start) and css_grid_track_placement_is_positioned(&placement_end) and not css_grid_track_placement_is_span(&placement_end):
        if result.span == 0:
            result.span = 1
        result.start = layout_grid_formatting_context_int_plus_size(result.end, 0 -% result.span)

    if css_grid_track_placement_is_positioned(&placement_start) and css_grid_track_placement_is_positioned(&placement_end):
        if result.start > result.end:
            let start = result.start
            result.start = result.end
            result.end = start
        if result.start != result.end:
            result.span = (usize)(i64)(result.end - result.start)
        else:
            result.span = 1
            result.end = layout_grid_formatting_context_int_plus_size(result.start, result.span)

    # If the placement contains two spans, remove the one contributed by the end grid-placement
    # property.
    if css_grid_track_placement_is_span(&placement_start) and css_grid_track_placement_is_span(&placement_end):
        result.span = (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_start))

    return result

## `MUST(String::formatted("{}{}", name, suffix))`.
func layout_grid_formatting_context_suffixed_name(name: ak.String, suffix: str) -> ak.String:
    var builder = ak.string_builder_new()
    ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&name))
    ak.string_builder_append(&builder, suffix)
    return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:364 Web::Layout::GridFormattingContext::resolve_grid_span.
func layout_grid_formatting_context_resolve_grid_span(this: LayoutGridFormattingContext*, child_box: LayoutBox*, dimension: LayoutGridDimension) -> usize:
    _ = this
    let computed_values = layout_box_computed(child_box)
    let placement_start = css_computed_values_grid_row_start(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_start(computed_values)
    let placement_end = css_computed_values_grid_row_end(computed_values) if dimension == LayoutGridDimension.row else css_computed_values_grid_column_end(computed_values)

    if css_grid_track_placement_is_span(&placement_start):
        return (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_start))
    if css_grid_track_placement_is_span(&placement_end):
        return (usize)(i64)css_int_from_style_value(css_grid_track_placement_span(&placement_end))
    return 1

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:377 Web::Layout::GridFormattingContext::place_item_with_row_and_column_position.
func layout_grid_formatting_context_place_item_with_row_and_column_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*):
    let row_placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.row)
    let column_placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.column)

    let row_start = row_placement_position.start
    let row_span = row_placement_position.span
    let column_start = column_placement_position.start
    let column_span = column_placement_position.span

    layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
        box = child_box,
        used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
        row = row_start,
        row_span = row_span,
        column = column_start,
        column_span = column_span))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:396 Web::Layout::GridFormattingContext::place_item_with_row_position.
func layout_grid_formatting_context_place_item_with_row_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*):
    let placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.row)
    let row_start = placement_position.start
    let row_span: usize = placement_position.span

    var column_start: i32 = 0
    let column_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.column)

    var found_available_column = false
    var column_index = column_start
    while column_index <= layout_occupation_grid_max_column_index(&this.m_occupation_grid):
        if not layout_occupation_grid_is_area_occupied(&this.m_occupation_grid, column_index, row_start, (i32)column_span, (i32)row_span):
            found_available_column = true
            column_start = column_index
            break
        column_index += 1
    if not found_available_column:
        column_start = layout_occupation_grid_max_column_index(&this.m_occupation_grid) + 1

    layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
        box = child_box,
        used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
        row = row_start,
        row_span = row_span,
        column = column_start,
        column_span = column_span))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:426 Web::Layout::GridFormattingContext::place_item_with_column_position.
func layout_grid_formatting_context_place_item_with_column_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*, auto_placement_cursor_row: i32*):
    let placement_position = layout_grid_formatting_context_resolve_grid_position(this, child_box, LayoutGridDimension.column)
    let column_start = placement_position.start
    let column_span: usize = placement_position.span

    let row_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.row)

    # Increment the cursor's row position until a value is found where the grid item does not
    # overlap any occupied grid cells (creating new rows in the implicit grid as necessary).
    while true:
        if not layout_occupation_grid_is_area_occupied(&this.m_occupation_grid, column_start, *auto_placement_cursor_row, (i32)column_span, (i32)row_span):
            break
        *auto_placement_cursor_row += 1

    layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
        box = child_box,
        used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
        row = *auto_placement_cursor_row,
        row_span = row_span,
        column = column_start,
        column_span = column_span))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:451 Web::Layout::OccupationGrid::find_unoccupied_place.
pub func layout_occupation_grid_find_unoccupied_place(this: const LayoutOccupationGrid*, dimension: LayoutGridDimension, column_index: i32*, row_index: i32*, column_span: i32, row_span: i32) -> LayoutFoundUnoccupiedPlace:
    if dimension == LayoutGridDimension.column:
        # Row-flow: columns are the inner (minor) axis, rows are the outer (major) axis.
        while *row_index <= layout_occupation_grid_max_row_index(this):
            while *column_index <= layout_occupation_grid_max_column_index(this):
                let minor_axis_fits = *column_index + column_span - 1 <= layout_occupation_grid_max_column_index(this)
                if minor_axis_fits and not layout_occupation_grid_is_area_occupied(this, *column_index, *row_index, column_span, row_span):
                    return LayoutFoundUnoccupiedPlace.yes
                *column_index += 1
            *row_index += 1
            *column_index = layout_occupation_grid_min_column_index(this)
    else:
        # Column-flow: rows are the inner (minor) axis, columns are the outer (major) axis.
        while *column_index <= layout_occupation_grid_max_column_index(this):
            while *row_index <= layout_occupation_grid_max_row_index(this):
                let minor_axis_fits = *row_index + row_span - 1 <= layout_occupation_grid_max_row_index(this)
                if minor_axis_fits and not layout_occupation_grid_is_area_occupied(this, *column_index, *row_index, column_span, row_span):
                    return LayoutFoundUnoccupiedPlace.yes
                *row_index += 1
            *column_index += 1
            *row_index = layout_occupation_grid_min_row_index(this)

    return LayoutFoundUnoccupiedPlace.no

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:482 Web::Layout::GridFormattingContext::place_item_with_no_declared_position.
func layout_grid_formatting_context_place_item_with_no_declared_position(this: LayoutGridFormattingContext*, child_box: LayoutBox*, auto_placement_cursor_column: i32*, auto_placement_cursor_row: i32*):
    var column_start: i32 = 0
    let column_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.column)
    var row_start: i32 = 0
    let row_span = layout_grid_formatting_context_resolve_grid_span(this, child_box, LayoutGridDimension.row)

    let auto_flow = css_computed_values_grid_auto_flow(layout_box_computed(layout_grid_formatting_context_grid_container(this)))
    let dimension = LayoutGridDimension.column if auto_flow.row else LayoutGridDimension.row

    # 4.1.2.1. Increment the column position of the auto-placement cursor until either this item's grid
    # area does not overlap any occupied grid cells, or the cursor's column position, plus the item's
    # column span, overflow the number of columns in the implicit grid, as determined earlier in this
    # algorithm.
    let found_unoccupied_area = layout_occupation_grid_find_unoccupied_place(&this.m_occupation_grid, dimension, auto_placement_cursor_column, auto_placement_cursor_row, (i32)column_span, (i32)row_span)

    # 4.1.2.2. If a non-overlapping position was found in the previous step, set the item's row-start
    # and column-start lines to the cursor's position. Otherwise, increment the auto-placement cursor's
    # row position (creating new rows in the implicit grid as necessary), set its column position to the
    # start-most column line in the implicit grid, and return to the previous step.
    column_start = *auto_placement_cursor_column
    row_start = *auto_placement_cursor_row

    # `cursor += span - 1`: int += size_t.
    *auto_placement_cursor_column = layout_grid_formatting_context_int_plus_size(*auto_placement_cursor_column, column_span -% 1)
    *auto_placement_cursor_row = layout_grid_formatting_context_int_plus_size(*auto_placement_cursor_row, row_span -% 1)

    if found_unoccupied_area == LayoutFoundUnoccupiedPlace.yes:
        if dimension == LayoutGridDimension.column:
            *auto_placement_cursor_column += 1
            *auto_placement_cursor_row = layout_occupation_grid_min_row_index(&this.m_occupation_grid)
        else:
            *auto_placement_cursor_row += 1
            *auto_placement_cursor_column = layout_occupation_grid_min_column_index(&this.m_occupation_grid)

    layout_grid_formatting_context_record_grid_placement(this, LayoutGridItem(
        box = child_box,
        used_values = layout_state_get_mutable(this.formatting_context.m_state, child_box.layout_node_with_style()),
        row = row_start,
        row_span = row_span,
        column = column_start,
        column_span = column_span))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:527 Web::Layout::GridFormattingContext::record_grid_placement.
func layout_grid_formatting_context_record_grid_placement(this: LayoutGridFormattingContext*, grid_item: LayoutGridItem):
    let column = grid_item.column else trap("VERIFY: the grid item's column has a value")
    let column_span = grid_item.column_span else trap("VERIFY: the grid item's column span has a value")
    let row = grid_item.row else trap("VERIFY: the grid item's row has a value")
    let row_span = grid_item.row_span else trap("VERIFY: the grid item's row span has a value")
    layout_occupation_grid_set_occupied(&this.m_occupation_grid, column, layout_grid_formatting_context_int_plus_size(column, column_span), row, layout_grid_formatting_context_int_plus_size(row, row_span))
    ak.vector_append_t(&this.m_grid_items, grid_item)

# mark: Tracks ==================================================================================

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:533 Web::Layout::GridFormattingContext::initialize_grid_tracks_from_definition.
func layout_grid_formatting_context_initialize_grid_tracks_from_definition(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
    let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    let template = css_computed_values_grid_template_columns(grid_computed_values) if dimension == LayoutGridDimension.column else css_computed_values_grid_template_rows(grid_computed_values)
    let tracks_definition = css_grid_track_size_list_track_list(&template)
    let tracks = layout_grid_formatting_context_tracks(this, dimension)
    let definitions = ak.vector_span_const(&tracks_definition)
    for track_definition in &definitions:
        var repeat_count: i32 = 1
        var is_auto_fit = false
        if css_explicit_grid_track_is_repeat(track_definition):
            let repeat = css_explicit_grid_track_repeat(track_definition)
            is_auto_fit = css_grid_repeat_is_auto_fit(&repeat)
            if css_grid_repeat_is_auto_fill(&repeat) or is_auto_fit:
                repeat_count = layout_grid_formatting_context_count_of_repeated_auto_fill_or_fit_tracks(this, dimension, track_definition)
            else:
                repeat_count = (i32)css_grid_repeat_repeat_count(&repeat)
        for _repetition in 0..<repeat_count:
            if css_explicit_grid_track_is_default(track_definition) or css_explicit_grid_track_is_minmax(track_definition):
                ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(track_definition, is_auto_fit))
            elif css_explicit_grid_track_is_repeat(track_definition):
                let repeat = css_explicit_grid_track_repeat(track_definition)
                let repeat_grid_track_size_list = css_grid_repeat_grid_track_size_list(&repeat)
                let repeat_track_list = css_grid_track_size_list_track_list(&repeat_grid_track_size_list)
                let explicit_grid_tracks = ak.vector_span_const(&repeat_track_list)
                for explicit_grid_track in &explicit_grid_tracks:
                    ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(explicit_grid_track, is_auto_fit))
            else:
                trap("VERIFY_NOT_REACHED")

## The implicit tracks of one dimension (the two halves of initialize_grid_tracks_for_columns_and_rows, the same steps for
## columns and rows): tracks prepended for items at negative indexes, the explicit tracks, then tracks appended up to the
## occupation grid's size, each implicit one from grid-auto-columns / grid-auto-rows in turn.
func layout_grid_formatting_context_initialize_grid_tracks_for_dimension(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension):
    let grid_computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    let tracks = layout_grid_formatting_context_tracks(this, dimension)
    let lines = &this.m_column_lines if dimension == LayoutGridDimension.column else &this.m_row_lines

    let grid_auto = css_computed_values_grid_auto_columns(grid_computed_values) if dimension == LayoutGridDimension.column else css_computed_values_grid_auto_rows(grid_computed_values)
    let grid_auto_tracks = css_grid_track_size_list_track_list(&grid_auto)
    var implicit_index: usize = 0
    # NOTE: If there are implicit tracks created by items with negative indexes they should prepend explicitly defined tracks
    let min_index = layout_occupation_grid_min_column_index(&this.m_occupation_grid) if dimension == LayoutGridDimension.column else layout_occupation_grid_min_row_index(&this.m_occupation_grid)
    let negative_index_implied_tracks_count = ak.abs_i32(min_index)
    for _line in 0..<negative_index_implied_tracks_count:
        ak.vector_insert(lines, 0, ak.Vector[CssGridLineName]())
    for _index in 0..<negative_index_implied_tracks_count:
        if ak.vector_size(&grid_auto_tracks) > 0:
            let definition = *ak.vector_at_const(&grid_auto_tracks, implicit_index % ak.vector_size(&grid_auto_tracks))
            ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(&definition))
        else:
            ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_auto())
        implicit_index += 1
    layout_grid_formatting_context_initialize_grid_tracks_from_definition(this, dimension)
    let count = layout_occupation_grid_column_count(&this.m_occupation_grid) if dimension == LayoutGridDimension.column else layout_occupation_grid_row_count(&this.m_occupation_grid)
    var index = ak.vector_size(tracks)
    while index < count:
        if ak.vector_size(&grid_auto_tracks) > 0:
            let definition = *ak.vector_at_const(&grid_auto_tracks, implicit_index % ak.vector_size(&grid_auto_tracks))
            ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_from_definition(&definition))
        else:
            ak.vector_append_t(tracks, layout_grid_formatting_context_grid_track_create_auto())
        implicit_index += 1
        index += 1

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:562 Web::Layout::GridFormattingContext::initialize_grid_tracks_for_columns_and_rows.
func layout_grid_formatting_context_initialize_grid_tracks_for_columns_and_rows(this: LayoutGridFormattingContext*):
    layout_grid_formatting_context_initialize_grid_tracks_for_dimension(this, LayoutGridDimension.column)
    layout_grid_formatting_context_initialize_grid_tracks_for_dimension(this, LayoutGridDimension.row)

    ak.vector_resize(&this.m_column_lines, ak.vector_size(&this.m_grid_columns) + 1)
    ak.vector_resize(&this.m_row_lines, ak.vector_size(&this.m_grid_rows) + 1)

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:622 Web::Layout::GridFormattingContext::initialize_gap_tracks.
func layout_grid_formatting_context_initialize_gap_tracks_layout_grid_dimension(this: LayoutGridFormattingContext*, dimension: LayoutGridDimension, available_size: LayoutAvailableSize):
    # https://www.w3.org/TR/css-grid-2/#gutters
    # 11.1. Gutters: the row-gap, column-gap, and gap properties
    # For the purpose of track sizing, each gutter is treated as an extra, empty, fixed-size track of the specified
    # size, which is spanned by any grid items that span across its corresponding grid line.
    let grid_tracks = layout_grid_formatting_context_tracks(this, dimension)
    let gap_tracks = &this.m_column_gap_tracks if dimension == LayoutGridDimension.column else &this.m_row_gap_tracks
    let tracks_and_gaps = layout_grid_formatting_context_tracks_and_gaps(this, dimension)

    ak.vector_clear(gap_tracks)
    ak.vector_clear(tracks_and_gaps)

    if ak.vector_is_empty(grid_tracks):
        return

    let computed_values = layout_box_computed(layout_grid_formatting_context_grid_container(this))
    let computed_gap = css_computed_values_column_gap(computed_values) if dimension == LayoutGridDimension.column else css_computed_values_row_gap(computed_values)
    var gap_size = layout_zero_px()
    match computed_gap:
        .css_normal_gap(_): _ = gap_size
        _: gap_size = layout_formatting_context_gap_to_px(this.layout_formatting_context(), computed_gap, layout_available_size_to_px_or_zero(&available_size))

    # The gap tracks are referenced from tracks_and_gaps, so their storage must not move while it is filled.
    ak.vector_ensure_capacity(gap_tracks, ak.vector_size(grid_tracks) - 1)

    for track_index in 0..<ak.vector_size(grid_tracks):
        ak.vector_append_t(tracks_and_gaps, ak.vector_at(grid_tracks, track_index))

        if track_index != ak.vector_size(grid_tracks) - 1:
            ak.vector_unchecked_append_u(gap_tracks, layout_grid_formatting_context_grid_track_create_gap(gap_size))
            ak.vector_append_t(tracks_and_gaps, ak.vector_last(gap_tracks))

## Ported from Libraries/LibWeb/Layout/GridFormattingContext.cpp:655 Web::Layout::GridFormattingContext::initialize_gap_tracks.
func layout_grid_formatting_context_initialize_gap_tracks_layout_available_space(this: LayoutGridFormattingContext*, available_space: LayoutAvailableSpace):
    layout_grid_formatting_context_initialize_gap_tracks_layout_grid_dimension(this, LayoutGridDimension.column, available_space.width)
    layout_grid_formatting_context_initialize_gap_tracks_layout_grid_dimension(this, LayoutGridDimension.row, available_space.height)