@tishlang/tish-format 2.16.13 → 2.36.0

package/crates/tish_builtins/src/array.rs

@@ -149,11 +149,19 @@ pub fn unshift(arr: &Value, args: &[Value]) -> Value {
     }
 }
 
-pub fn index_of(arr: &Value, search: &Value) -> Value {
+pub fn index_of(arr: &Value, search: &Value, from: Option<&Value>) -> Value {
     let arr = as_boxed_array(arr); let arr = &*arr;
     if let Value::Array(arr) = arr {
         let arr_borrow = arr.borrow();
-        for (i, v) in arr_borrow.iter().enumerate() {
+        // `fromIndex`: clamp positive to [0, len]; negative counts from the end (`len + n`, floored
+        // at 0). Same handling as `includes`. Absent → 0.
+        let len = arr_borrow.len() as i64;
+        let start = match from {
+            Some(Value::Number(n)) if *n >= 0.0 => (*n as i64).min(len).max(0) as usize,
+            Some(Value::Number(n)) if *n < 0.0 => ((len + *n as i64).max(0)) as usize,
+            _ => 0,
+        };
+        for (i, v) in arr_borrow.iter().enumerate().skip(start) {
             if v.strict_eq(search) {
                 return Value::Number(i as f64);
             }
@@ -218,6 +226,57 @@ pub fn reverse(arr: &Value) -> Value {
     }
 }
 
+/// `Array.prototype.toReversed()` — a reversed COPY (ES2023); the receiver is untouched.
+pub fn to_reversed(arr: &Value) -> Value {
+    let mut v = snapshot_values(arr);
+    v.reverse();
+    Value::Array(VmRef::new(v))
+}
+
+/// `Array.prototype.toSorted(cmp?)` — a sorted COPY (ES2023); the receiver is untouched. Sorting runs
+/// on the copy via the same comparator/default machinery as `sort`.
+pub fn to_sorted(arr: &Value, comparator: Option<&Value>) -> Value {
+    let copy = Value::Array(VmRef::new(snapshot_values(arr)));
+    match comparator {
+        Some(cmp @ Value::Function(_)) => sort_with_comparator(&copy, cmp),
+        _ => sort_default(&copy),
+    }
+}
+
+/// `Array.prototype.with(index, value)` — a COPY with `index` replaced (ES2023). A negative index
+/// counts from the end; an out-of-range index parks a catchable `RangeError` (matches node's message).
+pub fn with(arr: &Value, index: &Value, value: &Value) -> Value {
+    let mut v = snapshot_values(arr);
+    let len = v.len() as i64;
+    let rel = match index {
+        Value::Number(n) if n.is_finite() => *n as i64,
+        _ => 0,
+    };
+    let actual = if rel >= 0 { rel } else { len + rel };
+    if actual < 0 || actual >= len {
+        tishlang_core::set_pending_throw(tishlang_core::range_error(format!(
+            "Invalid index : {}",
+            rel
+        )));
+        return Value::Null;
+    }
+    v[actual as usize] = value.clone();
+    Value::Array(VmRef::new(v))
+}
+
+/// `Array.prototype.toSpliced(start, deleteCount?, ...items)` — a COPY with the splice applied (ES2023);
+/// unlike `splice` (which returns the removed elements) this returns the resulting array.
+pub fn to_spliced(
+    arr: &Value,
+    start: &Value,
+    delete_count: Option<&Value>,
+    items: &[Value],
+) -> Value {
+    let copy = Value::Array(VmRef::new(snapshot_values(arr)));
+    splice(&copy, start, delete_count, items);
+    copy
+}
+
 /// Fisher-Yates shuffle. Returns a new shuffled array (does not mutate).
 pub fn shuffle(arr: &Value) -> Value {
     let arr = as_boxed_array(arr); let arr = &*arr;
@@ -273,6 +332,55 @@ pub fn fill(arr: &Value, value: &Value, start: &Value, end: &Value) -> Value {
     }
 }
 
+pub fn last_index_of(arr: &Value, search: &Value, from: Option<&Value>) -> Value {
+    let arr = as_boxed_array(arr);
+    let arr = &*arr;
+    if let Value::Array(arr) = arr {
+        let arr_borrow = arr.borrow();
+        let len = arr_borrow.len() as i64;
+        // Default fromIndex is len-1; positive clamps to len-1; negative counts back from the end.
+        let start = match from {
+            Some(Value::Number(n)) if *n >= 0.0 => (*n as i64).min(len - 1),
+            Some(Value::Number(n)) => len + *n as i64,
+            _ => len - 1,
+        };
+        let mut i = start;
+        while i >= 0 {
+            if let Some(v) = arr_borrow.get(i as usize) {
+                if v.strict_eq(search) {
+                    return Value::Number(i as f64);
+                }
+            }
+            i -= 1;
+        }
+    }
+    Value::Number(-1.0)
+}
+
+/// `copyWithin(target, start, end)` — copy the `[start, end)` block to `target`, in place; returns
+/// the array. Indices are clamped, negatives count from the end.
+pub fn copy_within(arr: &Value, target: &Value, start: &Value, end: &Value) -> Value {
+    let arr = as_boxed_array(arr);
+    let arr = &*arr;
+    if let Value::Array(a) = arr {
+        let mut v = a.borrow_mut();
+        let len = v.len();
+        let t = normalize_index(target, len as i64, 0);
+        let s = normalize_index(start, len as i64, 0);
+        let e = normalize_index(end, len as i64, len);
+        if s < e && t < len {
+            let count = (e - s).min(len - t);
+            let block: Vec<Value> = v[s..s + count].to_vec();
+            for (k, val) in block.into_iter().enumerate() {
+                v[t + k] = val;
+            }
+        }
+        drop(v);
+        return Value::Array(a.clone());
+    }
+    Value::Null
+}
+
 pub fn slice(arr: &Value, start: &Value, end: &Value) -> Value {
     let arr = as_boxed_array(arr); let arr = &*arr;
     if let Value::Array(arr) = arr {
@@ -417,16 +525,25 @@ pub fn filter(arr: &Value, callback: &Value) -> Value {
     }
 }
 
-pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
+/// `initial` is `None` when no initial value was passed (`arr.reduce(fn)`) and `Some` for an explicit
+/// one (`arr.reduce(fn, x)`, INCLUDING `arr.reduce(fn, null)`). This distinction matters: reducing an
+/// empty array with NO initial value is a `TypeError` in JS, while an explicit initial (even `null`)
+/// is returned as-is. A `Value::Null` sentinel can't tell the two apart — hence `Option`.
+pub fn reduce(arr: &Value, callback: &Value, initial: Option<&Value>) -> Value {
     // Packed fast path: fold the `Vec<f64>` snapshot directly. Same no-initial rule as the boxed
     // path (absent init → first element as the seed, scan from index 1).
     if let Some((data, cb)) = packed_snapshot(arr, callback) {
         // `reduce` passes `(accumulator, element, index, array)` — the array is the 4th arg.
         let arr_value = arr.clone();
-        let (start_idx, mut acc) = if matches!(initial, Value::Null) && !data.is_empty() {
-            (1usize, Value::Number(data[0]))
-        } else {
-            (0usize, initial.clone())
+        let (start_idx, mut acc) = match initial {
+            Some(v) => (0usize, v.clone()),
+            None if !data.is_empty() => (1usize, Value::Number(data[0])),
+            None => {
+                tishlang_core::set_pending_throw(tishlang_core::type_error(
+                    "Reduce of empty array with no initial value",
+                ));
+                return Value::Null;
+            }
         };
         // `skip(start_idx)` preserves the true element index for the callback's 3rd arg.
         for (i, &x) in data.iter().enumerate().skip(start_idx) {
@@ -440,11 +557,15 @@ pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
         let arr_borrow = arr.borrow().clone(); // #382: snapshot; drop the guard before any callback
         let arr_value = Value::Array(arr.clone()); // 4th callback arg (JS `array`)
         let len = arr_borrow.len();
-        let (start_idx, mut acc) = if matches!(initial, Value::Null) && !arr_borrow.is_empty() {
-            // No initial value: use first element as acc, start from index 1
-            (1, arr_borrow[0].clone())
-        } else {
-            (0, initial.clone())
+        let (start_idx, mut acc) = match initial {
+            Some(v) => (0, v.clone()),
+            None if !arr_borrow.is_empty() => (1, arr_borrow[0].clone()),
+            None => {
+                tishlang_core::set_pending_throw(tishlang_core::type_error(
+                    "Reduce of empty array with no initial value",
+                ));
+                return Value::Null;
+            }
         };
         for i in start_idx..len {
             if tishlang_core::has_pending_throw() { return acc; } // #303
@@ -457,6 +578,64 @@ pub fn reduce(arr: &Value, callback: &Value, initial: &Value) -> Value {
     }
 }
 
+/// `reduceRight(cb, initial?)` — like [`reduce`] but folds right-to-left. `initial` is `None` when
+/// omitted (empty array + no initial → catchable TypeError).
+pub fn reduce_right(arr: &Value, callback: &Value, initial: Option<&Value>) -> Value {
+    let data = snapshot_values(arr);
+    if let Value::Function(cb) = callback {
+        let arr_value = arr.clone();
+        let len = data.len();
+        let (start, mut acc) = match initial {
+            Some(v) => (len, v.clone()),
+            None if len > 0 => (len - 1, data[len - 1].clone()),
+            None => {
+                tishlang_core::set_pending_throw(tishlang_core::type_error(
+                    "Reduce of empty array with no initial value",
+                ));
+                return Value::Null;
+            }
+        };
+        let mut i = start;
+        while i > 0 {
+            i -= 1;
+            if tishlang_core::has_pending_throw() {
+                return acc;
+            }
+            acc = cb.call(&[
+                acc,
+                data[i].clone(),
+                Value::Number(i as f64),
+                arr_value.clone(),
+            ]);
+        }
+        acc
+    } else {
+        Value::Null
+    }
+}
+
+/// `arr.keys()` — an iterator over the indices `0..len`.
+pub fn keys(arr: &Value) -> Value {
+    let len = snapshot_values(arr).len();
+    crate::iterator::array_iterator((0..len).map(|i| Value::Number(i as f64)).collect())
+}
+
+/// `arr.values()` — an iterator over the elements.
+pub fn values(arr: &Value) -> Value {
+    crate::iterator::array_iterator(snapshot_values(arr))
+}
+
+/// `arr.entries()` — an iterator over `[index, element]` pairs.
+pub fn entries(arr: &Value) -> Value {
+    crate::iterator::array_iterator(
+        snapshot_values(arr)
+            .into_iter()
+            .enumerate()
+            .map(|(i, v)| Value::Array(VmRef::new(vec![Value::Number(i as f64), v])))
+            .collect(),
+    )
+}
+
 pub fn for_each(arr: &Value, callback: &Value) -> Value {
     if let Some((data, cb)) = packed_snapshot(arr, callback) {
         let arr_value = arr.clone(); // 3rd callback arg (JS `array`)
@@ -974,14 +1153,14 @@ mod packed_hof_tests {
         let n = na(&[3.0, 1.0, 4.0, 1.0, 5.0]);
         let add = cb_num(|acc, x| acc + x);
         // With init.
-        assert_eq!(reduce(&n, &add, &Value::Number(0.0)).as_number(), Some(14.0));
-        // No init → first element seeds, scan from index 1 (same total here).
-        assert_eq!(reduce(&n, &add, &Value::Null).as_number(), Some(14.0));
+        assert_eq!(reduce(&n, &add, Some(&Value::Number(0.0))).as_number(), Some(14.0));
+        // No init (None) → first element seeds, scan from index 1 (same total here).
+        assert_eq!(reduce(&n, &add, None).as_number(), Some(14.0));
         // Index arg: callback (acc, _elem, index) — sum the indices 0..5 = 10.
         let sum_idx = Value::native(|a: &[Value]| {
             Value::Number(a[0].as_number().unwrap() + a[2].as_number().unwrap())
         });
-        assert_eq!(reduce(&n, &sum_idx, &Value::Number(0.0)).as_number(), Some(10.0));
+        assert_eq!(reduce(&n, &sum_idx, Some(&Value::Number(0.0))).as_number(), Some(10.0));
     }
 
     #[test]

package/crates/tish_builtins/src/collections.rs

@@ -175,9 +175,13 @@ pub fn map_get(map: &Value, key: &Value) -> Value {
 }
 
 /// Direct `Map.prototype.set` (mutates in place; returns `undefined` = `Null`).
-pub fn map_set(map: &Value, key: Value, val: Value) -> Value {
+///
+/// Takes the key/val by reference and clones on insert (the map owns its entries). Passing by
+/// reference lets the native emitter BORROW the caller's place instead of moving it, so
+/// `m.set(k, v); …use k…` no longer produces `E0382 use of moved value` in the generated Rust (#442).
+pub fn map_set(map: &Value, key: &Value, val: &Value) -> Value {
     if let Some(s) = map_store(map) {
-        s.borrow_mut().insert(Key(key), val);
+        s.borrow_mut().insert(Key(key.clone()), val.clone());
     }
     Value::Null
 }
@@ -320,6 +324,20 @@ pub fn set_instance(initial: &[Value]) -> Value {
             }),
         );
     }
+    // `__drain__`: the default-iteration array a Set yields (its elements). `drain_iterator`
+    // (and the interp/native equivalents) check `__drain__` FIRST, so exposing it here makes a
+    // Set directly iterable — `[...set]`, `for (x of set)`, `Array.from(set)` — across all three
+    // backends with no changes to any spread/for-of site. (#440)
+    {
+        let s = store.clone();
+        m.insert(
+            Arc::from("__drain__"),
+            Value::native(move |_args: &[Value]| {
+                let out: Vec<Value> = s.borrow().keys().map(|k| k.0.clone()).collect();
+                Value::Array(VmRef::new(out))
+            }),
+        );
+    }
 
     Value::object(m)
 }
@@ -442,6 +460,23 @@ pub fn map_instance(pairs: &[Value]) -> Value {
             }),
         );
     }
+    // `__drain__`: a Map's default iteration yields `[key, value]` entries. Exposed so the shared
+    // `drain_iterator` (checked first) makes a Map directly iterable — `[...map]`, `for (x of map)`,
+    // `Array.from(map)` — across interp/vm/native with no spread/for-of site changes. (#440)
+    {
+        let s = store.clone();
+        m.insert(
+            Arc::from("__drain__"),
+            Value::native(move |_args: &[Value]| {
+                let pairs: Vec<Value> = s
+                    .borrow()
+                    .iter()
+                    .map(|(k, v)| Value::Array(VmRef::new(vec![k.0.clone(), v.clone()])))
+                    .collect();
+                Value::Array(VmRef::new(pairs))
+            }),
+        );
+    }
 
     Value::object(m)
 }

package/crates/tish_builtins/src/globals.rs

@@ -5,7 +5,7 @@
 
 use std::sync::Arc;
 use tishlang_core::VmRef;
-use tishlang_core::{percent_decode, percent_encode, ObjectMap, Value};
+use tishlang_core::{percent_decode, percent_decode_component, percent_encode, percent_encode_component, ObjectMap, Value};
 
 /// Boolean(value) - coerce to bool
 pub fn boolean(args: &[Value]) -> Value {
@@ -13,7 +13,7 @@ pub fn boolean(args: &[Value]) -> Value {
     Value::Bool(v.is_truthy())
 }
 
-/// decodeURI(str)
+/// decodeURI(str) — preserves the URI reserved delimiters (the inverse of encodeURI).
 pub fn decode_uri(args: &[Value]) -> Value {
     let s = args
         .first()
@@ -31,19 +31,34 @@ pub fn encode_uri(args: &[Value]) -> Value {
     Value::String(percent_encode(&s).into())
 }
 
-/// isFinite(value)
+/// encodeURIComponent(str) — stricter than encodeURI (also escapes the URI reserved delimiters).
+pub fn encode_uri_component(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_encode_component(&s).into())
+}
+
+/// decodeURIComponent(str) — decodes ALL `%XX` escapes (including the reserved delimiters).
+pub fn decode_uri_component(args: &[Value]) -> Value {
+    let s = args
+        .first()
+        .map(Value::to_display_string)
+        .unwrap_or_default();
+    Value::String(percent_decode_component(&s).unwrap_or(s).into())
+}
+
+/// isFinite(value) — coerces via ToNumber (like `Number()`), then tests finiteness. `isFinite("3")`
+/// is `true`, `isFinite("x")`/`isFinite()` is `false`. (The non-coercing form is `Number.isFinite`.)
 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().map_or(f64::NAN, to_number).is_finite())
 }
 
-/// isNaN(value)
+/// isNaN(value) — coerces via ToNumber, then tests NaN. `isNaN("3")` is `false`; an absent arg
+/// (undefined) coerces to NaN → `true`. (The non-coercing form is `Number.isNaN`.)
 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().map_or(f64::NAN, to_number).is_nan())
 }
 
 /// Array.isArray(value)
@@ -51,6 +66,142 @@ pub fn array_is_array(args: &[Value]) -> Value {
     Value::Bool(matches!(args.first(), Some(Value::Array(_)) | Some(Value::NumberArray(_))))
 }
 
+/// `Array.of(...items)` — build an array from the args (unlike `Array(n)`, a single number is an
+/// element, not a length: `Array.of(7)` is `[7]`).
+pub fn array_of(args: &[Value]) -> Value {
+    Value::Array(VmRef::new(args.to_vec()))
+}
+
+/// `Array.from(source, mapFn?)` — build an array from an iterable (array, string, Set/Map, or any
+/// `__drain__`/`next` iterator — via the shared iterator protocol) or an array-like `{ length }`
+/// object, optionally mapping each element through `mapFn(item, index)`.
+pub fn array_from(args: &[Value]) -> Value {
+    let source = args.first().cloned().unwrap_or(Value::Null);
+    let items: Vec<Value> = match &source {
+        Value::Array(a) => a.borrow().clone(),
+        Value::NumberArray(a) => a.borrow().iter().map(|n| Value::Number(*n)).collect(),
+        // `drain_iterator` covers String (chars), Set/Map, and any iterator object.
+        other => {
+            if let Some(d) = tishlang_core::drain_iterator(other) {
+                d
+            } else if matches!(other, Value::Object(_)) {
+                let len = tishlang_core::object_get(other, &Value::String("length".into()))
+                    .and_then(|v| match v {
+                        Value::Number(n) if n.is_finite() && n >= 0.0 => Some(n as usize),
+                        _ => None,
+                    })
+                    .unwrap_or(0);
+                (0..len)
+                    .map(|i| {
+                        tishlang_core::object_get(other, &Value::String(i.to_string().into()))
+                            .unwrap_or(Value::Null)
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            }
+        }
+    };
+    let out: Vec<Value> = match args.get(1) {
+        Some(Value::Function(f)) => items
+            .into_iter()
+            .enumerate()
+            .map(|(i, x)| f.call(&[x, Value::Number(i as f64)]))
+            .collect(),
+        _ => items,
+    };
+    Value::Array(VmRef::new(out))
+}
+
+/// `structuredClone(value)` — a recursive deep copy of arrays, objects, and primitives, with cycles
+/// preserved (a repeated reference clones to the same new node). Functions and exotic types (Date,
+/// RegExp, Map, Set) are shared/shallow — a pragmatic subset covering plain data structures.
+pub fn structured_clone(args: &[Value]) -> Value {
+    let mut seen: Vec<(*const (), Value)> = Vec::new();
+    deep_clone(args.first().unwrap_or(&Value::Null), &mut seen)
+}
+
+fn deep_clone(v: &Value, seen: &mut Vec<(*const (), Value)>) -> Value {
+    match v {
+        Value::Array(a) => {
+            let ptr = a.as_ptr();
+            if let Some((_, c)) = seen.iter().find(|(p, _)| *p == ptr) {
+                return c.clone();
+            }
+            let new: VmRef<Vec<Value>> = VmRef::new(Vec::new());
+            seen.push((ptr, Value::Array(new.clone())));
+            let src = a.borrow().clone();
+            let cloned: Vec<Value> = src.iter().map(|e| deep_clone(e, seen)).collect();
+            *new.borrow_mut() = cloned;
+            Value::Array(new)
+        }
+        Value::NumberArray(a) => Value::NumberArray(VmRef::new(a.borrow().clone())),
+        Value::Object(o) => {
+            let ptr = o.as_ptr();
+            if let Some((_, c)) = seen.iter().find(|(p, _)| *p == ptr) {
+                return c.clone();
+            }
+            let entries: Vec<(Arc<str>, Value)> = o
+                .borrow()
+                .strings
+                .iter()
+                .map(|(k, val)| (k.clone(), val.clone()))
+                .collect();
+            let new_obj = Value::object(ObjectMap::default());
+            // register the (empty) new object before recursing so cycles resolve back to it
+            if let Value::Object(no) = &new_obj {
+                seen.push((ptr, new_obj.clone()));
+                for (k, val) in entries {
+                    let cloned = deep_clone(&val, seen);
+                    no.borrow_mut().strings.insert(k, cloned);
+                }
+            }
+            new_obj
+        }
+        other => other.clone(),
+    }
+}
+
+/// `Object.hasOwn(obj, key)` (ES2022) — true if `key` is an OWN property of `obj`. For arrays an
+/// in-range integer index or `"length"` counts; for plain objects, a key present in the string map.
+pub fn object_has_own(args: &[Value]) -> Value {
+    let key = match args.get(1) {
+        Some(Value::String(s)) => s.to_string(),
+        Some(Value::Number(n)) => tishlang_core::js_number_to_string(*n),
+        Some(v) => v.to_display_string(),
+        None => return Value::Bool(false),
+    };
+    match args.first() {
+        Some(Value::Object(obj)) => Value::Bool(obj.borrow().strings.contains_key(key.as_str())),
+        Some(Value::Array(arr)) => Value::Bool(
+            key == "length" || matches!(key.parse::<usize>(), Ok(i) if i < arr.borrow().len()),
+        ),
+        Some(Value::NumberArray(arr)) => Value::Bool(
+            key == "length" || matches!(key.parse::<usize>(), Ok(i) if i < arr.borrow().len()),
+        ),
+        _ => Value::Bool(false),
+    }
+}
+
+/// `Object.is(a, b)` — SameValue: like `===`, but NaN equals NaN and `+0` is NOT equal to `-0`.
+pub fn object_is(args: &[Value]) -> Value {
+    let a = args.first().unwrap_or(&Value::Null);
+    let b = args.get(1).unwrap_or(&Value::Null);
+    let same = match (a, b) {
+        (Value::Number(x), Value::Number(y)) => {
+            if x.is_nan() && y.is_nan() {
+                true
+            } else if *x == 0.0 && *y == 0.0 {
+                x.is_sign_negative() == y.is_sign_negative()
+            } else {
+                x == y
+            }
+        }
+        _ => a.strict_eq(b),
+    };
+    Value::Bool(same)
+}
+
 /// String(value) — convert value to string (JS String constructor as function).
 /// Uses JS `ToString` (arrays comma-join recursively, objects → "[object Object]"),
 /// not the inspect/display form.
@@ -64,8 +215,14 @@ pub fn string_convert(args: &[Value]) -> Value {
 /// otherwise NaN); arrays/objects go via their string form (so `Number([5])` → 5,
 /// `Number([])` → 0, objects → NaN).
 pub fn number_convert(args: &[Value]) -> Value {
-    let v = args.first().unwrap_or(&Value::Null);
-    let n = match v {
+    Value::Number(to_number(args.first().unwrap_or(&Value::Null)))
+}
+
+/// JS `ToNumber(v)`: Number → itself; Bool → 1/0; Null → 0; String → parsed (trimmed, `0x`/`0b`/`0o`
+/// and `Infinity`; `""` → 0, else NaN); anything else via its string form. The single ToNumber path
+/// shared by `Number()`, `isNaN`/`isFinite`, etc.
+pub fn to_number(v: &Value) -> f64 {
+    match v {
         Value::Number(n) => *n,
         Value::Bool(b) => {
             if *b {
@@ -77,8 +234,29 @@ pub fn number_convert(args: &[Value]) -> Value {
         Value::Null => 0.0,
         Value::String(s) => parse_numeric_string(s),
         other => parse_numeric_string(&other.to_js_string()),
-    };
-    Value::Number(n)
+    }
+}
+
+/// `Number.isInteger(v)` — true iff `v` IS a finite Number with no fractional part. No coercion
+/// (`Number.isInteger("3")` is `false`, unlike a bare `isNaN`-style coercion).
+pub fn number_is_integer(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Number(n)) if n.is_finite() && n.fract() == 0.0))
+}
+
+/// `Number.isSafeInteger(v)` — `isInteger` AND exactly representable (|v| ≤ 2^53 − 1).
+pub fn number_is_safe_integer(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(),
+        Some(Value::Number(n)) if n.is_finite() && n.fract() == 0.0 && n.abs() <= 9_007_199_254_740_991.0))
+}
+
+/// `Number.isNaN(v)` — true iff `v` IS the number NaN. No coercion (unlike the global `isNaN`).
+pub fn number_is_nan(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Number(n)) if n.is_nan()))
+}
+
+/// `Number.isFinite(v)` — true iff `v` is a finite Number. No coercion (unlike the global `isFinite`).
+pub fn number_is_finite(args: &[Value]) -> Value {
+    Value::Bool(matches!(args.first(), Some(Value::Number(n)) if n.is_finite()))
 }
 
 /// Parse a string as JS `Number` does: trimmed; `""` → 0; `0x`/`0o`/`0b` radix prefixes;
@@ -120,16 +298,28 @@ pub fn string_from_char_code(args: &[Value]) -> Value {
 
 /// Object.keys(obj)
 pub fn object_keys(args: &[Value]) -> Value {
-    if let Some(Value::Object(obj)) = args.first() {
-        let obj_borrow = obj.borrow();
-        let keys: Vec<Value> = obj_borrow
-            .strings
-            .keys()
-            .map(|k| Value::String(tishlang_core::ArcStr::from(k.as_ref())))
-            .collect();
-        Value::Array(VmRef::new(keys))
-    } else {
-        Value::Array(VmRef::new(Vec::new()))
+    match args.first() {
+        Some(Value::Object(obj)) => {
+            let obj_borrow = obj.borrow();
+            let keys: Vec<Value> = obj_borrow
+                .strings
+                .keys()
+                .map(|k| Value::String(tishlang_core::ArcStr::from(k.as_ref())))
+                .collect();
+            Value::Array(VmRef::new(keys))
+        }
+        // `Object.keys(array)` yields the index strings "0".."len-1" (an array's own enumerable keys
+        // are its indices, per JS). Previously returned `[]` — a node divergence, and the reason
+        // `for (k in array)` enumerated nothing on the vm/native backends (they lower for-in to
+        // for-of over `Object.keys`).
+        Some(Value::Array(arr)) => {
+            let len = arr.borrow().len();
+            let keys: Vec<Value> = (0..len)
+                .map(|i| Value::String(tishlang_core::ArcStr::from(i.to_string().as_str())))
+                .collect();
+            Value::Array(VmRef::new(keys))
+        }
+        _ => Value::Array(VmRef::new(Vec::new())),
     }
 }