dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / 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, "")