Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / parser / property_parsing_14.lucb

#==============================================================================================
#
#   property_parsing_14 - parsing property values: the grid shorthands
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/PropertyParsing.cpp (lines 4729-5085): grid-column and
#       grid-row, grid-template (and the grid-template part of grid), grid-area and grid.
#
#==============================================================================================

# mark: grid-column and grid-row ================================================================

## `GridTrackPlacementStyleValue::create(placement)` as a StyleValue.
func css_grid_track_placement_value_of(placement: CssGridTrackPlacement) -> CssStyleValue*:
    return css_grid_track_placement_style_value_create(placement).css_style_value()

## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4729 Web::CSS::Parser::Parser::parse_grid_track_placement_shorthand_value.
pub func css_parser_parse_grid_track_placement_shorthand_value(this: CssParser*, property_id: css_data.PropertyId, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    let start_property = css_data.PropertyId.grid_column_start if property_id == css_data.PropertyId.grid_column else css_data.PropertyId.grid_row_start
    let end_property = css_data.PropertyId.grid_column_end if property_id == css_data.PropertyId.grid_column else css_data.PropertyId.grid_row_end

    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)
    var current_token = css_syntax.token_stream_consume_a_token(tokens)

    var track_start_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
    while true:
        if css_syntax.component_value_is_delim(&current_token, (u32)'/'):
            css_syntax.token_stream_discard_whitespace(tokens)
            if not css_syntax.token_stream_has_next_token(tokens):
                return none
            break
        ak.vector_append_t(&track_start_placement_tokens, current_token)
        css_syntax.token_stream_discard_whitespace(tokens)
        if not css_syntax.token_stream_has_next_token(tokens):
            break
        current_token = css_syntax.token_stream_consume_a_token(tokens)

    var track_end_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
    if css_syntax.token_stream_has_next_token(tokens):
        current_token = css_syntax.token_stream_consume_a_token(tokens)
        while true:
            ak.vector_append_t(&track_end_placement_tokens, current_token)
            css_syntax.token_stream_discard_whitespace(tokens)
            if not css_syntax.token_stream_has_next_token(tokens):
                break
            current_token = css_syntax.token_stream_consume_a_token(tokens)

    var track_start_placement_token_stream = css_syntax.token_stream_create(track_start_placement_tokens)
    let parsed_start_value = css_parser_parse_grid_track_placement(this, &track_start_placement_token_stream)
    if let start_value = parsed_start_value:
        if ak.vector_is_empty(&track_end_placement_tokens):
            css_syntax.state_transaction_commit(&transaction)
            let start_placement = css_grid_track_placement_style_value_grid_track_placement(start_value)
            if css_grid_track_placement_is_custom_ident(&start_placement):
                let custom_ident = start_value.css_style_value()
                return css_shorthand_of(property_id, css_property_ids_of([start_property, end_property]), css_style_values_of([custom_ident, custom_ident]))
            return css_shorthand_of(property_id,
                                    css_property_ids_of([start_property, end_property]),
                                    css_style_values_of([start_value.css_style_value(), css_grid_track_placement_value_of(css_grid_track_placement_make_auto())]))

    var track_end_placement_token_stream = css_syntax.token_stream_create(track_end_placement_tokens)
    let parsed_end_value = css_parser_parse_grid_track_placement(this, &track_end_placement_token_stream)
    if let start_value = parsed_start_value:
        if let end_value = parsed_end_value:
            css_syntax.state_transaction_commit(&transaction)
            return css_shorthand_of(property_id,
                                    css_property_ids_of([start_property, end_property]),
                                    css_style_values_of([start_value.css_style_value(), end_value.css_style_value()]))

    return none

# mark: grid-template ===========================================================================

## The captures of the GridTrackParser lambda of parse_grid_track_size_list_shorthand_value.
struct CssParserParseGridTrackSizeListShorthandValueCaptures:
    var this: CssParser*
    var area_tokens: ak.Vector[css_syntax.ComponentValue]*

## The GridTrackParser lambda of parse_grid_track_size_list_shorthand_value: a <string> (kept for the areas) and an
## optional <track-size>.
func css_parser_parse_grid_template_row_track(context: void*?, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssExplicitGridTrack?:
    let captures = (CssParserParseGridTrackSizeListShorthandValueCaptures*)(context else trap("no captures"))
    css_syntax.token_stream_discard_whitespace(tokens)
    if not css_syntax.token_stream_has_next_token(tokens):
        return none
    let token = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is(&token, .string):
        return none
    ak.vector_append_t(captures.area_tokens, token)
    css_syntax.token_stream_discard_whitespace(tokens)
    if let track_size = css_parser_parse_grid_track_size(captures.this, tokens):
        return track_size
    css_syntax.token_stream_discard_whitespace(tokens)
    return css_explicit_grid_track_new(.css_grid_size(css_grid_size_make_auto()))

## The `[ <'grid-template-rows'> / <'grid-template-columns'> ]` block of parse_grid_track_size_list_shorthand_value,
## in a transaction: the rows and the columns.
func css_parser_parse_grid_template_rows_and_columns(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> (CssStyleValue*, CssStyleValue*)?:
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    if let parsed_template_rows_values = css_parser_parse_grid_track_size_list(this, tokens):
        css_syntax.token_stream_discard_whitespace(tokens)
        if css_syntax.token_stream_has_next_token(tokens) and css_next_token_is_delim(tokens, (u32)'/'):
            css_syntax.token_stream_discard_a_token(tokens)  # /
            css_syntax.token_stream_discard_whitespace(tokens)
            if let parsed_template_columns_values = css_parser_parse_grid_track_size_list(this, tokens):
                css_syntax.state_transaction_commit(&transaction)
                return (parsed_template_rows_values, parsed_template_columns_values)
    return none

## The `[ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?` block of
## parse_grid_track_size_list_shorthand_value, in a transaction: the areas, rows and columns when they parse (the
## C++ block's `return nullptr`s and falling out of the block both end in the function's `return nullptr`).
func css_parser_parse_grid_template_areas_rows_and_columns(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> (CssStyleValue*, CssStyleValue*, CssStyleValue*)?:
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)

    var track_list = CssGridTrackSizeList()
    var area_tokens = ak.Vector[css_syntax.ComponentValue]()

    var captures = CssParserParseGridTrackSizeListShorthandValueCaptures(this = this, area_tokens = &area_tokens)
    let parse_grid_track = ak.Function1[css_syntax.TokenStream[css_syntax.ComponentValue]*, CssExplicitGridTrack?](call = css_parser_parse_grid_template_row_track, context = &captures)

    let parsed_track_count = css_parser_parse_track_list_impl(this, tokens, &track_list, parse_grid_track, CssParserAllowTrailingLineNamesForEachTrack.yes)
    if parsed_track_count > 0:
        var area_tokens_stream = css_syntax.token_stream_create(area_tokens)
        let grid_areas = css_parser_parse_grid_template_areas_value(this, &area_tokens_stream) else return none

        let rows_track_list = css_grid_track_size_list_style_value_create(track_list).css_style_value()

        css_syntax.token_stream_discard_whitespace(tokens)

        var columns_track_list = css_property_initial_value(css_data.PropertyId.grid_template_columns)
        if css_syntax.token_stream_has_next_token(tokens) and css_next_token_is_delim(tokens, (u32)'/'):
            css_syntax.token_stream_discard_a_token(tokens)  # /
            css_syntax.token_stream_discard_whitespace(tokens)
            let parsed_columns = css_parser_parse_explicit_track_list(this, tokens)
            if not css_grid_track_size_list_is_empty(&parsed_columns):
                css_syntax.state_transaction_commit(&transaction)
                columns_track_list = css_grid_track_size_list_style_value_create(parsed_columns).css_style_value()
            else:
                return none
        elif css_syntax.token_stream_has_next_token(tokens):
            return none

        css_syntax.state_transaction_commit(&transaction)
        return (grid_areas, rows_track_list, columns_track_list)
    return none

## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4792 Web::CSS::Parser::Parser::parse_grid_track_size_list_shorthand_value.
# https://www.w3.org/TR/css-grid-2/#explicit-grid-shorthand
# 7.4. Explicit Grid Shorthand: the grid-template property
pub func css_parser_parse_grid_track_size_list_shorthand_value(this: CssParser*, property_id: css_data.PropertyId, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*,
                                                               include_grid_auto_properties: bool = false) -> CssStyleValue*?:
    var sub_properties = ak.Vector[css_data.PropertyId]()
    var values = ak.Vector[CssStyleValue*]()
    if include_grid_auto_properties:
        ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_auto_flow)
        ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_auto_rows)
        ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_auto_columns)
        ak.vector_append_t(&values, css_property_initial_value(css_data.PropertyId.grid_auto_flow))
        ak.vector_append_t(&values, css_property_initial_value(css_data.PropertyId.grid_auto_rows))
        ak.vector_append_t(&values, css_property_initial_value(css_data.PropertyId.grid_auto_columns))
    ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_template_areas)
    ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_template_rows)
    ak.vector_append_t(&sub_properties, css_data.PropertyId.grid_template_columns)
    ak.vector_ensure_capacity(&values, ak.vector_size(&sub_properties))

    # none
    if css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_) != none:
        ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_areas))
        ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_rows))
        ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_columns))
        return css_shorthand_of(property_id, sub_properties, values)

    # [ <'grid-template-rows'> / <'grid-template-columns'> ]
    if let rows_and_columns = css_parser_parse_grid_template_rows_and_columns(this, tokens):
        ak.vector_unchecked_append_u(&values, css_property_initial_value(css_data.PropertyId.grid_template_areas))
        ak.vector_unchecked_append_u(&values, rows_and_columns.0)
        ak.vector_unchecked_append_u(&values, rows_and_columns.1)
        return css_shorthand_of(property_id, sub_properties, values)

    # [ <line-names>? <string> <track-size>? <line-names>? ]+ [ / <explicit-track-list> ]?
    # NB: The GridTrackParser lambda is css_parser_parse_grid_template_row_track.
    if let areas_rows_and_columns = css_parser_parse_grid_template_areas_rows_and_columns(this, tokens):
        ak.vector_unchecked_append_u(&values, areas_rows_and_columns.0)
        ak.vector_unchecked_append_u(&values, areas_rows_and_columns.1)
        ak.vector_unchecked_append_u(&values, areas_rows_and_columns.2)
        return css_shorthand_of(property_id, sub_properties, values)

    return none

# mark: grid-area ===============================================================================

## The `parse_placement_tokens` lambda of parse_grid_area_shorthand_value.
func css_parse_grid_area_placement_tokens(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, placement_tokens: ak.Vector[css_syntax.ComponentValue]*, check_for_delimiter: bool = true):
    css_syntax.token_stream_discard_whitespace(tokens)
    while css_syntax.token_stream_has_next_token(tokens):
        let current_token = css_syntax.token_stream_consume_a_token(tokens)
        if check_for_delimiter and css_syntax.component_value_is_delim(&current_token, (u32)'/'):
            break
        ak.vector_append_t(placement_tokens, current_token)
        css_syntax.token_stream_discard_whitespace(tokens)

## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4896 Web::CSS::Parser::Parser::parse_grid_area_shorthand_value.
pub func css_parser_parse_grid_area_shorthand_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)

    # NB: The `parse_placement_tokens` lambda is css_parse_grid_area_placement_tokens.

    var row_start_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
    css_parse_grid_area_placement_tokens(tokens, &row_start_placement_tokens)

    var column_start_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
    if css_syntax.token_stream_has_next_token(tokens):
        css_parse_grid_area_placement_tokens(tokens, &column_start_placement_tokens)

    var row_end_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
    if css_syntax.token_stream_has_next_token(tokens):
        css_parse_grid_area_placement_tokens(tokens, &row_end_placement_tokens)

    var column_end_placement_tokens = ak.Vector[css_syntax.ComponentValue]()
    if css_syntax.token_stream_has_next_token(tokens):
        css_parse_grid_area_placement_tokens(tokens, &column_end_placement_tokens, false)

    # https://www.w3.org/TR/css-grid-2/#placement-shorthands
    # The grid-area property is a shorthand for grid-row-start, grid-column-start, grid-row-end and
    # grid-column-end.
    var row_start_placement_token_stream = css_syntax.token_stream_create(row_start_placement_tokens)
    let row_start_style_value = css_parser_parse_grid_track_placement(this, &row_start_placement_token_stream)
    if css_syntax.token_stream_has_next_token(&row_start_placement_token_stream):
        return none

    var column_start_placement_token_stream = css_syntax.token_stream_create(column_start_placement_tokens)
    let column_start_style_value = css_parser_parse_grid_track_placement(this, &column_start_placement_token_stream)
    if css_syntax.token_stream_has_next_token(&column_start_placement_token_stream):
        return none

    var row_end_placement_token_stream = css_syntax.token_stream_create(row_end_placement_tokens)
    let row_end_style_value = css_parser_parse_grid_track_placement(this, &row_end_placement_token_stream)
    if css_syntax.token_stream_has_next_token(&row_end_placement_token_stream):
        return none

    var column_end_placement_token_stream = css_syntax.token_stream_create(column_end_placement_tokens)
    let column_end_style_value = css_parser_parse_grid_track_placement(this, &column_end_placement_token_stream)
    if css_syntax.token_stream_has_next_token(&column_end_placement_token_stream):
        return none

    # If four <grid-line> values are specified, grid-row-start is set to the first value, grid-column-start
    # is set to the second value, grid-row-end is set to the third value, and grid-column-end is set to the
    # fourth value.
    var row_start = css_grid_track_placement_make_auto()
    var column_start = css_grid_track_placement_make_auto()
    var row_end = css_grid_track_placement_make_auto()
    var column_end = css_grid_track_placement_make_auto()

    if let value = row_start_style_value:
        row_start = css_grid_track_placement_style_value_grid_track_placement(value)

    # When grid-column-start is omitted, if grid-row-start is a <custom-ident>, all four longhands are set to
    # that value. Otherwise, it is set to auto.
    if let value = column_start_style_value:
        column_start = css_grid_track_placement_style_value_grid_track_placement(value)
    elif css_grid_track_placement_is_custom_ident(&row_start):
        column_start = row_start

    # When grid-row-end is omitted, if grid-row-start is a <custom-ident>, grid-row-end is set to that
    # <custom-ident>; otherwise, it is set to auto.
    if let value = row_end_style_value:
        row_end = css_grid_track_placement_style_value_grid_track_placement(value)
    elif css_grid_track_placement_is_custom_ident(&row_start):
        row_end = row_start

    # When grid-column-end is omitted, if grid-column-start is a <custom-ident>, grid-column-end is set to
    # that <custom-ident>; otherwise, it is set to auto.
    if let value = column_end_style_value:
        column_end = css_grid_track_placement_style_value_grid_track_placement(value)
    elif css_grid_track_placement_is_custom_ident(&column_start):
        column_end = column_start

    css_syntax.state_transaction_commit(&transaction)
    return css_shorthand_of(css_data.PropertyId.grid_area,
                            css_property_ids_of([css_data.PropertyId.grid_row_start, css_data.PropertyId.grid_column_start, css_data.PropertyId.grid_row_end,
                                                 css_data.PropertyId.grid_column_end]),
                            css_style_values_of([css_grid_track_placement_value_of(row_start), css_grid_track_placement_value_of(column_start),
                                                 css_grid_track_placement_value_of(row_end), css_grid_track_placement_value_of(column_end)]))

# mark: grid ====================================================================================

## The `parse_auto_flow_and_dense` lambda of parse_grid_shorthand_value.
func css_parse_grid_auto_flow_and_dense(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, axis: CssGridAutoFlowStyleValueAxis) -> CssStyleValue*?:
    var found_auto_flow = false
    var dense = CssGridAutoFlowStyleValueDense.no
    var i = 0
    while i < 2 and css_syntax.token_stream_has_next_token(tokens):
        let token = css_syntax.token_stream_next_token(tokens)
        if css_syntax.component_value_is_ident(&token, ak.sv("auto-flow")) and not found_auto_flow:
            css_syntax.token_stream_discard_a_token(tokens)  # auto-flow
            css_syntax.token_stream_discard_whitespace(tokens)
            found_auto_flow = true
        elif css_syntax.component_value_is_ident(&token, ak.sv("dense")) and dense == CssGridAutoFlowStyleValueDense.no:
            css_syntax.token_stream_discard_a_token(tokens)  # dense
            css_syntax.token_stream_discard_whitespace(tokens)
            dense = CssGridAutoFlowStyleValueDense.yes
        else:
            break
        i += 1

    if found_auto_flow:
        return css_grid_auto_flow_style_value_create(axis, dense).css_style_value()
    return none

## `grid_auto_tracks->as_grid_track_size_list().grid_track_size_list().is_empty()`.
func css_grid_track_size_list_value_is_empty(value: CssStyleValue*) -> bool:
    let list = css_grid_track_size_list_style_value_grid_track_size_list(css_style_value_as_grid_track_size_list(value))
    return css_grid_track_size_list_is_empty(&list)

## The `parse_shorthand_branch_1` lambda of parse_grid_shorthand_value:
## `[ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>`.
func css_parser_parse_grid_shorthand_branch_1(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)

    let grid_auto_flow = css_parse_grid_auto_flow_and_dense(tokens, CssGridAutoFlowStyleValueAxis.row) else return none

    var grid_auto_rows = css_parser_parse_grid_auto_track_sizes(this, tokens) else trap("VERIFY: grid-auto-rows")
    if css_grid_track_size_list_value_is_empty(grid_auto_rows):
        grid_auto_rows = css_property_initial_value(css_data.PropertyId.grid_auto_rows)

    css_syntax.token_stream_discard_whitespace(tokens)
    if not css_syntax.token_stream_has_next_token(tokens) or not css_next_token_is_delim(tokens, (u32)'/'):
        return none
    css_syntax.token_stream_discard_a_token(tokens)  # /
    css_syntax.token_stream_discard_whitespace(tokens)

    let grid_template_columns = css_parser_parse_grid_track_size_list(this, tokens) else return none

    css_syntax.state_transaction_commit(&transaction)
    return css_shorthand_of(css_data.PropertyId.grid,
                            css_property_ids_of([css_data.PropertyId.grid_auto_flow, css_data.PropertyId.grid_auto_rows, css_data.PropertyId.grid_auto_columns,
                                                 css_data.PropertyId.grid_template_areas, css_data.PropertyId.grid_template_rows, css_data.PropertyId.grid_template_columns]),
                            css_style_values_of([grid_auto_flow, grid_auto_rows, css_property_initial_value(css_data.PropertyId.grid_auto_columns),
                                                 css_property_initial_value(css_data.PropertyId.grid_template_areas), css_property_initial_value(css_data.PropertyId.grid_template_rows),
                                                 grid_template_columns]))

## The `parse_shorthand_branch_2` lambda of parse_grid_shorthand_value:
## `<'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>?`.
func css_parser_parse_grid_shorthand_branch_2(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)

    let grid_template_rows = css_parser_parse_grid_track_size_list(this, tokens) else return none

    css_syntax.token_stream_discard_whitespace(tokens)
    if not css_syntax.token_stream_has_next_token(tokens) or not css_next_token_is_delim(tokens, (u32)'/'):
        return none
    css_syntax.token_stream_discard_a_token(tokens)  # /
    css_syntax.token_stream_discard_whitespace(tokens)

    let grid_auto_flow = css_parse_grid_auto_flow_and_dense(tokens, CssGridAutoFlowStyleValueAxis.column) else return none

    var grid_auto_columns = css_parser_parse_grid_auto_track_sizes(this, tokens) else trap("VERIFY: grid-auto-columns")
    if css_grid_track_size_list_value_is_empty(grid_auto_columns):
        grid_auto_columns = css_property_initial_value(css_data.PropertyId.grid_auto_columns)

    css_syntax.state_transaction_commit(&transaction)
    return css_shorthand_of(css_data.PropertyId.grid,
                            css_property_ids_of([css_data.PropertyId.grid_auto_flow, css_data.PropertyId.grid_auto_rows, css_data.PropertyId.grid_auto_columns,
                                                 css_data.PropertyId.grid_template_areas, css_data.PropertyId.grid_template_rows, css_data.PropertyId.grid_template_columns]),
                            css_style_values_of([grid_auto_flow, css_property_initial_value(css_data.PropertyId.grid_auto_rows), grid_auto_columns,
                                                 css_property_initial_value(css_data.PropertyId.grid_template_areas), grid_template_rows,
                                                 css_property_initial_value(css_data.PropertyId.grid_template_columns)]))

## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:4987 Web::CSS::Parser::Parser::parse_grid_shorthand_value.
pub func css_parser_parse_grid_shorthand_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # <'grid-template'>
    if let grid_template = css_parser_parse_grid_track_size_list_shorthand_value(this, css_data.PropertyId.grid, tokens, true):
        return grid_template

    # NB: The `parse_auto_flow_and_dense`, `parse_shorthand_branch_1` and `parse_shorthand_branch_2` lambdas are
    #     css_parse_grid_auto_flow_and_dense, css_parser_parse_grid_shorthand_branch_1 and
    #     css_parser_parse_grid_shorthand_branch_2.

    if let grid = css_parser_parse_grid_shorthand_branch_1(this, tokens):
        return grid

    if let grid = css_parser_parse_grid_shorthand_branch_2(this, tokens):
        return grid

    return none