rusteerio 1.0.0 → 1.0.1

package/native/src/codec.rs

@@ -10,6 +10,9 @@ pub(crate) fn has_encoding(value: &str) -> bool {
     value.chars().any(is_reserved)
 }
 pub(crate) fn from_units(units: &[u16]) -> String {
+    if units.iter().all(|unit| !(0xd800..=0xe800).contains(unit)) {
+        return String::from_utf16_lossy(units);
+    }
     let mut output = String::with_capacity(units.len());
     let mut index = 0;
     while index < units.len() {
@@ -38,28 +41,69 @@ pub(crate) fn from_units(units: &[u16]) -> String {
     }
     output
 }
-pub(crate) fn to_units(value: &str) -> Vec<u16> {
-    let mut output = Vec::with_capacity(value.len());
-    let mut chars = value.chars().peekable();
-    while let Some(ch) = chars.next() {
-        if ch == ESCAPE && chars.peek().copied().is_some_and(is_reserved) {
-            output.push(chars.next().unwrap() as u16);
-        } else if ('\u{e000}'..'\u{e800}').contains(&ch) {
-            output.push(0xd800 + (ch as u16 - 0xe000));
-        } else {
-            let mut encoded = [0; 2];
-            output.extend_from_slice(ch.encode_utf16(&mut encoded));
-        }
+/// Receives the UTF-16 units of a string from [`visit_units`].
+pub(crate) trait UnitSink {
+    /// A run of ASCII bytes starting at byte offset `start`, one unit each.
+    fn ascii(&mut self, start: usize, run: &[u8]);
+    /// One unit and the byte offset of the character that starts there, or
+    /// `None` for the low half of a surrogate pair.
+    fn unit(&mut self, offset: Option<usize>, unit: u16);
+}
+
+impl UnitSink for Vec<u16> {
+    fn ascii(&mut self, _: usize, run: &[u8]) {
+        self.extend(run.iter().map(|value| u16::from(*value)));
+    }
+    fn unit(&mut self, _: Option<usize>, unit: u16) {
+        self.push(unit);
     }
-    output
 }
-pub(crate) fn logical_len(value: &str) -> usize {
-    if has_encoding(value) {
-        to_units(value).len()
-    } else {
-        value.encode_utf16().count()
+
+/// Feeds the UTF-16 units of `value` to `sink`. With `framed`, lossless frames
+/// decode to their original units.
+pub(crate) fn visit_units(value: &str, framed: bool, sink: &mut impl UnitSink) {
+    let bytes = value.as_bytes();
+    let mut byte = 0;
+    while byte < bytes.len() {
+        let ascii = bytes[byte..]
+            .iter()
+            .position(|value| !value.is_ascii())
+            .unwrap_or(bytes.len() - byte);
+        sink.ascii(byte, &bytes[byte..byte + ascii]);
+        byte += ascii;
+        let Some(ch) = value[byte..].chars().next() else {
+            break;
+        };
+        let start = byte;
+        byte += ch.len_utf8();
+        if framed && ch == ESCAPE {
+            if let Some(next) = value[byte..]
+                .chars()
+                .next()
+                .filter(|next| is_reserved(*next))
+            {
+                sink.unit(Some(start), next as u16);
+                byte += next.len_utf8();
+                continue;
+            }
+        }
+        if framed && ('\u{e000}'..ESCAPE).contains(&ch) {
+            sink.unit(Some(start), 0xd800 + (ch as u16 - 0xe000));
+            continue;
+        }
+        let mut encoded = [0; 2];
+        let encoded = ch.encode_utf16(&mut encoded);
+        sink.unit(Some(start), encoded[0]);
+        if let Some(low) = encoded.get(1) {
+            sink.unit(None, *low);
+        }
     }
 }
+pub(crate) fn to_units(value: &str) -> Vec<u16> {
+    let mut output = Vec::with_capacity(value.len());
+    visit_units(value, has_encoding(value), &mut output);
+    output
+}
 pub(crate) fn to_usv(value: &str) -> String {
     if has_encoding(value) {
         String::from_utf16_lossy(&to_units(value))

package/native/src/hook_sink.rs

@@ -1,7 +1,7 @@
 //! An active user-supplied tree adapter. Rust runs the HTML5 algorithm; the
 //! adapter supplies every construction, mutation and tree-inspection decision.
 use std::borrow::Cow;
-use std::cell::{Ref, RefCell};
+use std::cell::{Cell, Ref, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
@@ -196,6 +196,26 @@ struct HookSink {
     context: Option<Rc<crate::diagnostics::DiagnosticContext>>,
     diagnostics: RefCell<Vec<Value>>,
     locations: Option<crate::tracker::Locations<u32>>,
+    pending_escape: Cell<Option<TextTarget>>,
+}
+
+/// Where a text chunk is inserted: appended to `parent`, or before `sibling`.
+#[derive(Clone, Copy, PartialEq, Eq)]
+struct TextTarget {
+    parent: u32,
+    sibling: Option<u32>,
+}
+
+/// Whether the final character is a codec escape whose character has not
+/// arrived yet. Escapes pair with the following character.
+fn ends_with_unpaired_escape(text: &str) -> bool {
+    let mut chars = text.chars();
+    while let Some(ch) = chars.next() {
+        if ch == crate::codec::ESCAPE && chars.next().is_none() {
+            return true;
+        }
+    }
+    false
 }
 
 impl HookSink {
@@ -203,6 +223,17 @@ impl HookSink {
         if self.error.borrow().is_some() {
             return Value::Null;
         }
+        if matches!(
+            method,
+            "appendChild"
+                | "insertBefore"
+                | "detachNode"
+                | "setDocumentType"
+                | "setTemplateContent"
+                | "__snapshot"
+        ) {
+            self.flush_escape();
+        }
         let result = self.bridge.call(method, args);
         match result {
             Ok(value) => value,
@@ -215,6 +246,38 @@ impl HookSink {
     fn node(&self, method: &str, args: Value) -> u32 {
         self.call(method, args).as_u64().unwrap_or(0) as u32
     }
+    /// The tokenizer may split a codec escape from its character across text
+    /// chunks. Adapters decode each chunk separately, so a trailing escape is
+    /// held until the next chunk for the same target.
+    fn insert_text(&self, target: TextTarget, text: &str) {
+        let mut data = String::with_capacity(text.len() + crate::codec::ESCAPE.len_utf8());
+        if let Some(pending) = self.pending_escape.take() {
+            if pending == target {
+                data.push(crate::codec::ESCAPE);
+            } else {
+                self.send_text(pending, &crate::codec::ESCAPE.to_string());
+            }
+        }
+        data.push_str(text);
+        if ends_with_unpaired_escape(&data) {
+            data.pop();
+            self.pending_escape.set(Some(target));
+        }
+        if !data.is_empty() {
+            self.send_text(target, &data);
+        }
+    }
+    fn send_text(&self, target: TextTarget, data: &str) {
+        match target.sibling {
+            None => self.call("insertText", json!([target.parent, data])),
+            Some(sibling) => self.call("insertTextBefore", json!([target.parent, data, sibling])),
+        };
+    }
+    fn flush_escape(&self) {
+        if let Some(pending) = self.pending_escape.take() {
+            self.send_text(pending, &crate::codec::ESCAPE.to_string());
+        }
+    }
     fn attrs(attrs: Vec<Attribute>) -> Value {
         Value::Array(
             attrs
@@ -463,7 +526,11 @@ impl TreeSink for HookSink {
                 }
             }
             NodeOrText::AppendText(text) => {
-                self.call("insertText", json!([parent, text.as_ref()]));
+                let target = TextTarget {
+                    parent: *parent,
+                    sibling: None,
+                };
+                self.insert_text(target, text.as_ref());
                 self.mark_text(*parent, None, text.as_ref());
             }
         }
@@ -530,7 +597,11 @@ impl TreeSink for HookSink {
                 self.call("insertBefore", json!([parent, node, sibling]));
             }
             NodeOrText::AppendText(text) => {
-                self.call("insertTextBefore", json!([parent, text.as_ref(), sibling]));
+                let target = TextTarget {
+                    parent,
+                    sibling: Some(*sibling),
+                };
+                self.insert_text(target, text.as_ref());
                 self.mark_text(parent, Some(*sibling), text.as_ref());
             }
         }
@@ -589,6 +660,7 @@ fn parser(
         context: None,
         diagnostics: RefCell::new(Vec::new()),
         locations: None,
+        pending_escape: Cell::new(None),
     };
     sink.call(
         if is_document {
@@ -659,6 +731,7 @@ pub(crate) fn parse(
             diagnostics: RefCell::new(Vec::new()),
             locations: (options.get("sourceCodeLocationInfo") == Some(&Value::Bool(true)))
                 .then(|| crate::tracker::Locations::new(context.clone())),
+            pending_escape: Cell::new(None),
         };
         sink.call(
             if is_document {
@@ -706,6 +779,7 @@ where
         diagnostics: RefCell::new(Vec::new()),
         locations: (options.get("sourceCodeLocationInfo") == Some(&Value::Bool(true)))
             .then(|| crate::tracker::Locations::new(context.clone())),
+        pending_escape: Cell::new(None),
     };
     sink.call(
         if is_document {

package/native/src/lib.rs

@@ -23,6 +23,7 @@ mod gc;
 mod hook_sink;
 mod hook_stream;
 mod location;
+mod markup_tokenizer;
 mod runtime;
 mod selector;
 mod sink;
@@ -68,6 +69,56 @@ pub(crate) fn push_attribute_name(
     output.push_str(local);
 }
 
+/// Orders attributes the way a JavaScript object enumerates its keys: integer
+/// keys first, ascending, then insertion order. Cheerio serializes attributes
+/// from such an object.
+pub(crate) fn js_property_order<'a, T, I>(entries: I) -> JsPropertyOrder<I>
+where
+    I: Iterator<Item = (&'a str, T)> + Clone,
+{
+    if !entries.clone().any(|(name, _)| array_index(name).is_some()) {
+        return JsPropertyOrder::Unchanged(entries);
+    }
+    let mut keyed: Vec<_> = entries
+        .map(|entry| {
+            (
+                array_index(entry.0).map_or((1, 0), |index| (0, index)),
+                entry,
+            )
+        })
+        .collect();
+    keyed.sort_by_key(|(key, _)| *key);
+    let sorted: Vec<_> = keyed.into_iter().map(|(_, entry)| entry).collect();
+    JsPropertyOrder::Sorted(sorted.into_iter())
+}
+
+pub(crate) enum JsPropertyOrder<I: Iterator> {
+    Unchanged(I),
+    Sorted(std::vec::IntoIter<I::Item>),
+}
+
+impl<I: Iterator> Iterator for JsPropertyOrder<I> {
+    type Item = I::Item;
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            Self::Unchanged(entries) => entries.next(),
+            Self::Sorted(entries) => entries.next(),
+        }
+    }
+}
+
+fn array_index(name: &str) -> Option<u32> {
+    let is_canonical = !name.is_empty()
+        && name.len() <= 10
+        && name.bytes().all(|byte| byte.is_ascii_digit())
+        && (name == "0" || !name.starts_with('0'));
+    is_canonical
+        .then(|| name.parse::<u64>().ok())
+        .flatten()
+        .filter(|value| *value < u64::from(u32::MAX))
+        .map(|value| value as u32)
+}
+
 #[napi(custom_finalize)]
 pub struct NativeDocument {
     html: RefCell<Option<Html>>,
@@ -1323,7 +1374,13 @@ fn serialize_node(node: NodeRef<'_, Node>, output: &mut String) {
             Node::Element(element) => {
                 output.push('<');
                 output.push_str(element.name());
-                for (name, value) in &element.attrs {
+                let attributes = js_property_order(
+                    element
+                        .attrs
+                        .iter()
+                        .map(|(name, value)| (name.local.as_ref(), (name, value))),
+                );
+                for (_, (name, value)) in attributes {
                     output.push(' ');
                     push_attribute_name(
                         output,