Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / parser / property_parsing_16.lucb

#==============================================================================================
#
#   property_parsing_16 - parsing property values: filter and backdrop-filter, contain,
#                         container-type
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/PropertyParsing.cpp (lines 5298-5647).
#
#==============================================================================================

# mark: filter ==================================================================================

## The local `enum class FilterToken` of parse_filter_value_list_value.
enum CssParseFilterValueListValueFilterToken as u8:
    # Color filters:
    brightness = 0
    contrast = 1
    grayscale = 2
    invert = 3
    opacity = 4
    saturate = 5
    sepia = 6
    # Special filters:
    blur = 7
    drop_shadow = 8
    hue_rotate = 9

## The `filter_token_to_operation` lambda of parse_filter_value_list_value.
func css_filter_token_to_operation(filter: CssParseFilterValueListValueFilterToken) -> gfx.ColorFilterType:
    assert((u8)filter < (u8)CssParseFilterValueListValueFilterToken.blur)
    return (gfx.ColorFilterType)(i32)(u8)filter

## The `parse_filter_function_name` lambda of parse_filter_value_list_value.
func css_parse_filter_function_name(name: ak.FlyString) -> CssParseFilterValueListValueFilterToken?:
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("blur")):
        return CssParseFilterValueListValueFilterToken.blur
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("brightness")):
        return CssParseFilterValueListValueFilterToken.brightness
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("contrast")):
        return CssParseFilterValueListValueFilterToken.contrast
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("drop-shadow")):
        return CssParseFilterValueListValueFilterToken.drop_shadow
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("grayscale")):
        return CssParseFilterValueListValueFilterToken.grayscale
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("hue-rotate")):
        return CssParseFilterValueListValueFilterToken.hue_rotate
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("invert")):
        return CssParseFilterValueListValueFilterToken.invert
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("opacity")):
        return CssParseFilterValueListValueFilterToken.opacity
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("saturate")):
        return CssParseFilterValueListValueFilterToken.saturate
    if ak.fly_string_equals_ignoring_ascii_case_string_view(&name, ak.sv("sepia")):
        return CssParseFilterValueListValueFilterToken.sepia
    return none

## The `if_no_more_tokens_return` lambda of parse_filter_function.
func css_if_no_more_tokens_return(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, filter: CssFilterValue) -> CssFilterValue?:
    css_syntax.token_stream_discard_whitespace(tokens)
    if css_syntax.token_stream_has_next_token(tokens):
        return none
    return filter

## The `parse_filter_function` lambda of parse_filter_value_list_value.
# https://drafts.csswg.org/filter-effects-1/#typedef-filter-function
# <blur()> | <brightness()> | <contrast()> | <drop-shadow()> | <grayscale()> | <hue-rotate()> | <invert()> | <opacity()> | <sepia()> | <saturate()>
func css_parser_parse_filter_function(this: CssParser*, filter_token: CssParseFilterValueListValueFilterToken, function_values: ak.Vector[css_syntax.ComponentValue]) -> CssFilterValue?:
    var tokens_stream = css_syntax.token_stream_create(function_values)
    let tokens = &tokens_stream
    css_syntax.token_stream_discard_whitespace(tokens)

    # NB: The `if_no_more_tokens_return` lambda is css_if_no_more_tokens_return.

    if filter_token == CssParseFilterValueListValueFilterToken.blur:
        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-blur
        # blur( <length>? )

        # Default value when omitted is 0px.
        if not css_syntax.token_stream_has_next_token(tokens):
            return CssFilterValue.css_blur(value = CssBlur(radius = css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value()))

        # Negative values are not allowed.
        let blur_radius = css_parser_parse_length_value(this, tokens, css_non_negative_range)
        css_syntax.token_stream_discard_whitespace(tokens)
        let radius = blur_radius else return none
        return css_if_no_more_tokens_return(tokens, CssFilterValue.css_blur(value = CssBlur(radius = radius)))
    elif filter_token == CssParseFilterValueListValueFilterToken.drop_shadow:
        if not css_syntax.token_stream_has_next_token(tokens):
            return none
        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-drop-shadow
        # drop-shadow( [ <color>? && <length>{2,3} ] )

        # Note: The following code is a little awkward to allow the color to be before or after the lengths.
        var maybe_radius: CssStyleValue*? = none
        var maybe_color = css_parser_parse_color_value(this, tokens)
        css_syntax.token_stream_discard_whitespace(tokens)
        let x_offset = css_parser_parse_length_value(this, tokens, css_infinite_range)
        css_syntax.token_stream_discard_whitespace(tokens)
        if x_offset == none or not css_syntax.token_stream_has_next_token(tokens):
            return none

        let y_offset = css_parser_parse_length_value(this, tokens, css_infinite_range)
        css_syntax.token_stream_discard_whitespace(tokens)
        if y_offset == none:
            return none

        if css_syntax.token_stream_has_next_token(tokens):
            maybe_radius = css_parser_parse_length_value(this, tokens, css_infinite_range)
            css_syntax.token_stream_discard_whitespace(tokens)
            if maybe_color == none and (maybe_radius == none or css_syntax.token_stream_has_next_token(tokens)):
                maybe_color = css_parser_parse_color_value(this, tokens)
                if maybe_color == none:
                    return none
            elif maybe_radius == none:
                return none

        return css_if_no_more_tokens_return(tokens, CssFilterValue.css_drop_shadow(value = CssDropShadow(offset_x = x_offset else trap("release_nonnull"), offset_y = y_offset else trap("release_nonnull"),
                                                                                                         radius = maybe_radius, color = maybe_color)))
    elif filter_token == CssParseFilterValueListValueFilterToken.hue_rotate:
        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-hue-rotate
        # hue-rotate( [ <angle> | <zero> ]? )

        # Default value when omitted is 0deg.
        if not css_syntax.token_stream_has_next_token(tokens):
            return CssFilterValue.css_hue_rotate(value = CssHueRotate(angle = css_angle_style_value_create(css_angle_make_degrees(0.0)).css_style_value()))

        # The unit identifier may be omitted if the <angle> is zero.
        if css_next_token_is(tokens, .number):
            # hue-rotate(0)
            let number = css_syntax.token_stream_consume_a_token(tokens)
            let token = css_syntax.component_value_token(&number)
            if css_syntax.token_is_integer(&token) and css_syntax.token_to_integer(&token) == 0:
                return css_if_no_more_tokens_return(tokens, CssFilterValue.css_hue_rotate(value = CssHueRotate(angle = css_angle_style_value_create(css_angle_make_degrees(0.0)).css_style_value())))
            return none

        if let angle = css_parser_parse_angle_value(this, tokens, css_infinite_range):
            return css_if_no_more_tokens_return(tokens, CssFilterValue.css_hue_rotate(value = CssHueRotate(angle = angle)))

        return none
    else:
        # Simple filters:

        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-brightness
        # brightness( [ <number> | <percentage> ]? )

        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-contrast
        # contrast( [ <number> | <percentage> ]? )

        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-grayscale
        # grayscale( [ <number> | <percentage> ]? )

        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-invert
        # invert( [ <number> | <percentage> ]? )

        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-opacity
        # opacity( [ <number> | <percentage> ]? )

        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-sepia
        # sepia( [ <number> | <percentage> ]? )

        # https://drafts.csswg.org/filter-effects-1/#funcdef-filter-saturate
        # saturate( [ <number> | <percentage> ]? )

        # Default value when omitted is 1.
        if not css_syntax.token_stream_has_next_token(tokens):
            return CssFilterValue.css_color(value = CssColor(operation = css_filter_token_to_operation(filter_token), amount = css_number_style_value_create(1.0).css_style_value()))

        # Negative values are not allowed.
        var amount = css_parser_parse_number_percentage_value(this, tokens, css_non_negative_range, css_non_negative_range) else return none

        # Values of amount over 100% are allowed but UAs must clamp the values to 1.
        # NB: Only for grayscale(), invert(), opacity() and sepia() functions
        if (filter_token == CssParseFilterValueListValueFilterToken.grayscale or filter_token == CssParseFilterValueListValueFilterToken.invert or filter_token == CssParseFilterValueListValueFilterToken.opacity or filter_token == CssParseFilterValueListValueFilterToken.sepia):
            if css_style_value_is_percentage(amount):
                let percentage = css_percentage_style_value_percentage(css_style_value_as_percentage(amount))
                if css_percentage_value(&percentage) > 100.0:
                    amount = css_percentage_style_value_create(css_percentage_new(100.0)).css_style_value()
            if css_style_value_is_number(amount) and css_number_style_value_number(css_style_value_as_number(amount)) > 1.0:
                amount = css_number_style_value_create(1.0).css_style_value()

        return css_if_no_more_tokens_return(tokens, CssFilterValue.css_color(value = CssColor(operation = css_filter_token_to_operation(filter_token), amount = amount)))

## The step of parse_filter_value_list_value's loop that parses one filter function, in a value-parsing context
## for the function's name.
func css_parser_parse_filter_function_in_context(this: CssParser*, filter_token: CssParseFilterValueListValueFilterToken, function: css_syntax.Function) -> CssFilterValue?:
    css_parser_push_temporary_value_parsing_context(this, CssValueParsingContext.css_function_context(value = CssFunctionContext(name = ak.fly_string_bytes_as_string_view(&function.name))))
    defer css_parser_pop_temporary_value_parsing_context(this)
    return css_parser_parse_filter_function(this, filter_token, function.value)

## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:5298 Web::CSS::Parser::Parser::parse_filter_value_list_value.
pub func css_parser_parse_filter_value_list_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    if let none_ = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_):
        return none_

    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)

    # https://drafts.csswg.org/filter-effects-1/#typedef-filter-value-list
    # <filter-value-list> = [ <filter-function> | <url> ]+
    # FIXME: <url>s are ignored for now

    # NB: `FilterToken` is CssParseFilterValueListValueFilterToken; the `filter_token_to_operation`,
    #     `parse_filter_function_name` and `parse_filter_function` lambdas are css_filter_token_to_operation,
    #     css_parse_filter_function_name and css_parser_parse_filter_function.

    var filter_value_list = ak.Vector[CssFilterValue]()

    while css_syntax.token_stream_has_next_token(tokens):
        css_syntax.token_stream_discard_whitespace(tokens)
        if not css_syntax.token_stream_has_next_token(tokens):
            break

        if let url_function = css_parser_parse_url_function(this, tokens):
            ak.vector_append_t(&filter_value_list, CssFilterValue.css_url(value = url_function))
            continue

        let token = css_syntax.token_stream_consume_a_token(tokens)
        if not css_syntax.component_value_is_function(&token):
            return none
        let function = css_syntax.component_value_function(&token)
        let filter_token = css_parse_filter_function_name(function.name) else return none

        let filter_function = css_parser_parse_filter_function_in_context(this, filter_token, function) else return none
        ak.vector_append_t(&filter_value_list, filter_function)

    if ak.vector_is_empty(&filter_value_list):
        return none

    css_syntax.state_transaction_commit(&transaction)
    return css_filter_value_list_style_value_create(filter_value_list).css_style_value()

# mark: contain and container-type ==============================================================

## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:5515 Web::CSS::Parser::Parser::parse_contain_value.
pub func css_parser_parse_contain_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # none | strict | content | [ [size | inline-size] || layout || style || paint ]
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)

    # none
    if let none_ = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.none_):
        css_syntax.state_transaction_commit(&transaction)
        return none_

    # strict
    if let strict = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.strict):
        css_syntax.state_transaction_commit(&transaction)
        return strict

    # content
    if let content = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.content):
        css_syntax.state_transaction_commit(&transaction)
        return content

    # [ [size | inline-size] || layout || style || paint ]
    if not css_syntax.token_stream_has_next_token(tokens):
        return none

    var size_value: CssStyleValue*? = none
    var layout_value: CssStyleValue*? = none
    var style_value: CssStyleValue*? = none
    var paint_value: CssStyleValue*? = none

    while css_syntax.token_stream_has_next_token(tokens):
        css_syntax.token_stream_discard_whitespace(tokens)
        let keyword_value = css_parser_parse_keyword_value(this, tokens) else return none
        match css_style_value_to_keyword(keyword_value):
            .size, .inline_size:
                if size_value != none:
                    return none
                size_value = keyword_value
            .layout:
                if layout_value != none:
                    return none
                layout_value = keyword_value
            .style:
                if style_value != none:
                    return none
                style_value = keyword_value
            .paint:
                if paint_value != none:
                    return none
                paint_value = keyword_value
            _:
                return none

    var containment_values = ak.Vector[CssStyleValue*]()
    if let value = size_value:
        ak.vector_append_t(&containment_values, value)
    if let value = layout_value:
        ak.vector_append_t(&containment_values, value)
    if let value = style_value:
        ak.vector_append_t(&containment_values, value)
    if let value = paint_value:
        ak.vector_append_t(&containment_values, value)

    css_syntax.state_transaction_commit(&transaction)

    return css_style_value_list_of(containment_values, CssStyleValueListSeparator.space)

## Ported from Libraries/LibWeb/CSS/Parser/PropertyParsing.cpp:5596 Web::CSS::Parser::Parser::parse_container_type_value.
# https://drafts.csswg.org/css-conditional-5/#propdef-container-type
pub func css_parser_parse_container_type_value(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssStyleValue*?:
    # normal | [ [ size | inline-size ] || scroll-state ]
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)
    css_syntax.token_stream_discard_whitespace(tokens)

    # normal
    if let none_ = css_parser_parse_all_as_single_keyword_value(this, tokens, css_data.Keyword.normal):
        css_syntax.state_transaction_commit(&transaction)
        return none_

    # [ [ size | inline-size ] || scroll-state ]
    if not css_syntax.token_stream_has_next_token(tokens):
        return none

    var size_value: CssStyleValue*? = none
    var scroll_state_value: CssStyleValue*? = none

    while css_syntax.token_stream_has_next_token(tokens):
        let keyword_value = css_parser_parse_keyword_value(this, tokens) else return none
        match css_style_value_to_keyword(keyword_value):
            .size, .inline_size:
                if size_value != none:
                    return none
                size_value = keyword_value
            .scroll_state:
                if scroll_state_value != none:
                    return none
                scroll_state_value = keyword_value
            _:
                return none
        css_syntax.token_stream_discard_whitespace(tokens)

    var containment_values = ak.Vector[CssStyleValue*]()
    if let value = size_value:
        ak.vector_append_t(&containment_values, value)
    if let value = scroll_state_value:
        ak.vector_append_t(&containment_values, value)

    css_syntax.state_transaction_commit(&transaction)

    return css_style_value_list_of(containment_values, CssStyleValueListSeparator.space)