blitz-pdf 0.0.0-stage → 0.1.0

package/vendor/stylo/properties_and_values/rule.rs

@@ -0,0 +1,331 @@
+/* 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 [`@property`] at-rule.
+//!
+//! https://drafts.css-houdini.org/css-properties-values-api-1/#at-property-rule
+
+use super::{
+    registry::PropertyRegistration,
+    value::{
+        AllowComputationallyDependent, ComputedValue as ComputedRegisteredValue,
+        SpecifiedValue as SpecifiedRegisteredValue,
+    },
+};
+use crate::custom_properties::{Name as CustomPropertyName, SpecifiedValue};
+use crate::derives::*;
+use crate::error_reporting::ContextualParseError;
+use crate::parser::{Parse, ParserContext};
+use crate::shared_lock::{SharedRwLockReadGuard, ToCssWithGuard};
+use crate::values::{computed, serialize_atom_name};
+use cssparser::{BasicParseErrorKind, ParseErrorKind, Parser, RuleBodyParser, SourceLocation};
+use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
+use servo_arc::Arc;
+use std::fmt::{self, Write};
+use style_traits::{
+    CssStringWriter, CssWriter, ParseError, PropertyInheritsParseError, PropertySyntaxParseError,
+    StyleParseErrorKind, ToCss,
+};
+use to_shmem::{SharedMemoryBuilder, ToShmem};
+
+pub use super::syntax::Descriptor as SyntaxDescriptor;
+pub use crate::properties::property::{DescriptorId, DescriptorParser, Descriptors};
+
+/// Parse the block inside a `@property` rule.
+///
+/// Valid `@property` rules result in a registered custom property, as if `registerProperty()` had
+/// been called with equivalent parameters.
+pub fn parse_property_block(
+    context: &ParserContext,
+    input: &mut Parser,
+    name: PropertyRuleName,
+    source_location: SourceLocation,
+) -> Result<PropertyRegistration, ParseError> {
+    let mut descriptors = Descriptors::default();
+    let mut parser = DescriptorParser {
+        context,
+        descriptors: &mut descriptors,
+    };
+    let iter = RuleBodyParser::new(input, &mut parser);
+    let mut syntax_err = None;
+    let mut inherits_err = None;
+    for declaration in iter {
+        if !context.error_reporting_enabled() {
+            continue;
+        }
+        if let Err((error, slice, location)) = declaration {
+            let error = match error.kind {
+                // If the provided string is not a valid syntax string (if it
+                // returns failure when consume a syntax definition is called on
+                // it), the descriptor is invalid and must be ignored.
+                ParseErrorKind::Custom(StyleParseErrorKind::PropertySyntaxField(_)) => {
+                    syntax_err = Some(error.clone());
+                    ContextualParseError::UnsupportedValue(slice, error)
+                },
+
+                // If the provided string is not a valid inherits string,
+                // the descriptor is invalid and must be ignored.
+                ParseErrorKind::Custom(StyleParseErrorKind::PropertyInheritsField(_)) => {
+                    inherits_err = Some(error.clone());
+                    ContextualParseError::UnsupportedValue(slice, error)
+                },
+
+                // Unknown descriptors are invalid and ignored, but do not
+                // invalidate the @property rule.
+                _ => ContextualParseError::UnsupportedPropertyDescriptor(slice, error),
+            };
+            context.log_css_error(location, error);
+        }
+    }
+
+    // https://drafts.css-houdini.org/css-properties-values-api-1/#the-syntax-descriptor:
+    //
+    //     The syntax descriptor is required for the @property rule to be valid; if it’s
+    //     missing, the @property rule is invalid.
+    let Some(ref syntax) = descriptors.syntax else {
+        return Err(if let Some(err) = syntax_err {
+            err
+        } else {
+            let err = ParseError::custom(StyleParseErrorKind::PropertySyntaxField(
+                PropertySyntaxParseError::NoSyntax,
+            ));
+            context.log_css_error(
+                source_location,
+                ContextualParseError::UnsupportedValue("", err.clone()),
+            );
+            err
+        });
+    };
+
+    // https://drafts.css-houdini.org/css-properties-values-api-1/#inherits-descriptor:
+    //
+    //     The inherits descriptor is required for the @property rule to be valid; if it’s
+    //     missing, the @property rule is invalid.
+    if descriptors.inherits.is_none() {
+        return Err(if let Some(err) = inherits_err {
+            err
+        } else {
+            let err = ParseError::custom(StyleParseErrorKind::PropertyInheritsField(
+                PropertyInheritsParseError::NoInherits,
+            ));
+            context.log_css_error(
+                source_location,
+                ContextualParseError::UnsupportedValue("", err.clone()),
+            );
+            err
+        });
+    };
+
+    if PropertyRegistration::validate_initial_value(syntax, descriptors.initial_value.as_deref())
+        .is_err()
+    {
+        return Err(ParseError::from_basic_kind(
+            BasicParseErrorKind::AtRuleBodyInvalid,
+        ));
+    }
+
+    Ok(PropertyRegistration {
+        name,
+        descriptors,
+        url_data: context.url_data.clone(),
+        source_location,
+    })
+}
+
+/// Errors that can happen when registering a property.
+#[allow(missing_docs)]
+pub enum PropertyRegistrationError {
+    NoInitialValue,
+    InvalidInitialValue,
+    InitialValueNotComputationallyIndependent,
+}
+
+impl PropertyRegistration {
+    /// Measure heap usage.
+    pub fn size_of(&self, _: &SharedRwLockReadGuard, ops: &mut MallocSizeOfOps) -> usize {
+        MallocSizeOf::size_of(self, ops)
+    }
+
+    /// Computes the value of the computationally independent initial value.
+    pub fn compute_initial_value(
+        &self,
+        computed_context: &computed::Context,
+    ) -> Result<ComputedRegisteredValue, ()> {
+        let Some(ref initial) = self.descriptors.initial_value else {
+            return Err(());
+        };
+
+        if self.descriptors.is_universal() {
+            return Ok(ComputedRegisteredValue::universal(Arc::clone(initial)));
+        }
+
+        let mut input = Parser::new(initial.css_text());
+        input.skip_whitespace();
+
+        match SpecifiedRegisteredValue::compute(
+            &mut input,
+            &self.descriptors,
+            None,
+            &self.url_data,
+            computed_context,
+            AllowComputationallyDependent::No,
+            /* attr_taint */ Default::default(),
+        ) {
+            Ok(computed) => Ok(computed),
+            Err(_) => Err(()),
+        }
+    }
+
+    /// Performs syntax validation as per the initial value descriptor.
+    /// https://drafts.css-houdini.org/css-properties-values-api-1/#initial-value-descriptor
+    pub fn validate_initial_value(
+        syntax: &SyntaxDescriptor,
+        initial_value: Option<&SpecifiedValue>,
+    ) -> Result<(), PropertyRegistrationError> {
+        use crate::properties::CSSWideKeyword;
+        // If the value of the syntax descriptor is the universal syntax definition, then the
+        // initial-value descriptor is optional. If omitted, the initial value of the property is
+        // the guaranteed-invalid value.
+        if syntax.is_universal() && initial_value.is_none() {
+            return Ok(());
+        }
+
+        // Otherwise, if the value of the syntax descriptor is not the universal syntax definition,
+        // the following conditions must be met for the @property rule to be valid:
+
+        // The initial-value descriptor must be present.
+        let Some(initial) = initial_value else {
+            return Err(PropertyRegistrationError::NoInitialValue);
+        };
+
+        // A value that references the environment or other variables is not computationally
+        // independent.
+        if initial.has_references() {
+            return Err(PropertyRegistrationError::InitialValueNotComputationallyIndependent);
+        }
+
+        let mut input = Parser::new(initial.css_text());
+        input.skip_whitespace();
+
+        // The initial-value cannot include CSS-wide keywords.
+        if input.try_parse(CSSWideKeyword::parse).is_ok() {
+            return Err(PropertyRegistrationError::InitialValueNotComputationallyIndependent);
+        }
+
+        match SpecifiedRegisteredValue::parse(
+            &mut input,
+            syntax,
+            &initial.url_data,
+            None,
+            AllowComputationallyDependent::No,
+            /* attr_taint */ Default::default(),
+        ) {
+            Ok(_) => {},
+            Err(_) => return Err(PropertyRegistrationError::InvalidInitialValue),
+        }
+
+        Ok(())
+    }
+}
+
+impl ToCssWithGuard for PropertyRegistration {
+    /// <https://drafts.css-houdini.org/css-properties-values-api-1/#serialize-a-csspropertyrule>
+    fn to_css(&self, _guard: &SharedRwLockReadGuard, dest: &mut CssStringWriter) -> fmt::Result {
+        dest.write_str("@property ")?;
+        self.name.to_css(&mut CssWriter::new(dest))?;
+        dest.write_str(" { ")?;
+        self.descriptors.to_css(&mut CssWriter::new(dest))?;
+        dest.write_char('}')
+    }
+}
+
+impl ToShmem for PropertyRegistration {
+    fn to_shmem(&self, _builder: &mut SharedMemoryBuilder) -> to_shmem::Result<Self> {
+        Err(String::from(
+            "ToShmem failed for PropertyRule: cannot handle @property rules",
+        ))
+    }
+}
+
+/// A custom property name wrapper that includes the `--` prefix in its serialization
+#[derive(Clone, Debug, PartialEq, MallocSizeOf)]
+pub struct PropertyRuleName(pub CustomPropertyName);
+
+impl ToCss for PropertyRuleName {
+    fn to_css<W: Write>(&self, dest: &mut CssWriter<W>) -> fmt::Result {
+        dest.write_str("--")?;
+        serialize_atom_name(&self.0, dest)
+    }
+}
+
+/// <https://drafts.css-houdini.org/css-properties-values-api-1/#inherits-descriptor>
+#[derive(Clone, Debug, MallocSizeOf, PartialEq, ToCss, ToShmem)]
+pub enum Inherits {
+    /// `true` value for the `inherits` descriptor
+    True,
+    /// `false` value for the `inherits` descriptor
+    False,
+}
+
+impl Parse for Inherits {
+    fn parse(_context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        // FIXME(bug 1927012): Remove `return` from try_match_ident_ignore_ascii_case so the closure
+        // can be removed.
+        let result: Result<Inherits, ParseError> = (|| {
+            try_match_ident_ignore_ascii_case! { input,
+                "true" => Ok(Inherits::True),
+                "false" => Ok(Inherits::False),
+            }
+        })();
+        if result.is_err() {
+            Err(ParseError::custom(
+                StyleParseErrorKind::PropertyInheritsField(
+                    PropertyInheritsParseError::InvalidInherits,
+                ),
+            ))
+        } else {
+            result
+        }
+    }
+}
+
+/// Specifies the initial value of the custom property registration represented by the @property
+/// rule, controlling the property’s initial value.
+///
+/// The SpecifiedValue is wrapped in an Arc to avoid copying when using it.
+pub type InitialValue = Arc<SpecifiedValue>;
+
+impl Parse for InitialValue {
+    fn parse(context: &ParserContext, input: &mut Parser) -> Result<Self, ParseError> {
+        input.skip_whitespace();
+        Ok(Arc::new(SpecifiedValue::parse(
+            input,
+            Some(&context.namespaces.prefixes),
+            context.url_data,
+        )?))
+    }
+}
+
+impl Descriptors {
+    /// Returns descriptors for an unregistered property.
+    #[inline]
+    pub fn unregistered() -> &'static Self {
+        static UNREGISTERED: Descriptors = Descriptors {
+            inherits: Some(Inherits::True),
+            syntax: Some(SyntaxDescriptor::universal()),
+            initial_value: None,
+        };
+        &UNREGISTERED
+    }
+
+    /// Whether this property inherits.
+    pub fn inherits(&self) -> bool {
+        self.inherits != Some(Inherits::False)
+    }
+
+    /// Whether this property uses universal syntax.
+    pub fn is_universal(&self) -> bool {
+        self.syntax.as_ref().is_none_or(|s| s.is_universal())
+    }
+}

package/vendor/stylo/properties_and_values/syntax/ascii.rs

@@ -0,0 +1,60 @@
+/* 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/. */
+
+/// Trims ASCII whitespace characters from a slice, and returns the trimmed input.
+pub fn trim_ascii_whitespace(input: &str) -> &str {
+    if input.is_empty() {
+        return input;
+    }
+
+    let mut start = 0;
+    {
+        let mut iter = input.as_bytes().iter();
+        loop {
+            let byte = match iter.next() {
+                Some(b) => b,
+                None => return "",
+            };
+
+            if !byte.is_ascii_whitespace() {
+                break;
+            }
+            start += 1;
+        }
+    }
+
+    let mut end = input.len();
+    assert!(start < end);
+    {
+        let mut iter = input.as_bytes()[start..].iter().rev();
+        loop {
+            let byte = match iter.next() {
+                Some(b) => b,
+                None => {
+                    debug_assert!(false, "We should have caught this in the loop above!");
+                    return "";
+                },
+            };
+
+            if !byte.is_ascii_whitespace() {
+                break;
+            }
+            end -= 1;
+        }
+    }
+
+    &input[start..end]
+}
+
+#[test]
+fn trim_ascii_whitespace_test() {
+    fn test(i: &str, o: &str) {
+        assert_eq!(trim_ascii_whitespace(i), o)
+    }
+
+    test("", "");
+    test(" ", "");
+    test(" a b c ", "a b c");
+    test(" \t \t \ta b c \t \t \t \t", "a b c");
+}

package/vendor/stylo/properties_and_values/syntax/data_type.rs

@@ -0,0 +1,146 @@
+/* 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/. */
+
+//! Used for parsing and serializing component names from the syntax string.
+
+use super::{Component, ComponentName, Multiplier};
+use crate::derives::*;
+use std::fmt::{self, Debug, Write};
+use style_traits::{CssWriter, ToCss};
+
+/// Some types (lengths and colors) depend on other properties to resolve correctly.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, MallocSizeOf, ToShmem)]
+pub struct DependentDataTypes(u8);
+bitflags! {
+    impl DependentDataTypes: u8 {
+        /// <length> values depend on font-size/line-height/zoom...
+        const LENGTH = 1 << 0;
+        /// <color> values depend on color-scheme, etc..
+        const COLOR= 1 << 1;
+    }
+}
+
+/// <https://drafts.css-houdini.org/css-properties-values-api-1/#supported-names>
+#[derive(Clone, Copy, Debug, MallocSizeOf, PartialEq, ToShmem)]
+pub enum DataType {
+    /// Any valid `<length>` value
+    Length,
+    /// `<number>` values
+    Number,
+    /// Any valid <percentage> value
+    Percentage,
+    /// Any valid `<length>` or `<percentage>` value, any valid `<calc()>` expression combining
+    /// `<length>` and `<percentage>` components.
+    LengthPercentage,
+    /// Any valid `<color>` value
+    Color,
+    /// Any valid `<image>` value
+    Image,
+    /// Any valid `<url>` value
+    Url,
+    /// Any valid `<integer>` value
+    Integer,
+    /// Any valid `<angle>` value
+    Angle,
+    /// Any valid `<time>` value
+    Time,
+    /// Any valid `<resolution>` value
+    Resolution,
+    /// Any valid `<transform-function>` value
+    TransformFunction,
+    /// Any valid `<custom-ident>` value
+    CustomIdent,
+    /// A list of valid `<transform-function>` values. Note that "<transform-list>" is a pre-multiplied
+    /// data type name equivalent to "<transform-function>+"
+    TransformList,
+    /// Any valid `<string>` value
+    ///
+    /// <https://github.com/w3c/css-houdini-drafts/issues/1103>
+    String,
+}
+
+impl DataType {
+    /// Converts a component name from a pre-multiplied data type to its un-pre-multiplied equivalent.
+    ///
+    /// <https://drafts.css-houdini.org/css-properties-values-api-1/#pre-multiplied-data-type-name>
+    pub fn unpremultiply(&self) -> Option<Component> {
+        match *self {
+            DataType::TransformList => Some(Component {
+                name: ComponentName::DataType(DataType::TransformFunction),
+                multiplier: Some(Multiplier::Space),
+            }),
+            _ => None,
+        }
+    }
+
+    /// Parses a syntax component name.
+    pub fn from_str(ty: &str) -> Option<Self> {
+        Some(match ty.as_bytes() {
+            b"length" => DataType::Length,
+            b"number" => DataType::Number,
+            b"percentage" => DataType::Percentage,
+            b"length-percentage" => DataType::LengthPercentage,
+            b"color" => DataType::Color,
+            b"image" => DataType::Image,
+            b"url" => DataType::Url,
+            b"integer" => DataType::Integer,
+            b"angle" => DataType::Angle,
+            b"time" => DataType::Time,
+            b"resolution" => DataType::Resolution,
+            b"transform-function" => DataType::TransformFunction,
+            b"custom-ident" => DataType::CustomIdent,
+            b"transform-list" => DataType::TransformList,
+            b"string" => DataType::String,
+            _ => return None,
+        })
+    }
+
+    /// Returns which kinds of dependent data types this property might contain.
+    pub fn dependent_types(&self) -> DependentDataTypes {
+        match self {
+            DataType::Length
+            | DataType::LengthPercentage
+            | DataType::TransformFunction
+            | DataType::TransformList => DependentDataTypes::LENGTH,
+            DataType::Color => DependentDataTypes::COLOR,
+            DataType::Number
+            | DataType::Percentage
+            | DataType::Image
+            | DataType::Url
+            | DataType::Integer
+            | DataType::Angle
+            | DataType::Time
+            | DataType::Resolution
+            | DataType::CustomIdent
+            | DataType::String => DependentDataTypes::empty(),
+        }
+    }
+}
+
+impl ToCss for DataType {
+    fn to_css<W>(&self, dest: &mut CssWriter<W>) -> fmt::Result
+    where
+        W: Write,
+    {
+        dest.write_char('<')?;
+        dest.write_str(match *self {
+            DataType::Length => "length",
+            DataType::Number => "number",
+            DataType::Percentage => "percentage",
+            DataType::LengthPercentage => "length-percentage",
+            DataType::Color => "color",
+            DataType::Image => "image",
+            DataType::Url => "url",
+            DataType::Integer => "integer",
+            DataType::Angle => "angle",
+            DataType::Time => "time",
+            DataType::Resolution => "resolution",
+            DataType::TransformFunction => "transform-function",
+            DataType::CustomIdent => "custom-ident",
+            DataType::TransformList => "transform-list",
+            DataType::String => "string",
+        })?;
+        dest.write_char('>')
+    }
+}