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