Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / css / media_query.lucb

#==============================================================================================
#
#   media_query - CSS::MediaQuery and CSS::MediaFeature: media queries, their features and
#                 values, evaluation against a document and serialization
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/MediaQuery.cpp (lines 1-359) and the inline members of MediaQuery.h
#       (lines 18-218). A MediaFeature is a BooleanExpression; a MediaQuery (C++ RefCounted) is
#       a managed blob whose `m_matches` caches the last evaluation.
#
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: MediaFeatureValue =======================================================================

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:36 Web::CSS::MediaFeatureValue::MediaFeatureValue.
pub func css_media_feature_value_construct(this: CssMediaFeatureValue*, type_: CssMediaFeatureValueType, value: CssStyleValue*):
    this.m_type = type_
    this.m_value = value

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:29 Web::CSS::MediaFeatureValue::to_string.
pub func css_media_feature_value_to_string(this: const CssMediaFeatureValue*, mode: css_syntax.SerializationMode) -> ak.String:
    var builder = ak.string_builder_new()
    css_style_value_serialize(this.m_value, &builder, mode)
    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:44 Web::CSS::MediaFeatureValue::is_ident.
pub func css_media_feature_value_is_ident(this: const CssMediaFeatureValue*) -> bool:
    return this.m_type == CssMediaFeatureValueType.ident

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:45 Web::CSS::MediaFeatureValue::is_length.
pub func css_media_feature_value_is_length(this: const CssMediaFeatureValue*) -> bool:
    return this.m_type == CssMediaFeatureValueType.length

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:46 Web::CSS::MediaFeatureValue::is_integer.
pub func css_media_feature_value_is_integer(this: const CssMediaFeatureValue*) -> bool:
    return this.m_type == CssMediaFeatureValueType.integer

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:47 Web::CSS::MediaFeatureValue::is_ratio.
pub func css_media_feature_value_is_ratio(this: const CssMediaFeatureValue*) -> bool:
    return this.m_type == CssMediaFeatureValueType.ratio

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:48 Web::CSS::MediaFeatureValue::is_resolution.
pub func css_media_feature_value_is_resolution(this: const CssMediaFeatureValue*) -> bool:
    return this.m_type == CssMediaFeatureValueType.resolution

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:49 Web::CSS::MediaFeatureValue::is_unknown.
pub func css_media_feature_value_is_unknown(this: const CssMediaFeatureValue*) -> bool:
    return this.m_type == CssMediaFeatureValueType.unknown

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:50 Web::CSS::MediaFeatureValue::is_same_type.
pub func css_media_feature_value_is_same_type(this: const CssMediaFeatureValue*, other: CssMediaFeatureValue) -> bool:
    return this.m_type == other.m_type

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:52 Web::CSS::MediaFeatureValue::ident.
pub func css_media_feature_value_ident(this: const CssMediaFeatureValue*) -> css_data.Keyword:
    assert(css_media_feature_value_is_ident(this))
    return css_style_value_to_keyword(this.m_value)

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:58 Web::CSS::MediaFeatureValue::length.
pub func css_media_feature_value_length(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> CssLength:
    assert(css_media_feature_value_is_length(this))
    return css_length_from_style_value(css_style_value_absolutized(this.m_value, computation_context), none)

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:64 Web::CSS::MediaFeatureValue::ratio.
pub func css_media_feature_value_ratio(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> CssRatio:
    assert(css_media_feature_value_is_ratio(this))
    return css_ratio_style_value_resolved(css_style_value_as_ratio(css_style_value_absolutized(this.m_value, computation_context)))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:70 Web::CSS::MediaFeatureValue::resolution.
pub func css_media_feature_value_resolution(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> CssResolution:
    assert(css_media_feature_value_is_resolution(this))
    return css_resolution_from_style_value(css_style_value_absolutized(this.m_value, computation_context))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:76 Web::CSS::MediaFeatureValue::integer.
pub func css_media_feature_value_integer(this: const CssMediaFeatureValue*, computation_context: CssComputationContext) -> i32:
    assert(css_media_feature_value_is_integer(this))
    return css_int_from_style_value(css_style_value_absolutized(this.m_value, computation_context))

# mark: MediaFeature ============================================================================

## A MediaFeature allocated and constructed (`adopt_own(*new MediaFeature(...))`).
func css_media_feature_new(type_: CssMediaFeatureType, id: css_data.MediaFeatureId, value: EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange) -> CssMediaFeature*:
    let this = &(new CssMediaFeature[1] --- else trap("out of memory"))[0]
    css_media_feature_construct(this, type_, id, value)
    return this

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:99 Web::CSS::MediaFeature::boolean.
# Corresponds to `<mf-boolean>` grammar
pub func css_media_feature_boolean(id: css_data.MediaFeatureId) -> CssMediaFeature*:
    return css_media_feature_new(CssMediaFeatureType.is_true, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.empty)

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:105 Web::CSS::MediaFeature::plain.
# Corresponds to `<mf-plain>` grammar
pub func css_media_feature_plain(id: css_data.MediaFeatureId, value: CssMediaFeatureValue) -> CssMediaFeature*:
    return css_media_feature_new(CssMediaFeatureType.exact_value, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_value(value))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:109 Web::CSS::MediaFeature::min.
pub func css_media_feature_min(id: css_data.MediaFeatureId, value: CssMediaFeatureValue) -> CssMediaFeature*:
    return css_media_feature_new(CssMediaFeatureType.min_value, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_value(value))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:113 Web::CSS::MediaFeature::max.
pub func css_media_feature_max(id: css_data.MediaFeatureId, value: CssMediaFeatureValue) -> CssMediaFeature*:
    return css_media_feature_new(CssMediaFeatureType.max_value, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_value(value))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:118 Web::CSS::MediaFeature::half_range.
pub func css_media_feature_half_range_css_media_feature_value(value: CssMediaFeatureValue, comparison: CssMediaFeatureComparison, id: css_data.MediaFeatureId) -> CssMediaFeature*:
    let range = CssMediaFeatureRange(left_value = value, left_comparison = comparison)
    return css_media_feature_new(CssMediaFeatureType.range, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_range(range))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:126 Web::CSS::MediaFeature::half_range.
pub func css_media_feature_half_range_media_feature_id(id: css_data.MediaFeatureId, comparison: CssMediaFeatureComparison, value: CssMediaFeatureValue) -> CssMediaFeature*:
    let range = CssMediaFeatureRange(right_comparison = comparison, right_value = value)
    return css_media_feature_new(CssMediaFeatureType.range, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_range(range))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:136 Web::CSS::MediaFeature::range.
# Corresponds to `<mf-range>` grammar, with two comparisons
pub func css_media_feature_range_css_media_feature_value(left_value: CssMediaFeatureValue, left_comparison: CssMediaFeatureComparison, id: css_data.MediaFeatureId, right_comparison: CssMediaFeatureComparison, right_value: CssMediaFeatureValue) -> CssMediaFeature*:
    let range = CssMediaFeatureRange(left_value = left_value, left_comparison = left_comparison, right_comparison = right_comparison, right_value = right_value)
    return css_media_feature_new(CssMediaFeatureType.range, id, EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange.css_media_feature_range(range))

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:167 Web::CSS::MediaFeature::MediaFeature.
pub func css_media_feature_construct(this: CssMediaFeature*, type_: CssMediaFeatureType, id: css_data.MediaFeatureId, value: EmptyOrCssMediaFeatureValueOrCssMediaFeatureRange):
    css_boolean_expression_set_class(this.css_boolean_expression(), (const CssBooleanExpressionVTable*)&css_media_feature_vtable, &css_media_feature_class)
    this.m_type = type_
    this.m_id = id
    this.m_value = value

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:175 Web::CSS::MediaFeature::value.
pub func css_media_feature_value(this: CssMediaFeature*) -> CssMediaFeatureValue:
    match this.m_value:
        .css_media_feature_value(value): return value
        _: trap("VERIFY: Variant::get<MediaFeatureValue>")

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:176 Web::CSS::MediaFeature::range.
pub func css_media_feature_range(this: CssMediaFeature*) -> CssMediaFeatureRange:
    match this.m_value:
        .css_media_feature_range(range): return range
        _: trap("VERIFY: Variant::get<Range>")

## MediaFeature::to_string's `comparison_string` lambda.
func css_media_feature_comparison_string(comparison: CssMediaFeatureComparison) -> str:
    match comparison:
        .equal: return "="
        .less_than: return "<"
        .less_than_or_equal: return "<="
        .greater_than: return ">"
        .greater_than_or_equal: return ">="
        _: trap("VERIFY_NOT_REACHED")

## `(<prefix><feature name>: <value>)`, the plain, min and max forms of MediaFeature::to_string.
func css_media_feature_value_string(prefix: str, id: css_data.MediaFeatureId, value: const CssMediaFeatureValue*) -> ak.String:
    var builder = ak.string_builder_new()
    let value_string = css_media_feature_value_to_string(value, css_syntax.SerializationMode.normal)
    ak.string_builder_append(&builder, "(")
    ak.string_builder_append(&builder, prefix)
    ak.string_builder_append_string_view(&builder, css_data.string_from_media_feature_id(id))
    ak.string_builder_append(&builder, ": ")
    ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&value_string))
    ak.string_builder_append(&builder, ")")
    return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:36 Web::CSS::MediaFeature::to_string (override).
pub func css_media_feature_to_string_impl(base: CssBooleanExpression*) -> ak.String:
    let this = (CssMediaFeature*)base

    # NB: Even though we parse the parentheses as part of <media-in-parens> rather than <media-feature>, we serialize
    #     them as part of <media-feature> to avoid having to create a whole MediaInParens class just for serialization.
    match this.m_type:
        .is_true:
            var builder = ak.string_builder_new()
            ak.string_builder_append(&builder, "(")
            ak.string_builder_append_string_view(&builder, css_data.string_from_media_feature_id(this.m_id))
            ak.string_builder_append(&builder, ")")
            return ak.string_builder_to_string(&builder) else trap("MUST: String::formatted")
        .exact_value:
            let value = css_media_feature_value(this)
            return css_media_feature_value_string("", this.m_id, &value)
        .min_value:
            let value = css_media_feature_value(this)
            return css_media_feature_value_string("min-", this.m_id, &value)
        .max_value:
            let value = css_media_feature_value(this)
            return css_media_feature_value_string("max-", this.m_id, &value)
        .range:
            let range = css_media_feature_range(this)
            var builder = ak.string_builder_new()
            ak.string_builder_append_u8(&builder, '(')
            if let left_comparison = range.left_comparison:
                let left_value = range.left_value else trap("VERIFY: Optional::operator->")
                let left_string = css_media_feature_value_to_string(&left_value, css_syntax.SerializationMode.normal)
                ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&left_string))
                ak.string_builder_append(&builder, " ")
                ak.string_builder_append(&builder, css_media_feature_comparison_string(left_comparison))
                ak.string_builder_append(&builder, " ")
            ak.string_builder_append_string_view(&builder, css_data.string_from_media_feature_id(this.m_id))
            if let right_comparison = range.right_comparison:
                let right_value = range.right_value else trap("VERIFY: Optional::operator->")
                let right_string = css_media_feature_value_to_string(&right_value, css_syntax.SerializationMode.normal)
                ak.string_builder_append(&builder, " ")
                ak.string_builder_append(&builder, css_media_feature_comparison_string(right_comparison))
                ak.string_builder_append(&builder, " ")
                ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&right_string))
            ak.string_builder_append_u8(&builder, ')')

            return ak.string_builder_to_string_without_validation(&builder)
        _:
            trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:83 Web::CSS::MediaFeature::evaluate (override).
pub func css_media_feature_evaluate_impl(base: CssBooleanExpression*, document: DomDocument*?) -> CssMatchResult:
    let this = (CssMediaFeature*)base
    let document_ = document else trap("VERIFY: document")

    # FIXME: In some cases (e.g. when parsing HTML using DOMParser::parse_from_string()) a document may not be associated with a window -
    #        for now we just return false but perhaps there are some media queries we should still attempt to resolve.
    let window = dom_document_window(document_) else return CssMatchResult.false_

    let queried_value = html_window_query_media_feature(window, this.m_id) else return CssMatchResult.false_

    let computation_context = CssComputationContext(length_resolution_context = css_length_resolution_context_for_document(document_))
    match this.m_type:
        .is_true:
            if css_media_feature_value_is_integer(&queried_value):
                return css_as_match_result(css_media_feature_value_integer(&queried_value, computation_context) != 0)
            if css_media_feature_value_is_length(&queried_value):
                let length = css_media_feature_value_length(&queried_value, computation_context)
                return css_as_match_result(css_length_raw_value(&length) != 0.0)
            # FIXME: I couldn't figure out from the spec how ratios should be evaluated in a boolean context.
            if css_media_feature_value_is_ratio(&queried_value):
                let ratio = css_media_feature_value_ratio(&queried_value, computation_context)
                return css_as_match_result(not css_ratio_is_degenerate(&ratio))
            if css_media_feature_value_is_resolution(&queried_value):
                let resolution = css_media_feature_value_resolution(&queried_value, computation_context)
                return css_as_match_result(css_resolution_to_dots_per_pixel(&resolution) != 0.0)
            if css_media_feature_value_is_ident(&queried_value):
                if css_data.media_feature_keyword_is_falsey(this.m_id, css_media_feature_value_ident(&queried_value)):
                    return CssMatchResult.false_
                return CssMatchResult.true_
            return CssMatchResult.false_

        .exact_value:
            return css_media_feature_compare(document_, css_media_feature_value(this), CssMediaFeatureComparison.equal, queried_value)

        .min_value:
            return css_media_feature_compare(document_, queried_value, CssMediaFeatureComparison.greater_than_or_equal, css_media_feature_value(this))

        .max_value:
            return css_media_feature_compare(document_, queried_value, CssMediaFeatureComparison.less_than_or_equal, css_media_feature_value(this))

        .range:
            let range = css_media_feature_range(this)
            if let left_comparison = range.left_comparison:
                let left_value = range.left_value else trap("VERIFY: Optional::operator*")
                let left_result = css_media_feature_compare(document_, left_value, left_comparison, queried_value)
                if left_result != CssMatchResult.true_:
                    return left_result

            if let right_comparison = range.right_comparison:
                let right_value = range.right_value else trap("VERIFY: Optional::operator*")
                let right_result = css_media_feature_compare(document_, queried_value, right_comparison, right_value)
                if right_result != CssMatchResult.true_:
                    return right_result

            return CssMatchResult.true_

        _:
            trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:148 Web::CSS::MediaFeature::compare.
pub func css_media_feature_compare(document: DomDocument*, left: CssMediaFeatureValue, comparison: CssMediaFeatureComparison, right: CssMediaFeatureValue) -> CssMatchResult:
    if css_media_feature_value_is_unknown(&left) or css_media_feature_value_is_unknown(&right):
        return CssMatchResult.unknown

    if not css_media_feature_value_is_same_type(&left, right):
        return CssMatchResult.false_

    if css_media_feature_value_is_ident(&left):
        if comparison == CssMediaFeatureComparison.equal:
            return css_as_match_result(css_media_feature_value_ident(&left) == css_media_feature_value_ident(&right))
        return CssMatchResult.false_

    let length_resolution_context = css_length_resolution_context_for_document(document)

    let computation_context = CssComputationContext(length_resolution_context = length_resolution_context)

    if css_media_feature_value_is_integer(&left):
        let left_integer = css_media_feature_value_integer(&left, computation_context)
        let right_integer = css_media_feature_value_integer(&right, computation_context)
        match comparison:
            .equal: return css_as_match_result(left_integer == right_integer)
            .less_than: return css_as_match_result(left_integer < right_integer)
            .less_than_or_equal: return css_as_match_result(left_integer <= right_integer)
            .greater_than: return css_as_match_result(left_integer > right_integer)
            .greater_than_or_equal: return css_as_match_result(left_integer >= right_integer)
            _: trap("VERIFY_NOT_REACHED")

    if css_media_feature_value_is_length(&left):
        let left_length = css_media_feature_value_length(&left, computation_context)
        let right_length = css_media_feature_value_length(&right, computation_context)
        let left_px = css_length_absolute_length_to_px(&left_length)
        let right_px = css_length_absolute_length_to_px(&right_length)

        match comparison:
            .equal: return css_as_match_result(left_px.m_value == right_px.m_value)
            .less_than: return css_as_match_result(left_px.m_value < right_px.m_value)
            .less_than_or_equal: return css_as_match_result(left_px.m_value <= right_px.m_value)
            .greater_than: return css_as_match_result(left_px.m_value > right_px.m_value)
            .greater_than_or_equal: return css_as_match_result(left_px.m_value >= right_px.m_value)
            _: trap("VERIFY_NOT_REACHED")

    if css_media_feature_value_is_ratio(&left):
        let left_ratio = css_media_feature_value_ratio(&left, computation_context)
        let right_ratio = css_media_feature_value_ratio(&right, computation_context)
        let left_decimal = css_ratio_value(&left_ratio)
        let right_decimal = css_ratio_value(&right_ratio)

        match comparison:
            .equal: return css_as_match_result(left_decimal == right_decimal)
            .less_than: return css_as_match_result(left_decimal < right_decimal)
            .less_than_or_equal: return css_as_match_result(left_decimal <= right_decimal)
            .greater_than: return css_as_match_result(left_decimal > right_decimal)
            .greater_than_or_equal: return css_as_match_result(left_decimal >= right_decimal)
            _: trap("VERIFY_NOT_REACHED")

    if css_media_feature_value_is_resolution(&left):
        let left_resolution = css_media_feature_value_resolution(&left, computation_context)
        let right_resolution = css_media_feature_value_resolution(&right, computation_context)
        let left_dppx = css_resolution_to_dots_per_pixel(&left_resolution)
        let right_dppx = css_resolution_to_dots_per_pixel(&right_resolution)

        match comparison:
            .equal: return css_as_match_result(left_dppx == right_dppx)
            .less_than: return css_as_match_result(left_dppx < right_dppx)
            .less_than_or_equal: return css_as_match_result(left_dppx <= right_dppx)
            .greater_than: return css_as_match_result(left_dppx > right_dppx)
            .greater_than_or_equal: return css_as_match_result(left_dppx >= right_dppx)
            _: trap("VERIFY_NOT_REACHED")

    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:245 Web::CSS::MediaFeature::dump (override).
pub func css_media_feature_dump_impl(base: CssBooleanExpression*, builder: ak.StringBuilder*, indent_levels: i32):
    css_boolean_expression_indent(builder, indent_levels)
    let string = css_boolean_expression_to_string(base)
    ak.string_builder_append(builder, "MediaFeature: ")
    ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&string))
    ak.string_builder_append(builder, "\n")

# mark: MediaQuery ==============================================================================

## A MediaQuery with its default member initializers (`new MediaQuery`).
func css_media_query_new() -> CssMediaQuery*:
    let media_query = new CssMediaQuery else trap("out of memory")
    css_media_query_init_fields(media_query)
    return media_query

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:17 Web::CSS::MediaQuery::create_not_all.
pub func css_media_query_create_not_all() -> CssMediaQuery*:
    let media_query = css_media_query_new()
    media_query.m_negated = true
    media_query.m_media_type = CssMediaQueryMediaType(name = ak.fly_string_from_str("all"), known_type = CssMediaQueryKnownMediaType.all)

    return media_query

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:201 Web::CSS::MediaQuery::create.
pub func css_media_query_create() -> CssMediaQuery*:
    return css_media_query_new()

## Ported from Libraries/LibWeb/CSS/MediaQuery.h:203 Web::CSS::MediaQuery::matches.
pub func css_media_query_matches(this: const CssMediaQuery*) -> bool:
    return this.m_matches

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:251 Web::CSS::MediaQuery::to_string.
pub func css_media_query_to_string(this: const CssMediaQuery*) -> ak.String:
    var builder = ak.string_builder_new()

    if this.m_negated:
        ak.string_builder_append(&builder, "not ")

    if this.m_negated or this.m_media_type.known_type != CssMediaQueryKnownMediaType.all or this.m_media_condition == none:
        if let known_type = this.m_media_type.known_type:
            ak.string_builder_append_string_view(&builder, css_to_string_css_media_query_known_media_ty(known_type))
        else:
            let lowercase_name = ak.fly_string_to_ascii_lowercase(&this.m_media_type.name)
            let identifier = css_syntax.serialize_an_identifier_string_view(ak.fly_string_bytes_as_string_view(&lowercase_name))
            ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&identifier))
        if this.m_media_condition != none:
            ak.string_builder_append(&builder, " and ")

    if let media_condition = this.m_media_condition:
        let condition = css_boolean_expression_to_string(media_condition)
        ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&condition))

    return ak.string_builder_to_string(&builder) else trap("MUST: StringBuilder::to_string")

## MediaQuery::evaluate's `matches_media` lambda.
func css_media_query_matches_media(media: const CssMediaQueryMediaType*) -> CssMatchResult:
    let known_type = media.known_type else return CssMatchResult.false_
    match known_type:
        .all:
            return CssMatchResult.true_
        .print_:
            # FIXME: Enable for printing, when we have printing!
            return CssMatchResult.false_
        .screen:
            # FIXME: Disable for printing, when we have printing!
            return CssMatchResult.true_
        _:
            trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:275 Web::CSS::MediaQuery::evaluate.
pub func css_media_query_evaluate(this: CssMediaQuery*, document: DomDocument*) -> bool:
    var result = css_media_query_matches_media(&this.m_media_type)

    if result != CssMatchResult.false_:
        if let media_condition = this.m_media_condition:
            result = css_and(result, css_boolean_expression_evaluate(media_condition, document))

    if this.m_negated:
        result = css_negate(result)

    this.m_matches = result == CssMatchResult.true_
    return this.m_matches

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:305 Web::CSS::MediaQuery::dump.
pub func css_media_query_dump(this: const CssMediaQuery*, builder: ak.StringBuilder*, indent_levels: i32 = 0):
    dump_indent(builder, indent_levels)
    dump_appendff(builder, "Media condition: (matches = {})\n", [ak.arg_bool(this.m_matches)])

    dump_indent(builder, indent_levels + 1)
    dump_appendff(builder, "Negated: {}\n", [ak.arg_bool(this.m_negated)])

    dump_indent(builder, indent_levels + 1)
    dump_appendff(builder, "Type: {}\n", [dump_arg_fly_string(&this.m_media_type.name)])

    if let media_condition = this.m_media_condition:
        dump_indent(builder, indent_levels + 1)
        ak.string_builder_append(builder, "Condition:\n")
        css_boolean_expression_dump(media_condition, builder, indent_levels + 2)

# mark: Media query lists and media types =======================================================

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:324 Web::CSS::serialize_a_media_query_list.
# https://www.w3.org/TR/cssom-1/#serialize-a-media-query-list
pub func css_serialize_a_media_query_list(media_queries: ak.Vector[CssMediaQuery*]) -> ak.String:
    # 1. If the media query list is empty, then return the empty string.
    if ak.vector_is_empty(&media_queries):
        return ak.string_new()

    # 2. Serialize each media query in the list of media queries, in the same order as they
    # appear in the media query list, and then serialize the list.
    var builder = ak.string_builder_new()
    var first = true
    for media_query in ak.vector_span_const(&media_queries):
        if not first:
            ak.string_builder_append(&builder, ", ")
        first = false
        let serialized = css_media_query_to_string(media_query)
        ak.string_builder_append_string_view(&builder, ak.string_bytes_as_string_view(&serialized))
    return ak.string_builder_to_string(&builder) else trap("MUST: String::join")

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:335 Web::CSS::media_type_from_string.
pub func css_media_type_from_string(name: ak.StringView) -> CssMediaQueryKnownMediaType?:
    if ak.string_view_equals_ignoring_ascii_case(&name, ak.sv("all")):
        return CssMediaQueryKnownMediaType.all
    if ak.string_view_equals_ignoring_ascii_case(&name, ak.sv("print")):
        return CssMediaQueryKnownMediaType.print_
    if ak.string_view_equals_ignoring_ascii_case(&name, ak.sv("screen")):
        return CssMediaQueryKnownMediaType.screen
    return none

## Ported from Libraries/LibWeb/CSS/MediaQuery.cpp:346 Web::CSS::to_string.
pub func css_to_string_css_media_query_known_media_ty(media_type: CssMediaQueryKnownMediaType) -> ak.StringView:
    match media_type:
        .all: return ak.sv("all")
        .print_: return ak.sv("print")
        .screen: return ak.sv("screen")
        _: trap("VERIFY_NOT_REACHED")