biome style/useTrimStartEnd

• The rewrite assumes the base expression is a string; if it is not, both the original and rewritten code will throw a TypeError at runtime, so behavior is preserved but errors may occur where none were expected.
• If the method is accessed via a property name that is dynamically computed (e.g., obj[method]()), changing the hardcoded name from 'trimLeft' to 'trimStart' alters which property is looked up, potentially causing a different function to be called or undefined to be invoked.
• If the code relies on the method being non-enumerable or having specific descriptors (unlikely for built-ins), the rewrite does not affect descriptors since it only changes the identifier used in property access.
• In rare cases where trimLeft or trimRight has been overridden on String.prototype or an instance, the rewrite bypasses the override by calling the standard trimStart/trimEnd methods, altering behavior.
• If the call is part of a larger expression with side effects (e.g., in a logical chain like foo && bar.trimLeft()), the rewrite does not change evaluation order or side-effect timing.
• Comments attached directly to the method name (e.g., trimLeft/*comment*/()) would be lost because the autofix replaces the entire identifier, stripping any inline comments.
• If the code uses a with statement that binds a variable named trimLeft or trimStart, the lookup semantics could differ, though with is deprecated and rarely used.
• In strict mode, if trimLeft or trimStart is mistakenly referenced as a variable due to a typo, the rewrite could turn a ReferenceError into a valid method call (or vice versa), but this is outside the rule's scope as it only applies to property accesses.
• If the base expression evaluates to an object with a custom trimLeft property that is not a function (e.g., a getter with side effects), replacing the property name changes which getter is invoked.
• The autofix does not preserve trailing whitespace or formatting inside the method call parentheses (which are empty anyway), so no behavioral impact there.
• If the method is called via optional chaining (e.g., foo?.trimLeft()), the rewrite correctly preserves the optional chaining operator, so no hazard arises from that form.

--- orig.js	2026-10-17 17:07:29.974662689 -0400
+++ fixed.js	2026-10-17 17:07:30.251665670 -0400
@@ -2,7 +2,7 @@
   let s = '   hello   ';
   inner: {
     if (true) break outer;
-    console.log(s.trimLeft());
+    console.log(s.trimStart());
   }
 }
 console.log('done');

done

--- orig.js	2026-10-17 17:07:30.464667962 -0400
+++ fixed.js	2026-10-17 17:07:30.747671006 -0400
@@ -1,2 +1,2 @@
 let s = '  test  ';
-console.log(s.trimLeft().length);
+console.log(s.trimStart().length);

6

--- orig.js	2026-10-17 17:07:30.919672857 -0400
+++ fixed.js	2026-10-17 17:07:31.183675697 -0400
@@ -1,4 +1,4 @@
 let obj = {
   toString: () => '   abc   '
 };
-console.log((obj).trimLeft() + 'def');
+console.log((obj).trimStart() + 'def');

--- orig.js	2026-10-17 17:07:31.355677548 -0400
+++ fixed.js	2026-10-17 17:07:31.629680495 -0400
@@ -1,6 +1,6 @@
 let s = null;
 try {
-  console.log(s.trimLeft());
+  console.log(s.trimStart());
 } catch (e) {
   console.log(e.name + ': ' + e.message);
 }

TypeError: Cannot read properties of null (reading 'trimLeft')

hi

--- orig.js	2026-10-17 17:07:32.022684723 -0400
+++ fixed.js	2026-10-17 17:07:32.287687573 -0400
@@ -1,4 +1,4 @@
 let s = '  x  ';
 let desc = Object.getOwnPropertyDescriptor(String.prototype, 'trimLeft');
 console.log(desc.enumerable);
-console.log(s.trimLeft());
+console.log(s.trimStart());

false
x

--- orig.js	2026-10-17 17:07:32.450689326 -0400
+++ fixed.js	2026-10-17 17:07:32.720692230 -0400
@@ -1,4 +1,4 @@
 let s = null;
-console.log(s?.trimLeft() ?? 'null');
+console.log(s?.trimStart() ?? 'null');
 s = '  ok  ';
-console.log(s?.trimLeft());
+console.log(s?.trimStart());

null
ok

--- orig.js	2026-10-17 17:07:37.141739749 -0400
+++ fixed.js	2026-10-17 17:07:37.431742865 -0400
@@ -1,4 +1,4 @@
 let side = 0;
 function log() { return ++side; }
-const result = log() && '  hello'.trimLeft();
+const result = log() && '  hello'.trimStart();
 console.log(`side=${side}, result='${result}'`);

side=1, result='hello'

--- orig.js	2026-10-17 17:07:37.593744604 -0400
+++ fixed.js	2026-10-17 17:07:37.859747462 -0400
@@ -1,7 +1,7 @@
 async function test() {
   const p = Promise.resolve('  world');
   const a = await p;
-  const b = a.trimRight();
+  const b = a.trimEnd();
   console.log(`'${b}'`);
 }
 test().catch(e => console.error(e));

'  world'

--- orig.js	2026-10-17 17:07:38.048749492 -0400
+++ fixed.js	2026-10-17 17:07:38.329752510 -0400
@@ -1,2 +1,2 @@
 const s = '  hello';
-console.log(s.trimLeft/* keep this */());
+console.log(s.trimStart/* keep this */());

hello

--- orig.js	2026-10-17 17:07:38.503754378 -0400
+++ fixed.js	2026-10-17 17:07:38.775757300 -0400
@@ -1,4 +1,4 @@
 // trim whitespace from input
 const input = '  test  ';
-const out = input.trimLeft(); // keep this comment
+const out = input.trimStart(); // keep this comment
 console.log(`'${out}'`);

'test  '

'  ok'

--- orig.js	2026-10-17 17:07:39.156761391 -0400
+++ fixed.js	2026-10-17 17:07:39.414764161 -0400
@@ -1,2 +1,2 @@
 const s = '  foo';
-console.log(s.trimLeft( /* no args */ ));
+console.log(s.trimStart( /* no args */ ));

foo

--- orig.js	2026-10-17 17:07:39.578765922 -0400
+++ fixed.js	2026-10-17 17:07:39.851768853 -0400
@@ -1,4 +1,4 @@
 let count = 0;
 function inc() { return ++count; }
-const vals = [inc(), inc()].map(v => `${v}`.trimLeft());
+const vals = [inc(), inc()].map(v => `${v}`.trimStart());
 console.log(`count=${count}, vals=${vals}`);

count=2, vals=1,2