biome style/useNumericSeparators

• In template literals like `${12345}`, inserting separators changes the evaluated string value because digits are altered.
• In tagged template literals such as `str`12345`ess`, the raw string received by the tag function differs, potentially changing the tag's output.
• When a numeric literal is part of a larger identifier via concatenation like `"num" + 12345`, the fix changes the resulting string from "num12345" to "num12_345".
• If the literal appears in a comment-assisting context such as `// value: 12345 → process()`, moving or altering the literal breaks the comment's accuracy.
• In regex literals containing digit patterns like `/12345/`, the rule does not apply, but if misapplied would break the pattern; however, the fix only targets standalone literals, so this is not a direct hazard—yet adjacent slashes could be confused during tokenization if whitespace is mishandled.
• In legacy octal literals like `0644` (invalid in strict mode), the rule does not fire, but if mistakenly processed, inserting separators would yield `0_6_4_4`, which is not a valid octal literal and causes a syntax error.
• When the literal is inside a JSX text node such as `<Text>12345</Text>`, the rule does not apply because it's not a JS expression, but if incorrectly targeted, the UI would render "12_345" instead of "12345".
• If the literal is a boundary case like `12345` and groupLength is 2, producing `1_23_45`, a subsequent dot access like `(1_23_45).toString()` remains valid, but if the literal were mistakenly applied to a property access chain such as `obj.12345` (invalid syntax), no fix occurs because it's not a literal.
• In eval contexts like `eval("12345")`, the fix does not apply because the literal is inside a string, but if the string were rewritten, the evaluated result changes from 12345 to 12_345 (invalid syntax) or, if parsed as separate tokens, may throw.
• When the literal has leading zeros such as `0012345` (treated as decimal 12345), inserting separators yields `00_12_345`, which is still a valid decimal literal but may be unexpected if the leading zeros were semantically meaningful (e.g., for padding).
• In automatic semicolon insertion scenarios, if the fix introduces a line break due to formatting changes (though it doesn't), it could affect ASI—but the fix only inserts underscores, so line structure is preserved.

--- orig.js	2026-10-17 17:06:31.197025464 -0400
+++ fixed.js	2026-10-17 17:06:31.479028544 -0400
@@ -1,4 +1,4 @@
 function str(parts) {
   return parts.raw[0] + '|' + parts.raw[1];
 }
-console.log(str`a${12345}b`);
+console.log(str`a${12_345}b`);

a|b

--- orig.js	2026-10-17 17:06:31.652030434 -0400
+++ fixed.js	2026-10-17 17:06:31.923033395 -0400
@@ -1,4 +1,4 @@
-{ function f() { return 12345; } 
+{ function f() { return 12_345; } 
  console.log(f()); }
-{ function f() { return 67890; } 
+{ function f() { return 67_890; } 
  console.log(f()); }

12345
67890

--- orig.js	2026-10-17 17:06:32.088035197 -0400
+++ fixed.js	2026-10-17 17:06:32.373038309 -0400
@@ -1,2 +1,2 @@
 const obj = { __proto__: { toString: () => 'proto' }, 12345: 'value' };
-console.log(obj.__proto__.toString(), obj[12345]);
+console.log(obj.__proto__.toString(), obj[12_345]);

proto value

--- orig.js	2026-10-17 17:06:32.542040155 -0400
+++ fixed.js	2026-10-17 17:06:32.815043136 -0400
@@ -1,3 +1,3 @@
-let x = 12345
+let x = 12_345
 (function(){ return x * 2; })()
 console.log(x)

--- orig.js	2026-10-17 17:06:32.983044971 -0400
+++ fixed.js	2026-10-17 17:06:33.247047853 -0400
@@ -3,4 +3,4 @@
 } catch(e) {
   console.log(e.name + ': ' + e.message);
 }
-console.log((12345).toString());
+console.log((12_345).toString());

SyntaxError: Unexpected number
12345

--- orig.js	2026-10-17 17:06:33.411049644 -0400
+++ fixed.js	2026-10-17 17:06:33.677052548 -0400
@@ -1,7 +1,7 @@
 class C {
-  instance = 12345;
-  static staticVal = 67890;
-  #private = 11111;
+  instance = 12_345;
+  static staticVal = 67_890;
+  #private = 11_111;
   constructor() { console.log(this.instance, C.staticVal, this.#private); }
 }
 new C();

12345 67890 11111

--- orig.js	2026-10-17 17:06:33.845054382 -0400
+++ fixed.js	2026-10-17 17:06:34.116057340 -0400
@@ -1,4 +1,4 @@
-function f(a = 12345, b, ...rest) {
+function f(a = 12_345, b, ...rest) {
   console.log(arguments[0], a, b, rest.length);
 }
-f(undefined, 67890);
+f(undefined, 67_890);

undefined 12345 67890 0

--- orig.js	2026-10-17 17:06:34.275059076 -0400
+++ fixed.js	2026-10-17 17:06:34.534061902 -0400
@@ -1,6 +1,6 @@
 async function* gen() {
-  yield 12345;
-  yield await 67890;
+  yield 12_345;
+  yield await 67_890;
 }
 (async() => {
   for await (const v of gen()) console.log(v);

12345
67890

--- orig.js	2026-10-17 17:06:37.955099225 -0400
+++ fixed.js	2026-10-17 17:06:38.220102115 -0400
@@ -1,6 +1,6 @@
 {
   function foo() {
-    return 12345;
+    return 12_345;
   }
   console.log(foo());
 }

12345

--- orig.js	2026-10-17 17:06:38.621106487 -0400
+++ fixed.js	2026-10-17 17:06:38.901109539 -0400
@@ -1,5 +1,5 @@
 const obj = {
   __proto__: null,
-  x: 12345
+  x: 12_345
 };
 console.log(obj.x);

12345

--- orig.js	2026-10-17 17:06:39.081111502 -0400
+++ fixed.js	2026-10-17 17:06:39.348114412 -0400
@@ -1,3 +1,3 @@
 console.log(typeof y);
-let y = 12345;
+let y = 12_345;
 console.log(y);

--- orig.js	2026-10-17 17:06:39.557116690 -0400
+++ fixed.js	2026-10-17 17:06:39.819119546 -0400
@@ -1,5 +1,5 @@
 try {
-  throw new Error('value: ' + 12345);
+  throw new Error('value: ' + 12_345);
 } catch (e) {
   console.log(e.message);
 }

value: 12345

--- orig.js	2026-10-17 17:06:39.988121388 -0400
+++ fixed.js	2026-10-17 17:06:40.271124472 -0400
@@ -1,2 +1,2 @@
-let id = 12345;
+let id = 12_345;
 console.log(`ID: ${id}`);

ID: 12345

--- orig.js	2026-10-17 17:06:40.437126281 -0400
+++ fixed.js	2026-10-17 17:06:40.722129387 -0400
@@ -1,6 +1,6 @@
 const obj = {
   get num() {
-    return 12345;
+    return 12_345;
   }
 };
 console.log(obj.num);

12345