blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/parser.rs

@@ -0,0 +1,276 @@
+/* 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/. */
+
+//! The context within which CSS code is parsed.
+
+use crate::context::QuirksMode;
+use crate::custom_properties::{AttrTaint, AttrTaintedRange};
+use crate::error_reporting::{ContextualParseError, ParseErrorReporter};
+use crate::stylesheets::{CssRuleType, CssRuleTypes, Namespaces, Origin, UrlExtraData};
+use crate::use_counters::UseCounters;
+use cssparser::{Parser, SourceLocation, UnicodeRange};
+use selectors::parser::ParseRelative;
+use std::borrow::Cow;
+use style_traits::{OneOrMoreSeparated, ParseError, ParsingMode, Separator};
+
+/// Nesting context for parsing rules.
+#[derive(Clone, Copy)]
+pub struct NestingContext {
+    /// All rule types we've nested into, if any.
+    pub rule_types: CssRuleTypes,
+    /// Whether or not parsing relative selector syntax should be allowed.
+    pub parse_relative: ParseRelative,
+}
+
+impl NestingContext {
+    fn parse_relative_for(rule_type: CssRuleType) -> ParseRelative {
+        match rule_type {
+            CssRuleType::Scope => ParseRelative::ForScope,
+            CssRuleType::Style => ParseRelative::ForNesting,
+            _ => ParseRelative::No,
+        }
+    }
+
+    /// Create a new nesting context.
+    pub fn new(rule_types: CssRuleTypes, parse_nested_rule_type: Option<CssRuleType>) -> Self {
+        Self {
+            rule_types,
+            parse_relative: parse_nested_rule_type
+                .map_or(ParseRelative::No, Self::parse_relative_for),
+        }
+    }
+
+    /// Create a new nesting context based on the given rule.
+    pub fn new_from_rule(rule_type: Option<CssRuleType>) -> Self {
+        Self {
+            rule_types: rule_type.map(CssRuleTypes::from).unwrap_or_default(),
+            parse_relative: rule_type
+                .map(Self::parse_relative_for)
+                .unwrap_or(ParseRelative::No),
+        }
+    }
+
+    /// Save the current nesting context.
+    pub fn save(&mut self, rule_type: CssRuleType) -> Self {
+        let old = *self;
+        self.rule_types.insert(rule_type);
+        let new_parse_relative = Self::parse_relative_for(rule_type);
+        if new_parse_relative != ParseRelative::No {
+            self.parse_relative = new_parse_relative;
+        }
+        old
+    }
+
+    /// Load the saved nesting context.
+    pub fn restore(&mut self, saved: Self) {
+        *self = saved;
+    }
+}
+
+/// The data that the parser needs from outside in order to parse a stylesheet.
+pub struct ParserContext<'a> {
+    /// The `Origin` of the stylesheet, whether it's a user, author or
+    /// user-agent stylesheet.
+    pub stylesheet_origin: Origin,
+    /// The extra data we need for resolving url values.
+    pub url_data: &'a UrlExtraData,
+    /// The mode to use when parsing.
+    pub parsing_mode: ParsingMode,
+    /// The quirks mode of this stylesheet.
+    pub quirks_mode: QuirksMode,
+    /// The active error reporter, or none if error reporting is disabled.
+    error_reporter: Option<&'a dyn ParseErrorReporter>,
+    /// The currently active namespaces.
+    pub namespaces: Cow<'a, Namespaces>,
+    /// The use counters we want to record while parsing style rules, if any.
+    pub use_counters: Option<&'a UseCounters>,
+    /// Current nesting context.
+    pub nesting_context: NestingContext,
+    /// The relevant regions in the input that have been tainted by attr() if relevant.
+    pub attr_tainted_regions: AttrTaint,
+}
+
+impl<'a> ParserContext<'a> {
+    /// Create a parser context.
+    #[inline]
+    pub fn new(
+        stylesheet_origin: Origin,
+        url_data: &'a UrlExtraData,
+        rule_type: Option<CssRuleType>,
+        parsing_mode: ParsingMode,
+        quirks_mode: QuirksMode,
+        namespaces: Cow<'a, Namespaces>,
+        error_reporter: Option<&'a dyn ParseErrorReporter>,
+        use_counters: Option<&'a UseCounters>,
+        attr_tainted_regions: AttrTaint,
+    ) -> Self {
+        Self {
+            stylesheet_origin,
+            url_data,
+            parsing_mode,
+            quirks_mode,
+            error_reporter,
+            namespaces,
+            use_counters,
+            nesting_context: NestingContext::new_from_rule(rule_type),
+            attr_tainted_regions,
+        }
+    }
+
+    /// Temporarily sets the rule_type and executes the callback function, returning its result.
+    pub fn nest_for_rule<R>(
+        &mut self,
+        rule_type: CssRuleType,
+        cb: impl FnOnce(&mut Self) -> R,
+    ) -> R {
+        let old = self.nesting_context.save(rule_type);
+        let r = cb(self);
+        self.nesting_context.restore(old);
+        r
+    }
+
+    /// Temporarily adds a parsing mode flag and executes the callback, returning its result.
+    pub fn with_parsing_mode<R>(&mut self, mode: ParsingMode, cb: impl FnOnce(&Self) -> R) -> R {
+        let old = self.parsing_mode;
+        self.parsing_mode |= mode;
+        let r = cb(self);
+        self.parsing_mode = old;
+        r
+    }
+
+    /// Whether we're in a @page rule.
+    #[inline]
+    pub fn in_page_rule(&self) -> bool {
+        self.nesting_context.rule_types.contains(CssRuleType::Page)
+    }
+
+    /// Returns whether !important declarations are forbidden.
+    #[inline]
+    pub fn allows_important_declarations(&self) -> bool {
+        !self
+            .nesting_context
+            .rule_types
+            .intersects(CssRuleTypes::IMPORTANT_FORBIDDEN)
+    }
+
+    /// Returns whether we can parse element-dependent values.
+    #[inline]
+    pub fn has_element_context(&self) -> bool {
+        if self
+            .nesting_context
+            .rule_types
+            .intersects(CssRuleTypes::WITHOUT_ELEMENT_CONTEXT)
+        {
+            return false;
+        }
+
+        if self
+            .parsing_mode
+            .intersects(ParsingMode::MEDIA_QUERY_CONDITION)
+        {
+            return false;
+        }
+
+        true
+    }
+
+    /// Get the rule type, which assumes that one is available.
+    pub fn rule_types(&self) -> CssRuleTypes {
+        self.nesting_context.rule_types
+    }
+
+    /// Returns whether CSS error reporting is enabled.
+    #[inline]
+    pub fn error_reporting_enabled(&self) -> bool {
+        self.error_reporter.is_some()
+    }
+
+    /// Record a CSS parse error with this context’s error reporting.
+    pub fn log_css_error(&self, location: SourceLocation, error: ContextualParseError) {
+        let error_reporter = match self.error_reporter {
+            Some(r) => r,
+            None => return,
+        };
+
+        error_reporter.report_error(self.url_data, location, error)
+    }
+
+    /// Whether we're in a user-agent stylesheet.
+    #[inline]
+    pub fn in_ua_sheet(&self) -> bool {
+        self.stylesheet_origin == Origin::UserAgent
+    }
+
+    /// Returns whether chrome-only rules should be parsed.
+    #[inline]
+    pub fn chrome_rules_enabled(&self) -> bool {
+        self.url_data.chrome_rules_enabled() || self.stylesheet_origin != Origin::Author
+    }
+
+    /// Whether the parsing mode allows units or functions that are not computationally independent.
+    #[inline]
+    pub fn allows_computational_dependence(&self) -> bool {
+        self.parsing_mode.allows_computational_dependence()
+    }
+
+    /// Whether any `<url>` over this `range` is disallowed due to attr()-tainting.
+    pub fn disallow_urls_in_range(&self, range: &AttrTaintedRange) -> bool {
+        self.attr_tainted_regions
+            .should_disallow_urls_in_range(range)
+    }
+}
+
+/// A trait to abstract parsing of a specified value given a `ParserContext` and
+/// CSS input.
+///
+/// This can be derived on keywords with `#[derive(Parse)]`.
+///
+/// The derive code understands the following attributes on each of the variants:
+///
+///  * `#[parse(aliases = "foo,bar")]` can be used to alias a value with another
+///    at parse-time.
+///
+///  * `#[parse(condition = "function")]` can be used to make the parsing of the
+///    value conditional on `function`, which needs to fulfill
+///    `fn(&ParserContext) -> bool`.
+///
+///  * `#[parse(parse_fn = "function")]` can be used to specify a function other than Parser::parse
+///    for a particular variant.
+pub trait Parse: Sized {
+    /// Parse a value of this type.
+    ///
+    /// Returns an error on failure.
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError>;
+}
+
+impl<T> Parse for Vec<T>
+where
+    T: Parse + OneOrMoreSeparated,
+    <T as OneOrMoreSeparated>::S: Separator,
+{
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        <T as OneOrMoreSeparated>::S::parse(input, |i| T::parse(context, i))
+    }
+}
+
+impl<T> Parse for Box<T>
+where
+    T: Parse,
+{
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        T::parse(context, input).map(Box::new)
+    }
+}
+
+impl Parse for crate::OwnedStr {
+    fn parse(_: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        Ok(input.expect_string()?.as_ref().to_owned().into())
+    }
+}
+
+impl Parse for UnicodeRange {
+    fn parse(_: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        Ok(UnicodeRange::parse(input)?)
+    }
+}

package/vendor/stylo/piecewise_linear.rs

@@ -0,0 +1,282 @@
+/* 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/. */
+
+//! A piecewise linear function, following CSS linear easing
+use crate::derives::*;
+use crate::values::computed::Percentage;
+use core::slice::Iter;
+/// draft as in https://github.com/w3c/csswg-drafts/pull/6533.
+use euclid::approxeq::ApproxEq;
+use itertools::Itertools;
+use std::fmt::{self, Write};
+use style_traits::{CssWriter, ToCss};
+
+use crate::values::CSSFloat;
+
+type ValueType = CSSFloat;
+/// a single entry in a piecewise linear function.
+#[allow(missing_docs)]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToResolvedValue,
+    ToShmem,
+    Serialize,
+    Deserialize,
+)]
+#[repr(C)]
+pub struct PiecewiseLinearFunctionEntry {
+    pub x: ValueType,
+    pub y: ValueType,
+}
+
+impl ToCss for PiecewiseLinearFunctionEntry {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: fmt::Write,
+    {
+        self.y.to_css(dest)?;
+        dest.write_char(' ')?;
+        Percentage(self.x).to_css(dest)
+    }
+}
+
+/// Representation of a piecewise linear function, a series of linear functions.
+#[derive(
+    Default,
+    Clone,
+    Debug,
+    MallocSizeOf,
+    PartialEq,
+    SpecifiedValueInfo,
+    ToResolvedValue,
+    ToCss,
+    ToShmem,
+    Serialize,
+    Deserialize,
+)]
+#[repr(C)]
+#[css(comma)]
+pub struct PiecewiseLinearFunction {
+    #[css(iterable)]
+    #[ignore_malloc_size_of = "Arc"]
+    #[shmem(field_bound)]
+    entries: crate::ArcSlice<PiecewiseLinearFunctionEntry>,
+}
+
+/// Parameters to define one linear stop.
+pub type PiecewiseLinearFunctionBuildParameters = (CSSFloat, Option<CSSFloat>);
+
+impl PiecewiseLinearFunction {
+    /// Interpolate y value given x and two points. The linear function will be rooted at the asymptote.
+    fn interpolate(
+        x: ValueType,
+        prev: PiecewiseLinearFunctionEntry,
+        next: PiecewiseLinearFunctionEntry,
+        asymptote: &PiecewiseLinearFunctionEntry,
+    ) -> ValueType {
+        // Short circuit if the x is on prev or next.
+        // `next` point is preferred as per spec.
+        if x.approx_eq(&next.x) {
+            return next.y;
+        }
+        if x.approx_eq(&prev.x) {
+            return prev.y;
+        }
+        // Avoid division by zero.
+        if prev.x.approx_eq(&next.x) {
+            return next.y;
+        }
+        let slope = (next.y - prev.y) / (next.x - prev.x);
+        slope * (x - asymptote.x) + asymptote.y
+    }
+
+    /// Get the y value of the piecewise linear function given the x value, as per
+    /// https://drafts.csswg.org/css-easing-2/#linear-easing-function-output
+    pub fn at(&self, x: ValueType) -> ValueType {
+        if !x.is_finite() {
+            return if x > 0.0 { 1.0 } else { 0.0 };
+        }
+        if self.entries.is_empty() {
+            // Implied y = x, as per spec.
+            return x;
+        }
+        if self.entries.len() == 1 {
+            // Implied y = <constant>, as per spec.
+            return self.entries[0].y;
+        }
+        // Spec dictates the valid input domain is [0, 1]. Outside of this range, the output
+        // should be calculated as if the slopes at start and end extend to infinity. However, if the
+        // start/end have two points of the same position, the line should extend along the x-axis.
+        // The function doesn't have to cover the input domain, in which case the extension logic
+        // applies even if the input falls in the input domain.
+        // Also, we're guaranteed to have at least two elements at this point.
+        if x < self.entries[0].x {
+            return Self::interpolate(x, self.entries[0], self.entries[1], &self.entries[0]);
+        }
+        let mut rev_iter = self.entries.iter().rev();
+        let last = rev_iter.next().unwrap();
+        if x >= last.x {
+            let second_last = rev_iter.next().unwrap();
+            return Self::interpolate(x, *second_last, *last, last);
+        }
+
+        // Now we know the input sits within the domain explicitly defined by our function.
+        for (point_b, point_a) in self.entries.iter().rev().tuple_windows() {
+            // Need to let point A be the _last_ point where its x is less than the input x,
+            // hence the reverse traversal.
+            if x < point_a.x {
+                continue;
+            }
+            return Self::interpolate(x, *point_a, *point_b, point_a);
+        }
+        unreachable!("Input is supposed to be within the entries' min & max!");
+    }
+
+    #[allow(missing_docs)]
+    pub fn iter(&self) -> Iter<'_, PiecewiseLinearFunctionEntry> {
+        self.entries.iter()
+    }
+}
+
+/// Entry of a piecewise linear function while building, where the calculation of x value can be deferred.
+#[derive(Clone, Copy)]
+struct BuildEntry {
+    x: Option<ValueType>,
+    y: ValueType,
+}
+
+/// Builder object to generate a linear function.
+#[derive(Default)]
+pub struct PiecewiseLinearFunctionBuilder {
+    largest_x: Option<ValueType>,
+    smallest_x: Option<ValueType>,
+    entries: Vec<BuildEntry>,
+}
+
+impl PiecewiseLinearFunctionBuilder {
+    /// Create a builder for a known amount of linear stop entries.
+    pub fn with_capacity(len: usize) -> Self {
+        PiecewiseLinearFunctionBuilder {
+            largest_x: None,
+            smallest_x: None,
+            entries: Vec::with_capacity(len),
+        }
+    }
+
+    fn create_entry(&mut self, y: ValueType, x: Option<ValueType>) {
+        let x = match x {
+            Some(x) if x.is_finite() => x,
+            _ if self.entries.is_empty() => 0.0, // First x is 0 if not specified (Or not finite)
+            _ => {
+                self.entries.push(BuildEntry { x: None, y });
+                return;
+            },
+        };
+        // Specified x value cannot regress, as per spec.
+        let x = match self.largest_x {
+            Some(largest_x) => x.max(largest_x),
+            None => x,
+        };
+        self.largest_x = Some(x);
+        // Whatever we see the earliest is the smallest value.
+        if self.smallest_x.is_none() {
+            self.smallest_x = Some(x);
+        }
+        self.entries.push(BuildEntry { x: Some(x), y });
+    }
+
+    /// Add a new entry into the piecewise linear function with specified y value.
+    /// If the start x value is given, that is where the x value will be. Otherwise,
+    /// the x value is calculated later. If the end x value is specified, a flat segment
+    /// is generated. If start x value is not specified but end x is, it is treated as
+    /// start x.
+    pub fn push(&mut self, y: CSSFloat, x_start: Option<CSSFloat>) {
+        self.create_entry(y, x_start)
+    }
+
+    /// Finish building the piecewise linear function by resolving all undefined x values,
+    /// then return the result.
+    pub fn build(mut self) -> PiecewiseLinearFunction {
+        if self.entries.is_empty() {
+            return PiecewiseLinearFunction::default();
+        }
+        if self.entries.len() == 1 {
+            // Don't bother resolving anything.
+            return PiecewiseLinearFunction {
+                entries: crate::ArcSlice::from_iter(std::iter::once(
+                    PiecewiseLinearFunctionEntry {
+                        x: 0.,
+                        y: self.entries[0].y,
+                    },
+                )),
+            };
+        }
+        // Guaranteed at least two elements.
+        // Start element's x value should've been assigned when the first value was pushed.
+        debug_assert!(
+            self.entries[0].x.is_some(),
+            "Expected an entry with x defined!"
+        );
+        // Spec asserts that if the last entry does not have an x value, it is assigned the largest seen x value.
+        self.entries
+            .last_mut()
+            .unwrap()
+            .x
+            .get_or_insert(self.largest_x.filter(|x| x > &1.0).unwrap_or(1.0));
+        // Now we have at least two elements with x values, with start & end x values guaranteed.
+
+        let mut result = Vec::with_capacity(self.entries.len());
+        result.push(PiecewiseLinearFunctionEntry {
+            x: self.entries[0].x.unwrap(),
+            y: self.entries[0].y,
+        });
+        for (i, e) in self.entries.iter().enumerate().skip(1) {
+            if e.x.is_none() {
+                // Need to calculate x values by first finding an entry with the first
+                // defined x value (Guaranteed to exist as the list end has it defined).
+                continue;
+            }
+            // x is defined for this element.
+            let divisor = i - result.len() + 1;
+            // Any element(s) with undefined x to assign?
+            if divisor != 1 {
+                // Have at least one element in result at all times.
+                let start_x = result.last().unwrap().x;
+                let increment = (e.x.unwrap() - start_x) / divisor as ValueType;
+                // Grab every element with undefined x to this point, which starts at the end of the result
+                // array, and ending right before the current index. Then, assigned the evenly divided
+                // x values.
+                result.extend(
+                    self.entries[result.len()..i]
+                        .iter()
+                        .enumerate()
+                        .map(|(j, e)| {
+                            debug_assert!(e.x.is_none(), "Expected an entry with x undefined!");
+                            PiecewiseLinearFunctionEntry {
+                                x: increment * (j + 1) as ValueType + start_x,
+                                y: e.y,
+                            }
+                        }),
+                );
+            }
+            result.push(PiecewiseLinearFunctionEntry {
+                x: e.x.unwrap(),
+                y: e.y,
+            });
+        }
+        debug_assert_eq!(
+            result.len(),
+            self.entries.len(),
+            "Should've mapped one-to-one!"
+        );
+        PiecewiseLinearFunction {
+            entries: crate::ArcSlice::from_iter(result.into_iter()),
+        }
+    }
+}

package/vendor/stylo/prefs.rs

@@ -0,0 +1,33 @@
+/* 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/. */
+
+//! Macro helpers to get preference values.
+
+/// Returns the value of a preference exposed to the style crate.
+/// It allows overriding the result for either Gecko or Servo, which is
+/// useful when the preference only exists for one of them.
+#[macro_export]
+#[cfg(feature = "gecko")]
+macro_rules! pref {
+    ($string:tt $(, servo = $_:tt)?) => {
+        static_prefs::pref!($string)
+    };
+    ($string:tt, gecko = $value:tt) => {
+        $value
+    };
+}
+
+/// Returns the value of a preference exposed to the style crate.
+/// It allows overriding the result for either Gecko or Servo, which is
+/// useful when the preference only exists for one of them.
+#[macro_export]
+#[cfg(feature = "servo")]
+macro_rules! pref {
+    ($string:tt $(, gecko = $_:tt)?) => {
+        static_prefs::pref!($string)
+    };
+    ($string:tt, servo = $value:tt) => {
+        $value
+    };
+}