rusteerio 1.1.1 → 1.1.3

package/native/src/lib.rs

@@ -14,6 +14,8 @@ use napi_derive::napi;
 use scraper::{Html, Node, Selector};
 use serde_json::{Map, Value};
 
+use codec::JsText;
+
 #[cfg(target_os = "linux")]
 #[global_allocator]
 static ALLOCATOR: mimalloc::MiMalloc = mimalloc::MiMalloc;
@@ -158,6 +160,11 @@ pub struct NativeDocument {
     // unreachable documents under native memory pressure.
     content_bytes: Cell<usize>,
     reported_heap_bytes: Cell<i64>,
+    /// Results of extraction plans run on the parsing thread, in request
+    /// order, until JavaScript takes them.
+    prepared_plans: RefCell<Option<Vec<Option<String>>>>,
+    /// A snapshot built on the parsing thread, until JavaScript takes it.
+    prepared_snapshot: RefCell<Option<snapshot::NodeSnapshot>>,
 }
 
 /// Node-API calls the finalizers of a module that declares the experimental
@@ -259,6 +266,7 @@ impl NativeDocument {
         if arena.nodes.len() > POOL_RELEASE_NODES {
             runtime::start_release_thread();
         }
+        runtime::return_parse_pages(arena.nodes.len());
         Self {
             html: RefCell::new(None),
             ids: RefCell::new(Vec::new()),
@@ -279,6 +287,8 @@ impl NativeDocument {
             locations: RefCell::new(HashMap::new()),
             content_bytes: Cell::new(content_bytes),
             reported_heap_bytes: Cell::new(0),
+            prepared_plans: RefCell::new(None),
+            prepared_snapshot: RefCell::new(None),
         }
     }
     pub(crate) fn set_diagnostic_records(&self, records: Vec<Value>) {
@@ -507,6 +517,7 @@ impl NativeDocument {
         if ids.len() > POOL_RELEASE_NODES {
             runtime::start_release_thread();
         }
+        runtime::return_parse_pages(ids.len());
         Self {
             html: RefCell::new(Some(html)),
             ids: RefCell::new(ids),
@@ -527,6 +538,8 @@ impl NativeDocument {
             locations: RefCell::new(locations),
             content_bytes: Cell::new(content_bytes),
             reported_heap_bytes: Cell::new(0),
+            prepared_plans: RefCell::new(None),
+            prepared_snapshot: RefCell::new(None),
         }
     }
 
@@ -540,6 +553,14 @@ impl NativeDocument {
         arena
     }
 
+    /// The arena borrowed for a write that changes only attributes or data,
+    /// which keeps the name index valid.
+    pub(crate) fn arena_for_attribute_write(
+        &self,
+    ) -> std::cell::RefMut<'_, Option<arena::DomArena>> {
+        self.arena.borrow_mut()
+    }
+
     pub(crate) fn ensure_arena(&self) -> Result<()> {
         let missing = self.arena.borrow().is_none();
         if missing {
@@ -735,7 +756,9 @@ impl NativeDocument {
                 }
                 .into();
                 record.name = Some(element.name().into());
-                record.attribs = Map::with_capacity(element.attrs.len());
+                if !element.attrs.is_empty() {
+                    *record.attribs = Map::with_capacity(element.attrs.len());
+                }
                 for (name, value) in &element.attrs {
                     record
                         .attribs
@@ -775,7 +798,7 @@ impl NativeDocument {
             .map(|id| self.attribute_node(*id))
             .collect::<Option<_>>()?;
         let before: Vec<Map<String, Value>> =
-            nodes.iter().map(|node| node.attribs.clone()).collect();
+            nodes.iter().map(|node| (*node.attribs).clone()).collect();
         let mut scratch = arena::DomArena::from_records(nodes, options.clone());
         if self.options.get("__utf16Codec") == Some(&Value::Bool(true)) {
             scratch.options["__utf16Codec"] = Value::Bool(true);
@@ -795,7 +818,7 @@ impl NativeDocument {
         let node_ids = self.ids.borrow();
         for (index, id) in targets.iter().enumerate() {
             let after = &scratch.nodes[index].attribs;
-            if *after == before[index] {
+            if **after == before[index] {
                 continue;
             }
             let mut node = html.tree.get_mut(*node_ids.get(*id as usize)?)?;
@@ -1037,7 +1060,7 @@ impl NativeDocument {
             }
         }
         self.ensure_arena()?;
-        if let Some(arena) = self.arena_for_write().as_mut() {
+        if let Some(arena) = self.arena_for_attribute_write().as_mut() {
             arena.set_attr(&ids, &name, value.as_deref());
         }
         Ok(())
@@ -1293,14 +1316,46 @@ impl NativeDocument {
             .collect()
     }
 
-    #[napi]
+    /// The results of the extraction plans `parseManyAsync` ran on the
+    /// document's root while parsing it, each `null` if it failed; `null`
+    /// after the first call.
+    #[napi(
+        js_name = "takePreparedPlans",
+        ts_return_type = "Array<string | null> | null"
+    )]
+    pub fn take_prepared_plans(&self) -> Option<Vec<Option<JsText>>> {
+        self.prepared_plans.borrow_mut().take().map(|results| {
+            results
+                .into_iter()
+                .map(|result| result.map(JsText))
+                .collect()
+        })
+    }
+
+    /// The snapshot `parseManyAsync` built while parsing the document, if it
+    /// did; `null` after the first call, which discards it unless `is_wanted`.
+    /// It describes the parsed tree, so JavaScript discards it on its first write.
+    #[napi(js_name = "takePreparedSnapshot")]
+    pub fn take_prepared_snapshot(&self, env: Env, is_wanted: bool) -> Result<Option<Object>> {
+        let prepared = self.prepared_snapshot.borrow_mut().take();
+        match prepared {
+            Some(snapshot) if is_wanted => snapshot.into_js(&env).map(Some),
+            _ => Ok(None),
+        }
+    }
+
+    #[napi(js_name = "text", ts_return_type = "string")]
+    pub fn text_for_js(&self, ids: Vec<u32>) -> JsText {
+        JsText(self.text(ids))
+    }
+
     pub fn text(&self, ids: Vec<u32>) -> String {
         self.text_ids(&ids)
     }
 
-    #[napi(js_name = "innerHtml")]
-    pub fn inner_html_and_report(&self, env: Env, id: u32) -> String {
-        self.reported(env, self.inner_html(id))
+    #[napi(js_name = "innerHtml", ts_return_type = "string")]
+    pub fn inner_html_and_report(&self, env: Env, id: u32) -> JsText {
+        JsText(self.reported(env, self.inner_html(id)))
     }
 
     pub fn inner_html(&self, id: u32) -> String {
@@ -1312,20 +1367,24 @@ impl NativeDocument {
         self.serialize_nodes(&[id], true)
     }
 
-    #[napi]
+    #[napi(js_name = "outerHtml", ts_return_type = "string")]
+    pub fn outer_html_for_js(&self, ids: Vec<u32>) -> JsText {
+        JsText(self.outer_html(ids))
+    }
+
     pub fn outer_html(&self, ids: Vec<u32>) -> String {
         self.serialize_nodes(&ids, false)
     }
 
     /// Serializes nodes as the `render` command does, returning the markup
     /// itself rather than markup encoded as JSON.
-    #[napi(js_name = "render")]
+    #[napi(js_name = "render", ts_return_type = "string")]
     pub fn render_and_report(
         &self,
         env: Env,
         ids: Vec<u32>,
         options_json: Option<String>,
-    ) -> Result<String> {
+    ) -> Result<JsText> {
         self.maybe_collect();
         let overrides = match options_json {
             Some(json) => Some(serde_json::from_str::<Value>(&json).map_err(json_error)?),
@@ -1333,7 +1392,7 @@ impl NativeDocument {
         }
         .filter(Value::is_object);
         let rendered = self.render_nodes(&ids, overrides)?;
-        Ok(self.reported(env, rendered))
+        Ok(JsText(self.reported(env, rendered)))
     }
 
     fn render_nodes(&self, ids: &[u32], overrides: Option<Value>) -> Result<String> {
@@ -1364,7 +1423,11 @@ impl NativeDocument {
         Ok(arena.serialize(ids, &arena::normalized_options(options)))
     }
 
-    #[napi]
+    #[napi(js_name = "attr", ts_return_type = "string | null")]
+    pub fn attr_for_js(&self, id: u32, name: String) -> Option<JsText> {
+        self.attr(id, name).map(JsText)
+    }
+
     pub fn attr(&self, id: u32, name: String) -> Option<String> {
         self.attribute(id, &name)
     }
@@ -1382,9 +1445,9 @@ impl NativeDocument {
         .flatten()
     }
 
-    #[napi(js_name = "exportTree")]
-    pub fn export_tree_and_report(&self, env: Env) -> Result<String> {
-        self.reported(env, self.export_tree())
+    #[napi(js_name = "exportTree", ts_return_type = "string")]
+    pub fn export_tree_and_report(&self, env: Env) -> Result<JsText> {
+        self.reported(env, self.export_tree()).map(JsText)
     }
 
     pub fn export_tree(&self) -> Result<String> {
@@ -1412,9 +1475,9 @@ impl NativeDocument {
         built.into_js(&env)
     }
 
-    #[napi(js_name = "node")]
-    pub fn node_and_report(&self, env: Env, id: u32) -> Result<String> {
-        self.reported(env, self.node(id))
+    #[napi(js_name = "node", ts_return_type = "string")]
+    pub fn node_and_report(&self, env: Env, id: u32) -> Result<JsText> {
+        self.reported(env, self.node(id)).map(JsText)
     }
 
     pub fn node(&self, id: u32) -> Result<String> {
@@ -1563,9 +1626,9 @@ impl NativeDocument {
             .map_err(json_error)
     }
 
-    #[napi(js_name = "op")]
-    pub fn op_and_report(&self, env: Env, command: String, args_json: String) -> Result<String> {
-        self.reported(env, self.op(command, args_json))
+    #[napi(js_name = "op", ts_return_type = "string")]
+    pub fn op_and_report(&self, env: Env, command: String, args_json: String) -> Result<JsText> {
+        self.reported(env, self.op(command, args_json)).map(JsText)
     }
 
     pub fn op(&self, command: String, args_json: String) -> Result<String> {
@@ -1671,7 +1734,11 @@ impl NativeDocument {
             }
         }
         self.ensure_arena()?;
-        let mut arena = self.arena_for_write();
+        let mut arena = if attributes::keeps_element_names(&command) {
+            self.arena_for_attribute_write()
+        } else {
+            self.arena_for_write()
+        };
         let arena = arena.as_mut().unwrap();
         let previous_options = arena.options.clone();
         if let Some(options) = args.get("options").filter(|options| options.is_object()) {
@@ -2058,7 +2125,9 @@ fn convert_node(
                     .insert("prefix".into(), Value::String(String::from(&**prefix)));
             }
             let (mut namespaces, mut prefixes) = (Map::new(), Map::new());
-            record.attribs = Map::with_capacity(element.attrs.len());
+            if !element.attrs.is_empty() {
+                *record.attribs = Map::with_capacity(element.attrs.len());
+            }
             for (name, value) in &element.attrs {
                 let key = String::from(&*name.local);
                 if !name.ns.is_empty() {
@@ -2299,6 +2368,9 @@ pub struct ParseManyTask {
     is_document: bool,
     threads: usize,
     options: Value,
+    /// Extraction plans to run on each root after parsing; with them, each
+    /// document also gets its snapshot built on the parsing thread.
+    plans: Option<Vec<Value>>,
 }
 
 #[napi]
@@ -2308,12 +2380,24 @@ impl Task for ParseManyTask {
 
     fn compute(&mut self) -> Result<Self::Output> {
         runtime::parallel_map(&self.htmls, self.threads, |html| {
-            Ok(NativeDocument::parse_options(
-                html,
-                self.is_document,
-                self.options.clone(),
-                None,
-            ))
+            let document =
+                NativeDocument::parse_options(html, self.is_document, self.options.clone(), None);
+            if let Some(plans) = &self.plans {
+                let results = plans
+                    .iter()
+                    .map(|plan| {
+                        let args =
+                            serde_json::json!({"ids": [0], "plan": plan, "options": self.options});
+                        document.op("extractPlan".into(), args.to_string()).ok()
+                    })
+                    .collect();
+                *document.prepared_plans.borrow_mut() = Some(results);
+                // With source locations the snapshot is built from the mutable tree instead.
+                if document.source.borrow().is_none() {
+                    *document.prepared_snapshot.borrow_mut() = Some(snapshot::build(&document));
+                }
+            }
+            Ok(document)
         })
     }
 
@@ -2328,8 +2412,12 @@ pub fn parse_many_async(
     is_document: bool,
     threads: Option<u32>,
     options_json: Option<String>,
+    plans_json: Option<String>,
 ) -> Result<AsyncTask<ParseManyTask>> {
     let threads = thread_count(threads, htmls.len())?;
+    let plans = plans_json
+        .map(|json| serde_json::from_str(&json).map_err(json_error))
+        .transpose()?;
     Ok(AsyncTask::new(ParseManyTask {
         htmls,
         is_document,
@@ -2337,6 +2425,7 @@ pub fn parse_many_async(
         options: options_json
             .and_then(|value| serde_json::from_str(&value).ok())
             .unwrap_or_else(|| serde_json::json!({})),
+        plans,
     }))
 }
 

package/native/src/runtime.rs

@@ -183,6 +183,29 @@ static RELEASE_THREAD: OnceLock<mpsc::Sender<Box<dyn Send>>> = OnceLock::new();
 /// exists, so freeing large trees does not stall JavaScript. Documents large
 /// enough to be released later start it when they are created, because
 /// finalizers must not create threads.
+/// Trees with at least this many nodes return the parse's freed memory to
+/// the system once built.
+#[cfg(target_os = "linux")]
+const RETURN_PAGES_NODES: usize = 100_000;
+
+#[cfg(target_os = "linux")]
+extern "C" {
+    fn mi_collect(force: bool);
+}
+
+/// Building a large tree grows and then frees big buffers, such as a node
+/// vector that doubled several times. mimalloc keeps freed pages resident for
+/// reuse; after a large parse, return them on the parsing thread instead.
+pub(crate) fn return_parse_pages(nodes: usize) {
+    #[cfg(target_os = "linux")]
+    if nodes >= RETURN_PAGES_NODES {
+        // SAFETY: mimalloc's own collection frees only memory no block uses.
+        unsafe { mi_collect(true) };
+    }
+    #[cfg(not(target_os = "linux"))]
+    let _ = nodes;
+}
+
 pub(crate) fn start_release_thread() {
     RELEASE_THREAD.get_or_init(|| {
         let (sender, receiver) = mpsc::channel::<Box<dyn Send>>();

package/native/src/snapshot.rs

@@ -15,7 +15,7 @@
 //! which frees it as soon as the snapshot is collected; an external buffer
 //! would add finalizer bookkeeping and wait for a later event-loop turn.
 use html5ever::{LocalName, Namespace};
-use napi::{Env, JsObject, JsTypedArray, Result, TypedArrayType};
+use napi::{check_status, sys, Env, JsObject, JsTypedArray, NapiValue, Result};
 use scraper::Node;
 use serde_json::{Map, Value};
 
@@ -36,6 +36,17 @@ const EMPTY_ATTRIBUTE_MAPS: u32 = 8;
 /// The record cannot be represented here; JavaScript reads it individually.
 const OPAQUE: u32 = 16;
 const RELEASED: u32 = 32;
+const KINDS: [&str; 8] = [
+    "tag",
+    "text",
+    "comment",
+    "root",
+    "script",
+    "style",
+    "directive",
+    "cdata",
+];
+const SHORT_NAME_SLOTS: usize = 256;
 
 pub(crate) struct NodeSnapshot {
     is_encoded: bool,
@@ -58,90 +69,74 @@ impl NodeSnapshot {
             u32::from(self.is_encoded),
         ];
         let length = header.len() + parts.iter().map(|part| part.len()).sum::<usize>();
-        let mut buffer = env.create_arraybuffer(length * 4)?;
-        // SAFETY: every bit pattern is a valid `u32`; `align_to_mut` puts any
-        // misaligned bytes in the prefix, which is checked to be empty.
-        let (prefix, words, _) = unsafe { buffer.align_to_mut::<u32>() };
-        if !prefix.is_empty() || words.len() < length {
-            return Err(napi::Error::from_reason("Unaligned snapshot buffer"));
-        }
-        let mut offset = 0;
-        for part in std::iter::once(&header[..]).chain(parts.iter().map(|part| part.as_slice())) {
-            words[offset..offset + part.len()].copy_from_slice(part);
-            offset += part.len();
-        }
-        let data: JsTypedArray =
-            buffer
-                .into_raw()
-                .into_typedarray(TypedArrayType::Uint32, length, 0)?;
+        let data = uninitialized_words(env, length, |words| {
+            let mut offset = 0;
+            for part in std::iter::once(&header[..]).chain(parts.iter().map(|part| part.as_slice()))
+            {
+                words[offset..offset + part.len()].copy_from_slice(part);
+                offset += part.len();
+            }
+        })?;
         let mut object = env.create_object()?;
         object.set_named_property("data", data)?;
-        // V8 decodes UTF-8 slowly; text copies as Latin-1 when every
-        // character fits, which also keeps V8's compact one-byte string.
-        let text = if self.text.is_ascii() {
-            env.create_string_latin1(self.text.as_bytes())?
-        } else if let Some(latin1) = latin1_bytes(&self.text) {
-            env.create_string_latin1(&latin1)?
-        } else {
-            env.create_string_utf16(&utf16_units(&self.text))?
-        };
-        object.set_named_property("text", text)?;
+        object.set_named_property("text", crate::codec::js_string(env, &self.text)?)?;
         Ok(object)
     }
 }
 
-/// `text` in Latin-1, if every character is below U+0100: UTF-8 encodes
-/// those with lead bytes below 0xC4.
-fn latin1_bytes(text: &str) -> Option<Vec<u8>> {
-    if text.bytes().any(|byte| byte >= 0xC4) {
-        return None;
-    }
-    Some(text.chars().map(|character| character as u8).collect())
-}
-
-/// `text` as UTF-16, widening eight ASCII bytes at a time and decoding other
-/// characters directly from their UTF-8 bytes, which `text` guarantees valid.
-fn utf16_units(text: &str) -> Vec<u16> {
-    const HIGH_BITS: u64 = 0x8080_8080_8080_8080;
-    let bytes = text.as_bytes();
-    let mut units = Vec::with_capacity(bytes.len());
-    let mut index = 0;
-    while index < bytes.len() {
-        if let Some(chunk) = bytes.get(index..index + 8) {
-            let word = u64::from_le_bytes(chunk.try_into().unwrap());
-            if word & HIGH_BITS == 0 {
-                units.extend(chunk.iter().map(|byte| u16::from(*byte)));
-                index += 8;
-                continue;
-            }
-        }
-        let lead = u32::from(bytes[index]);
-        let continuation = |offset: usize| u32::from(bytes[index + offset] & 0x3F);
-        let (scalar, length) = match lead {
-            0x00..=0x7F => (lead, 1),
-            0x80..=0xDF => (((lead & 0x1F) << 6) | continuation(1), 2),
-            0xE0..=0xEF => (
-                ((lead & 0x0F) << 12) | (continuation(1) << 6) | continuation(2),
-                3,
-            ),
-            _ => (
-                ((lead & 0x07) << 18)
-                    | (continuation(1) << 12)
-                    | (continuation(2) << 6)
-                    | continuation(3),
-                4,
-            ),
-        };
-        if scalar < 0x1_0000 {
-            units.push(scalar as u16);
-        } else {
-            let offset = scalar - 0x1_0000;
-            units.push(0xD800 | (offset >> 10) as u16);
-            units.push(0xDC00 | (offset & 0x3FF) as u16);
+/// A `Uint32Array` of `length` words that `fill` writes. A Node buffer is
+/// used for its storage because, unlike an `ArrayBuffer`, it is not
+/// zero-filled first; `fill` writes every word before JavaScript can read it.
+fn uninitialized_words(
+    env: &Env,
+    length: usize,
+    fill: impl FnOnce(&mut [u32]),
+) -> Result<JsTypedArray> {
+    let raw_env = env.raw();
+    let mut buffer = std::ptr::null_mut();
+    let mut memory = std::ptr::null_mut();
+    // SAFETY: Node-API calls on the current environment with valid out
+    // pointers. `memory` is the buffer's own allocation of `length` words,
+    // checked to be aligned, and the buffer stays alive in this handle scope.
+    unsafe {
+        check_status!(sys::napi_create_buffer(
+            raw_env,
+            length * 4,
+            &mut memory,
+            &mut buffer
+        ))?;
+        let mut kind = 0;
+        let mut bytes = 0;
+        let mut view_memory = std::ptr::null_mut();
+        let mut arraybuffer = std::ptr::null_mut();
+        let mut byte_offset = 0;
+        check_status!(sys::napi_get_typedarray_info(
+            raw_env,
+            buffer,
+            &mut kind,
+            &mut bytes,
+            &mut view_memory,
+            &mut arraybuffer,
+            &mut byte_offset,
+        ))?;
+        if !byte_offset.is_multiple_of(4)
+            || !(memory as usize).is_multiple_of(4)
+            || bytes < length * 4
+        {
+            return Err(napi::Error::from_reason("Unaligned snapshot buffer"));
         }
-        index += length;
+        let mut words = std::ptr::null_mut();
+        check_status!(sys::napi_create_typedarray(
+            raw_env,
+            sys::TypedarrayType::uint32_array,
+            length,
+            arraybuffer,
+            byte_offset,
+            &mut words,
+        ))?;
+        fill(std::slice::from_raw_parts_mut(memory.cast::<u32>(), length));
+        Ok(JsTypedArray::from_raw_unchecked(raw_env, words))
     }
-    units
 }
 
 /// The UTF-16 length of `text`: one unit per character, two for characters
@@ -160,6 +155,11 @@ struct Builder {
     text: String,
     units: u32,
     interned: IdMap<String, u32>,
+    /// References of the common node types, resolved without hashing.
+    kinds: [Option<u32>; KINDS.len()],
+    /// Recently interned names of up to eight bytes, keyed by their bytes:
+    /// element and attribute names repeat across nodes.
+    short_names: Box<[(u64, u8, u32); SHORT_NAME_SLOTS]>,
     /// html5ever names are atoms that hash and compare by identity.
     local_names: IdMap<LocalName, u32>,
     namespaces: IdMap<Namespace, u32>,
@@ -179,6 +179,8 @@ pub(crate) fn build(document: &NativeDocument) -> NodeSnapshot {
         text: String::with_capacity(document.content_bytes.get()),
         units: 0,
         interned: IdMap::with_capacity_and_hasher(32, Default::default()),
+        kinds: [None; KINDS.len()],
+        short_names: Box::new([(0, 0, 0); SHORT_NAME_SLOTS]),
         local_names: IdMap::with_capacity_and_hasher(32, Default::default()),
         namespaces: IdMap::default(),
         codec,
@@ -245,6 +247,40 @@ impl Builder {
         (self.strings.len() / 2 - 1) as u32
     }
 
+    fn kind(&mut self, kind: &str) -> u32 {
+        let Some(slot) = KINDS.iter().position(|known| *known == kind) else {
+            return self.interned(kind);
+        };
+        if let Some(reference) = self.kinds[slot] {
+            return reference;
+        }
+        let reference = self.interned(kind);
+        self.kinds[slot] = Some(reference);
+        reference
+    }
+
+    fn interned_name(&mut self, name: &str) -> u32 {
+        let bytes = name.as_bytes();
+        if bytes.len() > 8 {
+            return self.interned(name);
+        }
+        let mut word = [0; 8];
+        word[..bytes.len()].copy_from_slice(bytes);
+        let key = u64::from_le_bytes(word);
+        let length = bytes.len() as u8;
+        let slot = (key
+            .wrapping_add(u64::from(length))
+            .wrapping_mul(0x9E37_79B9_7F4A_7C15)
+            >> 56) as usize;
+        let (cached_key, cached_length, cached) = self.short_names[slot];
+        if cached != 0 && cached_key == key && cached_length == length {
+            return cached - 1;
+        }
+        let reference = self.interned(name);
+        self.short_names[slot] = (key, length, reference + 1);
+        reference
+    }
+
     fn interned(&mut self, value: &str) -> u32 {
         if let Some(reference) = self.interned.get(value) {
             return *reference;
@@ -280,7 +316,7 @@ impl Builder {
 
     fn encode(&mut self, node: &DomNode) {
         let mut fields = [0; STRIDE];
-        fields[0] = self.interned(&node.kind);
+        fields[0] = self.kind(&node.kind);
         fields[1] = pointer(node.parent);
         fields[2] = pointer(node.prev);
         fields[3] = pointer(node.next);
@@ -290,7 +326,7 @@ impl Builder {
         fields[6] = node
             .name
             .as_deref()
-            .map_or(0, |name| self.interned(name) + 1);
+            .map_or(0, |name| self.interned_name(name) + 1);
         let mut flags = 0;
         match node.data.as_deref() {
             Some(data) if data.len() > LARGE_TEXT_BYTES => flags |= OPAQUE,
@@ -313,7 +349,7 @@ impl Builder {
                 flags |= OPAQUE;
                 break;
             };
-            let name = self.interned(name);
+            let name = self.interned_name(name);
             let value = self.string(value);
             self.attributes.extend_from_slice(&[name, value]);
         }
@@ -492,6 +528,7 @@ impl Builder {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::codec::{latin1_bytes, utf16_units};
 
     #[test]
     fn transcodes_text_like_the_standard_library() {