//! JavaScript semantics helpers shared by the whole port.
//!
//! Everything here reproduces ECMAScript / V8 behavior bit for bit so that
//! numbers, strings, and math results the JS engine would have produced come
//! out identical from the Rust side. Nothing in this module touches I/O.

// ─── Whitespace and string helpers ──────────────────────────────────────────

/// The characters JS `String.prototype.trim` and the regex `\s` class treat as
/// whitespace: ECMA-262 WhiteSpace (TAB, VT, FF, SP, NBSP, ZWNBSP, and the
/// Unicode `Zs` category) plus LineTerminator (LF, CR, LS, PS).
pub fn is_js_whitespace(c: char) -> bool {
    matches!(
        c,
        '\u{0009}'
            | '\u{000A}'
            | '\u{000B}'
            | '\u{000C}'
            | '\u{000D}'
            | '\u{0020}'
            | '\u{00A0}'
            | '\u{1680}'
            | '\u{2000}'
            ..='\u{200A}'
                | '\u{2028}'
                | '\u{2029}'
                | '\u{202F}'
                | '\u{205F}'
                | '\u{3000}'
                | '\u{FEFF}'
    )
}

/// The body of a regex character class matching exactly the JS `\s` set, for
/// splicing into `regex` crate patterns (whose `\s` is Unicode White_Space and
/// differs at U+0085 and U+FEFF).
pub const WS_CHARS: &str = r"\t\n\x0B\x0C\r \x{A0}\x{1680}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}\x{FEFF}";

/// A regex class equal to JS `\s`.
pub const WS: &str = r"[\t\n\x0B\x0C\r \x{A0}\x{1680}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}\x{FEFF}]";

/// JS `String.prototype.trim`.
pub fn trim(s: &str) -> &str {
    s.trim_matches(is_js_whitespace)
}

/// JS `String.prototype.trimStart`.
pub fn trim_start(s: &str) -> &str {
    s.trim_start_matches(is_js_whitespace)
}

/// JS `String.prototype.toLowerCase` (Unicode default full case mapping;
/// Rust's `to_lowercase` implements the same mapping including final sigma).
pub fn to_lower_case(s: &str) -> String {
    s.to_lowercase()
}

/// JS `String.prototype.toUpperCase`.
pub fn to_upper_case(s: &str) -> String {
    s.to_uppercase()
}

/// Expand an ASCII keyword into a case-insensitive regex fragment
/// (`oklch` -> `[oO][kK][lL][cC][hH]`). JS non-unicode `/i` never lets a
/// non-ASCII character match an ASCII one, so this is exactly its behavior
/// for ASCII literals, unlike the regex crate's Unicode case folding.
pub fn ci(word: &str) -> String {
    let mut out = String::with_capacity(word.len() * 4);
    for c in word.chars() {
        if c.is_ascii_alphabetic() {
            out.push('[');
            out.push(c.to_ascii_lowercase());
            out.push(c.to_ascii_uppercase());
            out.push(']');
        } else {
            out.push_str(&regex::escape(&c.to_string()));
        }
    }
    out
}

// ─── Number -> string ───────────────────────────────────────────────────────

/// Shortest round-trip decimal digits of a positive finite f64, as
/// (digits, n) where value = 0.d1d2..dk × 10^n, i.e. ECMA-262's (s, k, n)
/// with `digits.len() == k`.
fn shortest_digits(v: f64) -> (String, i32) {
    debug_assert!(v.is_finite() && v > 0.0);
    // Rust's `{:e}` is the shortest representation that round-trips.
    let s = format!("{:e}", v);
    let (mant, exp) = s.split_once('e').expect("exp form");
    let exp: i32 = exp.parse().expect("exp int");
    let mut digits: String = mant.chars().filter(|c| *c != '.').collect();
    // ECMA-262 Number::toString: when two shortest candidates are equally
    // close to x, choose the even one. Rust picks the upper one. A tie means
    // the exact expansion of x has exactly k+1 significant digits ending in
    // 5; check cheaply at 21 digits, then confirm on the exact expansion.
    let k = digits.len();
    if k < 17 {
        let probe = exact_sig_digits(v, 20);
        if probe.len() == k + 1 && probe.ends_with('5') {
            let exact = exact_sig_digits(v, 1100);
            if exact.len() == k + 1 && exact.ends_with('5') {
                let lower = &exact[..k];
                let last = lower.as_bytes()[k - 1] - b'0';
                if last % 2 == 0 {
                    digits = lower.to_string();
                } else {
                    let mut up = lower.as_bytes().to_vec();
                    let mut i = k;
                    loop {
                        if i == 0 {
                            up.insert(0, b'1');
                            break;
                        }
                        i -= 1;
                        if up[i] == b'9' {
                            up[i] = b'0';
                        } else {
                            up[i] += 1;
                            break;
                        }
                    }
                    let mut up = String::from_utf8(up).unwrap();
                    while up.len() > 1 && up.ends_with('0') {
                        up.pop();
                    }
                    digits = up;
                }
            }
        }
    }
    // mant is d.ddd × 10^exp = 0.dddd × 10^(exp+1)
    (digits, exp + 1)
}

/// Significant digits of `v` rounded (half-even) to `prec + 1` digits, with
/// trailing zeros removed. `prec = 1100` yields the exact expansion.
fn exact_sig_digits(v: f64, prec: usize) -> String {
    let s = format!("{:.*e}", prec, v);
    let (mant, _) = s.split_once('e').expect("exp form");
    let mut digits: String = mant.chars().filter(|c| *c != '.').collect();
    while digits.len() > 1 && digits.ends_with('0') {
        digits.pop();
    }
    digits
}

/// JS `Number.prototype.toString()` (radix 10), per ECMA-262 Number::toString.
pub fn number_to_string(v: f64) -> String {
    if v.is_nan() {
        return "NaN".to_string();
    }
    if v == 0.0 {
        return "0".to_string();
    }
    if v.is_infinite() {
        return if v > 0.0 {
            "Infinity".to_string()
        } else {
            "-Infinity".to_string()
        };
    }
    if v < 0.0 {
        return format!("-{}", number_to_string(-v));
    }
    let (digits, n) = shortest_digits(v);
    let k = digits.len() as i32;
    if k <= n && n <= 21 {
        let mut out = digits;
        for _ in 0..(n - k) {
            out.push('0');
        }
        return out;
    }
    if 0 < n && n <= 21 {
        let (a, b) = digits.split_at(n as usize);
        return format!("{}.{}", a, b);
    }
    if -6 < n && n <= 0 {
        let mut out = String::from("0.");
        for _ in 0..(-n) {
            out.push('0');
        }
        out.push_str(&digits);
        return out;
    }
    let e = n - 1;
    let sign = if e < 0 { '-' } else { '+' };
    if k == 1 {
        return format!("{}e{}{}", digits, sign, e.abs());
    }
    let (a, b) = digits.split_at(1);
    format!("{}.{}e{}{}", a, b, sign, e.abs())
}

/// The next representable double above `v` (for positive finite `v`).
fn next_double(v: f64) -> f64 {
    if v.is_nan() || v == f64::INFINITY {
        return v;
    }
    if v == 0.0 {
        return f64::from_bits(1);
    }
    let bits = v.to_bits();
    if v > 0.0 {
        f64::from_bits(bits + 1)
    } else {
        f64::from_bits(bits - 1)
    }
}

/// Unbiased exponent of the double's integer-mantissa form (V8 `Double::Exponent`).
fn double_exponent(v: f64) -> i32 {
    let bits = v.to_bits();
    let biased = ((bits >> 52) & 0x7ff) as i32;
    if biased == 0 {
        // Denormal
        return -1074;
    }
    biased - 1075
}

/// JS `Number.prototype.toString(radix)` for radix 2..36 (V8's
/// `DoubleToRadixCString`). Radix 10 delegates to [`number_to_string`].
pub fn number_to_string_radix(value: f64, radix: u32) -> String {
    if radix == 10 {
        return number_to_string(value);
    }
    if value.is_nan() {
        return "NaN".to_string();
    }
    if value == 0.0 {
        return "0".to_string();
    }
    if value.is_infinite() {
        return if value > 0.0 {
            "Infinity".to_string()
        } else {
            "-Infinity".to_string()
        };
    }
    const CHARS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
    let radix_f = radix as f64;
    let negative = value < 0.0;
    let value = if negative { -value } else { value };
    let mut integer = value.floor();
    let mut fraction = value - integer;
    let mut delta = 0.5 * (next_double(value) - value);
    delta = delta.max(next_double(0.0));
    let mut frac_digits: Vec<u8> = Vec::new();
    if fraction >= delta {
        loop {
            fraction *= radix_f;
            delta *= radix_f;
            let digit = fraction as i32;
            frac_digits.push(CHARS[digit as usize]);
            fraction -= digit as f64;
            if fraction > 0.5 || (fraction == 0.5 && (digit & 1) == 1) {
                if fraction + delta > 1.0 {
                    // Carry over into already written digits.
                    loop {
                        match frac_digits.pop() {
                            None => {
                                integer += 1.0;
                                break;
                            }
                            Some(c) => {
                                let d = if c > b'9' {
                                    (c - b'a') as u32 + 10
                                } else {
                                    (c - b'0') as u32
                                };
                                if d + 1 < radix {
                                    frac_digits.push(CHARS[(d + 1) as usize]);
                                    break;
                                }
                            }
                        }
                    }
                    break;
                }
            }
            if !(fraction >= delta) {
                break;
            }
        }
    }
    // Integer digits, filling unrepresented low digits with zero.
    let mut int_digits: Vec<u8> = Vec::new();
    while double_exponent(integer / radix_f) > 0 {
        integer /= radix_f;
        int_digits.push(b'0');
    }
    loop {
        let remainder = integer % radix_f;
        int_digits.push(CHARS[remainder as usize]);
        integer = (integer - remainder) / radix_f;
        if !(integer > 0.0) {
            break;
        }
    }
    let mut out = String::new();
    if negative {
        out.push('-');
    }
    for &c in int_digits.iter().rev() {
        out.push(c as char);
    }
    if !frac_digits.is_empty() {
        out.push('.');
        for &c in &frac_digits {
            out.push(c as char);
        }
    }
    out
}

/// JS `Number.prototype.toFixed(digits)`: rounds the exact decimal expansion
/// half-up (ties pick the larger n), unlike Rust's ties-to-even formatting.
pub fn to_fixed(v: f64, digits: usize) -> String {
    if !v.is_finite() {
        return number_to_string(v);
    }
    if v.abs() >= 1e21 {
        return number_to_string(v);
    }
    if v < 0.0 {
        return format!("-{}", to_fixed(-v, digits));
    }
    // Exact decimal expansion of the double (a double has at most 1074
    // fractional digits, so 1100 places is exact with trailing zeros).
    let exact = format!("{:.1100}", v.abs());
    let (int_part, frac_part) = exact.split_once('.').expect("fixed form");
    let keep = &frac_part[..digits];
    let rest = &frac_part[digits..];
    let round_up = match rest.as_bytes().first() {
        None => false,
        Some(&c) => c > b'5' || (c == b'5'), // remainder >= .5 rounds up (half-up)
    };
    let mut buf: Vec<u8> = format!("{}{}", int_part, keep).into_bytes();
    if round_up {
        let mut i = buf.len();
        loop {
            if i == 0 {
                buf.insert(0, b'1');
                break;
            }
            i -= 1;
            if buf[i] == b'9' {
                buf[i] = b'0';
            } else {
                buf[i] += 1;
                break;
            }
        }
    }
    let int_len = buf.len() - digits;
    let mut out = String::from_utf8(buf[..int_len].to_vec()).unwrap();
    if digits > 0 {
        out.push('.');
        out.push_str(std::str::from_utf8(&buf[int_len..]).unwrap());
    }
    out
}

// ─── String -> number ───────────────────────────────────────────────────────

fn scan_decimal_prefix(s: &str) -> Option<(usize, String)> {
    // Returns (byte length consumed, normalized literal for Rust parsing).
    let b = s.as_bytes();
    let mut i = 0;
    let mut norm = String::new();
    if i < b.len() && (b[i] == b'+' || b[i] == b'-') {
        if b[i] == b'-' {
            norm.push('-');
        }
        i += 1;
    }
    if s[i..].starts_with("Infinity") {
        norm.push_str("inf");
        return Some((i + "Infinity".len(), norm));
    }
    let int_start = i;
    while i < b.len() && b[i].is_ascii_digit() {
        i += 1;
    }
    let int_digits = &s[int_start..i];
    let mut frac_digits = "";
    let mut consumed = i;
    if i < b.len() && b[i] == b'.' {
        let fs = i + 1;
        let mut j = fs;
        while j < b.len() && b[j].is_ascii_digit() {
            j += 1;
        }
        frac_digits = &s[fs..j];
        if !int_digits.is_empty() || !frac_digits.is_empty() {
            consumed = j;
        }
    }
    if int_digits.is_empty() && frac_digits.is_empty() {
        return None;
    }
    // Exponent
    let mut exp = String::new();
    if consumed < b.len() && (b[consumed] == b'e' || b[consumed] == b'E') {
        let mut j = consumed + 1;
        let mut e = String::from("e");
        if j < b.len() && (b[j] == b'+' || b[j] == b'-') {
            e.push(b[j] as char);
            j += 1;
        }
        let ds = j;
        while j < b.len() && b[j].is_ascii_digit() {
            j += 1;
        }
        if j > ds {
            e.push_str(&s[ds..j]);
            exp = e;
            consumed = j;
        }
    }
    if int_digits.is_empty() {
        norm.push('0');
    } else {
        norm.push_str(int_digits);
    }
    if !frac_digits.is_empty() {
        norm.push('.');
        norm.push_str(frac_digits);
    }
    norm.push_str(&exp);
    Some((consumed, norm))
}

/// JS global `parseFloat`.
pub fn parse_float(s: &str) -> f64 {
    let t = trim_start(s);
    match scan_decimal_prefix(t) {
        None => f64::NAN,
        Some((_, norm)) => norm.parse::<f64>().unwrap_or(f64::NAN),
    }
}

/// JS `Number(string)` / unary `+` on a string (StringToNumber).
pub fn string_to_number(s: &str) -> f64 {
    let t = trim(s);
    if t.is_empty() {
        return 0.0;
    }
    let lower_prefix = |p: &str| {
        t.len() > 2 && t.as_bytes()[0] == b'0' && (t.as_bytes()[1] | 0x20) == p.as_bytes()[1]
    };
    if lower_prefix("0x") {
        return parse_radix_digits(&t[2..], 16).unwrap_or(f64::NAN);
    }
    if lower_prefix("0o") {
        return parse_radix_digits(&t[2..], 8).unwrap_or(f64::NAN);
    }
    if lower_prefix("0b") {
        return parse_radix_digits(&t[2..], 2).unwrap_or(f64::NAN);
    }
    match scan_decimal_prefix(t) {
        Some((n, norm)) if n == t.len() => norm.parse::<f64>().unwrap_or(f64::NAN),
        _ => f64::NAN,
    }
}

fn parse_radix_digits(s: &str, radix: u32) -> Option<f64> {
    if s.is_empty() {
        return None;
    }
    let mut v = 0.0f64;
    for c in s.chars() {
        let d = c.to_digit(radix)?;
        v = v * radix as f64 + d as f64;
    }
    Some(v)
}

/// JS global `parseInt(string, radix)`. `radix == 0` means "auto" (10, or 16
/// after a `0x` prefix). Returns NaN when no digit can be read.
pub fn parse_int(s: &str, radix: u32) -> f64 {
    let mut t = trim_start(s);
    let mut sign = 1.0;
    if let Some(rest) = t.strip_prefix('-') {
        sign = -1.0;
        t = rest;
    } else if let Some(rest) = t.strip_prefix('+') {
        t = rest;
    }
    let mut r = radix;
    let mut strip_prefix = true;
    if r != 0 {
        if !(2..=36).contains(&r) {
            return f64::NAN;
        }
        if r != 16 {
            strip_prefix = false;
        }
    } else {
        r = 10;
    }
    if strip_prefix && (t.starts_with("0x") || t.starts_with("0X")) {
        t = &t[2..];
        r = 16;
    }
    let end = t
        .chars()
        .take_while(|c| c.to_digit(r).is_some())
        .map(|c| c.len_utf8())
        .sum::<usize>();
    if end == 0 {
        return f64::NAN;
    }
    let digits = &t[..end];
    let v = if r == 10 {
        digits.parse::<f64>().unwrap_or(f64::NAN)
    } else {
        parse_radix_digits(digits, r).unwrap_or(f64::NAN)
    };
    sign * v
}

// ─── Math ───────────────────────────────────────────────────────────────────

/// JS `Math.round`: nearest integer, ties toward +∞, preserving -0.
pub fn math_round(x: f64) -> f64 {
    if !x.is_finite() {
        return x;
    }
    let f = x.floor();
    let diff = x - f;
    let r = if diff >= 0.5 { f + 1.0 } else { f };
    if r == 0.0 && x < 0.0 {
        -0.0
    } else {
        r
    }
}

/// JS `Math.max` over two values (NaN-propagating, +0 beats -0).
pub fn math_max(a: f64, b: f64) -> f64 {
    if a.is_nan() || b.is_nan() {
        return f64::NAN;
    }
    if a == 0.0 && b == 0.0 {
        return if a.is_sign_negative() && b.is_sign_negative() {
            -0.0
        } else {
            0.0
        };
    }
    if a > b {
        a
    } else {
        b
    }
}

/// JS `Math.min` over two values (NaN-propagating, -0 beats +0).
pub fn math_min(a: f64, b: f64) -> f64 {
    if a.is_nan() || b.is_nan() {
        return f64::NAN;
    }
    if a == 0.0 && b == 0.0 {
        return if a.is_sign_negative() || b.is_sign_negative() {
            -0.0
        } else {
            0.0
        };
    }
    if a < b {
        a
    } else {
        b
    }
}

/// JS `Math.max(a, b, c)`.
pub fn math_max3(a: f64, b: f64, c: f64) -> f64 {
    math_max(math_max(a, b), c)
}

/// JS `Math.min(a, b, c)`.
pub fn math_min3(a: f64, b: f64, c: f64) -> f64 {
    math_min(math_min(a, b), c)
}

/// JS `Math.hypot(...values)` as V8 computes it: scale by the max, Kahan-sum
/// the squares, `sqrt(sum) * max`.
pub fn math_hypot(values: &[f64]) -> f64 {
    if values.is_empty() {
        return 0.0;
    }
    let mut one_nan = false;
    let mut max = 0.0f64;
    let mut abs: Vec<f64> = Vec::with_capacity(values.len());
    for &v in values {
        if v.is_nan() {
            one_nan = true;
            abs.push(0.0);
        } else {
            let a = v.abs();
            abs.push(a);
            if a > max {
                max = a;
            }
        }
    }
    if max == f64::INFINITY {
        return f64::INFINITY;
    }
    if one_nan {
        return f64::NAN;
    }
    if max == 0.0 {
        return 0.0;
    }
    let mut sum = 0.0f64;
    let mut compensation = 0.0f64;
    for a in abs {
        let n = a / max;
        let summand = n * n - compensation;
        let preliminary = sum + summand;
        compensation = (preliminary - sum) - summand;
        sum = preliminary;
    }
    sum.sqrt() * max
}

/// JS `Math.sin` as V8 computes it in Node: fdlibm `sin` (Node builds V8
/// without `V8_USE_LIBM_TRIG_FUNCTIONS`, so `base::ieee754::sin` is fdlibm).
pub fn math_sin(x: f64) -> f64 {
    crate::fdlibm_trig::fdlibm_sin(x)
}

/// JS `Math.cos` as V8 computes it in Node (see [`math_sin`]).
pub fn math_cos(x: f64) -> f64 {
    crate::fdlibm_trig::fdlibm_cos(x)
}

/// JS `Math.pow` / `**` as V8 computes it (`v8::internal::math::pow` with
/// `--use-std-math-pow`, the default): the ECMAScript special cases, then
/// `std::pow` from the platform libm, which is what `f64::powf` calls.
pub fn math_pow(x: f64, y: f64) -> f64 {
    if y.is_nan() {
        return f64::NAN;
    }
    if y.is_infinite() && (x == 1.0 || x == -1.0) {
        return f64::NAN;
    }
    if y == 2.0 {
        return x * x;
    }
    if y == 0.5 {
        if x.is_infinite() {
            return f64::INFINITY;
        }
        return (x + 0.0).sqrt();
    }
    x.powf(y)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn number_to_string_cases() {
        assert_eq!(number_to_string(0.1 + 0.2), "0.30000000000000004");
        assert_eq!(number_to_string(1e21), "1e+21");
        assert_eq!(
            number_to_string(123456789012345680000.0),
            "123456789012345680000"
        );
        assert_eq!(number_to_string(5e-7), "5e-7");
        assert_eq!(number_to_string(0.000001), "0.000001");
        assert_eq!(number_to_string(-0.0), "0");
        assert_eq!(number_to_string(f64::NAN), "NaN");
        assert_eq!(number_to_string(f64::INFINITY), "Infinity");
        assert_eq!(number_to_string(f64::NEG_INFINITY), "-Infinity");
        assert_eq!(number_to_string(1.0), "1");
        assert_eq!(number_to_string(-1.5), "-1.5");
        assert_eq!(
            number_to_string(1.7976931348623157e308),
            "1.7976931348623157e+308"
        );
        assert_eq!(number_to_string(5e-324), "5e-324");
        assert_eq!(number_to_string(1234.5678), "1234.5678");
        assert_eq!(number_to_string(1.5e-7), "1.5e-7");
        assert_eq!(number_to_string(100.0), "100");
        assert_eq!(number_to_string(255.0), "255");
        // Shortest-digit ties pick the even candidate (ECMA-262), not the upper.
        assert_eq!(number_to_string(980014115057302.25), "980014115057302.2");
        assert_eq!(number_to_string(896675801537170.25), "896675801537170.2");
        assert_eq!(number_to_string(-980014115057302.25), "-980014115057302.2");
    }

    #[test]
    fn number_to_string_radix_cases() {
        assert_eq!(number_to_string_radix(255.0, 16), "ff");
        assert_eq!(number_to_string_radix(0.0, 16), "0");
        assert_eq!(number_to_string_radix(10.0, 16), "a");
        assert_eq!(number_to_string_radix(255.5, 16), "ff.8");
        assert_eq!(number_to_string_radix(-255.0, 16), "-ff");
        assert_eq!(number_to_string_radix(0.1, 16), "0.1999999999999a");
        assert_eq!(number_to_string_radix(f64::NAN, 16), "NaN");
        assert_eq!(number_to_string_radix(1e21, 16), "3635c9adc5dea00000");
    }

    #[test]
    fn to_fixed_cases() {
        assert_eq!(to_fixed(2.5, 0), "3");
        assert_eq!(to_fixed(1.005, 2), "1.00");
        assert_eq!(to_fixed(1.5, 0), "2");
        assert_eq!(to_fixed(0.5, 0), "1");
        assert_eq!(to_fixed(-2.5, 0), "-3");
        assert_eq!(to_fixed(-0.0001, 2), "-0.00");
        assert_eq!(to_fixed(0.0, 2), "0.00");
        assert_eq!(to_fixed(-0.0, 2), "0.00");
        assert_eq!(to_fixed(1e21, 2), "1e+21");
        assert_eq!(to_fixed(4.35, 1), "4.3");
        assert_eq!(to_fixed(4.45, 1), "4.5");
        assert_eq!(to_fixed(9.995, 2), "9.99");
        assert_eq!(to_fixed(99.5, 0), "100");
        assert_eq!(to_fixed(0.000001, 7), "0.0000010");
        assert_eq!(to_fixed(f64::NAN, 2), "NaN");
        assert_eq!(to_fixed(3.6, 1), "3.6");
        assert_eq!(to_fixed(1.45, 1), "1.4");
        assert_eq!(to_fixed(8.345, 2), "8.35");
    }

    #[test]
    fn parse_float_cases() {
        assert_eq!(parse_float("  1.5abc"), 1.5);
        assert!(parse_float("abc").is_nan());
        assert!(parse_float("").is_nan());
        assert!(parse_float(".").is_nan());
        assert_eq!(parse_float(".5"), 0.5);
        assert_eq!(parse_float("1."), 1.0);
        assert_eq!(parse_float("1e"), 1.0);
        assert_eq!(parse_float("1e3x"), 1000.0);
        assert_eq!(parse_float("-.5"), -0.5);
        assert_eq!(parse_float("1.2.3"), 1.2);
        assert!(parse_float("--5").is_nan());
        assert_eq!(parse_float("Infinityx"), f64::INFINITY);
        assert_eq!(parse_float("-Infinity"), f64::NEG_INFINITY);
        assert_eq!(parse_float("\u{a0}\u{feff}42"), 42.0);
        assert!(parse_float("0x10").is_nan() == false && parse_float("0x10") == 0.0);
        assert_eq!(parse_float("21.5%"), 21.5);
    }

    #[test]
    fn string_to_number_cases() {
        assert_eq!(string_to_number(""), 0.0);
        assert_eq!(string_to_number("  "), 0.0);
        assert_eq!(string_to_number("12"), 12.0);
        assert_eq!(string_to_number("1."), 1.0);
        assert_eq!(string_to_number(".5"), 0.5);
        assert!(string_to_number("1.2.3").is_nan());
        assert!(string_to_number(".").is_nan());
        assert!(string_to_number("1e").is_nan());
        assert_eq!(string_to_number("0x10"), 16.0);
        assert_eq!(string_to_number("-Infinity"), f64::NEG_INFINITY);
        assert_eq!(string_to_number("+.5"), 0.5);
    }

    #[test]
    fn parse_int_cases() {
        assert_eq!(parse_int("ff", 16), 255.0);
        assert_eq!(parse_int("0xff", 16), 255.0);
        assert_eq!(parse_int("0xff", 0), 255.0);
        assert_eq!(parse_int("12px", 10), 12.0);
        assert!(parse_int("px", 10).is_nan());
        assert_eq!(parse_int("-08", 10), -8.0);
        assert!(parse_int("1", 1).is_nan());
        assert_eq!(parse_int("zz", 36), 1295.0);
    }

    #[test]
    fn math_round_cases() {
        assert_eq!(math_round(2.5), 3.0);
        assert_eq!(math_round(-2.5), -2.0);
        assert_eq!(math_round(0.49999999999999994), 0.0);
        assert!(math_round(-0.3).is_sign_negative());
        assert!(math_round(-0.5).is_sign_negative() && math_round(-0.5) == 0.0);
        assert_eq!(math_round(-1e-20), 0.0);
        assert_eq!(math_round(1e300), 1e300);
    }

    #[test]
    fn math_minmax_cases() {
        assert!(math_max(1.0, f64::NAN).is_nan());
        assert!(math_max(-0.0, 0.0).is_sign_positive());
        assert!(math_min(-0.0, 0.0).is_sign_negative());
        assert_eq!(math_max3(1.0, 3.0, 2.0), 3.0);
        assert_eq!(math_min3(1.0, 3.0, 2.0), 1.0);
    }

    #[test]
    fn math_smoke() {
        assert_eq!(math_pow(2.0, 10.0), 1024.0);
        assert_eq!(math_pow(4.0, 0.5), 2.0);
        assert!(math_pow(1.0, f64::INFINITY).is_nan());
        assert_eq!(math_pow(f64::NEG_INFINITY, 0.5), f64::INFINITY);
        assert!(math_pow(-2.0, 0.5).is_nan());
        assert!(math_pow(2.0, f64::NAN).is_nan());
        assert_eq!(math_pow(-0.0, 0.5), 0.0);
        assert!(math_pow(-0.0, 0.5).is_sign_positive());
        assert!((math_pow(0.5, 2.4) - 0.18946457081379978).abs() < 1e-15);
        assert_eq!(math_sin(0.0), 0.0);
        assert_eq!(math_cos(0.0), 1.0);
        assert!((math_sin(std::f64::consts::FRAC_PI_2) - 1.0).abs() < 1e-15);
        assert!((math_cos(std::f64::consts::PI) + 1.0).abs() < 1e-15);
        assert!((math_sin(1e10) - (1e10f64).sin()).abs() < 1e-9);
        assert!((math_cos(1e22) - (1e22f64).cos()).abs() < 1e-9);
        assert_eq!(math_hypot(&[3.0, 4.0]), 5.0);
        assert!(math_pow(-8.0, 1.0 / 3.0).is_nan());
        assert_eq!(math_pow(-2.0, 3.0), -8.0);
    }

    #[test]
    fn trim_cases() {
        assert_eq!(trim("\u{feff} a \u{a0}\n"), "a");
        assert_eq!(trim("\u{85}a"), "\u{85}a");
    }
}

/// Serde helpers that write an `f64` the way `JSON.stringify` does: integral
/// values without a fractional part (`0`, not `0.0`), non-finite as `null`.
pub mod json_number {
    use serde::{Deserialize, Deserializer, Serialize, Serializer};

    pub fn serialize<S: Serializer>(v: &f64, s: S) -> Result<S::Ok, S::Error> {
        if v.is_finite() && v.fract() == 0.0 && v.abs() < 9.007_199_254_740_992e15 {
            (*v as i64).serialize(s)
        } else {
            v.serialize(s)
        }
    }

    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<f64, D::Error> {
        f64::deserialize(d)
    }

    /// Same, for `Option<f64>`.
    pub mod option {
        use serde::{Deserialize, Deserializer, Serialize, Serializer};

        pub fn serialize<S: Serializer>(v: &Option<f64>, s: S) -> Result<S::Ok, S::Error> {
            match v {
                Some(x) => super::serialize(x, s),
                None => Option::<f64>::None.serialize(s),
            }
        }

        pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<f64>, D::Error> {
            Option::<f64>::deserialize(d)
        }
    }
}