@tishlang/tish-format 2.16.13 → 2.36.0

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

package/crates/tish_builtins/src/string.rs

@@ -317,6 +317,59 @@ pub fn trim(s: &Value) -> Value {
     }
 }
 
+pub fn trim_start(s: &Value) -> Value {
+    if let Value::String(s) = s {
+        Value::String(s.trim_start().into())
+    } else {
+        Value::Null
+    }
+}
+
+/// Pure `String.prototype.normalize` core (ECMA-262 §22.1.3.13). `form` is one of NFC/NFD/NFKC/NFKD;
+/// returns `None` for an unrecognized form so the caller can surface a `RangeError`. Shared by every
+/// backend so interp/vm/native stay byte-identical.
+pub fn normalize_form(s: &str, form: &str) -> Option<String> {
+    use unicode_normalization::UnicodeNormalization;
+    match form {
+        "NFC" => Some(s.nfc().collect()),
+        "NFD" => Some(s.nfd().collect()),
+        "NFKC" => Some(s.nfkc().collect()),
+        "NFKD" => Some(s.nfkd().collect()),
+        _ => None,
+    }
+}
+
+/// `String.prototype.normalize(form?)` — core-`Value` entry (vm/native). An omitted form defaults to
+/// NFC; an invalid form parks a catchable `RangeError`.
+pub fn normalize(s: &Value, form: &Value) -> Value {
+    let input = match s {
+        Value::String(s) => s.as_ref(),
+        _ => return Value::Null,
+    };
+    let f: String = match form {
+        Value::Null => "NFC".to_string(),
+        Value::String(f) => f.to_string(),
+        v => v.to_display_string(),
+    };
+    match normalize_form(input, &f) {
+        Some(out) => Value::String(out.into()),
+        None => {
+            tishlang_core::set_pending_throw(tishlang_core::range_error(
+                "The normalization form should be one of NFC, NFD, NFKC, NFKD.",
+            ));
+            Value::Null
+        }
+    }
+}
+
+pub fn trim_end(s: &Value) -> Value {
+    if let Value::String(s) = s {
+        Value::String(s.trim_end().into())
+    } else {
+        Value::Null
+    }
+}
+
 pub fn to_upper_case(s: &Value) -> Value {
     if let Value::String(s) = s {
         Value::String(s.to_uppercase().into())
@@ -333,22 +386,74 @@ pub fn to_lower_case(s: &Value) -> Value {
     }
 }
 
-pub fn starts_with(s: &Value, search: &Value) -> Value {
+pub fn starts_with(s: &Value, search: &Value, position: Option<&Value>) -> Value {
     if let (Value::String(s), Value::String(search)) = (s, search) {
-        Value::Bool(s.starts_with(search.as_str()))
+        // `position`: test as if the string began at char `position` (clamped to [0, len]). Absent → 0.
+        let pos = match position {
+            Some(Value::Number(n)) if *n > 0.0 => *n as usize,
+            _ => 0,
+        };
+        let byte_start = s.char_indices().nth(pos).map(|(b, _)| b).unwrap_or(s.len());
+        Value::Bool(s[byte_start..].starts_with(search.as_str()))
     } else {
         Value::Bool(false)
     }
 }
 
-pub fn ends_with(s: &Value, search: &Value) -> Value {
+pub fn ends_with(s: &Value, search: &Value, end_position: Option<&Value>) -> Value {
     if let (Value::String(s), Value::String(search)) = (s, search) {
-        Value::Bool(s.ends_with(search.as_str()))
+        // `endPosition`: test as if the string ended at char `endPosition` (clamped to [0, len]).
+        // Absent → the full length.
+        let char_count = s.chars().count();
+        let end = match end_position {
+            Some(Value::Number(n)) if *n >= 0.0 => (*n as usize).min(char_count),
+            Some(Value::Number(_)) => 0,
+            _ => char_count,
+        };
+        let byte_end = s.char_indices().nth(end).map(|(b, _)| b).unwrap_or(s.len());
+        Value::Bool(s[..byte_end].ends_with(search.as_str()))
     } else {
         Value::Bool(false)
     }
 }
 
+/// Expand a string replacement's `$` patterns for one match: `$$`→`$`, `$&`→the match, `` $` ``→the
+/// text before it, `$'`→the text after it. Any other `$x` is literal. (String-search `replace`; the
+/// numbered `$1` captures only apply to regex replacements.)
+pub fn expand_replacement(repl: &str, matched: &str, before: &str, after: &str) -> String {
+    if !repl.contains('$') {
+        return repl.to_string();
+    }
+    let mut out = String::with_capacity(repl.len());
+    let mut chars = repl.chars().peekable();
+    while let Some(c) = chars.next() {
+        if c == '$' {
+            match chars.peek() {
+                Some('$') => {
+                    out.push('$');
+                    chars.next();
+                }
+                Some('&') => {
+                    out.push_str(matched);
+                    chars.next();
+                }
+                Some('`') => {
+                    out.push_str(before);
+                    chars.next();
+                }
+                Some('\'') => {
+                    out.push_str(after);
+                    chars.next();
+                }
+                _ => out.push('$'),
+            }
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
 fn replace_impl(s: &Value, search: &Value, replacement: &Value, all: bool) -> Value {
     if let Value::String(s) = s {
         let search_str = match search {
@@ -359,12 +464,37 @@ fn replace_impl(s: &Value, search: &Value, replacement: &Value, all: bool) -> Va
             Value::String(ss) => ss.as_str(),
             _ => "",
         };
-        let result = if all {
-            s.replace(search_str, repl_str)
-        } else {
-            s.replacen(search_str, repl_str, 1)
-        };
-        Value::String(result.into())
+        // Fast path: no `$` in the replacement (and non-empty search) → the library replace.
+        if !repl_str.contains('$') || search_str.is_empty() {
+            let result = if all {
+                s.replace(search_str, repl_str)
+            } else {
+                s.replacen(search_str, repl_str, 1)
+            };
+            return Value::String(result.into());
+        }
+        // `$`-expansion path: expand per match against the original string's before/after context.
+        let sref = s.as_str();
+        let mut out = String::with_capacity(sref.len());
+        let mut last = 0usize;
+        let mut start = 0usize;
+        while let Some(pos) = sref[start..].find(search_str) {
+            let m = start + pos;
+            out.push_str(&sref[last..m]);
+            out.push_str(&expand_replacement(
+                repl_str,
+                search_str,
+                &sref[..m],
+                &sref[m + search_str.len()..],
+            ));
+            last = m + search_str.len();
+            start = last;
+            if !all {
+                break;
+            }
+        }
+        out.push_str(&sref[last..]);
+        Value::String(out.into())
     } else {
         Value::Null
     }
@@ -507,6 +637,23 @@ pub fn char_code_at(s: &Value, idx: &Value) -> Value {
     }
 }
 
+/// `codePointAt(i)` — the Unicode code point at char index `i`, or `null` (JS `undefined`) if out of
+/// range. tish strings are code-point sequences, so this returns the same value as `charCodeAt` for
+/// an in-range index, but reads `null` (not `NaN`) past the end.
+pub fn code_point_at(s: &Value, idx: &Value) -> Value {
+    if let Value::String(s) = s {
+        let idx = match idx {
+            Value::Number(n) if *n >= 0.0 => *n as usize,
+            _ => return Value::Null,
+        };
+        char_at_idx(s, idx)
+            .map(|c| Value::Number(c as u32 as f64))
+            .unwrap_or(Value::Null)
+    } else {
+        Value::Null
+    }
+}
+
 pub fn repeat(s: &Value, count: &Value) -> Value {
     if let Value::String(s) = s {
         let count = match count {
@@ -525,12 +672,15 @@ fn pad_impl(s: &Value, target_len: &Value, pad: &Value, at_start: bool) -> Value
             Value::Number(n) => *n as usize,
             _ => return Value::String(s.clone()),
         };
+        // An *explicit* empty fill string means "no padding" (spec: `padStart(n, "")` → original,
+        // unchanged); only an ABSENT pad arg (`Value::Null`) defaults to a space. The old
+        // `if !p.is_empty()` guard conflated the two, space-padding on an explicit `""`.
         let pad_str = match pad {
-            Value::String(p) if !p.is_empty() => p.as_str(),
+            Value::String(p) => p.as_str(),
             _ => " ",
         };
         let char_count = s.chars().count();
-        if char_count >= target_len {
+        if char_count >= target_len || pad_str.is_empty() {
             return Value::String(s.clone());
         }
         let needed = target_len - char_count;
@@ -696,9 +846,12 @@ mod tests {
     fn case_and_prefix_suffix() {
         assert_same!(to_upper_case(&s("aB")), s("AB"));
         assert_same!(to_lower_case(&s("aB")), s("ab"));
-        assert_same!(starts_with(&s("/api"), &s("/api")), Value::Bool(true));
-        assert_same!(ends_with(&s("x.js"), &s(".js")), Value::Bool(true));
-        assert_same!(starts_with(&n(1.0), &s("")), Value::Bool(false));
+        assert_same!(starts_with(&s("/api"), &s("/api"), None), Value::Bool(true));
+        assert_same!(ends_with(&s("x.js"), &s(".js"), None), Value::Bool(true));
+        assert_same!(starts_with(&n(1.0), &s(""), None), Value::Bool(false));
+        // 2nd-arg: position / endPosition.
+        assert_same!(starts_with(&s("abc"), &s("bc"), Some(&n(1.0))), Value::Bool(true));
+        assert_same!(ends_with(&s("abc"), &s("ab"), Some(&n(2.0))), Value::Bool(true));
     }
 
     #[test]

package/crates/tish_bytecode/src/compiler.rs

@@ -334,10 +334,16 @@ fn stmt_rebinds(s: &Statement, name: &str) -> bool {
         }
         Statement::ForOf {
             name: n,
-            iterable,
+            iterable: e,
             body,
             ..
-        } => n.as_ref() == name || expr_rebinds(iterable, name) || stmt_rebinds(body, name),
+        }
+        | Statement::ForIn {
+            name: n,
+            object: e,
+            body,
+            ..
+        } => n.as_ref() == name || expr_rebinds(e, name) || stmt_rebinds(body, name),
         Statement::Switch {
             expr,
             cases,
@@ -504,10 +510,16 @@ fn name_rebinds_in_stmt(s: &Statement, name: &str) -> bool {
         }
         Statement::ForOf {
             name: n,
-            iterable,
+            iterable: e,
             body,
             ..
-        } => n.as_ref() == name || expr_rebinds(iterable, name) || name_rebinds_in_stmt(body, name),
+        }
+        | Statement::ForIn {
+            name: n,
+            object: e,
+            body,
+            ..
+        } => n.as_ref() == name || expr_rebinds(e, name) || name_rebinds_in_stmt(body, name),
         Statement::Switch {
             expr,
             cases,
@@ -1803,6 +1815,46 @@ impl<'a> Compiler<'a> {
                 self.emit(Opcode::LoopVarsEnd);
                 self.exit_block_scope();
             }
+            Statement::ForIn {
+                name,
+                name_span,
+                object,
+                body,
+                span,
+            } => {
+                // Lower `for (let k in obj)` to `for (let k of Object.keys(obj))` (#413): Object.keys
+                // yields exactly the own enumerable keys the interpreter enumerates — insertion order
+                // for objects, index strings for arrays, and `[]` for a non-object (so `for (k in
+                // null)` no-ops). Reuses the whole for-of iteration path.
+                let dummy = Span {
+                    start: (0, 0),
+                    end: (0, 0),
+                };
+                let keys_call = Expr::Call {
+                    callee: Box::new(Expr::Member {
+                        object: Box::new(Expr::Ident {
+                            name: Arc::from("Object"),
+                            span: dummy,
+                        }),
+                        prop: MemberProp::Name {
+                            name: Arc::from("keys"),
+                            span: dummy,
+                        },
+                        optional: false,
+                        span: dummy,
+                    }),
+                    args: vec![CallArg::Expr(object.clone())],
+                    span: dummy,
+                };
+                let lowered = Statement::ForOf {
+                    name: Arc::clone(name),
+                    name_span: *name_span,
+                    iterable: keys_call,
+                    body: body.clone(),
+                    span: *span,
+                };
+                self.compile_statement(&lowered)?;
+            }
             Statement::Return { value, .. } => {
                 // Evaluate the return value first (JS order), then run any enclosing `finally`
                 // blocks (they're stack-neutral, so the value stays on top), then return.

package/crates/tish_bytecode/src/opcode.rs

@@ -258,7 +258,9 @@ impl MathUnaryFn {
                 }
             }
             MathUnaryFn::Trunc => x.trunc(),
-            // JS `Math.sign` (matches `tishlang_builtins::math::sign`): NaN→NaN, else ±1, and 0/-0→+0.
+            // JS `Math.sign` (matches `tishlang_builtins::math::sign`): NaN→NaN, else ±1; and for
+            // ±0 return `x` unchanged so `Math.sign(-0)` is `-0` (`x < 0.0` is false for -0, so it
+            // lands in the else — bare `0.0` would drop the sign).
             MathUnaryFn::Sign => {
                 if x.is_nan() {
                     f64::NAN
@@ -267,7 +269,7 @@ impl MathUnaryFn {
                 } else if x < 0.0 {
                     -1.0
                 } else {
-                    0.0
+                    x
                 }
             }
             MathUnaryFn::Sin => x.sin(),