Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / 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