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