Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / computed_properties_3.lucb

#==============================================================================================
#
#   computed_properties_3 - ComputedProperties: equality, text, content, cursor, shadows
#
#   DESCRIPTION:
#       Port of LibWeb/CSS/ComputedProperties.cpp (lines 891-1398): operator==, the text
#       readers (anchor, alignment, justification, overflow, rendering, underline, tab-size,
#       word-break, spacing, white-space, decoration, transform, indent), the line and outline
#       styles, float, caret-color, clear, column-span, `content` (with quotes and counters),
#       content-visibility, cursor, visibility, display, list-style, overflow and the box and
#       text shadows.
#
#       Copyright (c) 2018-2025, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Equality and text =======================================================================

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:897 Web::CSS::ComputedProperties::operator==.
pub func css_computed_properties_eq(this: CssComputedProperties*, other: CssComputedProperties*) -> bool:
    for i in 0..<css_data.number_of_longhand_properties:
        let my_style = this.m_property_values[i]
        let other_style = other.m_property_values[i]
        if let my_value = my_style:
            let other_value = other_style else return false
            if css_style_value_type(my_value) != css_style_value_type(other_value):
                return false
            if not css_style_value_equals(my_value, other_value):
                return false
        elif other_style != none:
            return false

    return true

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:920 Web::CSS::ComputedProperties::text_anchor.
pub func css_computed_properties_text_anchor(this: CssComputedProperties*) -> css_data.TextAnchor:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_anchor)
    return css_data.keyword_to_text_anchor(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:926 Web::CSS::ComputedProperties::dominant_baseline.
pub func css_computed_properties_dominant_baseline(this: CssComputedProperties*) -> css_data.BaselineMetric?:
    let value = css_computed_properties_property(this, css_data.PropertyId.dominant_baseline)
    return css_data.keyword_to_baseline_metric(css_style_value_to_keyword(value))

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:932 Web::CSS::ComputedProperties::text_align.
pub func css_computed_properties_text_align(this: CssComputedProperties*) -> css_data.TextAlign:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_align)
    return css_data.keyword_to_text_align(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:938 Web::CSS::ComputedProperties::text_justify.
pub func css_computed_properties_text_justify(this: CssComputedProperties*) -> css_data.TextJustify:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_justify)
    return css_data.keyword_to_text_justify(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:944 Web::CSS::ComputedProperties::text_overflow.
pub func css_computed_properties_text_overflow(this: CssComputedProperties*) -> css_data.TextOverflow:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_overflow)
    return css_data.keyword_to_text_overflow(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:950 Web::CSS::ComputedProperties::text_rendering.
pub func css_computed_properties_text_rendering(this: CssComputedProperties*) -> css_data.TextRendering:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_rendering)
    return css_data.keyword_to_text_rendering(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:956 Web::CSS::ComputedProperties::text_underline_offset.
pub func css_computed_properties_text_underline_offset(this: CssComputedProperties*) -> gfx.CssPixels:
    let computed_text_underline_offset = css_computed_properties_property(this, css_data.PropertyId.text_underline_offset)

    # auto
    if css_style_value_to_keyword(computed_text_underline_offset) == css_data.Keyword.auto:
        return css_initial_values_text_underline_offset()

    # <length>
    # <percentage>
    let length = css_length_from_style_value(computed_text_underline_offset, css_length_make_px_css_pixels(css_computed_properties_font_size(this)))
    return css_length_absolute_length_to_px(&length)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:969 Web::CSS::ComputedProperties::text_underline_position.
pub func css_computed_properties_text_underline_position(this: CssComputedProperties*) -> CssTextUnderlinePosition:
    let computed_text_underline_position = css_style_value_as_text_underline_position(css_computed_properties_property(this, css_data.PropertyId.text_underline_position))

    return CssTextUnderlinePosition(
        horizontal = css_text_underline_position_style_value_horizontal(computed_text_underline_position),
        vertical = css_text_underline_position_style_value_vertical(computed_text_underline_position))

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:979 Web::CSS::ComputedProperties::pointer_events.
pub func css_computed_properties_pointer_events(this: CssComputedProperties*) -> css_data.PointerEvents:
    let value = css_computed_properties_property(this, css_data.PropertyId.pointer_events)
    return css_data.keyword_to_pointer_events(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:985 Web::CSS::ComputedProperties::tab_size.
pub func css_computed_properties_tab_size(this: CssComputedProperties*) -> CssLengthOrF64:
    let value = css_computed_properties_property(this, css_data.PropertyId.tab_size)
    if css_style_value_is_calculated(value):
        let math_value = css_style_value_as_calculated(value)
        if css_calculated_style_value_resolves_to_length(math_value):
            return CssLengthOrF64.css_length(css_calculated_style_value_resolve_length(math_value, CssCalculationResolutionContext()) else trap("VERIFY: Optional::value() of resolve_length()"))
        if css_calculated_style_value_resolves_to_number(math_value):
            return CssLengthOrF64.f64_(css_calculated_style_value_resolve_number(math_value, CssCalculationResolutionContext()) else trap("VERIFY: Optional::value() of resolve_number()"))

    if css_style_value_is_length(value):
        return CssLengthOrF64.css_length(css_length_style_value_length(css_style_value_as_length(value)))

    return CssLengthOrF64.f64_(css_number_style_value_number(css_style_value_as_number(value)))

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1004 Web::CSS::ComputedProperties::word_break.
pub func css_computed_properties_word_break(this: CssComputedProperties*) -> css_data.WordBreak:
    let value = css_computed_properties_property(this, css_data.PropertyId.word_break)
    return css_data.keyword_to_word_break(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1010 Web::CSS::ComputedProperties::word_spacing.
pub func css_computed_properties_word_spacing(this: CssComputedProperties*) -> gfx.CssPixels:
    let value = css_computed_properties_property(this, css_data.PropertyId.word_spacing)
    if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.normal:
        return gfx.css_pixels_from_int(0)

    let length = css_length_from_style_value(value, css_length_make_px_css_pixels(css_computed_properties_font_size(this)))
    return css_length_absolute_length_to_px(&length)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1019 Web::CSS::ComputedProperties::white_space_collapse.
pub func css_computed_properties_white_space_collapse(this: CssComputedProperties*) -> css_data.WhiteSpaceCollapse:
    let value = css_computed_properties_property(this, css_data.PropertyId.white_space_collapse)
    return css_data.keyword_to_white_space_collapse(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1025 Web::CSS::ComputedProperties::white_space_trim.
pub func css_computed_properties_white_space_trim(this: CssComputedProperties*) -> CssWhiteSpaceTrimData:
    let value = css_computed_properties_property(this, css_data.PropertyId.white_space_trim)

    if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.none_:
        return CssWhiteSpaceTrimData()

    if css_style_value_is_value_list(value):
        var white_space_trim_data = CssWhiteSpaceTrimData()

        let values = css_style_value_list_values(css_style_value_as_value_list(value))
        for item in ak.vector_span_const(&values):
            match css_keyword_style_value_keyword(css_style_value_as_keyword(item)):
                .discard_before:
                    white_space_trim_data.discard_before = true
                .discard_after:
                    white_space_trim_data.discard_after = true
                .discard_inner:
                    white_space_trim_data.discard_inner = true
                _:
                    trap("VERIFY_NOT_REACHED")

        return white_space_trim_data

    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1057 Web::CSS::ComputedProperties::letter_spacing.
pub func css_computed_properties_letter_spacing(this: CssComputedProperties*) -> gfx.CssPixels:
    let value = css_computed_properties_property(this, css_data.PropertyId.letter_spacing)
    if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.normal:
        return gfx.css_pixels_from_int(0)

    let length = css_length_from_style_value(value, css_length_make_px_css_pixels(css_computed_properties_font_size(this)))
    return css_length_absolute_length_to_px(&length)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1066 Web::CSS::ComputedProperties::line_style.
pub func css_computed_properties_line_style(this: CssComputedProperties*, property_id: css_data.PropertyId) -> css_data.LineStyle:
    let value = css_computed_properties_property(this, property_id)
    return css_data.keyword_to_line_style(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1072 Web::CSS::ComputedProperties::outline_style.
pub func css_computed_properties_outline_style(this: CssComputedProperties*) -> css_data.OutlineStyle:
    let value = css_computed_properties_property(this, css_data.PropertyId.outline_style)
    return css_data.keyword_to_outline_style(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1078 Web::CSS::ComputedProperties::float_.
pub func css_computed_properties_float(this: CssComputedProperties*) -> css_data.Float:
    let value = css_computed_properties_property(this, css_data.PropertyId.float)
    return css_data.keyword_to_float(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1084 Web::CSS::ComputedProperties::caret_color.
pub func css_computed_properties_caret_color(this: CssComputedProperties*, node: LayoutNodeWithStyle*) -> gfx.Color:
    let value = css_computed_properties_property(this, css_data.PropertyId.caret_color)
    if css_style_value_is_keyword(value) and css_style_value_to_keyword(value) == css_data.Keyword.auto:
        let computed_values = layout_node_with_style_computed_values(node)
        return css_computed_values_color(&computed_values.computed_values)

    if css_style_value_has_color(value):
        return css_style_value_to_color(value, css_color_resolution_context_for_layout_node_with_style(node)) else trap("VERIFY: Optional::value() of to_color()")

    return css_initial_values_caret_color()

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1096 Web::CSS::ComputedProperties::clear.
pub func css_computed_properties_clear(this: CssComputedProperties*) -> css_data.Clear:
    let value = css_computed_properties_property(this, css_data.PropertyId.clear)
    return css_data.keyword_to_clear(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1102 Web::CSS::ComputedProperties::column_span.
pub func css_computed_properties_column_span(this: CssComputedProperties*) -> css_data.ColumnSpan:
    let value = css_computed_properties_property(this, css_data.PropertyId.column_span)
    return css_data.keyword_to_column_span(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

# mark: content =================================================================================

## The `get_quote_string` lambda of ComputedProperties::content: the open or close quote at `depth`.
func css_computed_properties_get_quote_string(quotes_data: const CssQuotesData*, open: bool, depth: u32) -> ak.FlyString:
    match quotes_data.type_:
        .none_:
            return ak.FlyString()
        .auto:
            # FIXME: "A typographically appropriate used value for quotes is automatically chosen by the UA
            #        based on the content language of the element and/or its parent."
            if open:
                return ak.fly_string_from_str("“") if depth == 0 else ak.fly_string_from_str("‘")
            return ak.fly_string_from_str("”") if depth == 0 else ak.fly_string_from_str("’")
        .specified:
            # If the depth is greater than the number of pairs, the last pair is repeated.
            let level = ak.vector_at_const(&quotes_data.strings, ak.min((usize)depth, ak.vector_size(&quotes_data.strings) - 1))
            return (*level)[0] if open else (*level)[1]
        _:
            trap("VERIFY_NOT_REACHED")

## C++ `dbgln("`{}` is not supported in `<property>` (yet?)", item->to_string(SerializationMode::Normal))`.
func css_computed_properties_dbgln_unsupported(item: CssStyleValue*, property: str):
    let text = css_style_value_to_string(item, css_syntax.SerializationMode.normal)
    ak.dbgln(f"`{ak.string_view_text(ak.string_bytes_as_string_view(&text))}` is not supported in `{property}` (yet?)")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1108 Web::CSS::ComputedProperties::content.
pub func css_computed_properties_content(this: CssComputedProperties*, element_reference: DomAbstractElement*, initial_quote_nesting_level: u32) -> CssComputedPropertiesContentDataAndQuoteNestingLevel:
    let value = css_computed_properties_property(this, css_data.PropertyId.content)
    let quotes_data = css_computed_properties_quotes(this)

    var quote_nesting_level = initial_quote_nesting_level

    if css_style_value_is_content(value):
        let content_style_value = css_style_value_as_content(value)

        var content_data = CssContentData()

        let items = css_style_value_list_values(css_content_style_value_content(content_style_value))
        for item in ak.vector_span_const(&items):
            if css_style_value_is_string(item):
                let string_value = css_string_style_value_string_value(css_style_value_as_string(item))
                ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(ak.fly_string_to_string_const(&string_value)))
            elif css_style_value_is_keyword(item):
                match css_style_value_to_keyword(item):
                    .open_quote:
                        let quote = css_computed_properties_get_quote_string(&quotes_data, true, quote_nesting_level)
                        quote_nesting_level += 1
                        ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(ak.fly_string_to_string_const(&quote)))
                    .close_quote:
                        # A 'close-quote' or 'no-close-quote' that would make the depth negative is in error and is ignored
                        # (at rendering time): the depth stays at 0 and no quote mark is rendered (although the rest of the
                        # 'content' property's value is still inserted).
                        # - https://www.w3.org/TR/CSS21/generate.html#quotes-insert
                        # (This is missing from the CONTENT-3 spec.)
                        if quote_nesting_level > 0:
                            quote_nesting_level -= 1
                            let quote = css_computed_properties_get_quote_string(&quotes_data, false, quote_nesting_level)
                            ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(ak.fly_string_to_string_const(&quote)))
                    .no_open_quote:
                        quote_nesting_level += 1
                    .no_close_quote:
                        # NOTE: See CloseQuote
                        if quote_nesting_level > 0:
                            quote_nesting_level -= 1
                    _:
                        css_computed_properties_dbgln_unsupported(item, "content")
            elif css_style_value_is_counter(item):
                let counter = css_style_value_as_counter(item)
                let counter_style = css_style_value_as_counter_style(css_counter_style_value_counter_style(counter))
                ak.vector_append_t(&content_data.counter_style_dependencies, css_counter_style_style_value_resolve_counter_style(counter_style, dom_abstract_element_style_scope(element_reference)))
                ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.string(css_counter_style_value_resolve(counter, element_reference)))
            elif css_style_value_is_image(item):
                ak.vector_append_t(&content_data.data, StringOrCssImageStyleValue.css_image_style_value(css_style_value_as_image(item)))
            else:
                # TODO: Implement images, and other things.
                css_computed_properties_dbgln_unsupported(item, "content")
        content_data.type_ = CssContentDataType.list

        if let alt_text = css_content_style_value_alt_text(content_style_value):
            var alt_text_builder = ak.string_builder_new()
            let alt_items = css_style_value_list_values(alt_text)
            for item in ak.vector_span_const(&alt_items):
                if css_style_value_is_string(item):
                    let string_value = css_string_style_value_string_value(css_style_value_as_string(item))
                    ak.string_builder_append_string_view(&alt_text_builder, ak.fly_string_bytes_as_string_view(&string_value))
                elif css_style_value_is_counter(item):
                    let counter = css_style_value_as_counter(item)
                    let counter_style = css_style_value_as_counter_style(css_counter_style_value_counter_style(counter))
                    ak.vector_append_t(&content_data.counter_style_dependencies, css_counter_style_style_value_resolve_counter_style(counter_style, dom_abstract_element_style_scope(element_reference)))
                    let resolved = css_counter_style_value_resolve(counter, element_reference)
                    ak.string_builder_append_string_view(&alt_text_builder, ak.string_bytes_as_string_view(&resolved))
                else:
                    css_computed_properties_dbgln_unsupported(item, "content` alt-text")
            content_data.alt_text = ak.string_builder_to_string(&alt_text_builder) else trap("MUST: StringBuilder::to_string()")

        return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = content_data, final_quote_nesting_level = quote_nesting_level)

    match css_style_value_to_keyword(value):
        .none_:
            return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = CssContentData(type_ = CssContentDataType.none_), final_quote_nesting_level = quote_nesting_level)
        .normal:
            return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = CssContentData(type_ = CssContentDataType.normal), final_quote_nesting_level = quote_nesting_level)
        _:
            _ = value

    return CssComputedPropertiesContentDataAndQuoteNestingLevel(content_data = CssContentData(), final_quote_nesting_level = quote_nesting_level)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1209 Web::CSS::ComputedProperties::content_visibility.
pub func css_computed_properties_content_visibility(this: CssComputedProperties*) -> css_data.ContentVisibility:
    let value = css_computed_properties_property(this, css_data.PropertyId.content_visibility)
    return css_data.keyword_to_content_visibility(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

# mark: Cursor, visibility, display, decorations, lists =========================================

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1215 Web::CSS::ComputedProperties::cursor.
pub func css_computed_properties_cursor(this: CssComputedProperties*) -> ak.Vector[CssCursorData]:
    # Return the first available cursor.
    let value = css_computed_properties_property(this, css_data.PropertyId.cursor)
    var cursors: ak.Vector[CssCursorData]
    if css_style_value_is_value_list(value):
        let items = css_style_value_list_values(css_style_value_as_value_list(value))
        for item in ak.vector_span_const(&items):
            if css_style_value_is_cursor(item):
                ak.vector_append_t(&cursors, CssCursorData.css_cursor_style_value(css_style_value_as_cursor(item)))
                continue

            if let keyword = css_data.keyword_to_cursor_predefined(css_style_value_to_keyword(item)):
                ak.vector_append_t(&cursors, CssCursorData.cursor_predefined(keyword))
    elif css_style_value_is_keyword(value):
        if let keyword = css_data.keyword_to_cursor_predefined(css_style_value_to_keyword(value)):
            ak.vector_append_t(&cursors, CssCursorData.cursor_predefined(keyword))

    if ak.vector_is_empty(&cursors):
        ak.vector_append_t(&cursors, CssCursorData.cursor_predefined(css_data.CursorPredefined.auto))

    return cursors

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1241 Web::CSS::ComputedProperties::visibility.
pub func css_computed_properties_visibility(this: CssComputedProperties*) -> css_data.Visibility:
    let value = css_computed_properties_property(this, css_data.PropertyId.visibility)
    if not css_style_value_is_keyword(value):
        return css_data.Visibility.collapse  # `return {};`: the enum's zero value
    return css_data.keyword_to_visibility(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1249 Web::CSS::ComputedProperties::display.
pub func css_computed_properties_display(this: CssComputedProperties*) -> CssDisplay:
    return css_display_style_value_display(css_style_value_as_display(css_computed_properties_property(this, css_data.PropertyId.display)))

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1254 Web::CSS::ComputedProperties::text_decoration_line.
pub func css_computed_properties_text_decoration_line(this: CssComputedProperties*) -> ak.Vector[css_data.TextDecorationLine]:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_line)

    if css_style_value_to_keyword(value) == css_data.Keyword.none_:
        return ak.Vector[css_data.TextDecorationLine]()

    if css_style_value_is_value_list(value):
        var lines: ak.Vector[css_data.TextDecorationLine]
        let values = css_style_value_list_values(css_style_value_as_value_list(value))
        for item in ak.vector_span_const(&values):
            ak.vector_append_t(&lines, css_data.keyword_to_text_decoration_line(css_style_value_to_keyword(item)) else trap("VERIFY: Optional::value()"))
        return lines

    trap("VERIFY_NOT_REACHED")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1273 Web::CSS::ComputedProperties::text_decoration_skip_ink.
pub func css_computed_properties_text_decoration_skip_ink(this: CssComputedProperties*) -> css_data.TextDecorationSkipInk:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_skip_ink)
    return css_data.keyword_to_text_decoration_skip_ink(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1279 Web::CSS::ComputedProperties::text_decoration_style.
pub func css_computed_properties_text_decoration_style(this: CssComputedProperties*) -> css_data.TextDecorationStyle:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_style)
    return css_data.keyword_to_text_decoration_style(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1285 Web::CSS::ComputedProperties::text_decoration_thickness.
pub func css_computed_properties_text_decoration_thickness(this: CssComputedProperties*) -> CssTextDecorationThickness:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_decoration_thickness)
    if css_style_value_is_keyword(value):
        match css_style_value_to_keyword(value):
            .auto:
                return CssTextDecorationThickness(value = CssTextDecorationThicknessAutoOrCssTextDecorationThicknessFromFontOrCssLengthPercentage.css_text_decoration_thickness_auto(CssTextDecorationThicknessAuto()))
            .from_font:
                return CssTextDecorationThickness(value = CssTextDecorationThicknessAutoOrCssTextDecorationThicknessFromFontOrCssLengthPercentage.css_text_decoration_thickness_from_font(CssTextDecorationThicknessFromFont()))
            _:
                trap("VERIFY_NOT_REACHED")

    return CssTextDecorationThickness(value = CssTextDecorationThicknessAutoOrCssTextDecorationThicknessFromFontOrCssLengthPercentage.css_length_percentage(css_length_percentage_from_style_value(value)))

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1302 Web::CSS::ComputedProperties::text_transform.
pub func css_computed_properties_text_transform(this: CssComputedProperties*) -> css_data.TextTransform:
    let value = css_computed_properties_property(this, css_data.PropertyId.text_transform)
    return css_data.keyword_to_text_transform(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1308 Web::CSS::ComputedProperties::list_style_type.
pub func css_computed_properties_list_style_type(this: CssComputedProperties*, style_scope: const CssStyleScope*) -> CssListStyleType:
    let value = css_computed_properties_property(this, css_data.PropertyId.list_style_type)

    if css_style_value_to_keyword(value) == css_data.Keyword.none_:
        return CssListStyleType.empty

    if css_style_value_is_string(value):
        let string_value = css_string_style_value_string_value(css_style_value_as_string(value))
        return CssListStyleType.string(ak.fly_string_to_string_const(&string_value))

    return CssListStyleType.css_counter_style(css_counter_style_style_value_resolve_counter_style(css_style_value_as_counter_style(value), style_scope))

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1321 Web::CSS::ComputedProperties::list_style_position.
pub func css_computed_properties_list_style_position(this: CssComputedProperties*) -> css_data.ListStylePosition:
    let value = css_computed_properties_property(this, css_data.PropertyId.list_style_position)
    return css_data.keyword_to_list_style_position(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

# mark: Overflow, shadows, text-indent ==========================================================

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1327 Web::CSS::ComputedProperties::overflow_x.
pub func css_computed_properties_overflow_x(this: CssComputedProperties*) -> css_data.Overflow:
    return css_computed_properties_overflow(this, css_data.PropertyId.overflow_x)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1332 Web::CSS::ComputedProperties::overflow_y.
pub func css_computed_properties_overflow_y(this: CssComputedProperties*) -> css_data.Overflow:
    return css_computed_properties_overflow(this, css_data.PropertyId.overflow_y)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1337 Web::CSS::ComputedProperties::overflow.
pub func css_computed_properties_overflow(this: CssComputedProperties*, property_id: css_data.PropertyId) -> css_data.Overflow:
    let value = css_computed_properties_property(this, property_id)
    return css_data.keyword_to_overflow(css_style_value_to_keyword(value)) else trap("VERIFY: Optional::release_value()")

## The `make_shadow_data` lambda of ComputedProperties::shadow.
func css_computed_properties_make_shadow_data(layout_node: LayoutNode*, value: CssShadowStyleValue*) -> CssShadowData?:
    let offset_x = css_length_from_style_value(css_shadow_style_value_offset_x(value), none)
    let offset_y = css_length_from_style_value(css_shadow_style_value_offset_y(value), none)
    let blur_radius = css_length_from_style_value(css_shadow_style_value_blur_radius(value), none)
    let spread_distance = css_length_from_style_value(css_shadow_style_value_spread_distance(value), none)
    return CssShadowData(
        offset_x = offset_x,
        offset_y = offset_y,
        blur_radius = blur_radius,
        spread_distance = spread_distance,
        color = css_style_value_to_color(css_shadow_style_value_color(value), css_color_resolution_context_for_layout_node_with_style(as_layout_node_with_style(layout_node))) else trap("VERIFY: Optional::value() of to_color()"),
        placement = css_shadow_style_value_placement(value))

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1343 Web::CSS::ComputedProperties::shadow.
pub func css_computed_properties_shadow(this: CssComputedProperties*, property_id: css_data.PropertyId, layout_node: LayoutNode*) -> ak.Vector[CssShadowData]:
    let value = css_computed_properties_property(this, property_id)

    if css_style_value_to_keyword(value) == css_data.Keyword.none_:
        return ak.Vector[CssShadowData]()

    let value_list = css_style_value_as_value_list(value)

    var shadow_data: ak.Vector[CssShadowData]
    ak.vector_ensure_capacity(&shadow_data, css_style_value_list_size(value_list))
    let layers = css_style_value_list_values(value_list)
    for layer_value in ak.vector_span_const(&layers):
        let maybe_shadow_data = css_computed_properties_make_shadow_data(layout_node, css_style_value_as_shadow(layer_value)) else return ak.Vector[CssShadowData]()
        ak.vector_append_t(&shadow_data, maybe_shadow_data)

    return shadow_data

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1379 Web::CSS::ComputedProperties::box_shadow.
pub func css_computed_properties_box_shadow(this: CssComputedProperties*, layout_node: LayoutNode*) -> ak.Vector[CssShadowData]:
    return css_computed_properties_shadow(this, css_data.PropertyId.box_shadow, layout_node)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1384 Web::CSS::ComputedProperties::text_shadow.
pub func css_computed_properties_text_shadow(this: CssComputedProperties*, layout_node: LayoutNode*) -> ak.Vector[CssShadowData]:
    return css_computed_properties_shadow(this, css_data.PropertyId.text_shadow, layout_node)

## Ported from Libraries/LibWeb/CSS/ComputedProperties.cpp:1389 Web::CSS::ComputedProperties::text_indent.
pub func css_computed_properties_text_indent(this: CssComputedProperties*) -> CssTextIndentData:
    let value = css_style_value_as_text_indent(css_computed_properties_property(this, css_data.PropertyId.text_indent))

    return CssTextIndentData(
        length_percentage = css_length_percentage_from_style_value(css_text_indent_style_value_length_percentage(value)),
        each_line = css_text_indent_style_value_each_line(value),
        hanging = css_text_indent_style_value_hanging(value))