Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / style_values / shorthand_style_value_3.lucb

#==============================================================================================
#
#   shorthand_style_value_3 - ShorthandStyleValue: the special cases of serialize (grid, mask, text)
#
#   DESCRIPTION:
#       Port of the cases of ShorthandStyleValue::serialize's switch (ShorthandStyleValue.cpp
#       lines 553-980) that shorthand_style_value_1 calls, one function per shorthand, in the
#       switch's order. Each was a `case` body in C++: `return` there ends serialize, here it ends
#       the case's function, which serialize returns from at once. The lambdas of a case are
#       functions named after them.
#
#       Copyright (c) 2023, Ali Mohammad Pur <mpfard@serenityos.org>
#       Copyright (c) 2018-2020, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021, Tobias Christiansen <tobyase@serenityos.org>
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       Copyright (c) 2022-2023, MacDue <macdue@dueutil.tech>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Grid ====================================================================================

## The `is_auto` lambda of the `grid-area` case.
func css_shorthand_is_auto_track_placement(track_placement: CssStyleValue*) -> bool:
    if css_style_value_is_grid_track_placement(track_placement):
        let placement = css_grid_track_placement_style_value_grid_track_placement(css_style_value_as_grid_track_placement(track_placement))
        return css_grid_track_placement_is_auto(&placement)
    return false

## The `serialize_grid_area` lambda of the `grid-area` case.
func css_shorthand_serialize_grid_area(builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, row_start: CssStyleValue*, column_start: CssStyleValue*, row_end: CssStyleValue*, column_end: CssStyleValue*):
    if css_style_values_equal(row_start, column_start) and css_style_values_equal(row_start, row_end) and css_style_values_equal(row_start, column_end):
        css_style_value_serialize(row_start, builder, mode)
        return
    if css_style_values_equal(row_start, row_end) and css_style_values_equal(column_start, column_end):
        css_style_value_serialize(row_start, builder, mode)
        ak.string_builder_append(builder, " / ")
        css_style_value_serialize(column_start, builder, mode)
        return
    if css_style_values_equal(column_start, column_end):
        if css_shorthand_is_auto_track_placement(row_end):
            if css_shorthand_is_auto_track_placement(column_start):
                css_style_value_serialize(row_start, builder, mode)
                return
            css_style_value_serialize(row_start, builder, mode)
            ak.string_builder_append(builder, " / ")
            css_style_value_serialize(column_start, builder, mode)
            return
        css_style_value_serialize(row_start, builder, mode)
        ak.string_builder_append(builder, " / ")
        css_style_value_serialize(column_start, builder, mode)
        ak.string_builder_append(builder, " / ")
        css_style_value_serialize(row_end, builder, mode)
        return
    css_style_value_serialize(row_start, builder, mode)
    ak.string_builder_append(builder, " / ")
    css_style_value_serialize(column_start, builder, mode)
    ak.string_builder_append(builder, " / ")
    css_style_value_serialize(row_end, builder, mode)
    ak.string_builder_append(builder, " / ")
    css_style_value_serialize(column_end, builder, mode)

## ShorthandStyleValue::serialize, `case PropertyID::GridArea` (ShorthandStyleValue.cpp:553).
func css_shorthand_style_value_serialize_grid_area(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    # https://drafts.csswg.org/css-grid/#propdef-grid-area
    # The grid-area property is a shorthand for grid-row-start, grid-column-start, grid-row-end and grid-column-end.
    var row_start = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_row_start)
    var column_start = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_column_start)
    var row_end = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_row_end)
    var column_end = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_column_end)

    # If four <grid-line> values are specified, grid-row-start is set to the first value, grid-column-start is set
    # to the second value, grid-row-end is set to the third value, and grid-column-end is set to the fourth value.
    if not css_shorthand_is_auto_track_placement(row_start) and not css_shorthand_is_auto_track_placement(column_start) and not css_shorthand_is_auto_track_placement(row_end) and not css_shorthand_is_auto_track_placement(column_end):
        css_shorthand_serialize_grid_area(builder, mode, row_start, column_start, row_end, column_end)
        return

    # When grid-column-end is omitted, if grid-column-start is a <custom-ident>, grid-column-end is set to that
    # <custom-ident>; otherwise, it is set to auto.
    if css_shorthand_is_auto_track_placement(column_end) and css_style_value_is_custom_ident(column_start):
        column_end = column_start

    # When grid-column-start is omitted, if grid-row-start is a <custom-ident>, all four longhands are set to
    # that value. Otherwise, it is set to auto.
    if css_shorthand_is_auto_track_placement(column_start) and css_style_value_is_custom_ident(row_start):
        column_start = row_start
        row_end = row_start
        column_end = row_start

    # When grid-row-end is omitted, if grid-row-start is a <custom-ident>, grid-row-end is set to that
    # <custom-ident>; otherwise, it is set to auto.
    if css_shorthand_is_auto_track_placement(row_end) and css_style_value_is_custom_ident(row_start):
        row_end = row_start

    css_shorthand_serialize_grid_area(builder, mode, row_start, column_start, row_end, column_end)

## The `is_initial` lambda of the `grid` case.
func css_shorthand_is_initial(value: CssStyleValue*, property: css_data.PropertyId) -> bool:
    return css_style_value_eq(value, css_property_initial_value(property))

## ShorthandStyleValue::serialize, `case PropertyID::Grid` (ShorthandStyleValue.cpp:629). Answers whether the case
## falls through to `grid-template` (C++'s `[[fallthrough]]`).
func css_shorthand_style_value_serialize_grid(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode) -> bool:
    # https://drafts.csswg.org/css-grid/#propdef-grid
    # <'grid-template'> |
    # <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>? |
    # [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>
    let auto_flow_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_auto_flow)
    let auto_rows_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_auto_rows)
    let auto_columns_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_auto_columns)

    let auto_flow_is_initial = css_shorthand_is_initial(auto_flow_value, css_data.PropertyId.grid_auto_flow)
    let auto_rows_is_initial = css_shorthand_is_initial(auto_rows_value, css_data.PropertyId.grid_auto_rows)
    let auto_columns_is_initial = css_shorthand_is_initial(auto_columns_value, css_data.PropertyId.grid_auto_columns)

    if not auto_flow_is_initial or not auto_rows_is_initial or not auto_columns_is_initial:
        let areas_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_areas)
        let rows_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_rows)
        let columns_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_columns)

        let areas_is_initial = css_shorthand_is_initial(areas_value, css_data.PropertyId.grid_template_areas)
        let rows_is_initial = css_shorthand_is_initial(rows_value, css_data.PropertyId.grid_template_rows)
        let columns_is_initial = css_shorthand_is_initial(columns_value, css_data.PropertyId.grid_template_columns)

        let auto_flow = css_style_value_as_grid_auto_flow(auto_flow_value)

        # [ auto-flow && dense? ] <'grid-auto-rows'>? / <'grid-template-columns'>
        if css_grid_auto_flow_style_value_is_row(auto_flow) and auto_columns_is_initial and areas_is_initial and rows_is_initial:
            ak.string_builder_append(builder, "auto-flow")
            if css_grid_auto_flow_style_value_is_dense(auto_flow):
                ak.string_builder_append(builder, " dense")
            if not auto_rows_is_initial:
                ak.string_builder_append_u8(builder, ' ')
                css_style_value_serialize(auto_rows_value, builder, mode)
            ak.string_builder_append(builder, " / ")
            css_style_value_serialize(columns_value, builder, mode)
            return false

        # <'grid-template-rows'> / [ auto-flow && dense? ] <'grid-auto-columns'>?
        if css_grid_auto_flow_style_value_is_column(auto_flow) and auto_rows_is_initial and areas_is_initial and columns_is_initial:
            css_style_value_serialize(rows_value, builder, mode)
            ak.string_builder_append(builder, " / auto-flow")
            if css_grid_auto_flow_style_value_is_dense(auto_flow):
                ak.string_builder_append(builder, " dense")
            if not auto_columns_is_initial:
                ak.string_builder_append_u8(builder, ' ')
                css_style_value_serialize(auto_columns_value, builder, mode)
            return false

        return false

    # <'grid-template'>
    return true

## The `construct_rows_string` lambda of the `grid-template` case.
func css_shorthand_construct_rows_string(areas: CssGridTemplateAreaStyleValue*, rows: CssGridTrackSizeListStyleValue*, mode: css_syntax.SerializationMode) -> ak.String:
    var inner_builder = ak.string_builder_new()
    var area_index: usize = 0
    let row_list = css_grid_track_size_list_style_value_grid_track_size_list(rows)
    let list = css_grid_track_size_list_list(&row_list)
    for i in 0..<ak.vector_size(&list):
        match *ak.vector_at_const(&list, i):
            .css_grid_line_names(line_names):
                if i != 0:
                    ak.string_builder_append_u8(&inner_builder, ' ')
                css_grid_line_names_serialize(&line_names, &inner_builder)
            .css_explicit_grid_track(track_size):
                if area_index < css_grid_template_area_style_value_row_count(areas):
                    if not ak.string_builder_is_empty(&inner_builder):
                        ak.string_builder_append_u8(&inner_builder, ' ')
                    ak.string_builder_append(&inner_builder, "\"")
                    for y in 0..<css_grid_template_area_style_value_column_count(areas):
                        if y != 0:
                            ak.string_builder_append_u8(&inner_builder, ' ')
                        let cell_name = css_grid_template_area_style_value_cell_name_at(areas, area_index, y)
                        ak.string_builder_append_string_view(&inner_builder, ak.string_bytes_as_string_view(&cell_name))
                    ak.string_builder_append(&inner_builder, "\"")
                let track_size_serialization = css_explicit_grid_track_to_string(&track_size, mode)
                if not ak.string_eq_string_view(&track_size_serialization, ak.sv("auto")):
                    if not ak.string_builder_is_empty(&inner_builder):
                        ak.string_builder_append_u8(&inner_builder, ' ')
                    ak.string_builder_append_string_view(&inner_builder, ak.string_bytes_as_string_view(&track_size_serialization))
                area_index += 1
    return ak.string_builder_to_string(&inner_builder) else trap("MUST: StringBuilder::to_string")

## ShorthandStyleValue::serialize, `case PropertyID::GridTemplate` (ShorthandStyleValue.cpp:690).
func css_shorthand_style_value_serialize_grid_template(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    let areas_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_areas)
    let rows_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_rows)
    let columns_value = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.grid_template_columns)

    if not css_style_value_is_grid_template_area(areas_value) or not css_style_value_is_grid_track_size_list(rows_value) or not css_style_value_is_grid_track_size_list(columns_value):
        css_shorthand_style_value_default_serialize(this, builder, mode)
        return

    let areas = css_style_value_as_grid_template_area(areas_value)
    let rows = css_style_value_as_grid_track_size_list(rows_value)
    let columns = css_style_value_as_grid_track_size_list(columns_value)
    let row_list = css_grid_track_size_list_style_value_grid_track_size_list(rows)
    let column_list = css_grid_track_size_list_style_value_grid_track_size_list(columns)

    let row_tracks = css_grid_track_size_list_track_list(&row_list)
    let column_tracks = css_grid_track_size_list_track_list(&column_list)
    if css_grid_template_area_style_value_row_count(areas) == 0 and ak.vector_size(&row_tracks) == 0 and ak.vector_size(&column_tracks) == 0:
        ak.string_builder_append(builder, "none")
        return

    if css_grid_template_area_style_value_row_count(areas) == 0:
        css_grid_track_size_list_serialize(&row_list, builder, mode)
        ak.string_builder_append(builder, " / ")
        css_grid_track_size_list_serialize(&column_list, builder, mode)
        return

    let rows_serialization = css_shorthand_construct_rows_string(areas, rows, mode)
    if ak.string_is_empty(&rows_serialization):
        return

    if css_grid_track_size_list_is_empty(&column_list):
        ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&rows_serialization))
        return
    ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&rows_serialization))
    ak.string_builder_append(builder, " / ")
    css_grid_track_size_list_serialize(&column_list, builder, mode)

## ShorthandStyleValue::serialize, `case PropertyID::GridColumn` and `case PropertyID::GridRow`
## (ShorthandStyleValue.cpp:758, 770), the same body over a start and an end longhand.
func css_shorthand_style_value_serialize_grid_line_pair(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, start_id: css_data.PropertyId, end_id: css_data.PropertyId):
    let start = css_shorthand_style_value_required_longhand(this, start_id)
    let end = css_shorthand_style_value_required_longhand(this, end_id)
    let end_placement = css_grid_track_placement_style_value_grid_track_placement(css_style_value_as_grid_track_placement(end))
    if css_grid_track_placement_is_auto(&end_placement) or css_style_values_equal(start, end):
        css_style_value_serialize(start, builder, mode)
        return
    css_style_value_serialize(start, builder, mode)
    ak.string_builder_append(builder, " / ")
    css_style_value_serialize(end, builder, mode)

# mark: Mask ====================================================================================

## The value of a property among a mask layer's, the `property_value_string` lambda of the `mask` case.
func css_shorthand_mask_property_value_string(property_ids: const css_data.PropertyId[], property_values: const (CssStyleValue*?)[], property: css_data.PropertyId, mode: css_syntax.SerializationMode) -> ak.String:
    for i in 0..<property_ids.length:
        if property_ids[i] == property:
            return css_style_value_to_string(property_values[i] else trap("VERIFY: a mask layer value"), mode)
    trap("VERIFY_NOT_REACHED")

## The `is_initial_value` lambda of the `mask` case.
func css_shorthand_mask_is_initial_value(property_ids: const css_data.PropertyId[], property_values: const (CssStyleValue*?)[], property: css_data.PropertyId, mode: css_syntax.SerializationMode) -> bool:
    let value_string = css_shorthand_mask_property_value_string(property_ids, property_values, property, mode)
    let initial_string = css_style_value_to_string(css_property_initial_value(property), mode)
    return css_strings_equal(value_string, initial_string)

## The `can_skip_serializing_initial_value` lambda of the `mask` case.
func css_shorthand_mask_can_skip_serializing_initial_value(property_ids: const css_data.PropertyId[], property_values: const (CssStyleValue*?)[], property: css_data.PropertyId, mode: css_syntax.SerializationMode) -> bool:
    match property:
        .mask_position:
            return css_shorthand_mask_is_initial_value(property_ids, property_values, css_data.PropertyId.mask_size, mode)
        .mask_origin:
            let clip_string = css_shorthand_mask_property_value_string(property_ids, property_values, css_data.PropertyId.mask_clip, mode)
            return css_shorthand_mask_is_initial_value(property_ids, property_values, css_data.PropertyId.mask_clip, mode) or ak.string_eq_string_view(&clip_string, css_data.string_from_keyword(css_data.Keyword.no_clip))
        _:
            return true

## The `serialize_layer` lambda of the `mask` case.
func css_shorthand_serialize_mask_layer(builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, image_value: CssStyleValue*?, position_value: CssStyleValue*?, size_value: CssStyleValue*?, repeat_value: CssStyleValue*?, origin_value: CssStyleValue*?, clip_value: CssStyleValue*?, composite_value: CssStyleValue*?, mode_value: CssStyleValue*?):
    let canonical_property_order: css_data.PropertyId[7] = [
        css_data.PropertyId.mask_image,
        css_data.PropertyId.mask_position,
        # Intentionally skipping MaskSize here, it is handled together with MaskPosition.
        css_data.PropertyId.mask_repeat,
        css_data.PropertyId.mask_origin,
        css_data.PropertyId.mask_clip,
        css_data.PropertyId.mask_composite,
        css_data.PropertyId.mask_mode,
    ]

    let property_ids: css_data.PropertyId[8] = [css_data.PropertyId.mask_image, css_data.PropertyId.mask_position, css_data.PropertyId.mask_size, css_data.PropertyId.mask_repeat, css_data.PropertyId.mask_origin, css_data.PropertyId.mask_clip, css_data.PropertyId.mask_composite, css_data.PropertyId.mask_mode]
    let property_values: (CssStyleValue*?)[8] = [image_value, position_value, size_value, repeat_value, origin_value, clip_value, composite_value, mode_value]

    var layer_is_empty = true
    for property in canonical_property_order:
        let value = css_shorthand_mask_property_value_string(property_ids, property_values, property, mode)

        if css_shorthand_mask_is_initial_value(property_ids, property_values, property, mode) and css_shorthand_mask_can_skip_serializing_initial_value(property_ids, property_values, property, mode):
            continue
        if property == css_data.PropertyId.mask_clip and css_strings_equal(value, css_shorthand_mask_property_value_string(property_ids, property_values, css_data.PropertyId.mask_origin, mode)):
            continue

        if not layer_is_empty:
            ak.string_builder_append_u8(builder, ' ')
        ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&value))
        if property == css_data.PropertyId.mask_position and not css_shorthand_mask_is_initial_value(property_ids, property_values, css_data.PropertyId.mask_size, mode):
            ak.string_builder_append(builder, " / ")
            let size_string = css_shorthand_mask_property_value_string(property_ids, property_values, css_data.PropertyId.mask_size, mode)
            ak.string_builder_append_string_view(builder, ak.string_bytes_as_string_view(&size_string))
        layer_is_empty = false

    if layer_is_empty:
        ak.string_builder_append(builder, "none")

## ShorthandStyleValue::serialize, `case PropertyID::Mask` (ShorthandStyleValue.cpp:782).
func css_shorthand_style_value_serialize_mask(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    let mask_image = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_image)
    let mask_position = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_position)
    let mask_size = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_size)
    let mask_repeat = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_repeat)
    let mask_origin = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_origin)
    let mask_clip = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_clip)
    let mask_composite = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_composite)
    let mask_mode = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.mask_mode)

    let layer_count = ak.max[usize](css_shorthand_layer_count(mask_image), ak.max[usize](css_shorthand_layer_count(mask_position), ak.max[usize](css_shorthand_layer_count(mask_size), ak.max[usize](css_shorthand_layer_count(mask_repeat), ak.max[usize](css_shorthand_layer_count(mask_origin), ak.max[usize](css_shorthand_layer_count(mask_clip), ak.max[usize](css_shorthand_layer_count(mask_composite), css_shorthand_layer_count(mask_mode))))))))

    if layer_count == 1:
        css_shorthand_serialize_mask_layer(builder, mode, mask_image, mask_position, mask_size, mask_repeat, mask_origin, mask_clip, mask_composite, mask_mode)
    else:
        for i in 0..<layer_count:
            if i != 0:
                ak.string_builder_append(builder, ", ")

            css_shorthand_serialize_mask_layer(builder, mode, css_shorthand_layer_value(mask_image, i), css_shorthand_layer_value(mask_position, i), css_shorthand_layer_value(mask_size, i), css_shorthand_layer_value(mask_repeat, i), css_shorthand_layer_value(mask_origin, i), css_shorthand_layer_value(mask_clip, i), css_shorthand_layer_value(mask_composite, i), css_shorthand_layer_value(mask_mode, i))

# mark: Text ====================================================================================

## The `append_if_non_default` lambda of the `text-decoration` case.
func css_shorthand_append_if_non_default(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode, property_id: css_data.PropertyId):
    let value = css_shorthand_style_value_required_longhand(this, property_id)
    if not css_style_value_equals(value, css_property_initial_value(property_id)):
        if not ak.string_builder_is_empty(builder):
            ak.string_builder_append_u8(builder, ' ')
        css_style_value_serialize(value, builder, mode)

## ShorthandStyleValue::serialize, `case PropertyID::TextDecoration` (ShorthandStyleValue.cpp:900).
func css_shorthand_style_value_serialize_text_decoration(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    # The rule here seems to be, only print what's different from the default value,
    # but if they're all default, print the line.
    css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_line)
    css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_thickness)
    css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_style)
    css_shorthand_append_if_non_default(this, builder, mode, css_data.PropertyId.text_decoration_color)

    if ak.string_builder_is_empty(builder):
        css_style_value_serialize(css_shorthand_style_value_required_longhand(this, css_data.PropertyId.text_decoration_line), builder, mode)

## ShorthandStyleValue::serialize, `case PropertyID::WhiteSpace` (ShorthandStyleValue.cpp:933).
func css_shorthand_style_value_serialize_white_space(this: CssShorthandStyleValue*, builder: ak.StringBuilder*, mode: css_syntax.SerializationMode):
    let white_space_collapse_property = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.white_space_collapse)
    let text_wrap_mode_property = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.text_wrap_mode)
    let white_space_trim_property = css_shorthand_style_value_required_longhand(this, css_data.PropertyId.white_space_trim)

    if css_style_value_is_keyword(white_space_trim_property) and css_keyword_style_value_keyword(css_style_value_as_keyword(white_space_trim_property)) == css_data.Keyword.none_:
        let white_space_collapse_keyword = css_keyword_style_value_keyword(css_style_value_as_keyword(white_space_collapse_property))
        let text_wrap_mode_keyword = css_keyword_style_value_keyword(css_style_value_as_keyword(text_wrap_mode_property))

        if white_space_collapse_keyword == css_data.Keyword.collapse and text_wrap_mode_keyword == css_data.Keyword.wrap:
            ak.string_builder_append(builder, "normal")
            return

        if white_space_collapse_keyword == css_data.Keyword.preserve and text_wrap_mode_keyword == css_data.Keyword.nowrap:
            ak.string_builder_append(builder, "pre")
            return

        if white_space_collapse_keyword == css_data.Keyword.preserve and text_wrap_mode_keyword == css_data.Keyword.wrap:
            ak.string_builder_append(builder, "pre-wrap")
            return

        if white_space_collapse_keyword == css_data.Keyword.preserve_breaks and text_wrap_mode_keyword == css_data.Keyword.wrap:
            ak.string_builder_append(builder, "pre-line")
            return

    css_shorthand_style_value_default_serialize(this, builder, mode)