blitz-pdf 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,334 @@
+/* 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-value calc() leaf types.
+
+use super::{Angle, Length, Number, Percentage, Resolution, Time};
+use crate::derives::*;
+use crate::typed_om::{NumericBaseType, NumericType};
+use crate::values::generics::calc::{
+    self, CalcType, GenericCalcPercentageLeaf, SimplificationResult,
+};
+use crate::values::generics::Optional;
+use crate::Zero;
+use debug_unreachable::debug_unreachable;
+use serde::{Deserialize, Serialize};
+
+/// The value of a percentage leaf node that contains an associated percent hint.
+pub type CalcPercentageLeaf = GenericCalcPercentageLeaf<Percentage>;
+
+/// The computed leaf of a calc() expression.
+#[derive(
+    Clone,
+    Debug,
+    Deserialize,
+    MallocSizeOf,
+    PartialEq,
+    Serialize,
+    ToAnimatedZero,
+    ToCss,
+    ToResolvedValue,
+    ToTyped,
+)]
+#[allow(missing_docs)]
+#[repr(u8)]
+pub enum ComputedLeaf {
+    Length(Length),
+    Percentage(CalcPercentageLeaf),
+    Number(Number),
+    Angle(Angle),
+    Time(Time),
+    Resolution(Resolution),
+}
+
+impl ComputedLeaf {
+    pub(super) fn is_zero_length(&self) -> bool {
+        match *self {
+            Self::Length(ref l) => l.is_zero(),
+            Self::Percentage(..)
+            | Self::Number(..)
+            | Self::Angle(..)
+            | Self::Time(..)
+            | Self::Resolution(..) => false,
+        }
+    }
+}
+
+impl calc::CalcNodeLeaf for ComputedLeaf {
+    fn numeric_type(&self) -> NumericType {
+        match self {
+            Self::Length(_) => NumericType::length(),
+            Self::Percentage(p) => p.numeric_type(),
+            Self::Number(_) => NumericType::number(),
+            Self::Angle(_) => NumericType::angle(),
+            Self::Time(_) => NumericType::time(),
+            Self::Resolution(_) => NumericType::resolution(),
+        }
+    }
+
+    fn unitless_value(&self) -> Option<f32> {
+        Some(match *self {
+            Self::Length(ref l) => l.px(),
+            Self::Percentage(ref p) => p.get(),
+            Self::Number(n) => n,
+            Self::Angle(ref a) => a.degrees(),
+            Self::Time(ref t) => t.seconds(),
+            Self::Resolution(ref r) => r.dppx(),
+        })
+    }
+
+    fn canonical_value(&self) -> Option<f32> {
+        Some(match *self {
+            Self::Length(ref l) => l.px(),
+            Self::Percentage(ref p) => match p.hint {
+                // Percentages that are relative to some other value (indicated by a
+                // percent hint other than "percent") cannot yet resolve to a numeric
+                // value, as the percentage's basis is not available.
+                Optional::Some(NumericBaseType::Percent) => p.get(),
+                _ => return None,
+            },
+            Self::Number(n) => n,
+            Self::Angle(ref a) => a.degrees(),
+            Self::Time(ref t) => t.seconds(),
+            Self::Resolution(ref r) => r.dppx(),
+        })
+    }
+
+    fn new_number(value: f32) -> Self {
+        Self::Number(value)
+    }
+
+    fn as_number(&self) -> Option<f32> {
+        match *self {
+            Self::Length(_)
+            | Self::Percentage(_)
+            | Self::Angle(_)
+            | Self::Time(_)
+            | Self::Resolution(_) => None,
+            Self::Number(value) => Some(value),
+        }
+    }
+
+    fn as_percentage(&self) -> Option<(f32, Optional<NumericBaseType>)> {
+        match *self {
+            Self::Percentage(p) => Some((p.get(), p.hint)),
+            _ => None,
+        }
+    }
+
+    fn as_angle_radians(&self) -> Option<f32> {
+        match *self {
+            Self::Angle(a) => Some(a.radians()),
+            _ => None,
+        }
+    }
+
+    fn new_angle_from_radians(radians: f32) -> Self {
+        Self::Angle(Angle::from_radians(radians))
+    }
+
+    fn new_from_typed_value(value: f32, numeric_type: NumericType) -> Result<Self, ()> {
+        let calc_type = numeric_type.as_calc_type()?;
+        let percent_hint = numeric_type.percent_hint();
+        Ok(match calc_type {
+            CalcType::Number => Self::new_number(value),
+            CalcType::Length => Self::Length(Length::new(value)),
+            CalcType::Angle => Self::Angle(Angle::from_degrees(value)),
+            CalcType::Time => Self::Time(Time::from_seconds(value)),
+            CalcType::Resolution => Self::Resolution(Resolution::from_dppx(value)),
+            CalcType::Percentage => Self::Percentage(CalcPercentageLeaf::new(value, percent_hint)),
+        })
+    }
+
+    fn compare(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        use self::ComputedLeaf::*;
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return None;
+        }
+
+        // Percentages that resolve against some other basis value cannot be meaningfully compared.
+        if matches!(self, Percentage(p) if p.hint != Optional::Some(NumericBaseType::Percent)) {
+            return None;
+        }
+
+        let Ok(self_negative) = self.is_negative() else {
+            return None;
+        };
+        let Ok(other_negative) = other.is_negative() else {
+            return None;
+        };
+        if self_negative != other_negative {
+            return Some(if self_negative {
+                std::cmp::Ordering::Less
+            } else {
+                std::cmp::Ordering::Greater
+            });
+        }
+
+        match (self, other) {
+            (Length(one), Length(other)) => one.partial_cmp(other),
+            (Percentage(one), Percentage(other)) => one.value.partial_cmp(&other.value),
+            (Number(one), Number(other)) => one.partial_cmp(other),
+            (Angle(one), Angle(other)) => one.partial_cmp(other),
+            (Time(one), Time(other)) => one.partial_cmp(other),
+            (Resolution(one), Resolution(other)) => one.partial_cmp(other),
+            _ => unsafe {
+                match *self {
+                    Length(..) | Percentage(..) | Number(..) | Angle(..) | Time(..)
+                    | Resolution(..) => {},
+                }
+                debug_unreachable!("Forgot to handle unit in compare()")
+            },
+        }
+    }
+
+    fn try_sum_in_place(&mut self, other: &Self) -> Result<(), ()> {
+        use self::ComputedLeaf::*;
+
+        // 0px plus anything else is equal to the right hand side.
+        if self.is_zero_length() {
+            *self = other.clone();
+            return Ok(());
+        }
+
+        if other.is_zero_length() {
+            return Ok(());
+        }
+
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return Err(());
+        }
+
+        match (self, other) {
+            (&mut Length(ref mut one), Length(other)) => {
+                *one += *other;
+            },
+            (&mut Percentage(ref mut one), Percentage(other)) => {
+                *one = CalcPercentageLeaf::new(one.get() + other.get(), one.combined_hint(other));
+            },
+            (&mut Number(ref mut one), Number(other)) => {
+                *one += *other;
+            },
+            (&mut Angle(ref mut one), Angle(other)) => {
+                *one += *other;
+            },
+            (&mut Time(ref mut one), Time(other)) => {
+                *one += *other;
+            },
+            (&mut Resolution(ref mut one), Resolution(other)) => {
+                *one += *other;
+            },
+            _ => unsafe {
+                match *other {
+                    Length(..) | Percentage(..) | Number(..) | Angle(..) | Time(..)
+                    | Resolution(..) => {},
+                }
+                debug_unreachable!("Forgot to handle unit in try_sum_in_place()")
+            },
+        }
+
+        Ok(())
+    }
+
+    fn try_product_in_place(&mut self, other: &mut Self) -> bool {
+        if let Self::Number(ref mut left) = *self {
+            if let Self::Number(ref right) = *other {
+                // Both sides are numbers, so we can just modify the left side.
+                *left *= *right;
+                true
+            } else {
+                // The right side is not a number, so the result should be in the units of the right
+                // side.
+                if other.map(|v| v * *left).is_ok() {
+                    std::mem::swap(self, other);
+                    true
+                } else {
+                    false
+                }
+            }
+        } else if let Self::Number(ref right) = *other {
+            // The left side is not a number, but the right side is, so the result is the left
+            // side unit.
+            self.map(|v| v * *right).is_ok()
+        } else {
+            // Neither side is a number, so a product is not possible.
+            false
+        }
+    }
+
+    fn try_op<O>(&self, other: &Self, op: O) -> Result<Self, ()>
+    where
+        O: Fn(f32, f32) -> f32,
+    {
+        use self::ComputedLeaf::*;
+        if std::mem::discriminant(self) != std::mem::discriminant(other) {
+            return Err(());
+        }
+        Ok(match (self, other) {
+            (Length(one), Length(other)) => Length(super::Length::new(op(one.px(), other.px()))),
+            (Percentage(one), Percentage(other)) => Self::Percentage(CalcPercentageLeaf::new(
+                op(one.get(), other.get()),
+                one.combined_hint(other),
+            )),
+            (&Number(one), &Number(other)) => Self::Number(op(one, other)),
+            (Angle(one), Angle(other)) => Self::Angle(super::Angle::from_degrees(op(
+                one.degrees(),
+                other.degrees(),
+            ))),
+            (Time(one), Time(other)) => Self::Time(super::Time::from_seconds(op(
+                one.seconds(),
+                other.seconds(),
+            ))),
+            (Resolution(one), Resolution(other)) => {
+                Self::Resolution(super::Resolution::from_dppx(op(one.dppx(), other.dppx())))
+            },
+            _ => unsafe {
+                match *self {
+                    Length(..) | Percentage(..) | Number(..) | Angle(..) | Time(..)
+                    | Resolution(..) => {},
+                }
+                debug_unreachable!("Forgot to handle unit in try_op()")
+            },
+        })
+    }
+
+    fn map(&mut self, mut op: impl FnMut(f32) -> f32) -> Result<(), ()> {
+        let _: () = match self {
+            Self::Length(value) => {
+                *value = Length::new(op(value.px()));
+            },
+            Self::Percentage(p) => {
+                *p = CalcPercentageLeaf::new(op(p.get()), p.hint);
+            },
+            Self::Number(value) => {
+                *value = op(*value);
+            },
+            Self::Angle(value) => {
+                *value = Angle::from_degrees(op(value.degrees()));
+            },
+            Self::Time(value) => {
+                *value = Time::from_seconds(op(value.seconds()));
+            },
+            Self::Resolution(value) => {
+                *value = Resolution::from_dppx(op(value.dppx()));
+            },
+        };
+        Ok(())
+    }
+
+    fn simplify(&mut self) -> SimplificationResult {
+        SimplificationResult::Unchanged
+    }
+
+    fn sort_key(&self) -> calc::SortKey {
+        match *self {
+            Self::Length(..) => calc::SortKey::Px,
+            Self::Percentage(..) => calc::SortKey::Percentage,
+            Self::Number(..) => calc::SortKey::Number,
+            Self::Angle(..) => calc::SortKey::Deg,
+            Self::Time(..) => calc::SortKey::S,
+            Self::Resolution(..) => calc::SortKey::Dppx,
+        }
+    }
+}

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

@@ -0,0 +1,161 @@
+/* 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 color values.
+
+use crate::color::AbsoluteColor;
+use crate::typed_om::{KeywordValue, ToTyped, TypedValue};
+use crate::values::animated::ToAnimatedZero;
+use crate::values::computed::percentage::Percentage;
+use crate::values::generics::color::{
+    GenericCaretColor, GenericColor, GenericColorMix, GenericColorOrAuto,
+};
+use std::fmt::{self, Write};
+use style_traits::{CssString, CssWriter, ToCss};
+use thin_vec::ThinVec;
+
+pub use crate::values::specified::color::{ColorScheme, ForcedColorAdjust, PrintColorAdjust};
+
+/// The computed value of the `color` property.
+pub type ColorPropertyValue = AbsoluteColor;
+
+/// A computed value for `<color>`.
+pub type Color = GenericColor<Percentage>;
+
+/// A computed color-mix().
+pub type ColorMix = GenericColorMix<Color, Percentage>;
+
+impl ToCss for Color {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        match *self {
+            Self::Absolute(ref c) => c.to_css(dest),
+            Self::ColorFunction(ref color_function) => color_function.to_css(dest),
+            Self::CurrentColor => dest.write_str("currentcolor"),
+            Self::ColorMix(ref m) => m.to_css(dest),
+            Self::ContrastColor(ref c) => {
+                dest.write_str("contrast-color(")?;
+                c.to_css(dest)?;
+                dest.write_char(')')
+            },
+        }
+    }
+}
+
+impl ToTyped for Color {
+    fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        match *self {
+            Self::CurrentColor => {
+                dest.push(TypedValue::Keyword(KeywordValue(CssString::from(
+                    "currentcolor",
+                ))));
+                Ok(())
+            },
+            _ => Err(()),
+        }
+    }
+}
+
+impl Color {
+    /// A fully transparent color.
+    pub const TRANSPARENT_BLACK: Self = Self::Absolute(AbsoluteColor::TRANSPARENT_BLACK);
+
+    /// An opaque black color.
+    pub const BLACK: Self = Self::Absolute(AbsoluteColor::BLACK);
+
+    /// An opaque white color.
+    pub const WHITE: Self = Self::Absolute(AbsoluteColor::WHITE);
+
+    /// Create a new computed [`Color`] from a given color-mix, simplifying it to an absolute color
+    /// if possible.
+    pub fn from_color_mix(color_mix: ColorMix) -> Self {
+        if let Some(absolute) = color_mix.mix_to_absolute() {
+            Self::Absolute(absolute)
+        } else {
+            Self::ColorMix(Box::new(color_mix))
+        }
+    }
+
+    /// Combine this complex color with the given foreground color into an absolute color.
+    pub fn resolve_to_absolute(&self, current_color: &AbsoluteColor) -> AbsoluteColor {
+        match *self {
+            Self::Absolute(c) => c,
+            Self::ColorFunction(ref color_function) => {
+                color_function.resolve_to_absolute(current_color)
+            },
+            Self::CurrentColor => *current_color,
+            Self::ColorMix(ref mix) => {
+                use crate::color::mix;
+
+                let fill = mix.omitted_weight().unwrap_or(0.0);
+
+                mix::mix_many(
+                    mix.interpolation,
+                    mix.items.iter().map(|item| {
+                        mix::ColorMixItem::new(
+                            item.color.resolve_to_absolute(current_color),
+                            item.percentage.as_ref().map_or(fill, |p| p.0),
+                        )
+                    }),
+                    mix.flags,
+                )
+            },
+            Self::ContrastColor(ref c) => {
+                let bg_color = c.resolve_to_absolute(current_color);
+                Self::resolve_contrast_color(&bg_color)
+            },
+        }
+    }
+
+    /// Performs the resolution of contrast-color given a background color.
+    pub fn resolve_contrast_color(bg_color: &AbsoluteColor) -> AbsoluteColor {
+        if Self::contrast_ratio(bg_color, &AbsoluteColor::BLACK)
+            > Self::contrast_ratio(bg_color, &AbsoluteColor::WHITE)
+        {
+            AbsoluteColor::BLACK
+        } else {
+            AbsoluteColor::WHITE
+        }
+    }
+
+    fn contrast_ratio(a: &AbsoluteColor, b: &AbsoluteColor) -> f32 {
+        // TODO: This just implements the WCAG 2.1 algorithm,
+        // https://www.w3.org/TR/WCAG21/#dfn-contrast-ratio
+        // Consider using a more sophisticated contrast algorithm, e.g. see
+        // https://apcacontrast.com
+        let compute = |c| -> f32 {
+            if c <= 0.04045 {
+                c / 12.92
+            } else {
+                f32::powf((c + 0.055) / 1.055, 2.4)
+            }
+        };
+        let luminance = |r, g, b| -> f32 { 0.2126 * r + 0.7152 * g + 0.0722 * b };
+        let a = a.into_srgb_legacy();
+        let b = b.into_srgb_legacy();
+        let a = a.raw_components();
+        let b = b.raw_components();
+        let la = luminance(compute(a[0]), compute(a[1]), compute(a[2])) + 0.05;
+        let lb = luminance(compute(b[0]), compute(b[1]), compute(b[2])) + 0.05;
+        if la > lb {
+            la / lb
+        } else {
+            lb / la
+        }
+    }
+}
+
+impl ToAnimatedZero for AbsoluteColor {
+    fn to_animated_zero(&self) -> Result<Self, ()> {
+        Ok(Self::TRANSPARENT_BLACK)
+    }
+}
+
+/// auto | <color>
+pub type ColorOrAuto = GenericColorOrAuto<Color>;
+
+/// caret-color
+pub type CaretColor = GenericCaretColor<Color>;

package/vendor/stylo/values/computed/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/. */
+
+//! Computed types for the column properties.
+
+use crate::values::computed::PositiveInteger;
+use crate::values::generics::column::GenericColumnCount;
+
+/// A computed type for `column-count` values.
+pub type ColumnCount = GenericColumnCount<PositiveInteger>;

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

@@ -0,0 +1,155 @@
+/* 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 type for the `corner-shape` family of properties.
+
+use crate::derives::*;
+use crate::values::animated::{Animate, Procedure, ToAnimatedZero};
+use crate::values::distance::{ComputeSquaredDistance, SquaredDistance};
+use crate::values::generics::border::GenericCornerShapeRect;
+use std::fmt::{self, Write};
+use style_traits::{CssWriter, ToCss};
+
+/// The computed value for a single corner shape.
+///
+/// Per the spec, the computed value is always `superellipse(K)` where `K` may
+/// be any real value, including +infinity (for `square`) and -infinity
+/// (for `notch`).
+#[derive(
+    Clone, Copy, Debug, MallocSizeOf, PartialEq, ToShmem, ToTyped, ToAnimatedValue, ToResolvedValue,
+)]
+#[repr(C)]
+#[typed(todo_derive_fields)]
+pub struct CornerShape {
+    /// The K parameter from the `superellipse()` function.
+    pub k: f32,
+}
+
+impl CornerShape {
+    /// `round` -> superellipse(1).
+    #[inline]
+    pub fn round() -> Self {
+        Self { k: 1.0 }
+    }
+    /// `bevel` -> superellipse(0).
+    #[inline]
+    pub fn bevel() -> Self {
+        Self { k: 0.0 }
+    }
+    /// `square` -> superellipse(infinity).
+    #[inline]
+    pub fn square() -> Self {
+        Self { k: f32::INFINITY }
+    }
+    /// `notch` -> superellipse(-infinity).
+    #[inline]
+    pub fn notch() -> Self {
+        Self {
+            k: f32::NEG_INFINITY,
+        }
+    }
+    /// `scoop` -> superellipse(-1).
+    #[inline]
+    pub fn scoop() -> Self {
+        Self { k: -1.0 }
+    }
+    /// `squircle` -> superellipse(2).
+    #[inline]
+    pub fn squircle() -> Self {
+        Self { k: 2.0 }
+    }
+
+    /// Whether this corner is the default `round` shape (K == 1).
+    #[inline]
+    pub fn is_round(&self) -> bool {
+        self.k == 1.0
+    }
+}
+
+impl ToCss for CornerShape {
+    fn to_css<W: Write>(&self, dest: &mut CssWriter<W>) -> fmt::Result {
+        dest.write_str("superellipse(")?;
+        if self.k == f32::INFINITY {
+            dest.write_str("infinity")?;
+        } else if self.k == f32::NEG_INFINITY {
+            dest.write_str("-infinity")?;
+        } else {
+            self.k.to_css(dest)?;
+        }
+        dest.write_char(')')
+    }
+}
+
+/// Compute the "normalized superellipse half corner" for a superellipse
+/// parameter `s`, per
+/// <https://drafts.csswg.org/css-borders-4/#corner-shape-interpolation>.
+fn s_to_interpolation_value(s: f32) -> f32 {
+    if s == f32::NEG_INFINITY {
+        return 0.0;
+    }
+    if s == f32::INFINITY {
+        return 1.0;
+    }
+    let k = 0.5f32.powf(s.abs());
+    let convex_half_corner = 0.5f32.powf(k);
+    if s < 0.0 {
+        1.0 - convex_half_corner
+    } else {
+        convex_half_corner
+    }
+}
+
+/// Inverse of `s_to_interpolation_value`.
+fn interpolation_value_to_s(v: f32) -> f32 {
+    if v <= 0.0 {
+        return f32::NEG_INFINITY;
+    }
+    if v >= 1.0 {
+        return f32::INFINITY;
+    }
+    let convex_half_corner = if v < 0.5 { 1.0 - v } else { v };
+    let k = 0.5f32.ln() / convex_half_corner.ln();
+    let s = k.log2();
+    if v < 0.5 {
+        -s
+    } else {
+        s
+    }
+}
+
+impl Animate for CornerShape {
+    fn animate(&self, other: &Self, procedure: Procedure) -> Result<Self, ()> {
+        let a = s_to_interpolation_value(self.k);
+        let b = s_to_interpolation_value(other.k);
+        let interp = a.animate(&b, procedure)?;
+        Ok(CornerShape {
+            k: interpolation_value_to_s(interp),
+        })
+    }
+}
+
+impl ComputeSquaredDistance for CornerShape {
+    fn compute_squared_distance(&self, other: &Self) -> Result<SquaredDistance, ()> {
+        let a = s_to_interpolation_value(self.k);
+        let b = s_to_interpolation_value(other.k);
+        a.compute_squared_distance(&b)
+    }
+}
+
+impl ToAnimatedZero for CornerShape {
+    fn to_animated_zero(&self) -> Result<Self, ()> {
+        Ok(CornerShape::round())
+    }
+}
+
+/// The four computed corner shapes for an element.
+pub type CornerShapeRect = GenericCornerShapeRect<CornerShape>;
+
+impl CornerShapeRect {
+    /// Initial value: `round` on every corner.
+    #[inline]
+    pub fn round_all() -> Self {
+        Self::all(CornerShape::round())
+    }
+}

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

@@ -0,0 +1,26 @@
+/* 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 counter properties
+
+use crate::values::computed::image::Image;
+use crate::values::generics::counters as generics;
+use crate::values::generics::counters::CounterIncrement as GenericCounterIncrement;
+use crate::values::generics::counters::CounterReset as GenericCounterReset;
+use crate::values::generics::counters::CounterSet as GenericCounterSet;
+
+/// A computed value for the `counter-increment` property.
+pub type CounterIncrement = GenericCounterIncrement<i32>;
+
+/// A computed value for the `counter-reset` property.
+pub type CounterReset = GenericCounterReset<i32>;
+
+/// A computed value for the `counter-set` property.
+pub type CounterSet = GenericCounterSet<i32>;
+
+/// A computed value for the `content` property.
+pub type Content = generics::GenericContent<Image>;
+
+/// A computed content item.
+pub type ContentItem = generics::GenericContentItem<Image>;