Luce packages
LuceLuce BaseLuciaOS

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)