Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / css / interpolation_4.lucb

#==============================================================================================
#
#   interpolation_4 - CSS interpolation: shadows, mixed numeric values and the value types
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/CSS/Interpolation.cpp (lines 1378-1555 and 1556-1776), by
#       region p4a: the interpolation of shadow lists (padding with blank shadows), the value
#       type of a numeric style value, the interpolation of mixed numeric values (a
#       percentage-dimension mix or a calc() of both), and interpolate_value_impl: values of
#       different types or calculated ones are mixed, others are interpolated by their type.
#       Its longer cases (basic shapes, font styles, radial sizes, superellipses, value lists)
#       are functions of part 5. length_percentage_or_auto_to_style_value (lines 1540-1554) is
#       a template no code instantiates, so it is not ported.
#
#       Copyright (c) 2018-2023, Andreas Kling <andreas@ladybird.org>
#       Copyright (c) 2021-2025, Sam Atkins <sam@ladybird.org>
#       Copyright (c) 2024, Matthew Olsson <mattco@serenityos.org>
#       Copyright (c) 2025-2026, Tim Ledbetter <tim.ledbetter@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: Shadows =================================================================================

## interpolate_box_shadow's `process_list` lambda.
func css_box_shadow_process_list(value: CssStyleValue*) -> ak.Vector[CssStyleValue*]:
    if css_style_value_to_keyword(value) == css_data.Keyword.none_:
        return ak.Vector[CssStyleValue*]()

    return css_style_value_list_values(css_style_value_as_value_list(value))

## interpolate_box_shadow's `extend_list_if_necessary` lambda.
func css_box_shadow_extend_list_if_necessary(values: ak.Vector[CssStyleValue*]*, other: const ak.Vector[CssStyleValue*]*):
    ak.vector_ensure_capacity(values, ak.vector_size(other))
    for i in ak.vector_size(values)..<ak.vector_size(other):
        let first_shadow = css_style_value_as_shadow(*ak.vector_at_const(other, 0))
        let other_shadow = css_style_value_as_shadow(*ak.vector_at_const(other, i))
        let blank = css_shadow_style_value_create(css_shadow_style_value_shadow_type(first_shadow), css_color_style_value_create_from_color(gfx.color_new_named_color(gfx.ColorNamedColor.transparent), CssColorSyntax.legacy).css_style_value(), css_interpolation_zero_px(), css_interpolation_zero_px(), css_interpolation_zero_px(), css_interpolation_zero_px(), css_shadow_style_value_placement(other_shadow))
        ak.vector_append_t(values, blank.css_style_value())

## The color resolution context of an element's layout node, or the default one without a layout node.
func css_interpolation_color_resolution_context(element: DomElement*) -> CssColorResolutionContext:
    # NB: Called during style interpolation.
    if let node = dom_element_unsafe_layout_node(element):
        return css_color_resolution_context_for_layout_node_with_style(node)
    return CssColorResolutionContext()

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:1378 Web::CSS::interpolate_box_shadow.
pub func css_interpolate_box_shadow(element: DomElement*, calculation_context: const CssCalculationContext*, from_: CssStyleValue*, to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
    # https://drafts.csswg.org/css-backgrounds/#box-shadow
    # Animation type: by computed value, treating none as a zero-item list and appending blank shadows
    #                 (transparent 0 0 0 0) with a corresponding inset keyword as needed to match the longer list if
    #                 the shorter list is otherwise compatible with the longer one

    let from_list = css_box_shadow_process_list(from_)
    let to_list = css_box_shadow_process_list(to)
    var from_shadows = ak.vector_clone(&from_list)
    var to_shadows = ak.vector_clone(&to_list)

    css_box_shadow_extend_list_if_necessary(&from_shadows, &to_shadows)
    css_box_shadow_extend_list_if_necessary(&to_shadows, &from_shadows)

    assert(ak.vector_size(&from_shadows) == ak.vector_size(&to_shadows))
    var result_shadows: ak.Vector[CssStyleValue*]
    ak.vector_ensure_capacity(&result_shadows, ak.vector_size(&from_shadows))

    let color_resolution_context = css_interpolation_color_resolution_context(element)

    for i in 0..<ak.vector_size(&from_shadows):
        let from_shadow = css_style_value_as_shadow(*ak.vector_at_const(&from_shadows, i))
        let to_shadow = css_style_value_as_shadow(*ak.vector_at_const(&to_shadows, i))
        let interpolated_offset_x = css_interpolate_value(element, calculation_context, css_shadow_style_value_offset_x(from_shadow), css_shadow_style_value_offset_x(to_shadow), delta, allow_discrete)
        let interpolated_offset_y = css_interpolate_value(element, calculation_context, css_shadow_style_value_offset_y(from_shadow), css_shadow_style_value_offset_y(to_shadow), delta, allow_discrete)
        let interpolated_blur_radius = css_interpolate_value(element, calculation_context, css_shadow_style_value_blur_radius(from_shadow), css_shadow_style_value_blur_radius(to_shadow), delta, allow_discrete)
        let interpolated_spread_distance = css_interpolate_value(element, calculation_context, css_shadow_style_value_spread_distance(from_shadow), css_shadow_style_value_spread_distance(to_shadow), delta, allow_discrete)
        let offset_x = interpolated_offset_x else return none
        let offset_y = interpolated_offset_y else return none
        let blur_radius = interpolated_blur_radius else return none
        let spread_distance = interpolated_spread_distance else return none

        var interpolated_color_value = css_interpolate_color(css_shadow_style_value_color(from_shadow), css_shadow_style_value_color(to_shadow), delta, none, color_resolution_context)
        if interpolated_color_value == none:
            interpolated_color_value = css_color_style_value_create_from_color(gfx.color_new_named_color(gfx.ColorNamedColor.black), CssColorSyntax.modern).css_style_value()

        let placement = css_shadow_style_value_placement(to_shadow) if delta >= 0.5 else css_shadow_style_value_placement(from_shadow)
        let result_shadow = css_shadow_style_value_create(css_shadow_style_value_shadow_type(from_shadow), interpolated_color_value else trap("unreachable: set above"), offset_x, offset_y, blur_radius, spread_distance, placement)
        ak.vector_append_t(&result_shadows, result_shadow.css_style_value())

    return css_style_value_list_create(result_shadows, CssStyleValueListSeparator.comma).css_style_value()

# mark: Mixed numeric values ====================================================================

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:1450 Web::CSS::get_value_type_of_numeric_style_value.
func css_get_value_type_of_numeric_style_value(value: CssStyleValue*, calculation_context: const CssCalculationContext*) -> CssValueType?:
    match css_style_value_type(value):
        .angle:
            return CssValueType.angle
        .frequency:
            return CssValueType.frequency
        .integer:
            return CssValueType.integer
        .length:
            return CssValueType.length
        .number:
            return CssValueType.number
        .percentage:
            return calculation_context.percentages_resolve_as else CssValueType.percentage
        .resolution:
            return CssValueType.resolution
        .time:
            return CssValueType.time
        .calculated:
            let calculated = css_style_value_as_calculated(value)
            if css_calculated_style_value_resolves_to_angle_percentage(calculated):
                return CssValueType.angle
            if css_calculated_style_value_resolves_to_frequency_percentage(calculated):
                return CssValueType.frequency
            if css_calculated_style_value_resolves_to_length_percentage(calculated):
                return CssValueType.length
            if css_calculated_style_value_resolves_to_resolution(calculated):
                return CssValueType.resolution
            if css_calculated_style_value_resolves_to_number(calculated):
                return CssValueType.integer if calculation_context.resolve_numbers_as_integers else CssValueType.number
            if css_calculated_style_value_resolves_to_percentage(calculated):
                return calculation_context.percentages_resolve_as else CssValueType.percentage
            if css_calculated_style_value_resolves_to_time_percentage(calculated):
                return CssValueType.time

            return none
        _:
            return none

## `CalculationNode::from_style_value(value, context)` times a number, as a product node.
func css_interpolation_product(node: CssCalculationNode*, factor: f64, calculation_context: const CssCalculationContext*) -> CssCalculationNode*:
    var values: ak.Vector[CssCalculationNode*]
    ak.vector_append_t(&values, node)
    ak.vector_append_t(&values, css_numeric_calculation_node_create(CssCalculationNodeNumericValue.number(css_syntax.number_create(css_syntax.NumberType.number, factor)), *calculation_context).css_calculation_node())
    return css_product_calculation_node_create(values).css_calculation_node()

## `CalculatedStyleValue::create(simplify_a_calculation_tree(SumCalculationNode::create({ a, b }), context, {}),
## *a->numeric_type()->added_to(*b->numeric_type()), context)`: interpolate_mixed_value's and composite_mixed_value's sum.
func css_interpolation_calculated_sum(a: CssCalculationNode*, b: CssCalculationNode*, a_type_node: CssCalculationNode*, b_type_node: CssCalculationNode*, calculation_context: const CssCalculationContext*) -> CssStyleValue*:
    var values: ak.Vector[CssCalculationNode*]
    ak.vector_append_t(&values, a)
    ak.vector_append_t(&values, b)
    let sum = css_sum_calculation_node_create(values).css_calculation_node()
    let a_type = css_calculation_node_numeric_type(a_type_node) else trap("VERIFY: Optional::value()")
    let b_type = css_calculation_node_numeric_type(b_type_node) else trap("VERIFY: Optional::value()")
    let resolved_type = css_numeric_type_added_to(&a_type, b_type) else trap("VERIFY: Optional::value()")
    return css_calculated_style_value_create(css_simplify_a_calculation_tree(sum, *calculation_context, CssCalculationResolutionContext()), resolved_type, *calculation_context).css_style_value()

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:1493 Web::CSS::interpolate_mixed_value.
func css_interpolate_mixed_value(calculation_context: const CssCalculationContext*, from_: CssStyleValue*, to: CssStyleValue*, delta: f32) -> CssStyleValue*?:
    let from_value_type = css_get_value_type_of_numeric_style_value(from_, calculation_context)
    let to_value_type = css_get_value_type_of_numeric_style_value(to, calculation_context)

    if from_value_type != none and from_value_type == to_value_type:
        # https://drafts.csswg.org/css-values-4/#combine-mixed
        # The computed value of a percentage-dimension mix is defined as
        # FIXME: a computed dimension if the percentage component is zero or is defined specifically to compute to a dimension value
        # a computed percentage if the dimension component is zero
        # a computed calc() expression otherwise
        let from_dimension_value = as_if_css_dimension_style_value(from_)
        let to_dimension_value = as_if_css_dimension_style_value(to)
        if from_dimension_value != none and css_style_value_type(to) == CssStyleValueType.percentage:
            let dimension_component = css_dimension_style_value_raw_value(from_dimension_value else trap("unreachable: checked above")) * f64(1.0 - delta)
            let percentage_component = css_dimension_style_value_raw_value(css_style_value_as_percentage(to).css_dimension_style_value()) * f64(delta)
            if dimension_component == 0.0:
                return css_percentage_style_value_create(css_percentage_new(percentage_component)).css_style_value()
        elif to_dimension_value != none and css_style_value_type(from_) == CssStyleValueType.percentage:
            let dimension_component = css_dimension_style_value_raw_value(to_dimension_value else trap("unreachable: checked above")) * f64(delta)
            let percentage_component = css_dimension_style_value_raw_value(css_style_value_as_percentage(from_).css_dimension_style_value()) * f64(1.0 - delta)
            if dimension_component == 0.0:
                return css_percentage_style_value_create(css_percentage_new(percentage_component)).css_style_value()

        let from_node = css_calculation_node_from_style_value(from_, *calculation_context)
        let to_node = css_calculation_node_from_style_value(to, *calculation_context)

        # https://drafts.csswg.org/css-values-4/#combine-math
        # Interpolation of math functions, with each other or with numeric values and other numeric-valued functions, is defined as Vresult = calc((1 - p) * VA + p * VB).
        let from_contribution = css_interpolation_product(from_node, f64(1.0 - delta), calculation_context)
        let to_contribution = css_interpolation_product(to_node, f64(delta), calculation_context)

        return css_interpolation_calculated_sum(from_contribution, to_contribution, from_node, to_node, calculation_context)

    return none

# mark: interpolate_value_impl ==================================================================

## Ported from Libraries/LibWeb/CSS/Interpolation.cpp:1556 Web::CSS::interpolate_value_impl.
func css_interpolate_value_impl(element: DomElement*, calculation_context: const CssCalculationContext*, from_: CssStyleValue*, to: CssStyleValue*, delta: f32, allow_discrete: CssAllowDiscrete) -> CssStyleValue*?:
    if css_style_value_type(from_) != css_style_value_type(to) or css_style_value_is_calculated(from_) or css_style_value_is_calculated(to):
        # Handle mixed percentage and dimension types, as well as CalculatedStyleValues
        # https://www.w3.org/TR/css-values-4/#mixed-percentages
        return css_interpolate_mixed_value(calculation_context, from_, to, delta)

    match css_style_value_type(from_):
        .angle:
            let from_angle = css_angle_style_value_angle(css_style_value_as_angle(from_))
            let to_angle = css_angle_style_value_angle(css_style_value_as_angle(to))
            let interpolated_value = css_interpolate_raw_f64(css_angle_to_degrees(&from_angle), css_angle_to_degrees(&to_angle), delta, css_interpolation_accepted_range(calculation_context, CssValueType.angle))
            return css_angle_style_value_create(css_angle_make_degrees(interpolated_value)).css_style_value()
        .background_size:
            let from_size = css_style_value_as_background_size(from_)
            let to_size = css_style_value_as_background_size(to)
            let interpolated_x = css_interpolate_value(element, calculation_context, css_background_size_style_value_size_x(from_size), css_background_size_style_value_size_x(to_size), delta, allow_discrete)
            let interpolated_y = css_interpolate_value(element, calculation_context, css_background_size_style_value_size_y(from_size), css_background_size_style_value_size_y(to_size), delta, allow_discrete)
            let x = interpolated_x else return none
            let y = interpolated_y else return none

            return css_background_size_style_value_create(x, y).css_style_value()
        .border_image_slice:
            let from_border_image_slice = css_style_value_as_border_image_slice(from_)
            let to_border_image_slice = css_style_value_as_border_image_slice(to)
            if css_border_image_slice_style_value_fill(from_border_image_slice) != css_border_image_slice_style_value_fill(to_border_image_slice):
                return none
            let interpolated_top = css_interpolate_value(element, calculation_context, css_border_image_slice_style_value_top(from_border_image_slice), css_border_image_slice_style_value_top(to_border_image_slice), delta, allow_discrete)
            let interpolated_right = css_interpolate_value(element, calculation_context, css_border_image_slice_style_value_right(from_border_image_slice), css_border_image_slice_style_value_right(to_border_image_slice), delta, allow_discrete)
            let interpolated_bottom = css_interpolate_value(element, calculation_context, css_border_image_slice_style_value_bottom(from_border_image_slice), css_border_image_slice_style_value_bottom(to_border_image_slice), delta, allow_discrete)
            let interpolated_left = css_interpolate_value(element, calculation_context, css_border_image_slice_style_value_left(from_border_image_slice), css_border_image_slice_style_value_left(to_border_image_slice), delta, allow_discrete)
            let top = interpolated_top else return none
            let right = interpolated_right else return none
            let bottom = interpolated_bottom else return none
            let left = interpolated_left else return none
            return css_border_image_slice_style_value_create(top, right, bottom, left, css_border_image_slice_style_value_fill(from_border_image_slice)).css_style_value()
        .basic_shape:
            return css_interpolate_basic_shape(element, from_, to, delta, allow_discrete)
        .border_radius:
            let from_radius = css_style_value_as_border_radius(from_)
            let to_radius = css_style_value_as_border_radius(to)
            let interpolated_horizontal_radius = css_interpolate_value_impl(element, calculation_context, css_border_radius_style_value_horizontal_radius(from_radius), css_border_radius_style_value_horizontal_radius(to_radius), delta, allow_discrete)
            let interpolated_vertical_radius = css_interpolate_value_impl(element, calculation_context, css_border_radius_style_value_vertical_radius(from_radius), css_border_radius_style_value_vertical_radius(to_radius), delta, allow_discrete)
            let horizontal = interpolated_horizontal_radius else return none
            let vertical = interpolated_vertical_radius else return none
            return css_border_radius_style_value_create(horizontal, vertical).css_style_value()
        .border_radius_rect:
            return css_interpolate_border_radius_rect(element, from_, to, delta, allow_discrete)
        .color:
            if let interpolated = css_interpolate_color(from_, to, delta, none, css_interpolation_color_resolution_context(element)):
                return interpolated
            return css_color_style_value_create_from_color(gfx.color_new_named_color(gfx.ColorNamedColor.black), CssColorSyntax.modern).css_style_value()
        .edge:
            let from_offset = css_edge_style_value_offset(css_style_value_as_edge(from_))
            let to_offset = css_edge_style_value_offset(css_style_value_as_edge(to))

            if let interpolated_value = css_interpolate_value_impl(element, calculation_context, from_offset, to_offset, delta, allow_discrete):
                return css_edge_style_value_create(none, interpolated_value).css_style_value()

            return none
        .font_style:
            return css_interpolate_font_style(element, calculation_context, from_, to, delta, allow_discrete)
        .flex:
            let from_flex = css_flex_style_value_flex(css_style_value_as_flex(from_))
            let to_flex = css_flex_style_value_flex(css_style_value_as_flex(to))
            let interpolated_value = css_interpolate_raw_f64(css_flex_to_fr(&from_flex), css_flex_to_fr(&to_flex), delta, css_interpolation_accepted_range(calculation_context, CssValueType.flex))
            return css_flex_style_value_create(css_flex_make_fr(interpolated_value)).css_style_value()
        .function:
            let from_function = css_style_value_as_function(from_)
            let to_function = css_style_value_as_function(to)

            let from_name = css_function_style_value_name(from_function)
            let to_name = css_function_style_value_name(to_function)
            if not ak.fly_string_eq_fly_string(&from_name, &to_name):
                return none

            let interpolated_value = css_interpolate_value(element, calculation_context, css_function_style_value_value(from_function), css_function_style_value_value(to_function), delta, allow_discrete) else return none

            return css_function_style_value_create(from_name, interpolated_value).css_style_value()
        .integer:
            # https://drafts.csswg.org/css-values/#combine-integers
            # Interpolation of <integer> is defined as Vresult = round((1 - p) × VA + p × VB);
            # that is, interpolation happens in the real number space as for <number>s, and the result is converted to an <integer> by rounding to the nearest integer.
            let interpolated_value = css_interpolate_raw_i32(css_integer_style_value_integer(css_style_value_as_integer(from_)), css_integer_style_value_integer(css_style_value_as_integer(to)), delta, css_interpolation_accepted_range(calculation_context, CssValueType.integer))
            return css_integer_style_value_create(interpolated_value).css_style_value()
        .length:
            let from_length = css_length_style_value_length(css_style_value_as_length(from_))
            let to_length = css_length_style_value_length(css_style_value_as_length(to))
            let interpolated_value = css_interpolate_raw_f64(css_length_raw_value(&from_length), css_length_raw_value(&to_length), delta, css_interpolation_accepted_range(calculation_context, CssValueType.length))
            return css_length_style_value_create(css_length_new(interpolated_value, css_length_unit(&from_length))).css_style_value()
        .number:
            let interpolated_value = css_interpolate_raw_f64(css_number_style_value_number(css_style_value_as_number(from_)), css_number_style_value_number(css_style_value_as_number(to)), delta, css_interpolation_accepted_range(calculation_context, CssValueType.number))
            return css_number_style_value_create(interpolated_value).css_style_value()
        .opacity_value:
            let interpolated_value = css_interpolate_raw_f64(css_opacity_value_style_value_resolved(css_style_value_as_opacity_value(from_)), css_opacity_value_style_value_resolved(css_style_value_as_opacity_value(to)), delta, CssNumericRange(min = 0.0, max = 1.0))
            return css_opacity_value_style_value_create(css_number_style_value_create(interpolated_value).css_style_value()).css_style_value()
        .open_type_tagged:
            let from_open_type_tagged = css_style_value_as_open_type_tagged(from_)
            let to_open_type_tagged = css_style_value_as_open_type_tagged(to)
            let from_tag = css_open_type_tagged_style_value_tag(from_open_type_tagged)
            let to_tag = css_open_type_tagged_style_value_tag(to_open_type_tagged)
            if not ak.fly_string_eq_fly_string(&from_tag, &to_tag):
                return none
            let interpolated_value = css_interpolate_value(element, calculation_context, css_open_type_tagged_style_value_value(from_open_type_tagged), css_open_type_tagged_style_value_value(to_open_type_tagged), delta, allow_discrete) else return none
            return css_open_type_tagged_style_value_create(CssOpenTypeTaggedStyleValueMode.font_variation_settings, from_tag, interpolated_value).css_style_value()
        .percentage:
            let from_percentage = css_percentage_style_value_percentage(css_style_value_as_percentage(from_))
            let to_percentage = css_percentage_style_value_percentage(css_style_value_as_percentage(to))
            let interpolated_value = css_interpolate_raw_f64(css_percentage_value(&from_percentage), css_percentage_value(&to_percentage), delta, css_interpolation_accepted_range(calculation_context, CssValueType.percentage))
            return css_percentage_style_value_create(css_percentage_new(interpolated_value)).css_style_value()
        .position:
            # https://www.w3.org/TR/css-values-4/#combine-positions
            # FIXME: Interpolation of <position> is defined as the independent interpolation of each component (x, y) normalized as an offset from the top left corner as a <length-percentage>.
            let from_position = css_style_value_as_position(from_)
            let to_position = css_style_value_as_position(to)
            let interpolated_edge_x = css_interpolate_value(element, calculation_context, css_position_style_value_edge_x(from_position).css_style_value(), css_position_style_value_edge_x(to_position).css_style_value(), delta, allow_discrete)
            let interpolated_edge_y = css_interpolate_value(element, calculation_context, css_position_style_value_edge_y(from_position).css_style_value(), css_position_style_value_edge_y(to_position).css_style_value(), delta, allow_discrete)
            let edge_x = interpolated_edge_x else return none
            let edge_y = interpolated_edge_y else return none
            return css_position_style_value_create(css_style_value_as_edge(edge_x), css_style_value_as_edge(edge_y)).css_style_value()
        .radial_size:
            return css_interpolate_radial_size(element, from_, to, delta, allow_discrete)
        .ratio:
            let from_ratio = css_ratio_style_value_resolved(css_style_value_as_ratio(from_))
            let to_ratio = css_ratio_style_value_resolved(css_style_value_as_ratio(to))

            # https://drafts.csswg.org/css-values/#combine-ratio
            # If either <ratio> is degenerate, the values cannot be interpolated.
            if css_ratio_is_degenerate(&from_ratio) or css_ratio_is_degenerate(&to_ratio):
                return none

            # The interpolation of a <ratio> is defined by converting each <ratio> to a number by dividing the first value
            # by the second (so a ratio of 3 / 2 would become 1.5), taking the logarithm of that result (so the 1.5 would
            # become approximately 0.176), then interpolating those values. The result during the interpolation is
            # converted back to a <ratio> by inverting the logarithm, then interpreting the result as a <ratio> with the
            # result as the first value and 1 as the second value.
            let from_number = math.log(css_ratio_value(&from_ratio))
            let to_number = math.log(css_ratio_value(&to_ratio))
            let interpolated_value = css_interpolate_raw_f64(from_number, to_number, delta, css_interpolation_accepted_range(calculation_context, CssValueType.ratio))
            return css_ratio_style_value_create(css_interpolation_number(math.pow(math.e, interpolated_value)), css_interpolation_number(1.0)).css_style_value()
        .rect:
            let from_rect = css_style_value_as_rect(from_)
            let to_rect = css_style_value_as_rect(to)

            let interpolated_top = css_interpolate_value_impl(element, calculation_context, css_rect_style_value_top(from_rect), css_rect_style_value_top(to_rect), delta, allow_discrete)
            let interpolated_right = css_interpolate_value_impl(element, calculation_context, css_rect_style_value_right(from_rect), css_rect_style_value_right(to_rect), delta, allow_discrete)
            let interpolated_bottom = css_interpolate_value_impl(element, calculation_context, css_rect_style_value_bottom(from_rect), css_rect_style_value_bottom(to_rect), delta, allow_discrete)
            let interpolated_left = css_interpolate_value_impl(element, calculation_context, css_rect_style_value_left(from_rect), css_rect_style_value_left(to_rect), delta, allow_discrete)
            let top = interpolated_top else return none
            let right = interpolated_right else return none
            let bottom = interpolated_bottom else return none
            let left = interpolated_left else return none

            return css_rect_style_value_create(top, right, bottom, left).css_style_value()
        .text_indent:
            let from_text_indent = css_style_value_as_text_indent(from_)
            let to_text_indent = css_style_value_as_text_indent(to)

            if css_text_indent_style_value_each_line(from_text_indent) != css_text_indent_style_value_each_line(to_text_indent) or css_text_indent_style_value_hanging(from_text_indent) != css_text_indent_style_value_hanging(to_text_indent):
                return none

            let interpolated_length_percentage = css_interpolate_value(element, calculation_context, css_text_indent_style_value_length_percentage(from_text_indent), css_text_indent_style_value_length_percentage(to_text_indent), delta, allow_discrete) else return none

            let hanging = CssTextIndentStyleValueHanging.yes if css_text_indent_style_value_hanging(from_text_indent) else CssTextIndentStyleValueHanging.no
            let each_line = CssTextIndentStyleValueEachLine.yes if css_text_indent_style_value_each_line(from_text_indent) else CssTextIndentStyleValueEachLine.no
            return css_text_indent_style_value_create(interpolated_length_percentage, hanging, each_line).css_style_value()
        .superellipse:
            return css_interpolate_superellipse(from_, to, delta)
        .transformation:
            trap("VERIFY_NOT_REACHED")
        .value_list:
            return css_interpolate_value_list(element, calculation_context, from_, to, delta)
        _:
            return none