chore: Update cssparser & selectors

Signed-off-by: Dmitry Dygalo <[email protected]>

Author: Stranger6667

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## [Unreleased]
 
+### Changed
+
+- Update `cssparser` to `0.35`.
+- Update `selectors` to `0.28`.
+
 ### Performance
 
 - Slightly improve performance of HTML serialization.

css-inline/Cargo.toml

@@ -29,15 +29,16 @@ file = []
 stylesheet-cache = ["lru"]
 
 [dependencies]
-cssparser = "0.31.2"
+cssparser = "0.35.0"
 html5ever = "0.27.0"
 indexmap = "2.1"
 lru = { version = "0.12.3", optional = true }
 pico-args = { version = "0.3", optional = true }
+precomputed-hash = "0.1.1"
 rayon = { version = "1.10", optional = true }
 reqwest = { version = "0.12.0", optional = true, default-features = false, features = ["rustls-tls", "blocking"] }
 rustc-hash = "2.0.0"
-selectors = "0.25.0"
+selectors = "0.28.0"
 smallvec = "1"
 url = "2"
 

css-inline/src/html/document.rs

@@ -9,7 +9,7 @@ use super::{
 };
 use crate::{html::DocumentStyleMap, InlineError};
 use html5ever::local_name;
-use selectors::NthIndexCache;
+use selectors::context::SelectorCaches;
 use std::{fmt, fmt::Formatter, io::Write, iter::successors};
 
 /// HTML document representation.
@@ -297,7 +297,7 @@ impl Document {
     pub(crate) fn select<'a, 'b, 'c>(
         &'a self,
         selectors: &'b str,
-        caches: &'c mut NthIndexCache,
+        caches: &'c mut SelectorCaches,
     ) -> Result<Select<'a, 'c>, ParseError<'b>> {
         select(self, selectors, caches)
     }

css-inline/src/html/element.rs

@@ -7,8 +7,9 @@ use super::{
 use html5ever::{local_name, namespace_url, ns, Namespace, QualName};
 use selectors::{
     attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint},
-    context::QuirksMode,
-    matching, NthIndexCache, OpaqueElement,
+    bloom::BloomFilter,
+    context::{QuirksMode, SelectorCaches},
+    matching, OpaqueElement,
 };
 use std::cmp::Ordering;
 
@@ -92,14 +93,14 @@ impl<'a> Element<'a> {
             }
         }
     }
-    pub(crate) fn matches(&self, selector: &Selector, cache: &mut NthIndexCache) -> bool {
+    pub(crate) fn matches(&self, selector: &Selector, cache: &mut SelectorCaches) -> bool {
         let mut context = matching::MatchingContext::new(
             matching::MatchingMode::Normal,
             None,
             cache,
             QuirksMode::NoQuirks,
             matching::NeedsSelectorFlags::No,
-            matching::IgnoreNthChildForInvalidation::No,
+            matching::MatchingForInvalidation::No,
         );
         matching::matches_selector(selector, 0, None, self, &mut context)
     }
@@ -292,4 +293,10 @@ impl selectors::Element for Element<'_> {
     }
 
     fn apply_selector_flags(&self, _: matching::ElementSelectorFlags) {}
+    fn add_element_unique_hashes(&self, _: &mut BloomFilter) -> bool {
+        false
+    }
+    fn has_custom_state(&self, _name: &LocalName) -> bool {
+        false
+    }
 }

css-inline/src/html/iter.rs

@@ -5,14 +5,14 @@ use super::{
     selectors::{ParseError, Selectors},
     Specificity,
 };
-use selectors::NthIndexCache;
+use selectors::context::SelectorCaches;
 
 /// Compile selectors from a string and create an element iterator that yields elements matching these selectors.
 #[inline]
 pub(crate) fn select<'a, 'b, 'c>(
     document: &'a Document,
     selectors: &'b str,
-    caches: &'c mut NthIndexCache,
+    caches: &'c mut SelectorCaches,
 ) -> Result<Select<'a, 'c>, ParseError<'b>> {
     Selectors::compile(selectors).map(|selectors| Select {
         document,
@@ -25,7 +25,7 @@ pub(crate) fn select<'a, 'b, 'c>(
 /// An element iterator adaptor that yields elements matching given selectors.
 pub(crate) struct Select<'a, 'c> {
     document: &'a Document,
-    caches: &'c mut NthIndexCache,
+    caches: &'c mut SelectorCaches,
     iter: std::slice::Iter<'a, NodeId>,
     /// The selectors to be matched.
     selectors: Selectors,

css-inline/src/html/selectors/local_name.rs

@@ -1,4 +1,5 @@
 use cssparser::ToCss;
+use precomputed_hash::PrecomputedHash;
 use std::fmt::Write;
 
 /// `LocalName` type wraps `html5ever::LocalName` to extend it by implementing the `ToCss` trait,
@@ -37,3 +38,9 @@ impl ToCss for LocalName {
         dest.write_str(self.0.as_ref())
     }
 }
+
+impl PrecomputedHash for LocalName {
+    fn precomputed_hash(&self) -> u32 {
+        self.0.precomputed_hash()
+    }
+}

css-inline/src/html/selectors/mod.rs

@@ -49,7 +49,7 @@ impl Selectors {
     /// Compile a list of selectors.
     #[inline]
     pub(super) fn compile(selectors: &str) -> Result<Selectors, ParseError<'_>> {
-        parse(selectors).map(|list| Selectors(list.0))
+        parse(selectors).map(|list| Selectors(list.slice().into()))
     }
 
     /// Iterator over selectors.

css-inline/src/lib.rs

@@ -37,7 +37,7 @@ pub use error::InlineError;
 use indexmap::IndexMap;
 #[cfg(feature = "stylesheet-cache")]
 use lru::{DefaultHasher, LruCache};
-use selectors::NthIndexCache;
+use selectors::context::SelectorCaches;
 use std::{borrow::Cow, fmt::Formatter, hash::BuildHasherDefault, io::Write, sync::Arc};
 
 use crate::html::ElementStyleMap;
@@ -441,7 +441,7 @@ impl<'a> CSSInliner<'a> {
             rule_list.push(rule);
         }
         // This cache is unused but required in the `selectors` API
-        let mut caches = NthIndexCache::default();
+        let mut caches = SelectorCaches::default();
         for (selectors, (start, end)) in &rule_list {
             // Only CSS Syntax Level 3 is supported, therefore it is OK to split by `,`
             // With `is` or `where` selectors (Level 4) this split should be done on the parser level

css-inline/src/parser.rs

@@ -1,3 +1,5 @@
+use cssparser::ParserState;
+
 pub(crate) struct CSSRuleListParser<'d, 'i>(&'d mut Vec<Declaration<'i>>);
 
 impl<'d, 'i> CSSRuleListParser<'d, 'i> {
@@ -38,7 +40,7 @@ impl<'i> cssparser::QualifiedRuleParser<'i> for CSSRuleListParser<'_, 'i> {
     fn parse_block<'t>(
         &mut self,
         prelude: Self::Prelude,
-        _: &cssparser::ParserState,
+        _: &ParserState,
         input: &mut cssparser::Parser<'i, 't>,
     ) -> Result<Self::QualifiedRule, cssparser::ParseError<'i, Self::Error>> {
         // Parse list of declarations
@@ -61,6 +63,7 @@ impl<'i> cssparser::DeclarationParser<'i> for CSSDeclarationListParser {
         &mut self,
         name: Name<'i>,
         input: &mut cssparser::Parser<'i, 't>,
+        _declaration_start: &ParserState,
     ) -> Result<Self::Declaration, cssparser::ParseError<'i, Self::Error>> {
         Ok((name, exhaust(input)))
     }