dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / css / parser / media_parsing_1.lucb
#==============================================================================================
#
# media_parsing_1 - parsing media queries: query lists, <media-query>, <media-condition>
# and <media-feature>
#
# DESCRIPTION:
# Port of LibWeb/CSS/Parser/MediaParsing.cpp (lines 1-424): parse_as_media_query_list,
# <media-query-list> (the template over TokenStream<T>), parse_as_media_query,
# <media-query>, <media-condition> and <media-feature>. The lambdas of
# parse_media_feature (<mf-name>, <mf-boolean>, <mf-plain>, <mf-comparison>, <mf-range>)
# are the functions before it, with its local MediaFeatureName struct.
#
# 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>
# Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
# Copyright (c) 2022, MacDue <macdue@dueutil.tech>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: <media-query-list> ======================================================================
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:24 Web::CSS::Parser::Parser::parse_as_media_query_list.
pub func css_parser_parse_as_media_query_list(this: CssParser*) -> ak.Vector[CssMediaQuery*]:
return css_parser_parse_a_media_query_list(this, &this.m_token_stream)
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:30 Web::CSS::Parser::Parser::parse_a_media_query_list.
pub func css_parser_parse_a_media_query_list[T: css_syntax.TokenStreamToken[T]](this: CssParser*, tokens: css_syntax.TokenStream[T]*) -> ak.Vector[CssMediaQuery*]:
# https://www.w3.org/TR/mediaqueries-4/#mq-list
# AD-HOC: Ignore whitespace-only queries
# to make `@media {..}` equivalent to `@media all {..}`
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
return ak.Vector[CssMediaQuery*]()
let comma_separated_lists = css_parser_parse_a_comma_separated_list_of_component_values(this, tokens)
var media_queries = ak.Vector[CssMediaQuery*]()
for media_query_parts in ak.vector_span_const(&comma_separated_lists):
var stream = css_syntax.token_stream_create(media_query_parts)
ak.vector_append_t(&media_queries, css_parser_parse_media_query(this, &stream))
return media_queries
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:51 Web::CSS::Parser::Parser::parse_as_media_query.
pub func css_parser_parse_as_media_query(this: CssParser*) -> CssMediaQuery*?:
# https://www.w3.org/TR/cssom-1/#parse-a-media-query
var media_query_list = css_parser_parse_as_media_query_list(this)
if ak.vector_is_empty(&media_query_list):
return css_media_query_create_not_all()
if ak.vector_size(&media_query_list) == 1:
return *ak.vector_first(&media_query_list)
return none
# mark: <media-query> ===========================================================================
## The `parse_initial_modifier` lambda of parse_media_query: `[ not | only ]?`, returns whether to negate the
## query.
func css_parse_media_query_initial_modifier(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> bool?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
let token = css_syntax.token_stream_consume_a_token(tokens)
if not css_syntax.component_value_is(&token, .ident):
return none
let ident = css_component_value_ident(&token)
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("not")):
css_syntax.state_transaction_commit(&transaction)
return true
if ak.fly_string_equals_ignoring_ascii_case_string_view(&ident, ak.sv("only")):
css_syntax.state_transaction_commit(&transaction)
return false
return none
## The `invalid_media_query` lambda of parse_media_query.
func css_invalid_media_query(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, description: ak.String) -> CssMediaQuery*:
# "A media query that does not match the grammar in the previous section must be replaced by `not all`
# during parsing." - https://www.w3.org/TR/mediaqueries-5/#error-handling
css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_query_error(CssInvalidQueryError(
query_type = ak.fly_string_from_str("@media"),
value_string = css_syntax.token_stream_dump_string(tokens),
description = description,
)))
return css_media_query_create_not_all()
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:63 Web::CSS::Parser::Parser::parse_media_query.
# `<media-query>`, https://www.w3.org/TR/mediaqueries-4/#typedef-media-query
pub func css_parser_parse_media_query(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaQuery*:
# `<media-query> = <media-condition>
# | [ not | only ]? <media-type> [ and <media-condition-without-or> ]?`
let media_query = css_media_query_create()
css_syntax.token_stream_discard_whitespace(tokens)
# `<media-condition>`
if let media_condition = css_parser_parse_media_condition(this, tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if css_syntax.token_stream_has_next_token(tokens):
return css_invalid_media_query(tokens, ak.string_from_str("Trailing tokens after <media-condition>"))
media_query.m_media_condition = media_condition
return media_query
# `[ not | only ]?`
if let modifier = css_parse_media_query_initial_modifier(tokens):
media_query.m_negated = modifier
css_syntax.token_stream_discard_whitespace(tokens)
# `<media-type>`
if let media_type = css_parser_parse_media_type(this, tokens):
media_query.m_media_type = media_type
css_syntax.token_stream_discard_whitespace(tokens)
else:
# https://drafts.csswg.org/mediaqueries-4/#error-handling
# A media query that does not match the grammar in the previous section must be replaced by not all during parsing.
return css_invalid_media_query(tokens, ak.string_from_str("Doesn't match `<media-query>`"))
if not css_syntax.token_stream_has_next_token(tokens):
return media_query
# `[ and <media-condition-without-or> ]?`
let maybe_and = css_syntax.token_stream_consume_a_token(tokens)
if css_syntax.component_value_is_ident(&maybe_and, ak.sv("and")):
if let media_condition = css_parser_parse_media_condition(this, tokens):
# "or" is disallowed at the top level
if is_css_boolean_or_expression(media_condition):
return css_invalid_media_query(tokens, ak.string_from_str("Contains top-level `or`"))
css_syntax.token_stream_discard_whitespace(tokens)
if css_syntax.token_stream_has_next_token(tokens):
return css_invalid_media_query(tokens, ak.string_from_str("Trailing tokens after `<media-condition-without-or>`"))
media_query.m_media_condition = media_condition
return media_query
return css_invalid_media_query(tokens, ak.string_from_str("Missing `<media-condition>` after `and`"))
return css_invalid_media_query(tokens, ak.string_from_str("Trailing tokens after `<media-query>`"))
# mark: <media-condition> =======================================================================
## The `<test>` lambda of parse_media_condition: a parenthesized <media-feature>.
func css_parser_parse_media_condition_test(context: void*?, outer_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssBooleanExpression*?:
let this = (CssParser*)(context else trap("no parser"))
var transaction = css_syntax.token_stream_begin_transaction(outer_tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(outer_tokens)
let next = css_syntax.token_stream_next_token(outer_tokens)
if not css_component_value_is_paren_block(&next):
return none
let block_value = css_syntax.token_stream_consume_a_token(outer_tokens)
let block = css_syntax.component_value_block(&block_value)
var inner_tokens = css_syntax.token_stream_create(block.value)
if let media_feature = css_parser_parse_media_feature(this, &inner_tokens):
css_syntax.state_transaction_commit(&transaction)
return media_feature.css_boolean_expression()
return none
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:150 Web::CSS::Parser::Parser::parse_media_condition.
# `<media-condition>`, https://www.w3.org/TR/mediaqueries-4/#typedef-media-condition
pub func css_parser_parse_media_condition(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssBooleanExpression*?:
return css_parser_parse_boolean_expression(this, tokens, CssMatchResult.unknown,
ak.Function1[css_syntax.TokenStream[css_syntax.ComponentValue]*, CssBooleanExpression*?](call = css_parser_parse_media_condition_test, context = this))
# mark: <media-feature> =========================================================================
## parse_media_feature's local `struct MediaFeatureName`: `<mf-name> = <ident>`.
struct CssParserMediaFeatureName:
var type_: CssParserMediaFeatureNameType
var id: css_data.MediaFeatureId
## MediaFeatureName::Type.
enum CssParserMediaFeatureNameType as u8:
normal = 0
min = 1
max = 2
## The `parse_mf_name` lambda of parse_media_feature.
func css_parse_mf_name(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*, allow_min_max_prefix: bool) -> CssParserMediaFeatureName?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
let token = css_syntax.token_stream_consume_a_token(tokens)
if css_syntax.component_value_is(&token, .ident):
let name = css_component_value_ident(&token)
if let id = css_data.media_feature_id_from_string(ak.fly_string_bytes_as_string_view(&name)):
css_syntax.state_transaction_commit(&transaction)
return CssParserMediaFeatureName(type_ = CssParserMediaFeatureNameType.normal, id = id)
if allow_min_max_prefix and (ak.fly_string_starts_with_bytes(&name, ak.sv("min-"), ak.CaseSensitivity.case_insensitive) or ak.fly_string_starts_with_bytes(&name, ak.sv("max-"), ak.CaseSensitivity.case_insensitive)):
let name_view = ak.fly_string_bytes_as_string_view(&name)
let adjusted_name = ak.string_view_substring_view(&name_view, 4)
if let id = css_data.media_feature_id_from_string(adjusted_name):
if css_data.media_feature_type_is_range(id):
css_syntax.state_transaction_commit(&transaction)
var type_ = CssParserMediaFeatureNameType.max
if ak.fly_string_starts_with_bytes(&name, ak.sv("min-"), ak.CaseSensitivity.case_insensitive):
type_ = CssParserMediaFeatureNameType.min
return CssParserMediaFeatureName(type_ = type_, id = id)
return none
## The `parse_mf_boolean` lambda of parse_media_feature: `<mf-boolean> = <mf-name>`.
func css_parse_mf_boolean(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeature*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
if let name = css_parse_mf_name(tokens, false):
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_boolean(name.id)
return none
## The `parse_mf_plain` lambda of parse_media_feature: `<mf-plain> = <mf-name> : <mf-value>`.
func css_parser_parse_mf_plain(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeature*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
if let name = css_parse_mf_name(tokens, true):
css_syntax.token_stream_discard_whitespace(tokens)
let colon = css_syntax.token_stream_consume_a_token(tokens)
if css_syntax.component_value_is(&colon, .colon):
css_syntax.token_stream_discard_whitespace(tokens)
if let value = css_parser_parse_media_feature_value(this, name.id, tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
css_syntax.state_transaction_commit(&transaction)
match name.type_:
.normal: return css_media_feature_plain(name.id, value)
.min: return css_media_feature_min(name.id, value)
.max: return css_media_feature_max(name.id, value)
_: trap("VERIFY_NOT_REACHED")
return none
## The `parse_comparison` lambda of parse_media_feature:
## `<mf-lt> = '<' '='? <mf-gt> = '>' '='? <mf-eq> = '=' <mf-comparison> = <mf-lt> | <mf-gt> | <mf-eq>`.
func css_parse_mf_comparison(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeatureComparison?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
let first = css_syntax.token_stream_consume_a_token(tokens)
if css_syntax.component_value_is(&first, .delim):
let first_token = css_syntax.component_value_token(&first)
let first_delim = css_syntax.token_delim(&first_token)
if first_delim == (u32)'=':
css_syntax.state_transaction_commit(&transaction)
return CssMediaFeatureComparison.equal
if first_delim == (u32)'<':
let second = css_syntax.token_stream_next_token(tokens)
if css_syntax.component_value_is_delim(&second, (u32)'='):
css_syntax.token_stream_discard_a_token(tokens)
css_syntax.state_transaction_commit(&transaction)
return CssMediaFeatureComparison.less_than_or_equal
css_syntax.state_transaction_commit(&transaction)
return CssMediaFeatureComparison.less_than
if first_delim == (u32)'>':
let second = css_syntax.token_stream_next_token(tokens)
if css_syntax.component_value_is_delim(&second, (u32)'='):
css_syntax.token_stream_discard_a_token(tokens)
css_syntax.state_transaction_commit(&transaction)
return CssMediaFeatureComparison.greater_than_or_equal
css_syntax.state_transaction_commit(&transaction)
return CssMediaFeatureComparison.greater_than
return none
## The `comparisons_match` lambda of parse_media_feature.
func css_mf_comparisons_match(a: CssMediaFeatureComparison, b: CssMediaFeatureComparison) -> bool:
match a:
.equal:
return b == CssMediaFeatureComparison.equal
.less_than, .less_than_or_equal:
return b == CssMediaFeatureComparison.less_than or b == CssMediaFeatureComparison.less_than_or_equal
.greater_than, .greater_than_or_equal:
return b == CssMediaFeatureComparison.greater_than or b == CssMediaFeatureComparison.greater_than_or_equal
_:
trap("VERIFY_NOT_REACHED")
## The scan of parse_mf_range for the <mf-name> after the first comparison, in a transaction that is never
## committed: it only rewinds the stream.
func css_scan_mf_range_name(tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssParserMediaFeatureName?:
var maybe_name: CssParserMediaFeatureName? = none
# This transaction is never committed, we just use it to rewind automatically.
var temp_transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&temp_transaction)
while css_syntax.token_stream_has_next_token(tokens) and maybe_name == none:
if css_parse_mf_comparison(tokens) != none:
# We found a comparison, so the next non-whitespace token should be the <mf-name>
css_syntax.token_stream_discard_whitespace(tokens)
maybe_name = css_parse_mf_name(tokens, false)
break
css_syntax.token_stream_discard_a_token(tokens)
css_syntax.token_stream_discard_whitespace(tokens)
return maybe_name
## The `parse_mf_range` lambda of parse_media_feature:
## `<mf-range> = <mf-name> <mf-comparison> <mf-value>
## | <mf-value> <mf-comparison> <mf-name>
## | <mf-value> <mf-lt> <mf-name> <mf-lt> <mf-value>
## | <mf-value> <mf-gt> <mf-name> <mf-gt> <mf-value>`
func css_parser_parse_mf_range(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeature*?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
# `<mf-name> <mf-comparison> <mf-value>`
# NOTE: We have to check for <mf-name> first, since all <mf-name>s will also parse as <mf-value>.
if let name = css_parse_mf_name(tokens, false):
css_syntax.token_stream_discard_whitespace(tokens)
if let comparison = css_parse_mf_comparison(tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if let value = css_parser_parse_media_feature_value(this, name.id, tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens) and not css_media_feature_value_is_ident(&value):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_half_range_media_feature_id(name.id, comparison, value)
# `<mf-value> <mf-comparison> <mf-name>
# | <mf-value> <mf-lt> <mf-name> <mf-lt> <mf-value>
# | <mf-value> <mf-gt> <mf-name> <mf-gt> <mf-value>`
# NOTE: To parse the first value, we need to first find and parse the <mf-name> so we know what value types to parse.
# To allow for <mf-value> to be any number of tokens long, we scan forward until we find a comparison, and then
# treat the next non-whitespace token as the <mf-name>, which should be correct as long as they don't add a value
# type that can include a comparison in it. :^)
let maybe_name = css_scan_mf_range_name(tokens)
# Now, we can parse the range properly.
if let name = maybe_name:
if let left_value = css_parser_parse_media_feature_value(this, name.id, tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if let left_comparison = css_parse_mf_comparison(tokens):
css_syntax.token_stream_discard_whitespace(tokens)
css_syntax.token_stream_discard_a_token(tokens) # The <mf-name> which we already parsed above.
css_syntax.token_stream_discard_whitespace(tokens)
if not css_syntax.token_stream_has_next_token(tokens):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_half_range_css_media_feature_value(left_value, left_comparison, name.id)
if let right_comparison = css_parse_mf_comparison(tokens):
css_syntax.token_stream_discard_whitespace(tokens)
if let right_value = css_parser_parse_media_feature_value(this, name.id, tokens):
css_syntax.token_stream_discard_whitespace(tokens)
# For this to be valid, the following must be true:
# - Comparisons must either both be >/>= or both be </<=.
# - Neither comparison can be `=`.
# - Neither value can be an ident.
if (not css_syntax.token_stream_has_next_token(tokens) and css_mf_comparisons_match(left_comparison, right_comparison) and left_comparison != CssMediaFeatureComparison.equal and not css_media_feature_value_is_ident(&left_value) and not css_media_feature_value_is_ident(&right_value)):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_range_css_media_feature_value(left_value, left_comparison, name.id, right_comparison, right_value)
return none
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:174 Web::CSS::Parser::Parser::parse_media_feature.
# `<media-feature>`, https://drafts.csswg.org/mediaqueries-5/#typedef-media-feature
pub func css_parser_parse_media_feature(this: CssParser*, inner_tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeature*?:
# `<media-feature> = [ <mf-plain> | <mf-boolean> | <mf-range> ]`
var transaction = css_syntax.token_stream_begin_transaction(inner_tokens)
defer css_syntax.state_transaction_destroy(&transaction)
if let mf_boolean = css_parse_mf_boolean(inner_tokens):
css_syntax.token_stream_discard_whitespace(inner_tokens)
if css_syntax.token_stream_has_next_token(inner_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return mf_boolean
if let mf_plain = css_parser_parse_mf_plain(this, inner_tokens):
css_syntax.token_stream_discard_whitespace(inner_tokens)
if css_syntax.token_stream_has_next_token(inner_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return mf_plain
if let mf_range = css_parser_parse_mf_range(this, inner_tokens):
css_syntax.token_stream_discard_whitespace(inner_tokens)
if css_syntax.token_stream_has_next_token(inner_tokens):
return none
css_syntax.state_transaction_commit(&transaction)
return mf_range
return none