Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   selector_parsing_3 - parsing selectors: pseudo-elements and simple selectors
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/SelectorParsing.cpp (lines 872-1185): `::pseudo-element`,
#       `::pseudo-element(arguments)` and the legacy single-colon forms, unknown `-webkit-`
#       pseudo-elements, and <simple-selector> (type, universal, class, id, attribute,
#       pseudo-class, pseudo-element and nesting selectors).
#
#       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: Pseudo-elements =========================================================================

## `Selector::PseudoElementSelector { type, value }`.
func css_pseudo_element_selector_create(type_: css_data.PseudoElement, value: CssSelectorPseudoElementSelectorValue) -> CssSelectorPseudoElementSelector:
    var selector: CssSelectorPseudoElementSelector = ---
    css_selector_pseudo_element_selector_construct_css_selector_pseudo_element_se(&selector, type_, value)
    return selector

## `Selector::PseudoElementSelector { type, name, value }`.
func css_pseudo_element_selector_create_named(type_: css_data.PseudoElement, name: ak.String, value: CssSelectorPseudoElementSelectorValue) -> CssSelectorPseudoElementSelector:
    var selector: CssSelectorPseudoElementSelector = ---
    css_selector_pseudo_element_selector_construct_string(&selector, type_, name, value)
    return selector

## A SimpleSelector holding a pseudo-element selector.
func css_pseudo_element_simple_selector(pseudo_element: CssSelectorPseudoElementSelector) -> CssSelectorSimpleSelector:
    return CssSelectorSimpleSelector(
        type_ = CssSelectorSimpleSelectorType.pseudo_element,
        value = CssSelectorSimpleSelectorValue.css_selector_pseudo_element_selector(pseudo_element),
    )

## Ported from Libraries/LibWeb/CSS/Parser/SelectorParsing.cpp:872 Web::CSS::Parser::Parser::parse_pseudo_element_simple_selector.
pub func css_parser_parse_pseudo_element_simple_selector(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssSelectorSimpleSelector!:
    if css_peek_token_ends_selector(tokens):
        error(css_parser_parse_error_syntax_error, "")

    let colon = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is(&colon, .colon):
        error(css_parser_parse_error_syntax_error, "")
    # A few pseudo-elements are allowed to have a single colon, like a pseudo-class.
    let second_colon = css_syntax.token_stream_next_token(tokens)
    let started_with_double_colon = css_syntax.component_value_is(&second_colon, .colon)
    if started_with_double_colon:
        css_syntax.token_stream_discard_a_token(tokens)  # :

    let name_token = css_syntax.token_stream_consume_a_token(tokens)
    var is_function = false
    var pseudo_name = ak.fly_string_new()

    if css_syntax.component_value_is(&name_token, .ident):
        pseudo_name = css_component_value_ident(&name_token)
    elif css_syntax.component_value_is_function(&name_token):
        pseudo_name = css_syntax.component_value_function(&name_token).name
        is_function = true
    else:
        let name_token_debug_string = css_syntax.component_value_to_debug_string(&name_token)
        css_report_invalid_selector(css_syntax.component_value_to_string(&name_token),
                                    css_string_formatted("Pseudo-element should be an ident or function, got: '{}'", [css_arg_string(&name_token_debug_string)]))
        error(css_parser_parse_error_syntax_error, "")
    let pseudo_name_view = ak.fly_string_bytes_as_string_view(&pseudo_name)

    var is_aliased_pseudo = false
    var maybe_pseudo_element = css_data.pseudo_element_from_string(pseudo_name_view)
    if maybe_pseudo_element == none:
        maybe_pseudo_element = css_data.aliased_pseudo_element_from_string(pseudo_name_view)
        is_aliased_pseudo = maybe_pseudo_element != none

    if let pseudo_element = maybe_pseudo_element:
        # :has() is fussy about pseudo-elements inside it
        if ak.vector_contains_slow[css_data.PseudoClass, css_data.PseudoClassTraits](&this.m_pseudo_class_context, css_data.PseudoClass.has) and not css_data.is_has_allowed_pseudo_element(pseudo_element):
            error(css_parser_parse_error_syntax_error, "")

        # Support legacy single-colon syntax for some older pseudo-elements.
        if not started_with_double_colon:
            if css_is_legacy_single_colon_pseudo_element(pseudo_element):
                return css_pseudo_element_simple_selector(css_pseudo_element_selector_create(pseudo_element, CssSelectorPseudoElementSelectorValue.empty))
            css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                       "This is not a legacy pseudo-element.")
            error(css_parser_parse_error_syntax_error, "")

        let metadata = css_data.pseudo_element_metadata(pseudo_element)

        var value = CssSelectorPseudoElementSelectorValue.empty
        if is_function:
            if not metadata.is_valid_as_function:
                css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                           "Not valid as a function.")
                error(css_parser_parse_error_syntax_error, "")

            # Parse arguments
            let function = css_syntax.component_value_function(&name_token)
            var function_tokens = css_syntax.token_stream_create(function.value)
            css_syntax.token_stream_discard_whitespace(&function_tokens)

            match metadata.parameter_type:
                .none_:
                    if css_syntax.token_stream_has_next_token(&function_tokens):
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                                   "Should have no arguments.")
                        error(css_parser_parse_error_syntax_error, "")
                .compound_selector:
                    var compound_selector = css_parser_parse_compound_selector(this, &function_tokens) catch:
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                                   "Failed to parse argument as a compound selector.")
                        error(css_parser_parse_error_syntax_error, "")
                    css_syntax.token_stream_discard_whitespace(&function_tokens)
                    if css_syntax.token_stream_has_next_token(&function_tokens):
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                                   "Trailing tokens after compound selector argument.")
                        error(css_parser_parse_error_syntax_error, "")

                    compound_selector.combinator = CssSelectorCombinator.none_
                    var compound_selectors = ak.Vector[CssSelectorCompoundSelector]()
                    ak.vector_append_t(&compound_selectors, compound_selector)
                    value = CssSelectorPseudoElementSelectorValue.css_selector(css_selector_create(compound_selectors))
                .ident_list:
                    # <ident>+
                    var idents = ak.Vector[ak.FlyString]()
                    while css_syntax.token_stream_has_next_token(&function_tokens):
                        let next = css_syntax.token_stream_next_token(&function_tokens)
                        if not css_syntax.component_value_is(&next, .ident):
                            css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                                       "Contains invalid <ident>.")
                            error(css_parser_parse_error_syntax_error, "")
                        let ident_token = css_syntax.token_stream_consume_a_token(&function_tokens)
                        ak.vector_append_t(&idents, css_component_value_ident(&ident_token))
                        css_syntax.token_stream_discard_whitespace(&function_tokens)
                    value = CssSelectorPseudoElementSelectorValue.vector_fly_string(idents)
                .pt_name_selector:
                    # <pt-name-selector> = '*' | <custom-ident>
                    # https://drafts.csswg.org/css-view-transitions-1/#typedef-pt-name-selector
                    let next = css_syntax.token_stream_next_token(&function_tokens)
                    var no_blacklist: const ak.StringView[]
                    if css_syntax.component_value_is_delim(&next, (u32)'*'):
                        css_syntax.token_stream_discard_a_token(&function_tokens)  # *
                        value = CssSelectorPseudoElementSelectorValue.css_selector_pseudo_element_selector_pt_name_selector(
                            CssSelectorPseudoElementSelectorPtNameSelector(is_universal = true, value = ak.fly_string_new()))
                    elif let custom_ident = css_parser_parse_custom_ident(this, &function_tokens, no_blacklist):
                        value = CssSelectorPseudoElementSelectorValue.css_selector_pseudo_element_selector_pt_name_selector(
                            CssSelectorPseudoElementSelectorPtNameSelector(is_universal = false, value = custom_ident))
                    else:
                        let following = css_syntax.token_stream_next_token(&function_tokens)
                        let following_string = css_syntax.component_value_to_debug_string(&following)
                        css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_pseudo_class_or_element_error(CssInvalidPseudoClassOrElementError(
                            name = ak.fly_string_from_string(css_pseudo_name_formatted("::{}", pseudo_name_view)),
                            value_string = css_syntax.component_value_to_string(&name_token),
                            description = css_string_formatted("Invalid <pt-name-selector> - expected `*` or `<custom-ident>`, got `{}`", [css_arg_string(&following_string)]),
                        )))
                        error(css_parser_parse_error_syntax_error, "")
                    css_syntax.token_stream_discard_whitespace(&function_tokens)
                    if css_syntax.token_stream_has_next_token(&function_tokens):
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                                   "Invalid <pt-name-selector> - trailing tokens.")
                        error(css_parser_parse_error_syntax_error, "")
                _:
                    trap("VERIFY_NOT_REACHED")
        else:
            if not metadata.is_valid_as_identifier:
                css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view), css_syntax.component_value_to_string(&name_token),
                                                           "Only valid as a function.")
                error(css_parser_parse_error_syntax_error, "")

        # NB: Aliased pseudo-elements behave like their target pseudo-element, but serialize as themselves. So store
        #     their name like we do for unknown -webkit pseudos below.
        if is_aliased_pseudo:
            let name = ak.fly_string_to_string_const_2(&pseudo_name)
            return css_pseudo_element_simple_selector(css_pseudo_element_selector_create_named(pseudo_element, ak.string_to_ascii_lowercase(&name), value))

        return css_pseudo_element_simple_selector(css_pseudo_element_selector_create(pseudo_element, value))

    # https://drafts.csswg.org/selectors-4/#compat
    # All other pseudo-elements whose names begin with the string “-webkit-” (matched ASCII case-insensitively)
    # and that are not functional notations must be treated as valid at parse time. (That is, ::-webkit-asdf is
    # valid at parse time, but ::-webkit-jkl() is not.) If they’re not otherwise recognized and supported, they
    # must be treated as matching nothing, and are unknown -webkit- pseudo-elements.
    if not is_function and ak.fly_string_starts_with_bytes(&pseudo_name, ak.sv("-webkit-"), ak.CaseSensitivity.case_insensitive):
        # NB: :has() only allows a limited set of pseudo-elements inside it, which doesn't include unknown ones.
        if ak.vector_contains_slow[css_data.PseudoClass, css_data.PseudoClassTraits](&this.m_pseudo_class_context, css_data.PseudoClass.has):
            error(css_parser_parse_error_syntax_error, "")

        # Unknown -webkit- pseudo-elements must be serialized in ASCII lowercase.
        let name = ak.fly_string_to_string_const_2(&pseudo_name)
        return css_pseudo_element_simple_selector(css_pseudo_element_selector_create_named(css_data.PseudoElement.unknown_web_kit, ak.string_to_ascii_lowercase(&name),
                                                                                           CssSelectorPseudoElementSelectorValue.empty))

    if css_parser_has_ignored_vendor_prefix(pseudo_name_view):
        error(css_parser_parse_error_includes_ignored_vendor_prefix, "")

    css_report_unknown_pseudo_class_or_element(css_pseudo_name_formatted("::{}", pseudo_name_view))
    error(css_parser_parse_error_syntax_error, "")

# mark: <simple-selector> =======================================================================

## `value.is_block() && value.block().is_square()`.
func css_component_value_is_square_block(value: const css_syntax.ComponentValue*) -> bool:
    if not css_syntax.component_value_is_block(value):
        return false
    let block = css_syntax.component_value_block(value)
    return css_syntax.simple_block_is_square(&block)

## Ported from Libraries/LibWeb/CSS/Parser/SelectorParsing.cpp:1087 Web::CSS::Parser::Parser::parse_simple_selector.
pub func css_parser_parse_simple_selector(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> (CssSelectorSimpleSelector?)!:
    if css_peek_token_ends_selector(tokens):
        return none

    # Handle universal and tag-name types together, since both can be namespaced
    if let qualified_name = css_parser_parse_selector_qualified_name(this, tokens, CssParserAllowWildcardName.yes):
        if ak.fly_string_eq_string_view(&qualified_name.name.name, ak.sv("*")):
            return CssSelectorSimpleSelector(
                type_ = CssSelectorSimpleSelectorType.universal,
                value = CssSelectorSimpleSelectorValue.css_selector_simple_selector_qualified_name(qualified_name),
            )
        return CssSelectorSimpleSelector(
            type_ = CssSelectorSimpleSelectorType.tag_name,
            value = CssSelectorSimpleSelectorValue.css_selector_simple_selector_qualified_name(qualified_name),
        )

    if css_next_is_pseudo_element(tokens):
        return try css_parser_parse_pseudo_element_simple_selector(this, tokens)

    let next = css_syntax.token_stream_next_token(tokens)
    if css_syntax.component_value_is(&next, .colon):
        return try css_parser_parse_pseudo_class_simple_selector(this, tokens)

    if css_syntax.component_value_is(&next, .delim):
        let next_token = css_syntax.component_value_token(&next)
        let delim = (u8)css_syntax.token_delim(&next_token)
        if delim == '>' or delim == '+' or delim == '~' or delim == '|':
            # Whitespace is not required between the compound-selector and a combinator.
            # So, if we see a combinator, return that this compound-selector is done, instead of a syntax error.
            return none

    let first_value = css_syntax.token_stream_consume_a_token(tokens)

    if css_syntax.component_value_is(&first_value, .delim):
        let first_token = css_syntax.component_value_token(&first_value)
        let delim = css_syntax.token_delim(&first_token)
        match delim:
            0x2a:  # '*'
                # Handled already
                trap("VERIFY_NOT_REACHED")
            0x26:  # '&'
                return CssSelectorSimpleSelector(type_ = CssSelectorSimpleSelectorType.nesting, value = CssSelectorSimpleSelectorValue.empty)
            0x2e:  # '.'
                if css_peek_token_ends_selector(tokens):
                    error(css_parser_parse_error_syntax_error, "")

                let class_name_value = css_syntax.token_stream_consume_a_token(tokens)
                if not css_syntax.component_value_is(&class_name_value, .ident):
                    let class_name_string = css_syntax.component_value_to_debug_string(&class_name_value)
                    css_report_invalid_selector(css_syntax.token_stream_dump_string(tokens),
                                                css_string_formatted("Expected an ident after '.', got: {}", [css_arg_string(&class_name_string)]))
                    error(css_parser_parse_error_syntax_error, "")
                return CssSelectorSimpleSelector(
                    type_ = CssSelectorSimpleSelectorType.class_,
                    value = CssSelectorSimpleSelectorValue.css_selector_simple_selector_name(css_selector_simple_selector_name_create(css_component_value_ident(&class_name_value))),
                )
            _:
                let token_string = css_syntax.token_to_string(&first_token)
                css_report_invalid_selector(css_syntax.token_stream_dump_string(tokens), css_string_formatted("Unrecognized delimiter: {}", [css_arg_string(&token_string)]))
                error(css_parser_parse_error_syntax_error, "")

    if css_syntax.component_value_is(&first_value, .hash_):
        let hash_token = css_syntax.component_value_token(&first_value)
        if css_syntax.token_hash_type(&hash_token) != css_syntax.TokenHashType.id:
            let first_value_string = css_syntax.component_value_to_debug_string(&first_value)
            css_report_invalid_selector(css_syntax.token_stream_dump_string(tokens), css_string_formatted("Hash token is not an id: {}", [css_arg_string(&first_value_string)]))
            error(css_parser_parse_error_syntax_error, "")
        return CssSelectorSimpleSelector(
            type_ = CssSelectorSimpleSelectorType.id,
            value = CssSelectorSimpleSelectorValue.css_selector_simple_selector_name(css_selector_simple_selector_name_create(css_syntax.token_hash_value(&hash_token))),
        )

    if css_component_value_is_square_block(&first_value):
        return try css_parser_parse_attribute_simple_selector(this, first_value)

    let first_value_string = css_syntax.component_value_to_debug_string(&first_value)
    css_report_invalid_selector(css_syntax.token_stream_dump_string(tokens), css_string_formatted("Invalid start of a simple selector: {}", [css_arg_string(&first_value_string)]))
    error(css_parser_parse_error_syntax_error, "")