--- source: crates/biome_js_analyze/tests/spec_tests.rs expression: invalid.js --- # Input ```jsx Math.pow(a, b); (Math).pow(a, b); // able to catch some workarounds Math[`pow`](a, b); (Math)['pow'](a, b); (Math)["pow"](a, b); (Math)[`pow`](a, b); // non-expression parents that don't require parens var x = Math.pow(a, b); if(Math.pow(a, b)){} for(;Math.pow(a, b);){} switch(foo){ case Math.pow(a, b): break; } { foo: Math.pow(a, b) } function foo(bar, baz = Math.pow(a, b), quux){} `${Math.pow(a, b)}` // non-expression parents that do require parens class C extends Math.pow(a, b) {} // already parenthesised, shouldn't insert extra parens +(Math.pow(a, b)) (Math.pow(a, b)).toString() (class extends (Math.pow(a, b)) {}) class C extends (Math.pow(a, b)) {} // '**' is right-associative, that applies to both parent and child nodes a ** Math.pow(b, c); Math.pow(a, b) ** c; Math.pow(a, b ** c); Math.pow(a ** b, c); a ** Math.pow(b ** c, d ** e) ** f; // doesn't remove already existing unnecessary parens around the whole expression (Math.pow(a, b)); foo + (Math.pow(a, b)); (Math.pow(a, b)) + foo; `${(Math.pow(a, b))}`; // Optional chaining Math.pow?.(a, b) Math?.pow(a, b) Math?.pow?.(a, b) ;(Math?.pow)(a, b) ;(Math?.pow)?.(a, b) // doesn't put extra parens Math.pow((a + b), (c + d)) // tokens that can be adjacent a+Math.pow(b, c)+d ``` # Diagnostics ``` invalid.js:1:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. > 1 │ Math.pow(a, b); │ ^^^^^^^^^^^^^^ 2 │ (Math).pow(a, b); 3 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 1 │ - Math.pow(a,·b); 1 │ + a·**·b; 2 2 │ (Math).pow(a, b); 3 3 │ ``` ``` invalid.js:2:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 1 │ Math.pow(a, b); > 2 │ (Math).pow(a, b); │ ^^^^^^^^^^^^^^^^ 3 │ 4 │ // able to catch some workarounds i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 1 1 │ Math.pow(a, b); 2 │ - (Math).pow(a,·b); 2 │ + a·**·b; 3 3 │ 4 4 │ // able to catch some workarounds ``` ``` invalid.js:5:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 4 │ // able to catch some workarounds > 5 │ Math[`pow`](a, b); │ ^^^^^^^^^^^^^^^^^ 6 │ (Math)['pow'](a, b); 7 │ (Math)["pow"](a, b); i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 3 3 │ 4 4 │ // able to catch some workarounds 5 │ - Math[`pow`](a,·b); 5 │ + a·**·b; 6 6 │ (Math)['pow'](a, b); 7 7 │ (Math)["pow"](a, b); ``` ``` invalid.js:6:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 4 │ // able to catch some workarounds 5 │ Math[`pow`](a, b); > 6 │ (Math)['pow'](a, b); │ ^^^^^^^^^^^^^^^^^^^ 7 │ (Math)["pow"](a, b); 8 │ (Math)[`pow`](a, b); i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 4 4 │ // able to catch some workarounds 5 5 │ Math[`pow`](a, b); 6 │ - (Math)['pow'](a,·b); 6 │ + a·**·b; 7 7 │ (Math)["pow"](a, b); 8 8 │ (Math)[`pow`](a, b); ``` ``` invalid.js:7:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 5 │ Math[`pow`](a, b); 6 │ (Math)['pow'](a, b); > 7 │ (Math)["pow"](a, b); │ ^^^^^^^^^^^^^^^^^^^ 8 │ (Math)[`pow`](a, b); 9 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 5 5 │ Math[`pow`](a, b); 6 6 │ (Math)['pow'](a, b); 7 │ - (Math)["pow"](a,·b); 7 │ + a·**·b; 8 8 │ (Math)[`pow`](a, b); 9 9 │ ``` ``` invalid.js:8:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 6 │ (Math)['pow'](a, b); 7 │ (Math)["pow"](a, b); > 8 │ (Math)[`pow`](a, b); │ ^^^^^^^^^^^^^^^^^^^ 9 │ 10 │ // non-expression parents that don't require parens i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 6 6 │ (Math)['pow'](a, b); 7 7 │ (Math)["pow"](a, b); 8 │ - (Math)[`pow`](a,·b); 8 │ + a·**·b; 9 9 │ 10 10 │ // non-expression parents that don't require parens ``` ``` invalid.js:11:9 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 10 │ // non-expression parents that don't require parens > 11 │ var x = Math.pow(a, b); │ ^^^^^^^^^^^^^^ 12 │ if(Math.pow(a, b)){} 13 │ for(;Math.pow(a, b);){} i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 9 9 │ 10 10 │ // non-expression parents that don't require parens 11 │ - var·x·=·Math.pow(a,·b); 11 │ + var·x·=·a·**·b; 12 12 │ if(Math.pow(a, b)){} 13 13 │ for(;Math.pow(a, b);){} ``` ``` invalid.js:12:4 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 10 │ // non-expression parents that don't require parens 11 │ var x = Math.pow(a, b); > 12 │ if(Math.pow(a, b)){} │ ^^^^^^^^^^^^^^ 13 │ for(;Math.pow(a, b);){} 14 │ switch(foo){ case Math.pow(a, b): break; } i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 10 10 │ // non-expression parents that don't require parens 11 11 │ var x = Math.pow(a, b); 12 │ - if(Math.pow(a,·b)){} 12 │ + if(a·**·b){} 13 13 │ for(;Math.pow(a, b);){} 14 14 │ switch(foo){ case Math.pow(a, b): break; } ``` ``` invalid.js:13:6 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 11 │ var x = Math.pow(a, b); 12 │ if(Math.pow(a, b)){} > 13 │ for(;Math.pow(a, b);){} │ ^^^^^^^^^^^^^^ 14 │ switch(foo){ case Math.pow(a, b): break; } 15 │ { foo: Math.pow(a, b) } i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 11 11 │ var x = Math.pow(a, b); 12 12 │ if(Math.pow(a, b)){} 13 │ - for(;Math.pow(a,·b);){} 13 │ + for(;a·**·b;){} 14 14 │ switch(foo){ case Math.pow(a, b): break; } 15 15 │ { foo: Math.pow(a, b) } ``` ``` invalid.js:14:19 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 12 │ if(Math.pow(a, b)){} 13 │ for(;Math.pow(a, b);){} > 14 │ switch(foo){ case Math.pow(a, b): break; } │ ^^^^^^^^^^^^^^ 15 │ { foo: Math.pow(a, b) } 16 │ function foo(bar, baz = Math.pow(a, b), quux){} i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 12 12 │ if(Math.pow(a, b)){} 13 13 │ for(;Math.pow(a, b);){} 14 │ - switch(foo){·case·Math.pow(a,·b):·break;·} 14 │ + switch(foo){·case·a·**·b:·break;·} 15 15 │ { foo: Math.pow(a, b) } 16 16 │ function foo(bar, baz = Math.pow(a, b), quux){} ``` ``` invalid.js:15:8 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 13 │ for(;Math.pow(a, b);){} 14 │ switch(foo){ case Math.pow(a, b): break; } > 15 │ { foo: Math.pow(a, b) } │ ^^^^^^^^^^^^^^ 16 │ function foo(bar, baz = Math.pow(a, b), quux){} 17 │ `${Math.pow(a, b)}` i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 13 13 │ for(;Math.pow(a, b);){} 14 14 │ switch(foo){ case Math.pow(a, b): break; } 15 │ - {·foo:·Math.pow(a,·b)·} 15 │ + {·foo:·a·**·b·} 16 16 │ function foo(bar, baz = Math.pow(a, b), quux){} 17 17 │ `${Math.pow(a, b)}` ``` ``` invalid.js:16:25 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 14 │ switch(foo){ case Math.pow(a, b): break; } 15 │ { foo: Math.pow(a, b) } > 16 │ function foo(bar, baz = Math.pow(a, b), quux){} │ ^^^^^^^^^^^^^^ 17 │ `${Math.pow(a, b)}` 18 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 14 14 │ switch(foo){ case Math.pow(a, b): break; } 15 15 │ { foo: Math.pow(a, b) } 16 │ - function·foo(bar,·baz·=·Math.pow(a,·b),·quux){} 16 │ + function·foo(bar,·baz·=·a·**·b,·quux){} 17 17 │ `${Math.pow(a, b)}` 18 18 │ ``` ``` invalid.js:17:4 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 15 │ { foo: Math.pow(a, b) } 16 │ function foo(bar, baz = Math.pow(a, b), quux){} > 17 │ `${Math.pow(a, b)}` │ ^^^^^^^^^^^^^^ 18 │ 19 │ // non-expression parents that do require parens i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 15 15 │ { foo: Math.pow(a, b) } 16 16 │ function foo(bar, baz = Math.pow(a, b), quux){} 17 │ - `${Math.pow(a,·b)}` 17 │ + `${a·**·b}` 18 18 │ 19 19 │ // non-expression parents that do require parens ``` ``` invalid.js:20:17 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 19 │ // non-expression parents that do require parens > 20 │ class C extends Math.pow(a, b) {} │ ^^^^^^^^^^^^^^ 21 │ 22 │ // already parenthesised, shouldn't insert extra parens i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 18 18 │ 19 19 │ // non-expression parents that do require parens 20 │ - class·C·extends·Math.pow(a,·b)·{} 20 │ + class·C·extends·(a·**·b)·{} 21 21 │ 22 22 │ // already parenthesised, shouldn't insert extra parens ``` ``` invalid.js:23:3 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 22 │ // already parenthesised, shouldn't insert extra parens > 23 │ +(Math.pow(a, b)) │ ^^^^^^^^^^^^^^ 24 │ (Math.pow(a, b)).toString() 25 │ (class extends (Math.pow(a, b)) {}) i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 21 21 │ 22 22 │ // already parenthesised, shouldn't insert extra parens 23 │ - +(Math.pow(a,·b)) 23 │ + +(a·**·b) 24 24 │ (Math.pow(a, b)).toString() 25 25 │ (class extends (Math.pow(a, b)) {}) ``` ``` invalid.js:24:2 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 22 │ // already parenthesised, shouldn't insert extra parens 23 │ +(Math.pow(a, b)) > 24 │ (Math.pow(a, b)).toString() │ ^^^^^^^^^^^^^^ 25 │ (class extends (Math.pow(a, b)) {}) 26 │ class C extends (Math.pow(a, b)) {} i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 22 22 │ // already parenthesised, shouldn't insert extra parens 23 23 │ +(Math.pow(a, b)) 24 │ - (Math.pow(a,·b)).toString() 24 │ + (a·**·b).toString() 25 25 │ (class extends (Math.pow(a, b)) {}) 26 26 │ class C extends (Math.pow(a, b)) {} ``` ``` invalid.js:25:17 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 23 │ +(Math.pow(a, b)) 24 │ (Math.pow(a, b)).toString() > 25 │ (class extends (Math.pow(a, b)) {}) │ ^^^^^^^^^^^^^^ 26 │ class C extends (Math.pow(a, b)) {} 27 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 23 23 │ +(Math.pow(a, b)) 24 24 │ (Math.pow(a, b)).toString() 25 │ - (class·extends·(Math.pow(a,·b))·{}) 25 │ + (class·extends·(a·**·b)·{}) 26 26 │ class C extends (Math.pow(a, b)) {} 27 27 │ ``` ``` invalid.js:26:18 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 24 │ (Math.pow(a, b)).toString() 25 │ (class extends (Math.pow(a, b)) {}) > 26 │ class C extends (Math.pow(a, b)) {} │ ^^^^^^^^^^^^^^ 27 │ 28 │ // '**' is right-associative, that applies to both parent and child nodes i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 24 24 │ (Math.pow(a, b)).toString() 25 25 │ (class extends (Math.pow(a, b)) {}) 26 │ - class·C·extends·(Math.pow(a,·b))·{} 26 │ + class·C·extends·(a·**·b)·{} 27 27 │ 28 28 │ // '**' is right-associative, that applies to both parent and child nodes ``` ``` invalid.js:29:6 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 28 │ // '**' is right-associative, that applies to both parent and child nodes > 29 │ a ** Math.pow(b, c); │ ^^^^^^^^^^^^^^ 30 │ Math.pow(a, b) ** c; 31 │ Math.pow(a, b ** c); i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 27 27 │ 28 28 │ // '**' is right-associative, that applies to both parent and child nodes 29 │ - a·**·Math.pow(b,·c); 29 │ + a·**·b·**·c; 30 30 │ Math.pow(a, b) ** c; 31 31 │ Math.pow(a, b ** c); ``` ``` invalid.js:30:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 28 │ // '**' is right-associative, that applies to both parent and child nodes 29 │ a ** Math.pow(b, c); > 30 │ Math.pow(a, b) ** c; │ ^^^^^^^^^^^^^^ 31 │ Math.pow(a, b ** c); 32 │ Math.pow(a ** b, c); i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 28 28 │ // '**' is right-associative, that applies to both parent and child nodes 29 29 │ a ** Math.pow(b, c); 30 │ - Math.pow(a,·b)·**·c; 30 │ + (a·**·b)·**·c; 31 31 │ Math.pow(a, b ** c); 32 32 │ Math.pow(a ** b, c); ``` ``` invalid.js:31:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 29 │ a ** Math.pow(b, c); 30 │ Math.pow(a, b) ** c; > 31 │ Math.pow(a, b ** c); │ ^^^^^^^^^^^^^^^^^^^ 32 │ Math.pow(a ** b, c); 33 │ a ** Math.pow(b ** c, d ** e) ** f; i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 29 29 │ a ** Math.pow(b, c); 30 30 │ Math.pow(a, b) ** c; 31 │ - Math.pow(a,·b·**·c); 31 │ + a·**·b·**·c; 32 32 │ Math.pow(a ** b, c); 33 33 │ a ** Math.pow(b ** c, d ** e) ** f; ``` ``` invalid.js:32:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 30 │ Math.pow(a, b) ** c; 31 │ Math.pow(a, b ** c); > 32 │ Math.pow(a ** b, c); │ ^^^^^^^^^^^^^^^^^^^ 33 │ a ** Math.pow(b ** c, d ** e) ** f; 34 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 30 30 │ Math.pow(a, b) ** c; 31 31 │ Math.pow(a, b ** c); 32 │ - Math.pow(a·**·b,·c); 32 │ + (a·**·b)·**·c; 33 33 │ a ** Math.pow(b ** c, d ** e) ** f; 34 34 │ ``` ``` invalid.js:33:6 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 31 │ Math.pow(a, b ** c); 32 │ Math.pow(a ** b, c); > 33 │ a ** Math.pow(b ** c, d ** e) ** f; │ ^^^^^^^^^^^^^^^^^^^^^^^^ 34 │ 35 │ // doesn't remove already existing unnecessary parens around the whole expression i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 31 31 │ Math.pow(a, b ** c); 32 32 │ Math.pow(a ** b, c); 33 │ - a·**·Math.pow(b·**·c,·d·**·e)·**·f; 33 │ + a·**·((b·**·c)·**·d·**·e)·**·f; 34 34 │ 35 35 │ // doesn't remove already existing unnecessary parens around the whole expression ``` ``` invalid.js:36:2 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 35 │ // doesn't remove already existing unnecessary parens around the whole expression > 36 │ (Math.pow(a, b)); │ ^^^^^^^^^^^^^^ 37 │ foo + (Math.pow(a, b)); 38 │ (Math.pow(a, b)) + foo; i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 34 34 │ 35 35 │ // doesn't remove already existing unnecessary parens around the whole expression 36 │ - (Math.pow(a,·b)); 36 │ + (a·**·b); 37 37 │ foo + (Math.pow(a, b)); 38 38 │ (Math.pow(a, b)) + foo; ``` ``` invalid.js:37:8 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 35 │ // doesn't remove already existing unnecessary parens around the whole expression 36 │ (Math.pow(a, b)); > 37 │ foo + (Math.pow(a, b)); │ ^^^^^^^^^^^^^^ 38 │ (Math.pow(a, b)) + foo; 39 │ `${(Math.pow(a, b))}`; i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 35 35 │ // doesn't remove already existing unnecessary parens around the whole expression 36 36 │ (Math.pow(a, b)); 37 │ - foo·+·(Math.pow(a,·b)); 37 │ + foo·+·(a·**·b); 38 38 │ (Math.pow(a, b)) + foo; 39 39 │ `${(Math.pow(a, b))}`; ``` ``` invalid.js:38:2 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 36 │ (Math.pow(a, b)); 37 │ foo + (Math.pow(a, b)); > 38 │ (Math.pow(a, b)) + foo; │ ^^^^^^^^^^^^^^ 39 │ `${(Math.pow(a, b))}`; 40 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 36 36 │ (Math.pow(a, b)); 37 37 │ foo + (Math.pow(a, b)); 38 │ - (Math.pow(a,·b))·+·foo; 38 │ + (a·**·b)·+·foo; 39 39 │ `${(Math.pow(a, b))}`; 40 40 │ ``` ``` invalid.js:39:5 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 37 │ foo + (Math.pow(a, b)); 38 │ (Math.pow(a, b)) + foo; > 39 │ `${(Math.pow(a, b))}`; │ ^^^^^^^^^^^^^^ 40 │ 41 │ // Optional chaining i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 37 37 │ foo + (Math.pow(a, b)); 38 38 │ (Math.pow(a, b)) + foo; 39 │ - `${(Math.pow(a,·b))}`; 39 │ + `${(a·**·b)}`; 40 40 │ 41 41 │ // Optional chaining ``` ``` invalid.js:42:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 41 │ // Optional chaining > 42 │ Math.pow?.(a, b) │ ^^^^^^^^^^^^^^^^ 43 │ Math?.pow(a, b) 44 │ Math?.pow?.(a, b) i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 40 40 │ 41 41 │ // Optional chaining 42 │ - Math.pow?.(a,·b) 42 │ + a·**·b 43 43 │ Math?.pow(a, b) 44 44 │ Math?.pow?.(a, b) ``` ``` invalid.js:43:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 41 │ // Optional chaining 42 │ Math.pow?.(a, b) > 43 │ Math?.pow(a, b) │ ^^^^^^^^^^^^^^^ 44 │ Math?.pow?.(a, b) 45 │ ;(Math?.pow)(a, b) i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 41 41 │ // Optional chaining 42 42 │ Math.pow?.(a, b) 43 │ - Math?.pow(a,·b) 43 │ + a·**·b 44 44 │ Math?.pow?.(a, b) 45 45 │ ;(Math?.pow)(a, b) ``` ``` invalid.js:44:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 42 │ Math.pow?.(a, b) 43 │ Math?.pow(a, b) > 44 │ Math?.pow?.(a, b) │ ^^^^^^^^^^^^^^^^^ 45 │ ;(Math?.pow)(a, b) 46 │ ;(Math?.pow)?.(a, b) i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 42 42 │ Math.pow?.(a, b) 43 43 │ Math?.pow(a, b) 44 │ - Math?.pow?.(a,·b) 44 │ + a·**·b 45 45 │ ;(Math?.pow)(a, b) 46 46 │ ;(Math?.pow)?.(a, b) ``` ``` invalid.js:45:2 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 43 │ Math?.pow(a, b) 44 │ Math?.pow?.(a, b) > 45 │ ;(Math?.pow)(a, b) │ ^^^^^^^^^^^^^^^^^ 46 │ ;(Math?.pow)?.(a, b) 47 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 43 43 │ Math?.pow(a, b) 44 44 │ Math?.pow?.(a, b) 45 │ - ;(Math?.pow)(a,·b) 45 │ + ;a·**·b 46 46 │ ;(Math?.pow)?.(a, b) 47 47 │ ``` ``` invalid.js:46:2 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 44 │ Math?.pow?.(a, b) 45 │ ;(Math?.pow)(a, b) > 46 │ ;(Math?.pow)?.(a, b) │ ^^^^^^^^^^^^^^^^^^^ 47 │ 48 │ // doesn't put extra parens i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 44 44 │ Math?.pow?.(a, b) 45 45 │ ;(Math?.pow)(a, b) 46 │ - ;(Math?.pow)?.(a,·b) 46 │ + ;a·**·b 47 47 │ 48 48 │ // doesn't put extra parens ``` ``` invalid.js:49:1 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 48 │ // doesn't put extra parens > 49 │ Math.pow((a + b), (c + d)) │ ^^^^^^^^^^^^^^^^^^^^^^^^^^ 50 │ 51 │ // tokens that can be adjacent i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 47 47 │ 48 48 │ // doesn't put extra parens 49 │ - Math.pow((a·+·b),·(c·+·d)) 49 │ + (a·+·b)·**·(c·+·d) 50 50 │ 51 51 │ // tokens that can be adjacent ``` ``` invalid.js:52:3 lint/style/useExponentiationOperator FIXABLE ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ! Use the '**' operator instead of 'Math.pow'. 51 │ // tokens that can be adjacent > 52 │ a+Math.pow(b, c)+d │ ^^^^^^^^^^^^^^ 53 │ i Unsafe fix: Use the '**' operator instead of 'Math.pow'. 50 50 │ 51 51 │ // tokens that can be adjacent 52 │ - a+Math.pow(b,·c)+d 52 │ + a+b·**·c+d 53 53 │ ```