dymokomi/luce-browser-engine
Source of release 0.6.0
0.6.0 / src / web / css / parser / media_parsing_2.lucb
#==============================================================================================
#
# media_parsing_2 - parsing media queries: <media-type>, <mf-value>, and @media rules
#
# DESCRIPTION:
# Port of LibWeb/CSS/Parser/MediaParsing.cpp (lines 426-663): <media-type>, the tokens a
# <mf-value> may contain, <mf-value> itself (with the "unknown" fallback), and
# convert_to_media_rule (the template over the nested-declarations rule type).
#
# 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: <media-type> ============================================================================
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:426 Web::CSS::Parser::Parser::parse_media_type.
pub func css_parser_parse_media_type(this: CssParser*, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaQueryMediaType?:
_ = this
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
# https://drafts.csswg.org/mediaqueries-3/#error-handling
# "However, an exception is made for media types ‘layer’, ‘not’, ‘and’, ‘only’, and ‘or’. Even though they do match
# the IDENT production, they must not be treated as unknown media types, but rather trigger the malformed query clause."
if (css_syntax.component_value_is_ident(&token, ak.sv("layer")) or css_syntax.component_value_is_ident(&token, ak.sv("not")) or css_syntax.component_value_is_ident(&token, ak.sv("and")) or css_syntax.component_value_is_ident(&token, ak.sv("only")) or css_syntax.component_value_is_ident(&token, ak.sv("or"))):
return none
css_syntax.state_transaction_commit(&transaction)
let ident = css_component_value_ident(&token)
return CssMediaQueryMediaType(
name = ident,
known_type = css_media_type_from_string(ak.fly_string_bytes_as_string_view(&ident)),
)
# mark: <mf-value> ==============================================================================
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:450 Web::CSS::Parser::is_media_feature_value_token.
func css_is_media_feature_value_token(component_value: css_syntax.ComponentValue) -> bool:
if not css_syntax.component_value_is_token(&component_value):
return true
let token = css_syntax.component_value_token(&component_value)
match css_syntax.token_type(&token):
.ident, .function, .at_keyword, .hash_, .string, .bad_string, .url, .bad_url, .number, .percentage, .dimension, .whitespace, .comma:
return true
.delim:
# FIXME: What list of delimiters should we actually allow here?
let delim = css_syntax.token_delim(&token)
return not (delim == (u32)'<' or delim == (u32)'>' or delim == (u32)'=')
.invalid, .end_of_file, .cdo, .cdc, .colon, .semicolon, .open_square, .close_square, .open_paren, .close_paren, .open_curly, .close_curly:
return false
_:
trap("VERIFY_NOT_REACHED")
## `MediaFeatureValue(type, value)`.
func css_media_feature_value_create(type_: CssMediaFeatureValueType, value: CssStyleValue*) -> CssMediaFeatureValue:
var media_feature_value: CssMediaFeatureValue = ---
css_media_feature_value_construct(&media_feature_value, type_, value)
return media_feature_value
## The immediately-invoked `value` lambda of parse_media_feature_value: one branch for each member of the
## MediaFeatureValueType enum, in a temporary MediaCondition value-parsing context.
func css_parser_parse_media_feature_value_of_accepted_type(this: CssParser*, media_feature: css_data.MediaFeatureId, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeatureValue?:
css_parser_push_temporary_value_parsing_context(this, CssValueParsingContext.css_special_context(CssSpecialContext.media_condition))
defer css_parser_pop_temporary_value_parsing_context(this)
# One branch for each member of the MediaFeatureValueType enum:
# Identifiers
let next = css_syntax.token_stream_next_token(tokens)
if css_syntax.component_value_is(&next, .ident):
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 keyword = css_parser_parse_keyword_value(this, tokens):
if css_data.media_feature_accepts_keyword(media_feature, css_style_value_to_keyword(keyword)):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_value_create(CssMediaFeatureValueType.ident, keyword)
# Boolean (<mq-boolean> in the spec: a 1 or 0)
if css_data.media_feature_accepts_type(media_feature, css_data.MediaFeatureValueType.boolean):
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 integer = css_parser_parse_integer_value(this, tokens, css_infinite_integer_range):
if (css_style_value_is_calculated(integer) or css_integer_style_value_integer(css_style_value_as_integer(integer)) == 0 or css_integer_style_value_integer(css_style_value_as_integer(integer)) == 1):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_value_create(CssMediaFeatureValueType.integer, integer)
# Integer
if css_data.media_feature_accepts_type(media_feature, css_data.MediaFeatureValueType.integer):
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
if let integer = css_parser_parse_integer_value(this, tokens, css_infinite_integer_range):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_value_create(CssMediaFeatureValueType.integer, integer)
# Length
if css_data.media_feature_accepts_type(media_feature, css_data.MediaFeatureValueType.length):
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 length = css_parser_parse_length_value(this, tokens, css_infinite_range):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_value_create(CssMediaFeatureValueType.length, length)
# https://drafts.csswg.org/mediaqueries-5/#typedef-mf-value
# <mf-value> = <number> | <dimension> | <ident> | <ratio>
#
# https://drafts.csswg.org/css-values-4/#lengths
# "For zero lengths the unit identifier is optional"
#
# https://drafts.csswg.org/css-values-4/#zero-value
# "Values of '0' can be written without units, even if the
# value type doesn't allow 'unitless zeroes'."
if css_syntax.token_stream_has_next_token(tokens):
let token = css_syntax.token_stream_next_token(tokens)
var calculation_context = CssCalculationContext()
_ = ak.hash_map_set(&calculation_context.accepted_ranges_by_type, CssValueType.number, css_infinite_range)
if let calc = css_parser_parse_calculated_value(this, token, calculation_context):
if css_calculated_style_value_resolves_to_number(calc):
if let resolved_number = css_calculated_style_value_resolve_number(calc, CssCalculationResolutionContext()):
if resolved_number == 0.0:
css_syntax.token_stream_discard_a_token(tokens)
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_value_create(CssMediaFeatureValueType.length, css_length_style_value_create(css_length_make_px_f64(0.0)).css_style_value())
# Ratio
if css_data.media_feature_accepts_type(media_feature, css_data.MediaFeatureValueType.ratio):
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 ratio = css_parser_parse_ratio_value(this, tokens):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_value_create(CssMediaFeatureValueType.ratio, ratio)
# Resolution
if css_data.media_feature_accepts_type(media_feature, css_data.MediaFeatureValueType.resolution):
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 resolution = css_parser_parse_resolution_value(this, tokens, css_infinite_range):
css_syntax.state_transaction_commit(&transaction)
return css_media_feature_value_create(CssMediaFeatureValueType.resolution, resolution)
return none
## The first block of parse_media_feature_value: the value of an accepted type, in a transaction that is
## committed only when no value tokens follow it (otherwise the stream is rewound for the "unknown" value).
func css_parser_parse_media_feature_value_without_trailing_tokens(this: CssParser*, media_feature: css_data.MediaFeatureId, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeatureValue?:
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
let value = css_parser_parse_media_feature_value_of_accepted_type(this, media_feature, tokens)
if let parsed_value = value:
css_syntax.token_stream_discard_whitespace(tokens)
# Only returned the value if there are no trailing tokens.
# Otherwise, the transaction gets reverted and we consume all the value tokens below.
if not css_is_media_feature_value_token(css_syntax.token_stream_next_token(tokens)):
css_syntax.state_transaction_commit(&transaction)
return parsed_value
return none
## `MUST(String::join(""sv, values))`: the component values' strings, concatenated.
func css_join_component_values(values: const ak.Vector[css_syntax.ComponentValue]*) -> ak.String:
var builder = ak.string_builder_new()
for value in ak.vector_span_const(values):
let text = css_syntax.component_value_to_string(&value)
ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&text))
return ak.string_builder_to_string_without_validation(&builder)
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:490 Web::CSS::Parser::Parser::parse_media_feature_value.
# `<mf-value>`, https://www.w3.org/TR/mediaqueries-4/#typedef-mf-value
pub func css_parser_parse_media_feature_value(this: CssParser*, media_feature: css_data.MediaFeatureId, tokens: css_syntax.TokenStream[css_syntax.ComponentValue]*) -> CssMediaFeatureValue?:
if let value = css_parser_parse_media_feature_value_without_trailing_tokens(this, media_feature, tokens):
return value
# Parsing failed somehow, so wrap all the tokens into an "unknown" MediaFeatureValue if possible.
var transaction = css_syntax.token_stream_begin_transaction(tokens)
defer css_syntax.state_transaction_destroy(&transaction)
css_syntax.token_stream_discard_whitespace(tokens)
var unknown_tokens = ak.Vector[css_syntax.ComponentValue]()
# Consume any tokens that could be part of a value.
while css_syntax.token_stream_has_next_token(tokens):
if css_is_media_feature_value_token(css_syntax.token_stream_next_token(tokens)):
ak.vector_append_t(&unknown_tokens, css_syntax.token_stream_consume_a_token(tokens))
else:
break
if not ak.vector_is_empty(&unknown_tokens):
css_syntax.state_transaction_commit(&transaction)
css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_value_error(CssInvalidValueError(
value_type = ak.fly_string_from_str("<mf-value>"),
value_string = css_join_component_values(&unknown_tokens),
description = ak.string_from_str("Unrecognized type"),
)))
# NB: We only use this for serialization so the substitution function presence is irrelevant and we can just
# set it to empty.
return css_media_feature_value_create(CssMediaFeatureValueType.unknown,
css_unresolved_style_value_create(unknown_tokens, css_syntax.SubstitutionFunctionsPresence()).css_style_value())
return none
# mark: @media ==================================================================================
## Ported from Libraries/LibWeb/CSS/Parser/MediaParsing.cpp:626 Web::CSS::Parser::Parser::convert_to_media_rule.
pub func css_parser_convert_to_media_rule[TNestedDeclarationsRule](this: CssParser*, rule: css_syntax.AtRule, nested: CssParserNested) -> CssMediaRule*?:
# https://drafts.csswg.org/css-conditional-3/#at-media
# @media <media-query-list> {
# <rule-list>
# }
if not rule.is_block_rule:
css_error_reporter_report(css_error_reporter_the(), CssParsingError.css_invalid_rule_error(CssInvalidRuleError(
rule_name = ak.fly_string_from_str("@media"),
prelude = css_join_component_values(&rule.prelude),
description = ak.string_from_str("Expected a block."),
)))
return none
var media_query_tokens = css_syntax.token_stream_create(rule.prelude)
let media_query_list = css_parser_parse_a_media_query_list(this, &media_query_tokens)
let media_list = css_media_list_create(css_parser_realm(this), media_query_list)
var child_rules = ak.Vector[CssRule*]()
for child in ak.vector_span_const(&rule.child_rules_and_lists_of_declarations):
match child:
.rule(child_rule):
if let converted_rule = css_parser_convert_to_rule[TNestedDeclarationsRule](this, child_rule, nested):
ak.vector_append_t(&child_rules, converted_rule)
.vector_declaration(declarations):
ak.vector_append_t(&child_rules, css_parser_create_nested_declarations_rule[TNestedDeclarationsRule](this, declarations))
let rule_list = css_rule_list_create(css_parser_realm(this), ak.vector_span_const(&child_rules))
return css_media_rule_create(css_parser_realm(this), media_list, rule_list)