rusteerio 0.0.0-stage → 0.1.0

package/native/src/arena.rs

@@ -0,0 +1,1781 @@
+//! Mutable, stable-ID DOM storage. All mutations stay on the native side.
+use std::collections::{HashMap, HashSet};
+
+use napi::{Error, Result, Status};
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Map, Value};
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub(crate) struct DomNode {
+    #[serde(default)]
+    pub id: u32,
+    #[serde(rename = "type", default = "root_kind")]
+    pub kind: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub data: Option<String>,
+    #[serde(default)]
+    pub attribs: Map<String, Value>,
+    #[serde(default)]
+    pub children: Vec<u32>,
+    #[serde(default)]
+    pub parent: Option<u32>,
+    #[serde(default)]
+    pub prev: Option<u32>,
+    #[serde(default)]
+    pub next: Option<u32>,
+    #[serde(flatten)]
+    pub extras: Map<String, Value>,
+}
+
+fn root_kind() -> String {
+    "root".into()
+}
+
+impl DomNode {
+    pub(crate) fn new(kind: &str) -> Self {
+        Self {
+            id: 0,
+            kind: kind.into(),
+            name: None,
+            data: None,
+            attribs: Map::new(),
+            children: Vec::new(),
+            parent: None,
+            prev: None,
+            next: None,
+            extras: Map::new(),
+        }
+    }
+    pub(crate) fn is_element(&self) -> bool {
+        matches!(self.kind.as_str(), "tag" | "script" | "style")
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct DomArena {
+    pub nodes: Vec<DomNode>,
+    pub options: Value,
+    pub free: Vec<u32>,
+}
+
+impl DomArena {
+    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 mut arena = Self {
+            nodes,
+            options,
+            free: Vec::new(),
+        };
+        for id in 0..arena.nodes.len() {
+            arena.relink(id as u32);
+        }
+        arena
+    }
+    pub(crate) fn node(&self, id: u32) -> Option<&DomNode> {
+        self.nodes
+            .get(id as usize)
+            .filter(|node| node.kind != "released")
+    }
+    pub(crate) fn xml_mode(&self) -> bool {
+        xml_mode(&self.options)
+    }
+    pub(crate) fn push(&mut self, mut node: DomNode) -> u32 {
+        while let Some(id) = self.free.pop() {
+            if self
+                .nodes
+                .get(id as usize)
+                .is_some_and(|old| old.kind == "released")
+            {
+                node.id = id;
+                self.nodes[id as usize] = node;
+                return id;
+            }
+        }
+        let id = self.nodes.len() as u32;
+        node.id = id;
+        self.nodes.push(node);
+        id
+    }
+    pub(crate) fn attr(&self, id: u32, name: &str) -> Option<&str> {
+        self.node(id)?.attribs.get(name)?.as_str()
+    }
+    pub(crate) fn set_attr(&mut self, ids: &[u32], name: &str, value: Option<&str>) {
+        for id in ids {
+            if let Some(node) = self.nodes.get_mut(*id as usize) {
+                if node.is_element() {
+                    match value {
+                        Some(value) => {
+                            node.attribs
+                                .insert(name.into(), Value::String(value.into()));
+                        }
+                        None => {
+                            node.attribs.remove(name);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    pub(crate) fn relink(&mut self, parent: u32) {
+        let children = self
+            .nodes
+            .get(parent as usize)
+            .map(|node| node.children.clone())
+            .unwrap_or_default();
+        for (index, child) in children.iter().enumerate() {
+            if let Some(node) = self.nodes.get_mut(*child as usize) {
+                node.parent = Some(parent);
+                node.prev = index
+                    .checked_sub(1)
+                    .and_then(|index| children.get(index))
+                    .copied();
+                node.next = children.get(index + 1).copied();
+            }
+        }
+    }
+    pub(crate) fn detach(&mut self, id: u32) {
+        if let Some(parent) = self.node(id).and_then(|node| node.parent) {
+            if let Some(node) = self.nodes.get_mut(parent as usize) {
+                node.children.retain(|child| *child != id);
+            }
+            self.relink(parent);
+        }
+        if let Some(node) = self.nodes.get_mut(id as usize) {
+            node.parent = None;
+            node.prev = None;
+            node.next = None;
+        }
+    }
+    pub(crate) fn detach_many(&mut self, ids: &[u32]) {
+        if ids.len() < 2 {
+            if let Some(id) = ids.first() {
+                self.detach(*id);
+            }
+            return;
+        }
+        let removed: HashSet<_> = ids.iter().copied().collect();
+        let parents: HashSet<_> = ids
+            .iter()
+            .filter_map(|id| self.node(*id).and_then(|node| node.parent))
+            .collect();
+        for parent in parents {
+            if let Some(node) = self.nodes.get_mut(parent as usize) {
+                node.children.retain(|child| !removed.contains(child));
+            }
+            self.relink(parent);
+        }
+        for id in removed {
+            if let Some(node) = self.nodes.get_mut(id as usize) {
+                node.parent = None;
+                node.prev = None;
+                node.next = None;
+            }
+        }
+    }
+    pub(crate) fn set_children(&mut self, parent: u32, children: &[u32]) {
+        if self.node(parent).is_none() {
+            return;
+        }
+        if !self
+            .node(parent)
+            .is_some_and(|node| node.is_element() || node.kind == "root" || node.kind == "cdata")
+        {
+            return;
+        }
+        let old = std::mem::take(&mut self.nodes[parent as usize].children);
+        self.detach_many(&old);
+        let mut seen = HashSet::new();
+        let mut children: Vec<_> = children
+            .iter()
+            .rev()
+            .copied()
+            .filter(|id| *id != parent && self.node(*id).is_some() && seen.insert(*id))
+            .collect();
+        children.reverse();
+        self.detach_many(&children);
+        self.nodes[parent as usize].children = children;
+        self.relink(parent);
+    }
+    pub(crate) fn text(&self, ids: &[u32]) -> String {
+        let mut output = String::new();
+        for id in ids {
+            let mut stack = vec![*id];
+            let mut visited = HashSet::new();
+            while let Some(id) = stack.pop() {
+                if !visited.insert(id) {
+                    continue;
+                }
+                if let Some(node) = self.node(id) {
+                    if node.kind == "text" {
+                        output.push_str(node.data.as_deref().unwrap_or(""));
+                    } else {
+                        stack.extend(node.children.iter().rev().copied());
+                    }
+                }
+            }
+        }
+        output
+    }
+    pub(crate) fn set_text(&mut self, ids: &[u32], value: &str) {
+        for id in ids {
+            if self
+                .node(*id)
+                .is_some_and(|node| node.is_element() || node.kind == "root")
+            {
+                self.set_children(*id, &[]);
+                if !value.is_empty() {
+                    let mut text = DomNode::new("text");
+                    text.data = Some(value.into());
+                    let child = self.push(text);
+                    self.set_children(*id, &[child]);
+                }
+            }
+        }
+    }
+    pub(crate) fn inner_html(&self, id: u32) -> String {
+        self.outer_html(
+            self.node(id)
+                .map(|node| node.children.as_slice())
+                .unwrap_or(&[]),
+        )
+    }
+    pub(crate) fn inner_html_mut(&mut self, id: u32) -> String {
+        if !self.xml_mode() && self.options.get("_useHtmlParser2") != Some(&Value::Bool(true)) {
+            if let Some(node) = self.node(id) {
+                let mut children = node.children.clone();
+                let mut index = 0;
+                while index < children.len() {
+                    if let Some(root) = self
+                        .node(children[index])
+                        .filter(|node| node.kind == "root")
+                    {
+                        let contents = root.children.clone();
+                        children.splice(index..index + 1, contents);
+                    }
+                    index += 1;
+                }
+                self.nodes[id as usize].children = children;
+            }
+        }
+        self.inner_html(id)
+    }
+    pub(crate) fn outer_html(&self, ids: &[u32]) -> String {
+        self.serialize(ids, &self.options)
+    }
+    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));
+        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() {
+            if budget == 0 {
+                break;
+            }
+            budget -= 1;
+            let Some(node) = self.node(id) else {
+                continue;
+            };
+            if close {
+                output.push_str("</");
+                output.push_str(node.name.as_deref().unwrap_or(""));
+                output.push('>');
+                continue;
+            }
+            match node.kind.as_str() {
+                "root" => stack.extend(node.children.iter().rev().map(|id| (*id, false))),
+                "text" => {
+                    let raw = !xml
+                        && node
+                            .parent
+                            .and_then(|id| self.node(id))
+                            .is_some_and(|parent| {
+                                matches!(
+                                    parent.name.as_deref(),
+                                    Some(
+                                        "script"
+                                            | "style"
+                                            | "xmp"
+                                            | "iframe"
+                                            | "noembed"
+                                            | "noframes"
+                                            | "plaintext"
+                                            | "noscript"
+                                    )
+                                ) && (parent.name.as_deref() != Some("noscript")
+                                    || options.get("scriptingEnabled") != Some(&Value::Bool(false)))
+                            });
+                    if raw || !encode {
+                        output.push_str(node.data.as_deref().unwrap_or(""));
+                    } else {
+                        escape(
+                            node.data.as_deref().unwrap_or(""),
+                            false,
+                            xml || options.get("_useHtmlParser2") == Some(&Value::Bool(true)),
+                            options.get("encodeEntities").and_then(Value::as_str) == Some("utf8"),
+                            &mut output,
+                        );
+                    }
+                }
+                "comment" => {
+                    output.push_str("<!--");
+                    output.push_str(node.data.as_deref().unwrap_or(""));
+                    output.push_str("-->");
+                }
+                "cdata" => {
+                    output.push_str("<![CDATA[");
+                    output.push_str(&self.text(&node.children));
+                    output.push_str("]]>");
+                }
+                "directive" | "doctype" => {
+                    output.push('<');
+                    if !xml && node.name.as_deref() == Some("!doctype") {
+                        output.push_str("!DOCTYPE ");
+                        output.push_str(
+                            node.extras
+                                .get("x-name")
+                                .and_then(Value::as_str)
+                                .unwrap_or("html"),
+                        );
+                    } else {
+                        output.push_str(node.data.as_deref().unwrap_or(""));
+                    }
+                    output.push('>');
+                }
+                _ if node.is_element() => {
+                    let name = node.name.as_deref().unwrap_or("");
+                    output.push('<');
+                    output.push_str(name);
+                    for (name, value) in &node.attribs {
+                        output.push(' ');
+                        if !xml {
+                            if let Some(prefix) = node
+                                .extras
+                                .get("attribsPrefix")
+                                .and_then(|value| value.get(name))
+                                .and_then(Value::as_str)
+                            {
+                                output.push_str(prefix);
+                                output.push(':');
+                            }
+                        }
+                        output.push_str(name);
+                        let value = value
+                            .as_str()
+                            .map(str::to_owned)
+                            .unwrap_or_else(|| value.to_string());
+                        if !xml
+                            && options.get("_useHtmlParser2") == Some(&Value::Bool(true))
+                            && options.get("emptyAttrs") != Some(&Value::Bool(true))
+                            && value.is_empty()
+                        {
+                            continue;
+                        }
+                        output.push_str("=\"");
+                        if encode {
+                            escape(
+                                &value,
+                                true,
+                                xml || options.get("_useHtmlParser2") == Some(&Value::Bool(true)),
+                                options.get("encodeEntities").and_then(Value::as_str)
+                                    == Some("utf8"),
+                                &mut output,
+                            );
+                        } else {
+                            output.push_str(&value.replace('"', "&quot;"));
+                        }
+                        output.push('"');
+                    }
+                    let is_void = !xml
+                        && (node
+                            .extras
+                            .get("namespace")
+                            .and_then(Value::as_str)
+                            .is_none_or(|namespace| namespace == super::HTML_NS))
+                        && super::void_name(name);
+                    if xml
+                        && node.children.is_empty()
+                        && options.get("selfClosingTags") != Some(&Value::Bool(false))
+                    {
+                        output.push_str("/>");
+                        continue;
+                    }
+                    output.push('>');
+                    if is_void {
+                        continue;
+                    }
+                    stack.push((id, true));
+                    if !xml
+                        && options.get("_useHtmlParser2") != Some(&Value::Bool(true))
+                        && name == "template"
+                    {
+                        if let Some(contents) = node.children.first().and_then(|id| self.node(*id))
+                        {
+                            stack.extend(contents.children.iter().rev().map(|id| (*id, false)));
+                        }
+                    } else {
+                        stack.extend(node.children.iter().rev().map(|id| (*id, false)));
+                    }
+                }
+                _ => {}
+            }
+        }
+        output
+    }
+    pub(crate) fn clone_ids(&mut self, ids: &[u32], deep: bool) -> Vec<u32> {
+        ids.iter()
+            .filter_map(|id| self.clone_branch(*id, deep))
+            .collect()
+    }
+    fn clone_branch(&mut self, root: u32, deep: bool) -> Option<u32> {
+        let mut node = self.node(root)?.clone();
+        if node.is_element() {
+            node.extras.remove("data");
+        }
+        let source_children = node.children.clone();
+        node.children.clear();
+        node.parent = None;
+        node.prev = None;
+        node.next = None;
+        let new_root = self.push(node);
+        if deep {
+            let mut queue = vec![(new_root, source_children)];
+            while let Some((parent, children)) = queue.pop() {
+                for child in children {
+                    if let Some(node) = self.node(child) {
+                        let mut copy = node.clone();
+                        if copy.is_element() {
+                            copy.extras.remove("data");
+                        }
+                        let child_children = copy.children.clone();
+                        copy.children.clear();
+                        copy.parent = None;
+                        copy.prev = None;
+                        copy.next = None;
+                        let id = self.push(copy);
+                        self.nodes[parent as usize].children.push(id);
+                        queue.push((id, child_children));
+                    }
+                }
+                self.relink(parent);
+            }
+        }
+        Some(new_root)
+    }
+    pub(crate) fn import(&mut self, records: &[DomNode], roots: &[u32]) -> Vec<u32> {
+        self.import_internal(records, roots, true)
+    }
+    fn import_internal(
+        &mut self,
+        records: &[DomNode],
+        roots: &[u32],
+        detach_roots: bool,
+    ) -> Vec<u32> {
+        self.nodes.reserve(records.len());
+        let mut mapping = HashMap::new();
+        for record in records {
+            let mut node = record.clone();
+            node.children.clear();
+            node.parent = None;
+            node.prev = None;
+            node.next = None;
+            let id = self.push(node);
+            mapping.insert(record.id, id);
+        }
+        for record in records {
+            if let Some(id) = mapping.get(&record.id) {
+                self.nodes[*id as usize].children = record
+                    .children
+                    .iter()
+                    .filter_map(|child| mapping.get(child).copied())
+                    .collect();
+                self.relink(*id);
+            }
+        }
+        let roots: Vec<_> = roots
+            .iter()
+            .filter_map(|root| mapping.get(root).copied())
+            .collect();
+        if detach_roots {
+            self.detach_many(&roots);
+        }
+        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 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;
+        }
+        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))
+    }
+    pub(crate) fn set_html(&mut self, ids: &[u32], html: &str) -> Result<()> {
+        for id in ids {
+            let children = self.create_fragment(html, Some(*id))?;
+            self.set_children(*id, &children);
+        }
+        Ok(())
+    }
+    pub(crate) fn insert(&mut self, targets: &[u32], ids: &[u32], position: &str) -> Vec<u32> {
+        let mut inserted = Vec::new();
+        for (index, target) in targets.iter().enumerate() {
+            if self.node(*target).is_none() {
+                continue;
+            }
+            if matches!(position, "append" | "prepend")
+                && !self
+                    .node(*target)
+                    .is_some_and(|node| node.is_element() || node.kind == "root")
+            {
+                continue;
+            }
+            let ids = if index + 1 == targets.len() {
+                ids.to_vec()
+            } else {
+                self.clone_ids(ids, true)
+            };
+            let (parent, mut offset) = if matches!(position, "append" | "prepend") {
+                (
+                    *target,
+                    if position == "append" {
+                        self.nodes[*target as usize].children.len()
+                    } else {
+                        0
+                    },
+                )
+            } else {
+                let Some(parent) = self.nodes[*target as usize].parent else {
+                    continue;
+                };
+                let at = self.nodes[parent as usize]
+                    .children
+                    .iter()
+                    .position(|id| id == target)
+                    .unwrap_or(0);
+                (parent, at + usize::from(position == "after"))
+            };
+            let valid: Vec<_> = ids
+                .iter()
+                .copied()
+                .filter(|id| *id != parent && self.node(*id).is_some())
+                .collect();
+            let removed: HashSet<_> = valid.iter().copied().collect();
+            offset -= self.nodes[parent as usize]
+                .children
+                .iter()
+                .take(offset)
+                .filter(|id| removed.contains(id))
+                .count();
+            self.detach_many(&valid);
+            let mut seen = HashSet::new();
+            let mut moved: Vec<_> = valid
+                .iter()
+                .rev()
+                .copied()
+                .filter(|id| seen.insert(*id))
+                .collect();
+            moved.reverse();
+            let offset = offset.min(self.nodes[parent as usize].children.len());
+            self.nodes[parent as usize]
+                .children
+                .splice(offset..offset, moved);
+            inserted.extend(valid);
+            self.relink(parent);
+            if position == "replace" && !ids.contains(target) {
+                self.detach(*target);
+            }
+        }
+        inserted
+    }
+    pub(crate) fn traverse(&self, ids: &[u32], kind: &str) -> Vec<u32> {
+        let mut result = Vec::new();
+        for id in ids {
+            let Some(node) = self.node(*id) else {
+                continue;
+            };
+            match kind {
+                "children" => result.extend(
+                    node.children
+                        .iter()
+                        .copied()
+                        .filter(|id| self.node(*id).is_some_and(DomNode::is_element)),
+                ),
+                "contents" => result.extend(node.children.iter().copied()),
+                "parent" => result.extend(
+                    node.parent
+                        .filter(|id| self.node(*id).is_some_and(DomNode::is_element)),
+                ),
+                "parents" | "ancestors" => {
+                    let mut parent = node.parent;
+                    let mut seen = HashSet::new();
+                    while let Some(id) = parent {
+                        if !seen.insert(id) {
+                            break;
+                        }
+                        if self.node(id).is_some_and(DomNode::is_element) {
+                            result.push(id);
+                        }
+                        parent = self.node(id).and_then(|node| node.parent);
+                    }
+                }
+                "next" | "prev" | "nextAll" | "prevAll" => {
+                    let forward = kind.starts_with("next");
+                    let mut next = if forward { node.next } else { node.prev };
+                    let mut seen = HashSet::new();
+                    while let Some(id) = next {
+                        if !seen.insert(id) {
+                            break;
+                        }
+                        if self.node(id).is_some_and(DomNode::is_element) {
+                            result.push(id);
+                            if kind == "next" || kind == "prev" {
+                                break;
+                            }
+                        }
+                        next = self
+                            .node(id)
+                            .and_then(|node| if forward { node.next } else { node.prev });
+                    }
+                }
+                "siblings" => {
+                    if let Some(parent) = node.parent.and_then(|parent| self.node(parent)) {
+                        result.extend(parent.children.iter().copied().filter(|other| {
+                            other != id && self.node(*other).is_some_and(DomNode::is_element)
+                        }));
+                    }
+                }
+                "descendants" => {
+                    let mut stack: Vec<_> = node.children.iter().rev().copied().collect();
+                    while let Some(id) = stack.pop() {
+                        if let Some(node) = self.node(id) {
+                            if node.is_element() {
+                                result.push(id);
+                            }
+                            stack.extend(node.children.iter().rev().copied());
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+        result
+    }
+    pub(crate) fn set_node(&mut self, id: u32, field: &str, value: &Value) -> Result<()> {
+        if self.node(id).is_none() {
+            return Ok(());
+        }
+        if field == "children" {
+            self.set_children(id, &value_ids(value));
+            return Ok(());
+        }
+        let node = &mut self.nodes[id as usize];
+        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(),
+            "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),
+            _ => {
+                if value.is_null() {
+                    node.extras.remove(field);
+                } else {
+                    node.extras.insert(field.into(), value.clone());
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+impl super::selector::SelectDom for DomArena {
+    fn kind(&self, id: u32) -> &str {
+        self.node(id).map_or("", |node| node.kind.as_str())
+    }
+    fn name(&self, id: u32) -> Option<&str> {
+        self.node(id)?.name.as_deref()
+    }
+    fn attr(&self, id: u32, name: &str) -> Option<&str> {
+        DomArena::attr(self, id, name)
+    }
+    fn parent(&self, id: u32) -> Option<u32> {
+        self.node(id)?.parent
+    }
+    fn children(&self, id: u32) -> &[u32] {
+        self.node(id).map_or(&[], |node| node.children.as_slice())
+    }
+    fn text(&self, id: u32) -> String {
+        DomArena::text(self, &[id])
+    }
+    fn xml_mode(&self) -> bool {
+        DomArena::xml_mode(self)
+    }
+    fn lower_case_tags(&self) -> bool {
+        self.options
+            .get("lowerCaseTags")
+            .and_then(Value::as_bool)
+            .unwrap_or(!self.xml_mode())
+    }
+    fn lower_case_attribute_names(&self) -> bool {
+        self.options
+            .get("lowerCaseAttributeNames")
+            .and_then(Value::as_bool)
+            .unwrap_or(!self.xml_mode())
+    }
+    fn custom_pseudo(&self, id: u32, name: &str, arg: Option<&str>) -> Option<bool> {
+        let key = format!("{}({})", name, arg.unwrap_or(""));
+        self.options
+            .get("__pseudoMatches")?
+            .get(&key)?
+            .as_array()
+            .map(|ids| ids.iter().any(|value| value.as_u64() == Some(id as u64)))
+    }
+    fn pseudo_alias(&self, name: &str) -> Option<&str> {
+        self.options.get("pseudos")?.get(name)?.as_str()
+    }
+}
+
+pub(crate) fn value_ids(value: &Value) -> Vec<u32> {
+    value
+        .as_array()
+        .map(|ids| {
+            ids.iter()
+                .filter_map(|id| id.as_u64().map(|id| id as u32))
+                .collect()
+        })
+        .unwrap_or_default()
+}
+pub(crate) fn xml_mode(options: &Value) -> bool {
+    options
+        .get("xmlMode")
+        .and_then(Value::as_bool)
+        .unwrap_or_else(|| {
+            options
+                .get("xml")
+                .is_some_and(|xml| xml.is_object() || xml == &Value::Bool(true))
+        })
+}
+pub(crate) fn normalized_options(mut options: Value) -> Value {
+    if !options.is_object() {
+        options = json!({});
+    }
+    if let Some(xml) = options.get("xml").and_then(Value::as_object).cloned() {
+        options["xmlMode"] = Value::Bool(true);
+        options["_useHtmlParser2"] = Value::Bool(true);
+        for (key, value) in xml {
+            options[&key] = value;
+        }
+    } else if options.get("xml") == Some(&Value::Bool(true)) {
+        options["xmlMode"] = Value::Bool(true);
+        options["_useHtmlParser2"] = Value::Bool(true);
+    }
+    options
+}
+fn escape(value: &str, attribute: bool, xml: bool, utf8: bool, output: &mut String) {
+    if xml && !utf8 && crate::codec::has_encoding(value) {
+        use std::fmt::Write;
+        let units = crate::codec::to_units(value);
+        let mut index = 0;
+        while index < units.len() {
+            let unit = units[index];
+            let named = match unit {
+                34 => Some("&quot;"),
+                38 => Some("&amp;"),
+                39 => Some("&apos;"),
+                60 => Some("&lt;"),
+                62 => Some("&gt;"),
+                _ => None,
+            };
+            if let Some(named) = named {
+                output.push_str(named);
+                index += 1;
+                continue;
+            }
+            if unit >= 0x80 || unit == 0x24 {
+                let high = (0xd800..=0xdbff).contains(&unit);
+                let code = if high
+                    && units
+                        .get(index + 1)
+                        .is_some_and(|unit| (0xdc00..=0xdfff).contains(unit))
+                {
+                    0x10000 + ((unit as u32 - 0xd800) << 10) + (units[index + 1] as u32 - 0xdc00)
+                } else {
+                    unit as u32
+                };
+                let _ = write!(output, "&#x{code:x};");
+                // entities.encodeXML advances over a following code unit for
+                // every high surrogate, including a lone high surrogate.
+                index += if high { 2 } else { 1 };
+            } else {
+                output.push(char::from_u32(unit as u32).unwrap());
+                index += 1;
+            }
+        }
+        return;
+    }
+    for ch in value.chars() {
+        match ch {
+            '&' => output.push_str("&amp;"),
+            '"' if attribute || xml => output.push_str("&quot;"),
+            '\'' if xml => output.push_str("&apos;"),
+            '<' if !attribute || xml => output.push_str("&lt;"),
+            '>' if !attribute || xml => output.push_str("&gt;"),
+            '\u{a0}' if !xml => output.push_str("&nbsp;"),
+            ch if xml && !utf8 && (ch > '\u{7f}' || ch == '$') => {
+                use std::fmt::Write;
+                let _ = write!(output, "&#x{:x};", ch as u32);
+            }
+            ch => output.push(ch),
+        }
+    }
+}
+
+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)));
+        }
+    }
+}
+
+/// Incremental HTML-parser2/XML state; only incomplete markup/entity tokens are
+/// buffered, while completed input is discarded after native tree construction.
+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;
+            }
+        }
+        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,
+    mut node: DomNode,
+    start: usize,
+    end: usize,
+) -> u32 {
+    if node.kind == "text" {
+        if let Some(previous) = arena.nodes[parent as usize]
+            .children
+            .last()
+            .copied()
+            .filter(|id| arena.nodes[*id as usize].kind == "text")
+        {
+            arena.nodes[previous as usize]
+                .data
+                .get_or_insert_with(String::new)
+                .push_str(node.data.as_deref().unwrap_or(""));
+            if arena.options.get("withEndIndices") == Some(&Value::Bool(true)) {
+                arena.nodes[previous as usize]
+                    .extras
+                    .insert("endIndex".into(), json!(end));
+            }
+            return previous;
+        }
+    }
+    if arena.options.get("withStartIndices") == Some(&Value::Bool(true)) {
+        node.extras.insert("startIndex".into(), json!(start));
+    }
+    if arena.options.get("withEndIndices") == Some(&Value::Bool(true)) {
+        node.extras.insert("endIndex".into(), json!(end));
+    }
+    let previous = arena.nodes[parent as usize].children.last().copied();
+    node.parent = Some(parent);
+    node.prev = previous;
+    let id = arena.push(node);
+    if let Some(previous) = previous {
+        arena.nodes[previous as usize].next = Some(id);
+    }
+    arena.nodes[parent as usize].children.push(id);
+    id
+}
+
+pub(crate) fn html_parser_void(name: &str) -> bool {
+    (super::void_name(name) && name != "bgsound") || matches!(name, "command" | "isindex")
+}
+pub(crate) fn implied_close(name: &str, open: &str) -> bool {
+    match name {
+        "tr" => matches!(open, "tr" | "th" | "td"),
+        "th" => open == "th",
+        "td" => matches!(open, "thead" | "th" | "td"),
+        "body" => matches!(open, "head" | "link" | "script"),
+        "li" => open == "li",
+        "option" => open == "option",
+        "optgroup" => matches!(open, "option" | "optgroup"),
+        "select" | "input" | "output" | "button" | "datalist" | "textarea" => matches!(
+            open,
+            "input" | "option" | "optgroup" | "select" | "button" | "datalist" | "textarea"
+        ),
+        "dd" | "dt" => matches!(open, "dd" | "dt"),
+        "rt" | "rp" => matches!(open, "rt" | "rp"),
+        "tbody" | "tfoot" => matches!(open, "thead" | "tbody"),
+        "p" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "address" | "article" | "aside"
+        | "blockquote" | "details" | "div" | "dl" | "fieldset" | "figcaption" | "figure"
+        | "footer" | "form" | "header" | "hr" | "main" | "nav" | "ol" | "pre" | "section"
+        | "table" | "ul" => open == "p",
+        _ => 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,
+    attribute: bool,
+    codec: bool,
+) -> String {
+    let scalar_string = |scalar: char| {
+        if codec {
+            crate::codec::encode_scalar(scalar)
+        } else {
+            scalar.to_string()
+        }
+    };
+    let bytes = source.as_bytes();
+    let mut output = String::with_capacity(source.len());
+    let mut cursor = 0;
+    while let Some(relative) = source[cursor..].find('&') {
+        let amp = cursor + relative;
+        output.push_str(&source[cursor..amp]);
+        let mut end = amp + 1;
+        let mut decoded = None;
+        if bytes.get(end) == Some(&b'#') {
+            end += 1;
+            let hexadecimal = matches!(bytes.get(end), Some(b'x' | b'X'));
+            if hexadecimal {
+                end += 1;
+            }
+            let digits = end;
+            let mut number = 0u32;
+            while let Some(digit) = bytes
+                .get(end)
+                .and_then(|value| (*value as char).to_digit(if hexadecimal { 16 } else { 10 }))
+            {
+                number = number
+                    .saturating_mul(if hexadecimal { 16 } else { 10 })
+                    .saturating_add(digit);
+                end += 1;
+            }
+            let semicolon = bytes.get(end) == Some(&b';');
+            if digits != end && (!xml || semicolon) {
+                if semicolon {
+                    end += 1;
+                }
+                let scalar = match number {
+                    0 | 0xd800..=0xdfff | 0x110000..=u32::MAX => '\u{fffd}',
+                    0x80..=0x9f => html5ever::data::C1_REPLACEMENTS[(number - 0x80) as usize]
+                        .unwrap_or(char::from_u32(number).unwrap()),
+                    _ => char::from_u32(number).unwrap(),
+                };
+                decoded = Some(scalar_string(scalar));
+            }
+        } else {
+            while bytes.get(end).is_some_and(u8::is_ascii_alphanumeric) {
+                end += 1;
+            }
+            if bytes.get(end) == Some(&b';') {
+                end += 1;
+            }
+            if xml {
+                let scalar = match &source[amp + 1..end] {
+                    "amp;" => Some('&'),
+                    "lt;" => Some('<'),
+                    "gt;" => Some('>'),
+                    "quot;" => Some('"'),
+                    "apos;" => Some('\''),
+                    _ => None,
+                };
+                decoded = scalar.map(scalar_string);
+            } else {
+                for candidate in (amp + 2..=end).rev() {
+                    if let Some(&(first, second)) =
+                        html5ever::data::NAMED_ENTITIES.get(&source[amp + 1..candidate])
+                    {
+                        if first == 0 {
+                            continue;
+                        }
+                        if bytes[candidate - 1] != b';'
+                            && attribute
+                            && bytes
+                                .get(candidate)
+                                .is_some_and(|next| next.is_ascii_alphanumeric() || *next == b'=')
+                        {
+                            break;
+                        }
+                        let mut value = scalar_string(char::from_u32(first).unwrap());
+                        if second != 0 {
+                            value.push_str(&scalar_string(char::from_u32(second).unwrap()));
+                        }
+                        decoded = Some(value);
+                        end = candidate;
+                        break;
+                    }
+                }
+            }
+        }
+        if let Some(value) = decoded {
+            output.push_str(&value);
+            cursor = end;
+        } else {
+            output.push('&');
+            cursor = amp + 1;
+        }
+    }
+    output.push_str(&source[cursor..]);
+    output
+}
+
+pub(crate) fn primitive(arena: &mut DomArena, command: &str, args: &Value) -> Result<Value> {
+    let ids = value_ids(&args["ids"]);
+    let id = args["id"].as_u64().unwrap_or(0) as u32;
+    Ok(match command {
+        "node" => arena
+            .node(id)
+            .map(|node| serde_json::to_value(node).unwrap())
+            .unwrap_or(Value::Null),
+        "createNode" => {
+            let mut fields = args.clone();
+            if let Some(fields) = fields.as_object_mut() {
+                fields.remove("options");
+            }
+            let mut node: DomNode = serde_json::from_value(fields)
+                .map_err(|error| Error::new(Status::InvalidArg, error.to_string()))?;
+            node.children.clear();
+            node.parent = None;
+            node.prev = None;
+            node.next = None;
+            json!(arena.push(node))
+        }
+        "setNode" => {
+            arena.set_node(id, args["field"].as_str().unwrap_or(""), &args["value"])?;
+            Value::Null
+        }
+        "attrs" => {
+            if let Some(value) = args.get("value") {
+                arena.set_node(id, "attribs", value)?;
+                Value::Null
+            } else {
+                Value::Object(
+                    arena
+                        .node(id)
+                        .map(|node| node.attribs.clone())
+                        .unwrap_or_default(),
+                )
+            }
+        }
+        "attr" => {
+            let name = args["name"].as_str().unwrap_or("");
+            if let Some(value) = args.get("value") {
+                let value = value
+                    .as_str()
+                    .map(str::to_owned)
+                    .or_else(|| (!value.is_null()).then(|| value.to_string()));
+                arena.set_attr(&ids, name, value.as_deref());
+                Value::Null
+            } else {
+                ids.first()
+                    .and_then(|id| arena.attr(*id, name))
+                    .map(|value| json!(value))
+                    .unwrap_or(Value::Null)
+            }
+        }
+        "text" => {
+            if let Some(value) = args.get("value") {
+                arena.set_text(&ids, value.as_str().unwrap_or(""));
+                Value::Null
+            } else {
+                json!(arena.text(&ids))
+            }
+        }
+        "html" => {
+            if let Some(value) = args.get("value") {
+                arena.set_html(&ids, value.as_str().unwrap_or(""))?;
+                Value::Null
+            } else {
+                ids.first()
+                    .map(|id| json!(arena.inner_html_mut(*id)))
+                    .unwrap_or(Value::Null)
+            }
+        }
+        "outerHtml" | "render" => {
+            let mut options = arena.options.clone();
+            if let Some(overrides) = args.get("options").and_then(Value::as_object) {
+                for (key, value) in overrides {
+                    options[key] = value.clone();
+                }
+            }
+            json!(arena.serialize(&ids, &normalized_options(options)))
+        }
+        "traverse" => json!(arena.traverse(&ids, args["kind"].as_str().unwrap_or("children"))),
+        "select" | "matches" => {
+            let previous = arena
+                .options
+                .as_object_mut()
+                .and_then(|options| options.remove("__pseudoMatches"));
+            if let Some(matches) = args.get("pseudoMatches") {
+                arena.options["__pseudoMatches"] = matches.clone();
+            }
+            let result = if command == "select" {
+                super::selector::select(
+                    arena,
+                    args["selector"].as_str().unwrap_or(""),
+                    args.get("contexts").map(value_ids).as_deref(),
+                )
+            } else {
+                super::selector::filter(arena, args["selector"].as_str().unwrap_or(""), &ids)
+            };
+            arena
+                .options
+                .as_object_mut()
+                .unwrap()
+                .remove("__pseudoMatches");
+            if let Some(previous) = previous {
+                arena.options["__pseudoMatches"] = previous;
+            }
+            json!(result?)
+        }
+        "create" => json!(arena.create_fragment(
+            args["html"].as_str().unwrap_or(""),
+            args["contextId"].as_u64().map(|id| id as u32)
+        )?),
+        "import" => {
+            let records: Vec<DomNode> = serde_json::from_value(args["nodes"].clone())
+                .map_err(|error| Error::new(Status::InvalidArg, error.to_string()))?;
+            json!(arena.import(&records, &value_ids(&args["roots"])))
+        }
+        "clone" => json!(arena.clone_ids(&ids, args["deep"].as_bool().unwrap_or(true))),
+        "insert" => json!(arena.insert(
+            &value_ids(&args["targetIds"]),
+            &value_ids(&args["nodeIds"]),
+            args["position"].as_str().unwrap_or("append")
+        )),
+        "remove" => {
+            if args["keepChildren"].as_bool() == Some(true) {
+                for id in &ids {
+                    let children = arena
+                        .node(*id)
+                        .map(|node| node.children.clone())
+                        .unwrap_or_default();
+                    arena.insert(&[*id], &children, "before");
+                    arena.detach(*id);
+                }
+            } else {
+                arena.detach_many(&ids);
+            }
+            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)
+        }
+        "contains" => {
+            let parent = args
+                .get("container")
+                .or_else(|| args.get("parent"))
+                .and_then(Value::as_u64)
+                .unwrap_or(0) as u32;
+            let mut node = args
+                .get("contained")
+                .or_else(|| args.get("child"))
+                .and_then(Value::as_u64)
+                .map(|id| id as u32);
+            let mut found = false;
+            let mut seen = HashSet::new();
+            while let Some(id) = node {
+                if !seen.insert(id) {
+                    break;
+                }
+                node = arena.node(id).and_then(|node| node.parent);
+                if node == Some(parent) {
+                    found = true;
+                    break;
+                }
+            }
+            json!(found)
+        }
+        _ => {
+            return Err(Error::new(
+                Status::InvalidArg,
+                format!("Unknown native DOM command {command}"),
+            ))
+        }
+    })
+}