rusteerio 1.0.1 → 1.1.1

package/dist/slim.d.mts

@@ -1,6 +1,6 @@
 export { contains, dom, merge } from './index.mjs';
-import { L as LoadContent, C as CheerioOptions, a as CheerioAPI } from './types-BP6TpxE5.mjs';
-export { A as AcceptedElems, b as AcceptedFilters, c as AnyNode, B as BasicAcceptedElems, d as CDATA, type e as Cheerio, f as CheerioRequestOptions, g as ChildNode, h as Comment, D as DataNode, i as DecodeStreamOptions, j as Document, k as DocumentMode, E as Element, type l as ElementType, m as EncodingOptions, n as ExtractDescriptor, o as ExtractMap, p as ExtractedMap, q as ExtractedValue, r as ExtractionDescriptor, s as ExtractionMap, t as ExtractionResult, F as FilterFunction, u as FormDataLike, H as HTMLParser2Options, I as InternalOptions, N as NamespaceURI, v as Node, w as NodeWithChildren, P as ParallelOptions, x as ParentNode, y as ParserError, z as ParserErrorCode, G as ParserErrorHandler, J as ProcessingInstruction, S as SelectorType, K as SerializedField, M as SourceCodeLocation, T as TagSourceCodeLocation, O as Text, Q as Tokenizer, R as TokenizerCallbacks, U as TokenizerConstructor, V as TokenizerOptions, W as TreeAdapter, X as TreeAdapterAttribute } from './types-BP6TpxE5.mjs';
+import { L as LoadContent, C as CheerioOptions, a as CheerioAPI } from './types-Cs9UP1Vv.mjs';
+export { A as AcceptedElems, b as AcceptedFilters, c as AnyNode, B as BasicAcceptedElems, d as CDATA, type e as Cheerio, f as CheerioRequestOptions, g as ChildNode, h as Comment, D as DataNode, i as DecodeStreamOptions, j as Document, k as DocumentMode, E as Element, type l as ElementType, m as EncodingOptions, n as ExtractDescriptor, o as ExtractMap, p as ExtractedMap, q as ExtractedValue, r as ExtractionDescriptor, s as ExtractionMap, t as ExtractionResult, F as FilterFunction, u as FormDataLike, H as HTMLParser2Options, I as InternalOptions, N as NamespaceURI, v as Node, w as NodeWithChildren, P as ParallelOptions, x as ParentNode, y as ParserError, z as ParserErrorCode, G as ParserErrorHandler, J as ProcessingInstruction, S as SelectorType, K as SerializedField, M as SourceCodeLocation, T as TagSourceCodeLocation, O as Text, Q as Tokenizer, R as TokenizerCallbacks, U as TokenizerConstructor, V as TokenizerOptions, W as TreeAdapter, X as TreeAdapterAttribute } from './types-Cs9UP1Vv.mjs';
 import 'node:stream';
 import 'node:querystring';
 import 'node:buffer';

package/dist/slim.d.ts

@@ -1,6 +1,6 @@
 export { contains, dom, merge } from './index.js';
-import { L as LoadContent, C as CheerioOptions, a as CheerioAPI } from './types-BP6TpxE5.js';
-export { A as AcceptedElems, b as AcceptedFilters, c as AnyNode, B as BasicAcceptedElems, d as CDATA, type e as Cheerio, f as CheerioRequestOptions, g as ChildNode, h as Comment, D as DataNode, i as DecodeStreamOptions, j as Document, k as DocumentMode, E as Element, type l as ElementType, m as EncodingOptions, n as ExtractDescriptor, o as ExtractMap, p as ExtractedMap, q as ExtractedValue, r as ExtractionDescriptor, s as ExtractionMap, t as ExtractionResult, F as FilterFunction, u as FormDataLike, H as HTMLParser2Options, I as InternalOptions, N as NamespaceURI, v as Node, w as NodeWithChildren, P as ParallelOptions, x as ParentNode, y as ParserError, z as ParserErrorCode, G as ParserErrorHandler, J as ProcessingInstruction, S as SelectorType, K as SerializedField, M as SourceCodeLocation, T as TagSourceCodeLocation, O as Text, Q as Tokenizer, R as TokenizerCallbacks, U as TokenizerConstructor, V as TokenizerOptions, W as TreeAdapter, X as TreeAdapterAttribute } from './types-BP6TpxE5.js';
+import { L as LoadContent, C as CheerioOptions, a as CheerioAPI } from './types-Cs9UP1Vv.js';
+export { A as AcceptedElems, b as AcceptedFilters, c as AnyNode, B as BasicAcceptedElems, d as CDATA, type e as Cheerio, f as CheerioRequestOptions, g as ChildNode, h as Comment, D as DataNode, i as DecodeStreamOptions, j as Document, k as DocumentMode, E as Element, type l as ElementType, m as EncodingOptions, n as ExtractDescriptor, o as ExtractMap, p as ExtractedMap, q as ExtractedValue, r as ExtractionDescriptor, s as ExtractionMap, t as ExtractionResult, F as FilterFunction, u as FormDataLike, H as HTMLParser2Options, I as InternalOptions, N as NamespaceURI, v as Node, w as NodeWithChildren, P as ParallelOptions, x as ParentNode, y as ParserError, z as ParserErrorCode, G as ParserErrorHandler, J as ProcessingInstruction, S as SelectorType, K as SerializedField, M as SourceCodeLocation, T as TagSourceCodeLocation, O as Text, Q as Tokenizer, R as TokenizerCallbacks, U as TokenizerConstructor, V as TokenizerOptions, W as TreeAdapter, X as TreeAdapterAttribute } from './types-Cs9UP1Vv.js';
 import 'node:stream';
 import 'node:querystring';
 import 'node:buffer';

package/dist/slim.mjs

@@ -3,7 +3,7 @@ import {
   dom,
   load,
   merge
-} from "./chunk-DMRD3FGC.mjs";
+} from "./chunk-FPRP6UIX.mjs";
 import "./chunk-OHPGEY3E.mjs";
 
 // src/slim.ts

package/dist/{types-BP6TpxE5.d.mts → types-Cs9UP1Vv.d.mts}

@@ -69,14 +69,14 @@ interface AttributeMethods<T = AnyNode> {
     serialize<U extends AnyNode>(this: Cheerio<U>): string;
 }
 
-/** An array-like selection of stable handles into the Rust document arena. */
+/** An array-like selection of native nodes. */
 declare class Cheerio<T = AnyNode> implements ArrayLike<T>, Iterable<T> {
     [index: number]: T;
+    length: number;
     options: CheerioOptions;
     _root: Cheerio<Document> | null;
     prevObject: Cheerio<any> | undefined;
-    length: number;
-    cheerio: "[cheerio object]";
+    cheerio: '[cheerio object]';
     constructor(api: CheerioAPI, document: NativeDocument, ids?: number[], root?: Cheerio<Document> | null, options?: CheerioOptions, values?: T[]);
     _make<R>(value: ArrayLike<R> | R | string, context?: BasicAcceptedElems<AnyNode>): Cheerio<R>;
     _parse(content: any, options: CheerioOptions, isDocument: boolean, context: ParentNode | null): Document;

package/dist/{types-BP6TpxE5.d.ts → types-Cs9UP1Vv.d.ts}

@@ -69,14 +69,14 @@ interface AttributeMethods<T = AnyNode> {
     serialize<U extends AnyNode>(this: Cheerio<U>): string;
 }
 
-/** An array-like selection of stable handles into the Rust document arena. */
+/** An array-like selection of native nodes. */
 declare class Cheerio<T = AnyNode> implements ArrayLike<T>, Iterable<T> {
     [index: number]: T;
+    length: number;
     options: CheerioOptions;
     _root: Cheerio<Document> | null;
     prevObject: Cheerio<any> | undefined;
-    length: number;
-    cheerio: "[cheerio object]";
+    cheerio: '[cheerio object]';
     constructor(api: CheerioAPI, document: NativeDocument, ids?: number[], root?: Cheerio<Document> | null, options?: CheerioOptions, values?: T[]);
     _make<R>(value: ArrayLike<R> | R | string, context?: BasicAcceptedElems<AnyNode>): Cheerio<R>;
     _parse(content: any, options: CheerioOptions, isDocument: boolean, context: ParentNode | null): Document;

package/dist/utils.d.mts

@@ -1,4 +1,4 @@
-import { e as Cheerio, c as AnyNode, E as Element } from './types-BP6TpxE5.mjs';
+import { e as Cheerio, c as AnyNode, E as Element } from './types-Cs9UP1Vv.mjs';
 import 'node:querystring';
 import 'node:stream';
 import 'node:buffer';

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { e as Cheerio, c as AnyNode, E as Element } from './types-BP6TpxE5.js';
+import { e as Cheerio, c as AnyNode, E as Element } from './types-Cs9UP1Vv.js';
 import 'node:querystring';
 import 'node:stream';
 import 'node:buffer';

package/native/src/arena.rs

@@ -1,4 +1,5 @@
 //! Mutable, stable-ID DOM storage. All mutations stay on the native side.
+use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 
 use napi::{Error, Result, Status};
@@ -10,7 +11,7 @@ pub(crate) struct DomNode {
     #[serde(default)]
     pub id: u32,
     #[serde(rename = "type", default = "root_kind")]
-    pub kind: String,
+    pub kind: Cow<'static, str>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
@@ -25,16 +26,65 @@ pub(crate) struct DomNode {
     pub prev: Option<u32>,
     #[serde(default)]
     pub next: Option<u32>,
+    /// Element namespace; borrowed for the namespaces HTML parsing produces.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub namespace: Option<Cow<'static, str>>,
+    /// parse5's per-attribute namespace and prefix maps, when the node has them.
+    #[serde(
+        rename = "attribsNamespace",
+        default,
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub attribs_namespace: Option<Box<Map<String, Value>>>,
+    #[serde(
+        rename = "attribsPrefix",
+        default,
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub attribs_prefix: Option<Box<Map<String, Value>>>,
     #[serde(flatten)]
     pub extras: Map<String, Value>,
 }
 
-fn root_kind() -> String {
-    "root".into()
+fn root_kind() -> Cow<'static, str> {
+    Cow::Borrowed("root")
+}
+
+pub(crate) const HTML_NAMESPACE: &str = "http://www.w3.org/1999/xhtml";
+
+/// A namespace, borrowed for the ones HTML parsing produces.
+pub(crate) fn namespace_name(namespace: &str) -> Cow<'static, str> {
+    match namespace {
+        HTML_NAMESPACE => Cow::Borrowed(HTML_NAMESPACE),
+        "http://www.w3.org/2000/svg" => Cow::Borrowed("http://www.w3.org/2000/svg"),
+        "http://www.w3.org/1998/Math/MathML" => Cow::Borrowed("http://www.w3.org/1998/Math/MathML"),
+        "http://www.w3.org/1999/xlink" => Cow::Borrowed("http://www.w3.org/1999/xlink"),
+        "http://www.w3.org/XML/1998/namespace" => {
+            Cow::Borrowed("http://www.w3.org/XML/1998/namespace")
+        }
+        "http://www.w3.org/2000/xmlns/" => Cow::Borrowed("http://www.w3.org/2000/xmlns/"),
+        other => Cow::Owned(other.to_owned()),
+    }
+}
+
+/// A node type, borrowed for the types the DOM defines.
+pub(crate) fn node_kind(kind: &str) -> Cow<'static, str> {
+    match kind {
+        "tag" => Cow::Borrowed("tag"),
+        "text" => Cow::Borrowed("text"),
+        "root" => Cow::Borrowed("root"),
+        "script" => Cow::Borrowed("script"),
+        "style" => Cow::Borrowed("style"),
+        "comment" => Cow::Borrowed("comment"),
+        "directive" => Cow::Borrowed("directive"),
+        "cdata" => Cow::Borrowed("cdata"),
+        "doctype" => Cow::Borrowed("doctype"),
+        other => Cow::Owned(other.to_owned()),
+    }
 }
 
 impl DomNode {
-    pub(crate) fn new(kind: &str) -> Self {
+    pub(crate) fn new(kind: impl Into<Cow<'static, str>>) -> Self {
         Self {
             id: 0,
             kind: kind.into(),
@@ -45,11 +95,14 @@ impl DomNode {
             parent: None,
             prev: None,
             next: None,
+            namespace: None,
+            attribs_namespace: None,
+            attribs_prefix: None,
             extras: Map::new(),
         }
     }
     pub(crate) fn is_element(&self) -> bool {
-        matches!(self.kind.as_str(), "tag" | "script" | "style")
+        matches!(self.kind.as_ref(), "tag" | "script" | "style")
     }
     pub(crate) fn content_bytes(&self) -> usize {
         let attributes: usize = self
@@ -67,25 +120,106 @@ pub(crate) struct DomArena {
     pub nodes: Vec<DomNode>,
     pub options: Value,
     pub free: Vec<u32>,
+    /// Parents whose child lists changed since JavaScript last asked, so it
+    /// can refresh the child arrays it holds without rereading every node.
+    pub touched: Vec<u32>,
+    /// Too many changes were recorded to list; every parent counts as touched.
+    pub touched_overflow: bool,
+    /// Whether parsing records start and end indices, read once per parse.
+    pub parse_indices: Option<(bool, bool)>,
+    /// Nodes removed from a parent since the last collection.
+    pub detached_since_collection: u32,
+    /// Live nodes after the last collection, or when the arena was built.
+    pub collected_live: u32,
+    /// Elements by ASCII-lowercased name, in document order, as parsing
+    /// created them; dropped before any write, which may reorder ids.
+    pub name_index: Option<NameIndex>,
 }
 
+pub(crate) type NameIndex = crate::id_hash::IdMap<String, Vec<u32>>;
+
+const TOUCHED_LIMIT: usize = 1 << 16;
+
 impl DomArena {
+    /// An arena over records whose ids and links are already consistent, as
+    /// a parse tree's conversion produces them.
+    pub(crate) fn from_linked_records(nodes: Vec<DomNode>, options: Value) -> Self {
+        let slots = nodes.len() as u32;
+        Self {
+            nodes,
+            options,
+            free: Vec::new(),
+            touched: Vec::new(),
+            touched_overflow: false,
+            parse_indices: None,
+            detached_since_collection: 0,
+            collected_live: slots,
+            name_index: None,
+        }
+    }
     pub(crate) fn from_records(mut nodes: Vec<DomNode>, options: Value) -> Self {
         for (id, node) in nodes.iter_mut().enumerate() {
             node.id = id as u32;
-            node.extras.entry("startIndex").or_insert(Value::Null);
-            node.extras.entry("endIndex").or_insert(Value::Null);
         }
+        let slots = nodes.len() as u32;
         let mut arena = Self {
             nodes,
             options,
             free: Vec::new(),
+            touched: Vec::new(),
+            touched_overflow: false,
+            parse_indices: None,
+            detached_since_collection: 0,
+            collected_live: slots,
+            name_index: None,
         };
         for id in 0..arena.nodes.len() {
             arena.relink(id as u32);
         }
+        arena.take_touched();
         arena
     }
+    pub(crate) fn touch(&mut self, parent: u32) {
+        if self.touched_overflow {
+            return;
+        }
+        if self.touched.len() >= TOUCHED_LIMIT {
+            self.touched = Vec::new();
+            self.touched_overflow = true;
+        } else {
+            self.touched.push(parent);
+        }
+    }
+    /// The parents touched since the last call, or `None` when too many were.
+    pub(crate) fn take_touched(&mut self) -> Option<Vec<u32>> {
+        let touched = std::mem::take(&mut self.touched);
+        let overflow = std::mem::replace(&mut self.touched_overflow, false);
+        (!overflow).then_some(touched)
+    }
+    fn note_detached(&mut self) {
+        self.detached_since_collection = self.detached_since_collection.saturating_add(1);
+    }
+    /// Every live node that `root` does not reach through child links.
+    pub(crate) fn detached_slots(&self, root: u32) -> Vec<u32> {
+        let mut attached = vec![false; self.nodes.len()];
+        let mut stack = vec![root];
+        while let Some(id) = stack.pop() {
+            let Some(node) = self.node(id) else { continue };
+            if std::mem::replace(&mut attached[id as usize], true) {
+                continue;
+            }
+            stack.extend(node.children.iter().copied());
+        }
+        (0..self.nodes.len() as u32)
+            .filter(|id| !attached[*id as usize] && self.node(*id).is_some())
+            .collect()
+    }
+    /// Whether removed nodes may have left enough garbage to collect: the
+    /// live slots have grown by half since the last collection.
+    pub(crate) fn is_collection_due(&self) -> bool {
+        let live = self.nodes.len().saturating_sub(self.free.len()) as u64;
+        self.detached_since_collection > 0 && live >= u64::from(self.collected_live) * 3 / 2 + 256
+    }
     pub(crate) fn node(&self, id: u32) -> Option<&DomNode> {
         self.nodes
             .get(id as usize)
@@ -124,7 +258,7 @@ impl DomArena {
                                 .insert(name.into(), Value::String(value.into()));
                         }
                         None => {
-                            node.attribs.remove(name);
+                            node.attribs.shift_remove(name);
                         }
                     }
                 }
@@ -132,6 +266,7 @@ impl DomArena {
         }
     }
     pub(crate) fn relink(&mut self, parent: u32) {
+        self.touch(parent);
         let children = self
             .nodes
             .get(parent as usize)
@@ -150,6 +285,7 @@ impl DomArena {
     }
     pub(crate) fn detach(&mut self, id: u32) {
         if let Some(parent) = self.node(id).and_then(|node| node.parent) {
+            self.note_detached();
             if let Some(node) = self.nodes.get_mut(parent as usize) {
                 node.children.retain(|child| *child != id);
             }
@@ -169,6 +305,11 @@ impl DomArena {
             return;
         }
         let removed: HashSet<_> = ids.iter().copied().collect();
+        for id in ids {
+            if self.node(*id).is_some_and(|node| node.parent.is_some()) {
+                self.note_detached();
+            }
+        }
         let parents: HashSet<_> = ids
             .iter()
             .filter_map(|id| self.node(*id).and_then(|node| node.parent))
@@ -270,6 +411,7 @@ impl DomArena {
                     index += 1;
                 }
                 self.nodes[id as usize].children = children;
+                self.touch(id);
             }
         }
         self.inner_html(id)
@@ -280,8 +422,12 @@ impl DomArena {
     pub(crate) fn serialize(&self, ids: &[u32], options: &Value) -> String {
         let mut output = String::new();
         let xml = xml_mode(options);
-        let encode = options.get("decodeEntities") != Some(&Value::Bool(false))
-            && options.get("encodeEntities") != Some(&Value::Bool(false));
+        // Cheerio serializes HTML with parse5, which always escapes; only the
+        // htmlparser2 serializer leaves entities alone when asked to.
+        let is_parse5 = !xml && options.get("_useHtmlParser2") != Some(&Value::Bool(true));
+        let encode = is_parse5
+            || (options.get("decodeEntities") != Some(&Value::Bool(false))
+                && options.get("encodeEntities") != Some(&Value::Bool(false)));
         let mut stack: Vec<(u32, bool)> = ids.iter().rev().map(|id| (*id, false)).collect();
         let mut budget = self.nodes.len().saturating_mul(8).saturating_add(1024);
         while let Some((id, close)) = stack.pop() {
@@ -298,7 +444,7 @@ impl DomArena {
                 output.push('>');
                 continue;
             }
-            match node.kind.as_str() {
+            match node.kind.as_ref() {
                 "root" => stack.extend(node.children.iter().rev().map(|id| (*id, false))),
                 "text" => {
                     let raw = !xml
@@ -366,12 +512,10 @@ impl DomArena {
                     // rendering write the stored attribute names unchanged.
                     let qualifiers = (!xml
                         && options.get("_useHtmlParser2") != Some(&Value::Bool(true)))
-                    .then(|| {
-                        (
-                            node.extras.get("attribsNamespace"),
-                            node.extras.get("attribsPrefix"),
-                        )
-                    });
+                    .then_some((
+                        node.attribs_namespace.as_deref(),
+                        node.attribs_prefix.as_deref(),
+                    ));
                     let attributes = super::js_property_order(
                         node.attribs
                             .iter()
@@ -420,9 +564,8 @@ impl DomArena {
                     }
                     let is_void = !xml
                         && (node
-                            .extras
-                            .get("namespace")
-                            .and_then(Value::as_str)
+                            .namespace
+                            .as_deref()
                             .is_none_or(|namespace| namespace == super::HTML_NS))
                         && super::void_name(name);
                     if xml
@@ -534,28 +677,44 @@ impl DomArena {
         roots
     }
     pub(crate) fn create_fragment(&mut self, html: &str, context: Option<u32>) -> Result<Vec<u32>> {
-        let context_name = context
-            .and_then(|id| self.node(id))
-            .and_then(|node| node.name.clone());
+        let parsed = self.parse_fragment(html, context)?;
+        let roots = parsed.nodes[0].children.clone();
+        Ok(self.import_internal(&parsed.nodes, &roots, false))
+    }
+    /// Parses `html` as the children of `context`; only the context's name
+    /// and namespace affect the result.
+    fn parse_fragment(&self, html: &str, context: Option<u32>) -> Result<DomArena> {
+        let (context_name, namespace) = self.fragment_context(context);
         let mut options = self.options.clone();
-        if let Some(namespace) = context
-            .and_then(|id| self.node(id))
-            .and_then(|node| node.extras.get("namespace"))
-            .cloned()
-        {
-            options["__contextNamespace"] = namespace;
+        if let Some(namespace) = namespace {
+            options["__contextNamespace"] = Value::String(namespace);
         }
         let document =
             super::NativeDocument::parse_options(html, false, options, context_name.as_deref());
         document.ensure_arena()?;
-        let arena = document.arena.borrow();
-        let parsed = arena.as_ref().unwrap();
-        let roots = parsed.nodes[0].children.clone();
-        Ok(self.import_internal(&parsed.nodes, &roots, false))
+        let parsed = document.arena.borrow_mut().take().unwrap();
+        Ok(parsed)
+    }
+    fn fragment_context(&self, context: Option<u32>) -> (Option<String>, Option<String>) {
+        let node = context.and_then(|id| self.node(id));
+        (
+            node.and_then(|node| node.name.clone()),
+            node.and_then(|node| node.namespace.as_deref().map(str::to_owned)),
+        )
     }
     pub(crate) fn set_html(&mut self, ids: &[u32], html: &str) -> Result<()> {
+        // Each target receives its own copy; targets of the same element type
+        // share one parse, since the result depends only on that context.
+        let mut parsed: HashMap<(Option<String>, Option<String>), DomArena> = HashMap::new();
         for id in ids {
-            let children = self.create_fragment(html, Some(*id))?;
+            let key = self.fragment_context(Some(*id));
+            if !parsed.contains_key(&key) {
+                let fragment = self.parse_fragment(html, Some(*id))?;
+                parsed.insert(key.clone(), fragment);
+            }
+            let fragment = &parsed[&key];
+            let roots = fragment.nodes[0].children.clone();
+            let children = self.import_internal(&fragment.nodes, &roots, false);
             self.set_children(*id, &children);
         }
         Ok(())
@@ -725,11 +884,18 @@ impl DomArena {
         match field {
             "name" | "tagName" => node.name = value.as_str().map(str::to_owned),
             "data" | "nodeValue" => node.data = value.as_str().map(str::to_owned),
-            "type" => node.kind = value.as_str().unwrap_or("tag").into(),
+            "type" => node.kind = node_kind(value.as_str().unwrap_or("tag")),
             "attribs" => node.attribs = value.as_object().cloned().unwrap_or_default(),
             "parent" => node.parent = value.as_u64().map(|id| id as u32),
             "prev" => node.prev = value.as_u64().map(|id| id as u32),
             "next" => node.next = value.as_u64().map(|id| id as u32),
+            "namespace" => node.namespace = value.as_str().map(namespace_name),
+            "attribsNamespace" | "x-attribsNamespace" => {
+                node.attribs_namespace = value.as_object().cloned().map(Box::new)
+            }
+            "attribsPrefix" | "x-attribsPrefix" => {
+                node.attribs_prefix = value.as_object().cloned().map(Box::new)
+            }
             _ => {
                 if value.is_null() {
                     node.extras.remove(field);
@@ -744,7 +910,7 @@ impl DomArena {
 
 impl super::selector::SelectDom for DomArena {
     fn kind(&self, id: u32) -> &str {
-        self.node(id).map_or("", |node| node.kind.as_str())
+        self.node(id).map_or("", |node| node.kind.as_ref())
     }
     fn name(&self, id: u32) -> Option<&str> {
         self.node(id)?.name.as_deref()
@@ -787,6 +953,13 @@ impl super::selector::SelectDom for DomArena {
     fn pseudo_alias(&self, name: &str) -> Option<&str> {
         self.options.get("pseudos")?.get(name)?.as_str()
     }
+    fn elements_named(&self, lowercase_name: &str) -> Option<&[u32]> {
+        let index = self.name_index.as_ref()?;
+        Some(index.get(lowercase_name).map_or(&[], Vec::as_slice))
+    }
+    fn is_id_order_document_order(&self) -> bool {
+        self.name_index.is_some()
+    }
 }
 
 pub(crate) fn value_ids(value: &Value) -> Vec<u32> {
@@ -916,6 +1089,12 @@ pub(crate) fn append_parsed(
     start: usize,
     end: usize,
 ) -> u32 {
+    let (start_indices, end_indices) = *arena.parse_indices.get_or_insert_with(|| {
+        (
+            arena.options.get("withStartIndices") == Some(&Value::Bool(true)),
+            arena.options.get("withEndIndices") == Some(&Value::Bool(true)),
+        )
+    });
     if node.kind == "text" {
         if let Some(previous) = arena.nodes[parent as usize]
             .children
@@ -927,7 +1106,7 @@ pub(crate) fn append_parsed(
                 .data
                 .get_or_insert_with(String::new)
                 .push_str(node.data.as_deref().unwrap_or(""));
-            if arena.options.get("withEndIndices") == Some(&Value::Bool(true)) {
+            if end_indices {
                 arena.nodes[previous as usize]
                     .extras
                     .insert("endIndex".into(), json!(end));
@@ -935,10 +1114,10 @@ pub(crate) fn append_parsed(
             return previous;
         }
     }
-    if arena.options.get("withStartIndices") == Some(&Value::Bool(true)) {
+    if start_indices {
         node.extras.insert("startIndex".into(), json!(start));
     }
-    if arena.options.get("withEndIndices") == Some(&Value::Bool(true)) {
+    if end_indices {
         node.extras.insert("endIndex".into(), json!(end));
     }
     let previous = arena.nodes[parent as usize].children.last().copied();
@@ -1224,47 +1403,7 @@ pub(crate) fn primitive(arena: &mut DomArena, command: &str, args: &Value) -> Re
             }
             Value::Null
         }
-        "uniqueSort" => {
-            let mut ids = ids;
-            let mut unique = HashSet::new();
-            ids.retain(|id| unique.insert(*id));
-            let ancestry = |id: u32| {
-                let mut path = vec![id];
-                let mut seen = HashSet::from([id]);
-                let mut parent = arena.node(id).and_then(|node| node.parent);
-                while let Some(id) = parent {
-                    if !seen.insert(id) {
-                        break;
-                    }
-                    path.push(id);
-                    parent = arena.node(id).and_then(|node| node.parent);
-                }
-                path.reverse();
-                path
-            };
-            let paths: HashMap<_, _> = ids.iter().map(|id| (*id, ancestry(*id))).collect();
-            ids.sort_by(|a, b| {
-                use std::cmp::Ordering;
-                let (a, b) = (&paths[a], &paths[b]);
-                if a.first() != b.first() {
-                    return Ordering::Equal;
-                }
-                for index in 0..a.len().min(b.len()) {
-                    if a[index] != b[index] {
-                        let siblings = arena
-                            .node(a[index - 1])
-                            .map(|node| node.children.as_slice())
-                            .unwrap_or(&[]);
-                        return siblings
-                            .iter()
-                            .position(|id| *id == a[index])
-                            .cmp(&siblings.iter().position(|id| *id == b[index]));
-                    }
-                }
-                a.len().cmp(&b.len())
-            });
-            json!(ids)
-        }
+        "uniqueSort" => json!(crate::document_order::unique_sort(&*arena, &ids)),
         "contains" => {
             let parent = args
                 .get("container")

package/native/src/attributes.rs

@@ -173,7 +173,7 @@ fn set_css(arena: &mut DomArena, ids: &[u32], name: &str, value: &Value) {
         }
         let mut properties = parse_css(arena.attr(*id, "style").unwrap_or(""));
         if value.as_str() == Some("") {
-            properties.remove(name);
+            properties.shift_remove(name);
         } else if !value.is_null() {
             properties.insert(name.into(), json!(js_string(value)));
         }
@@ -207,9 +207,15 @@ fn node_property(arena: &DomArena, id: u32, name: &str) -> bool {
             | "type"
             | "startIndex"
             | "endIndex"
-    ) || arena
-        .node(id)
-        .is_some_and(|node| node.extras.contains_key(name))
+    ) || arena.node(id).is_some_and(|node| {
+        node.extras.contains_key(name)
+            || match name {
+                "namespace" => node.namespace.is_some(),
+                "attribsNamespace" => node.attribs_namespace.is_some(),
+                "attribsPrefix" => node.attribs_prefix.is_some(),
+                _ => false,
+            }
+    })
 }
 
 fn get_prop(arena: &DomArena, id: u32, name: &str) -> napi::Result<Value> {
@@ -682,7 +688,7 @@ pub(crate) fn execute(
                         .and_then(|node| node.extras.get_mut("data"))
                         .and_then(Value::as_object_mut)
                     {
-                        data.remove(name);
+                        data.shift_remove(name);
                     }
                 }
             }