esupgrade 2025.19.0 → 2025.20.1

package/.gitattributes

@@ -1,2 +1 @@
 package-lock.json linguist-generated
-src/jQuery/HTMLInputElement.json linguist-generated

package/.github/agents/superjoe.agent.md

@@ -5,12 +5,12 @@ name: SuperJoe
 description: CodingJoe's digital clone following his coding guidelines and best practices.
 ---
 
-
 # SuperJoe
 
 ## Planning
 
 You MUST ALWAYS follow the `naming-things` guidelines. Use the following command to access the guidelines:
+
 ```console
 curl -sSL https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md | head -n 500
 ```
@@ -44,7 +44,6 @@ Avoid functions or other code inside functions.
 Avoid if-statements in favor of switch/match-statements or polymorphism.
 Do not assign names to objects which are returned in the next line.
 
-
 ## Python
 
 Follow PEP 8 guidelines for code style.

package/.pre-commit-config.yaml

@@ -18,10 +18,10 @@ repos:
     hooks:
       - id: mdformat
         additional_dependencies:
+          - mdformat-front-matters
           - mdformat-footnote
           - mdformat-gfm
           - mdformat-gfm-alerts
-        exclude: '.github/agents/'
   - repo: https://github.com/google/yamlfmt
     rev: v0.21.0
     hooks:
@@ -32,7 +32,7 @@ repos:
       - id: write-good
         args: [--no-passive]
   - repo: https://github.com/pre-commit/mirrors-eslint
-    rev: v10.4.0
+    rev: v10.4.1
     hooks:
       - id: eslint
         args: ["--fix"]

package/AGENTS.md

@@ -31,3 +31,13 @@ console.log('modified:', res.modified);
 console.log('code:\n' + res.code);
 EOF
 ```
+
+## Writing Transformers
+
+Transformers must only apply to types that are statically verifiable. Use `NodeTest` from
+`src/types.js` to guard transformations:
+
+- `new NodeTest(node).isIterable()` — array literals, `new Array()`, `Array.from()`, and `Array.of()`. Use this when the transformation is array-specific (e.g., index access, `.at()`).
+- `new NodeTest(node).hasIndexOfAndIncludes()` — arrays and strings (includes string literals and array method chains like `.map()`, `.filter()`). Use this when the transformation applies to both arrays and strings.
+
+Never apply a transformation based solely on structural shape (e.g., a `.length` property or bracket access) without first verifying the receiver is a known type. An unknown identifier such as `arr` cannot be assumed to be an array and must not be transformed.

package/CONTRIBUTING.md

@@ -24,3 +24,8 @@ uvx pre-commit run --all-files
 ## Naming conversions
 
 When writing code, please follow the [naming guidelines](https://raw.githubusercontent.com/codingjoe/naming-things/refs/heads/main/README.md).
+
+## Baselines release dates
+
+The `baselineDate` can be found on
+https://github.com/web-platform-dx/web-features named `baseline_low_date`.

package/README.md

@@ -13,7 +13,7 @@ Keeping your JavaScript and TypeScript code up to date with full browser compati
 ## Usage
 
 esupgrade is safe and meant to be used automatically on your codebase.
-We recommend integrating it into your development workflow using [pre-commit].
+We recommend integrating it into your development workflow using [pre-commit] or [husky].
 
 To try it out on a repository without writing changes, run:
 
@@ -40,6 +40,15 @@ repos:
 pre-commit run esupgrade --all-files
 ```
 
+### Husky
+
+Assuming Husky is already initialized and `.husky/pre-commit` already contains `set -e`, append:
+
+```bash
+echo "git diff --cached --name-only --diff-filter=ACMR -z -- '*.js' '*.jsx' '*.ts' '*.tsx' '*.mjs' '*.cjs' | xargs -0 sh -c 'test \"\$#\" -eq 0 && exit 0; npx esupgrade -- \"\$@\"' sh" >> .husky/pre-commit
+echo "git diff --cached --name-only --diff-filter=ACMR -z -- '*.js' '*.jsx' '*.ts' '*.tsx' '*.mjs' '*.cjs' | xargs -0 sh -c 'test \"\$#\" -eq 0 && exit 0; git add -- \"\$@\"' sh" >> .husky/pre-commit
+```
+
 ### CLI
 
 ```bash
@@ -215,6 +224,18 @@ Supports:
 +const withItem = [...array, item];
 ```
 
+#### `1000000` → [Numeric separators][mdn-numeric-separators]
+
+```diff
+-const budget = 1000000;
+-const maxUsers = 1000000n;
++const budget = 1_000_000;
++const maxUsers = 1_000_000n;
+```
+
+esupgrade transforms decimal integer and bigint literals with at least five digits.
+Fractional, exponential, hexadecimal, octal, binary, and already formatted literals are left unchanged.
+
 #### `Array.slice(0)` → [Array spread [...]][mdn-spread]
 
 ```diff
@@ -231,9 +252,16 @@ Supports:
 +const first = [1, 2, 3].find(n => n > 1);
 ```
 
-Transforms `filter(predicate)[0]` to the more explicit and performant `find(predicate)`, which stops at the first match instead of filtering the entire array.
+Transformations are limited to when the receiver can be verified as an array (array literals, `new Array()`, or known array method chains) and `filter()` is called with one argument.
 
-Transformations are limited to when the receiver can be verified as an array (array literals, `new Array()`, or known array method chains) and `filter()` is called with exactly one argument.
+#### `arr[arr.length - n]` → [`Array.at()`][mdn-at]
+
+```diff
+-const last = arr[arr.length - 1];
+-const item = arr[arr.length - n];
++const last = arr.at(-1);
++const item = arr.at(-n);
+```
 
 #### `Math.pow()` → [Exponentiation operator \*\*][mdn-exponentiation]
 
@@ -244,6 +272,31 @@ Transformations are limited to when the receiver can be verified as an array (ar
 +const area = Math.PI * radius ** 2;
 ```
 
+#### Verbose arithmetic assignments → [Compound assignment operators (+=, -=, …)][mdn-compound-assignment]
+
+```diff
+-x = x + y
++x += y
+-x = x - y
++x -= y
+-x = x * y
++x *= y
+-x = x / y
++x /= y
+-x = x % y
++x %= y
+-x = x ** y
++x **= y
+```
+
+> [!NOTE]
+> When the assignment target is a member expression with potential side effects
+> (e.g., `getObj().prop = getObj().prop + y` or `obj[f()] = obj[f()] + y`), the
+> transformation evaluates the target expression once instead of twice.
+> If `getObj()` or `f()` have observable side effects or return different values
+> on each call, `getObj().prop += y` may produce different results than the
+> original `getObj().prop = getObj().prop + y`.
+
 #### Named function assignments → [Function declarations][mdn-functions]
 
 ```diff
@@ -336,6 +389,7 @@ Transforms constructor functions (both function declarations and variable declar
 
 - Function name starts with an uppercase letter
 - At least one prototype method is defined
+- Prototype methods are matched only to constructors declared in the current or an ancestor lexical scope (never sibling or child scopes)
 - Prototype methods using `this` in arrow functions are skipped
 - Prototype object literals with getters, setters, or computed properties are skipped
 
@@ -397,6 +451,32 @@ ES6 modules are automatically in strict mode, making explicit `'use strict'` dir
 +const result = obj.prop ?? 0;
 ```
 
+#### Logical assignment patterns → [Logical assignment operators (??=, ||=, &&=)][mdn-logical-assignment]
+
+```diff
+-x = x ?? y
++x ??= y
+-x = x || y
++x ||= y
+-x = x && y
++x &&= y
+```
+
+```diff
+-if (x === null || x === undefined) x = y
++x ??= y
+```
+
+> [!NOTE]
+> For member expression targets (e.g., `obj.prop ||= y`), the original
+> unconditional assignment always invokes property setters, while the logical
+> assignment operator skips the setter when the condition is not met. This
+> generally improves performance by avoiding unnecessary setter calls.
+>
+> Similarly, for `if (obj.prop === null || obj.prop === undefined) obj.prop = y`,
+> the transformation to `obj.prop ??= y` reads `obj.prop` once instead of twice
+> before assigning, which improves performance for getter-backed properties.
+
 #### `indexOf()` → [includes()][mdn-includes]
 
 ```diff
@@ -437,6 +517,15 @@ Transforms the deprecated `substr()` method to `slice()`:
 
 Transformations are limited to when the receiver can be verified as a string (string literals, template literals, or string method chains).
 
+#### `split().join()` / `replace(/literal/g)` → [String.replaceAll()][mdn-replaceall]
+
+```diff
+-const value = "a,b,c".split(",").join(".");
+-const label = "foo".replace(/o/g, "a");
++const value = "a,b,c".replaceAll(",", ".");
++const label = "foo".replaceAll("o", "a");
+```
+
 #### `Object.keys().forEach()` → [Object.entries()][mdn-object-entries]
 
 ```diff
@@ -449,8 +538,6 @@ Transformations are limited to when the receiver can be verified as a string (st
 +});
 ```
 
-Transforms Object.keys() iteration patterns where the value is accessed from the same object into Object.entries() with array destructuring. This eliminates duplicate property lookups and makes the code more concise.
-
 Transforms when:
 
 - The callback has one parameter (the key)
@@ -464,11 +551,9 @@ Transforms when:
 +Object.values(obj)
 ```
 
-Transforms `Object.keys(obj).map(key => obj[key])` patterns to use `Object.values()` directly. This eliminates redundant property lookups and expresses intent more clearly.
-
 Transforms when:
 
-- The callback has exactly one parameter (the key)
+- The callback has one parameter (the key)
 - The callback body returns `obj[key]` (expression or block with a single return statement)
 - The object being accessed matches the object passed to Object.keys()
 
@@ -628,187 +713,13 @@ These transformations are mainly to harden code for future releases and should b
 +});
 ```
 
-<picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://jquery.com/wp-content/themes/jquery/images/logo-jquery@2x.png">
-  <source media="(prefers-color-scheme: light)" srcset="https://upload.wikimedia.org/wikipedia/commons/f/fd/JQuery-Logo.svg">
-  <img alt="jQuery logo" src="https://upload.wikimedia.org/wikipedia/commons/f/fd/JQuery-Logo.svg" height="32" align="right">
-</picture>
-
-## jQuery
-
-esupgrade can transform common [jQuery] patterns to modern, standards-based DOM APIs via the `--jQuery` argument.
-For further reading, we recommend: [You Might Not Need jQuery](https://youmightnotneedjquery.com/).
-
-```bash
-npx esupgrade --jQuery <files>
-```
-
-> [!WARNING]
-> jQuery transformers are experimental and may produce unsafe code in complex scenarios.
-> Review all changes before applying them to your codebase.
-
-### Selection
-
-#### `$(selector)` → `document.querySelectorAll()` / `document.getElementById()`
-
-```diff
--$('.foo')
-- $('#bar')
-+document.querySelectorAll('.foo')
-+document.getElementById('bar')
-```
-
-Skipped when jQuery chaining is present (e.g. `$('.x').css(...).addClass(...)`).
-
-### Class and Attributes
-
-#### Class helpers
-
-```diff
--$(el).addClass('a b');
--$(el).removeClass('a');
--$(el).toggleClass('x');
--$(el).hasClass('x');
-+el.classList.add('a', 'b');
-+el.classList.remove('a');
-+el.classList.toggle('x');
-+el.classList.contains('x');
-```
-
-#### Attribute helpers
-
-```diff
--$(el).attr('data');
--$(el).attr('data', v);
--$(el).removeAttr('disabled');
-+el.getAttribute('data');
-+el.setAttribute('data', v);
-+el.removeAttribute('disabled');
-```
-
-### Content and Value
-
-#### Text and HTML accessors
-
-```diff
--const text = $(el).text();
--$(el).text('new text');
--const html = $(el).html();
--$(el).html('<b>bold</b>');
-+const text = el.textContent;
-+el.textContent = 'new text';
-+const html = el.innerHTML;
-+el.innerHTML = '<b>bold</b>';
-```
-
-#### Value accessors
-
-```diff
--const val = $(el).val();
--$(el).val('new value');
-+const val = el.value;
-+el.value = 'new value';
-```
-
-### DOM Manipulation
-
-#### Insertion and Removal
-
-```diff
--$(parent).append(child);
--$(parent).prepend(child);
--$(el).before(node);
--$(el).after(node);
--$(el).remove();
--$(el).empty();
-+parent.append(child);
-+parent.prepend(child);
-+el.before(node);
-+el.after(node);
-+el.remove();
-+el.replaceChildren();
-```
-
-### Events
-
-#### Event Listeners
-
-```diff
--$(el).on('click', handler);
--$(el).off('click', handler);
--$(el).click(handler);
-+el.addEventListener('click', handler);
-+el.removeEventListener('click', handler);
-+el.addEventListener('click', handler);
-```
-
-#### Dispatching and Ready
-
-```diff
--$(el).trigger('custom');
--$(document).ready(fn);
-+el.dispatchEvent(new CustomEvent('custom'));
-+document.addEventListener('DOMContentLoaded', fn);
-```
-
-### Traversal
-
-#### Traversal helpers
-
-```diff
--$(el).find('.sel');
--$(el).parent();
--$(el).closest('.sel');
--$(el).next();
--$(el).prev();
--$(el).children();
--$(el).siblings();
-+el.querySelectorAll('.sel');
-+el.parentElement;
-+el.closest('.sel');
-+el.nextElementSibling;
-+el.previousElementSibling;
-+Array.from(el.children);
-+Array.from(el.parentElement.children).filter(c => c !== el);
-```
-
-### Style and Sizing
-
-#### CSS and Display
-
-```diff
--$(el).css('color');
--$(el).css('color', 'red');
--$(el).show();
--$(el).hide();
-+getComputedStyle(el).color;
-+el.style.color = 'red';
-+el.style.display = '';
-+el.style.display = 'none';
-```
-
-#### Dimensions
-
-```diff
--$(el).width();
--$(el).height();
-+el.clientWidth;
-+el.clientHeight;
-```
-
-### Static Utilities
-
-#### Collection and String utilities
+#### `Object.prototype.hasOwnProperty.call()` → [Object.hasOwn()][mdn-object-has-own]
 
 ```diff
--$.each(array, fn);
--$.map(array, fn);
--$.inArray(val, array) !== -1;
--$.trim(str);
-+array.forEach(fn);
-+array.map(fn);
-+array.includes(val);
-+str.trim();
+-Object.prototype.hasOwnProperty.call(obj, prop);
+-({}).hasOwnProperty.call(obj, prop);
++Object.hasOwn(obj, prop);
++Object.hasOwn(obj, prop);
 ```
 
 ## Versioning
@@ -833,10 +744,12 @@ Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is
 [baseline]: https://web.dev/baseline/
 [calver]: https://calver.org/
 [django-upgrade]: https://github.com/adamchainz/django-upgrade
-[jquery]: https://jquery.com/
+[husky]: https://typicode.github.io/husky/
 [mdn-arrow-functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
 [mdn-async-await]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
+[mdn-at]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at
 [mdn-classes]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes
+[mdn-compound-assignment]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Addition_assignment
 [mdn-console]: https://developer.mozilla.org/en-US/docs/Web/API/console
 [mdn-const]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const
 [mdn-default-parameters]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters
@@ -849,10 +762,14 @@ Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is
 [mdn-globalthis]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
 [mdn-includes]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes
 [mdn-let]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let
+[mdn-logical-assignment]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR_assignment
 [mdn-nullish-coalescing]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing
+[mdn-numeric-separators]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#numeric_separators
 [mdn-object-entries]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries
+[mdn-object-has-own]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn
 [mdn-object-values]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values
 [mdn-promise-try]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/try
+[mdn-replaceall]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll
 [mdn-rest-parameters]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters
 [mdn-slice]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice
 [mdn-spread]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_syntax

package/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: esupgrade
+description: Auto-update JavaScript and TypeScript syntax to new ECMAScript features based on browser support.
+---
+
+Use the CLI with `npx` on files or directories:
+
+```console
+npx esupgrade [--baseline <newly-available|widely-available>] [--check] [--write] <files-or-directories>
+```
+
+- Use `--check` to preview changes and fail when updates are needed.
+- Use `--write` to apply updates in place.
+- Use `--baseline` to choose `newly-available` or `widely-available` (default).

package/bin/esupgrade.js

@@ -30,12 +30,11 @@ class WorkerRunner {
    * Run a worker thread to process a file.
    * @param {string} filePath - Path to the file to process.
    * @param {string} baseline - Baseline level for transformations.
-   * @param {boolean} jQuery - Whether to include jQuery transformers.
    * @returns {Promise<Object>} Worker message result.
    */
-  async run(filePath, baseline, jQuery) {
+  async run(filePath, baseline) {
     const worker = new Worker(this.workerPath, {
-      workerData: { filePath, baseline, jQuery },
+      workerData: { filePath, baseline },
     })
 
     const [message] = await once(worker, "message")
@@ -59,7 +58,6 @@ class FileProcessor {
    * @param {boolean} options.check - Whether to only check for changes.
    * @param {boolean} options.write - Whether to write changes to file.
    * @param {boolean} options.verbose - The verbosity level for logging.
-   * @param {boolean} options.jQuery - Whether to include jQuery transformers.
    * @returns {Promise<{modified: boolean, error: boolean}>} Result of processing.
    */
   async processFile(filePath, options) {
@@ -76,11 +74,7 @@ class FileProcessor {
     }
 
     try {
-      const workerResult = await this.workerRunner.run(
-        filePath,
-        options.baseline,
-        options.jQuery,
-      )
+      const workerResult = await this.workerRunner.run(filePath, options.baseline)
 
       if (!workerResult.success) {
         if (options.verbose) console.error(workerResult.error)
@@ -203,7 +197,6 @@ class CLIRunner {
   async run(patterns, options) {
     console.time("Processing")
     // Hand CLI-provided names directly to the worker pool; file validation occurs in processFile.
-    // Pass jQuery to worker pool
     const results = await this.workerPool.processFiles(patterns, options)
     console.timeEnd("Processing")
 
@@ -277,7 +270,6 @@ program
     false,
   )
   .option("--write", "Write changes to files", false)
-  .option("--jquery, --jQuery", "Enable jQuery specific transformers", false)
   .action(async (files, options) => {
     await cliRunner.run(files, options)
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esupgrade",
-  "version": "2025.19.0",
+  "version": "2025.20.1",
   "description": "Auto-upgrade your JavaScript syntax",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -1,7 +1,6 @@
 import jscodeshift from "jscodeshift"
 import * as newlyAvailable from "./newlyAvailable.js"
 import * as widelyAvailable from "./widelyAvailable.js"
-import * as jQueryTransformers from "./jQuery.js"
 
 /**
  * Transformer function type.
@@ -49,10 +48,9 @@ function applyTransformersRecursively(code, j, transformers, globalModified = fa
  *
  * @param {string} code - The source code to transform.
  * @param {string} baseline - Baseline level ('widely-available' or 'newly-available').
- * @param {boolean} jQuery - Whether to include jQuery transformers.
  * @returns {TransformResult} Object with transformed code and modification status.
  */
-export function transform(code, baseline = "widely-available", jQuery) {
+export function transform(code, baseline = "widely-available") {
   const j = jscodeshift.withParser("tsx")
 
   let transformers =
@@ -60,9 +58,5 @@ export function transform(code, baseline = "widely-available", jQuery) {
       ? { ...widelyAvailable, ...newlyAvailable }
       : widelyAvailable
 
-  if (jQuery) {
-    transformers = { ...transformers, ...jQueryTransformers }
-  }
-
   return applyTransformersRecursively(code, j, Object.values(transformers))
 }

package/src/newlyAvailable/promiseTry.js

@@ -151,3 +151,4 @@ export function promiseTry(root) {
 
   return modified
 }
+promiseTry.baselineDate = new Date(Date.UTC(2025, 0, 7))

package/src/widelyAvailable/anonymousFunctionToArrow.js

@@ -75,3 +75,4 @@ export function anonymousFunctionToArrow(root) {
 
   return modified
 }
+anonymousFunctionToArrow.baselineDate = new Date(Date.UTC(2016, 8, 20))

package/src/widelyAvailable/argumentsToRestParameters.js

@@ -26,8 +26,7 @@ export function argumentsToRestParameters(root) {
 
   functionNodes.forEach(({ node: func }) => {
     if (
-      (func.params.length > 0 &&
-        j.RestElement.check(func.params[func.params.length - 1])) ||
+      (func.params.length > 0 && j.RestElement.check(func.params.at(-1))) ||
       !j.BlockStatement.check(func.body)
     ) {
       return
@@ -86,3 +85,4 @@ export function argumentsToRestParameters(root) {
 
   return modified
 }
+argumentsToRestParameters.baselineDate = new Date(Date.UTC(2016, 8, 20))

package/src/widelyAvailable/arrayConcatToSpread.js

@@ -65,3 +65,4 @@ export function arrayConcatToSpread(root) {
 
   return modified
 }
+arrayConcatToSpread.baselineDate = new Date(Date.UTC(2015, 9, 14))

package/src/widelyAvailable/arrayFilterToFind.js

@@ -76,3 +76,4 @@ export function arrayFilterToFind(root) {
 
   return modified
 }
+arrayFilterToFind.baselineDate = new Date(Date.UTC(2016, 8, 20))

package/src/widelyAvailable/arrayFromForEachToForOf.js

@@ -72,3 +72,4 @@ export function arrayFromForEachToForOf(root) {
 
   return modified
 }
+arrayFromForEachToForOf.baselineDate = new Date(Date.UTC(2016, 8, 20))

package/src/widelyAvailable/arrayFromToSpread.js

@@ -56,3 +56,4 @@ export function arrayFromToSpread(root) {
 
   return modified
 }
+arrayFromToSpread.baselineDate = new Date(Date.UTC(2016, 8, 20))

package/src/widelyAvailable/arraySliceToSpread.js

@@ -54,3 +54,4 @@ export function arraySliceToSpread(root) {
 
   return modified
 }
+arraySliceToSpread.baselineDate = new Date(Date.UTC(2015, 9, 14))

package/src/widelyAvailable/compoundAssignment.js

@@ -0,0 +1,53 @@
+import { default as j } from "jscodeshift"
+import { NodeTest } from "../types.js"
+
+const BINARY_TO_COMPOUND = new Map([
+  ["+", "+="],
+  ["-", "-="],
+  ["*", "*="],
+  ["/", "/="],
+  ["%", "%="],
+  ["**", "**="],
+])
+
+/**
+ * Transform verbose assignment patterns to compound assignment operators.
+ *
+ * Transforms:
+ * - `x = x + y` → `x += y`
+ * - `x = x - y` → `x -= y`
+ * - `x = x * y` → `x *= y`
+ * - `x = x / y` → `x /= y`
+ * - `x = x % y` → `x %= y`
+ * - `x = x ** y` → `x **= y`
+ *
+ * @param {import("jscodeshift").Collection} root - The root AST collection
+ * @returns {boolean} True if code was modified
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Addition_assignment
+ */
+export function compoundAssignment(root) {
+  let modified = false
+
+  root
+    .find(j.AssignmentExpression, { operator: "=" })
+    .filter(({ node }) => {
+      if (!j.BinaryExpression.check(node.right)) return false
+      const op = node.right.operator
+      if (!BINARY_TO_COMPOUND.has(op)) return false
+      return new NodeTest(node.left).isEqual(node.right.left)
+    })
+    .forEach((path) => {
+      const { node } = path
+      const op = node.right.operator
+      const right = node.right.right
+
+      j(path).replaceWith(
+        j.assignmentExpression(BINARY_TO_COMPOUND.get(op), node.left, right),
+      )
+      modified = true
+    })
+
+  return modified
+}
+
+compoundAssignment.baselineDate = new Date(Date.UTC(1997, 5, 1))