Luce packages
LuceLuce BaseLuciaOS

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