@miaskiewicz/turbo-dom 0.5.7 → 0.6.0

package/src/core.rs

@@ -6,9 +6,13 @@
 //! marshaling proving to be the actual cost. Do not SoA-ify here yet.
 
 use html5ever::driver::ParseOpts;
+use html5ever::tendril::StrTendril;
 use html5ever::tendril::TendrilSink;
+use html5ever::tokenizer::{BufferQueue, Token, TokenSink, TokenSinkResult, Tokenizer};
+use html5ever::tree_builder::TreeBuilder;
 use html5ever::tree_builder::TreeBuilderOpts;
-use html5ever::{ns, parse_document, parse_fragment, LocalName, QualName};
+use html5ever::TokenizerResult;
+use html5ever::{ns, parse_fragment, LocalName, QualName};
 use markup5ever_rcdom::{Handle, NodeData, RcDom};
 
 /// DOM nodeType constants (subset html5ever can emit).
@@ -69,13 +73,194 @@ fn opts() -> ParseOpts {
     }
 }
 
+/// Chrome 156 treats an empty DOCTYPE system identifier as missing when it picks the
+/// document's quirks mode (miaskiewicz/turbo-dom#103): `<!DOCTYPE html PUBLIC "-//W3C//DTD
+/// HTML 4.01 Transitional//EN" "">` is quirks (a `<table>` stays in an open `<p>`), where the
+/// HTML spec (and html5ever) reads a present identifier. `doctype.systemId` is `""` both ways.
+#[must_use]
+pub fn chrome_doctype(token: Token) -> Token {
+    match token {
+        Token::DoctypeToken(mut doctype) if doctype.system_id.as_deref() == Some("") => {
+            doctype.system_id = None;
+            Token::DoctypeToken(doctype)
+        }
+        token => token,
+    }
+}
+
+/// A token sink that applies [`chrome_doctype`] before the wrapped sink (html5ever's tree
+/// builder) sees a token.
+pub struct ChromeTokens<S>(pub S);
+
+impl<S: TokenSink> TokenSink for ChromeTokens<S> {
+    type Handle = S::Handle;
+    fn process_token(&self, token: Token, line_number: u64) -> TokenSinkResult<S::Handle> {
+        self.0.process_token(chrome_doctype(token), line_number)
+    }
+    // (html5ever's `TreeBuilder::end` only pops the open elements into the sink, and
+    // `RcDom` ignores pops, so no tree here observes this delegation; it keeps the wrapper
+    // transparent for any sink.)
+    fn end(&self) {
+        self.0.end();
+    }
+    fn adjusted_current_node_present_but_not_in_html_namespace(&self) -> bool {
+        self.0
+            .adjusted_current_node_present_but_not_in_html_namespace()
+    }
+}
+
+/// `html5ever::parse_document` over a whole string, with [`ChromeTokens`].
+fn parse_document_dom(html: &str, opts: ParseOpts) -> RcDom {
+    let builder = TreeBuilder::new(RcDom::default(), opts.tree_builder);
+    let tokenizer = Tokenizer::new(ChromeTokens(builder), opts.tokenizer);
+    let input = BufferQueue::default();
+    input.push_back(StrTendril::from_slice(html));
+    while !matches!(tokenizer.feed(&input), TokenizerResult::Done) {}
+    tokenizer.end();
+    let dom = tokenizer.sink.0.sink;
+    if mentions_selectedcontent(html) {
+        fill_selectedcontent(&dom.document);
+    }
+    dom
+}
+
+/// Does `html` mention `<selectedcontent>` (ASCII case-insensitive)? Gates [`fill_selectedcontent`].
+#[must_use]
+pub fn mentions_selectedcontent(html: &str) -> bool {
+    html.as_bytes()
+        .windows(15)
+        .any(|w| w.eq_ignore_ascii_case(b"selectedcontent"))
+}
+
+/// Chrome 156 fills every `<selectedcontent>` of a non-`multiple` `<select>` with a clone of
+/// the selected option's content while it parses (the "maybe clone an option into
+/// selectedcontent" step; miaskiewicz/turbo-dom#104): the last option with `selected`, else
+/// the first option that is not disabled (itself or through its `<optgroup>`); with none,
+/// the element keeps its content. `markup5ever_rcdom` 0.39's step never finds the element (its
+/// descendant search compares the select's own name) and html5ever only runs it on an
+/// explicit `</option>`, so the parsed tree is completed here — the final state Chrome's
+/// per-option runs leave.
+pub fn fill_selectedcontent(root: &Handle) {
+    let mut pending = vec![root.clone()];
+    while let Some(node) = pending.pop() {
+        if html_element(&node, "select") && !has_attribute(&node, "multiple") {
+            let (options, contents) = select_parts(&node);
+            let selected = options
+                .iter()
+                .rev()
+                .find(|(option, _)| has_attribute(option, "selected"))
+                .or_else(|| options.iter().find(|(_, disabled)| !disabled));
+            if let Some((option, _)) = selected {
+                for content in &contents {
+                    for old in content.children.take() {
+                        old.parent.set(None);
+                    }
+                    for child in option.children.borrow().iter() {
+                        append_handle(content, deep_clone(child));
+                    }
+                }
+            }
+        }
+        pending.extend(node.children.borrow().iter().cloned());
+    }
+}
+
+fn html_element(node: &Handle, local: &str) -> bool {
+    matches!(&node.data, NodeData::Element { name, .. } if name.ns == ns!(html) && &*name.local == local)
+}
+
+fn has_attribute(node: &Handle, local: &str) -> bool {
+    matches!(&node.data, NodeData::Element { attrs, .. }
+        if attrs.borrow().iter().any(|a| a.name.ns == ns!() && &*a.name.local == local))
+}
+
+/// A select's options (with whether each is disabled) and selectedcontent elements, in tree
+/// order: an option counts unless an option, datalist or hr, or a second optgroup, lies
+/// between it and the select; a selectedcontent inside an option is not the select's
+/// (Chrome 156 leaves it as parsed).
+fn select_parts(select: &Handle) -> (Vec<(Handle, bool)>, Vec<Handle>) {
+    let (mut options, mut contents) = (Vec::new(), Vec::new());
+    // (node, blocked, inside an option, inside an optgroup, inside a disabled optgroup)
+    let mut pending: Vec<(Handle, bool, bool, bool, bool)> = select
+        .children
+        .borrow()
+        .iter()
+        .rev()
+        .map(|child| (child.clone(), false, false, false, false))
+        .collect();
+    while let Some((node, mut blocked, mut in_option, mut grouped, mut group_disabled)) =
+        pending.pop()
+    {
+        // (the parser never nests a select: a `<select>` start tag closes an open one)
+        if html_element(&node, "selectedcontent") && !in_option {
+            contents.push(node);
+            continue;
+        }
+        if html_element(&node, "option") {
+            if !blocked {
+                options.push((
+                    node.clone(),
+                    group_disabled || has_attribute(&node, "disabled"),
+                ));
+            }
+            blocked = true;
+            in_option = true;
+        } else if html_element(&node, "datalist") || html_element(&node, "hr") {
+            blocked = true;
+        } else if html_element(&node, "optgroup") {
+            blocked |= grouped;
+            grouped = true;
+            group_disabled |= has_attribute(&node, "disabled");
+        }
+        for child in node.children.borrow().iter().rev() {
+            pending.push((child.clone(), blocked, in_option, grouped, group_disabled));
+        }
+    }
+    (options, contents)
+}
+
+fn append_handle(parent: &Handle, child: Handle) {
+    child.parent.set(Some(std::rc::Rc::downgrade(parent)));
+    parent.children.borrow_mut().push(child);
+}
+
+/// A deep copy of a parsed node (element attributes and template contents included).
+fn deep_clone(node: &Handle) -> Handle {
+    let data = match &node.data {
+        NodeData::Element {
+            name,
+            attrs,
+            template_contents,
+            mathml_annotation_xml_integration_point,
+        } => NodeData::Element {
+            name: name.clone(),
+            attrs: std::cell::RefCell::new(attrs.borrow().clone()),
+            template_contents: std::cell::RefCell::new(
+                template_contents.borrow().as_ref().map(deep_clone),
+            ),
+            mathml_annotation_xml_integration_point: *mathml_annotation_xml_integration_point,
+        },
+        NodeData::Text { contents } => NodeData::Text {
+            contents: std::cell::RefCell::new(contents.borrow().clone()),
+        },
+        NodeData::Comment { contents } => NodeData::Comment {
+            contents: contents.clone(),
+        },
+        NodeData::Document | NodeData::Doctype { .. } | NodeData::ProcessingInstruction { .. } => {
+            unreachable!("an option holds elements, text and comments only")
+        }
+    };
+    let copy = markup5ever_rcdom::Node::new(data);
+    for child in node.children.borrow().iter() {
+        append_handle(&copy, deep_clone(child));
+    }
+    copy
+}
+
 /// Parse a full HTML document. Always yields a Document root (nodeType 9).
 #[must_use]
 pub fn parse_html_document(html: &str) -> Node {
-    let dom = parse_document(RcDom::default(), opts())
-        .from_utf8()
-        .read_from(&mut html.as_bytes())
-        .expect("RcDom read_from is infallible over a byte slice");
+    let dom = parse_document_dom(html, opts());
     walk(&dom.document)
 }
 
@@ -115,6 +300,11 @@ pub struct Soa {
     pub strings: Vec<String>,     // text/comment/doctype data, pooled
 }
 
+/// Why the marshalers have no processing-instruction arm: `markup5ever_rcdom` builds a
+/// `NodeData::ProcessingInstruction` only from `TreeSink::create_pi`, which html5ever 0.39's
+/// tree builder never calls (only xml5ever does); HTML's `<?x?>` is a bogus comment.
+const NO_PI: &str = "html5ever never creates a processing instruction";
+
 struct SoaBuilder {
     soa: Soa,
     tag_map: rustc_hash::FxHashMap<String, u32>,
@@ -204,11 +394,7 @@ impl SoaBuilder {
                 self.soa.node_type[idx] = COMMENT_NODE;
                 self.soa.text_id[idx] = self.push_string(contents);
             }
-            NodeData::ProcessingInstruction { target, contents } => {
-                self.soa.node_type[idx] = PROCESSING_INSTRUCTION_NODE;
-                self.soa.tag_id[idx] = self.intern_tag(target);
-                self.soa.text_id[idx] = self.push_string(contents);
-            }
+            NodeData::ProcessingInstruction { .. } => unreachable!("{NO_PI}"),
             NodeData::Element {
                 name,
                 attrs,
@@ -267,6 +453,7 @@ impl SoaBuilder {
             }
             if parent >= 0 {
                 let previous = last_child[parent as usize];
+                // (-1: no child yet; index 0 is the root, never anyone's child)
                 if previous < 0 {
                     self.soa.first_child[parent as usize] = index;
                 } else {
@@ -294,10 +481,7 @@ pub fn parse_html_soa(html: &str) -> Soa {
 /// Parse once and retain html5ever's document compatibility mode.
 #[must_use]
 pub fn parse_html_soa_with_compat_mode(html: &str) -> (Soa, &'static str) {
-    let dom = parse_document(RcDom::default(), opts())
-        .from_utf8()
-        .read_from(&mut html.as_bytes())
-        .expect("RcDom read_from is infallible over a byte slice");
+    let dom = parse_document_dom(html, opts());
     let mut b = SoaBuilder {
         soa: Soa::default(),
         // pre-reserve typical intern-table sizes so the build loop doesn't rehash:
@@ -329,10 +513,7 @@ pub fn parse_html_soa_with_compat_mode(html: &str) -> (Soa, &'static str) {
 /// marshaling. Isolates raw html5ever parse cost from tree-build + boundary cost.
 #[must_use]
 pub fn parse_html_document_count(html: &str) -> u32 {
-    let dom = parse_document(RcDom::default(), opts())
-        .from_utf8()
-        .read_from(&mut html.as_bytes())
-        .expect("RcDom read_from is infallible over a byte slice");
+    let dom = parse_document_dom(html, opts());
     count(&dom.document)
 }
 
@@ -372,14 +553,50 @@ pub fn parse_html_fragment_in(html: &str, context_ns: &str, context_local: &str)
         "math" => ns!(mathml),
         _ => ns!(html),
     };
+    // Chrome 156 drops a literal U+0000 in an RCDATA-context (textarea / title) fragment,
+    // where html5ever emits U+FFFD (miaskiewicz/turbo-dom#92). The whole input is text there
+    // and U+0000 only ends a character reference, so each NUL-free segment is parsed alone
+    // and the texts joined (the same rule as the rtdom crate's core).
+    if ns == ns!(html) && matches!(context_local, "textarea" | "title") && html.contains('\0') {
+        let value: String = html
+            .split('\0')
+            .flat_map(|segment| parse_html_fragment_in(segment, context_ns, context_local).children)
+            .map(|text| text.value)
+            .collect();
+        let text = (!value.is_empty()).then(|| Node {
+            node_type: TEXT_NODE,
+            name: "#text".to_string(),
+            value,
+            namespace: String::new(),
+            public_id: String::new(),
+            system_id: String::new(),
+            attrs: Vec::new(),
+            children: Vec::new(),
+        });
+        return fragment_root(text.into_iter().collect());
+    }
     let ctx = QualName::new(None, ns, LocalName::from(context_local));
     let dom = parse_fragment(RcDom::default(), opts(), ctx, vec![], false)
         .from_utf8()
         .read_from(&mut html.as_bytes())
         .expect("RcDom read_from is infallible over a byte slice");
-    // parse_fragment wraps results under a synthetic <html> element; unwrap it.
+    if mentions_selectedcontent(html) {
+        fill_selectedcontent(&dom.document);
+    }
+    // parse_fragment wraps results under a synthetic <html> element, the Document's only
+    // child: in the fragment case nothing is inserted into the Document itself (its comment
+    // inserts are the "after after body / frameset" modes, entered only from `</html>` in
+    // "after body" — ignored when fragment parsing — and from "after frameset", which
+    // `</frameset>` never enters when fragment parsing).
     let root = walk(&dom.document);
-    let mut frag = Node {
+    let [html] =
+        <[Node; 1]>::try_from(root.children).expect("a parsed fragment has one <html> root");
+    fragment_root(html.children)
+}
+
+/// The synthetic root a fragment parse returns (nodeType 9, `#document-fragment`).
+fn fragment_root(children: Vec<Node>) -> Node {
+    Node {
         node_type: DOCUMENT_NODE,
         name: "#document-fragment".to_string(),
         value: String::new(),
@@ -387,16 +604,8 @@ pub fn parse_html_fragment_in(html: &str, context_ns: &str, context_local: &str)
         public_id: String::new(),
         system_id: String::new(),
         attrs: Vec::new(),
-        children: Vec::new(),
-    };
-    for child in root.children {
-        if child.node_type == ELEMENT_NODE && child.name == "html" {
-            frag.children.extend(child.children);
-        } else {
-            frag.children.push(child);
-        }
+        children,
     }
-    frag
 }
 
 fn shallow_node(handle: &Handle) -> Node {
@@ -440,13 +649,7 @@ fn shallow_node(handle: &Handle) -> Node {
             String::new(),
             Vec::new(),
         ),
-        NodeData::ProcessingInstruction { target, contents } => (
-            PROCESSING_INSTRUCTION_NODE,
-            target.to_string(),
-            contents.to_string(),
-            String::new(),
-            Vec::new(),
-        ),
+        NodeData::ProcessingInstruction { .. } => unreachable!("{NO_PI}"),
         NodeData::Element { name, attrs, .. } => {
             let a = attrs
                 .borrow()
@@ -528,14 +731,8 @@ fn walk(handle: &Handle) -> Node {
     complete.pop().expect("one parsed root")
 }
 
-/// Drain nested parser intermediates without recursive destructor calls.
-/// This leaves the public marshaled Node representation unchanged.
-pub fn discard_node(mut root: Node) {
-    let mut pending = std::mem::take(&mut root.children);
-    while let Some(mut node) = pending.pop() {
-        pending.append(&mut node.children);
-    }
-}
+#[cfg(test)]
+mod conformance_tests;
 
 #[cfg(test)]
 mod tests {
@@ -613,6 +810,152 @@ mod tests {
         assert_eq!(content.children[0].value, "Hello");
     }
 
+    #[test]
+    fn rcdata_fragments_drop_nul_like_chrome() {
+        // miaskiewicz/turbo-dom#92 (Chrome 156): a literal U+0000 is dropped, &#0; is U+FFFD
+        let text = |html: &str, ctx: &str| {
+            let frag = parse_html_fragment_context(html, ctx);
+            assert_eq!(
+                (frag.node_type, frag.name.as_str(), frag.value.as_str()),
+                (DOCUMENT_NODE, "#document-fragment", "")
+            );
+            frag.children
+                .iter()
+                .map(|c| (c.node_type, c.value.clone()))
+                .collect::<Vec<_>>()
+        };
+        assert_eq!(
+            text("a\0b</textarea>c\0d", "textarea"),
+            [(TEXT_NODE, "ab</textarea>cd".into())]
+        );
+        assert_eq!(
+            text("x&am\0p;&not\0in;", "title"),
+            [(TEXT_NODE, "x&amp;\u{ac}in;".into())]
+        );
+        assert_eq!(
+            text("a&#0;b", "textarea"),
+            [(TEXT_NODE, "a\u{fffd}b".into())]
+        );
+        assert_eq!(text("\0", "title"), []);
+        // other contexts keep html5ever's answer (data state: dropped; RAWTEXT: U+FFFD)
+        assert_eq!(text("a\0b", "style"), [(TEXT_NODE, "a\u{fffd}b".into())]);
+        assert_eq!(text("a\0b", "div"), [(TEXT_NODE, "ab".into())]);
+        assert_eq!(text("a\0b", "svg title"), [(TEXT_NODE, "ab".into())]);
+    }
+
+    #[test]
+    fn fragment_context_strings_pick_namespace_and_element() {
+        let dump = |html: &str, ctx: &str| {
+            conformance_tests::dump_node(&parse_html_fragment_context(html, ctx))
+        };
+        // body context ("" too): a stray <td> is dropped, its text kept
+        assert_eq!(dump("<td>x", ""), "| \"x\"");
+        assert_eq!(dump("<td>x", "body"), "| \"x\"");
+        // a <tr> context (bare, or with any prefix other than svg / math: an HTML element)
+        let cell = "| <td>\n|   \"x\"";
+        assert_eq!(dump("<td>x", "tr"), cell);
+        assert_eq!(dump("<td>x", "html tr"), cell);
+        // foreign contexts: <mi> stays SVG under svg, is HTML in a MathML text
+        // integration point (<ms>), and MathML under math <math>
+        assert_eq!(dump("<mi/>", "svg path"), "| <svg mi>");
+        assert_eq!(dump("<mi/>", "math ms"), "| <mi>");
+        assert_eq!(dump("<mi/>", "math math"), "| <math mi>");
+        let frag = parse_html_fragment("<b>y</b>");
+        assert_eq!(
+            (frag.node_type, frag.name.as_str(), frag.children.len()),
+            (DOCUMENT_NODE, "#document-fragment", 1)
+        );
+        assert_eq!(conformance_tests::dump_node(&frag), "| <b>\n|   \"y\"");
+    }
+
+    #[test]
+    fn soa_interns_names_values_and_prefixes_once() {
+        let soa =
+            parse_html_soa("<p class=a></p><p class=a id=b></p><svg><a xlink:href=b></a></svg>");
+        assert_eq!(
+            soa.tag_names,
+            ["html", "head", "body", "p", "svg", "a"].map(String::from)
+        );
+        assert_eq!(soa.attr_names, ["class", "id", "href"].map(String::from));
+        assert_eq!(soa.attr_values, ["a", "b"].map(String::from));
+        assert_eq!(soa.attr_prefixes, ["", "xlink"].map(String::from));
+        assert_eq!(soa.attr_name_id, [0, 0, 1, 2]);
+        assert_eq!(soa.attr_value_id, [0, 0, 1, 1]);
+        assert_eq!(soa.attr_prefix_id, [0, 0, 0, 1]);
+        // document, html, head, body, p, p, svg, a
+        assert_eq!(soa.node_type, [9, 1, 1, 1, 1, 1, 1, 1]);
+        assert_eq!(soa.ns, [0, 0, 0, 0, 0, 0, 1, 1]);
+        assert_eq!(soa.tag_id, [0, 0, 1, 2, 3, 3, 4, 5]);
+        assert_eq!(soa.parent, [-1, 0, 1, 1, 3, 3, 3, 6]);
+        assert_eq!(soa.first_child, [1, 2, -1, 4, -1, -1, 7, -1]);
+        assert_eq!(soa.next_sib, [-1, -1, 3, -1, 5, 6, -1, -1]);
+        assert_eq!(soa.attr_start, [-1, -1, -1, -1, 0, 1, -1, 3]);
+        assert_eq!(soa.attr_count, [0, 0, 0, 0, 1, 2, 0, 1]);
+        assert_eq!(soa.text_id, [-1; 8]);
+        assert_eq!(soa.strings.len(), 0);
+    }
+
+    #[test]
+    fn soa_strings_doctype_text_comment_and_template_content() {
+        let (soa, mode) = parse_html_soa_with_compat_mode(
+            "<!DOCTYPE html PUBLIC \"p\" \"s\"><!--c--><template>t</template>",
+        );
+        assert_eq!(mode, "CSS1Compat");
+        // document, doctype, comment, html, head, template, content, "t", body
+        assert_eq!(soa.node_type, [9, 10, 8, 1, 1, 1, 11, 3, 1]);
+        assert_eq!(soa.strings, ["html", "p", "s", "c", "t"].map(String::from));
+        assert_eq!(soa.text_id, [-1, 0, 3, -1, -1, -1, -1, 4, -1]);
+        assert_eq!(soa.pub_id, [-1, 1, -1, -1, -1, -1, -1, -1, -1]);
+        assert_eq!(soa.sys_id, [-1, 2, -1, -1, -1, -1, -1, -1, -1]);
+        assert_eq!(soa.tag_names[soa.tag_id[6] as usize], "content");
+        assert_eq!(soa.parent[6..8], [5, 6]);
+        assert_eq!(soa.first_child[5], 6);
+        assert_eq!(parse_html_soa_with_compat_mode("<p>").1, "BackCompat");
+        assert_eq!(parse_html_document_count("<!--c--><p>x"), 7);
+    }
+
+    #[test]
+    fn selectedcontent_skips_options_in_a_nested_optgroup() {
+        // Chrome 156 (headless DOMParser, recorded for this test): an option below a second
+        // optgroup is not one of the select's options, so the next option fills
+        // <selectedcontent>; Chrome's tree is the same and its innerHTML is "b".
+        let html = "<select><optgroup><div><optgroup><option>a</option></optgroup></div></optgroup>\
+                    <option>b</option><button><selectedcontent></selectedcontent></button></select>";
+        let want = "| <html>\n|   <head>\n|   <body>\n|     <select>\n|       <optgroup>\n\
+                    |         <div>\n|           <optgroup>\n|             <option>\n\
+                    |               \"a\"\n|       <option>\n|         \"b\"\n|       <button>\n\
+                    |         <selectedcontent>\n|           \"b\"";
+        assert_eq!(
+            conformance_tests::dump_node(&parse_html_document(html)),
+            want
+        );
+        assert_eq!(conformance_tests::dump_soa(&parse_html_soa(html)), want);
+    }
+
+    #[test]
+    fn selectedcontent_inside_an_option_is_not_filled() {
+        // Chrome 156 (headless DOMParser): a <selectedcontent> inside the option it would
+        // copy keeps its (empty) content instead of receiving a clone of the option.
+        let html = "<select><option>a<selectedcontent></selectedcontent></option></select>";
+        let want = "| <html>\n|   <head>\n|   <body>\n|     <select>\n|       <option>\n\
+                    |         \"a\"\n|         <selectedcontent>";
+        assert_eq!(
+            conformance_tests::dump_node(&parse_html_document(html)),
+            want
+        );
+        assert_eq!(conformance_tests::dump_soa(&parse_html_soa(html)), want);
+    }
+
+    #[test]
+    fn mentions_selectedcontent_is_an_ascii_case_insensitive_substring_test() {
+        assert!(mentions_selectedcontent("selectedcontent"));
+        assert!(mentions_selectedcontent("<b></b><SelectedContent>"));
+        assert!(mentions_selectedcontent("xSELECTEDCONTENTx"));
+        assert!(!mentions_selectedcontent("selectedconten"));
+        assert!(!mentions_selectedcontent("<select><option>"));
+        assert!(!mentions_selectedcontent(""));
+    }
+
     #[test]
     fn fragment_context_namespace() {
         let frag = parse_html_fragment_context("<rect/>", "svg path");

package/src/lib.rs

@@ -55,7 +55,11 @@ mod napi_front {
                 attrs: n
                     .attrs
                     .into_iter()
-                    .map(|a| JsAttr { name: a.name, value: a.value, prefix: a.prefix })
+                    .map(|a| JsAttr {
+                        name: a.name,
+                        value: a.value,
+                        prefix: a.prefix,
+                    })
                     .collect(),
                 children: n.children.into_iter().map(JsNode::from).collect(),
             }
@@ -105,25 +109,54 @@ mod napi_front {
             let n = s.node_type.len();
             let m = s.attr_name_id.len();
             let mut buf: Vec<u8> = Vec::with_capacity(36 * n + 12 * m);
-            for col in [&s.tag_id] { for v in col { buf.extend_from_slice(&v.to_le_bytes()); } }
-            for col in [&s.parent, &s.first_child, &s.next_sib, &s.text_id, &s.pub_id, &s.sys_id, &s.attr_start] {
-                for v in col { buf.extend_from_slice(&v.to_le_bytes()); }
+            for col in [&s.tag_id] {
+                for v in col {
+                    buf.extend_from_slice(&v.to_le_bytes());
+                }
+            }
+            for col in [
+                &s.parent,
+                &s.first_child,
+                &s.next_sib,
+                &s.text_id,
+                &s.pub_id,
+                &s.sys_id,
+                &s.attr_start,
+            ] {
+                for v in col {
+                    buf.extend_from_slice(&v.to_le_bytes());
+                }
             }
             for col in [&s.attr_name_id, &s.attr_value_id, &s.attr_prefix_id] {
-                for v in col { buf.extend_from_slice(&v.to_le_bytes()); }
+                for v in col {
+                    buf.extend_from_slice(&v.to_le_bytes());
+                }
+            }
+            for v in &s.attr_count {
+                buf.extend_from_slice(&v.to_le_bytes());
             }
-            for v in &s.attr_count { buf.extend_from_slice(&v.to_le_bytes()); }
             buf.extend_from_slice(&s.node_type);
             buf.extend_from_slice(&s.ns);
             // pack all five string tables into one byte blob + meta (5 counts, then
             // per-string byte lengths in table order). Zero napi string conversion.
-            let tables: [&Vec<String>; 5] =
-                [&s.tag_names, &s.attr_names, &s.attr_prefixes, &s.attr_values, &s.strings];
+            let tables: [&Vec<String>; 5] = [
+                &s.tag_names,
+                &s.attr_names,
+                &s.attr_prefixes,
+                &s.attr_values,
+                &s.strings,
+            ];
             let total_strs: usize = tables.iter().map(|t| t.len()).sum();
-            let total_bytes: usize = tables.iter().flat_map(|t| t.iter()).map(std::string::String::len).sum();
+            let total_bytes: usize = tables
+                .iter()
+                .flat_map(|t| t.iter())
+                .map(std::string::String::len)
+                .sum();
             let mut str_blob: Vec<u8> = Vec::with_capacity(total_bytes);
             let mut str_meta: Vec<u32> = Vec::with_capacity(5 + total_strs);
-            for t in &tables { str_meta.push(t.len() as u32); }
+            for t in &tables {
+                str_meta.push(t.len() as u32);
+            }
             for t in &tables {
                 for x in *t {
                     str_meta.push(x.len() as u32);

package/src/runtime/buffer.mjs

@@ -72,7 +72,6 @@ export class Buffer {
   nodeType(i) { return this.soa.nodeType[i]; }
   ns(i) { return NS_SHORT[this.soa.ns[i]] || ''; }
   tagName(i) { return this.soa.tagNames[this.soa.tagId[i]]; }
-  parent(i) { return this.soa.parent[i]; }
   firstChild(i) { return this.soa.firstChild[i]; }
   nextSib(i) { return this.soa.nextSib[i]; }
   text(i) { const t = this.soa.textId[i]; return t < 0 ? '' : this.soa.strings[t]; }