Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

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

#==============================================================================================
#
#   selector_parsing_2 - parsing selectors: attribute selectors and pseudo-classes
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/Parser/SelectorParsing.cpp (lines 390-870): `[attr op value i]`
#       and `:pseudo-class` / `:pseudo-class(arguments)`, with each kind of argument the
#       pseudo-class metadata names (An+B, An+B of <selector-list>, compound selectors,
#       (forgiving) selector lists, idents, language ranges, levels).
#
#       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: Attribute selectors =====================================================================

## The `parse_attribute_match_type` lambda of parse_attribute_simple_selector: one of `=`, `~=`,
## `*=`, `|=`, `^=`, `$=`.
func css_parser_parse_attribute_match_type(first_value: const css_syntax.ComponentValue*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssSelectorSimpleSelectorAttributeMatchType!:
    # This is one of: `=`, `~=`, `*=`, `|=`, `^=`, `$=`
    var transaction = css_syntax.token_stream_begin_transaction(tokens)
    defer css_syntax.state_transaction_destroy(&transaction)

    let first_delim = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is(&first_delim, .delim):
        let first_delim_string = css_syntax.component_value_to_debug_string(&first_delim)
        css_report_invalid_selector(css_syntax.component_value_to_string(first_value),
                                    css_string_formatted("Expected delim for attribute comparison, got: '{}'.", [css_arg_string(&first_delim_string)]))
        error(css_parser_parse_error_syntax_error, "")

    let first_delim_token = css_syntax.component_value_token(&first_delim)
    if css_syntax.token_delim(&first_delim_token) == (u32)'=':
        css_syntax.state_transaction_commit(&transaction)
        return CssSelectorSimpleSelectorAttributeMatchType.exact_value_match

    if not css_syntax.token_stream_has_next_token(tokens):
        css_report_invalid_selector(css_syntax.component_value_to_string(first_value), ak.string_from_str("Attribute selector ended part way through a match type."))
        error(css_parser_parse_error_syntax_error, "")

    let second_delim = css_syntax.token_stream_consume_a_token(tokens)
    if not css_syntax.component_value_is_delim(&second_delim, (u32)'='):
        let first_delim_string = css_syntax.component_value_to_debug_string(&first_delim)
        let second_delim_string = css_syntax.component_value_to_debug_string(&second_delim)
        css_report_invalid_selector(css_syntax.component_value_to_string(first_value),
                                    css_string_formatted("Expected a double delim for attribute comparison, got: '{}{}'.",
                                                         [css_arg_string(&first_delim_string), css_arg_string(&second_delim_string)]))
        error(css_parser_parse_error_syntax_error, "")
    match css_syntax.token_delim(&first_delim_token):
        0x7e:  # '~'
            css_syntax.state_transaction_commit(&transaction)
            return CssSelectorSimpleSelectorAttributeMatchType.contains_word
        0x2a:  # '*'
            css_syntax.state_transaction_commit(&transaction)
            return CssSelectorSimpleSelectorAttributeMatchType.contains_string
        0x7c:  # '|'
            css_syntax.state_transaction_commit(&transaction)
            return CssSelectorSimpleSelectorAttributeMatchType.starts_with_segment
        0x5e:  # '^'
            css_syntax.state_transaction_commit(&transaction)
            return CssSelectorSimpleSelectorAttributeMatchType.starts_with_string
        0x24:  # '$'
            css_syntax.state_transaction_commit(&transaction)
            return CssSelectorSimpleSelectorAttributeMatchType.ends_with_string
        _:
            css_report_invalid_selector(css_syntax.component_value_to_string(first_value),
                                        css_string_formatted("Invalid attribute selector match type `{:c}=`", [ak.arg_u64((u64)css_syntax.token_delim(&first_delim_token))]))
            error(css_parser_parse_error_syntax_error, "")

## A SimpleSelector holding an attribute selector.
func css_attribute_simple_selector(attribute: CssSelectorSimpleSelectorAttribute) -> CssSelectorSimpleSelector:
    return CssSelectorSimpleSelector(
        type_ = CssSelectorSimpleSelectorType.attribute,
        value = CssSelectorSimpleSelectorValue.css_selector_simple_selector_attribute(attribute),
    )

## Ported from Libraries/LibWeb/CSS/Parser/SelectorParsing.cpp:390 Web::CSS::Parser::Parser::parse_attribute_simple_selector.
pub func css_parser_parse_attribute_simple_selector(this: CssParser*, first_value: css_syntax.ComponentValue) -> CssSelectorSimpleSelector!:
    let block = css_syntax.component_value_block(&first_value)
    var attribute_tokens = css_syntax.token_stream_create(block.value)

    css_syntax.token_stream_discard_whitespace(&attribute_tokens)

    if not css_syntax.token_stream_has_next_token(&attribute_tokens):
        css_report_invalid_selector(css_syntax.component_value_to_string(&first_value), ak.string_from_str("Attribute selector is empty."))
        error(css_parser_parse_error_syntax_error, "")

    let maybe_qualified_name = css_parser_parse_selector_qualified_name(this, &attribute_tokens, CssParserAllowWildcardName.no)
    if maybe_qualified_name == none:
        let next = css_syntax.token_stream_next_token(&attribute_tokens)
        let next_string = css_syntax.component_value_to_debug_string(&next)
        css_report_invalid_selector(css_syntax.component_value_to_string(&first_value),
                                    css_string_formatted("Expected qualified-name, got: '{}'.", [css_arg_string(&next_string)]))
        error(css_parser_parse_error_syntax_error, "")
    let qualified_name = maybe_qualified_name else trap("VERIFY: a qualified name")

    # The attribute of the simple selector; the C++ builds the SimpleSelector first and then changes
    # its `attribute()` in place.
    var attribute = CssSelectorSimpleSelectorAttribute(
        match_type = CssSelectorSimpleSelectorAttributeMatchType.has_attribute,
        qualified_name = qualified_name,
        value = ak.string_new(),
        case_type = CssSelectorSimpleSelectorAttributeCaseType.default_match,
    )

    css_syntax.token_stream_discard_whitespace(&attribute_tokens)
    if not css_syntax.token_stream_has_next_token(&attribute_tokens):
        return css_attribute_simple_selector(attribute)

    attribute.match_type = try css_parser_parse_attribute_match_type(&first_value, &attribute_tokens)

    css_syntax.token_stream_discard_whitespace(&attribute_tokens)
    if not css_syntax.token_stream_has_next_token(&attribute_tokens):
        css_report_invalid_selector(css_syntax.component_value_to_string(&first_value), ak.string_from_str("Attribute selector ended without a value to match."))
        error(css_parser_parse_error_syntax_error, "")

    let value_part = css_syntax.token_stream_consume_a_token(&attribute_tokens)
    if not css_syntax.component_value_is(&value_part, .ident) and not css_syntax.component_value_is(&value_part, .string):
        let value_part_string = css_syntax.component_value_to_debug_string(&value_part)
        css_report_invalid_selector(css_syntax.component_value_to_string(&first_value),
                                    css_string_formatted("Expected a string or ident for the value to match attribute against, got: '{}'.",
                                                         [css_arg_string(&value_part_string)]))
        error(css_parser_parse_error_syntax_error, "")
    let value_token = css_syntax.component_value_token(&value_part)
    let value_string = css_syntax.token_ident(&value_token) if css_syntax.token_is(&value_token, .ident) else css_syntax.token_string(&value_token)
    attribute.value = ak.fly_string_to_string_const_2(&value_string)

    css_syntax.token_stream_discard_whitespace(&attribute_tokens)
    # Handle case-sensitivity suffixes. https://www.w3.org/TR/selectors-4/#attribute-case
    if css_syntax.token_stream_has_next_token(&attribute_tokens):
        let case_sensitivity_part = css_syntax.token_stream_consume_a_token(&attribute_tokens)
        if css_syntax.component_value_is(&case_sensitivity_part, .ident):
            let case_sensitivity = css_component_value_ident(&case_sensitivity_part)
            if ak.fly_string_equals_ignoring_ascii_case_string_view(&case_sensitivity, ak.sv("i")):
                attribute.case_type = CssSelectorSimpleSelectorAttributeCaseType.case_insensitive_match
            elif ak.fly_string_equals_ignoring_ascii_case_string_view(&case_sensitivity, ak.sv("s")):
                attribute.case_type = CssSelectorSimpleSelectorAttributeCaseType.case_sensitive_match
            else:
                let part_string = css_syntax.component_value_to_debug_string(&case_sensitivity_part)
                css_report_invalid_selector(css_syntax.component_value_to_string(&first_value),
                                            css_string_formatted("Expected a \"i\" or \"s\" attribute selector case sensitivity identifier, got: '{}'.",
                                                                 [css_arg_string(&part_string)]))
                error(css_parser_parse_error_syntax_error, "")
        else:
            let part_string = css_syntax.component_value_to_debug_string(&case_sensitivity_part)
            css_report_invalid_selector(css_syntax.component_value_to_string(&first_value),
                                        css_string_formatted("Expected an attribute selector case sensitivity identifier, got: '{}'", [css_arg_string(&part_string)]))
            error(css_parser_parse_error_syntax_error, "")

    css_syntax.token_stream_discard_whitespace(&attribute_tokens)

    if css_syntax.token_stream_has_next_token(&attribute_tokens):
        css_report_invalid_selector(css_syntax.component_value_to_string(&first_value), ak.string_from_str("Trailing tokens in attribute selector."))
        error(css_parser_parse_error_syntax_error, "")

    return css_attribute_simple_selector(attribute)

# mark: Pseudo-classes ==========================================================================

## The `peek_token_ends_selector` lambda of the simple-selector parsers.
func css_peek_token_ends_selector(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> bool:
    let value = css_syntax.token_stream_next_token(tokens)
    return css_syntax.component_value_is(&value, .end_of_file) or css_syntax.component_value_is(&value, .whitespace) or css_syntax.component_value_is(&value, .comma)

## `ErrorReporter::the().report(InvalidPseudoClassOrElementError { ... })`.
func css_report_invalid_pseudo_class_or_element(name: ak.String, value_string: ak.String, description: str):
    css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_pseudo_class_or_element_error(CssInvalidPseudoClassOrElementError(
        name = ak.fly_string_from_string(name),
        value_string = value_string,
        description = ak.string_from_str(description),
    )))

## `ErrorReporter::the().report(UnknownPseudoClassOrElementError { .name = ... })` with the default rule name, "style".
func css_report_unknown_pseudo_class_or_element(name: ak.String):
    css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_unknown_pseudo_class_or_element_error(CssUnknownPseudoClassOrElementError(
        rule_name = ak.fly_string_from_str("style"),
        name = ak.fly_string_from_string(name),
    )))

## `MUST(String::formatted(fmtstr, name))` for a pseudo-class or -element name.
func css_pseudo_name_formatted(fmtstr: str, name: ak.StringView) -> ak.String:
    return css_string_formatted(fmtstr, [ak.arg_string_view(name)])

## `value.token().is_integer()`.
func css_component_value_is_integer(value: const css_syntax.ComponentValue*) -> bool:
    let token = css_syntax.component_value_token(value)
    return css_syntax.token_is_integer(&token)

## A SimpleSelector holding a pseudo-class selector.
func css_pseudo_class_simple_selector(pseudo_class: CssSelectorSimpleSelectorPseudoClassSelector) -> CssSelectorSimpleSelector:
    return CssSelectorSimpleSelector(
        type_ = CssSelectorSimpleSelectorType.pseudo_class,
        value = CssSelectorSimpleSelectorValue.css_selector_simple_selector_pseudo_class_selector(pseudo_class),
    )

## The `parse_an_plus_b_selector` lambda of parse_pseudo_class_simple_selector: `An+B` or, when
## allowed, `An+B of <selector-list>`.
func css_parser_parse_an_plus_b_selector(this: CssParser*, pseudo_class: css_data.PseudoClass, function_values: const ak.Vector[css_syntax.ComponentValue]*, allow_of: bool = false) -> CssSelectorSimpleSelector!:
    var tokens = css_syntax.token_stream_create(*function_values)
    let maybe_an_plus_b_pattern = css_parser_parse_a_n_plus_b_pattern(this, &tokens)
    if maybe_an_plus_b_pattern == none:
        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", css_data.pseudo_class_name(pseudo_class)),
                                                   css_syntax.token_stream_dump_string(&tokens), "Invalid An+B format.")
        error(css_parser_parse_error_syntax_error, "")
    let an_plus_b_pattern = maybe_an_plus_b_pattern else trap("VERIFY: an An+B pattern")

    css_syntax.token_stream_discard_whitespace(&tokens)
    if not css_syntax.token_stream_has_next_token(&tokens):
        return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(type_ = pseudo_class, an_plus_b_pattern = an_plus_b_pattern))

    if not allow_of:
        error(css_parser_parse_error_syntax_error, "")

    # Parse the `of <selector-list>` syntax
    let maybe_of = css_syntax.token_stream_consume_a_token(&tokens)
    if not css_syntax.component_value_is_ident(&maybe_of, ak.sv("of")):
        error(css_parser_parse_error_syntax_error, "")

    css_syntax.token_stream_discard_whitespace(&tokens)
    let selector_list = try css_parser_parse_a_selector_list(this, &tokens, CssParserSelectorType.standalone)

    css_syntax.token_stream_discard_whitespace(&tokens)
    if css_syntax.token_stream_has_next_token(&tokens):
        error(css_parser_parse_error_syntax_error, "")

    return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(
        type_ = pseudo_class,
        an_plus_b_pattern = an_plus_b_pattern,
        argument_selector_list = selector_list,
    ))

## Ported from Libraries/LibWeb/CSS/Parser/SelectorParsing.cpp:547 Web::CSS::Parser::Parser::parse_pseudo_class_simple_selector.
pub func css_parser_parse_pseudo_class_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, "")

    if css_peek_token_ends_selector(tokens):
        error(css_parser_parse_error_syntax_error, "")

    let next = css_syntax.token_stream_next_token(tokens)
    if css_syntax.component_value_is(&next, .ident):
        let pseudo_name_token = css_syntax.token_stream_consume_a_token(tokens)
        let pseudo_name = css_component_value_ident(&pseudo_name_token)
        let pseudo_name_view = ak.fly_string_bytes_as_string_view(&pseudo_name)

        if let pseudo_class = css_data.pseudo_class_from_string(pseudo_name_view):
            if not css_data.pseudo_class_metadata(pseudo_class).is_valid_as_identifier:
                css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", pseudo_name_view),
                                                           ak.fly_string_to_string_const_2(&pseudo_name), "Only valid as a function.")
                error(css_parser_parse_error_syntax_error, "")

            return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(type_ = pseudo_class))

        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, "")

    if css_syntax.component_value_is_function(&next):
        let pseudo_function_value = css_syntax.token_stream_consume_a_token(tokens)
        let pseudo_function = css_syntax.component_value_function(&pseudo_function_value)
        let function_name = ak.fly_string_bytes_as_string_view(&pseudo_function.name)
        let maybe_pseudo_class = css_data.pseudo_class_from_string(function_name)
        if maybe_pseudo_class == none:
            css_report_unknown_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name))
            error(css_parser_parse_error_syntax_error, "")
        let pseudo_class = maybe_pseudo_class else trap("VERIFY: a pseudo-class")
        let metadata = css_data.pseudo_class_metadata(pseudo_class)

        if not metadata.is_valid_as_function:
            css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                       ak.fly_string_to_string_const_2(&pseudo_function.name), "Not valid as a function.")
            error(css_parser_parse_error_syntax_error, "")

        if ak.vector_is_empty(&pseudo_function.value):
            css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                       ak.fly_string_to_string_const_2(&pseudo_function.name), "Missing arguments.")
            error(css_parser_parse_error_syntax_error, "")

        # "The :has() pseudo-class cannot be nested; :has() is not valid within :has()."
        # https://drafts.csswg.org/selectors/#relational
        if pseudo_class == css_data.PseudoClass.has and ak.vector_contains_slow[css_data.PseudoClass, css_data.PseudoClassTraits](&this.m_pseudo_class_context, css_data.PseudoClass.has):
            css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                       ak.fly_string_to_string_const_2(&pseudo_function.name), ":has() is not allowed inside :has().")
            error(css_parser_parse_error_syntax_error, "")

        ak.vector_append_t(&this.m_pseudo_class_context, pseudo_class)
        defer _ = ak.vector_take_last(&this.m_pseudo_class_context)

        match metadata.parameter_type:
            .an_plus_b:
                return try css_parser_parse_an_plus_b_selector(this, pseudo_class, &pseudo_function.value, false)
            .an_plus_b_of:
                return try css_parser_parse_an_plus_b_selector(this, pseudo_class, &pseudo_function.value, true)
            .compound_selector:
                var function_token_stream = css_syntax.token_stream_create(pseudo_function.value)
                var compound_selector = css_parser_parse_compound_selector(this, &function_token_stream) catch:
                    css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                               ak.fly_string_to_string_const_2(&pseudo_function.name), "Failed to parse argument as a compound selector.")
                    error(css_parser_parse_error_syntax_error, "")
                css_syntax.token_stream_discard_whitespace(&function_token_stream)
                if css_syntax.token_stream_has_next_token(&function_token_stream):
                    css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted("::{}", function_name),
                                                               ak.fly_string_to_string_const_2(&pseudo_function.name), "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)
                let selector = css_selector_create(compound_selectors)

                var argument_selector_list = ak.Vector[CssSelector*]()
                ak.vector_append_t(&argument_selector_list, selector)
                return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(type_ = pseudo_class, argument_selector_list = argument_selector_list))
            .forgiving_relative_selector_list, .forgiving_selector_list:
                var function_token_stream = css_syntax.token_stream_create(pseudo_function.value)
                var selector_type = CssParserSelectorType.relative
                if metadata.parameter_type == css_data.PseudoClassMetadataParameterType.forgiving_selector_list:
                    selector_type = CssParserSelectorType.standalone
                # NOTE: Because it's forgiving, even complete garbage will parse OK as an empty selector-list.
                let argument_selector_list = css_parser_parse_a_selector_list(this, &function_token_stream, selector_type, CssParserSelectorParsingMode.forgiving) else trap("MUST: a forgiving selector list")

                return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(
                    type_ = pseudo_class,
                    is_forgiving = true,
                    argument_selector_list = argument_selector_list,
                ))
            .ident:
                var function_token_stream = css_syntax.token_stream_create(pseudo_function.value)
                css_syntax.token_stream_discard_whitespace(&function_token_stream)
                let maybe_ident_token = css_syntax.token_stream_consume_a_token(&function_token_stream)
                css_syntax.token_stream_discard_whitespace(&function_token_stream)
                if not css_syntax.component_value_is(&maybe_ident_token, .ident) or css_syntax.token_stream_has_next_token(&function_token_stream):
                    css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                               ak.fly_string_to_string_const_2(&pseudo_function.name), "Failed to parse argument as an ident.")
                    error(css_parser_parse_error_syntax_error, "")

                let ident = css_component_value_ident(&maybe_ident_token)

                return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(
                    type_ = pseudo_class,
                    ident = CssSelectorSimpleSelectorPseudoClassSelectorIdent(
                        keyword = css_data.keyword_from_string(ak.fly_string_bytes_as_string_view(&ident)) else css_data.Keyword.invalid,
                        string_value = ident,
                    ),
                ))
            .language_ranges:
                var languages = ak.Vector[ak.FlyString]()
                var function_token_stream = css_syntax.token_stream_create(pseudo_function.value)
                let language_token_lists = css_parser_parse_a_comma_separated_list_of_component_values(this, &function_token_stream)

                for language_token_list in ak.vector_span_const(&language_token_lists):
                    var language_token_stream = css_syntax.token_stream_create(language_token_list)
                    css_syntax.token_stream_discard_whitespace(&language_token_stream)
                    let language_token = css_syntax.token_stream_consume_a_token(&language_token_stream)
                    if not (css_syntax.component_value_is(&language_token, .ident) or css_syntax.component_value_is(&language_token, .string)):
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                                   ak.fly_string_to_string_const_2(&pseudo_function.name),
                                                                   "Failed to parse argument as a language range: Not a string/ident.")
                        error(css_parser_parse_error_syntax_error, "")

                    let token = css_syntax.component_value_token(&language_token)
                    let language_string = css_syntax.token_string(&token) if css_syntax.token_is(&token, .string) else css_syntax.token_ident(&token)
                    ak.vector_append_t(&languages, language_string)

                    css_syntax.token_stream_discard_whitespace(&language_token_stream)
                    if css_syntax.token_stream_has_next_token(&language_token_stream):
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                                   ak.fly_string_to_string_const_2(&pseudo_function.name),
                                                                   "Failed to parse argument as a language range: Has trailing tokens.")
                        error(css_parser_parse_error_syntax_error, "")

                return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(type_ = pseudo_class, languages = languages))
            .level_list:
                # https://drafts.csswg.org/selectors-5/#heading-functional-pseudo
                # :heading() = :heading( <level># )
                # where <level> is a <number-token> with its type flag set to "integer".
                var levels = ak.Vector[i64]()
                var function_token_stream = css_syntax.token_stream_create(pseudo_function.value)
                let level_lists = css_parser_parse_a_comma_separated_list_of_component_values(this, &function_token_stream)

                for level_tokens in ak.vector_span_const(&level_lists):
                    var level_token_stream = css_syntax.token_stream_create(level_tokens)
                    css_syntax.token_stream_discard_whitespace(&level_token_stream)
                    let maybe_integer = css_syntax.token_stream_consume_a_token(&level_token_stream)
                    css_syntax.token_stream_discard_whitespace(&level_token_stream)

                    if not css_syntax.component_value_is(&maybe_integer, .number) or not css_component_value_is_integer(&maybe_integer):
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                                   ak.fly_string_to_string_const_2(&pseudo_function.name),
                                                                   "Failed to parse argument as a <level>: Not an <integer> literal.")
                        error(css_parser_parse_error_syntax_error, "")

                    if css_syntax.token_stream_has_next_token(&level_token_stream):
                        css_report_invalid_pseudo_class_or_element(css_pseudo_name_formatted(":{}", function_name),
                                                                   ak.fly_string_to_string_const_2(&pseudo_function.name),
                                                                   "Failed to parse argument as a <level>: Has trailing tokens.")
                        error(css_parser_parse_error_syntax_error, "")

                    let integer_token = css_syntax.component_value_token(&maybe_integer)
                    ak.vector_append_t(&levels, (i64)css_syntax.token_to_integer(&integer_token))

                return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(type_ = pseudo_class, levels = levels))
            .relative_selector_list, .selector_list:
                var function_token_stream = css_syntax.token_stream_create(pseudo_function.value)
                var selector_type = CssParserSelectorType.relative
                if metadata.parameter_type == css_data.PseudoClassMetadataParameterType.selector_list:
                    selector_type = CssParserSelectorType.standalone
                let not_selector = try css_parser_parse_a_selector_list(this, &function_token_stream, selector_type)

                return css_pseudo_class_simple_selector(CssSelectorSimpleSelectorPseudoClassSelector(type_ = pseudo_class, argument_selector_list = not_selector))
            .none_:
                # `None` means this is not a function-type pseudo-class, so this state should be impossible.
                trap("VERIFY_NOT_REACHED")
            _:
                trap("VERIFY_NOT_REACHED")

    let next_string = css_syntax.component_value_to_string(&next)
    let next_debug_string = css_syntax.component_value_to_debug_string(&next)
    css_report_invalid_selector(next_string, css_string_formatted("Pseudo-class should be an ident or function, got: '{}'", [css_arg_string(&next_debug_string)]))
    error(css_parser_parse_error_syntax_error, "")