chore: Update html5ever to 0.31

Signed-off-by: Dmitry Dygalo <dmitry@dygalo.dev>

Author: Stranger6667

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Changed
 
 - Update `cssparser` to `0.35`.
+- Update `html5ever` to `0.31`.
 - Update `selectors` to `0.28`.
 
 ## [0.14.5] - 2025-06-16

css-inline/Cargo.toml

@@ -30,7 +30,7 @@ stylesheet-cache = ["lru"]
 
 [dependencies]
 cssparser = "0.35.0"
-html5ever = "0.27.0"
+html5ever = "0.31.0"
 indexmap = "2.1"
 lru = { version = "0.14.0", optional = true }
 pico-args = { version = "0.3", optional = true }

css-inline/src/html/attributes.rs

@@ -1,4 +1,4 @@
-use html5ever::{local_name, namespace_url, ns, tendril::StrTendril, QualName};
+use html5ever::{local_name, ns, tendril::StrTendril, QualName};
 use rustc_hash::FxHasher;
 use selectors::attr::CaseSensitivity;
 use std::hash::{Hash, Hasher};

css-inline/src/html/document.rs

@@ -322,7 +322,7 @@ impl std::ops::IndexMut<NodeId> for Document {
 #[cfg(test)]
 mod tests {
     use super::{super::node::ElementData, *};
-    use html5ever::{local_name, namespace_url, ns, QualName};
+    use html5ever::{local_name, ns, QualName};
     use indexmap::IndexMap;
     use test_case::test_case;
 

css-inline/src/html/element.rs

@@ -4,7 +4,7 @@ use super::{
     node::{ElementData, NodeData, NodeId},
     selectors::{AttrValue, InlinerSelectors, LocalName, PseudoClass, PseudoElement, Selector},
 };
-use html5ever::{local_name, namespace_url, ns, Namespace, QualName};
+use html5ever::{local_name, ns, Namespace, QualName};
 use selectors::{
     attr::{AttrSelectorOperation, CaseSensitivity, NamespaceConstraint},
     bloom::BloomFilter,

css-inline/src/html/parser.rs

@@ -4,12 +4,15 @@ use super::{
     node::{ElementData, Node, NodeData, NodeId},
 };
 use html5ever::{
-    expanded_name, local_name, namespace_url, ns,
+    expanded_name, local_name, ns,
     tendril::{StrTendril, TendrilSink},
     tree_builder::{ElementFlags, NodeOrText, QuirksMode, TreeSink},
-    Attribute, ExpandedName, QualName,
+    Attribute, QualName,
+};
+use std::{
+    borrow::Cow,
+    cell::{Ref, RefCell},
 };
-use std::borrow::Cow;
 
 #[derive(Debug, Copy, Clone)]
 pub(crate) enum InliningMode {
@@ -26,7 +29,7 @@ pub(crate) fn parse_with_options(
     mode: InliningMode,
 ) -> Document {
     let sink = Sink {
-        document: Document::with_capacity(preallocate_node_capacity),
+        document: RefCell::new(Document::with_capacity(preallocate_node_capacity)),
     };
     let options = html5ever::ParseOpts::default();
     match mode {
@@ -61,17 +64,17 @@ pub(crate) fn parse_with_options(
 /// It takes care of creating and appending nodes to the document as the parsing progresses.
 struct Sink {
     /// An HTML document that is being parsed.
-    document: Document,
+    document: RefCell<Document>,
 }
 
 impl Sink {
     /// Push a new node into the document.
-    fn push_node(&mut self, data: NodeData) -> NodeId {
-        self.document.push_node(data)
+    fn push_node(&self, data: NodeData) -> NodeId {
+        self.document.borrow_mut().push_node(data)
     }
 
     fn push_element(
-        &mut self,
+        &self,
         name: QualName,
         attributes: Vec<Attribute>,
         inlining_ignored: bool,
@@ -80,28 +83,28 @@ impl Sink {
             element: ElementData::new(name, attributes),
             inlining_ignored,
         });
-        self.document.push_element_id(node_id);
+        self.document.borrow_mut().push_element_id(node_id);
         node_id
     }
 
-    fn push_text(&mut self, text: StrTendril) -> NodeId {
+    fn push_text(&self, text: StrTendril) -> NodeId {
         self.push_node(NodeData::Text { text })
     }
 
-    fn push_comment(&mut self, text: StrTendril) -> NodeId {
+    fn push_comment(&self, text: StrTendril) -> NodeId {
         self.push_node(NodeData::Comment { text })
     }
 
-    fn push_processing_instruction(&mut self, target: StrTendril, data: StrTendril) -> NodeId {
+    fn push_processing_instruction(&self, target: StrTendril, data: StrTendril) -> NodeId {
         self.push_node(NodeData::ProcessingInstruction { target, data })
     }
 
-    fn push_doctype(&mut self, name: StrTendril) -> NodeId {
+    fn push_doctype(&self, name: StrTendril) -> NodeId {
         self.push_node(NodeData::Doctype { name })
     }
 
     /// Append a new node or text to the document.
-    fn append_impl<P, A>(&mut self, child: NodeOrText<NodeId>, previous: P, append: A)
+    fn append_impl<P, A>(&self, child: NodeOrText<NodeId>, previous: P, append: A)
     where
         P: FnOnce(&mut Document) -> Option<NodeId>,
         A: FnOnce(&mut Document, NodeId),
@@ -110,50 +113,55 @@ impl Sink {
             NodeOrText::AppendText(text) => {
                 // If the previous node is a text node, append to it.
                 // Otherwise create a new text node.
-                if let Some(id) = previous(&mut self.document) {
-                    if let Node {
-                        data: NodeData::Text { text: existing },
-                        ..
-                    } = &mut self.document[id]
-                    {
-                        existing.push_tendril(&text);
-                        return;
-                    }
+                let Some(id) = previous(&mut self.document.borrow_mut()) else {
+                    let new_node = self.push_text(text);
+                    append(&mut self.document.borrow_mut(), new_node);
+                    return;
+                };
+                if let Node {
+                    data: NodeData::Text { text: existing },
+                    ..
+                } = &mut self.document.borrow_mut()[id]
+                {
+                    existing.push_tendril(&text);
+                    return;
                 }
                 self.push_text(text)
             }
             NodeOrText::AppendNode(node) => node,
         };
 
-        append(&mut self.document, new_node);
+        append(&mut self.document.borrow_mut(), new_node);
     }
 }
 
 impl TreeSink for Sink {
     type Handle = NodeId;
     type Output = Document;
+    type ElemName<'a>
+        = Ref<'a, QualName>
+    where
+        Self: 'a;
 
     fn finish(self) -> Document {
-        self.document
+        self.document.into_inner()
     }
 
-    fn parse_error(&mut self, _msg: Cow<'static, str>) {}
+    fn parse_error(&self, _msg: Cow<'static, str>) {}
 
-    fn get_document(&mut self) -> NodeId {
+    fn get_document(&self) -> NodeId {
         NodeId::document_id()
     }
 
-    fn elem_name<'a>(&'a self, &target: &'a NodeId) -> ExpandedName<'a> {
-        self.document[target]
-            .as_element()
-            // The `TreeSink` trait promises to never call this method on non-element node
-            .expect("Not an element")
-            .name
-            .expanded()
+    fn elem_name<'a>(&'a self, target: &NodeId) -> Self::ElemName<'a> {
+        let document = self.document.borrow();
+        let node = Ref::map(document, |document| &document[*target]);
+        let element = Ref::map(node, |node| node.as_element().expect("Not an element"));
+        Ref::map(element, |element| &element.name)
     }
 
     fn create_element(
-        &mut self,
+        &self,
         name: QualName,
         attrs: Vec<Attribute>,
         _flags: ElementFlags,
@@ -191,24 +199,24 @@ impl TreeSink for Sink {
         let element = self.push_element(name, attrs, inlining_ignored);
         // Collect `style` tags and linked stylesheets separately to use them for CSS inlining later.
         if is_style {
-            self.document.add_style(element);
+            self.document.borrow_mut().add_style(element);
         }
         if is_stylesheet {
-            self.document.add_linked_stylesheet(element);
+            self.document.borrow_mut().add_linked_stylesheet(element);
         }
         element
     }
 
-    fn create_comment(&mut self, text: StrTendril) -> NodeId {
+    fn create_comment(&self, text: StrTendril) -> NodeId {
         self.push_comment(text)
     }
 
-    fn create_pi(&mut self, target: StrTendril, data: StrTendril) -> NodeId {
+    fn create_pi(&self, target: StrTendril, data: StrTendril) -> NodeId {
         self.push_processing_instruction(target, data)
     }
 
     /// Append a node as the last child of the given node.
-    fn append(&mut self, &parent: &NodeId, child: NodeOrText<NodeId>) {
+    fn append(&self, &parent: &NodeId, child: NodeOrText<NodeId>) {
         self.append_impl(
             child,
             |document| document[parent].last_child,
@@ -217,12 +225,12 @@ impl TreeSink for Sink {
     }
 
     fn append_based_on_parent_node(
-        &mut self,
+        &self,
         element: &NodeId,
         prev_element: &NodeId,
         child: NodeOrText<NodeId>,
     ) {
-        if self.document[*element].parent.is_some() {
+        if self.document.borrow()[*element].parent.is_some() {
             self.append_before_sibling(element, child);
         } else {
             self.append(prev_element, child);
@@ -231,16 +239,18 @@ impl TreeSink for Sink {
 
     /// Append a `DOCTYPE` element to the `Document` node.
     fn append_doctype_to_document(
-        &mut self,
+        &self,
         name: StrTendril,
         _public_id: StrTendril,
         _system_id: StrTendril,
     ) {
         let node = self.push_doctype(name);
-        self.document.append(NodeId::document_id(), node);
+        self.document
+            .borrow_mut()
+            .append(NodeId::document_id(), node);
     }
 
-    fn get_template_contents(&mut self, &target: &NodeId) -> NodeId {
+    fn get_template_contents(&self, &target: &NodeId) -> NodeId {
         target
     }
 
@@ -249,10 +259,10 @@ impl TreeSink for Sink {
         x == y
     }
 
-    fn set_quirks_mode(&mut self, _mode: QuirksMode) {}
+    fn set_quirks_mode(&self, _mode: QuirksMode) {}
 
     /// Append a node as the sibling immediately before the given node.
-    fn append_before_sibling(&mut self, &sibling: &NodeId, child: NodeOrText<NodeId>) {
+    fn append_before_sibling(&self, &sibling: &NodeId, child: NodeOrText<NodeId>) {
         self.append_impl(
             child,
             |document| document[sibling].previous_sibling,
@@ -261,10 +271,9 @@ impl TreeSink for Sink {
     }
 
     /// Add each attribute to the given element, if no attribute with that name already exists.
-    fn add_attrs_if_missing(&mut self, &target: &NodeId, attrs: Vec<Attribute>) {
-        let element = self.document[target]
-            .as_element_mut()
-            .expect("not an element");
+    fn add_attrs_if_missing(&self, &target: &NodeId, attrs: Vec<Attribute>) {
+        let mut document = self.document.borrow_mut();
+        let element = document[target].as_element_mut().expect("not an element");
         let attributes = &mut element.attributes;
         for attr in attrs {
             if attributes
@@ -278,12 +287,14 @@ impl TreeSink for Sink {
     }
 
     /// Detach the given node from its parent.
-    fn remove_from_parent(&mut self, &target: &NodeId) {
-        self.document.detach(target);
+    fn remove_from_parent(&self, &target: &NodeId) {
+        self.document.borrow_mut().detach(target);
     }
 
     /// Remove all the children from node and append them to `new_parent`.
-    fn reparent_children(&mut self, node: &NodeId, new_parent: &NodeId) {
-        self.document.reparent_children(*node, *new_parent);
+    fn reparent_children(&self, node: &NodeId, new_parent: &NodeId) {
+        self.document
+            .borrow_mut()
+            .reparent_children(*node, *new_parent);
     }
 }

css-inline/src/html/serializer.rs

@@ -5,7 +5,7 @@ use super::{
     DocumentStyleMap, InliningMode,
 };
 use crate::{html::ElementStyleMap, parser, InlineError};
-use html5ever::{local_name, namespace_url, ns, tendril::StrTendril, LocalName, QualName};
+use html5ever::{local_name, ns, tendril::StrTendril, LocalName, QualName};
 use smallvec::{smallvec, SmallVec};
 use std::io::Write;