rusteerio 1.0.0 → 1.1.0

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,13 +512,16 @@ 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"),
-                        )
-                    });
-                    for (name, value) in &node.attribs {
+                    .then_some((
+                        node.attribs_namespace.as_deref(),
+                        node.attribs_prefix.as_deref(),
+                    ));
+                    let attributes = super::js_property_order(
+                        node.attribs
+                            .iter()
+                            .map(|(name, value)| (name.as_str(), value)),
+                    );
+                    for (name, value) in attributes {
                         output.push(' ');
                         match qualifiers {
                             Some((namespaces, prefixes)) => super::push_attribute_name(
@@ -415,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
@@ -529,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(())
@@ -720,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);
@@ -739,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()
@@ -782,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> {
@@ -880,481 +1058,30 @@ fn escape(value: &str, attribute: bool, xml: bool, utf8: bool, output: &mut Stri
 }
 
 pub(crate) fn parse_xml(source: &str, options: Value) -> DomArena {
-    let mut arena = DomArena::from_records(vec![DomNode::new("root")], options);
-    let mut parents = vec![0u32];
-    parse_xml_segment(source, &mut arena, &mut parents, 0);
-    arena
-}
-
-fn parse_xml_segment(source: &str, arena: &mut DomArena, parents: &mut Vec<u32>, base: usize) {
-    let xml = arena.xml_mode();
-    let indices = arena.options.get("withStartIndices") == Some(&Value::Bool(true))
-        || arena.options.get("withEndIndices") == Some(&Value::Bool(true));
-    let mut positions = if indices {
-        vec![0usize; source.len() + 1]
-    } else {
-        Vec::new()
-    };
-    let mut utf16 = 0;
-    let codec = arena.options.get("__utf16Codec") == Some(&Value::Bool(true));
-    let mut escaped = false;
-    if indices {
-        for (at, ch) in source.char_indices() {
-            for position in &mut positions[at..at + ch.len_utf8()] {
-                *position = utf16;
-            }
-            if codec && ch == crate::codec::ESCAPE && !escaped {
-                escaped = true;
-            } else {
-                utf16 += ch.len_utf16();
-                escaped = false;
-            }
-            positions[at + ch.len_utf8()] = utf16;
-        }
-    }
-    let source_position = |index: usize| {
-        base + if indices {
-            positions[index.min(source.len())]
-        } else {
-            index
-        }
-    };
-    macro_rules! append_parsed {
-        ($arena:expr,$parent:expr,$node:expr,$start:expr,$end:expr $(,)?) => {
-            append_parsed(
-                $arena,
-                $parent,
-                $node,
-                source_position($start),
-                source_position(($end).saturating_add(1)).saturating_sub(1),
-            )
-        };
-    }
-    let mut index = 0;
-    let bytes = source.as_bytes();
-    let decode = arena.options.get("decodeEntities") != Some(&Value::Bool(false));
-    while index < bytes.len() {
-        let start = index;
-        if !xml {
-            if let Some(name) = parents
-                .last()
-                .and_then(|id| arena.node(*id))
-                .and_then(|node| node.name.as_deref())
-                .filter(|name| matches!(*name, "script" | "style" | "xmp" | "textarea" | "title"))
-                .map(str::to_owned)
-            {
-                let closing = format!("</{name}");
-                let end = source.as_bytes()[index..]
-                    .windows(closing.len())
-                    .enumerate()
-                    .find(|(offset, candidate)| {
-                        candidate.eq_ignore_ascii_case(closing.as_bytes())
-                            && bytes
-                                .get(index + offset + closing.len())
-                                .is_none_or(|ch| *ch == b'>' || ch.is_ascii_whitespace())
-                    })
-                    .map_or(bytes.len(), |(offset, _)| index + offset);
-                if end > index {
-                    let text = &source[index..end];
-                    let mut node = DomNode::new("text");
-                    node.data = Some(if decode && name == "title" {
-                        decode_entities_mode(
-                            text,
-                            false,
-                            false,
-                            arena.options.get("__utf16Codec") == Some(&Value::Bool(true)),
-                        )
-                    } else {
-                        text.into()
-                    });
-                    append_parsed!(
-                        arena,
-                        *parents.last().unwrap(),
-                        node,
-                        index,
-                        end.saturating_sub(1),
-                    );
-                    index = end;
-                    continue;
-                }
-            }
-            if bytes[index] == b'<'
-                && bytes.get(index + 1).is_some_and(|ch| {
-                    !ch.is_ascii_alphabetic() && !matches!(*ch, b'!' | b'?' | b'/')
-                })
-            {
-                let mut node = DomNode::new("text");
-                node.data = Some("<".into());
-                append_parsed!(arena, *parents.last().unwrap(), node, index, index);
-                index += 1;
-                continue;
-            }
-        }
-        if bytes[index] != b'<' {
-            index = source[index..]
-                .find('<')
-                .map_or(bytes.len(), |offset| index + offset);
-            let text = &source[start..index];
-            let mut node = DomNode::new("text");
-            node.data = Some(if decode {
-                decode_entities_mode(
-                    text,
-                    xml,
-                    false,
-                    arena.options.get("__utf16Codec") == Some(&Value::Bool(true)),
-                )
-            } else {
-                text.into()
-            });
-            append_parsed!(
-                arena,
-                *parents.last().unwrap(),
-                node,
-                start,
-                index.saturating_sub(1),
-            );
-            continue;
-        }
-        if source[index..].starts_with("<!--") {
-            let end = source[index + 4..]
-                .find("-->")
-                .map(|offset| index + 4 + offset);
-            let data_end = end.unwrap_or(bytes.len());
-            index = end.map_or(bytes.len(), |end| end + 3);
-            let mut node = DomNode::new("comment");
-            node.data = Some(source[start + 4..data_end].into());
-            append_parsed!(
-                arena,
-                *parents.last().unwrap(),
-                node,
-                start,
-                index.saturating_sub(1),
-            );
-            continue;
-        }
-        if source[index..].starts_with("<![CDATA[") {
-            let end = source[index + 9..]
-                .find("]]>")
-                .map(|offset| index + 9 + offset);
-            let data_end = end.unwrap_or(bytes.len());
-            index = end.map_or(bytes.len(), |end| end + 3);
-            if !xml && arena.options.get("recognizeCDATA") != Some(&Value::Bool(true)) {
-                let mut node = DomNode::new("comment");
-                node.data = Some(format!("[CDATA[{}]]", &source[start + 9..data_end]));
-                append_parsed!(
-                    arena,
-                    *parents.last().unwrap(),
-                    node,
-                    start,
-                    index.saturating_sub(1)
-                );
-                continue;
-            }
-            let id = append_parsed!(
-                arena,
-                *parents.last().unwrap(),
-                DomNode::new("cdata"),
-                start,
-                index.saturating_sub(1),
-            );
-            let mut text = DomNode::new("text");
-            text.data = Some(source[start + 9..data_end].into());
-            append_parsed!(arena, id, text, start + 9, data_end.saturating_sub(1));
-            continue;
-        }
-        let mut cursor = index + 1;
-        let mut quote = None;
-        while cursor < bytes.len() {
-            let ch = bytes[cursor];
-            if let Some(q) = quote {
-                if ch == q {
-                    quote = None;
-                }
-            } else if ch == b'\'' || ch == b'"' {
-                quote = Some(ch);
-            } else if ch == b'>' {
-                break;
-            }
-            cursor += 1;
-        }
-        if cursor >= bytes.len() {
-            let mut text = DomNode::new("text");
-            text.data = Some(source[index..].into());
-            append_parsed!(
-                arena,
-                *parents.last().unwrap(),
-                text,
-                start,
-                bytes.len().saturating_sub(1),
-            );
-            break;
-        }
-        index = cursor + 1;
-        let token = source[start + 1..cursor].trim();
-        if token.starts_with('!') || token.starts_with('?') {
-            let mut node = DomNode::new("directive");
-            node.name = Some(token.split_whitespace().next().unwrap_or("").into());
-            node.data = Some(token.into());
-            append_parsed!(arena, *parents.last().unwrap(), node, start, cursor);
-            continue;
-        }
-        if let Some(close) = token.strip_prefix('/') {
-            let close = close.split_whitespace().next().unwrap_or("");
-            if let Some(position) = parents.iter().rposition(|id| {
-                arena.nodes[*id as usize]
-                    .name
-                    .as_deref()
-                    .is_some_and(|name| {
-                        if xml {
-                            name == close
-                        } else {
-                            name.eq_ignore_ascii_case(close)
-                        }
-                    })
-            }) {
-                for id in parents.drain(position..) {
-                    if arena.options.get("withEndIndices") == Some(&Value::Bool(true)) {
-                        arena.nodes[id as usize]
-                            .extras
-                            .insert("endIndex".into(), json!(source_position(cursor)));
-                    }
-                }
-            }
-            continue;
-        }
-        let slash = token.ends_with('/');
-        let content = token.strip_suffix('/').unwrap_or(token);
-        let name_end = content.find(char::is_whitespace).unwrap_or(content.len());
-        let name = &content[..name_end];
-        if name.is_empty() {
-            continue;
-        }
-        let lower = arena
-            .options
-            .get("lowerCaseTags")
-            .and_then(Value::as_bool)
-            .unwrap_or(!xml);
-        let name = if lower {
-            name.to_ascii_lowercase()
-        } else {
-            name.into()
-        };
-        if !xml {
-            while parents
-                .last()
-                .and_then(|id| arena.node(*id))
-                .and_then(|node| node.name.as_deref())
-                .is_some_and(|open| implied_close(&name, open))
-            {
-                let id = parents.pop().unwrap();
-                if arena.options.get("withEndIndices") == Some(&Value::Bool(true)) {
-                    arena.nodes[id as usize].extras.insert(
-                        "endIndex".into(),
-                        json!(source_position(start.saturating_sub(1))),
-                    );
-                }
-            }
-        }
-        let foreign = matches!(name.as_str(), "svg" | "math")
-            || parents
-                .iter()
-                .rev()
-                .filter_map(|id| arena.node(*id))
-                .filter_map(|node| node.name.as_deref())
-                .find_map(|name| {
-                    if matches!(
-                        name,
-                        "mi" | "mo"
-                            | "mn"
-                            | "ms"
-                            | "mtext"
-                            | "annotation-xml"
-                            | "foreignobject"
-                            | "desc"
-                            | "title"
-                    ) {
-                        Some(false)
-                    } else if matches!(name, "svg" | "math") {
-                        Some(true)
-                    } else {
-                        None
-                    }
-                })
-                .unwrap_or(false);
-        let self_close = slash
-            && (xml
-                || foreign
-                || arena.options.get("recognizeSelfClosing") == Some(&Value::Bool(true)));
-        let mut node = DomNode::new(if !xml && name == "script" {
-            "script"
-        } else if !xml && name == "style" {
-            "style"
-        } else {
-            "tag"
-        });
-        node.name = Some(name.clone());
-        node.attribs = parse_attributes(
-            &content[name_end..],
-            decode,
-            arena
-                .options
-                .get("lowerCaseAttributeNames")
-                .and_then(Value::as_bool)
-                .unwrap_or(!xml),
-            xml,
-            arena.options.get("__utf16Codec") == Some(&Value::Bool(true)),
-        );
-        let id = append_parsed!(arena, *parents.last().unwrap(), node, start, cursor);
-        let void = !xml && html_parser_void(&name);
-        if !self_close && !void {
-            parents.push(id);
-        } else if arena.options.get("withEndIndices") == Some(&Value::Bool(true)) {
-            arena.nodes[id as usize]
-                .extras
-                .insert("endIndex".into(), json!(source_position(cursor)));
-        }
-    }
+    crate::tokenizer::parse_markup(source, options)
 }
 
-/// Incremental HTML-parser2/XML state; only incomplete markup/entity tokens are
-/// buffered, while completed input is discarded after native tree construction.
+/// Incremental htmlparser2/XML input. The complete input is tokenized once, so
+/// tags and entities split across chunks parse exactly as one string does.
 pub(crate) struct XmlStream {
     pub arena: DomArena,
-    parents: Vec<u32>,
     pending: String,
-    offset: usize,
 }
 impl XmlStream {
     pub(crate) fn new(options: Value) -> Self {
         Self {
             arena: DomArena::from_records(vec![DomNode::new("root")], options),
-            parents: vec![0],
             pending: String::new(),
-            offset: 0,
         }
     }
     pub(crate) fn feed(&mut self, chunk: &str, finish: bool) {
         self.pending.push_str(chunk);
-        let mut consumed = 0;
-        loop {
-            let input = &self.pending[consumed..];
-            let mut length = if finish {
-                input.len()
-            } else {
-                self.complete_prefix(input)
-            };
-            if !finish
-                && self.arena.options.get("__utf16Codec") == Some(&Value::Bool(true))
-                && input[..length]
-                    .chars()
-                    .rev()
-                    .take_while(|ch| *ch == crate::codec::ESCAPE)
-                    .count()
-                    % 2
-                    == 1
-            {
-                length -= crate::codec::ESCAPE.len_utf8();
-            }
-            if length == 0 {
-                break;
-            }
-            let segment = &input[..length];
-            parse_xml_segment(segment, &mut self.arena, &mut self.parents, self.offset);
-            self.offset += if self.arena.options.get("__utf16Codec") == Some(&Value::Bool(true)) {
-                crate::codec::logical_len(segment)
-            } else {
-                segment.encode_utf16().count()
-            };
-            consumed += length;
-            if consumed == self.pending.len() || finish {
-                break;
-            }
+        if finish {
+            let options = self.arena.options.clone();
+            self.arena = parse_xml(&std::mem::take(&mut self.pending), options);
         }
-        self.pending.drain(..consumed);
-    }
-    fn complete_prefix(&self, input: &str) -> usize {
-        let bytes = input.as_bytes();
-        if input.is_empty() {
-            return 0;
-        }
-        if !self.arena.xml_mode() {
-            if let Some(name) = self
-                .parents
-                .last()
-                .and_then(|id| self.arena.node(*id))
-                .and_then(|node| node.name.as_deref())
-                .filter(|name| matches!(*name, "script" | "style" | "xmp" | "textarea" | "title"))
-            {
-                let close = format!("</{name}");
-                let closing = bytes
-                    .windows(close.len())
-                    .enumerate()
-                    .find(|(at, value)| {
-                        value.eq_ignore_ascii_case(close.as_bytes())
-                            && bytes
-                                .get(at + close.len())
-                                .is_none_or(|ch| *ch == b'>' || ch.is_ascii_whitespace())
-                    })
-                    .map(|(at, _)| at);
-                match closing {
-                    Some(0) if bytes.len() == close.len() => return 0,
-                    Some(0) => {}
-                    Some(index) => return safe_entity_prefix(input, index, name == "title"),
-                    None => {
-                        let mut end = input.len().saturating_sub(close.len() + 1);
-                        while !input.is_char_boundary(end) {
-                            end -= 1;
-                        }
-                        return safe_entity_prefix(input, end, name == "title");
-                    }
-                }
-            }
-        }
-        if bytes[0] != b'<' {
-            let end = input.find('<').unwrap_or(input.len());
-            return safe_entity_prefix(
-                input,
-                end,
-                self.arena.options.get("decodeEntities") != Some(&Value::Bool(false)),
-            );
-        }
-        if input.starts_with("<!--") {
-            return input.find("-->").map_or(0, |index| index + 3);
-        }
-        if input.starts_with("<![CDATA[") {
-            return input.find("]]>").map_or(0, |index| index + 3);
-        }
-        let mut quote = None;
-        for (index, ch) in bytes.iter().copied().enumerate().skip(1) {
-            if let Some(q) = quote {
-                if ch == q {
-                    quote = None;
-                }
-            } else if ch == b'\'' || ch == b'"' {
-                quote = Some(ch);
-            } else if ch == b'>' {
-                return index + 1;
-            }
-        }
-        0
     }
 }
-fn safe_entity_prefix(source: &str, end: usize, decode: bool) -> usize {
-    if decode {
-        if let Some(start) = source[..end].rfind('&') {
-            let tail = &source[start + 1..end];
-            if tail.len() < 64
-                && tail
-                    .chars()
-                    .all(|ch| ch.is_ascii_alphanumeric() || ch == '#')
-            {
-                return start;
-            }
-        }
-    }
-    end
-}
-
 pub(crate) fn append_parsed(
     arena: &mut DomArena,
     parent: u32,
@@ -1362,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
@@ -1373,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));
@@ -1381,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();
@@ -1424,70 +1157,6 @@ pub(crate) fn implied_close(name: &str, open: &str) -> bool {
         _ => false,
     }
 }
-fn parse_attributes(
-    source: &str,
-    decode: bool,
-    lower: bool,
-    xml: bool,
-    codec: bool,
-) -> Map<String, Value> {
-    let bytes = source.as_bytes();
-    let mut index = 0;
-    let mut attrs = Map::new();
-    while index < bytes.len() {
-        while index < bytes.len() && bytes[index].is_ascii_whitespace() {
-            index += 1;
-        }
-        let start = index;
-        while index < bytes.len() && !bytes[index].is_ascii_whitespace() && bytes[index] != b'=' {
-            index += 1;
-        }
-        if start == index {
-            index += 1;
-            continue;
-        }
-        let name = &source[start..index];
-        while index < bytes.len() && bytes[index].is_ascii_whitespace() {
-            index += 1;
-        }
-        let mut value = "";
-        if bytes.get(index) == Some(&b'=') {
-            index += 1;
-            while index < bytes.len() && bytes[index].is_ascii_whitespace() {
-                index += 1;
-            }
-            if matches!(bytes.get(index), Some(b'\'' | b'"')) {
-                let quote = bytes[index];
-                index += 1;
-                let start = index;
-                while index < bytes.len() && bytes[index] != quote {
-                    index += 1;
-                }
-                value = &source[start..index];
-                index += (index < bytes.len()) as usize;
-            } else {
-                let start = index;
-                while index < bytes.len() && !bytes[index].is_ascii_whitespace() {
-                    index += 1;
-                }
-                value = &source[start..index];
-            }
-        }
-        let name = if lower {
-            name.to_ascii_lowercase()
-        } else {
-            name.into()
-        };
-        attrs.entry(name).or_insert_with(|| {
-            Value::String(if decode {
-                decode_entities_mode(value, xml, true, codec)
-            } else {
-                value.into()
-            })
-        });
-    }
-    attrs
-}
 pub(crate) fn decode_entities_mode(
     source: &str,
     xml: bool,
@@ -1734,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")