Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / grid_track_size.lucb

#==============================================================================================
#
#   grid_track_size - the grid track sizing values: GridSize, GridMinMax, GridRepeat,
#   ExplicitGridTrack, GridLineNames, GridTrackSizeList
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/GridTrackSize.cpp (lines 1-321) and the inline members of
#       GridTrackSize.h, in the order of GridTrackSize.cpp with each class's header members
#       first. The variant visits are matches. The defaulted operator==s that the C++ relies
#       on (style values compare by value: ValueComparingRefPtr) are the css_*_eq functions;
#       GridTrackSizeList's out-of-line defaulted operator== is css_grid_track_size_list_eq.
#
#       Copyright (c) 2022, Martin Falisse <mfalisse@outlook.com>
#       Copyright (c) 2025, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       Copyright (c) 2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: GridSize ================================================================================

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:17 Web::CSS::GridSize::GridSize.
pub func css_grid_size_construct(this: CssGridSize*, size: CssStyleValue*):
    this.m_value = size

## `GridSize { size }` as a value.
pub func css_grid_size_new(size: CssStyleValue*) -> CssGridSize:
    var grid_size: CssGridSize = ---
    css_grid_size_construct(&grid_size, size)
    return grid_size

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:24 Web::CSS::GridSize::is_auto.
pub func css_grid_size_is_auto(this: const CssGridSize*, available_size: LayoutAvailableSize) -> bool:
    if css_style_value_to_keyword(this.m_value) == css_data.Keyword.auto:
        return true

    if css_style_value_is_percentage(this.m_value) or (css_style_value_is_calculated(this.m_value) and css_calculated_style_value_contains_percentage(css_style_value_as_calculated(this.m_value))):
        return not layout_available_size_is_definite(&available_size)

    return false

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:35 Web::CSS::is_length_percentage.
func css_is_length_percentage(value: CssStyleValue*) -> bool:
    return css_style_value_is_length(value) or css_style_value_is_percentage(value) or (css_style_value_is_calculated(value) and css_calculated_style_value_resolves_to_length(css_style_value_as_calculated(value)))

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:40 Web::CSS::GridSize::is_fixed.
pub func css_grid_size_is_fixed(this: const CssGridSize*, available_size: LayoutAvailableSize) -> bool:
    if not css_is_length_percentage(this.m_value):
        return false
    if css_style_value_is_percentage(this.m_value) or (css_style_value_is_calculated(this.m_value) and css_calculated_style_value_contains_percentage(css_style_value_as_calculated(this.m_value))):
        return layout_available_size_is_definite(&available_size)
    return true

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:51 Web::CSS::GridSize::is_flexible_length.
pub func css_grid_size_is_flexible_length(this: const CssGridSize*) -> bool:
    return css_style_value_is_flex(this.m_value) or (css_style_value_is_calculated(this.m_value) and css_calculated_style_value_resolves_to_flex(css_style_value_as_calculated(this.m_value)))

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:56 Web::CSS::GridSize::is_fit_content.
pub func css_grid_size_is_fit_content(this: const CssGridSize*) -> bool:
    if css_style_value_to_keyword(this.m_value) == css_data.Keyword.fit_content:
        return true
    if css_style_value_is_function(this.m_value):
        let name = css_function_style_value_name(css_style_value_as_function(this.m_value))
        if ak.fly_string_eq_string_view(&name, ak.sv("fit-content")):
            return true
    return false

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:67 Web::CSS::GridSize::is_max_content.
pub func css_grid_size_is_max_content(this: const CssGridSize*) -> bool:
    return css_style_value_to_keyword(this.m_value) == css_data.Keyword.max_content

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:72 Web::CSS::GridSize::is_min_content.
pub func css_grid_size_is_min_content(this: const CssGridSize*) -> bool:
    return css_style_value_to_keyword(this.m_value) == css_data.Keyword.min_content

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:34 Web::CSS::GridSize::css_size.
pub func css_grid_size_css_size(this: const CssGridSize*) -> CssSize:
    return css_size_from_style_value(this.m_value)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:35 Web::CSS::GridSize::flex_factor.
pub func css_grid_size_flex_factor(this: const CssGridSize*) -> f64:
    let flex = css_flex_from_style_value(this.m_value)
    return css_flex_to_fr(&flex)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:37 Web::CSS::GridSize::style_value.
pub func css_grid_size_style_value(this: const CssGridSize*) -> CssStyleValue*:
    return this.m_value

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:77 Web::CSS::GridSize::is_intrinsic.
# https://www.w3.org/TR/css-grid-2/#layout-algorithm
# An intrinsic sizing function (min-content, max-content, auto, fit-content()).
pub func css_grid_size_is_intrinsic(this: const CssGridSize*, available_size: LayoutAvailableSize) -> bool:
    return css_grid_size_is_auto(this, available_size) or css_grid_size_is_max_content(this) or css_grid_size_is_min_content(this) or css_grid_size_is_fit_content(this)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:82 Web::CSS::GridSize::is_definite.
pub func css_grid_size_is_definite(this: const CssGridSize*) -> bool:
    return css_is_length_percentage(this.m_value)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:87 Web::CSS::GridSize::make_auto.
pub func css_grid_size_make_auto() -> CssGridSize:
    return css_grid_size_new(css_keyword_style_value_create(css_data.Keyword.auto).css_style_value())

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:92 Web::CSS::GridSize::serialize.
pub func css_grid_size_serialize(this: const CssGridSize*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    css_style_value_serialize(this.m_value, builder, mode)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:97 Web::CSS::GridSize::to_string.
pub func css_grid_size_to_string(this: const CssGridSize*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_grid_size_serialize(this, &builder, mode)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:104 Web::CSS::GridSize::absolutized.
pub func css_grid_size_absolutized(this: const CssGridSize*, context: CssComputationContext) -> CssGridSize:
    let absolutized_value = css_style_value_absolutized(this.m_value, context)
    if absolutized_value == this.m_value:
        return *this
    return css_grid_size_new(absolutized_value)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:48 Web::CSS::GridSize::operator== (defaulted: the values
## compare by value).
pub func css_grid_size_eq(this: const CssGridSize*, other: CssGridSize) -> bool:
    return css_style_values_equal(this.m_value, other.m_value)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:50 Web::CSS::GridSize::is_computationally_independent.
pub func css_grid_size_is_computationally_independent(this: const CssGridSize*) -> bool:
    return css_style_value_is_computationally_independent(this.m_value)

# mark: GridMinMax ==============================================================================

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:114 Web::CSS::GridMinMax::GridMinMax.
pub func css_grid_min_max_construct(this: CssGridMinMax*, min_grid_size: CssGridSize, max_grid_size: CssGridSize):
    this.m_min_grid_size = min_grid_size
    this.m_max_grid_size = max_grid_size

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:60 Web::CSS::GridMinMax::min_grid_size.
pub func css_grid_min_max_min_grid_size(this: const CssGridMinMax*) -> CssGridSize:
    return this.m_min_grid_size

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:61 Web::CSS::GridMinMax::max_grid_size.
pub func css_grid_min_max_max_grid_size(this: const CssGridMinMax*) -> CssGridSize:
    return this.m_max_grid_size

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:120 Web::CSS::GridMinMax::serialize.
pub func css_grid_min_max_serialize(this: const CssGridMinMax*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    ak.string_builder_append(builder, "minmax(")
    css_grid_size_serialize(&this.m_min_grid_size, builder, mode)
    ak.string_builder_append(builder, ", ")
    css_grid_size_serialize(&this.m_max_grid_size, builder, mode)
    ak.string_builder_append(builder, ")")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:129 Web::CSS::GridMinMax::to_string.
pub func css_grid_min_max_to_string(this: const CssGridMinMax*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_grid_min_max_serialize(this, &builder, mode)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:136 Web::CSS::GridMinMax::absolutized.
pub func css_grid_min_max_absolutized(this: const CssGridMinMax*, context: CssComputationContext) -> CssGridMinMax:
    var result: CssGridMinMax = ---
    css_grid_min_max_construct(&result, css_grid_size_absolutized(&this.m_min_grid_size, context), css_grid_size_absolutized(&this.m_max_grid_size, context))
    return result

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:66 Web::CSS::GridMinMax::operator== (defaulted).
pub func css_grid_min_max_eq(this: const CssGridMinMax*, other: CssGridMinMax) -> bool:
    return css_grid_size_eq(&this.m_min_grid_size, other.m_min_grid_size) and css_grid_size_eq(&this.m_max_grid_size, other.m_max_grid_size)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:68 Web::CSS::GridMinMax::is_computationally_independent.
pub func css_grid_min_max_is_computationally_independent(this: const CssGridMinMax*) -> bool:
    return css_grid_size_is_computationally_independent(&this.m_min_grid_size) and css_grid_size_is_computationally_independent(&this.m_max_grid_size)

# mark: GridRepeat ==============================================================================

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:144 Web::CSS::GridRepeat::GridRepeat.
pub func css_grid_repeat_construct_css_grid_repeat_type(this: CssGridRepeat*, grid_repeat_type: CssGridRepeatType, grid_track_size_list: CssGridTrackSizeList, repeat_count: CssStyleValue*?):
    this.m_type = grid_repeat_type
    this.m_grid_track_size_list = grid_track_size_list
    this.m_repeat_count = repeat_count

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:151 Web::CSS::GridRepeat::GridRepeat.
pub func css_grid_repeat_construct_css_grid_track_size_list(this: CssGridRepeat*, grid_track_size_list: CssGridTrackSizeList, params: CssGridRepeatParams):
    css_grid_repeat_construct_css_grid_repeat_type(this, params.type_, grid_track_size_list, params.count)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:158 Web::CSS::GridRepeat::is_auto_fill.
pub func css_grid_repeat_is_auto_fill(this: const CssGridRepeat*) -> bool:
    return this.m_type == CssGridRepeatType.auto_fill

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:159 Web::CSS::GridRepeat::is_auto_fit.
pub func css_grid_repeat_is_auto_fit(this: const CssGridRepeat*) -> bool:
    return this.m_type == CssGridRepeatType.auto_fit

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:160 Web::CSS::GridRepeat::is_fixed.
pub func css_grid_repeat_is_fixed(this: const CssGridRepeat*) -> bool:
    return this.m_type == CssGridRepeatType.fixed

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:161 Web::CSS::GridRepeat::repeat_count.
pub func css_grid_repeat_repeat_count(this: const CssGridRepeat*) -> usize:
    assert(css_grid_repeat_is_fixed(this))
    let repeat_count = this.m_repeat_count else trap("VERIFY: a repeat count")
    # int -> size_t, as C++ converts it.
    return (usize)(i64)css_int_from_style_value(repeat_count)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:166 Web::CSS::GridRepeat::grid_track_size_list.
pub func css_grid_repeat_grid_track_size_list(this: const CssGridRepeat*) -> CssGridTrackSizeList:
    return this.m_grid_track_size_list

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:167 Web::CSS::GridRepeat::type.
pub func css_grid_repeat_type(this: const CssGridRepeat*) -> CssGridRepeatType:
    return this.m_type

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:156 Web::CSS::GridRepeat::serialize.
pub func css_grid_repeat_serialize(this: const CssGridRepeat*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    ak.string_builder_append(builder, "repeat(")
    match this.m_type:
        .auto_fit:
            ak.string_builder_append(builder, "auto-fit")
        .auto_fill:
            ak.string_builder_append(builder, "auto-fill")
        .fixed:
            css_style_value_serialize(this.m_repeat_count else trap("VERIFY: a repeat count"), builder, mode)
        _: trap("VERIFY_NOT_REACHED")
    ak.string_builder_append(builder, ", ")
    css_grid_track_size_list_serialize(&this.m_grid_track_size_list, builder, mode)
    ak.string_builder_append(builder, ")")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:177 Web::CSS::GridRepeat::to_string.
pub func css_grid_repeat_to_string(this: const CssGridRepeat*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_grid_repeat_serialize(this, &builder, mode)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:184 Web::CSS::GridRepeat::absolutized.
pub func css_grid_repeat_absolutized(this: const CssGridRepeat*, context: CssComputationContext) -> CssGridRepeat:
    var repeat_count: CssStyleValue*? = none
    if let count = this.m_repeat_count:
        repeat_count = css_style_value_absolutized(count, context)
    var result: CssGridRepeat = ---
    css_grid_repeat_construct_css_grid_repeat_type(&result, this.m_type, css_grid_track_size_list_absolutized(&this.m_grid_track_size_list, context), repeat_count)
    return result

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:172 Web::CSS::GridRepeat::operator== (defaulted).
pub func css_grid_repeat_eq(this: const CssGridRepeat*, other: CssGridRepeat) -> bool:
    return this.m_type == other.m_type and css_grid_track_size_list_eq(&this.m_grid_track_size_list, other.m_grid_track_size_list) and css_optional_style_values_equal(this.m_repeat_count, other.m_repeat_count)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:174 Web::CSS::GridRepeat::is_computationally_independent.
pub func css_grid_repeat_is_computationally_independent(this: const CssGridRepeat*) -> bool:
    if not css_grid_track_size_list_is_computationally_independent(&this.m_grid_track_size_list):
        return false
    if let repeat_count = this.m_repeat_count:
        return css_style_value_is_computationally_independent(repeat_count)
    return true

# mark: ExplicitGridTrack =======================================================================

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:193 Web::CSS::ExplicitGridTrack::ExplicitGridTrack.
pub func css_explicit_grid_track_construct(this: CssExplicitGridTrack*, value: CssGridRepeatOrCssGridMinMaxOrCssGridSize):
    this.m_value = value

## `ExplicitGridTrack { value }` as a value.
pub func css_explicit_grid_track_new(value: CssGridRepeatOrCssGridMinMaxOrCssGridSize) -> CssExplicitGridTrack:
    var track: CssExplicitGridTrack = ---
    css_explicit_grid_track_construct(&track, value)
    return track

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:186 Web::CSS::ExplicitGridTrack::is_repeat.
pub func css_explicit_grid_track_is_repeat(this: const CssExplicitGridTrack*) -> bool:
    match this.m_value:
        .css_grid_repeat(_): return true
        _: return false

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:187 Web::CSS::ExplicitGridTrack::repeat.
pub func css_explicit_grid_track_repeat(this: const CssExplicitGridTrack*) -> CssGridRepeat:
    match this.m_value:
        .css_grid_repeat(repeat): return repeat
        _: trap("VERIFY: a GridRepeat")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:189 Web::CSS::ExplicitGridTrack::is_minmax.
pub func css_explicit_grid_track_is_minmax(this: const CssExplicitGridTrack*) -> bool:
    match this.m_value:
        .css_grid_min_max(_): return true
        _: return false

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:190 Web::CSS::ExplicitGridTrack::minmax.
pub func css_explicit_grid_track_minmax(this: const CssExplicitGridTrack*) -> CssGridMinMax:
    match this.m_value:
        .css_grid_min_max(minmax): return minmax
        _: trap("VERIFY: a GridMinMax")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:192 Web::CSS::ExplicitGridTrack::is_default.
pub func css_explicit_grid_track_is_default(this: const CssExplicitGridTrack*) -> bool:
    match this.m_value:
        .css_grid_size(_): return true
        _: return false

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:193 Web::CSS::ExplicitGridTrack::grid_size.
pub func css_explicit_grid_track_grid_size(this: const CssExplicitGridTrack*) -> CssGridSize:
    match this.m_value:
        .css_grid_size(grid_size): return grid_size
        _: trap("VERIFY: a GridSize")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:198 Web::CSS::ExplicitGridTrack::serialize.
pub func css_explicit_grid_track_serialize(this: const CssExplicitGridTrack*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    match this.m_value:
        .css_grid_repeat(track): css_grid_repeat_serialize(&track, builder, mode)
        .css_grid_min_max(track): css_grid_min_max_serialize(&track, builder, mode)
        .css_grid_size(track): css_grid_size_serialize(&track, builder, mode)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:205 Web::CSS::ExplicitGridTrack::to_string.
pub func css_explicit_grid_track_to_string(this: const CssExplicitGridTrack*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_explicit_grid_track_serialize(this, &builder, mode)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:212 Web::CSS::ExplicitGridTrack::absolutized.
pub func css_explicit_grid_track_absolutized(this: const CssExplicitGridTrack*, context: CssComputationContext) -> CssExplicitGridTrack:
    match this.m_value:
        .css_grid_repeat(it): return css_explicit_grid_track_new(.css_grid_repeat(css_grid_repeat_absolutized(&it, context)))
        .css_grid_min_max(it): return css_explicit_grid_track_new(.css_grid_min_max(css_grid_min_max_absolutized(&it, context)))
        .css_grid_size(it): return css_explicit_grid_track_new(.css_grid_size(css_grid_size_absolutized(&it, context)))

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:198 Web::CSS::ExplicitGridTrack::operator== (defaulted).
pub func css_explicit_grid_track_eq(this: const CssExplicitGridTrack*, other: CssExplicitGridTrack) -> bool:
    match this.m_value:
        .css_grid_repeat(track):
            match other.m_value:
                .css_grid_repeat(other_track): return css_grid_repeat_eq(&track, other_track)
                _: return false
        .css_grid_min_max(track):
            match other.m_value:
                .css_grid_min_max(other_track): return css_grid_min_max_eq(&track, other_track)
                _: return false
        .css_grid_size(track):
            match other.m_value:
                .css_grid_size(other_track): return css_grid_size_eq(&track, other_track)
                _: return false

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:200 Web::CSS::ExplicitGridTrack::is_computationally_independent.
pub func css_explicit_grid_track_is_computationally_independent(this: const CssExplicitGridTrack*) -> bool:
    match this.m_value:
        .css_grid_repeat(value): return css_grid_repeat_is_computationally_independent(&value)
        .css_grid_min_max(value): return css_grid_min_max_is_computationally_independent(&value)
        .css_grid_size(value): return css_grid_size_is_computationally_independent(&value)

# mark: GridTemplateAreas and GridLineNames =====================================================

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:99 Web::CSS::GridTemplateAreas::is_empty.
pub func css_grid_template_areas_is_empty(this: const CssGridTemplateAreas*) -> bool:
    return this.row_count == 0

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:105 Web::CSS::GridLineNames::append.
pub func css_grid_line_names_append(this: CssGridLineNames*, name: ak.FlyString):
    ak.vector_append_t(&this.m_names, CssGridLineName(name = name, implicit = false))

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:106 Web::CSS::GridLineNames::is_empty.
pub func css_grid_line_names_is_empty(this: const CssGridLineNames*) -> bool:
    return ak.vector_is_empty(&this.m_names)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:107 Web::CSS::GridLineNames::names.
pub func css_grid_line_names_names(this: const CssGridLineNames*) -> ak.Vector[CssGridLineName]:
    return this.m_names

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:219 Web::CSS::GridLineNames::serialize.
pub func css_grid_line_names_serialize(this: const CssGridLineNames*, builder: ak.StringBuilder*):
    ak.string_builder_append(builder, "[")
    for i in 0..<ak.vector_size(&this.m_names):
        if i > 0:
            ak.string_builder_append(builder, " ")
        let name = ak.vector_at_const(&this.m_names, i).name
        ak.string_builder_append_string_view(builder, ak.fly_string_bytes_as_string_view(&name))
    ak.string_builder_append(builder, "]")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:230 Web::CSS::GridLineNames::to_string.
pub func css_grid_line_names_to_string(this: const CssGridLineNames*) -> ak.String:
    var builder = ak.string_builder_new()
    css_grid_line_names_serialize(this, &builder)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:112 Web::CSS::GridLineNames::operator== (defaulted: the names
## and their implicit flags, in order).
pub func css_grid_line_names_eq(this: const CssGridLineNames*, other: CssGridLineNames) -> bool:
    let size = ak.vector_size(&this.m_names)
    if size != ak.vector_size(&other.m_names):
        return false
    for i in 0..<size:
        let name = ak.vector_at_const(&this.m_names, i)
        let other_name = ak.vector_at_const(&other.m_names, i)
        if not ak.fly_string_eq_fly_string(&name.name, &other_name.name) or name.implicit != other_name.implicit:
            return false
    return true

# mark: GridTrackSizeList =======================================================================

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:237 Web::CSS::GridTrackSizeList::make_none.
pub func css_grid_track_size_list_make_none() -> CssGridTrackSizeList:
    return CssGridTrackSizeList(m_list = ak.Vector[CssExplicitGridTrackOrCssGridLineNames]())

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:269 Web::CSS::GridTrackSizeList::track_list.
pub func css_grid_track_size_list_track_list(this: const CssGridTrackSizeList*) -> ak.Vector[CssExplicitGridTrack]:
    var track_list = ak.Vector[CssExplicitGridTrack]()
    for line_definition_or_name in ak.vector_span_const(&this.m_list):
        match line_definition_or_name:
            .css_explicit_grid_track(track): ak.vector_append_t(&track_list, track)
            _: _ = track_list
    return track_list

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:123 Web::CSS::GridTrackSizeList::list.
pub func css_grid_track_size_list_list(this: const CssGridTrackSizeList*) -> ak.Vector[CssExplicitGridTrackOrCssGridLineNames]:
    return this.m_list

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:242 Web::CSS::GridTrackSizeList::serialize.
pub func css_grid_track_size_list_serialize(this: const CssGridTrackSizeList*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    if ak.vector_is_empty(&this.m_list):
        ak.string_builder_append(builder, "none")
        return

    var first = true
    for line_definition_or_name in ak.vector_span_const(&this.m_list):
        if not first:
            ak.string_builder_append(builder, " ")
        first = false
        match line_definition_or_name:
            .css_explicit_grid_track(track): css_explicit_grid_track_serialize(&track, builder, mode)
            .css_grid_line_names(names): css_grid_line_names_serialize(&names, builder)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:262 Web::CSS::GridTrackSizeList::to_string.
pub func css_grid_track_size_list_to_string(this: const CssGridTrackSizeList*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_grid_track_size_list_serialize(this, &builder, mode)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:279 Web::CSS::GridTrackSizeList::operator== (defaulted).
pub func css_grid_track_size_list_eq(this: const CssGridTrackSizeList*, other: CssGridTrackSizeList) -> bool:
    let size = ak.vector_size(&this.m_list)
    if size != ak.vector_size(&other.m_list):
        return false
    for i in 0..<size:
        match *ak.vector_at_const(&this.m_list, i):
            .css_explicit_grid_track(track):
                match *ak.vector_at_const(&other.m_list, i):
                    .css_explicit_grid_track(other_track):
                        if not css_explicit_grid_track_eq(&track, other_track):
                            return false
                    _: return false
            .css_grid_line_names(names):
                match *ak.vector_at_const(&other.m_list, i):
                    .css_grid_line_names(other_names):
                        if not css_grid_line_names_eq(&names, other_names):
                            return false
                    _: return false
    return true

## Ported from Libraries/LibWeb/CSS/GridTrackSize.h:129 Web::CSS::GridTrackSizeList::is_empty.
pub func css_grid_track_size_list_is_empty(this: const CssGridTrackSizeList*) -> bool:
    return ak.vector_is_empty(&this.m_list)

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:281 Web::CSS::GridTrackSizeList::append.
pub func css_grid_track_size_list_append_css_grid_line_names(this: CssGridTrackSizeList*, line_names: CssGridLineNames):
    if not ak.vector_is_empty(&this.m_list):
        let last = ak.vector_last(&this.m_list)
        match *last:
            .css_grid_line_names(last_line_names):
                # `auto& last_line_names = m_list.last().get<GridLineNames>()`: appended to in place, so the
                # updated names are stored back.
                var updated_line_names = last_line_names
                for name in ak.vector_span_const(&line_names.m_names):
                    css_grid_line_names_append(&updated_line_names, name.name)
                *last = .css_grid_line_names(updated_line_names)
                return
            _: _ = last
    ak.vector_append_t(&this.m_list, CssExplicitGridTrackOrCssGridLineNames.css_grid_line_names(line_names))

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:292 Web::CSS::GridTrackSizeList::append.
pub func css_grid_track_size_list_append_css_explicit_grid_track(this: CssGridTrackSizeList*, explicit_track: CssExplicitGridTrack):
    ak.vector_append_t(&this.m_list, CssExplicitGridTrackOrCssGridLineNames.css_explicit_grid_track(explicit_track))

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:297 Web::CSS::GridTrackSizeList::absolutized.
pub func css_grid_track_size_list_absolutized(this: const CssGridTrackSizeList*, context: CssComputationContext) -> CssGridTrackSizeList:
    var result = css_grid_track_size_list_make_none()
    for item in ak.vector_span_const(&this.m_list):
        match item:
            .css_explicit_grid_track(track):
                css_grid_track_size_list_append_css_explicit_grid_track(&result, css_explicit_grid_track_absolutized(&track, context))
            .css_grid_line_names(names):
                # The lambda takes `GridLineNames names` by value: a copy that the result may append to.
                css_grid_track_size_list_append_css_grid_line_names(&result, CssGridLineNames(m_names = ak.vector_clone(&names.m_names)))
    return result

## Ported from Libraries/LibWeb/CSS/GridTrackSize.cpp:312 Web::CSS::GridTrackSizeList::is_computationally_independent.
pub func css_grid_track_size_list_is_computationally_independent(this: const CssGridTrackSizeList*) -> bool:
    for item in ak.vector_span_const(&this.m_list):
        match item:
            .css_explicit_grid_track(track):
                if not css_explicit_grid_track_is_computationally_independent(&track):
                    return false
            .css_grid_line_names(_):
                _ = item
    return true