fix(es/minifier): avoid inexact number radix folding (#12057)

**Description:**

`Number#toString(radix)` folding currently converts integer values
through `u128`. Unsafe integers can already have rounded
representations, so this conversion can produce digits that do not match
JavaScript for non-power-of-two radices.

This PR restricts radix folding to safe integers, with a separate exact
path for supported power-of-two radices below the `u128` bound. Values
outside those limits remain for runtime evaluation.

**Related issue (if exists):**

- #12043
  - #12047
    - #12050
      - #12048
        - #12051
      - #12052
        - #12053
      - #12054
      - #12055
      - #12056
      - **#12057** (current)
    - #12058
    - #12049
      - #12059
        - #12060

Author: magic-akari

.changeset/avoid-inexact-number-radix-folding.md

@@ -0,0 +1,6 @@
+---
+swc_core: patch
+swc_ecma_minifier: patch
+---
+
+fix(es/minifier): Avoid inexact number radix folding

crates/swc_ecma_minifier/src/compress/pure/evaluate.rs

@@ -19,6 +19,30 @@ use crate::{
     util::ValueExt,
 };
 
+/// Formats an integer with `radix_fmt` only where its exact integer output is
+/// also a valid ECMAScript `Number::toString` result.
+fn format_integer_in_radix(value: f64, radix: u8) -> Option<String> {
+    const MAX_SAFE_INTEGER: f64 = 9_007_199_254_740_991_f64;
+
+    let magnitude = value.abs();
+    let is_safe_integer = magnitude <= MAX_SAFE_INTEGER;
+    let is_supported_binary_radix = radix.is_power_of_two() && magnitude < u128::MAX as f64;
+
+    if !is_safe_integer && !is_supported_binary_radix {
+        return None;
+    }
+
+    let digits = Radix::new(magnitude as u128, radix).to_string();
+    if value >= 0_f64 {
+        return Some(digits);
+    }
+
+    let mut output = String::with_capacity(digits.len() + 1);
+    output.push('-');
+    output.push_str(&digits);
+    Some(output)
+}
+
 impl Pure<'_> {
     ///
     /// - `1 == 1` => `true`
@@ -668,26 +692,17 @@ impl Pure<'_> {
 
             if num.value.fract() == 0.0 && (2.0..=36.0).contains(&base) && base.fract() == 0.0 {
                 let base = base.floor() as u8;
-
-                self.changed = true;
-
-                let value = {
-                    let x = num.value;
-                    if x < 0. {
-                        // I don't know if u128 is really needed, but it works.
-                        format!("-{}", Radix::new(-x as u128, base))
-                    } else {
-                        Radix::new(x as u128, base).to_string()
-                    }
-                }
-                .into();
+                let Some(value) = format_integer_in_radix(num.value, base) else {
+                    return;
+                };
 
                 *e = Lit::Str(Str {
                     span: e.span(),
                     raw: None,
-                    value,
+                    value: value.into(),
                 })
-                .into()
+                .into();
+                self.changed = true;
             }
         }
     }

crates/swc_ecma_minifier/tests/fixture/issues/number-radix-conversion/config.json

@@ -0,0 +1,4 @@
+{
+    "defaults": true,
+    "passes": 2
+}

crates/swc_ecma_minifier/tests/fixture/issues/number-radix-conversion/expected.stdout

@@ -0,0 +1 @@
+1121202011211211122211100012101111,1121202011211211122211100012101111,-1121202011211211122211100012101111,l3r41ifs0p800,-l3r41ifs0p800,80000000000000000000000000000000,-80000000000000000000000000000000,100000000000000000000000000000000,-100000000000000000000000000000000

crates/swc_ecma_minifier/tests/fixture/issues/number-radix-conversion/input.js

@@ -0,0 +1,11 @@
+console.log([
+    (9007199254740991).toString(3),
+    (9007199254740994).toString(3),
+    (-9007199254740994).toString(3),
+    (1e20).toString(36),
+    (-1e20).toString(36),
+    (2 ** 127).toString(16),
+    (-(2 ** 127)).toString(16),
+    (2 ** 128).toString(16),
+    (-(2 ** 128)).toString(16),
+].join(","));

crates/swc_ecma_minifier/tests/fixture/issues/number-radix-conversion/output.js

@@ -0,0 +1,11 @@
+console.log([
+    "1121202011211211122211100012101111",
+    9007199254740994..toString(3),
+    (-9007199254740994).toString(3),
+    1e20.toString(36),
+    (-100000000000000000000).toString(36),
+    "80000000000000000000000000000000",
+    "-80000000000000000000000000000000",
+    3.402823669209385e+38.toString(16),
+    (-3.402823669209385e+38).toString(16)
+].join(","));