@tishlang/tish-lsp 2.16.13 → 2.35.0

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())),
     }
 }
 

package/crates/tish_builtins/src/math.rs

@@ -1,7 +1,7 @@
 //! Math builtin functions.
 
 use crate::helpers::extract_num;
-use tishlang_core::Value;
+use tishlang_core::{to_int32, to_uint32, Value};
 
 macro_rules! math_unary {
     ($name:ident, $op:ident) => {
@@ -28,6 +28,20 @@ math_unary!(log2, log2);
 math_unary!(exp, exp);
 math_unary!(trunc, trunc);
 math_unary!(cbrt, cbrt);
+math_unary!(expm1, exp_m1);
+math_unary!(log1p, ln_1p);
+
+/// `Math.clz32(x)` — count leading zero bits of `ToUint32(x)` (0..=32).
+pub fn clz32(args: &[Value]) -> Value {
+    let n = to_uint32(extract_num(args.first()).unwrap_or(0.0));
+    Value::Number(n.leading_zeros() as f64)
+}
+
+/// `Math.fround(x)` — round `x` to the nearest 32-bit float, back to f64.
+pub fn fround(args: &[Value]) -> Value {
+    let x = extract_num(args.first()).unwrap_or(f64::NAN);
+    Value::Number(x as f32 as f64)
+}
 
 // --- f64-domain semantics (single source of truth) -------------------------------------------------
 // These hold the JS-specific Math rules so every backend agrees: the vm/native paths call the
@@ -119,7 +133,9 @@ pub fn sign(args: &[Value]) -> Value {
     } else if n < 0.0 {
         -1.0
     } else {
-        0.0
+        // ±0 → return the input unchanged so `Math.sign(-0)` is `-0` (per ES);
+        // `n < 0.0` is false for -0, so it lands here — bare `0.0` would drop the sign.
+        n
     })
 }
 
@@ -129,15 +145,57 @@ pub fn atan2(args: &[Value]) -> Value {
     Value::Number(y.atan2(x))
 }
 
+/// ECMAScript `Math.hypot(...args)` core: sqrt of the sum of squares, VARIADIC and
+/// NaN/Infinity-correct. Infinity takes precedence over NaN (any ±∞ arg → +∞, even alongside a NaN);
+/// otherwise any NaN → NaN; the finite case is scaled by the max magnitude to avoid intermediate
+/// overflow/underflow (matches V8). `Math.hypot()` (no args) → 0. Shared so interp/vm/native agree
+/// (#247 — the interp/native path was 2-arg only, so `Math.hypot(3,4,12)` gave 5 not 13, and the vm
+/// dropped non-number args instead of propagating NaN).
+pub fn hypot_f64(nums: &[f64]) -> f64 {
+    let mut any_nan = false;
+    let mut max = 0.0_f64;
+    for &n in nums {
+        if n.is_infinite() {
+            return f64::INFINITY;
+        }
+        if n.is_nan() {
+            any_nan = true;
+        }
+        let a = n.abs();
+        if a > max {
+            max = a;
+        }
+    }
+    if any_nan {
+        return f64::NAN;
+    }
+    if max == 0.0 {
+        return 0.0;
+    }
+    let mut sum = 0.0_f64;
+    for &n in nums {
+        let r = n / max;
+        sum += r * r;
+    }
+    max * sum.sqrt()
+}
+
 pub fn hypot(args: &[Value]) -> Value {
-    let x = extract_num(args.first()).unwrap_or(0.0);
-    let y = extract_num(args.get(1)).unwrap_or(0.0);
-    Value::Number(x.hypot(y))
+    let nums: Vec<f64> = args
+        .iter()
+        .map(|v| extract_num(Some(v)).unwrap_or(f64::NAN))
+        .collect();
+    Value::Number(hypot_f64(&nums))
 }
 
 /// ES6 `Math.imul`: 32-bit integer multiply (used by xmur3 PRNG in juke-cards).
+///
+/// Operands go through JS `ToInt32` (modulo 2³², NaN/±Infinity → 0), NOT a saturating `as i32`
+/// cast: the latter clamps any argument ≥ 2³¹ (e.g. a full uint32 hash state) to `i32::MAX` and
+/// diverges from ECMAScript / V8 (`Math.imul(3e9, 1)` = -1294967296, not 2147483647). The typed
+/// native path inlines the same ToInt32 + wrapping multiply, so all backends agree.
 pub fn imul(args: &[Value]) -> Value {
-    let a = extract_num(args.first()).unwrap_or(0.0) as i32;
-    let b = extract_num(args.get(1)).unwrap_or(0.0) as i32;
+    let a = to_int32(extract_num(args.first()).unwrap_or(0.0));
+    let b = to_int32(extract_num(args.get(1)).unwrap_or(0.0));
     Value::Number(a.wrapping_mul(b) as f64)
 }

package/crates/tish_builtins/src/number.rs

@@ -43,6 +43,179 @@ pub fn to_fixed_str(num: f64, digits: usize) -> String {
     format!("{:.*}", digits, rounded)
 }
 
+/// `Number.prototype.toExponential(fractionDigits?)` — ECMA-262 §21.1.3.2. Exponential notation with
+/// `fractionDigits` mantissa fraction digits (0–100), or the minimal digits needed when omitted. The
+/// exponent always carries an explicit sign (`1.23e+4`, `1e-7`) to match V8.
+pub fn to_exponential(n: &Value, digits: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    let d = match digits {
+        Value::Number(x) => Some((*x as i32).clamp(0, 100) as usize),
+        _ => None,
+    };
+    Value::String(to_exponential_str(num, d).into())
+}
+
+/// f64-domain core of `toExponential`, shared with the tree-walk interpreter.
+pub fn to_exponential_str(num: f64, digits: Option<usize>) -> String {
+    if num.is_nan() {
+        return "NaN".to_string();
+    }
+    if num.is_infinite() {
+        return if num < 0.0 { "-Infinity" } else { "Infinity" }.to_string();
+    }
+    let d = match digits {
+        // No fractionDigits: shortest round-trip mantissa (Rust's `{:e}` matches V8 here).
+        None => return fix_exponent_sign(&format!("{:e}", num)),
+        Some(d) => d,
+    };
+    if num == 0.0 {
+        let mant = if d == 0 {
+            "0".to_string()
+        } else {
+            format!("0.{}", "0".repeat(d))
+        };
+        return format!("{}e+0", mant);
+    }
+    let sign = if num < 0.0 { "-" } else { "" };
+    let (ds, e) = sig_digits(num.abs(), d + 1);
+    let mant = if d == 0 {
+        ds
+    } else {
+        format!("{}.{}", &ds[..1], &ds[1..])
+    };
+    let esign = if e >= 0 { "+" } else { "-" };
+    format!("{}{}e{}{}", sign, mant, esign, e.abs())
+}
+
+/// Round `x` (finite, `x > 0`) to `sig` significant decimal digits with **half-away-from-zero**
+/// rounding — ECMA's "pick the larger n" tie rule (`2.5.toPrecision(1) === "3"`, not "2"). Returns the
+/// `sig`-digit string and the base-10 exponent of the leading digit.
+///
+/// The exact value of an f64 has a finite decimal expansion; scaling it through `f64` arithmetic
+/// re-rounds and can land a genuinely-below-half value (e.g. `2.675` ≈ `2.67499…`) exactly on `.5`,
+/// corrupting the tie test. So we format with many guard digits — `{:.Ne}` gives the correctly-rounded
+/// exact-value expansion — capturing the TRUE digit at position `sig`, then round the digit string:
+/// `digit[sig] >= 5` rounds up (half-away; `== 5` is a true tie only because the guard digits show no
+/// nonzero remainder). Rust's `{:e}` alone rounds half-to-even, which is exactly what we must avoid.
+fn sig_digits(x: f64, sig: usize) -> (String, i32) {
+    let sig = sig.max(1);
+    // Guard digits push the format's own (half-to-even) rounding far to the right of digit[sig], so
+    // digit[sig] is exact. A cascade into digit[sig] would need 16 consecutive 9s — not a real input.
+    let guard = sig + 16;
+    let raw = format!("{:.*e}", guard, x);
+    let (mant, exp_str) = raw.split_once('e').unwrap();
+    let mut e: i32 = exp_str.parse().unwrap_or(0);
+    let mut digits: Vec<u8> = mant
+        .bytes()
+        .filter(u8::is_ascii_digit)
+        .map(|b| b - b'0')
+        .collect();
+    if digits.len() > sig {
+        let round_up = digits[sig] >= 5;
+        digits.truncate(sig);
+        if round_up {
+            let mut i = sig;
+            loop {
+                if i == 0 {
+                    // carry out of the leading digit: 9…9 → 1 0…0, one more place
+                    digits.insert(0, 1);
+                    digits.truncate(sig);
+                    e += 1;
+                    break;
+                }
+                i -= 1;
+                if digits[i] == 9 {
+                    digits[i] = 0;
+                } else {
+                    digits[i] += 1;
+                    break;
+                }
+            }
+        }
+    }
+    let s: String = digits.iter().map(|d| (d + b'0') as char).collect();
+    (s, e)
+}
+
+/// Rust's `{:e}` writes a bare positive exponent (`1.23e4`); JS/V8 always signs it (`1.23e+4`). Negative
+/// exponents already carry `-`.
+fn fix_exponent_sign(s: &str) -> String {
+    match s.split_once('e') {
+        Some((mantissa, exp)) if !exp.starts_with('-') && !exp.starts_with('+') => {
+            format!("{}e+{}", mantissa, exp)
+        }
+        _ => s.to_string(),
+    }
+}
+
+/// `Number.prototype.toPrecision(precision?)` — ECMA-262 §21.1.3.5. With `precision` significant digits,
+/// choosing fixed or exponential per the spec; omitted precision falls back to `ToString`. An
+/// out-of-range precision (`<1` or `>100`) parks a catchable `RangeError`.
+pub fn to_precision(n: &Value, precision: &Value) -> Value {
+    let num = match n {
+        Value::Number(x) => *x,
+        _ => f64::NAN,
+    };
+    match precision {
+        Value::Number(p) => {
+            let p = *p as i32;
+            if !(1..=100).contains(&p) && num.is_finite() {
+                tishlang_core::set_pending_throw(tishlang_core::range_error(
+                    "toPrecision() argument must be between 1 and 100",
+                ));
+                return Value::Null;
+            }
+            Value::String(to_precision_str(num, p).into())
+        }
+        // precision undefined → behave like ToString(number)
+        _ => Value::String(tishlang_core::js_number_to_string(num).into()),
+    }
+}
+
+/// f64-domain core of `toPrecision`, shared with the tree-walk interpreter. Assumes `precision` is in
+/// range (the `&Value` entry point validates and parks a RangeError otherwise).
+pub fn to_precision_str(num: f64, precision: i32) -> String {
+    if num.is_nan() {
+        return "NaN".to_string();
+    }
+    if num.is_infinite() {
+        return if num < 0.0 { "-Infinity" } else { "Infinity" }.to_string();
+    }
+    let p = precision.clamp(1, 100) as usize;
+    if num == 0.0 {
+        if p == 1 {
+            return "0".to_string();
+        }
+        return format!("0.{}", "0".repeat(p - 1));
+    }
+    let sign = if num < 0.0 { "-" } else { "" };
+    // `p` significant digits + base-10 exponent, half-away rounded (shared with toExponential).
+    let (digits, e) = sig_digits(num.abs(), p);
+    let body = if e < -6 || e >= p as i32 {
+        // exponential form
+        let mut m = String::new();
+        m.push(digits.as_bytes()[0] as char);
+        if p > 1 {
+            m.push('.');
+            m.push_str(&digits[1..]);
+        }
+        let esign = if e >= 0 { "+" } else { "-" };
+        format!("{}e{}{}", m, esign, e.abs())
+    } else if e == p as i32 - 1 {
+        digits
+    } else if e >= 0 {
+        let split = (e + 1) as usize;
+        format!("{}.{}", &digits[..split], &digits[split..])
+    } else {
+        let zeros = (-e - 1) as usize;
+        format!("0.{}{}", "0".repeat(zeros), digits)
+    };
+    format!("{}{}", sign, body)
+}
+
 /// `Number.prototype.toString([radix])` — ECMA-262 §21.1.3.6.
 ///
 /// Radix defaults to 10 (canonical JS number formatting). For radix 2–36 the value is