blitz-pdf 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,94 @@
+/* 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 @page at-rule properties and named-page style properties
+
+use crate::derives::*;
+use crate::parser::{Parse, ParserContext};
+use crate::values::generics::size::Size2D;
+use crate::values::specified::length::NonNegativeLength;
+use crate::values::{generics, CustomIdent};
+use cssparser::{match_ignore_ascii_case, Parser};
+use style_traits::ParseError;
+
+pub use generics::page::PageOrientation;
+pub use generics::page::PageSizeOrientation;
+pub use generics::page::PaperSize;
+/// Specified value of the @page size descriptor
+pub type PageSize = generics::page::PageSize<Size2D<NonNegativeLength>>;
+
+impl Parse for PageSize {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        // Try to parse as <page-size> [ <orientation> ]
+        if let Ok(paper_size) = input.try_parse(PaperSize::parse) {
+            let orientation = input
+                .try_parse(PageSizeOrientation::parse)
+                .unwrap_or(PageSizeOrientation::Portrait);
+            return Ok(PageSize::PaperSize(paper_size, orientation));
+        }
+        // Try to parse as <orientation> [ <page-size> ]
+        if let Ok(orientation) = input.try_parse(PageSizeOrientation::parse) {
+            if let Ok(paper_size) = input.try_parse(PaperSize::parse) {
+                return Ok(PageSize::PaperSize(paper_size, orientation));
+            }
+            return Ok(PageSize::Orientation(orientation));
+        }
+        // Try to parse dimensions
+        if let Ok(size) =
+            input.try_parse(|i| Size2D::parse_with(context, i, NonNegativeLength::parse))
+        {
+            return Ok(PageSize::Size(size));
+        }
+        // auto value
+        input.expect_ident_matching("auto")?;
+        Ok(PageSize::Auto)
+    }
+}
+
+/// Page name value.
+///
+/// https://drafts.csswg.org/css-page-3/#using-named-pages
+#[derive(
+    Clone,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToCss,
+    ToComputedValue,
+    ToResolvedValue,
+    ToShmem,
+    ToTyped,
+)]
+#[repr(C, u8)]
+pub enum PageName {
+    /// `auto` value.
+    Auto,
+    /// Page name value
+    PageName(CustomIdent),
+}
+
+impl Parse for PageName {
+    fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        let ident = input.expect_ident()?;
+        Ok(match_ignore_ascii_case! { ident,
+            "auto" => PageName::auto(),
+            _ => PageName::PageName(CustomIdent::from_ident(ident, &[])?),
+        })
+    }
+}
+
+impl PageName {
+    /// `auto` value.
+    #[inline]
+    pub fn auto() -> Self {
+        PageName::Auto
+    }
+
+    /// Whether this is the `auto` value.
+    #[inline]
+    pub fn is_auto(&self) -> bool {
+        matches!(*self, PageName::Auto)
+    }
+}

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

@@ -0,0 +1,121 @@
+/* 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 specified value CSS param() values.
+
+use crate::custom_properties::VariableValue;
+use crate::parser::{Parse, ParserContext};
+use crate::values::fmt;
+use crate::values::CssWriter;
+use crate::{derives::*, values::DashedIdent};
+use cssparser::Parser;
+use std::fmt::Write;
+use style_traits::arc_slice::ArcSlice;
+use style_traits::owned_str::OwnedStr;
+use style_traits::{ParseError, ToCss};
+
+/// A struct to hold a specific '<declaration-value>'.
+#[derive(
+    Clone,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToComputedValue,
+    ToResolvedValue,
+    ToShmem,
+)]
+#[repr(transparent)]
+pub struct LinkParamValue(pub OwnedStr);
+
+/// A single param(--ident, value) entry: https://drafts.csswg.org/css-link-params-1/#funcdef-param
+#[derive(
+    Clone,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToComputedValue,
+    ToResolvedValue,
+    ToShmem,
+)]
+#[repr(C)]
+pub struct LinkParam {
+    /// link-parameters' param name, in the form of an <dashed-ident>: https://drafts.csswg.org/css-values-4/#typedef-dashed-ident
+    pub name: DashedIdent,
+    /// link-parameters' value, in the form of a <declaration-value>: https://drafts.csswg.org/css-syntax-3/#typedef-declaration-value
+    pub value: LinkParamValue,
+}
+
+/// A struct to hold all specified link-parameters: https://drafts.csswg.org/css-link-params-1/
+///
+/// We treat `none` as an empty slice and vis-versa
+#[derive(
+    Clone,
+    Debug,
+    Default,
+    MallocSizeOf,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToComputedValue,
+    ToCss,
+    ToResolvedValue,
+    ToShmem,
+    ToTyped,
+)]
+#[repr(C)]
+#[css(comma)]
+#[typed(skip_derive_fields)]
+pub struct LinkParameters(
+    /// Slice of specified link-parameters properties: https://drafts.csswg.org/css-link-params-1/#link-param-prop
+    #[css(iterable, if_empty = "none")]
+    #[ignore_malloc_size_of = "Arc"]
+    pub ArcSlice<LinkParam>,
+);
+
+impl LinkParameters {
+    /// Returns the `none` value.
+    pub fn none() -> Self {
+        Self(ArcSlice::default())
+    }
+}
+
+impl Parse for LinkParameters {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        if input.try_parse(|i| i.expect_ident_matching("none")).is_ok() {
+            return Ok(Self::none());
+        }
+
+        let params = input.parse_comma_separated(|input| {
+            input.expect_function_matching("param")?;
+            input.parse_nested_block(|input| {
+                let name = DashedIdent::parse(context, input)?;
+                input.expect_comma()?;
+                // if a comma exists then parse it and set value as specified, even if no value provided
+                // need to handle url references properly https://bugzilla.mozilla.org/show_bug.cgi?id=2028998
+                let parsed = VariableValue::parse(input, None, context.url_data)?;
+                let value = LinkParamValue(OwnedStr::from(parsed.css));
+                Ok(LinkParam { name, value })
+            })
+        })?;
+
+        Ok(Self(crate::ArcSlice::from_iter(params.into_iter())))
+    }
+}
+
+impl ToCss for LinkParam {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        dest.write_str("param(")?;
+        self.name.to_css(dest)?;
+        dest.write_str(", ")?;
+        if !self.value.0.is_empty() {
+            // Don't use to_css, instead write the raw CSS value without extra quoting.
+            dest.write_str(&self.value.0)?;
+        }
+        dest.write_char(')')
+    }
+}

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

@@ -0,0 +1,364 @@
+/* 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 percentages.
+
+use crate::derives::*;
+use crate::parser::{Parse, ParserContext};
+use crate::typed_om::{ToTyped, TypedValue};
+use crate::values::computed::percentage::Percentage as ComputedPercentage;
+use crate::values::computed::{Context, ToComputedValue};
+use crate::values::generics::{NonNegative, Optional};
+use crate::values::specified::calc::{CalcNode, CalcNumeric, CalcPercentageLeaf, Leaf};
+use crate::values::specified::{CalcLengthPercentage, LengthPercentage, NoCalcNumber, Number};
+use crate::values::tagged_numeric::{Extracted, NumericUnion, Unpacked, UnpackedMut};
+use crate::values::{normalize, reify_percentage, serialize_percentage, CSSFloat};
+use cssparser::{Parser, Token};
+use std::fmt::{self, Write};
+use style_traits::values::specified::AllowedNumericType;
+use style_traits::{CssWriter, ParseError, SpecifiedValueInfo, ToCss};
+use thin_vec::ThinVec;
+
+/// A percentage value, where [0 .. 100%] maps to [0.0 .. 1.0]
+#[derive(Clone, Copy, Debug, Default, MallocSizeOf, PartialEq, ToShmem)]
+#[repr(C)]
+pub struct NoCalcPercentage(CSSFloat);
+
+impl SpecifiedValueInfo for NoCalcPercentage {}
+
+impl ToCss for NoCalcPercentage {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        serialize_percentage(self.0, dest)
+    }
+}
+
+impl ToTyped for NoCalcPercentage {
+    fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        reify_percentage(self.0, dest)
+    }
+}
+
+impl NoCalcPercentage {
+    /// Creates a percentage from a numeric value.
+    pub fn new(value: CSSFloat) -> Self {
+        Self(value)
+    }
+
+    /// `0%`
+    #[inline]
+    pub fn zero() -> Self {
+        Self::new(0.)
+    }
+
+    /// `100%`
+    #[inline]
+    pub fn hundred() -> Self {
+        Self::new(1.)
+    }
+
+    /// Gets the underlying value for this float.
+    #[inline]
+    pub fn get(&self) -> CSSFloat {
+        self.0
+    }
+
+    /// Return the unit, as a string.
+    pub fn unit(&self) -> &'static str {
+        "percent"
+    }
+
+    /// Return no canonical unit (percent values do not have one).
+    pub fn canonical_unit(&self) -> Option<&'static str> {
+        None
+    }
+
+    /// Convert only if the unit is the same (conversion to other units does
+    /// not make sense).
+    pub fn to(&self, unit: &str) -> Result<Self, ()> {
+        if !unit.eq_ignore_ascii_case("percent") {
+            return Err(());
+        }
+        Ok(*self)
+    }
+}
+
+impl ToComputedValue for NoCalcPercentage {
+    type ComputedValue = ComputedPercentage;
+
+    fn to_computed_value(&self, _: &Context) -> Self::ComputedValue {
+        ComputedPercentage(normalize(self.get()))
+    }
+
+    fn from_computed_value(computed: &Self::ComputedValue) -> Self {
+        Self::new(computed.0)
+    }
+}
+
+impl From<f32> for NoCalcPercentage {
+    fn from(value: f32) -> Self {
+        Self(value)
+    }
+}
+
+impl From<NoCalcPercentage> for f32 {
+    fn from(percentage: NoCalcPercentage) -> f32 {
+        percentage.0
+    }
+}
+
+/// A specified percentage value, either a plain value or a `calc()` expression.
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToShmem)]
+pub struct Percentage(NumericUnion<(), f32, CalcNumeric>);
+
+impl ToCss for Percentage {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        match self.0.unpack() {
+            Unpacked::Inline((), p) => NoCalcPercentage(p).to_css(dest),
+            Unpacked::Boxed(calc) => calc.to_css(dest),
+        }
+    }
+}
+
+impl ToTyped for Percentage {
+    fn to_typed(&self, dest: &mut ThinVec<TypedValue>) -> Result<(), ()> {
+        match self.0.unpack() {
+            Unpacked::Inline((), p) => NoCalcPercentage(p).to_typed(dest),
+            Unpacked::Boxed(calc) => calc.to_typed(dest),
+        }
+    }
+}
+
+impl Percentage {
+    /// Creates a percentage from a numeric value.
+    pub fn new(value: CSSFloat) -> Self {
+        Self(NumericUnion::inline((), value))
+    }
+
+    /// Returns a new percentage calc value with the value `val`.
+    #[inline]
+    pub fn new_calc(val: Box<CalcNumeric>) -> Self {
+        Self(NumericUnion::boxed(val))
+    }
+
+    /// `0%`
+    #[inline]
+    pub fn zero() -> Self {
+        Self::new(0.)
+    }
+
+    /// `100%`
+    #[inline]
+    pub fn hundred() -> Self {
+        Self::new(1.)
+    }
+
+    /// Returns true if it is a calc percentage.
+    #[inline]
+    pub fn is_calc(&self) -> bool {
+        self.0.is_boxed()
+    }
+
+    /// Returns the value if this is a plain (non-calc) percentage, or None otherwise.
+    /// Use `resolve()` to also handle resolvable calc expressions, or `to_computed_value()`
+    /// when computed context is available.
+    #[inline]
+    pub fn get(&self) -> Option<f32> {
+        match self.0.unpack() {
+            Unpacked::Inline((), f) => Some(f),
+            Unpacked::Boxed(..) => None,
+        }
+    }
+
+    /// Returns the value if it can be resolved at parse time, including resolvable calc
+    /// expressions. Returns None for calc expressions that require computed context
+    /// (e.g. those using relative lengths or sibling-index()).
+    #[inline]
+    pub fn resolve(&self) -> Option<CSSFloat> {
+        match self.0.unpack() {
+            Unpacked::Inline((), f) => Some(f),
+            Unpacked::Boxed(calc) => calc.as_percentage().map(|p| p.get()),
+        }
+    }
+
+    /// Returns this percentage as a number.
+    pub fn to_number(&self) -> Option<Number> {
+        Some(match self.0.unpack() {
+            Unpacked::Inline((), p) => Number::new(p),
+            Unpacked::Boxed(calc) => {
+                let p = calc.as_percentage()?.get();
+                Number::new_calc(Box::new(
+                    calc.with_leaf_node(Leaf::Number(NoCalcNumber::new(p))),
+                ))
+            },
+        })
+    }
+
+    /// Returns this percentage as a LengthPercentage.
+    pub fn to_length_percentage(self) -> LengthPercentage {
+        match self.0.extract() {
+            Extracted::Inline((), p) => LengthPercentage::Percentage(NoCalcPercentage(p)),
+            Extracted::Boxed(calc) => LengthPercentage::Calc(Box::new(CalcLengthPercentage(*calc))),
+        }
+    }
+
+    /// Reverses this percentage, preserving calc-ness.
+    ///
+    /// For example: If it was 20%, convert it into 80%.
+    pub fn reverse(&mut self) {
+        match self.0.unpack_mut() {
+            UnpackedMut::Inline(_, p) => {
+                *p = 1. - *p;
+            },
+            UnpackedMut::Boxed(calc) => {
+                let mut sum = smallvec::SmallVec::<[CalcNode; 2]>::new();
+                sum.push(CalcNode::Leaf(Leaf::Percentage(CalcPercentageLeaf::new(
+                    1.,
+                    Optional::None,
+                ))));
+                let mut node = calc.node.clone();
+                node.negate();
+                sum.push(node);
+                let mut diff = CalcNode::Sum(sum.into_boxed_slice().into());
+                diff.simplify_and_sort();
+                calc.node = diff;
+            },
+        }
+    }
+
+    /// Parses a specific kind of percentage.
+    pub fn parse_with_clamping_mode(
+        context: &ParserContext,
+        input: &mut Parser,
+        num_context: AllowedNumericType,
+    ) -> Result<Self, ParseError> {
+        Ok(Self(match *input.next()? {
+            Token::Percentage { unit_value, .. }
+                if num_context.is_ok(context.parsing_mode, unit_value) =>
+            {
+                NumericUnion::inline((), unit_value)
+            },
+            Token::Function(ref name) => {
+                let function = CalcNode::math_function(context, name)?;
+                let calc = CalcNode::parse_percentage(context, input, num_context, function)?;
+                NumericUnion::boxed(Box::new(calc))
+            },
+            _ => return Err(ParseError::unexpected_token()),
+        }))
+    }
+
+    /// Parses a percentage token, but rejects it if it's negative.
+    pub fn parse_non_negative(
+        context: &ParserContext,
+        input: &mut Parser,
+    ) -> Result<Self, ParseError> {
+        Self::parse_with_clamping_mode(context, input, AllowedNumericType::NonNegative)
+    }
+
+    /// Parses a percentage token, but rejects it if it's negative or more than
+    /// 100%.
+    pub fn parse_zero_to_a_hundred(
+        context: &ParserContext,
+        input: &mut Parser,
+    ) -> Result<Self, ParseError> {
+        Self::parse_with_clamping_mode(context, input, AllowedNumericType::ZeroToOne)
+    }
+
+    /// Clamp to 100% if the value is over 100%.
+    #[inline]
+    pub fn clamp_to_hundred(&mut self) {
+        match self.0.unpack_mut() {
+            UnpackedMut::Inline((), p) => *p = p.min(1.),
+            UnpackedMut::Boxed(calc) => {
+                calc.clamping_mode = AllowedNumericType::ZeroToOne;
+            },
+        }
+    }
+}
+
+impl Parse for Percentage {
+    #[inline]
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        Self::parse_with_clamping_mode(context, input, AllowedNumericType::All)
+    }
+}
+
+impl ToComputedValue for Percentage {
+    type ComputedValue = ComputedPercentage;
+
+    #[inline]
+    fn to_computed_value(&self, context: &Context) -> Self::ComputedValue {
+        match self.0.unpack() {
+            Unpacked::Inline((), p) => NoCalcPercentage(p).to_computed_value(context),
+            Unpacked::Boxed(calc) => {
+                let value = calc.resolve(context, |result| match result {
+                    Ok(Leaf::Percentage(p)) => p.get(),
+                    _ => {
+                        debug_assert!(
+                            false,
+                            "Unexpected Percentage::Calc without resolved percentage"
+                        );
+                        f32::NAN
+                    },
+                });
+                ComputedPercentage(crate::values::normalize(value).min(f32::MAX).max(f32::MIN))
+            },
+        }
+    }
+
+    #[inline]
+    fn from_computed_value(computed: &Self::ComputedValue) -> Self {
+        Percentage::new(computed.0)
+    }
+}
+
+impl SpecifiedValueInfo for Percentage {}
+
+/// Turns the percentage into a plain float.
+pub trait ToPercentage {
+    /// Returns whether this percentage used to be a calc().
+    fn is_calc(&self) -> bool {
+        false
+    }
+    /// Returns the percentage as a plain float, or None for calc expressions that require
+    /// computed context. Will always return Some if `is_calc` is false.
+    fn to_percentage(&self) -> Option<CSSFloat>;
+}
+
+impl ToPercentage for Percentage {
+    fn is_calc(&self) -> bool {
+        self.0.is_boxed()
+    }
+
+    fn to_percentage(&self) -> Option<CSSFloat> {
+        self.resolve()
+    }
+}
+
+/// A wrapper of Percentage, whose value must be >= 0.
+pub type NonNegativePercentage = NonNegative<Percentage>;
+
+impl Parse for NonNegativePercentage {
+    #[inline]
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        Ok(NonNegative(Percentage::parse_non_negative(context, input)?))
+    }
+}
+
+impl NonNegativePercentage {
+    /// Convert to ComputedPercentage, for FontFaceRule size-adjust getter.
+    /// Returns None if the value is a calc expression that cannot be resolved at parse time.
+    #[inline]
+    pub fn compute(&self) -> Option<ComputedPercentage> {
+        self.0
+            .resolve()
+            .map(|f| AllowedNumericType::NonNegative.clamp(f))
+            .map(ComputedPercentage)
+    }
+}