@tishlang/tish 1.6.0 → 1.8.0

package/crates/tish_builtins/src/construct.rs

@@ -2,6 +2,7 @@
 //! Browser-exact behavior remains on `tish build --target js`.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 
@@ -16,7 +17,7 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
         Value::Object(o) => {
             let b = o.borrow();
             if let Some(Value::Function(ctor)) = b.get(&Arc::from(CONSTRUCT)) {
-                let c = Rc::clone(ctor);
+                let c = ctor.clone();
                 drop(b);
                 return c(args);
             }
@@ -29,11 +30,11 @@ pub fn construct(callee: &Value, args: &[Value]) -> Value {
 fn param(initial: f64) -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("value"), Value::Number(initial));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn connect_fn() -> Value {
-    Value::Function(Rc::new(|_| Value::Null))
+    Value::native(|_| Value::Null)
 }
 
 /// Shared audio-node shape: connect, gain, optional filter fields.
@@ -44,33 +45,33 @@ fn audio_node_stub() -> Value {
     m.insert(Arc::from("frequency"), param(440.0));
     m.insert(Arc::from("Q"), param(1.0));
     m.insert(Arc::from("type"), Value::String("peaking".into()));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn analyser_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("fftSize"), Value::Number(2048.0));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn stereo_panner_stub() -> Value {
     let mut m = ObjectMap::default();
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(Arc::from("pan"), param(0.0));
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn audio_buffer_stub(len: usize) -> Value {
     let n = len.max(1);
-    let data = Rc::new(RefCell::new(vec![Value::Number(0.0); n]));
-    let data2 = Rc::clone(&data);
+    let data = VmRef::new(vec![Value::Number(0.0); n]);
+    let data2 = data.clone();
     let mut m = ObjectMap::default();
     m.insert(
         Arc::from("getChannelData"),
-        Value::Function(Rc::new(move |_args| Value::Array(Rc::clone(&data2)))),
+        Value::native(move |_args| Value::Array(data2.clone())),
     );
-    Value::Object(Rc::new(RefCell::new(m)))
+    Value::Object(VmRef::new(m))
 }
 
 fn buffer_source_stub() -> Value {
@@ -80,13 +81,10 @@ fn buffer_source_stub() -> Value {
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(
         Arc::from("start"),
-        Value::Function(Rc::new(|_| Value::Null)),
+        Value::native(|_| Value::Null),
     );
-    m.insert(
-        Arc::from("stop"),
-        Value::Function(Rc::new(|_| Value::Null)),
-    );
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
+    Value::Object(VmRef::new(m))
 }
 
 fn oscillator_stub() -> Value {
@@ -96,13 +94,10 @@ fn oscillator_stub() -> Value {
     m.insert(Arc::from("connect"), connect_fn());
     m.insert(
         Arc::from("start"),
-        Value::Function(Rc::new(|_| Value::Null)),
-    );
-    m.insert(
-        Arc::from("stop"),
-        Value::Function(Rc::new(|_| Value::Null)),
+        Value::native(|_| Value::Null),
     );
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from("stop"), Value::native(|_| Value::Null));
+    Value::Object(VmRef::new(m))
 }
 
 fn audio_context_instance() -> Value {
@@ -112,66 +107,66 @@ fn audio_context_instance() -> Value {
 
     ctx.insert(
         Arc::from("createGain"),
-        Value::Function(Rc::new(|_| audio_node_stub())),
+        Value::native(|_| audio_node_stub()),
     );
     ctx.insert(
         Arc::from("createBiquadFilter"),
-        Value::Function(Rc::new(|_| audio_node_stub())),
+        Value::native(|_| audio_node_stub()),
     );
     ctx.insert(
         Arc::from("createStereoPanner"),
-        Value::Function(Rc::new(|_| stereo_panner_stub())),
+        Value::native(|_| stereo_panner_stub()),
     );
     ctx.insert(
         Arc::from("createAnalyser"),
-        Value::Function(Rc::new(|_| analyser_stub())),
+        Value::native(|_| analyser_stub()),
     );
     ctx.insert(
         Arc::from("createBuffer"),
-        Value::Function(Rc::new(|args: &[Value]| {
+        Value::native(|args: &[Value]| {
             let len = args
                 .get(1)
                 .and_then(Value::as_number)
                 .unwrap_or(0.0)
                 .clamp(0.0, 1_000_000_000.0) as usize;
             audio_buffer_stub(len)
-        })),
+        }),
     );
     ctx.insert(
         Arc::from("createBufferSource"),
-        Value::Function(Rc::new(|_| buffer_source_stub())),
+        Value::native(|_| buffer_source_stub()),
     );
     ctx.insert(
         Arc::from("createOscillator"),
-        Value::Function(Rc::new(|_| oscillator_stub())),
+        Value::native(|_| oscillator_stub()),
     );
     ctx.insert(
         Arc::from("decodeAudioData"),
-        Value::Function(Rc::new(|_| Value::Null)),
+        Value::native(|_| Value::Null),
     );
 
-    Value::Object(Rc::new(RefCell::new(ctx)))
+    Value::Object(VmRef::new(ctx))
 }
 
 /// Global `Uint8Array` for native/VM: `new Uint8Array(n)` → numeric array of zeros (not real bytes).
 pub fn uint8_array_constructor_value() -> Value {
-    let ctor = Rc::new(|args: &[Value]| {
+    let ctor = Value::native(|args: &[Value]| {
         let len = args
             .first()
             .and_then(Value::as_number)
             .unwrap_or(0.0)
             .clamp(0.0, 1_000_000_000.0) as usize;
-        Value::Array(Rc::new(RefCell::new(vec![Value::Number(0.0); len])))
+        Value::Array(VmRef::new(vec![Value::Number(0.0); len]))
     });
     let mut m = ObjectMap::default();
-    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from(CONSTRUCT), ctor);
+    Value::Object(VmRef::new(m))
 }
 
 /// Global `AudioContext` for native/VM: stub graph (no real audio).
 pub fn audio_context_constructor_value() -> Value {
-    let ctor = Rc::new(|_args: &[Value]| audio_context_instance());
+    let ctor = Value::native(|_args: &[Value]| audio_context_instance());
     let mut m = ObjectMap::default();
-    m.insert(Arc::from(CONSTRUCT), Value::Function(ctor));
-    Value::Object(Rc::new(RefCell::new(m)))
+    m.insert(Arc::from(CONSTRUCT), ctor);
+    Value::Object(VmRef::new(m))
 }

package/crates/tish_builtins/src/globals.rs

@@ -4,6 +4,7 @@
 //! independent of tishlang_runtime.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
@@ -16,29 +17,35 @@ pub fn boolean(args: &[Value]) -> Value {
 
 /// decodeURI(str)
 pub fn decode_uri(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
     Value::String(percent_decode(&s).unwrap_or(s).into())
 }
 
 /// encodeURI(str)
 pub fn encode_uri(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
     Value::String(percent_encode(&s).into())
 }
 
 /// isFinite(value)
 pub fn is_finite(args: &[Value]) -> Value {
-    Value::Bool(args.first().is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite())))
+    Value::Bool(
+        args.first()
+            .is_some_and(|v| matches!(v, Value::Number(n) if n.is_finite())),
+    )
 }
 
 /// isNaN(value)
 pub fn is_nan(args: &[Value]) -> Value {
-    Value::Bool(
-        args.first().is_none_or(|v| {
-            matches!(v, Value::Number(n) if n.is_nan())
-                || !matches!(v, Value::Number(_))
-        }),
-    )
+    Value::Bool(args.first().is_none_or(|v| {
+        matches!(v, Value::Number(n) if n.is_nan()) || !matches!(v, Value::Number(_))
+    }))
 }
 
 /// Array.isArray(value)
@@ -72,9 +79,9 @@ pub fn object_keys(args: &[Value]) -> Value {
             .keys()
             .map(|k| Value::String(Arc::clone(k)))
             .collect();
-        Value::Array(Rc::new(RefCell::new(keys)))
+        Value::Array(VmRef::new(keys))
     } else {
-        Value::Array(Rc::new(RefCell::new(Vec::new())))
+        Value::Array(VmRef::new(Vec::new()))
     }
 }
 
@@ -83,9 +90,9 @@ pub fn object_values(args: &[Value]) -> Value {
     if let Some(Value::Object(obj)) = args.first() {
         let obj_borrow = obj.borrow();
         let values: Vec<Value> = obj_borrow.values().cloned().collect();
-        Value::Array(Rc::new(RefCell::new(values)))
+        Value::Array(VmRef::new(values))
     } else {
-        Value::Array(Rc::new(RefCell::new(Vec::new())))
+        Value::Array(VmRef::new(Vec::new()))
     }
 }
 
@@ -96,15 +103,15 @@ pub fn object_entries(args: &[Value]) -> Value {
         let entries: Vec<Value> = obj_borrow
             .iter()
             .map(|(k, v)| {
-                Value::Array(Rc::new(RefCell::new(vec![
+                Value::Array(VmRef::new(vec![
                     Value::String(Arc::clone(k)),
                     v.clone(),
-                ])))
+                ]))
             })
             .collect();
-        Value::Array(Rc::new(RefCell::new(entries)))
+        Value::Array(VmRef::new(entries))
     } else {
-        Value::Array(Rc::new(RefCell::new(Vec::new())))
+        Value::Array(VmRef::new(Vec::new()))
     }
 }
 
@@ -139,17 +146,23 @@ pub fn object_assign(args: &[Value]) -> Value {
         }
     }
     drop(target_mut);
-    Value::Object(Rc::clone(target))
+    Value::Object(target.clone())
 }
 
 /// parseInt(string, radix?)
 pub fn parse_int(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
     let s = s.trim();
-    let radix = args.get(1).and_then(|v| match v {
-        Value::Number(n) => Some(*n as i32),
-        _ => None,
-    }).unwrap_or(10);
+    let radix = args
+        .get(1)
+        .and_then(|v| match v {
+            Value::Number(n) => Some(*n as i32),
+            _ => None,
+        })
+        .unwrap_or(10);
 
     if (2..=36).contains(&radix) {
         let prefix: String = s
@@ -165,7 +178,10 @@ pub fn parse_int(args: &[Value]) -> Value {
 
 /// parseFloat(string)
 pub fn parse_float(args: &[Value]) -> Value {
-    let s = args.first().map(Value::to_display_string).unwrap_or_default();
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
     Value::Number(s.trim().parse().unwrap_or(f64::NAN))
 }
 
@@ -188,8 +204,8 @@ pub fn object_from_entries(args: &[Value]) -> Value {
             }
         }
 
-        Value::Object(Rc::new(RefCell::new(obj)))
+        Value::Object(VmRef::new(obj))
     } else {
-        Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
+        Value::Object(VmRef::new(ObjectMap::default()))
     }
 }

package/crates/tish_builtins/src/helpers.rs

@@ -1,6 +1,7 @@
 //! Common helper functions used across builtin implementations.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::{ObjectMap, Value};
@@ -25,7 +26,7 @@ pub fn normalize_index(idx: &Value, len: i64, default: usize) -> usize {
 pub fn make_error_value(e: impl std::fmt::Display) -> Value {
     let mut obj = ObjectMap::with_capacity(1);
     obj.insert(Arc::from("error"), Value::String(e.to_string().into()));
-    Value::Object(Rc::new(RefCell::new(obj)))
+    Value::Object(VmRef::new(obj))
 }
 
 /// Extract a number from a Value, returning None for non-numbers.

package/crates/tish_builtins/src/lib.rs

@@ -5,11 +5,11 @@
 //! and native signatures.
 
 pub mod array;
-pub mod string;
-pub mod object;
-pub mod math;
-pub mod helpers;
-pub mod globals;
 pub mod construct;
+pub mod globals;
+pub mod helpers;
+pub mod math;
+pub mod object;
+pub mod string;
 
 pub use tishlang_core::Value;

package/crates/tish_builtins/src/math.rs

@@ -1,7 +1,7 @@
 //! Math builtin functions.
 
-use tishlang_core::Value;
 use crate::helpers::extract_num;
+use tishlang_core::Value;
 
 macro_rules! math_unary {
     ($name:ident, $op:ident) => {
@@ -31,14 +31,16 @@ math_unary!(trunc, trunc);
 math_unary!(cbrt, cbrt);
 
 pub fn min(args: &[Value]) -> Value {
-    let n = args.iter()
+    let n = args
+        .iter()
         .filter_map(|v| extract_num(Some(v)))
         .fold(f64::INFINITY, f64::min);
     Value::Number(if n == f64::INFINITY { f64::NAN } else { n })
 }
 
 pub fn max(args: &[Value]) -> Value {
-    let n = args.iter()
+    let n = args
+        .iter()
         .filter_map(|v| extract_num(Some(v)))
         .fold(f64::NEG_INFINITY, f64::max);
     Value::Number(if n == f64::NEG_INFINITY { f64::NAN } else { n })

package/crates/tish_builtins/src/object.rs

@@ -4,18 +4,19 @@
 //! Functions will be migrated here from tishlang_runtime and tishlang_eval.
 
 use std::cell::RefCell;
+use tishlang_core::VmRef;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::{ObjectMap, Value};
 
 /// Create a new empty object Value.
 pub fn new() -> Value {
-    Value::Object(Rc::new(RefCell::new(ObjectMap::default())))
+    Value::Object(VmRef::new(ObjectMap::default()))
 }
 
 /// Create a new object Value with a given capacity.
 pub fn with_capacity(capacity: usize) -> Value {
-    Value::Object(Rc::new(RefCell::new(ObjectMap::with_capacity(capacity))))
+    Value::Object(VmRef::new(ObjectMap::with_capacity(capacity)))
 }
 
 /// Get the keys of an object.

package/crates/tish_builtins/src/string.rs

@@ -3,11 +3,12 @@
 //! All indices use character (Unicode scalar) positions for consistency with
 //! JavaScript, matching .length and .charAt(). Byte offsets are never exposed.
 
+use crate::helpers::normalize_index;
+use tishlang_core::VmRef;
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Arc;
 use tishlang_core::Value;
-use crate::helpers::normalize_index;
 
 /// Byte offset -> character index.
 fn byte_to_char_index(s: &str, byte_offset: usize) -> usize {
@@ -152,7 +153,10 @@ pub fn slice(s: &Value, start: &Value, end: &Value) -> Value {
     if let Value::String(s) = s {
         let chars: Vec<char> = s.chars().collect();
         let len = chars.len() as i64;
-        let (si, ei) = (normalize_index(start, len, 0), normalize_index(end, len, len as usize));
+        let (si, ei) = (
+            normalize_index(start, len, 0),
+            normalize_index(end, len, len as usize),
+        );
         let result: String = if si < ei {
             chars[si..ei].iter().collect()
         } else {
@@ -191,12 +195,13 @@ pub fn split(s: &Value, sep: &Value) -> Value {
     if let Value::String(s) = s {
         let separator = match sep {
             Value::String(ss) => ss.as_ref(),
-            _ => return Value::Array(Rc::new(RefCell::new(vec![Value::String(Arc::clone(s))]))),
+            _ => return Value::Array(VmRef::new(vec![Value::String(Arc::clone(s))])),
         };
-        let parts: Vec<Value> = s.split(separator)
+        let parts: Vec<Value> = s
+            .split(separator)
             .map(|p| Value::String(p.into()))
             .collect();
-        Value::Array(Rc::new(RefCell::new(parts)))
+        Value::Array(VmRef::new(parts))
     } else {
         Value::Null
     }
@@ -244,9 +249,19 @@ pub fn ends_with(s: &Value, search: &Value) -> Value {
 
 fn replace_impl(s: &Value, search: &Value, replacement: &Value, all: bool) -> Value {
     if let Value::String(s) = s {
-        let search_str = match search { Value::String(ss) => ss.as_ref(), _ => return Value::String(Arc::clone(s)) };
-        let repl_str = match replacement { Value::String(ss) => ss.as_ref(), _ => "" };
-        let result = if all { s.replace(search_str, repl_str) } else { s.replacen(search_str, repl_str, 1) };
+        let search_str = match search {
+            Value::String(ss) => ss.as_ref(),
+            _ => return Value::String(Arc::clone(s)),
+        };
+        let repl_str = match replacement {
+            Value::String(ss) => ss.as_ref(),
+            _ => "",
+        };
+        let result = if all {
+            s.replace(search_str, repl_str)
+        } else {
+            s.replacen(search_str, repl_str, 1)
+        };
         Value::String(result.into())
     } else {
         Value::Null
@@ -261,14 +276,66 @@ pub fn replace_all(s: &Value, search: &Value, replacement: &Value) -> Value {
     replace_impl(s, search, replacement, true)
 }
 
+/// HTML entity escape for the five canonical characters (`& < > " '`).
+/// Single linear pass over the input; takes a zero-copy fast path when no
+/// character needs escaping. Matches TFB's fortunes verifier byte-for-byte.
+pub fn escape_html(s: &Value) -> Value {
+    let input = match s {
+        Value::String(s) => s.as_ref(),
+        Value::Null => return Value::String(Arc::from("")),
+        _ => return Value::Null,
+    };
+    let bytes = input.as_bytes();
+    let mut extra = 0usize;
+    for b in bytes {
+        match b {
+            b'&' => extra += 4,
+            b'<' | b'>' => extra += 3,
+            b'"' => extra += 5,
+            b'\'' => extra += 4,
+            _ => {}
+        }
+    }
+    if extra == 0 {
+        return Value::String(Arc::clone(match s {
+            Value::String(s) => s,
+            _ => unreachable!(),
+        }));
+    }
+    let mut out = String::with_capacity(input.len() + extra);
+    let mut last = 0usize;
+    for (i, b) in bytes.iter().enumerate() {
+        let repl: Option<&'static str> = match b {
+            b'&' => Some("&amp;"),
+            b'<' => Some("&lt;"),
+            b'>' => Some("&gt;"),
+            b'"' => Some("&quot;"),
+            b'\'' => Some("&#39;"),
+            _ => None,
+        };
+        if let Some(r) = repl {
+            out.push_str(&input[last..i]);
+            out.push_str(r);
+            last = i + 1;
+        }
+    }
+    out.push_str(&input[last..]);
+    Value::String(Arc::from(out))
+}
+
 fn char_at_idx(s: &str, idx: usize) -> Option<char> {
     s.chars().nth(idx)
 }
 
 pub fn char_at(s: &Value, idx: &Value) -> Value {
     if let Value::String(s) = s {
-        let idx = match idx { Value::Number(n) => *n as usize, _ => 0 };
-        char_at_idx(s, idx).map(|c| Value::String(c.to_string().into())).unwrap_or(Value::String("".into()))
+        let idx = match idx {
+            Value::Number(n) => *n as usize,
+            _ => 0,
+        };
+        char_at_idx(s, idx)
+            .map(|c| Value::String(c.to_string().into()))
+            .unwrap_or(Value::String("".into()))
     } else {
         Value::Null
     }
@@ -276,8 +343,13 @@ pub fn char_at(s: &Value, idx: &Value) -> Value {
 
 pub fn char_code_at(s: &Value, idx: &Value) -> Value {
     if let Value::String(s) = s {
-        let idx = match idx { Value::Number(n) => *n as usize, _ => 0 };
-        char_at_idx(s, idx).map(|c| Value::Number(c as u32 as f64)).unwrap_or(Value::Number(f64::NAN))
+        let idx = match idx {
+            Value::Number(n) => *n as usize,
+            _ => 0,
+        };
+        char_at_idx(s, idx)
+            .map(|c| Value::Number(c as u32 as f64))
+            .unwrap_or(Value::Number(f64::NAN))
     } else {
         Value::Null
     }
@@ -311,7 +383,11 @@ fn pad_impl(s: &Value, target_len: &Value, pad: &Value, at_start: bool) -> Value
         }
         let needed = target_len - char_count;
         let padding: String = pad_str.chars().cycle().take(needed).collect();
-        let result = if at_start { format!("{}{}", padding, s) } else { format!("{}{}", s, padding) };
+        let result = if at_start {
+            format!("{}{}", padding, s)
+        } else {
+            format!("{}{}", s, padding)
+        };
         Value::String(result.into())
     } else {
         Value::Null
@@ -382,16 +458,31 @@ mod tests {
     fn includes_basic() {
         assert_same!(includes(&s("hello"), &s("ll"), None), Value::Bool(true));
         assert_same!(includes(&s("hello"), &s("x"), None), Value::Bool(false));
-        assert_same!(includes(&s("hello"), &s("l"), Some(&n(3.0))), Value::Bool(true));
-        assert_same!(includes(&s("hello"), &s("l"), Some(&n(4.0))), Value::Bool(false));
+        assert_same!(
+            includes(&s("hello"), &s("l"), Some(&n(3.0))),
+            Value::Bool(true)
+        );
+        assert_same!(
+            includes(&s("hello"), &s("l"), Some(&n(4.0))),
+            Value::Bool(false)
+        );
     }
 
     #[test]
     fn includes_negative_from() {
-        assert_same!(includes(&s("hello"), &s("o"), Some(&n(-1.0))), Value::Bool(true));
-        assert_same!(includes(&s("hello"), &s("h"), Some(&n(-5.0))), Value::Bool(true));
+        assert_same!(
+            includes(&s("hello"), &s("o"), Some(&n(-1.0))),
+            Value::Bool(true)
+        );
+        assert_same!(
+            includes(&s("hello"), &s("h"), Some(&n(-5.0))),
+            Value::Bool(true)
+        );
         // fromIndex -1 → start at len-1 = 1 ("i" only), "h" not found
-        assert_same!(includes(&s("hi"), &s("h"), Some(&n(-1.0))), Value::Bool(false));
+        assert_same!(
+            includes(&s("hi"), &s("h"), Some(&n(-1.0))),
+            Value::Bool(false)
+        );
     }
 
     #[test]
@@ -420,7 +511,7 @@ mod tests {
         assert_eq!(a.borrow().len(), 2);
         assert_same!(
             split(&s("x"), &n(1.0)),
-            Value::Array(Rc::new(RefCell::new(vec![s("x")])))
+            Value::Array(VmRef::new(vec![s("x")]))
         );
         assert_same!(split(&n(1.0), &s(",")), Value::Null);
         assert_same!(trim(&s("  x  ")), s("x"));
@@ -466,7 +557,10 @@ mod tests {
 
     #[test]
     fn last_index_of_basic() {
-        assert_same!(last_index_of(&s("abcabc"), &s("a"), &n(f64::INFINITY)), n(3.0));
+        assert_same!(
+            last_index_of(&s("abcabc"), &s("a"), &n(f64::INFINITY)),
+            n(3.0)
+        );
         assert_same!(last_index_of(&s("abcabc"), &s("a"), &n(2.0)), n(0.0));
         assert_same!(last_index_of(&s("hello"), &s("l"), &n(3.0)), n(3.0));
         assert_same!(last_index_of(&s("hello"), &s("l"), &n(1.0)), n(-1.0));
@@ -490,12 +584,40 @@ mod tests {
 
     #[test]
     fn last_index_of_unicode() {
-        assert_same!(last_index_of(&s("😀a😀"), &s("a"), &n(f64::INFINITY)), n(1.0));
-        assert_same!(last_index_of(&s("😀a😀"), &s("😀"), &n(f64::INFINITY)), n(2.0));
+        assert_same!(
+            last_index_of(&s("😀a😀"), &s("a"), &n(f64::INFINITY)),
+            n(1.0)
+        );
+        assert_same!(
+            last_index_of(&s("😀a😀"), &s("😀"), &n(f64::INFINITY)),
+            n(2.0)
+        );
     }
 
     #[test]
     fn last_index_of_non_string() {
         assert_same!(last_index_of(&n(1.0), &s("a"), &n(0.0)), n(-1.0));
     }
+
+    #[test]
+    fn escape_html_basic() {
+        assert_same!(escape_html(&s("plain text")), s("plain text"));
+        assert_same!(
+            escape_html(&s("<script>alert(\"xss\")</script>")),
+            s("&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;")
+        );
+        assert_same!(escape_html(&s("tom & jerry")), s("tom &amp; jerry"));
+        assert_same!(escape_html(&s("it's")), s("it&#39;s"));
+        assert_same!(
+            escape_html(&s("<script>alert('x' & \"y\");</script>")),
+            s("&lt;script&gt;alert(&#39;x&#39; &amp; &quot;y&quot;);&lt;/script&gt;")
+        );
+    }
+
+    #[test]
+    fn escape_html_unicode_preserved() {
+        // Astral symbols / non-ASCII must round-trip unchanged.
+        assert_same!(escape_html(&s("フレーム")), s("フレーム"));
+        assert_same!(escape_html(&s("🎉 & 💥")), s("🎉 &amp; 💥"));
+    }
 }