rusteerio 1.1.1 → 1.1.3

package/dist/slim.d.mts

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

package/dist/slim.d.ts

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

package/dist/slim.mjs

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

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

@@ -2,6 +2,16 @@ import * as node_querystring from 'node:querystring';
 import * as node_stream from 'node:stream';
 import * as node_buffer from 'node:buffer';
 
+/**
+ * The compact record copy returned by `NativeDocument.snapshot()`: the
+ * lengths of the node, child, attribute and string lists, whether any string
+ * holds codec escapes, then the lists.
+ */
+interface NativeSnapshot {
+    data: Uint32Array;
+    text: string;
+}
+
 interface NativeDocument {
     readonly nodeSpace?: object;
     retainNode?(id: number): void;
@@ -17,6 +27,8 @@ interface NativeDocument {
     tagName(id: number): string | undefined | null;
     exportTree(): string;
     rootId(): number;
+    takePreparedPlans?(): (string | null)[] | null;
+    takePreparedSnapshot?(isWanted: boolean): NativeSnapshot | null;
     parserDiagnostics?(): string;
 }
 interface NativeWorkerPoolInfo {

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

@@ -2,6 +2,16 @@ import * as node_querystring from 'node:querystring';
 import * as node_stream from 'node:stream';
 import * as node_buffer from 'node:buffer';
 
+/**
+ * The compact record copy returned by `NativeDocument.snapshot()`: the
+ * lengths of the node, child, attribute and string lists, whether any string
+ * holds codec escapes, then the lists.
+ */
+interface NativeSnapshot {
+    data: Uint32Array;
+    text: string;
+}
+
 interface NativeDocument {
     readonly nodeSpace?: object;
     retainNode?(id: number): void;
@@ -17,6 +27,8 @@ interface NativeDocument {
     tagName(id: number): string | undefined | null;
     exportTree(): string;
     rootId(): number;
+    takePreparedPlans?(): (string | null)[] | null;
+    takePreparedSnapshot?(isWanted: boolean): NativeSnapshot | null;
     parserDiagnostics?(): string;
 }
 interface NativeWorkerPoolInfo {

package/dist/utils.d.mts

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

package/dist/utils.d.ts

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

package/native/src/arena.rs

@@ -17,7 +17,7 @@ pub(crate) struct DomNode {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub data: Option<String>,
     #[serde(default)]
-    pub attribs: Map<String, Value>,
+    pub attribs: FieldMap,
     #[serde(default)]
     pub children: Vec<u32>,
     #[serde(default)]
@@ -43,7 +43,94 @@ pub(crate) struct DomNode {
     )]
     pub attribs_prefix: Option<Box<Map<String, Value>>>,
     #[serde(flatten)]
-    pub extras: Map<String, Value>,
+    pub extras: FieldMap,
+}
+
+/// A string-keyed map that most nodes leave empty, boxed so that an empty
+/// one costs a pointer instead of a whole map in every node.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct FieldMap(Option<Box<Map<String, Value>>>);
+
+static EMPTY_FIELDS: std::sync::LazyLock<Map<String, Value>> = std::sync::LazyLock::new(Map::new);
+
+impl std::ops::Deref for FieldMap {
+    type Target = Map<String, Value>;
+    fn deref(&self) -> &Self::Target {
+        self.0.as_deref().unwrap_or(&EMPTY_FIELDS)
+    }
+}
+
+impl std::ops::DerefMut for FieldMap {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.0.get_or_insert_with(Box::default)
+    }
+}
+
+impl From<Map<String, Value>> for FieldMap {
+    fn from(map: Map<String, Value>) -> Self {
+        Self((!map.is_empty()).then(|| Box::new(map)))
+    }
+}
+
+/// Removals and lookups for writing leave an empty map unallocated; other
+/// writes go through `DerefMut`, which allocates it.
+impl FieldMap {
+    pub(crate) fn into_map(self) -> Map<String, Value> {
+        self.0.map_or_else(Map::new, |map| *map)
+    }
+
+    pub(crate) fn get_mut(&mut self, key: &str) -> Option<&mut Value> {
+        self.0.as_mut()?.get_mut(key)
+    }
+
+    pub(crate) fn remove(&mut self, key: &str) -> Option<Value> {
+        self.0.as_mut()?.remove(key)
+    }
+
+    pub(crate) fn shift_remove(&mut self, key: &str) -> Option<Value> {
+        self.0.as_mut()?.shift_remove(key)
+    }
+}
+
+impl<'a> IntoIterator for &'a FieldMap {
+    type Item = (&'a String, &'a Value);
+    type IntoIter = serde_json::map::Iter<'a>;
+    fn into_iter(self) -> Self::IntoIter {
+        (**self).iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a mut FieldMap {
+    type Item = (&'a String, &'a mut Value);
+    type IntoIter = serde_json::map::IterMut<'a>;
+    fn into_iter(self) -> Self::IntoIter {
+        (**self).iter_mut()
+    }
+}
+
+impl IntoIterator for FieldMap {
+    type Item = (String, Value);
+    type IntoIter = serde_json::map::IntoIter;
+    fn into_iter(self) -> Self::IntoIter {
+        self.into_map().into_iter()
+    }
+}
+
+impl Serialize for FieldMap {
+    fn serialize<S: serde::Serializer>(
+        &self,
+        serializer: S,
+    ) -> std::result::Result<S::Ok, S::Error> {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for FieldMap {
+    fn deserialize<D: serde::Deserializer<'de>>(
+        deserializer: D,
+    ) -> std::result::Result<Self, D::Error> {
+        Map::deserialize(deserializer).map(Self::from)
+    }
 }
 
 fn root_kind() -> Cow<'static, str> {
@@ -90,7 +177,7 @@ impl DomNode {
             kind: kind.into(),
             name: None,
             data: None,
-            attribs: Map::new(),
+            attribs: FieldMap::default(),
             children: Vec::new(),
             parent: None,
             prev: None,
@@ -98,7 +185,7 @@ impl DomNode {
             namespace: None,
             attribs_namespace: None,
             attribs_prefix: None,
-            extras: Map::new(),
+            extras: FieldMap::default(),
         }
     }
     pub(crate) fn is_element(&self) -> bool {
@@ -722,7 +809,10 @@ impl DomArena {
     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() {
+            // As Cheerio, only nodes that can hold children are targets.
+            if !self.node(*target).is_some_and(|node| {
+                node.is_element() || matches!(node.kind.as_ref(), "root" | "cdata")
+            }) {
                 continue;
             }
             if matches!(position, "append" | "prepend")
@@ -885,7 +975,7 @@ impl DomArena {
             "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 = node_kind(value.as_str().unwrap_or("tag")),
-            "attribs" => node.attribs = value.as_object().cloned().unwrap_or_default(),
+            "attribs" => node.attribs = value.as_object().cloned().unwrap_or_default().into(),
             "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),
@@ -1131,6 +1221,72 @@ pub(crate) fn append_parsed(
     id
 }
 
+/// Appends a fresh node of `kind` to `parent` and returns its id. The record
+/// is built in the arena itself: moving a whole record through the callers
+/// copied it several times per node.
+pub(crate) fn append_parsed_new(
+    arena: &mut DomArena,
+    parent: u32,
+    kind: &'static str,
+    start: usize,
+    end: usize,
+) -> u32 {
+    let (start_indices, end_indices) = parse_index_flags(arena);
+    let previous = arena.nodes[parent as usize].children.last().copied();
+    let id = arena.push(DomNode::new(kind));
+    let node = &mut arena.nodes[id as usize];
+    node.parent = Some(parent);
+    node.prev = previous;
+    if start_indices {
+        node.extras.insert("startIndex".into(), json!(start));
+    }
+    if end_indices {
+        node.extras.insert("endIndex".into(), json!(end));
+    }
+    if let Some(previous) = previous {
+        arena.nodes[previous as usize].next = Some(id);
+    }
+    arena.nodes[parent as usize].children.push(id);
+    id
+}
+
+/// Whether parsing records start and end indices, read once per parse.
+fn parse_index_flags(arena: &mut DomArena) -> (bool, bool) {
+    *arena.parse_indices.get_or_insert_with(|| {
+        (
+            arena.options.get("withStartIndices") == Some(&Value::Bool(true)),
+            arena.options.get("withEndIndices") == Some(&Value::Bool(true)),
+        )
+    })
+}
+
+/// Appends parsed text to `parent`, merging it into a preceding text node.
+pub(crate) fn append_parsed_text(
+    arena: &mut DomArena,
+    parent: u32,
+    data: String,
+    start: usize,
+    end: usize,
+) -> u32 {
+    let previous_text = arena.nodes[parent as usize]
+        .children
+        .last()
+        .copied()
+        .filter(|id| arena.nodes[*id as usize].kind == "text");
+    if let Some(previous) = previous_text {
+        let (_, end_indices) = parse_index_flags(arena);
+        let node = &mut arena.nodes[previous as usize];
+        node.data.get_or_insert_with(String::new).push_str(&data);
+        if end_indices {
+            node.extras.insert("endIndex".into(), json!(end));
+        }
+        return previous;
+    }
+    let id = append_parsed_new(arena, parent, "text", start, end);
+    arena.nodes[id as usize].data = Some(data);
+    id
+}
+
 pub(crate) fn html_parser_void(name: &str) -> bool {
     (super::void_name(name) && name != "bgsound") || matches!(name, "command" | "isindex")
 }
@@ -1297,7 +1453,7 @@ pub(crate) fn primitive(arena: &mut DomArena, command: &str, args: &Value) -> Re
                 Value::Object(
                     arena
                         .node(id)
-                        .map(|node| node.attribs.clone())
+                        .map(|node| (*node.attribs).clone())
                         .unwrap_or_default(),
                 )
             }

package/native/src/attributes.rs

@@ -94,7 +94,7 @@ fn get_attr(arena: &DomArena, id: u32, name: &str) -> Value {
         return Value::Null;
     };
     if name.is_empty() {
-        return Value::Object(node.attribs.clone());
+        return Value::Object((*node.attribs).clone());
     }
     if let Some(value) = node.attribs.get(name) {
         return if !arena.xml_mode() && boolean_attribute(name) {
@@ -570,6 +570,23 @@ fn encode_component(value: &str, encoded: bool) -> Result<String, ()> {
     Ok(output)
 }
 
+pub(crate) fn keeps_element_names(command: &str) -> bool {
+    matches!(
+        command,
+        "attr"
+            | "removeAttr"
+            | "css"
+            | "data"
+            | "removeData"
+            | "hasClass"
+            | "addClass"
+            | "removeClass"
+            | "toggleClass"
+            | "serializeArray"
+            | "serialize"
+    )
+}
+
 pub(crate) fn execute(
     arena: &mut DomArena,
     command: &str,

package/native/src/codec.rs

@@ -1,7 +1,86 @@
 //! Lossless JavaScript UTF-16 over valid Rust strings. Ordinary Unicode keeps
 //! its original representation; lone surrogates use BMP private-use frames.
+use napi::{Env, JsString, NapiRaw};
 use serde_json::Value;
 
+/// A string returned to JavaScript. V8 decodes UTF-8 slowly, so text is
+/// handed over as Latin-1 when every character fits, which also keeps V8's
+/// compact one-byte string, and as UTF-16 otherwise.
+pub struct JsText(pub String);
+
+impl napi::bindgen_prelude::ToNapiValue for JsText {
+    unsafe fn to_napi_value(
+        env: napi::sys::napi_env,
+        value: Self,
+    ) -> napi::Result<napi::sys::napi_value> {
+        Ok(js_string(&Env::from_raw(env), &value.0)?.raw())
+    }
+}
+
+pub(crate) fn js_string(env: &Env, text: &str) -> napi::Result<JsString> {
+    if text.is_ascii() {
+        env.create_string_latin1(text.as_bytes())
+    } else if let Some(latin1) = latin1_bytes(text) {
+        env.create_string_latin1(&latin1)
+    } else {
+        env.create_string_utf16(&utf16_units(text))
+    }
+}
+
+/// `text` in Latin-1, if every character is below U+0100: UTF-8 encodes
+/// those with lead bytes below 0xC4.
+pub(crate) 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.
+pub(crate) 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);
+        }
+        index += length;
+    }
+    units
+}
+
 pub(crate) const ESCAPE: char = '\u{e800}';
 pub(crate) fn is_reserved(ch: char) -> bool {
     ('\u{e000}'..=ESCAPE).contains(&ch)