Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   value_parsing_7 - parsing CSS values: <easing-function>, <url>, border radii,
#                     <radial-size> and fit-content()
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/ValueParsing.cpp (lines 3134-3599): the easing functions
#       (step-start/step-end, linear(), cubic-bezier(), steps()), url()/src() with their request
#       modifiers, <url> values, the border-radius rectangle, <radial-size> and fit-content().
#
#       Copyright (c) 2018-2024, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       (the full list of ValueParsing.cpp's copyright holders is in value_parsing_1)
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: <easing-function> =======================================================================

## `EasingStyleValue::create(function)` of one of the three easing function kinds.
func css_easing_style_value_from(variant: CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps) -> CssStyleValue*:
    return css_easing_style_value_create(CssEasingStyleValueFunction(variant = variant)).css_style_value()

## The `[](auto& value) { return value.is(Token::Type::Whitespace); }` predicate of parse_easing_value.
func css_component_value_is_whitespace(context: void*?, value: const css_syntax.ComponentValue*) -> bool:
    _ = context
    return css_syntax.component_value_is(value, .whitespace)

## The `parse_argument` lambda of parse_easing_value's cubic-bezier() branch.
func css_parser_parse_easing_argument(this: CssParser*, comma_separated_arguments: const ak.Vector[ak.Vector[css_syntax.ComponentValue]]*, index: usize, accepted_range: CssNumericRange) -> CssStyleValue*?:
    var argument_tokens = css_syntax.token_stream_create(*ak.vector_at_const(comma_separated_arguments, index))
    return css_parser_parse_number_value(this, &argument_tokens, accepted_range)

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3134 Web::CSS::Parser::Parser::parse_easing_value.
pub func css_parser_parse_easing_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)

    css_syntax.token_stream_discard_whitespace(tokens)

    let part = css_syntax.token_stream_consume_a_token(tokens)

    if css_syntax.component_value_is(&part, .ident):
        let name = css_component_value_ident(&part)
        var maybe_simple_easing: CssStyleValue*? = none
        if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("step-start")):
            maybe_simple_easing = css_easing_style_value_from(CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_steps(CssEasingStyleValueSteps(number_of_intervals = css_integer_style_value_create(1).css_style_value(), position = css_data.StepPosition.start)))
        elif ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("step-end")):
            maybe_simple_easing = css_easing_style_value_from(CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_steps(CssEasingStyleValueSteps(number_of_intervals = css_integer_style_value_create(1).css_style_value(), position = css_data.StepPosition.end)))

        let simple_easing = maybe_simple_easing else return none

        css_syntax.state_transaction_commit(&transaction)
        return simple_easing

    if not css_syntax.component_value_is_function(&part):
        return none

    let function = css_syntax.component_value_function(&part)
    var argument_tokens = css_syntax.token_stream_create(function.value)
    var comma_separated_arguments = css_parser_parse_a_comma_separated_list_of_component_values(this, &argument_tokens)

    # Remove whitespace
    let arguments_span = ak.vector_span(&comma_separated_arguments)
    for argument in &arguments_span:
        _ = ak.vector_remove_all_matching(argument, ak.Function1[const css_syntax.ComponentValue*, bool](call = css_component_value_is_whitespace, context = none))

    let name = function.name
    css_parser_push_temporary_value_parsing_context(this, css_function_context_of(&function))
    defer css_parser_pop_temporary_value_parsing_context(this)

    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("linear")):
        # linear() = linear( [ <number> && <percentage>{0,2} ]# )
        var stops = ak.Vector[CssEasingStyleValueLinearStop]()
        for argument in ak.vector_span_const(&comma_separated_arguments):
            var linear_argument_tokens = css_syntax.token_stream_create(argument)

            var output: CssStyleValue*? = none
            var first_input: CssStyleValue*? = none
            var second_input: CssStyleValue*? = none

            if let maybe_output = css_parser_parse_number_value(this, &linear_argument_tokens, css_infinite_range):
                output = maybe_output

            if let maybe_first_input = css_parser_parse_percentage_value(this, &linear_argument_tokens, css_infinite_range):
                first_input = maybe_first_input
                if let maybe_second_input = css_parser_parse_percentage_value(this, &linear_argument_tokens, css_infinite_range):
                    second_input = maybe_second_input

            if let maybe_output = css_parser_parse_number_value(this, &linear_argument_tokens, css_infinite_range):
                if output != none:
                    return none
                output = maybe_output

            if css_syntax.token_stream_has_next_token(&linear_argument_tokens) or output == none:
                return none

            let stop_output = output else trap("VERIFY: an output")
            ak.vector_append_t(&stops, CssEasingStyleValueLinearStop(output = stop_output, input = first_input))
            if second_input != none:
                ak.vector_append_t(&stops, CssEasingStyleValueLinearStop(output = stop_output, input = second_input))

        if ak.vector_is_empty(&stops):
            return none

        css_syntax.state_transaction_commit(&transaction)
        return css_easing_style_value_from(CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_linear(CssEasingStyleValueLinear(stops = stops)))

    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("cubic-bezier")):
        if ak.vector_size(&comma_separated_arguments) != 4:
            return none

        for argument in ak.vector_span_const(&comma_separated_arguments):
            if ak.vector_size(&argument) != 1:
                return none

        let x1 = css_parser_parse_easing_argument(this, &comma_separated_arguments, 0, CssNumericRange(min = 0.0, max = 1.0))
        let x2 = css_parser_parse_easing_argument(this, &comma_separated_arguments, 2, CssNumericRange(min = 0.0, max = 1.0))
        let y1 = css_parser_parse_easing_argument(this, &comma_separated_arguments, 1, css_infinite_range)
        let y2 = css_parser_parse_easing_argument(this, &comma_separated_arguments, 3, css_infinite_range)
        if x1 == none or y1 == none or x2 == none or y2 == none:
            return none

        let bezier = CssEasingStyleValueCubicBezier(
            x1 = x1 else trap("VERIFY: x1"),
            y1 = y1 else trap("VERIFY: y1"),
            x2 = x2 else trap("VERIFY: x2"),
            y2 = y2 else trap("VERIFY: y2"),
        )

        css_syntax.state_transaction_commit(&transaction)
        return css_easing_style_value_from(CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_cubic_bezier(bezier))

    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("steps")):
        if ak.vector_is_empty(&comma_separated_arguments) or ak.vector_size(&comma_separated_arguments) > 2:
            return none

        for argument in ak.vector_span_const(&comma_separated_arguments):
            if ak.vector_size(&argument) != 1:
                return none

        var position = css_data.StepPosition.end

        if ak.vector_size(&comma_separated_arguments) == 2:
            let second_argument = ak.vector_at_const(&comma_separated_arguments, 1)
            if ak.vector_size(second_argument) != 1:
                return none

            let token = *ak.vector_at_const(second_argument, 0)

            if not css_syntax.component_value_is(&token, .ident):
                return none

            let ident = css_component_value_ident(&token)
            let keyword = css_data.keyword_from_string(ak.fly_string_bytes_as_string_view(&ident)) else return none

            let step_position = css_data.keyword_to_step_position(keyword) else return none

            position = step_position

        let intervals_argument = ak.vector_at_const(ak.vector_at_const(&comma_separated_arguments, 0), 0)
        var intervals_token = css_syntax.token_stream_of_single_token(intervals_argument)

        # https://drafts.csswg.org/css-easing/#step-easing-functions
        # If the <step-position> is jump-none, the <integer> must be at least 2, or the function is invalid.
        # Otherwise, the <integer> must be at least 1, or the function is invalid.

        let min_internals: f64 = 2.0 if position == css_data.StepPosition.jump_none else 1.0
        let intervals = css_parser_parse_integer_value(this, &intervals_token, CssNumericRange(min = min_internals, max = f64(ak.i32_max))) else return none

        css_syntax.state_transaction_commit(&transaction)
        return css_easing_style_value_from(CssEasingStyleValueLinearOrCssEasingStyleValueCubicBezierOrCssEasingStyleValueSteps.css_easing_style_value_steps(CssEasingStyleValueSteps(number_of_intervals = intervals, position = position)))

    return none

# mark: <url> ===================================================================================

## `URL { url, type, request_url_modifiers }` as a value.
func css_url_new(url: ak.String, type_: CssUrlType = CssUrlType.url, request_url_modifiers: ak.Vector[CssRequestUrlModifier] = ak.Vector[CssRequestUrlModifier]()) -> CssUrl:
    var result: CssUrl = ---
    css_url_construct(&result, url, type_, request_url_modifiers)
    return result

## `request_url_modifiers.contains([](auto& modifier) { return modifier.type() == type; })`.
func css_request_url_modifiers_contain_type(request_url_modifiers: const ak.Vector[CssRequestUrlModifier]*, type_: CssRequestUrlModifierType) -> bool:
    for modifier in ak.vector_span_const(request_url_modifiers):
        if css_request_url_modifier_type(&modifier) == type_:
            return true
    return false

## The comparator of parse_url_function's quick_sort: `to_underlying(a.type()) < to_underlying(b.type())`.
func css_request_url_modifier_type_less_than(context: void*?, a: const CssRequestUrlModifier*, b: const CssRequestUrlModifier*) -> bool:
    _ = context
    return (u8)css_request_url_modifier_type(a) < (u8)css_request_url_modifier_type(b)

## The keyword of a modifier function's single <ident> argument (`cross-origin(...)`, `referrer-policy(...)`).
func css_url_modifier_keyword(modifier_function: const css_syntax.Function*) -> css_data.Keyword?:
    var modifier_tokens = css_syntax.token_stream_create(modifier_function.value)
    css_syntax.token_stream_discard_whitespace(&modifier_tokens)
    if not css_next_token_is(&modifier_tokens, .ident):
        return none
    let ident_token = css_consume_a_token_token(&modifier_tokens)
    let ident = css_syntax.token_ident(&ident_token)
    let maybe_keyword = css_data.keyword_from_string(ak.fly_string_bytes_as_string_view(&ident))
    css_syntax.token_stream_discard_whitespace(&modifier_tokens)
    if maybe_keyword == none or css_syntax.token_stream_has_next_token(&modifier_tokens):
        return none
    return maybe_keyword

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3299 Web::CSS::Parser::Parser::parse_url_function.
# https://drafts.csswg.org/css-values-4/#url-value
pub func css_parser_parse_url_function(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssUrl?:
    _ = this
    # <url> = <url()> | <src()>
    # <url()> = url( <string> <url-modifier>* ) | <url-token>
    # <src()> = src( <string> <url-modifier>* )
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    let component_value = css_syntax.token_stream_consume_a_token(tokens)

    # <url-token>
    if css_syntax.component_value_is(&component_value, .url):
        css_syntax.state_transaction_commit(&transaction)
        let token = css_syntax.component_value_token(&component_value)
        let url = css_syntax.token_url(&token)
        return css_url_new(ak.fly_string_to_string_const(&url))

    # <url()> = url( <string> <url-modifier>* )
    # <src()> = src( <string> <url-modifier>* )
    if css_syntax.component_value_is_function(&component_value):
        var function_type = CssUrlType.url
        if css_syntax.component_value_is_function_string_view(&component_value, ak.sv("url")):
            function_type = CssUrlType.url
        elif css_syntax.component_value_is_function_string_view(&component_value, ak.sv("src")):
            function_type = CssUrlType.src
        else:
            return none

        let function = css_syntax.component_value_function(&component_value)
        var url_tokens = css_syntax.token_stream_create(function.value)

        css_syntax.token_stream_discard_whitespace(&url_tokens)
        let url_string = css_syntax.token_stream_consume_a_token(&url_tokens)
        if not css_syntax.component_value_is(&url_string, .string):
            return none
        css_syntax.token_stream_discard_whitespace(&url_tokens)

        # NB: Currently <request-url-modifier> is the only kind of <url-modifier>
        # https://drafts.csswg.org/css-values-5/#request-url-modifiers
        # <request-url-modifier> = <cross-origin-modifier> | <integrity-modifier> | <referrer-policy-modifier>
        var request_url_modifiers = ak.Vector[CssRequestUrlModifier]()
        # AD-HOC: This isn't mentioned in the spec, but WPT expects modifiers to be unique (one per type).
        # Spec issue: https://github.com/w3c/csswg-drafts/issues/12151
        while css_syntax.token_stream_has_next_token(&url_tokens):
            let modifier_token = css_syntax.token_stream_consume_a_token(&url_tokens)
            if css_syntax.component_value_is_function_string_view(&modifier_token, ak.sv("cross-origin")):
                # Reject duplicates
                if css_request_url_modifiers_contain_type(&request_url_modifiers, CssRequestUrlModifierType.cross_origin):
                    return none
                # <cross-origin-modifier> = cross-origin(anonymous | use-credentials)
                let modifier_function = css_syntax.component_value_function(&modifier_token)
                let maybe_keyword = css_url_modifier_keyword(&modifier_function) else return none
                if let value = css_data.keyword_to_cross_origin_modifier_value(maybe_keyword):
                    ak.vector_append_t(&request_url_modifiers, css_request_url_modifier_create_cross_origin(value))
                else:
                    return none
            elif css_syntax.component_value_is_function_string_view(&modifier_token, ak.sv("integrity")):
                # Reject duplicates
                if css_request_url_modifiers_contain_type(&request_url_modifiers, CssRequestUrlModifierType.integrity):
                    return none
                # <integrity-modifier> = integrity(<string>)
                let modifier_function = css_syntax.component_value_function(&modifier_token)
                var modifier_tokens = css_syntax.token_stream_create(modifier_function.value)
                css_syntax.token_stream_discard_whitespace(&modifier_tokens)
                let maybe_string = css_syntax.token_stream_consume_a_token(&modifier_tokens)
                css_syntax.token_stream_discard_whitespace(&modifier_tokens)
                if not css_syntax.component_value_is(&maybe_string, .string) or css_syntax.token_stream_has_next_token(&modifier_tokens):
                    return none
                let string_token = css_syntax.component_value_token(&maybe_string)
                ak.vector_append_t(&request_url_modifiers, css_request_url_modifier_create_integrity(css_syntax.token_string(&string_token)))
            elif css_syntax.component_value_is_function_string_view(&modifier_token, ak.sv("referrer-policy")):
                # Reject duplicates
                if css_request_url_modifiers_contain_type(&request_url_modifiers, CssRequestUrlModifierType.referrer_policy):
                    return none

                # <referrer-policy-modifier> = (no-referrer | no-referrer-when-downgrade | same-origin | origin | strict-origin | origin-when-cross-origin | strict-origin-when-cross-origin | unsafe-url)
                let modifier_function = css_syntax.component_value_function(&modifier_token)
                let maybe_keyword = css_url_modifier_keyword(&modifier_function) else return none
                if let value = css_data.keyword_to_referrer_policy_modifier_value(maybe_keyword):
                    ak.vector_append_t(&request_url_modifiers, css_request_url_modifier_create_referrer_policy(value))
                else:
                    return none
            else:
                let modifier_string = css_syntax.component_value_to_string(&modifier_token)
                css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_value_error(CssInvalidValueError(
                    value_type = ak.fly_string_from_str("<url>"),
                    value_string = css_syntax.function_to_string(&function),
                    description = css_string_formatted("Unrecognized URL modifier: {}", [css_arg_string(&modifier_string)]),
                )))
                return none
            css_syntax.token_stream_discard_whitespace(&url_tokens)

        # AD-HOC: This isn't mentioned in the spec, but WPT expects modifiers to be sorted alphabetically.
        # Spec issue: https://github.com/w3c/csswg-drafts/issues/12151
        ak.quick_sort_t_collection_t_less_than(ak.vector_span(&request_url_modifiers), ak.Function2[const CssRequestUrlModifier*, const CssRequestUrlModifier*, bool](call = css_request_url_modifier_type_less_than, context = none))

        css_syntax.state_transaction_commit(&transaction)
        let string_token = css_syntax.component_value_token(&url_string)
        let string = css_syntax.token_string(&string_token)
        return css_url_new(ak.fly_string_to_string_const(&string), function_type, request_url_modifiers)

    return none

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3415 Web::CSS::Parser::Parser::parse_url_value.
pub func css_parser_parse_url_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssUrlStyleValue*?:
    let url = css_parser_parse_url_function(this, tokens) else return none
    return css_url_style_value_create(url)

# mark: Border radii ============================================================================

## The `top_left` lambda of parse_border_radius_rect_value.
func css_border_radius_top_left(radii: const ak.Vector[CssStyleValue*]*) -> CssStyleValue*:
    return *ak.vector_at_const(radii, 0)

## The `top_right` lambda of parse_border_radius_rect_value.
func css_border_radius_top_right(radii: const ak.Vector[CssStyleValue*]*) -> CssStyleValue*:
    match ak.vector_size(radii):
        4, 3, 2: return *ak.vector_at_const(radii, 1)
        1: return *ak.vector_at_const(radii, 0)
        _: trap("VERIFY_NOT_REACHED")

## The `bottom_right` lambda of parse_border_radius_rect_value.
func css_border_radius_bottom_right(radii: const ak.Vector[CssStyleValue*]*) -> CssStyleValue*:
    match ak.vector_size(radii):
        4, 3: return *ak.vector_at_const(radii, 2)
        2, 1: return *ak.vector_at_const(radii, 0)
        _: trap("VERIFY_NOT_REACHED")

## The `bottom_left` lambda of parse_border_radius_rect_value.
func css_border_radius_bottom_left(radii: const ak.Vector[CssStyleValue*]*) -> CssStyleValue*:
    match ak.vector_size(radii):
        4: return *ak.vector_at_const(radii, 3)
        3, 2: return *ak.vector_at_const(radii, 1)
        1: return *ak.vector_at_const(radii, 0)
        _: trap("VERIFY_NOT_REACHED")

## `BorderRadiusStyleValue::create(corner(horizontal_radii), vertical_radii.is_empty() ? corner(horizontal_radii) : corner(vertical_radii))`.
func css_border_radius_corner(corner: func(const ak.Vector[CssStyleValue*]*) -> CssStyleValue*, horizontal_radii: const ak.Vector[CssStyleValue*]*, vertical_radii: const ak.Vector[CssStyleValue*]*) -> CssStyleValue*:
    let vertical = corner(horizontal_radii) if ak.vector_is_empty(vertical_radii) else corner(vertical_radii)
    return css_border_radius_style_value_create(corner(horizontal_radii), vertical).css_style_value()

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3423 Web::CSS::Parser::Parser::parse_border_radius_rect_value.
pub func css_parser_parse_border_radius_rect_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssBorderRadiusRectStyleValue*?:
    var horizontal_radii = ak.Vector[CssStyleValue*]()
    var vertical_radii = ak.Vector[CssStyleValue*]()
    var reading_vertical = false
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)

    while css_syntax.token_stream_has_next_token(tokens):
        if css_next_token_is_delim(tokens, (u32)'/'):
            if reading_vertical or ak.vector_is_empty(&horizontal_radii):
                return none

            reading_vertical = true
            css_syntax.token_stream_discard_a_token(tokens)  # `/`
            css_syntax.token_stream_discard_whitespace(tokens)
            continue

        let maybe_dimension = css_parser_parse_length_percentage_value(this, tokens, css_non_negative_range, css_non_negative_range) else return none
        if reading_vertical:
            ak.vector_append_t(&vertical_radii, maybe_dimension)
        else:
            ak.vector_append_t(&horizontal_radii, maybe_dimension)
        css_syntax.token_stream_discard_whitespace(tokens)

    if (ak.vector_size(&horizontal_radii) > 4 or ak.vector_size(&vertical_radii) > 4 or ak.vector_is_empty(&horizontal_radii) or (reading_vertical and ak.vector_is_empty(&vertical_radii))):
        return none

    let top_left_radius = css_border_radius_corner(css_border_radius_top_left, &horizontal_radii, &vertical_radii)
    let top_right_radius = css_border_radius_corner(css_border_radius_top_right, &horizontal_radii, &vertical_radii)
    let bottom_right_radius = css_border_radius_corner(css_border_radius_bottom_right, &horizontal_radii, &vertical_radii)
    let bottom_left_radius = css_border_radius_corner(css_border_radius_bottom_left, &horizontal_radii, &vertical_radii)

    css_syntax.state_transaction_commit(&transaction)
    return css_border_radius_rect_style_value_create(top_left_radius, top_right_radius, bottom_right_radius, bottom_left_radius)

# mark: <radial-size> ===========================================================================

## The `parse_radial_extent` lambda of parse_radial_size.
func css_parser_parse_radial_extent(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> css_data.RadialExtent?:
    var radial_extent_transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&radial_extent_transaction)

    let keyword_value = css_parser_parse_keyword_value(this, tokens) else return none

    let radial_extent = css_data.keyword_to_radial_extent(css_style_value_to_keyword(keyword_value)) else return none

    css_syntax.state_transaction_commit(&radial_extent_transaction)
    return radial_extent

## The `parse_nonnegative_length_percentage_value` lambda of parse_radial_size.
func css_parser_parse_nonnegative_length_percentage_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    var length_percentage_transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&length_percentage_transaction)

    let length_percentage_value = css_parser_parse_length_percentage_value(this, tokens, css_non_negative_range, css_non_negative_range) else return none

    css_syntax.state_transaction_commit(&length_percentage_transaction)
    return length_percentage_value

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3511 Web::CSS::Parser::Parser::parse_radial_size.
# https://drafts.csswg.org/css-images-4/#radial-size
pub func css_parser_parse_radial_size(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssRadialSizeStyleValue*?:
    # <radial-size> = <radial-extent>{1,2} | <length-percentage [0,∞]>{1,2}
    # <radial-extent> = closest-corner | closest-side | farthest-corner | farthest-side
    # AD-HOC: The grammar by the spec above is incorrect as it disallows mixing of <length-percentage> and
    #         <radial-extent> which breaks backwards compatibility with `<shape-radius>` which it is intended to
    #         replace (see https://github.com/w3c/csswg-drafts/issues/9729). To avoid this issue we instead use the
    #         following grammar:
    #         `<radial-size> = [ <radial-extent> | <length-percentage [0,∞]> ]{1,2}`
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    var values = ak.Vector[CssRadialSizeStyleValueComponent]()

    while css_syntax.token_stream_has_next_token(tokens) and ak.vector_size(&values) < 2:
        css_syntax.token_stream_discard_whitespace(tokens)

        if let radial_extent = css_parser_parse_radial_extent(this, tokens):
            ak.vector_append_t(&values, CssRadialSizeStyleValueComponent.radial_extent(radial_extent))
            continue

        if let length_percentage = css_parser_parse_nonnegative_length_percentage_value(this, tokens):
            ak.vector_append_t(&values, CssRadialSizeStyleValueComponent.css_style_value(length_percentage))
            continue

        break

    if ak.vector_is_empty(&values):
        return none

    css_syntax.state_transaction_commit(&transaction)
    return css_radial_size_style_value_create(values)

# mark: fit-content() ===========================================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3572 Web::CSS::Parser::Parser::parse_fit_content_value.
pub func css_parser_parse_fit_content_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)
    let component_value = css_syntax.token_stream_consume_a_token(tokens)

    if css_syntax.component_value_is_ident(&component_value, ak.sv("fit-content")):
        css_syntax.state_transaction_commit(&transaction)
        return css_keyword_style_value_create(css_data.Keyword.fit_content).css_style_value()

    if not css_syntax.component_value_is_function(&component_value):
        return none

    let function = css_syntax.component_value_function(&component_value)
    if not ak.fly_string_eq_string_view(&function.name, ak.sv("fit-content")):
        return none
    var argument_tokens = css_syntax.token_stream_create(function.value)
    css_syntax.token_stream_discard_whitespace(&argument_tokens)
    let length_percentage_value = css_parser_parse_length_percentage_value(this, &argument_tokens, css_infinite_range, css_infinite_range) else return none
    css_syntax.token_stream_discard_whitespace(&argument_tokens)
    if css_syntax.token_stream_has_next_token(&argument_tokens):
        return none

    css_syntax.state_transaction_commit(&transaction)
    return css_function_style_value_create(ak.fly_string_from_str("fit-content"), length_percentage_value).css_style_value()