dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / parser / value_parsing_9.lucb
#==============================================================================================
#
# value_parsing_9 - parsing CSS values: <basic-shape>, CSS-wide keywords, <custom-ident>,
# <random-value-sharing> and <dashed-ident>
#
# DESCRIPTION:
# Port of LibWeb/CSS/Parser/ValueParsing.cpp (lines 3942-4417): the basic shapes
# (inset(), xywh(), rect(), circle(), ellipse(), polygon(), path()), the CSS-wide keywords,
# <custom-ident>, <random-value-sharing> and <dashed-ident>, with their style-value forms.
#
# 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: <basic-shape> ===========================================================================
## The `parse_fill_rule_argument` lambda of parse_basic_shape_value.
func css_parse_fill_rule_argument(component_values: const ak.Vector[css_syntax.ComponentValue]*) -> gfx.WindingRule?:
var tokens = css_syntax.token_stream_create(*component_values)
css_syntax.token_stream_discard_whitespace(&tokens)
let maybe_ident = css_syntax.token_stream_consume_a_token(&tokens)
css_syntax.token_stream_discard_whitespace(&tokens)
if css_syntax.token_stream_has_next_token(&tokens):
return none
if css_syntax.component_value_is_ident(&maybe_ident, ak.sv("nonzero")):
return gfx.WindingRule.nonzero
if css_syntax.component_value_is_ident(&maybe_ident, ak.sv("evenodd")):
return gfx.WindingRule.even_odd
return none
## The `[ round <'border-radius'> ]?` tail of inset(), xywh() and rect(): the border radius (zero when absent), or
## none when `round` is not followed by a valid border radius.
func css_parser_parse_basic_shape_round(this: CssParser*, arguments_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
var border_radius = css_border_radius_rect_style_value_create_zero().css_style_value()
if css_next_token_is_ident(arguments_tokens, "round"):
css_syntax.token_stream_discard_a_token(arguments_tokens) # 'round'
let parsed_border_radius = css_parser_parse_border_radius_rect_value(this, arguments_tokens) else return none
border_radius = parsed_border_radius.css_style_value()
css_syntax.token_stream_discard_whitespace(arguments_tokens)
return border_radius
## The `parse_length_percentage_or_auto` lambda of parse_basic_shape_value's rect() branch.
func css_parser_parse_length_percentage_or_auto(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
css_syntax.token_stream_discard_whitespace(tokens)
if let value = css_parser_parse_length_percentage_value(this, tokens, css_infinite_range, css_infinite_range):
return value
let consumed = css_syntax.token_stream_consume_a_token(tokens)
if css_syntax.component_value_is_ident(&consumed, ak.sv("auto")):
return css_keyword_style_value_create(css_data.Keyword.auto).css_style_value()
return none
## The `[ at <position> ]? ` tail of circle() and ellipse(): `true` and the position (none when absent), or `false`
## when `at` is not followed by a valid position.
func css_parser_parse_basic_shape_at_position(this: CssParser*, arguments_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, position: CssStyleValue*?*) -> bool:
css_syntax.token_stream_discard_whitespace(arguments_tokens)
if css_next_token_is_ident(arguments_tokens, "at"):
css_syntax.token_stream_discard_a_token(arguments_tokens)
css_syntax.token_stream_discard_whitespace(arguments_tokens)
let maybe_position = css_parser_parse_position_value(this, arguments_tokens) else return false
*position = maybe_position.css_style_value()
return true
## `RadialSizeStyleValue::create({ extents... })`.
func css_radial_size_of_extents(extents: const css_data.RadialExtent[]) -> CssRadialSizeStyleValue*:
var components = ak.Vector[CssRadialSizeStyleValueComponent]()
for extent in extents:
ak.vector_append_t(&components, CssRadialSizeStyleValueComponent.radial_extent(extent))
return css_radial_size_style_value_create(components)
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:3942 Web::CSS::Parser::Parser::parse_basic_shape_value.
pub func css_parser_parse_basic_shape_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 not css_syntax.component_value_is_function(&component_value):
return none
let function = css_syntax.component_value_function(&component_value)
let function_name = ak.fly_string_bytes_as_string_view(&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.string_view_equals_ignoring_ascii_case(&function_name, ak.sv("inset")):
# inset() = inset( <length-percentage>{1,4} [ round <'border-radius'> ]? )
var arguments_tokens = css_syntax.token_stream_create(function.value)
# If less than four <length-percentage> values are provided,
# the omitted values default in the same way as the margin shorthand:
# an omitted second or third value defaults to the first, and an omitted fourth value defaults to the second.
# The four <length-percentage>s define the position of the top, right, bottom, and left edges of a rectangle.
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let top = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_infinite_range, css_infinite_range) else return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let right = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_infinite_range, css_infinite_range) else top
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let bottom = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_infinite_range, css_infinite_range) else top
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let left = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_infinite_range, css_infinite_range) else right
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let border_radius = css_parser_parse_basic_shape_round(this, &arguments_tokens) else return none
if css_syntax.token_stream_has_next_token(&arguments_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return css_basic_shape_style_value_create(CssBasicShape.css_inset(CssInset(top = top, right = right, bottom = bottom, left = left, border_radius = border_radius))).css_style_value()
if ak.string_view_equals_ignoring_ascii_case(&function_name, ak.sv("xywh")):
# xywh() = xywh( <length-percentage>{2} <length-percentage [0,∞]>{2} [ round <'border-radius'> ]? )
var arguments_tokens = css_syntax.token_stream_create(function.value)
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let x = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_infinite_range, css_infinite_range) else return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let y = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_infinite_range, css_infinite_range) else return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let width = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_non_negative_range, css_non_negative_range) else return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let height = css_parser_parse_length_percentage_value(this, &arguments_tokens, css_non_negative_range, css_non_negative_range) else return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let border_radius = css_parser_parse_basic_shape_round(this, &arguments_tokens) else return none
if css_syntax.token_stream_has_next_token(&arguments_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return css_basic_shape_style_value_create(CssBasicShape.css_xywh(CssXywh(x = x, y = y, width = width, height = height, border_radius = border_radius))).css_style_value()
if ak.string_view_equals_ignoring_ascii_case(&function_name, ak.sv("rect")):
# rect() = rect( [ <length-percentage> | auto ]{4} [ round <'border-radius'> ]? )
var arguments_tokens = css_syntax.token_stream_create(function.value)
let top = css_parser_parse_length_percentage_or_auto(this, &arguments_tokens)
let right = css_parser_parse_length_percentage_or_auto(this, &arguments_tokens)
let bottom = css_parser_parse_length_percentage_or_auto(this, &arguments_tokens)
let left = css_parser_parse_length_percentage_or_auto(this, &arguments_tokens)
if top == none or right == none or bottom == none or left == none:
return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
let border_radius = css_parser_parse_basic_shape_round(this, &arguments_tokens) else return none
if css_syntax.token_stream_has_next_token(&arguments_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return css_basic_shape_style_value_create(CssBasicShape.css_rect(CssRect(top = top else trap("VERIFY: top"), right = right else trap("VERIFY: right"), bottom = bottom else trap("VERIFY: bottom"), left = left else trap("VERIFY: left"), border_radius = border_radius))).css_style_value()
if ak.string_view_equals_ignoring_ascii_case(&function_name, ak.sv("circle")):
# circle() = circle( <radial-size>? [ at <position> ]? )
var arguments_tokens = css_syntax.token_stream_create(function.value)
var radius = css_parser_parse_radial_size(this, &arguments_tokens)
if let parsed_radius = radius:
let components = css_radial_size_style_value_components(parsed_radius)
if ak.vector_size(&components) != 1:
return none
if radius == none:
let closest_side: css_data.RadialExtent[1] = [css_data.RadialExtent.closest_side]
radius = css_radial_size_of_extents(closest_side)
var position: CssStyleValue*? = none
if not css_parser_parse_basic_shape_at_position(this, &arguments_tokens, &position):
return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
if css_syntax.token_stream_has_next_token(&arguments_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return css_basic_shape_style_value_create(CssBasicShape.css_circle(CssCircle(radius = (radius else trap("VERIFY: a radius")).css_style_value(), position = position))).css_style_value()
if ak.string_view_equals_ignoring_ascii_case(&function_name, ak.sv("ellipse")):
# ellipse() = ellipse( <radial-size>? [ at <position> ]? )
var arguments_tokens = css_syntax.token_stream_create(function.value)
var radius = css_parser_parse_radial_size(this, &arguments_tokens)
# NB: The spec doesn't specify whether a single value radius is valid here but WPT expects it to not be.
if let parsed_radius = radius:
let components = css_radial_size_style_value_components(parsed_radius)
if ak.vector_size(&components) != 2:
return none
if radius == none:
# AD-HOC: The spec calls for this to default to `closest-side` but as outlined above it's not clear whether
# the spec intends for single value radii to be valid.
let closest_sides: css_data.RadialExtent[2] = [css_data.RadialExtent.closest_side, css_data.RadialExtent.closest_side]
radius = css_radial_size_of_extents(closest_sides)
var position: CssStyleValue*? = none
if not css_parser_parse_basic_shape_at_position(this, &arguments_tokens, &position):
return none
css_syntax.token_stream_discard_whitespace(&arguments_tokens)
if css_syntax.token_stream_has_next_token(&arguments_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return css_basic_shape_style_value_create(CssBasicShape.css_ellipse(CssEllipse(radius = (radius else trap("VERIFY: a radius")).css_style_value(), position = position))).css_style_value()
if ak.string_view_equals_ignoring_ascii_case(&function_name, ak.sv("polygon")):
# polygon() = polygon( <'fill-rule'>? , [<length-percentage> <length-percentage>]# )
var arguments_tokens = css_syntax.token_stream_create(function.value)
var arguments = css_parser_parse_a_comma_separated_list_of_component_values(this, &arguments_tokens)
if ak.vector_size(&arguments) < 1:
return none
var fill_rule = css_parse_fill_rule_argument(ak.vector_at_const(&arguments, 0))
if fill_rule != none:
ak.vector_remove(&arguments, 0)
else:
fill_rule = gfx.WindingRule.nonzero
if ak.vector_size(&arguments) < 1:
return none
var points = ak.Vector[CssPolygonPoint]()
for argument in ak.vector_span_const(&arguments):
var argument_tokens = css_syntax.token_stream_create(argument)
css_syntax.token_stream_discard_whitespace(&argument_tokens)
let x_pos = 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)
let y_pos = 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
ak.vector_append_t(&points, CssPolygonPoint(x = x_pos, y = y_pos))
css_syntax.state_transaction_commit(&transaction)
return css_basic_shape_style_value_create(CssBasicShape.css_polygon(CssPolygon(fill_rule = fill_rule else trap("VERIFY: a fill rule"), points = points))).css_style_value()
if ak.string_view_equals_ignoring_ascii_case(&function_name, ak.sv("path")):
# <path()> = path( <'fill-rule'>?, <string> )
var arguments_tokens = css_syntax.token_stream_create(function.value)
let arguments = css_parser_parse_a_comma_separated_list_of_component_values(this, &arguments_tokens)
if ak.vector_size(&arguments) < 1 or ak.vector_size(&arguments) > 2:
return none
# <'fill-rule'>?
var fill_rule = gfx.WindingRule.nonzero
if ak.vector_size(&arguments) == 2:
let maybe_fill_rule = css_parse_fill_rule_argument(ak.vector_at_const(&arguments, 0)) else return none
fill_rule = maybe_fill_rule
# <string>, which is a path string
var path_argument_tokens = css_syntax.token_stream_create(*ak.vector_last_const(&arguments))
css_syntax.token_stream_discard_whitespace(&path_argument_tokens)
let maybe_string = css_syntax.token_stream_consume_a_token(&path_argument_tokens)
css_syntax.token_stream_discard_whitespace(&path_argument_tokens)
if not css_syntax.component_value_is(&maybe_string, .string) or css_syntax.token_stream_has_next_token(&path_argument_tokens):
return none
let string_token = css_syntax.component_value_token(&maybe_string)
let path_fly_string = css_syntax.token_string(&string_token)
let path_string = ak.fly_string_to_string_const(&path_fly_string)
let path_data = svg_attribute_parser_parse_path_data(ak.string_bytes_as_string_view(&path_string))
if svg_path_instructions(&path_data).length == 0:
return none
css_syntax.state_transaction_commit(&transaction)
return css_basic_shape_style_value_create(CssBasicShape.css_path(CssPath(fill_rule = fill_rule, path_instructions = path_data))).css_style_value()
return none
# mark: CSS-wide keywords =======================================================================
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:4262 Web::CSS::Parser::Parser::parse_builtin_value.
pub func css_parser_parse_builtin_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
_ = this
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(&component_value, .ident):
let ident = css_component_value_ident(&component_value)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("inherit")):
css_syntax.state_transaction_commit(&transaction)
return css_keyword_style_value_create(css_data.Keyword.inherit).css_style_value()
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("initial")):
css_syntax.state_transaction_commit(&transaction)
return css_keyword_style_value_create(css_data.Keyword.initial).css_style_value()
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("unset")):
css_syntax.state_transaction_commit(&transaction)
return css_keyword_style_value_create(css_data.Keyword.unset).css_style_value()
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("revert")):
css_syntax.state_transaction_commit(&transaction)
return css_keyword_style_value_create(css_data.Keyword.revert).css_style_value()
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("revert-layer")):
css_syntax.state_transaction_commit(&transaction)
return css_keyword_style_value_create(css_data.Keyword.revert_layer).css_style_value()
return none
# mark: <custom-ident> ==========================================================================
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:4294 Web::CSS::Parser::Parser::parse_custom_ident.
# https://www.w3.org/TR/css-values-4/#custom-idents
pub func css_parser_parse_custom_ident(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, blacklist: const ak.StringView[]) -> ak.FlyString?:
_ = this
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
let token = css_syntax.token_stream_consume_a_token(tokens)
if not css_syntax.component_value_is(&token, .ident):
return none
let custom_ident = css_component_value_ident(&token)
if not is_valid_custom_ident(custom_ident, blacklist):
return none
css_syntax.state_transaction_commit(&transaction)
return custom_ident
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:4311 Web::CSS::Parser::Parser::parse_custom_ident_value.
pub func css_parser_parse_custom_ident_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, blacklist: const ak.StringView[]) -> CssCustomIdentStyleValue*?:
if let custom_ident = css_parser_parse_custom_ident(this, tokens, blacklist):
return css_custom_ident_style_value_create(custom_ident)
return none
# mark: <random-value-sharing> ==================================================================
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:4319 Web::CSS::Parser::Parser::parse_random_value_sharing.
# https://drafts.csswg.org/css-values-5/#typedef-random-value-sharing
pub func css_parser_parse_random_value_sharing(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssRandomValueSharingStyleValue*?:
# <random-value-sharing> = [ [ auto | <dashed-ident> ] || element-shared ] | fixed <number [0,1]>
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
return none
# fixed <number [0,1]>
if css_next_token_is_ident(tokens, "fixed"):
css_syntax.token_stream_discard_a_token(tokens)
css_syntax.token_stream_discard_whitespace(tokens)
# NB: Fixed values have to be less than one and numbers serialize with six digits of precision
if let fixed_value = css_parser_parse_number_value(this, tokens, CssNumericRange(min = 0.0, max = 0.999999)):
css_syntax.token_stream_discard_whitespace(tokens)
if css_syntax.token_stream_has_next_token(tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return css_random_value_sharing_style_value_create_fixed(fixed_value)
return none
# [ [ auto | <dashed-ident> ] || element-shared ]
var has_explicit_auto = false
var dashed_ident: ak.FlyString? = none
var element_shared = false
while css_syntax.token_stream_has_next_token(tokens):
if let maybe_dashed_ident_value = css_parser_parse_dashed_ident_value(this, tokens):
if has_explicit_auto or dashed_ident != none:
return none
dashed_ident = css_custom_ident_style_value_custom_ident(maybe_dashed_ident_value)
css_syntax.token_stream_discard_whitespace(tokens)
continue
let maybe_keyword_value = css_parser_parse_keyword_value(this, tokens)
if let keyword_value = maybe_keyword_value:
if css_style_value_to_keyword(keyword_value) == css_data.Keyword.auto:
if has_explicit_auto or dashed_ident != none:
return none
has_explicit_auto = true
css_syntax.token_stream_discard_whitespace(tokens)
continue
if css_style_value_to_keyword(keyword_value) == css_data.Keyword.element_shared:
if element_shared:
return none
element_shared = true
css_syntax.token_stream_discard_whitespace(tokens)
continue
return none
# NB: The donor returns without committing the transaction here, so the tokens are rewound.
let name = dashed_ident else return css_random_value_sharing_style_value_create_auto(css_parser_random_value_sharing_auto_name(this), element_shared)
return css_random_value_sharing_style_value_create_dashed_ident(name, element_shared)
# mark: <dashed-ident> ==========================================================================
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:4396 Web::CSS::Parser::Parser::parse_dashed_ident.
# https://drafts.csswg.org/css-values-4/#typedef-dashed-ident
pub func css_parser_parse_dashed_ident(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> ak.FlyString?:
# The <dashed-ident> production is a <custom-ident>, with all the case-sensitivity that implies, with the
# additional restriction that it must start with two dashes (U+002D HYPHEN-MINUS).
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
var no_blacklist: const ak.StringView[]
let custom_ident = css_parser_parse_custom_ident(this, tokens, no_blacklist) else return none
if not ak.fly_string_starts_with_bytes(&custom_ident, ak.sv("--")):
return none
css_syntax.state_transaction_commit(&transaction)
return custom_ident
## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:4408 Web::CSS::Parser::Parser::parse_dashed_ident_value.
pub func css_parser_parse_dashed_ident_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssCustomIdentStyleValue*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
if let dashed_ident = css_parser_parse_dashed_ident(this, tokens):
css_syntax.state_transaction_commit(&transaction)
return css_custom_ident_style_value_create(dashed_ident)
return none