Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   selector_parsing_4 - parsing selectors: the An+B microsyntax and @page selector lists
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/SelectorParsing.cpp (lines 1187-1566): parse_a_n_plus_b_pattern
#       (its predicate lambdas are the small functions before it), parse_as_page_selector_list
#       and <page-selector-list> (the template over TokenStream<T>).
#
#       Copyright (c) 2018-2022, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2020-2021, the SerenityOS developers.
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: The An+B microsyntax ====================================================================

## The `is_sign` lambda of parse_a_n_plus_b_pattern.
func css_anb_is_sign(value: const css_syntax.ComponentValue*) -> bool:
    if not css_syntax.component_value_is(value, .delim):
        return false
    let token = css_syntax.component_value_token(value)
    return css_syntax.token_delim(&token) == (u32)'+' or css_syntax.token_delim(&token) == (u32)'-'

## The `is_series_of_1_or_more_digits` lambda of parse_a_n_plus_b_pattern.
func css_anb_is_series_of_1_or_more_digits(string: ak.StringView) -> bool:
    if ak.string_view_is_empty(&string):
        return false
    for c in ak.string_view_bytes(&string):
        if not ak.is_ascii_digit(c):
            return false
    return true

## `value.token().dimension_unit()` of a dimension token.
func css_anb_dimension_unit(value: const css_syntax.ComponentValue*) -> ak.FlyString:
    let token = css_syntax.component_value_token(value)
    return css_syntax.token_dimension_unit(&token)

## The `is_n_dimension` lambda: <n-dimension> is a <dimension-token> with its type flag set to "integer", and a
## unit that is an ASCII case-insensitive match for "n".
func css_anb_is_n_dimension(value: const css_syntax.ComponentValue*) -> bool:
    if not css_syntax.component_value_is(value, .dimension) or not css_component_value_is_integer(value):
        return false
    let unit_ = css_anb_dimension_unit(value)
    return ak.fly_string_equals_ignoring_ascii_case_string_view(&unit_, ak.sv("n"))

## The `is_ndash_dimension` lambda: <ndash-dimension> is a <dimension-token> with its type flag set to "integer",
## and a unit that is an ASCII case-insensitive match for "n-".
func css_anb_is_ndash_dimension(value: const css_syntax.ComponentValue*) -> bool:
    if not css_syntax.component_value_is(value, .dimension) or not css_component_value_is_integer(value):
        return false
    let unit_ = css_anb_dimension_unit(value)
    return ak.fly_string_equals_ignoring_ascii_case_string_view(&unit_, ak.sv("n-"))

## The `is_ndashdigit_dimension` lambda: <ndashdigit-dimension> is a <dimension-token> with its type flag set to
## "integer", and a unit that is an ASCII case-insensitive match for "n-*", where "*" is a series of one or more
## digits.
func css_anb_is_ndashdigit_dimension(value: const css_syntax.ComponentValue*) -> bool:
    if not css_syntax.component_value_is(value, .dimension) or not css_component_value_is_integer(value):
        return false
    let unit_ = css_anb_dimension_unit(value)
    if not ak.fly_string_starts_with_bytes(&unit_, ak.sv("n-"), ak.CaseSensitivity.case_insensitive):
        return false
    let unit_view = ak.fly_string_bytes_as_string_view(&unit_)
    return css_anb_is_series_of_1_or_more_digits(ak.string_view_substring_view(&unit_view, 2))

## Whether `value` is an <ident-token> starting with `prefix` (ASCII case-insensitively) followed by a series of one
## or more digits: the `is_ndashdigit_ident` and `is_dashndashdigit_ident` lambdas.
func css_anb_is_ident_with_digits_after(value: const css_syntax.ComponentValue*, prefix: str) -> bool:
    if not css_syntax.component_value_is(value, .ident):
        return false
    let ident = css_component_value_ident(value)
    if not ak.fly_string_starts_with_bytes(&ident, ak.sv(prefix), ak.CaseSensitivity.case_insensitive):
        return false
    let ident_view = ak.fly_string_bytes_as_string_view(&ident)
    return css_anb_is_series_of_1_or_more_digits(ak.string_view_substring_view(&ident_view, prefix.length))

## The `is_ndashdigit_ident` lambda: <ndashdigit-ident> is an <ident-token> whose value is an ASCII
## case-insensitive match for "n-*", where "*" is a series of one or more digits.
func css_anb_is_ndashdigit_ident(value: const css_syntax.ComponentValue*) -> bool:
    return css_anb_is_ident_with_digits_after(value, "n-")

## The `is_dashndashdigit_ident` lambda: <dashndashdigit-ident> is an <ident-token> whose value is an ASCII
## case-insensitive match for "-n-*", where "*" is a series of one or more digits.
func css_anb_is_dashndashdigit_ident(value: const css_syntax.ComponentValue*) -> bool:
    return css_anb_is_ident_with_digits_after(value, "-n-")

## The `is_integer` lambda: <integer> is a <number-token> with its type flag set to "integer".
func css_anb_is_integer(value: const css_syntax.ComponentValue*) -> bool:
    return css_syntax.component_value_is(value, .number) and css_component_value_is_integer(value)

## The `is_signed_integer` lambda: <signed-integer> is a <number-token> with its type flag set to "integer", and a
## sign character.
func css_anb_is_signed_integer(value: const css_syntax.ComponentValue*) -> bool:
    if not css_syntax.component_value_is(value, .number):
        return false
    let token = css_syntax.component_value_token(value)
    return css_syntax.token_is_integer_with_explicit_sign(&token)

## The `is_signless_integer` lambda: <signless-integer> is a <number-token> with its type flag set to "integer",
## and no sign character.
func css_anb_is_signless_integer(value: const css_syntax.ComponentValue*) -> bool:
    if not css_syntax.component_value_is(value, .number) or not css_component_value_is_integer(value):
        return false
    let token = css_syntax.component_value_token(value)
    return not css_syntax.token_is_integer_with_explicit_sign(&token)

## `value.token().to_integer()`.
func css_anb_to_integer(value: const css_syntax.ComponentValue*) -> i32:
    let token = css_syntax.component_value_token(value)
    return css_syntax.token_to_integer(&token)

## `value.token().dimension_value_int()`.
func css_anb_dimension_value_int(value: const css_syntax.ComponentValue*) -> i32:
    let token = css_syntax.component_value_token(value)
    return css_syntax.token_dimension_value_int(&token)

## `Selector::SimpleSelector::ANPlusBPattern { a, b }`.
func css_an_plus_b_pattern(a: i32, b: i32) -> CssSelectorSimpleSelectorAnPlusBPattern:
    return CssSelectorSimpleSelectorAnPlusBPattern(step_size = a, offset = b)

## The `['+' | '-'] <signless-integer>` step after `n`, `-n` and <n-dimension>: B, or none when the next two
## values are not that (C++ consumes them in a child transaction that it commits only on a match).
func css_anb_parse_sign_and_signless_integer(values: css_syntax.TokenStream[css_syntax.ComponentValue]*, transaction: css_syntax.StateTransaction*) -> i32?:
    var child_transaction = css_syntax.state_transaction_create_child(transaction)
    defer css_syntax.state_transaction_destroy(&child_transaction)
    let second_value = css_syntax.token_stream_consume_a_token(values)
    css_syntax.token_stream_discard_whitespace(values)
    let third_value = css_syntax.token_stream_consume_a_token(values)

    if css_anb_is_sign(&second_value) and css_anb_is_signless_integer(&third_value):
        var sign: i32 = -1
        if css_syntax.component_value_is_delim(&second_value, (u32)'+'):
            sign = 1
        let b = css_anb_to_integer(&third_value) * sign
        css_syntax.state_transaction_commit(&child_transaction)
        return b
    return none

## Ported from Libraries/LibWeb/CSS/Parser/SelectorParsing.cpp:1187 Web::CSS::Parser::Parser::parse_a_n_plus_b_pattern.
# https://drafts.csswg.org/css-syntax-3/#anb-microsyntax
pub func css_parser_parse_a_n_plus_b_pattern(this: CssParser*, values: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssSelectorSimpleSelectorAnPlusBPattern?:
    _ = this
    var transaction = css_syntax.token_stream_begin_transaction(values)
    defer css_syntax.state_transaction_destroy(&transaction)

    css_syntax.token_stream_discard_whitespace(values)

    # odd | even
    let first = css_syntax.token_stream_next_token(values)
    if css_syntax.component_value_is_ident(&first, ak.sv("odd")):
        css_syntax.token_stream_discard_a_token(values)  # odd
        css_syntax.state_transaction_commit(&transaction)
        return css_an_plus_b_pattern(2, 1)
    if css_syntax.component_value_is_ident(&first, ak.sv("even")):
        css_syntax.token_stream_discard_a_token(values)  # even
        css_syntax.state_transaction_commit(&transaction)
        return css_an_plus_b_pattern(2, 0)

    # <integer>
    if css_anb_is_integer(&first):
        let integer = css_syntax.token_stream_consume_a_token(values)
        let b = css_anb_to_integer(&integer)
        css_syntax.state_transaction_commit(&transaction)
        return css_an_plus_b_pattern(0, b)

    # <n-dimension>
    # <n-dimension> <signed-integer>
    # <n-dimension> ['+' | '-'] <signless-integer>
    if css_anb_is_n_dimension(&first):
        let dimension = css_syntax.token_stream_consume_a_token(values)
        let a = css_anb_dimension_value_int(&dimension)
        css_syntax.token_stream_discard_whitespace(values)

        # <n-dimension> <signed-integer>
        let next = css_syntax.token_stream_next_token(values)
        if css_anb_is_signed_integer(&next):
            let integer = css_syntax.token_stream_consume_a_token(values)
            let b = css_anb_to_integer(&integer)
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(a, b)

        # <n-dimension> ['+' | '-'] <signless-integer>
        if let b = css_anb_parse_sign_and_signless_integer(values, &transaction):
            return css_an_plus_b_pattern(a, b)

        # <n-dimension>
        css_syntax.state_transaction_commit(&transaction)
        return css_an_plus_b_pattern(a, 0)

    # <ndash-dimension> <signless-integer>
    if css_anb_is_ndash_dimension(&first):
        css_syntax.token_stream_discard_whitespace(values)
        let first_value = css_syntax.token_stream_consume_a_token(values)
        let second_value = css_syntax.token_stream_consume_a_token(values)
        if css_anb_is_signless_integer(&second_value):
            let a = css_anb_dimension_value_int(&first_value)
            let b = -css_anb_to_integer(&second_value)
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(a, b)

        return none

    # <ndashdigit-dimension>
    if css_anb_is_ndashdigit_dimension(&first):
        let dimension = css_syntax.token_stream_consume_a_token(values)
        let a = css_anb_dimension_value_int(&dimension)
        let unit_ = css_anb_dimension_unit(&dimension)
        let unit_view = ak.fly_string_bytes_as_string_view(&unit_)
        let b_view = ak.string_view_substring_view(&unit_view, 1)
        if let b = ak.string_view_to_number_i32(&b_view):
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(a, b)

        return none

    # <dashndashdigit-ident>
    if css_anb_is_dashndashdigit_ident(&first):
        let ident_value = css_syntax.token_stream_consume_a_token(values)
        let ident = css_component_value_ident(&ident_value)
        let ident_view = ak.fly_string_bytes_as_string_view(&ident)
        let b_view = ak.string_view_substring_view(&ident_view, 2)
        if let b = ak.string_view_to_number_i32(&b_view):
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(-1, b)

        return none

    # -n
    # -n <signed-integer>
    # -n ['+' | '-'] <signless-integer>
    if css_syntax.component_value_is_ident(&first, ak.sv("-n")):
        css_syntax.token_stream_discard_a_token(values)  # -n
        css_syntax.token_stream_discard_whitespace(values)

        # -n <signed-integer>
        let next = css_syntax.token_stream_next_token(values)
        if css_anb_is_signed_integer(&next):
            let integer = css_syntax.token_stream_consume_a_token(values)
            let b = css_anb_to_integer(&integer)
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(-1, b)

        # -n ['+' | '-'] <signless-integer>
        if let b = css_anb_parse_sign_and_signless_integer(values, &transaction):
            return css_an_plus_b_pattern(-1, b)

        # -n
        css_syntax.state_transaction_commit(&transaction)
        return css_an_plus_b_pattern(-1, 0)
    # -n- <signless-integer>
    if css_syntax.component_value_is_ident(&first, ak.sv("-n-")):
        css_syntax.token_stream_discard_a_token(values)  # -n-
        css_syntax.token_stream_discard_whitespace(values)
        let second_value = css_syntax.token_stream_consume_a_token(values)
        if css_anb_is_signless_integer(&second_value):
            let b = -css_anb_to_integer(&second_value)
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(-1, b)

        return none

    # All that's left now are these:
    # '+'?† n
    # '+'?† n <signed-integer>
    # '+'?† n ['+' | '-'] <signless-integer>
    # '+'?† n- <signless-integer>
    # '+'?† <ndashdigit-ident>
    # In all of these cases, the + is optional, and has no effect.
    # So, we consume the + if it's there.
    if css_syntax.component_value_is_delim(&first, (u32)'+'):
        css_syntax.token_stream_discard_a_token(values)  # +
        # We do *not* skip whitespace here.

    let first_after_plus = css_syntax.token_stream_consume_a_token(values)
    # '+'?† n
    # '+'?† n <signed-integer>
    # '+'?† n ['+' | '-'] <signless-integer>
    if css_syntax.component_value_is_ident(&first_after_plus, ak.sv("n")):
        css_syntax.token_stream_discard_whitespace(values)

        # '+'?† n <signed-integer>
        let next = css_syntax.token_stream_next_token(values)
        if css_anb_is_signed_integer(&next):
            let integer = css_syntax.token_stream_consume_a_token(values)
            let b = css_anb_to_integer(&integer)
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(1, b)

        # '+'?† n ['+' | '-'] <signless-integer>
        if let b = css_anb_parse_sign_and_signless_integer(values, &transaction):
            return css_an_plus_b_pattern(1, b)

        # '+'?† n
        css_syntax.state_transaction_commit(&transaction)
        return css_an_plus_b_pattern(1, 0)

    # '+'?† n- <signless-integer>
    if css_syntax.component_value_is_ident(&first_after_plus, ak.sv("n-")):
        css_syntax.token_stream_discard_whitespace(values)
        let second_value = css_syntax.token_stream_consume_a_token(values)
        if css_anb_is_signless_integer(&second_value):
            let b = -css_anb_to_integer(&second_value)
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(1, b)

        return none

    # '+'?† <ndashdigit-ident>
    if css_anb_is_ndashdigit_ident(&first_after_plus):
        let ident = css_component_value_ident(&first_after_plus)
        let ident_view = ak.fly_string_bytes_as_string_view(&ident)
        let b_view = ak.string_view_substring_view(&ident_view, 1)
        if let b = ak.string_view_to_number_i32(&b_view):
            css_syntax.state_transaction_commit(&transaction)
            return css_an_plus_b_pattern(1, b)

        return none

    return none

# mark: <page-selector-list> ====================================================================

## Ported from Libraries/LibWeb/CSS/Parser/SelectorParsing.cpp:1475 Web::CSS::Parser::Parser::parse_as_page_selector_list.
pub func css_parser_parse_as_page_selector_list(this: CssParser*) -> ak.Vector[CssPageSelector]?:
    let selector_list: ak.Vector[CssPageSelector]? = css_parser_parse_a_page_selector_list(this, &this.m_token_stream) catch:
        recover none
    return selector_list

## `ErrorReporter::the().report(InvalidSelectorError { .rule_name = "@page"_fly_string, ... })`.
func css_report_invalid_page_selector(value_string: ak.String, description: str):
    css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_selector_error(CssInvalidSelectorError(
        rule_name = ak.fly_string_from_str("@page"),
        value_string = value_string,
        description = ak.string_from_str(description),
    )))

## Ported from Libraries/LibWeb/CSS/Parser/SelectorParsing.cpp:1484 Web::CSS::Parser::Parser::parse_a_page_selector_list.
pub func css_parser_parse_a_page_selector_list[T: css_syntax.TokenStreamToken[T]](this: CssParser*, tokens: css_syntax.TokenStream[T]*) -> ak.Vector[CssPageSelector]!:
    _ = this
    # https://drafts.csswg.org/css-page-3/#syntax-page-selector
    # <page-selector-list> = <page-selector>#
    # <page-selector> = [ <ident-token>? <pseudo-page>* ]!
    # <pseudo-page> = : [ left | right | first | blank ]

    var selector_list = ak.Vector[CssPageSelector]()

    css_syntax.token_stream_discard_whitespace(tokens)

    while css_syntax.token_stream_has_next_token(tokens):
        # First optional ident
        var maybe_ident: ak.FlyString? = none
        if css_syntax.token_stream_next_token(tokens).token_stream_is(.ident):
            let ident_token = css_syntax.token_stream_consume_a_token(tokens)
            let token = css_parser_token_from(&ident_token)
            maybe_ident = css_syntax.token_ident(&token)

        # Then an optional series of pseudo-classes
        var pseudo_classes = ak.Vector[CssPagePseudoClass]()
        while css_syntax.token_stream_next_token(tokens).token_stream_is(.colon):
            css_syntax.token_stream_discard_a_token(tokens)  # :
            if not css_syntax.token_stream_next_token(tokens).token_stream_is(.ident):
                css_report_invalid_page_selector(css_syntax.token_stream_dump_string(tokens), "Pseudo-classes must be idents.")
                error(css_parser_parse_error_syntax_error, "")
            let pseudo_class_token = css_syntax.token_stream_consume_a_token(tokens)
            let token = css_parser_token_from(&pseudo_class_token)
            let pseudo_class_name = css_syntax.token_ident(&token)
            if let pseudo_class = css_page_pseudo_class_from_string(ak.fly_string_bytes_as_string_view(&pseudo_class_name)):
                ak.vector_append_t(&pseudo_classes, pseudo_class)
            else:
                css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_unknown_pseudo_class_or_element_error(CssUnknownPseudoClassOrElementError(
                    rule_name = ak.fly_string_from_str("@page"),
                    name = ak.fly_string_from_string(css_pseudo_name_formatted(":{}", ak.fly_string_bytes_as_string_view(&pseudo_class_name))),
                )))
                error(css_parser_parse_error_syntax_error, "")

        if maybe_ident == none and ak.vector_is_empty(&pseudo_classes):
            # Nothing parsed
            css_report_invalid_page_selector(css_syntax.token_stream_dump_string(tokens), "Is empty.")
            error(css_parser_parse_error_syntax_error, "")

        var selector: CssPageSelector = ---
        css_page_selector_construct(&selector, maybe_ident, pseudo_classes)
        ak.vector_append_t(&selector_list, selector)

        css_syntax.token_stream_discard_whitespace(tokens)

        if css_syntax.token_stream_next_token(tokens).token_stream_is(.comma):
            css_syntax.token_stream_discard_a_token(tokens)  # ,
            css_syntax.token_stream_discard_whitespace(tokens)
            if not css_syntax.token_stream_has_next_token(tokens):
                css_report_invalid_page_selector(css_syntax.token_stream_dump_string(tokens), "Trailing comma.")
                error(css_parser_parse_error_syntax_error, "")
        elif css_syntax.token_stream_has_next_token(tokens):
            css_report_invalid_page_selector(css_syntax.token_stream_dump_string(tokens), "Trailing tokens.")
            error(css_parser_parse_error_syntax_error, "")

    return selector_list