dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / 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