dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / 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()