blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/values/computed/motion.rs

@@ -0,0 +1,73 @@
+/* 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/. */
+
+//! Computed types for CSS values that are related to motion path.
+
+use crate::derives::*;
+use crate::values::computed::basic_shape::BasicShape;
+use crate::values::computed::url::ComputedUrl;
+use crate::values::computed::{Angle, LengthPercentage, Position};
+use crate::values::generics::motion::{
+    GenericOffsetPath, GenericOffsetPathFunction, GenericOffsetPosition, GenericRayFunction,
+};
+use crate::Zero;
+
+/// The computed value of ray() function.
+pub type RayFunction = GenericRayFunction<Angle, Position>;
+
+/// The computed value of <offset-path>.
+pub type OffsetPathFunction = GenericOffsetPathFunction<BasicShape, RayFunction, ComputedUrl>;
+
+/// The computed value of `offset-path`.
+pub type OffsetPath = GenericOffsetPath<OffsetPathFunction>;
+
+/// The computed value of `offset-position`.
+pub type OffsetPosition = GenericOffsetPosition<LengthPercentage, LengthPercentage>;
+
+#[inline]
+fn is_auto_zero_angle(auto: &bool, angle: &Angle) -> bool {
+    *auto && angle.is_zero()
+}
+
+/// A computed offset-rotate.
+#[derive(
+    Animate,
+    Clone,
+    ComputeSquaredDistance,
+    Copy,
+    Debug,
+    Deserialize,
+    MallocSizeOf,
+    PartialEq,
+    Serialize,
+    ToAnimatedValue,
+    ToAnimatedZero,
+    ToCss,
+    ToResolvedValue,
+    ToTyped,
+)]
+#[repr(C)]
+pub struct OffsetRotate {
+    /// If auto is false, this is a fixed angle which indicates a
+    /// constant clockwise rotation transformation applied to it by this
+    /// specified rotation angle. Otherwise, the angle will be added to
+    /// the angle of the direction in layout.
+    #[animation(constant)]
+    #[css(represents_keyword)]
+    pub auto: bool,
+    /// The angle value.
+    #[css(contextual_skip_if = "is_auto_zero_angle")]
+    pub angle: Angle,
+}
+
+impl OffsetRotate {
+    /// Returns "auto 0deg".
+    #[inline]
+    pub fn auto() -> Self {
+        OffsetRotate {
+            auto: true,
+            angle: Zero::zero(),
+        }
+    }
+}

package/vendor/stylo/values/computed/outline.rs

@@ -0,0 +1,7 @@
+/* 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/. */
+
+//! Computed values for outline properties
+
+pub use crate::values::specified::OutlineStyle;

package/vendor/stylo/values/computed/page.rs

@@ -0,0 +1,77 @@
+/* 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/. */
+
+//! Computed @page at-rule properties and named-page style properties
+
+use crate::derives::*;
+use crate::values::computed::length::NonNegativeLength;
+use crate::values::computed::{Context, ToComputedValue};
+use crate::values::generics;
+use crate::values::generics::size::Size2D;
+
+use crate::values::specified::page as specified;
+pub use generics::page::GenericPageSize;
+pub use generics::page::PageOrientation;
+pub use generics::page::PageSizeOrientation;
+pub use generics::page::PaperSize;
+pub use specified::PageName;
+
+/// Computed value of the @page size descriptor
+///
+/// The spec says that the computed value should be the same as the specified
+/// value but with all absolute units, but it's not currently possibly observe
+/// the computed value of page-size.
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToCss, ToResolvedValue, ToShmem, ToTyped)]
+#[repr(C, u8)]
+#[typed(todo_derive_fields)]
+pub enum PageSize {
+    /// Specified size, paper size, or paper size and orientation.
+    Size(Size2D<NonNegativeLength>),
+    /// `landscape` or `portrait` value, no specified size.
+    Orientation(PageSizeOrientation),
+    /// `auto` value
+    Auto,
+}
+
+impl ToComputedValue for specified::PageSize {
+    type ComputedValue = PageSize;
+
+    fn to_computed_value(&self, ctx: &Context) -> Self::ComputedValue {
+        match self {
+            Self::Size(s) => PageSize::Size(s.to_computed_value(ctx)),
+            Self::PaperSize(p, PageSizeOrientation::Landscape) => PageSize::Size(Size2D {
+                width: p.long_edge().to_computed_value(ctx),
+                height: p.short_edge().to_computed_value(ctx),
+            }),
+            Self::PaperSize(p, PageSizeOrientation::Portrait) => PageSize::Size(Size2D {
+                width: p.short_edge().to_computed_value(ctx),
+                height: p.long_edge().to_computed_value(ctx),
+            }),
+            Self::Orientation(o) => PageSize::Orientation(*o),
+            Self::Auto => PageSize::Auto,
+        }
+    }
+
+    fn from_computed_value(computed: &Self::ComputedValue) -> Self {
+        match *computed {
+            PageSize::Size(s) => Self::Size(ToComputedValue::from_computed_value(&s)),
+            PageSize::Orientation(o) => Self::Orientation(o),
+            PageSize::Auto => Self::Auto,
+        }
+    }
+}
+
+impl PageSize {
+    /// `auto` value.
+    #[inline]
+    pub fn auto() -> Self {
+        PageSize::Auto
+    }
+
+    /// Whether this is the `auto` value.
+    #[inline]
+    pub fn is_auto(&self) -> bool {
+        matches!(*self, PageSize::Auto)
+    }
+}

package/vendor/stylo/values/computed/param.rs

@@ -0,0 +1,9 @@
+/* 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/. */
+
+//! Common handling for the computed value CSS link-parameters: param() values.
+//!
+//! specified == computed for link-parameters
+
+pub use crate::values::specified::param::LinkParameters;

package/vendor/stylo/values/computed/percentage.rs

@@ -0,0 +1,143 @@
+/* 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/. */
+
+//! Computed percentages.
+
+use crate::derives::*;
+use crate::typed_om::{ToTyped, TypedValue};
+use crate::values::generics::{ClampToNonNegative, NonNegative};
+use crate::values::specified::percentage::ToPercentage;
+use crate::values::{reify_percentage, serialize_normalized_percentage, CSSFloat};
+use crate::Zero;
+use std::fmt;
+use style_traits::{CssWriter, ToCss};
+use thin_vec::ThinVec;
+
+/// A computed percentage.
+#[derive(
+    Animate,
+    Clone,
+    ComputeSquaredDistance,
+    Copy,
+    Debug,
+    Default,
+    Deserialize,
+    MallocSizeOf,
+    PartialEq,
+    PartialOrd,
+    Serialize,
+    SpecifiedValueInfo,
+    ToAnimatedValue,
+    ToAnimatedZero,
+    ToComputedValue,
+    ToResolvedValue,
+    ToShmem,
+)]
+#[repr(C)]
+pub struct Percentage(pub CSSFloat);
+
+impl ClampToNonNegative for Percentage {
+    #[inline]
+    fn clamp_to_non_negative(self) -> Self {
+        Percentage(self.0.max(0.))
+    }
+}
+
+impl Percentage {
+    /// 100%
+    #[inline]
+    pub fn hundred() -> Self {
+        Percentage(1.)
+    }
+
+    /// Returns the absolute value for this percentage.
+    #[inline]
+    pub fn abs(&self) -> Self {
+        Percentage(self.0.abs())
+    }
+}
+
+impl Zero for Percentage {
+    fn zero() -> Self {
+        Percentage(0.)
+    }
+
+    fn is_zero(&self) -> bool {
+        self.0 == 0.
+    }
+}
+
+impl ToPercentage for Percentage {
+    fn to_percentage(&self) -> Option<CSSFloat> {
+        Some(self.0)
+    }
+}
+
+impl std::ops::AddAssign for Percentage {
+    fn add_assign(&mut self, other: Self) {
+        self.0 += other.0
+    }
+}
+
+impl std::ops::Add for Percentage {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Percentage(self.0 + other.0)
+    }
+}
+
+impl std::ops::Sub for Percentage {
+    type Output = Self;
+
+    fn sub(self, other: Self) -> Self {
+        Percentage(self.0 - other.0)
+    }
+}
+
+impl std::ops::Rem for Percentage {
+    type Output = Self;
+
+    fn rem(self, other: Self) -> Self {
+        Percentage(self.0 % other.0)
+    }
+}
+
+impl From<f32> for Percentage {
+    fn from(value: f32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<Percentage> for f32 {
+    fn from(percentage: Percentage) -> f32 {
+        percentage.0
+    }
+}
+
+impl ToCss for Percentage {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        serialize_normalized_percentage(self.0, dest)
+    }
+}
+
+impl ToTyped for Percentage {
+    fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        reify_percentage(self.0, dest)
+    }
+}
+
+/// A wrapper over a `Percentage`, whose value should be clamped to 0.
+pub type NonNegativePercentage = NonNegative<Percentage>;
+
+impl NonNegativePercentage {
+    /// 100%
+    #[inline]
+    pub fn hundred() -> Self {
+        NonNegative(Percentage::hundred())
+    }
+}

package/vendor/stylo/values/computed/position.rs

@@ -0,0 +1,273 @@
+/* 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/. */
+
+//! CSS handling for the computed value of
+//! [`position`][position] values.
+//!
+//! [position]: https://drafts.csswg.org/css-backgrounds-3/#position
+
+use crate::logical_geometry::PhysicalSide;
+use crate::values::computed::{
+    Context, Integer, LengthPercentage, NonNegativeNumber, Percentage, ToComputedValue,
+};
+use crate::values::generics;
+#[cfg(feature = "gecko")]
+use crate::values::generics::position::TreeScoped;
+use crate::values::generics::position::{
+    AnchorSideKeyword, AspectRatio as GenericAspectRatio, GenericAnchorFunction, GenericAnchorSide,
+    GenericInset, Position as GenericPosition, PositionComponent as GenericPositionComponent,
+    PositionOrAuto as GenericPositionOrAuto, ZIndex as GenericZIndex,
+};
+pub use crate::values::specified::position::{
+    AnchorName, DashedIdentAndOrTryTactic, FlexWrap, GridAutoFlow, GridTemplateAreas,
+    MasonryAutoFlow, PositionAnchor, PositionArea, PositionAreaAxis, PositionAreaKeyword,
+    PositionAreaType, PositionTryFallbacks, PositionTryFallbacksTryTactic,
+    PositionTryFallbacksTryTacticKeyword, PositionTryOrder, PositionVisibility, ScopedName,
+};
+use crate::Zero;
+use std::fmt::{self, Write};
+use style_traits::{CssWriter, ToCss};
+
+/// The computed value of a CSS `<position>`
+pub type Position = GenericPosition<HorizontalPosition, VerticalPosition>;
+
+/// The computed value of an `auto | <position>`
+pub type PositionOrAuto = GenericPositionOrAuto<Position>;
+
+/// The computed value of a CSS horizontal position.
+pub type HorizontalPosition = LengthPercentage;
+
+/// The computed value of a CSS vertical position.
+pub type VerticalPosition = LengthPercentage;
+
+/// The computed value of anchor side.
+pub type AnchorSide = GenericAnchorSide<Percentage>;
+
+impl AnchorSide {
+    /// Break down given anchor side into its equivalent keyword and percentage.
+    pub fn keyword_and_percentage(&self) -> (AnchorSideKeyword, Percentage) {
+        match self {
+            Self::Percentage(p) => (AnchorSideKeyword::Start, *p),
+            Self::Keyword(k) => {
+                if matches!(k, AnchorSideKeyword::Center) {
+                    (AnchorSideKeyword::Start, Percentage(0.5))
+                } else {
+                    (*k, Percentage::zero())
+                }
+            },
+        }
+    }
+}
+
+/// The computed value of an `anchor()` function.
+pub type AnchorFunction = GenericAnchorFunction<Percentage, Inset>;
+
+#[cfg(feature = "gecko")]
+use crate::{
+    gecko_bindings::structs::AnchorPosOffsetResolutionParams,
+    values::{computed::Length, DashedIdent},
+};
+
+impl AnchorFunction {
+    /// Resolve the anchor function with the given resolver. Returns `Err()` if no anchor is found.
+    #[cfg(feature = "gecko")]
+    pub fn resolve(
+        anchor_name: &TreeScoped<DashedIdent>,
+        anchor_side: &AnchorSide,
+        prop_side: PhysicalSide,
+        params: &AnchorPosOffsetResolutionParams,
+    ) -> Result<Length, ()> {
+        use crate::gecko_bindings::structs::Gecko_GetAnchorPosOffset;
+
+        let (keyword, percentage) = anchor_side.keyword_and_percentage();
+        let mut offset = Length::zero();
+        let valid = unsafe {
+            Gecko_GetAnchorPosOffset(
+                params,
+                anchor_name.value.0.as_ptr(),
+                &anchor_name.scope,
+                prop_side as u8,
+                keyword as u8,
+                percentage.0,
+                &mut offset,
+            )
+        };
+
+        if !valid {
+            return Err(());
+        }
+
+        Ok(offset)
+    }
+}
+
+/// Perform the adjustment of a given value for a given try tactic, as per:
+/// https://drafts.csswg.org/css-anchor-position-1/#swap-due-to-a-try-tactic
+pub(crate) trait TryTacticAdjustment {
+    /// Performs the adjustments necessary given an old side we're relative to, and a new side
+    /// we're relative to.
+    fn try_tactic_adjustment(&mut self, old_side: PhysicalSide, new_side: PhysicalSide);
+}
+
+impl<T: TryTacticAdjustment> TryTacticAdjustment for Box<T> {
+    fn try_tactic_adjustment(&mut self, old_side: PhysicalSide, new_side: PhysicalSide) {
+        (**self).try_tactic_adjustment(old_side, new_side);
+    }
+}
+
+impl<T: TryTacticAdjustment> TryTacticAdjustment for generics::NonNegative<T> {
+    fn try_tactic_adjustment(&mut self, old_side: PhysicalSide, new_side: PhysicalSide) {
+        self.0.try_tactic_adjustment(old_side, new_side);
+    }
+}
+
+impl<Percentage: TryTacticAdjustment> TryTacticAdjustment for GenericAnchorSide<Percentage> {
+    fn try_tactic_adjustment(&mut self, old_side: PhysicalSide, new_side: PhysicalSide) {
+        match self {
+            Self::Percentage(p) => p.try_tactic_adjustment(old_side, new_side),
+            Self::Keyword(side) => side.try_tactic_adjustment(old_side, new_side),
+        }
+    }
+}
+
+impl<Percentage: TryTacticAdjustment, Fallback: TryTacticAdjustment> TryTacticAdjustment
+    for GenericAnchorFunction<Percentage, Fallback>
+{
+    fn try_tactic_adjustment(&mut self, old_side: PhysicalSide, new_side: PhysicalSide) {
+        self.side.try_tactic_adjustment(old_side, new_side);
+        if let Some(fallback) = self.fallback.as_mut() {
+            fallback.try_tactic_adjustment(old_side, new_side);
+        }
+    }
+}
+
+/// A computed type for `inset` properties.
+pub type Inset = GenericInset<Percentage, LengthPercentage>;
+impl TryTacticAdjustment for Inset {
+    // https://drafts.csswg.org/css-anchor-position-1/#swap-due-to-a-try-tactic:
+    //
+    //     For inset properties, change the specified side in anchor() functions to maintain the
+    //     same relative relationship to the new direction that they had to the old.
+    //
+    //     If a <percentage> is used, and directions are opposing, change it to 100% minus the
+    //     original percentage.
+    fn try_tactic_adjustment(&mut self, old_side: PhysicalSide, new_side: PhysicalSide) {
+        match self {
+            Self::Auto => {},
+            Self::AnchorContainingCalcFunction(lp) | Self::LengthPercentage(lp) => {
+                lp.try_tactic_adjustment(old_side, new_side)
+            },
+            Self::AnchorFunction(anchor) => anchor.try_tactic_adjustment(old_side, new_side),
+            Self::AnchorSizeFunction(anchor) => anchor.try_tactic_adjustment(old_side, new_side),
+        }
+    }
+}
+
+impl Position {
+    /// `50% 50%`
+    #[inline]
+    pub fn center() -> Self {
+        Self::new(
+            LengthPercentage::new_percent(Percentage(0.5)),
+            LengthPercentage::new_percent(Percentage(0.5)),
+        )
+    }
+
+    /// `0% 0%`
+    #[inline]
+    pub fn zero() -> Self {
+        Self::new(LengthPercentage::zero(), LengthPercentage::zero())
+    }
+}
+
+impl ToCss for Position {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        self.horizontal.to_css(dest)?;
+        dest.write_char(' ')?;
+        self.vertical.to_css(dest)
+    }
+}
+
+impl GenericPositionComponent for LengthPercentage {
+    fn is_center(&self) -> bool {
+        match self.to_percentage() {
+            Some(Percentage(per)) => per == 0.5,
+            _ => false,
+        }
+    }
+}
+
+#[inline]
+fn block_or_inline_to_inferred(keyword: PositionAreaKeyword) -> PositionAreaKeyword {
+    if matches!(
+        keyword.axis(),
+        PositionAreaAxis::Block | PositionAreaAxis::Inline
+    ) {
+        keyword.with_axis(PositionAreaAxis::Inferred)
+    } else {
+        keyword
+    }
+}
+
+#[inline]
+fn inferred_to_block(keyword: PositionAreaKeyword) -> PositionAreaKeyword {
+    keyword.with_inferred_axis(PositionAreaAxis::Block)
+}
+
+#[inline]
+fn inferred_to_inline(keyword: PositionAreaKeyword) -> PositionAreaKeyword {
+    keyword.with_inferred_axis(PositionAreaAxis::Inline)
+}
+
+// This exists because the spec currently says that further simplifications
+// should be made to the computed value. That's confusing though, and probably
+// all these simplifications should be wrapped up into the simplifications that
+// we make to the specified value. I.e. all this should happen in
+// PositionArea::parse_internal().
+// See also https://github.com/w3c/csswg-drafts/issues/12759
+impl ToComputedValue for PositionArea {
+    type ComputedValue = Self;
+
+    fn to_computed_value(&self, _context: &Context) -> Self {
+        let mut computed = *self;
+        let pair_type = self.get_type();
+        if pair_type == PositionAreaType::Logical || pair_type == PositionAreaType::SelfLogical {
+            if computed.second != PositionAreaKeyword::None {
+                computed.first = block_or_inline_to_inferred(computed.first);
+                computed.second = block_or_inline_to_inferred(computed.second);
+            }
+        } else if pair_type == PositionAreaType::Inferred
+            || pair_type == PositionAreaType::SelfInferred
+        {
+            if computed.second == PositionAreaKeyword::SpanAll {
+                // We remove the superfluous span-all, converting the inferred
+                // keyword to a logical keyword to avoid ambiguity, per spec.
+                computed.first = inferred_to_block(computed.first);
+                computed.second = PositionAreaKeyword::None;
+            } else if computed.first == PositionAreaKeyword::SpanAll {
+                computed.first = computed.second;
+                computed.first = inferred_to_inline(computed.first);
+                computed.second = PositionAreaKeyword::None;
+            }
+        }
+
+        if computed.first == computed.second {
+            computed.second = PositionAreaKeyword::None;
+        }
+        computed
+    }
+
+    fn from_computed_value(computed: &Self) -> Self {
+        *computed
+    }
+}
+
+/// A computed value for the `z-index` property.
+pub type ZIndex = GenericZIndex<Integer>;
+
+/// A computed value for the `aspect-ratio` property.
+pub type AspectRatio = GenericAspectRatio<NonNegativeNumber>;

package/vendor/stylo/values/computed/ratio.rs

@@ -0,0 +1,88 @@
+/* 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/. */
+
+//! `<ratio>` computed values.
+
+use crate::values::animated::{Animate, Procedure};
+use crate::values::computed::NonNegativeNumber;
+use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
+use crate::values::generics::ratio::Ratio as GenericRatio;
+use crate::values::generics::NonNegative;
+use crate::Zero;
+use std::cmp::Ordering;
+
+/// A computed <ratio> value.
+pub type Ratio = GenericRatio<NonNegativeNumber>;
+
+impl PartialOrd for Ratio {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        f64::partial_cmp(
+            &((self.0).0 as f64 * (other.1).0 as f64),
+            &((self.1).0 as f64 * (other.0).0 as f64),
+        )
+    }
+}
+
+impl Ratio {
+    /// Returns the f32 value by dividing the first value by the second one.
+    #[inline]
+    fn to_f32(&self) -> f32 {
+        debug_assert!(!self.is_degenerate());
+        (self.0).0 / (self.1).0
+    }
+    /// Returns a new Ratio.
+    #[inline]
+    pub fn new(a: f32, b: f32) -> Self {
+        GenericRatio(a.into(), b.into())
+    }
+}
+
+/// https://drafts.csswg.org/css-values/#combine-ratio
+impl Animate for Ratio {
+    fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
+        // If either <ratio> is degenerate, the values cannot be interpolated.
+        if self.is_degenerate() || other.is_degenerate() {
+            return Err(());
+        }
+
+        // Addition of <ratio>s is not possible, and based on
+        // https://drafts.csswg.org/css-values-4/#not-additive,
+        // we simply use the first value as the result value.
+        // Besides, the procedure for accumulation should be identical to addition here.
+        if matches!(procedure, Procedure::Add | Procedure::Accumulate { .. }) {
+            return Ok(*self);
+        }
+
+        // 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 start = self.to_f32().ln();
+        let end = other.to_f32().ln();
+        let e = std::f32::consts::E;
+        let result = e.powf(start.animate(&end, procedure)?);
+        // The range of the result is [0, inf), based on the easing function.
+        if result.is_zero() || result.is_infinite() {
+            return Err(());
+        }
+        Ok(GenericRatio(NonNegative(result), NonNegative(1.0)))
+    }
+}
+
+impl ComputeSquaredDistance for Ratio {
+    fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
+        if self.is_degenerate() || other.is_degenerate() {
+            return Err(());
+        }
+        // Use the distance of their logarithm values. (This is used by testing, so don't
+        // need to care about the base. Here we use the same base as that in animate().)
+        self.to_f32()
+            .ln()
+            .compute_squared_distance(&other.to_f32().ln())
+    }
+}

package/vendor/stylo/values/computed/rect.rs

@@ -0,0 +1,19 @@
+/* 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/. */
+
+//! Computed types for CSS borders.
+
+use crate::typed_om::{ToTyped, TypedValue};
+use crate::values::computed::length::NonNegativeLengthOrNumber;
+use crate::values::generics::rect::Rect;
+use thin_vec::ThinVec;
+
+/// A specified rectangle made of four `<length-or-number>` values.
+pub type NonNegativeLengthOrNumberRect = Rect<NonNegativeLengthOrNumber>;
+
+impl ToTyped for NonNegativeLengthOrNumberRect {
+    fn to_typed(&self, _dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        Err(())
+    }
+}