rusteerio 1.0.0 → 1.1.0

package/native/src/attributes.rs

@@ -173,7 +173,7 @@ fn set_css(arena: &mut DomArena, ids: &[u32], name: &str, value: &Value) {
         }
         let mut properties = parse_css(arena.attr(*id, "style").unwrap_or(""));
         if value.as_str() == Some("") {
-            properties.remove(name);
+            properties.shift_remove(name);
         } else if !value.is_null() {
             properties.insert(name.into(), json!(js_string(value)));
         }
@@ -207,9 +207,15 @@ fn node_property(arena: &DomArena, id: u32, name: &str) -> bool {
             | "type"
             | "startIndex"
             | "endIndex"
-    ) || arena
-        .node(id)
-        .is_some_and(|node| node.extras.contains_key(name))
+    ) || arena.node(id).is_some_and(|node| {
+        node.extras.contains_key(name)
+            || match name {
+                "namespace" => node.namespace.is_some(),
+                "attribsNamespace" => node.attribs_namespace.is_some(),
+                "attribsPrefix" => node.attribs_prefix.is_some(),
+                _ => false,
+            }
+    })
 }
 
 fn get_prop(arena: &DomArena, id: u32, name: &str) -> napi::Result<Value> {
@@ -682,7 +688,7 @@ pub(crate) fn execute(
                         .and_then(|node| node.extras.get_mut("data"))
                         .and_then(Value::as_object_mut)
                     {
-                        data.remove(name);
+                        data.shift_remove(name);
                     }
                 }
             }

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))