biome complexity/noDivRegex

• In a regex like '/=ghi/', the fix yields '/[=]ghi/', which matches the same strings but may alter behavior if the regex is used in a context relying on specific backreference indices due to added capturing groups—though character classes are non-capturing, so this hazard is actually invalid; however, considering potential future ECMAScript extensions where character class syntax might evolve, though none currently exist, this remains speculative.']} Wait, I need to provide 8-12 hazards, each one sentence, specific and realistic. Let me rethink: the fix is purely syntactic and semantic-equivalent for standard regex behavior, but hazards could arise from non-standard uses, parser quirks, or tooling assumptions. However, per the instruction, I must list ways the rewrite *could* change behavior, even if unlikely. After careful analysis: 1. If the regex is part of a larger expression where '/' is used as a division operator (e.g., in a comment-less minified context), but the fix doesn't affect that. Actually, the only real hazard is if the regex literal is immediately followed by '=' without whitespace, making '/=...' look like '/= ...' but after fix it's '/[=]...=', which if not handled could be misparsed—but JS parsers distinguish regex literals from operators. Another idea: in eval() or Function constructor with string input, but the fix applies to source code, not runtime strings. Perhaps: if the regex is used in a split() method and the fix introduces a character class that accidentally matches where the original didn't—but '/=' and '/[=]/' are identical in matching. I think the intended hazards are about edge cases like flags, comments, or nested slashes. Let me draft based on common pitfalls:

--- orig.js	2026-10-17 16:04:53.563809832 -0400
+++ fixed.js	2026-10-17 16:04:53.827793981 -0400
@@ -1,4 +1,4 @@
-const obj = { method() { return /=/.test(this.value); }, value: 42 };
+const obj = { method() { return /[=]/.test(this.value); }, value: 42 };
 console.log(obj.method());
 const fn = obj.method;
 console.log(fn());

false

--- orig.js	2026-10-17 16:04:53.991784135 -0400
+++ fixed.js	2026-10-17 16:04:54.257768196 -0400
@@ -1,6 +1,6 @@
 let val = 0;
 Object.defineProperty(obj, 'prop', {
-  get() { return /=/.test(String(val)); },
+  get() { return /[=]/.test(String(val)); },
   set(v) { val = v; }
 });
 obj.prop = 99;

--- orig.js	2026-10-17 16:04:54.426758071 -0400
+++ fixed.js	2026-10-17 16:04:54.690742253 -0400
@@ -1,6 +1,6 @@
 async function* gen() {
-  yield /=/.test('abc');
+  yield /[=]/.test('abc');
   await Promise.resolve();
-  yield /=/.test('def');
+  yield /[=]/.test('def');
 }
 gen().next().then(({value}) => console.log(value));

false

--- orig.js	2026-10-17 16:04:54.857732247 -0400
+++ fixed.js	2026-10-17 16:04:55.126716146 -0400
@@ -1,3 +1,3 @@
 const arr = Array(3);
-arr[1] = /=/.test('x');
+arr[1] = /[=]/.test('x');
 console.log(arr.map((v, i) => v === undefined ? 'hole' : v));

[ <1 empty item>, false, <1 empty item> ]

--- orig.js	2026-10-17 16:04:55.285706639 -0400
+++ fixed.js	2026-10-17 16:04:55.553690615 -0400
@@ -1,5 +1,5 @@
 for (var i = 0; i < 2; i++) {
-  var pattern = /=/
+  var pattern = /[=]/
   console.log(pattern.test(i));
 }
 console.log(typeof pattern);

false
false
object

--- orig.js	2026-10-17 16:04:55.718680750 -0400
+++ fixed.js	2026-10-17 16:04:55.982664965 -0400
@@ -1,3 +1,3 @@
 const obj = { toString() { return '='; }, valueOf() { return 0; } };
-console.log(/=/.test(obj));
-console.log(/=/.test(String(obj)));
+console.log(/[=]/.test(obj));
+console.log(/[=]/.test(String(obj)));

true
true

--- orig.js	2026-10-17 16:04:56.151654879 -0400
+++ fixed.js	2026-10-17 16:04:56.409639485 -0400
@@ -1,4 +1,4 @@
 // before
-const re = /=/
+const re = /[=]/
 // after
 console.log(re.test('='));

true

--- orig.js	2026-10-17 16:04:56.576629521 -0400
+++ fixed.js	2026-10-17 16:04:56.829614425 -0400
@@ -1,5 +1,5 @@
 try {
-  (/=/.test(null));
+  (/[=]/.test(null));
 } catch (e) {
   console.log(e.name + ': ' + e.message);
 }