blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/values/specified/column.rs

@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Specified types for the column properties.
+
+use crate::values::generics::column::GenericColumnCount;
+use crate::values::specified::PositiveInteger;
+
+/// A specified type for `column-count` values.
+pub type ColumnCount = GenericColumnCount<PositiveInteger>;

package/vendor/stylo/values/specified/corner_shape.rs

@@ -0,0 +1,152 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Specified types for the `corner-shape` family of properties.
+//!
+//! <https://drafts.csswg.org/css-borders-4/#corner-shaping>
+
+use crate::derives::*;
+use crate::parser::{Parse, ParserContext};
+use crate::values::computed::corner_shape as computed;
+use crate::values::computed::{Context, ToComputedValue};
+use crate::values::specified::Number;
+use cssparser::{Parser, Token};
+use style_traits::{ParseError, StyleParseErrorKind};
+
+/// The argument to the `superellipse()` function.
+///
+/// `superellipse(K)` defines the corner shape using the unit equation
+/// `x^(2^K) + y^(2^K) = 1`. `infinity` and `-infinity` are accepted as
+/// special-cased keyword arguments.
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss, ToShmem, ToTyped)]
+#[typed(todo_derive_fields)]
+pub enum SuperellipseArg {
+    /// `<number>` argument.
+    Number(Number),
+    /// The `infinity` keyword.
+    Infinity,
+    /// The `-infinity` keyword (lexed as the literal text `-infinity`).
+    #[css(keyword = "-infinity")]
+    NegativeInfinity,
+}
+
+impl SuperellipseArg {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if let Ok(arg) = input.try_parse(|i| -> Result<SuperellipseArg, ParseError> {
+            match i.next()? {
+                Token::Ident(ident) if ident.eq_ignore_ascii_case("infinity") => {
+                    Ok(SuperellipseArg::Infinity)
+                },
+                Token::Ident(ident) if ident.eq_ignore_ascii_case("-infinity") => {
+                    Ok(SuperellipseArg::NegativeInfinity)
+                },
+                _ => Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError)),
+            }
+        }) {
+            return Ok(arg);
+        }
+        Number::parse(context, input).map(SuperellipseArg::Number)
+    }
+
+    /// Resolve to a numeric `K` value (possibly +/- infinity).
+    pub fn to_k(&self, context: &Context) -> f32 {
+        match self {
+            SuperellipseArg::Infinity => f32::INFINITY,
+            SuperellipseArg::NegativeInfinity => f32::NEG_INFINITY,
+            SuperellipseArg::Number(n) => n.to_computed_value(context),
+        }
+    }
+}
+
+/// The specified value of a single corner-shape (e.g. `corner-top-left-shape`).
+///
+/// <https://drafts.csswg.org/css-borders-4/#typedef-corner-shape-value>
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, SpecifiedValueInfo, ToCss, ToShmem, ToTyped)]
+#[typed(todo_derive_fields)]
+pub enum CornerShape {
+    /// `round`, equivalent to `superellipse(1)`. Initial value.
+    Round,
+    /// `scoop`, equivalent to `superellipse(-1)`.
+    Scoop,
+    /// `bevel`, equivalent to `superellipse(0)`.
+    Bevel,
+    /// `notch`, equivalent to `superellipse(-infinity)`.
+    Notch,
+    /// `square`, equivalent to `superellipse(infinity)`.
+    Square,
+    /// `squircle`, equivalent to `superellipse(2)`.
+    Squircle,
+    /// `superellipse(<arg>)`.
+    #[css(function)]
+    Superellipse(SuperellipseArg),
+}
+
+impl CornerShape {
+    /// The initial value: `round`.
+    #[inline]
+    pub fn round() -> Self {
+        CornerShape::Round
+    }
+}
+
+impl Parse for CornerShape {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        // Try the `superellipse(...)` function first.
+        if let Ok(arg) = input.try_parse(|i| {
+            i.expect_function_matching("superellipse")?;
+            i.parse_nested_block(|i| SuperellipseArg::parse(context, i))
+        }) {
+            return Ok(CornerShape::Superellipse(arg));
+        }
+        Ok(try_match_ident_ignore_ascii_case! { input,
+            "round" => CornerShape::Round,
+            "scoop" => CornerShape::Scoop,
+            "bevel" => CornerShape::Bevel,
+            "notch" => CornerShape::Notch,
+            "square" => CornerShape::Square,
+            "squircle" => CornerShape::Squircle,
+        })
+    }
+}
+
+impl ToComputedValue for CornerShape {
+    type ComputedValue = computed::CornerShape;
+
+    fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
+        // Per spec, the computed value is always the corresponding
+        // `superellipse(K)` value.
+        computed::CornerShape {
+            k: match self {
+                CornerShape::Round => 1.0,
+                CornerShape::Scoop => -1.0,
+                CornerShape::Bevel => 0.0,
+                CornerShape::Notch => f32::NEG_INFINITY,
+                CornerShape::Square => f32::INFINITY,
+                CornerShape::Squircle => 2.0,
+                CornerShape::Superellipse(arg) => arg.to_k(context),
+            },
+        }
+    }
+
+    fn from_computed_value(c: &Self::ComputedValue) -> Self {
+        let arg = if c.k == f32::INFINITY {
+            SuperellipseArg::Infinity
+        } else if c.k == f32::NEG_INFINITY {
+            SuperellipseArg::NegativeInfinity
+        } else {
+            SuperellipseArg::Number(Number::new(c.k))
+        };
+        CornerShape::Superellipse(arg)
+    }
+}
+
+/// The specified value of `corner-shape`. Stored per-corner.
+pub type CornerShapeRect = crate::values::generics::border::GenericCornerShapeRect<CornerShape>;
+
+impl CornerShapeRect {
+    /// Initial value: `round` for all four corners.
+    pub fn round() -> Self {
+        Self::all(CornerShape::Round)
+    }
+}

package/vendor/stylo/values/specified/counters.rs

@@ -0,0 +1,242 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Specified types for counter properties.
+
+use crate::counter_style::CounterStyle;
+use crate::parser::{Parse, ParserContext};
+use crate::values::generics::counters as generics;
+use crate::values::generics::counters::CounterPair;
+use crate::values::specified::image::Image;
+use crate::values::specified::Integer;
+use crate::values::CustomIdent;
+use cssparser::{match_ignore_ascii_case, Parser, Token};
+use selectors::parser::SelectorParseErrorKind;
+use style_traits::{ParseError, StyleParseErrorKind};
+
+#[derive(PartialEq)]
+enum CounterType {
+    Increment,
+    Set,
+    Reset,
+}
+
+impl CounterType {
+    fn default_value(&self) -> i32 {
+        match *self {
+            Self::Increment => 1,
+            Self::Reset | Self::Set => 0,
+        }
+    }
+}
+
+/// A specified value for the `counter-increment` property.
+pub type CounterIncrement = generics::GenericCounterIncrement<Integer>;
+
+impl Parse for CounterIncrement {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        Ok(Self::new(parse_counters(
+            context,
+            input,
+            CounterType::Increment,
+        )?))
+    }
+}
+
+/// A specified value for the `counter-set` property.
+pub type CounterSet = generics::GenericCounterSet<Integer>;
+
+impl Parse for CounterSet {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        Ok(Self::new(parse_counters(context, input, CounterType::Set)?))
+    }
+}
+
+/// A specified value for the `counter-reset` property.
+pub type CounterReset = generics::GenericCounterReset<Integer>;
+
+impl Parse for CounterReset {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        Ok(Self::new(parse_counters(
+            context,
+            input,
+            CounterType::Reset,
+        )?))
+    }
+}
+
+fn parse_counters(
+    context: &ParserContext,
+    input: &mut Parser,
+    counter_type: CounterType,
+) -> Result<Vec<CounterPair<Integer>>, ParseError> {
+    if input
+        .try_parse(|input| input.expect_ident_matching("none"))
+        .is_ok()
+    {
+        return Ok(vec![]);
+    }
+
+    let mut counters = Vec::new();
+    loop {
+        let (name, is_reversed) = match input.next() {
+            Ok(Token::Ident(ident)) => (CustomIdent::from_ident(ident, &["none"])?, false),
+            Ok(Token::Function(name))
+                if counter_type == CounterType::Reset && name.eq_ignore_ascii_case("reversed") =>
+            {
+                input
+                    .parse_nested_block(|input| Ok((CustomIdent::parse(input, &["none"])?, true)))?
+            },
+            Ok(..) => {
+                return Err(ParseError::unexpected_token());
+            },
+            Err(_) => break,
+        };
+
+        let value = match input.try_parse(|input| Integer::parse(context, input)) {
+            Ok(start) => {
+                if start.get() == Some(i32::MIN) {
+                    // The spec says that values must be clamped to the valid range,
+                    // and we reserve i32::MIN as an internal magic value.
+                    // https://drafts.csswg.org/css-lists/#auto-numbering
+                    Integer::new(i32::MIN + 1)
+                } else {
+                    start
+                }
+            },
+            _ => Integer::new(if is_reversed {
+                i32::MIN
+            } else {
+                counter_type.default_value()
+            }),
+        };
+        counters.push(CounterPair {
+            name,
+            value,
+            is_reversed,
+        });
+    }
+
+    if !counters.is_empty() {
+        Ok(counters)
+    } else {
+        Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError))
+    }
+}
+
+/// The specified value for the `content` property.
+pub type Content = generics::GenericContent<Image>;
+
+/// The specified value for a content item in the `content` property.
+pub type ContentItem = generics::GenericContentItem<Image>;
+
+impl Content {
+    fn parse_counter_style(context: &ParserContext, input: &mut Parser) -> CounterStyle {
+        use crate::counter_style::CounterStyleParsingFlags;
+        input
+            .try_parse(|input| {
+                input.expect_comma()?;
+                CounterStyle::parse(context, input, CounterStyleParsingFlags::empty())
+            })
+            .unwrap_or_else(|_| CounterStyle::decimal())
+    }
+}
+
+impl Parse for Content {
+    // normal | none | [ <string> | <counter> | open-quote | close-quote | no-open-quote |
+    // no-close-quote ]+
+    #[cfg_attr(feature = "servo", allow(unused_mut))]
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if input
+            .try_parse(|input| input.expect_ident_matching("normal"))
+            .is_ok()
+        {
+            return Ok(generics::Content::Normal);
+        }
+        if input
+            .try_parse(|input| input.expect_ident_matching("none"))
+            .is_ok()
+        {
+            return Ok(generics::Content::None);
+        }
+
+        let mut items = thin_vec::ThinVec::new();
+        let mut alt_start = None;
+        loop {
+            if alt_start.is_none() {
+                if let Ok(image) = input.try_parse(|i| Image::parse_forbid_none(context, i)) {
+                    items.push(generics::ContentItem::Image(image));
+                    continue;
+                }
+            }
+            let Ok(t) = input.next() else { break };
+            match *t {
+                Token::QuotedString(ref value) => {
+                    items.push(generics::ContentItem::String(
+                        value.as_ref().to_owned().into(),
+                    ));
+                },
+                Token::Function(ref name) => {
+                    // FIXME(emilio): counter() / counters() should be valid per spec past
+                    // the alt marker, but it's likely non-trivial to support and other
+                    // browsers don't support it either, so restricting it for now.
+                    let result = match_ignore_ascii_case! { &name,
+                        "counter" if alt_start.is_none() => input.parse_nested_block(|input| {
+                            let name = CustomIdent::parse(input, &[])?;
+                            let style = Content::parse_counter_style(context, input);
+                            Ok(generics::ContentItem::Counter(name, style))
+                        }),
+                        "counters" if alt_start.is_none() => input.parse_nested_block(|input| {
+                            let name = CustomIdent::parse(input, &[])?;
+                            input.expect_comma()?;
+                            let separator = input.expect_string()?.as_ref().to_owned().into();
+                            let style = Content::parse_counter_style(context, input);
+                            Ok(generics::ContentItem::Counters(name, separator, style))
+                        }),
+                        _ => {
+                            use style_traits::StyleParseErrorKind;
+                            return Err(ParseError::custom(
+                                StyleParseErrorKind::UnexpectedFunction,
+                            ))
+                        }
+                    }?;
+                    items.push(result);
+                },
+                Token::Ident(ref ident) if alt_start.is_none() => {
+                    items.push(match_ignore_ascii_case! { &ident,
+                        "open-quote" => generics::ContentItem::OpenQuote,
+                        "close-quote" => generics::ContentItem::CloseQuote,
+                        "no-open-quote" => generics::ContentItem::NoOpenQuote,
+                        "no-close-quote" => generics::ContentItem::NoCloseQuote,
+                        #[cfg(feature = "gecko")]
+                        "-moz-alt-content" if context.in_ua_sheet() => {
+                            generics::ContentItem::MozAltContent
+                        },
+                        #[cfg(feature = "gecko")]
+                        "-moz-label-content" if context.chrome_rules_enabled() => {
+                            generics::ContentItem::MozLabelContent
+                        },
+                        _ =>{
+                            return Err(ParseError::custom(
+                                SelectorParseErrorKind::UnexpectedIdent
+                            ));
+                        }
+                    });
+                },
+                Token::Delim('/') if alt_start.is_none() && !items.is_empty() => {
+                    alt_start = Some(items.len());
+                },
+                _ => return Err(ParseError::unexpected_token()),
+            }
+        }
+        if items.is_empty() {
+            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+        }
+        let alt_start = alt_start.unwrap_or(items.len());
+        Ok(generics::Content::Items(generics::GenericContentItems {
+            items,
+            alt_start,
+        }))
+    }
+}

package/vendor/stylo/values/specified/easing.rs

@@ -0,0 +1,225 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+//! Specified types for CSS Easing functions.
+use crate::parser::{Parse, ParserContext};
+use crate::piecewise_linear::{PiecewiseLinearFunction, PiecewiseLinearFunctionBuilder};
+use crate::values::computed::easing::TimingFunction as ComputedTimingFunction;
+use crate::values::computed::{Context, ToComputedValue};
+use crate::values::generics::easing::TimingFunction as GenericTimingFunction;
+use crate::values::generics::easing::{StepPosition, TimingKeyword};
+use crate::values::specified::percentage::ToPercentage;
+use crate::values::specified::{AnimationName, Integer, Number, Percentage};
+use cssparser::{match_ignore_ascii_case, Delimiter, Parser, Token};
+use selectors::parser::SelectorParseErrorKind;
+use style_traits::{ParseError, StyleParseErrorKind};
+
+/// A specified timing function.
+pub type TimingFunction = GenericTimingFunction<Integer, Number, PiecewiseLinearFunction>;
+
+impl Parse for TimingFunction {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if let Ok(keyword) = input.try_parse(TimingKeyword::parse) {
+            return Ok(GenericTimingFunction::Keyword(keyword));
+        }
+        if let Ok(ident) = input.try_parse(|i| i.expect_ident_cloned()) {
+            let position = match_ignore_ascii_case! { &ident,
+                "step-start" => StepPosition::Start,
+                "step-end" => StepPosition::End,
+                _ => {
+                    return Err(ParseError::custom(
+                        SelectorParseErrorKind::UnexpectedIdent
+                    ));
+                },
+            };
+            return Ok(GenericTimingFunction::Steps(Integer::new(1), position));
+        }
+        let function = input.expect_function()?.clone();
+        input.parse_nested_block(move |i| {
+            match_ignore_ascii_case! { &function,
+                "cubic-bezier" => Self::parse_cubic_bezier(context, i),
+                "steps" => Self::parse_steps(context, i),
+                "linear" => Self::parse_linear_function(context, i),
+                _ => Err(ParseError::custom(StyleParseErrorKind::UnexpectedFunction)),
+            }
+        })
+    }
+}
+
+impl TimingFunction {
+    fn parse_cubic_bezier(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        let x1 = Number::parse(context, input)?;
+        input.expect_comma()?;
+        let y1 = Number::parse(context, input)?;
+        input.expect_comma()?;
+        let x2 = Number::parse(context, input)?;
+        input.expect_comma()?;
+        let y2 = Number::parse(context, input)?;
+
+        // TODO(Bug 2037743) - Enable calc()-expressions that can only be resolved at
+        // computed value time (due to relative lengths, sibling-index(), etc.).
+        if let (Some(x1), Some(_), Some(x2), Some(_)) =
+            (x1.resolve(), y1.resolve(), x2.resolve(), y2.resolve())
+        {
+            if !(0.0..=1.0).contains(&x1) || !(0.0..=1.0).contains(&x2) {
+                return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+            }
+        } else {
+            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+        }
+
+        Ok(GenericTimingFunction::CubicBezier { x1, y1, x2, y2 })
+    }
+
+    fn parse_steps(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        let steps = Integer::parse_positive(context, input)?;
+        let position = input
+            .try_parse(|i| {
+                i.expect_comma()?;
+                StepPosition::parse(i)
+            })
+            .unwrap_or(StepPosition::End);
+
+        // TODO(Bug 2037743) - Enable calc()-expressions that can only be resolved at
+        // computed value time (due to relative lengths, sibling-index(), etc.).
+        let num_steps = match steps.resolve() {
+            Some(v) => v,
+            None => return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError)),
+        };
+
+        // jump-none accepts a positive integer greater than 1.
+        // FIXME(emilio): The spec asks us to avoid rejecting it at parse
+        // time except until computed value time.
+        //
+        // It's not totally clear it's worth it though, and no other browser
+        // does this.
+        if position == StepPosition::JumpNone && num_steps <= 1 {
+            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+        }
+        Ok(GenericTimingFunction::Steps(steps, position))
+    }
+
+    fn parse_linear_function(
+        context: &ParserContext,
+        input: &mut Parser,
+    ) -> Result<Self, ParseError> {
+        let mut builder = PiecewiseLinearFunctionBuilder::default();
+        let mut num_specified_stops = 0;
+        // Closely follows `parse_comma_separated`, but can generate multiple entries for one comma-separated entry.
+        loop {
+            input.parse_until_before(Delimiter::Comma, |i| {
+                let builder = &mut builder;
+                let mut input_start = i.try_parse(|i| Percentage::parse(context, i)).ok();
+                let mut input_end = i.try_parse(|i| Percentage::parse(context, i)).ok();
+
+                let output = Number::parse(context, i)?;
+                if input_start.is_none() {
+                    debug_assert!(input_end.is_none(), "Input end parsed without input start?");
+                    input_start = i.try_parse(|i| Percentage::parse(context, i)).ok();
+                    input_end = i.try_parse(|i| Percentage::parse(context, i)).ok();
+                }
+
+                // TODO(Bug 2037743) - Enable calc()-expressions that can only be resolved at
+                // computed value time (due to relative lengths, sibling-index(), etc.).
+                let output = match output.resolve() {
+                    Some(v) => v,
+                    None => return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError)),
+                };
+                if matches!(input_start.as_ref().or(input_end.as_ref()), Some(p) if p.resolve().is_none()) {
+                    return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+                }
+
+                let has_input_start = input_start.is_some();
+                builder.push(
+                    output,
+                    input_start.map(|v| v.to_percentage().unwrap()),
+                );
+                num_specified_stops += 1;
+                if input_end.is_some() {
+                    debug_assert!(has_input_start, "Input end valid but not input start?");
+                    builder.push(output, input_end.map(|v| v.to_percentage().unwrap()));
+                }
+
+                Ok(())
+            })?;
+
+            match input.next() {
+                Err(_) => break,
+                Ok(&Token::Comma) => continue,
+                Ok(_) => unreachable!(),
+            }
+        }
+        // By spec, specifying only a single stop makes the function invalid, even if that single entry may generate
+        // two entries.
+        if num_specified_stops < 2 {
+            return Err(ParseError::custom(StyleParseErrorKind::UnspecifiedError));
+        }
+
+        Ok(GenericTimingFunction::LinearFunction(builder.build()))
+    }
+
+    /// Returns true if the name matches any keyword.
+    #[inline]
+    pub fn match_keywords(name: &AnimationName) -> bool {
+        if let Some(name) = name.as_atom() {
+            #[cfg(feature = "gecko")]
+            return name.with_str(|n| TimingKeyword::from_ident(n).is_ok());
+            #[cfg(feature = "servo")]
+            return TimingKeyword::from_ident(name).is_ok();
+        }
+        false
+    }
+}
+
+// We need this for converting the specified TimingFunction into computed TimingFunction without
+// Context (for some FFIs in glue.rs). In fact, we don't really need Context to get the computed
+// value of TimingFunction.
+impl TimingFunction {
+    /// Generate the ComputedTimingFunction without Context.
+    pub fn to_computed_value_without_context(&self) -> ComputedTimingFunction {
+        match &self {
+            GenericTimingFunction::Steps(steps, pos) => {
+                // Resolvable value was enforced at parse time
+                GenericTimingFunction::Steps(steps.resolve().unwrap(), *pos)
+            },
+            GenericTimingFunction::CubicBezier { x1, y1, x2, y2 } => {
+                // Resolvable value was enforced at parse time
+                GenericTimingFunction::CubicBezier {
+                    x1: x1.resolve().unwrap(),
+                    y1: y1.resolve().unwrap(),
+                    x2: x2.resolve().unwrap(),
+                    y2: y2.resolve().unwrap(),
+                }
+            },
+            GenericTimingFunction::Keyword(keyword) => GenericTimingFunction::Keyword(*keyword),
+            GenericTimingFunction::LinearFunction(function) => {
+                // Resolvable value was enforced at parse time
+                GenericTimingFunction::LinearFunction(function.clone())
+            },
+        }
+    }
+}
+
+impl ToComputedValue for TimingFunction {
+    type ComputedValue = ComputedTimingFunction;
+    fn to_computed_value(&self, _: &Context) -> Self::ComputedValue {
+        self.to_computed_value_without_context()
+    }
+
+    fn from_computed_value(computed: &Self::ComputedValue) -> Self {
+        match &computed {
+            ComputedTimingFunction::Steps(steps, pos) => Self::Steps(Integer::new(*steps), *pos),
+            ComputedTimingFunction::CubicBezier { x1, y1, x2, y2 } => Self::CubicBezier {
+                x1: Number::new(*x1),
+                y1: Number::new(*y1),
+                x2: Number::new(*x2),
+                y2: Number::new(*y2),
+            },
+            ComputedTimingFunction::Keyword(keyword) => GenericTimingFunction::Keyword(*keyword),
+            ComputedTimingFunction::LinearFunction(function) => {
+                GenericTimingFunction::LinearFunction(function.clone())
+            },
+        }
+    }
+}