Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   value_parsing_3 - parsing CSS values: keywords, scroll()/view(), rect(), <hue> and alpha
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/ValueParsing.cpp (lines 1193-1493): <'view-timeline-inset'>,
#       keyword values, the scroll() and view() timeline functions, the CSS 2.1 rect() shape,
#       [<hue> | none] and the [ / <alpha-value> ] tail of the modern color functions.
#
#       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: Scroll timelines ========================================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1194 Web::CSS::Parser::Parser::parse_view_timeline_inset_value.
# https://drafts.csswg.org/scroll-animations-1/#view-timeline-inset
pub func css_parser_parse_view_timeline_inset_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # [ [ auto | <length-percentage> ]{1,2} ]
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)

    var inset_values = ak.Vector[CssStyleValue*]()

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

        if css_next_token_is_ident(tokens, "auto"):
            css_syntax.token_stream_discard_a_token(tokens)  # auto
            ak.vector_append_t(&inset_values, css_keyword_style_value_create(css_data.Keyword.auto).css_style_value())
            continue

        if let length_percentage = css_parser_parse_length_percentage_value(this, tokens, css_infinite_range, css_infinite_range):
            ak.vector_append_t(&inset_values, length_percentage)
            continue

        break

    if ak.vector_is_empty(&inset_values):
        return none

    css_syntax.state_transaction_commit(&transaction)

    # If the second value is omitted, it is set to the first.
    if ak.vector_size(&inset_values) == 1:
        var both = ak.Vector[CssStyleValue*]()
        ak.vector_append_t(&both, *ak.vector_at(&inset_values, 0))
        ak.vector_append_t(&both, *ak.vector_at(&inset_values, 0))
        return css_style_value_list_create(both, CssStyleValueListSeparator.space).css_style_value()

    return css_style_value_list_create(inset_values, CssStyleValueListSeparator.space).css_style_value()

# mark: Keywords ================================================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1230 Web::CSS::Parser::Parser::parse_keyword_value.
pub func css_parser_parse_keyword_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    _ = this
    css_syntax.token_stream_discard_whitespace(tokens)
    let peek_token = css_syntax.token_stream_next_token(tokens)
    if css_syntax.component_value_is(&peek_token, .ident):
        let ident = css_component_value_ident(&peek_token)
        if let keyword = css_data.keyword_from_string(ak.fly_string_bytes_as_string_view(&ident)):
            css_syntax.token_stream_discard_a_token(tokens)  # ident
            return css_keyword_style_value_create(keyword).css_style_value()

    return none

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1245 Web::CSS::Parser::Parser::parse_specific_keyword_value.
pub func css_parser_parse_specific_keyword_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, keyword: css_data.Keyword) -> CssStyleValue*?:
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)

    if let keyword_value = css_parser_parse_keyword_value(this, tokens):
        if css_style_value_to_keyword(keyword_value) == keyword:
            css_syntax.state_transaction_commit(&transaction)
            return keyword_value

    return none

# mark: scroll() and view() =====================================================================

## `StyleValueTuple tuple; tuple.resize_with_default_value(size, nullptr);`.
func css_empty_style_value_tuple(size: usize) -> ak.Vector[CssStyleValue*?]:
    var tuple = ak.Vector[CssStyleValue*?]()
    ak.vector_resize_with_default_value(&tuple, size, none)
    return tuple

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1258 Web::CSS::Parser::Parser::parse_scroll_function_value.
# https://drafts.csswg.org/scroll-animations-1/#funcdef-scroll
pub func css_parser_parse_scroll_function_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssFunctionStyleValue*?:
    # <scroll()> = scroll( [ <scroller> || <axis> ]? )
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    let function_token = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is_function_string_view(&function_token, ak.sv("scroll")):
        return none

    var tuple = css_empty_style_value_tuple(2)

    var has_scroller = false
    var has_axis = false

    let function = css_syntax.component_value_function(&function_token)
    var argument_tokens = css_syntax.token_stream_create(function.value)

    while css_syntax.token_stream_has_next_token(&argument_tokens):
        # NB: The donor discards whitespace from the outer `tokens` here, not from the arguments.
        css_syntax.token_stream_discard_whitespace(tokens)

        if not css_syntax.token_stream_has_next_token(&argument_tokens):
            break

        let keyword_value = css_parser_parse_keyword_value(this, &argument_tokens) else return none

        if let maybe_scroller = css_data.keyword_to_scroller(css_style_value_to_keyword(keyword_value)):
            if has_scroller:
                return none

            # NB: The default value of <scroller> `nearest` is omitted from the serialization.
            if maybe_scroller != css_data.Scroller.nearest:
                *ak.vector_at(&tuple, css_tuple_style_value_indices_scroll_function_scroller) = keyword_value

            has_scroller = true
            continue

        if let maybe_axis = css_data.keyword_to_axis(css_style_value_to_keyword(keyword_value)):
            if has_axis:
                return none

            # NB: The default value of <axis> `block` is omitted from the serialization.
            if maybe_axis != css_data.Axis.block:
                *ak.vector_at(&tuple, css_tuple_style_value_indices_scroll_function_axis) = keyword_value

            has_axis = true
            continue

        return none

    css_syntax.state_transaction_commit(&transaction)
    return css_function_style_value_create(ak.fly_string_from_str("scroll"), css_tuple_style_value_create(tuple).css_style_value())

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1317 Web::CSS::Parser::Parser::parse_view_function_value.
# https://drafts.csswg.org/scroll-animations-1/#funcdef-view
pub func css_parser_parse_view_function_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssFunctionStyleValue*?:
    # <view()> = view( [ <axis> || <'view-timeline-inset'> ]? )
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    let function_token = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is_function_string_view(&function_token, ak.sv("view")):
        return none

    css_parser_push_temporary_value_parsing_context(this, CssValueParsingContext.css_function_context(CssFunctionContext(name = ak.sv("view"))))
    defer css_parser_pop_temporary_value_parsing_context(this)

    var tuple = css_empty_style_value_tuple(2)

    var has_axis = false
    var has_inset = false

    let function = css_syntax.component_value_function(&function_token)
    var argument_tokens = css_syntax.token_stream_create(function.value)

    while css_syntax.token_stream_has_next_token(&argument_tokens):
        css_syntax.token_stream_discard_whitespace(&argument_tokens)

        if not css_syntax.token_stream_has_next_token(&argument_tokens):
            break

        if let inset_value = css_parser_parse_view_timeline_inset_value(this, &argument_tokens):
            if has_inset:
                return none

            let inset_values = css_style_value_list_values(css_style_value_as_value_list(inset_value))

            # NB: The default value of <'view-timeline-inset'> `auto auto` is omitted from the serialization.
            if css_style_value_to_keyword(*ak.vector_at_const(&inset_values, 0)) != css_data.Keyword.auto or css_style_value_to_keyword(*ak.vector_at_const(&inset_values, 1)) != css_data.Keyword.auto:
                *ak.vector_at(&tuple, css_tuple_style_value_indices_view_function_inset) = inset_value

            has_inset = true
            continue

        if let keyword_value = css_parser_parse_keyword_value(this, &argument_tokens):
            if css_data.keyword_to_axis(css_style_value_to_keyword(keyword_value)) != none:
                if has_axis:
                    return none

                # NB: The default value of <axis> `block` is omitted from the serialization.
                if css_style_value_to_keyword(keyword_value) != css_data.Keyword.block:
                    *ak.vector_at(&tuple, css_tuple_style_value_indices_view_function_axis) = keyword_value

                has_axis = true
                continue

        return none

    css_syntax.state_transaction_commit(&transaction)
    return css_function_style_value_create(ak.fly_string_from_str("view"), css_tuple_style_value_create(tuple).css_style_value())

# mark: rect() ==================================================================================

## The `CommaRequirement` enum of parse_rect_value.
enum CssRectCommaRequirement:
    unknown
    requires_commas
    requires_no_commas

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1375 Web::CSS::Parser::Parser::parse_rect_value.
# https://www.w3.org/TR/CSS2/visufx.html#value-def-shape
pub func css_parser_parse_rect_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 function_token = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is_function_string_view(&function_token, ak.sv("rect")):
        return none

    css_parser_push_temporary_value_parsing_context(this, CssValueParsingContext.css_function_context(CssFunctionContext(name = ak.sv("rect"))))
    defer css_parser_pop_temporary_value_parsing_context(this)

    var params = ak.Vector[CssStyleValue*]()
    ak.vector_ensure_capacity(&params, 4)

    let function = css_syntax.component_value_function(&function_token)
    var argument_tokens = css_syntax.token_stream_create(function.value)

    # The `Side` enum: Top = 0, Right = 1, Bottom = 2, Left = 3.
    let side_left: usize = 3

    var comma_requirement = CssRectCommaRequirement.unknown

    # In CSS 2.1, the only valid <shape> value is: rect(<top>, <right>, <bottom>, <left>) where
    # <top> and <bottom> specify offsets from the top border edge of the box, and <right>, and
    #  <left> specify offsets from the left border edge of the box.
    for side: usize in 0..<4:
        css_syntax.token_stream_discard_whitespace(&argument_tokens)

        # <top>, <right>, <bottom>, and <left> may either have a <length> value or 'auto'.
        # Negative lengths are permitted.
        if css_next_token_is_ident(&argument_tokens, "auto"):
            _ = css_syntax.token_stream_consume_a_token(&argument_tokens)  # `auto`
            ak.vector_append_t(&params, css_keyword_style_value_create(css_data.Keyword.auto).css_style_value())
        else:
            let maybe_length = css_parser_parse_length_value(this, &argument_tokens, css_infinite_range) else return none

            ak.vector_append_t(&params, maybe_length)
        css_syntax.token_stream_discard_whitespace(&argument_tokens)

        # The last side, should be no more tokens following it.
        if side == side_left:
            if css_syntax.token_stream_has_next_token(&argument_tokens):
                return none
            break

        let next_is_comma = css_next_token_is(&argument_tokens, .comma)

        # Authors should separate offset values with commas. User agents must support separation
        # with commas, but may also support separation without commas (but not a combination),
        # because a previous revision of this specification was ambiguous in this respect.
        if comma_requirement == CssRectCommaRequirement.unknown:
            comma_requirement = CssRectCommaRequirement.requires_commas if next_is_comma else CssRectCommaRequirement.requires_no_commas

        match comma_requirement:
            .requires_commas:
                if next_is_comma:
                    css_syntax.token_stream_discard_a_token(&argument_tokens)
                else:
                    return none
            .requires_no_commas:
                if next_is_comma:
                    return none
            .unknown:
                trap("VERIFY_NOT_REACHED")

    css_syntax.state_transaction_commit(&transaction)
    return css_rect_style_value_create(*ak.vector_at(&params, 0), *ak.vector_at(&params, 1), *ak.vector_at(&params, 2), *ak.vector_at(&params, 3)).css_style_value()

# mark: Color components ========================================================================

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1457 Web::CSS::Parser::Parser::parse_hue_none_value.
# https://www.w3.org/TR/css-color-4/#typedef-hue
pub func css_parser_parse_hue_none_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # Parses [<hue> | none]
    #   <hue> = <number> | <angle>

    if let angle = css_parser_parse_angle_value(this, tokens, css_infinite_range):
        return angle
    if let number = css_parser_parse_number_value(this, tokens, css_infinite_range):
        return number
    if css_next_token_is_ident(tokens, "none"):
        css_syntax.token_stream_discard_a_token(tokens)  # keyword none
        return css_keyword_style_value_create(css_data.Keyword.none_).css_style_value()

    return none

## Ported from Libraries/LibWeb/CSS/Parser/ValueParsing.cpp:1475 Web::CSS::Parser::Parser::parse_solidus_and_alpha_value.
# https://www.w3.org/TR/css-color-4/#typedef-color-alpha-value
pub func css_parser_parse_solidus_and_alpha_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # [ / [<alpha-value> | none] ]?
    # <alpha-value> = <number> | <percentage>
    # Common to the modern-syntax color functions.

    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)
    let solidus = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is_delim(&solidus, (u32)'/'):
        return none
    css_syntax.token_stream_discard_whitespace(tokens)
    let alpha = css_parser_parse_number_percentage_none_value(this, tokens) else return none
    css_syntax.token_stream_discard_whitespace(tokens)

    css_syntax.state_transaction_commit(&transaction)
    return alpha