esupgrade 2025.20.1 → 2025.22.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,32 @@
+{
+  "name": "esupgrade",
+  "description": "Auto-upgrade JavaScript and TypeScript syntax to new ECMAScript features based on browser support.",
+  "owner": {
+    "name": "codingjoe",
+    "email": "security@codingjoe.dev"
+  },
+  "plugins": [
+    {
+      "name": "esupgrade",
+      "source": "./",
+      "description": "Auto-upgrade JavaScript and TypeScript syntax to new ECMAScript features based on browser support.",
+      "displayName": "esupgrade",
+      "author": {
+        "name": "Johannes Maron",
+        "email": "security@codingjoe.dev"
+      },
+      "homepage": "https://github.com/codingjoe/esupgrade",
+      "repository": "https://github.com/codingjoe/esupgrade",
+      "license": "BSD-2-Clause",
+      "keywords": [
+        "javascript",
+        "ecmascript",
+        "modernize",
+        "upgrade",
+        "codemod",
+        "ast",
+        "transform"
+      ]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,22 @@
+{
+  "name": "esupgrade",
+  "displayName": "ESUpgrade",
+  "description": "Auto-upgrade JavaScript and TypeScript syntax to new ECMAScript features based on browser support.",
+  "version": "0.1.0",
+  "author": {
+    "name": "Johannes Maron",
+    "email": "security@codingjoe.dev"
+  },
+  "homepage": "https://github.com/codingjoe/esupgrade",
+  "repository": "https://github.com/codingjoe/esupgrade",
+  "license": "BSD-2-Clause",
+  "keywords": [
+    "javascript",
+    "ecmascript",
+    "modernize",
+    "upgrade",
+    "codemod",
+    "ast",
+    "transform"
+  ]
+}

package/.github/workflows/ci.yml

@@ -28,7 +28,7 @@ jobs:
           node-version-file: package.json
       - run: npm ci
       - run: node --test --experimental-test-coverage --test-reporter=spec --test-reporter=lcov --test-reporter-destination=stdout --test-reporter-destination=lcov.info
-      - uses: codecov/codecov-action@v6
+      - uses: codecov/codecov-action@v7
         with:
           token: ${{ secrets.CODECOV_TOKEN }}
           flags: javascript

package/README.md

@@ -10,15 +10,33 @@
 
 Keeping your JavaScript and TypeScript code up to date with full browser compatibility.
 
+## Sponsors
+
+[![Sponsors](https://django.the-box.sh/sponsors/codingjoe/esupgrade.svg)](https://github.com/sponsors/codingjoe)
+
 ## Usage
 
 esupgrade is safe and meant to be used automatically on your codebase.
-We recommend integrating it into your development workflow using [pre-commit] or [husky].
+We recommend integrating it into your development workflow using [pre-commit], [husky], or as an agent skill.
+
+### CLI
 
 To try it out on a repository without writing changes, run:
 
 ```bash
-npx esupgrade $(git ls-files | grep -E -i -w '.*\.(t|j)sx?')
+npx -y esupgrade $(git ls-files | grep -E -i -w '.*\.(t|j)sx?')
+```
+
+To transform code from standard input, pass `-` as the input path:
+
+```bash
+echo 'var x = 1;' | npx esupgrade -
+```
+
+For help with available options:
+
+```bash
+npx esupgrade --help
 ```
 
 ### pre-commit
@@ -45,15 +63,18 @@ pre-commit run esupgrade --all-files
 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; npx -y 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
+### Agent Skill
 
-```bash
-npx esupgrade --help
-```
+esupgrade is available as a skill in [Claude Code]. To use it:
+
+1. Run `/plugin marketplace add codingjoe/esupgrade`
+1. Run `/plugin install esupgrade@esupgrade`
+
+The skill will analyze your selected code and suggest transformations based on the Baseline browser support policy.
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://web-platform-dx.github.io/assets/img/baseline-wordmark-dark.svg">
@@ -229,12 +250,21 @@ Supports:
 ```diff
 -const budget = 1000000;
 -const maxUsers = 1000000n;
+-const permission = 0o1234567;
+-const mask = 0xabcdef;
+-const flags = 0b1010000111000011;
+-const ratio = 100000.25;
+-const large = 1e100000;
 +const budget = 1_000_000;
 +const maxUsers = 1_000_000n;
++const permission = 0o1_234_567;
++const mask = 0xab_cd_ef;
++const flags = 0b10100001_11000011;
++const ratio = 100_000.25;
++const large = 1e100_000;
 ```
 
-esupgrade transforms decimal integer and bigint literals with at least five digits.
-Fractional, exponential, hexadecimal, octal, binary, and already formatted literals are left unchanged.
+Decimal and octal numerals are grouped by triplets; hex and binary by byte.
 
 #### `Array.slice(0)` → [Array spread [...]][mdn-spread]
 
@@ -389,7 +419,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 are matched 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
 
@@ -743,6 +773,7 @@ Furthermore, esupgrade supports JavaScript, TypeScript, and more, while lebab is
 
 [baseline]: https://web.dev/baseline/
 [calver]: https://calver.org/
+[claude code]: https://code.claude.com
 [django-upgrade]: https://github.com/adamchainz/django-upgrade
 [husky]: https://typicode.github.io/husky/
 [mdn-arrow-functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions

package/SKILL.md

@@ -1,14 +1,20 @@
 ---
 name: esupgrade
 description: Auto-update JavaScript and TypeScript syntax to new ECMAScript features based on browser support.
+license: BSD-2-Clause
+metadata:
+  author: codingjoe <security@codingjoe.dev>
+allowed-tools: Bash(npx -y esupgrade *) READ
+compatibility: Requires Node.js 24 or later and npx.
 ---
 
-Use the CLI with `npx` on files or directories:
+Use the CLI with `npx` on files, directories, or standard input:
 
 ```console
-npx esupgrade [--baseline <newly-available|widely-available>] [--check] [--write] <files-or-directories>
+npx -y 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 `-` to read from standard input and write the transformed code to standard output.
+- Use `--write` to apply updates in place for file inputs.
 - Use `--baseline` to choose `newly-available` or `widely-available` (default).

package/bin/esupgrade.js

@@ -10,6 +10,7 @@ import path from "path"
 import { fileURLToPath } from "url"
 import { Worker } from "worker_threads"
 import pkg from "../package.json" with { type: "json" }
+import { transform } from "../src/index.js"
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -179,6 +180,62 @@ class WorkerPool {
   }
 }
 
+/**
+ * Processes stdin and handles output.
+ */
+class StdinProcessor {
+  /**
+   * Process stdin using the configured transformation options.
+   * @param {Object} options - Processing options.
+   * @param {string} options.baseline - Baseline level for transformations.
+   * @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.
+   * @returns {Promise<void>} Complete when stdin processing finishes.
+   */
+  async processStdin(options) {
+    if (options.write) {
+      console.error("Error: '--write' cannot be used with stdin")
+      process.exit(1)
+    }
+
+    try {
+      const code = await this.#readStdin()
+      const result = transform(code, options.baseline)
+
+      if (options.check) {
+        if (result.modified) {
+          process.exit(1)
+        }
+        return
+      }
+
+      process.stdout.write(result.code)
+    } catch (error) {
+      if (options.verbose) console.error(error)
+      console.error(`\x1b[31m✗\x1b[0m Error: stdin: ${error.message}`)
+      process.exit(128)
+    }
+  }
+
+  /**
+   * Read source code from stdin.
+   * @returns {Promise<string>} Source code from stdin.
+   */
+  async #readStdin() {
+    process.stdin.setEncoding("utf8")
+    let code = ""
+
+    function handleChunk(chunk) {
+      code += chunk
+    }
+
+    process.stdin.on("data", handleChunk)
+    await once(process.stdin, "end")
+    return code
+  }
+}
+
 /**
  * Orchestrates the CLI application.
  */
@@ -187,6 +244,7 @@ class CLIRunner {
     const workerRunner = new WorkerRunner(workerPath)
     const fileProcessor = new FileProcessor(workerRunner)
     this.workerPool = new WorkerPool(fileProcessor)
+    this.stdinProcessor = new StdinProcessor()
   }
 
   /**
@@ -195,6 +253,17 @@ class CLIRunner {
    * @param {Object} options - Processing options.
    */
   async run(patterns, options) {
+    switch (this.#getInputMode(patterns)) {
+      case "stdin":
+        await this.stdinProcessor.processStdin(options)
+        return
+      case "mixed":
+        console.error("Error: '-' cannot be combined with file paths")
+        return process.exit(1)
+      default:
+        break
+    }
+
     console.time("Processing")
     // Hand CLI-provided names directly to the worker pool; file validation occurs in processFile.
     const results = await this.workerPool.processFiles(patterns, options)
@@ -203,6 +272,24 @@ class CLIRunner {
     this.#reportSummary(results, options)
   }
 
+  /**
+   * Classify the input mode selected by CLI arguments.
+   * @param {string[]} patterns - File paths to process.
+   * @returns {"files" | "stdin" | "mixed"} Selected input mode.
+   */
+  #getInputMode(patterns) {
+    const stdinCount = patterns.filter((pattern) => pattern === "-").length
+
+    switch (stdinCount) {
+      case 0:
+        return "files"
+      case 1:
+        return patterns.length === 1 ? "stdin" : "mixed"
+      default:
+        return "mixed"
+    }
+  }
+
   #reportSummary(results, options) {
     let modifiedCount = 0
     const errorCount = results.filter((result) => {
@@ -257,7 +344,7 @@ program
   .name("esupgrade")
   .description("Auto-upgrade your JavaScript syntax")
   .version(pkg.version)
-  .argument("<files...>", "Files or directories to process")
+  .argument("<files...>", "Files or directories to process, or '-' to read from stdin")
   .addOption(
     new Option("--baseline <level>", "Set baseline level for transformations")
       .choices(["widely-available", "newly-available"])

package/package.json

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

package/src/widelyAvailable/numericSeparators.js

@@ -1,6 +1,33 @@
 import { default as j } from "jscodeshift"
 
-const LARGE_DECIMAL_INTEGER_LITERAL = /^(?<digits>[1-9]\d{4,})(?<suffix>n)?$/
+const MIN_DIGITS_FOR_GROUPING = 5
+const TRANSFORMABLE_DECIMAL_INTEGER_LITERAL = new RegExp(
+  `^(?<digits>[1-9]\\d{${MIN_DIGITS_FOR_GROUPING - 1},})(?<suffix>n)?$`,
+)
+const TRANSFORMABLE_OCTAL_LITERAL =
+  /^(?<prefix>0[oO])(?<digits>[0-7]{4,})(?<suffix>n)?$/
+const TRANSFORMABLE_HEX_LITERAL =
+  /^(?<prefix>0[xX])(?<digits>[0-9a-fA-F]{3,})(?<suffix>n)?$/
+const TRANSFORMABLE_BINARY_LITERAL =
+  /^(?<prefix>0[bB])(?<digits>[01]{9,})(?<suffix>n)?$/
+const FLOAT_LITERAL = /^(?<integer>\d+)\.(?<decimal>\d*)$/
+const EXPONENTIAL_LITERAL =
+  /^(?:(?<mantissaInt>\d+)(?:\.(?<mantissaDec>\d*))?|\.(?<mantissaLeadingDec>\d+))(?<expMarker>[eE])(?<sign>[+-]?)(?<exponent>\d+)$/
+
+/**
+ * Apply numeric separators to digit groups counted from the right.
+ *
+ * @param {string} digits - Digit string without separators.
+ * @param {number} groupSize - Number of characters per group.
+ * @returns {string} Digits with `_` inserted between right-aligned groups.
+ */
+function applyDigitGroupSep(digits, groupSize) {
+  const firstGroupLength = digits.length % groupSize || groupSize
+
+  return digits.length > groupSize
+    ? `${digits.slice(0, firstGroupLength)}_${applyDigitGroupSep(digits.slice(firstGroupLength), groupSize)}`
+    : digits
+}
 
 /**
  * Return a decimal integer literal with numeric separators when applicable.
@@ -8,8 +35,8 @@ const LARGE_DECIMAL_INTEGER_LITERAL = /^(?<digits>[1-9]\d{4,})(?<suffix>n)?$/
  * @param {string} rawLiteral - Raw literal source text.
  * @returns {string | null} Formatted literal or null when no change applies.
  */
-function formatNumericLiteral(rawLiteral) {
-  const match = rawLiteral.match(LARGE_DECIMAL_INTEGER_LITERAL)
+function formatDecimalIntegerLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_DECIMAL_INTEGER_LITERAL)
 
   if (!match?.groups) {
     return null
@@ -17,7 +44,147 @@ function formatNumericLiteral(rawLiteral) {
 
   const { digits, suffix = "" } = match.groups
 
-  return `${digits.replace(/\B(?=(\d{3})+(?!\d))/g, "_")}${suffix}`
+  return `${applyDigitGroupSep(digits, 3)}${suffix}`
+}
+
+/**
+ * Return an octal literal with triplet numeric separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatOctalLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_OCTAL_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { prefix, digits, suffix = "" } = match.groups
+
+  return `${prefix}${applyDigitGroupSep(digits, 3)}${suffix}`
+}
+
+/**
+ * Return a hex literal with byte-level numeric separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatHexLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_HEX_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { prefix, digits, suffix = "" } = match.groups
+
+  // Insert `_` before each group of 2 hex chars counted from the right.
+  return `${prefix}${applyDigitGroupSep(digits, 2)}${suffix}`
+}
+
+/**
+ * Return a binary literal with byte-level numeric separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatBinaryLiteral(rawLiteral) {
+  const match = rawLiteral.match(TRANSFORMABLE_BINARY_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { prefix, digits, suffix = "" } = match.groups
+
+  // Insert `_` before each group of 8 bits counted from the right.
+  return `${prefix}${applyDigitGroupSep(digits, 8)}${suffix}`
+}
+
+/**
+ * Return a float literal with thousands separators on the integer part when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatFloatLiteral(rawLiteral) {
+  const match = rawLiteral.match(FLOAT_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const { integer, decimal } = match.groups
+
+  if (integer.length < MIN_DIGITS_FOR_GROUPING) {
+    return null
+  }
+
+  return `${applyDigitGroupSep(integer, 3)}.${decimal}`
+}
+
+/**
+ * Return an exponential literal with thousands separators on large parts when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatExponentialLiteral(rawLiteral) {
+  const match = rawLiteral.match(EXPONENTIAL_LITERAL)
+
+  if (!match?.groups) {
+    return null
+  }
+
+  const {
+    mantissaInt = "",
+    mantissaDec,
+    mantissaLeadingDec,
+    expMarker,
+    sign,
+    exponent,
+  } = match.groups
+
+  const formattedMantissaInt =
+    mantissaInt.length >= MIN_DIGITS_FOR_GROUPING
+      ? applyDigitGroupSep(mantissaInt, 3)
+      : mantissaInt
+  const formattedExponent =
+    exponent.length >= MIN_DIGITS_FOR_GROUPING
+      ? applyDigitGroupSep(exponent, 3)
+      : exponent
+
+  if (formattedMantissaInt === mantissaInt && formattedExponent === exponent) {
+    return null
+  }
+
+  const mantissa =
+    typeof mantissaLeadingDec === "string"
+      ? `.${mantissaLeadingDec}`
+      : typeof mantissaDec === "string"
+        ? `${formattedMantissaInt}.${mantissaDec}`
+        : formattedMantissaInt
+
+  return `${mantissa}${expMarker}${sign}${formattedExponent}`
+}
+
+/**
+ * Return a numeric literal with separators when applicable.
+ *
+ * @param {string} rawLiteral - Raw literal source text.
+ * @returns {string | null} Formatted literal or null when no change applies.
+ */
+function formatLiteral(rawLiteral) {
+  return (
+    formatDecimalIntegerLiteral(rawLiteral) ??
+    formatOctalLiteral(rawLiteral) ??
+    formatHexLiteral(rawLiteral) ??
+    formatBinaryLiteral(rawLiteral) ??
+    formatFloatLiteral(rawLiteral) ??
+    formatExponentialLiteral(rawLiteral)
+  )
 }
 
 /**
@@ -29,7 +196,7 @@ function formatNumericLiteral(rawLiteral) {
 function updateNumericLiteral(literalNode) {
   const formattedLiteral =
     typeof literalNode.extra?.raw === "string"
-      ? formatNumericLiteral(literalNode.extra.raw)
+      ? formatLiteral(literalNode.extra.raw)
       : null
 
   if (!formattedLiteral) {
@@ -45,7 +212,7 @@ function updateNumericLiteral(literalNode) {
 }
 
 /**
- * Transform large decimal integer literals to use numeric separators.
+ * Transform numeric literals to use numeric separators.
  *
  * @param {import("jscodeshift").Collection} root - The root AST collection.
  * @returns {boolean} True if code was modified.

package/tests/cli.test.js

@@ -106,6 +106,118 @@ describe("CLI", () => {
     assert.equal(result.status, 0, "exits successfully")
   })
 
+  test("transform stdin and write code to stdout", () => {
+    fs.writeFileSync(path.join(tempDir, "-"), "const fromFile = true;")
+
+    const result = spawnSync(process.execPath, [CLI_PATH, "-"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+      cwd: tempDir,
+    })
+
+    assert.match(result.stdout, /const x = 1;/, "writes transformed code to stdout")
+    assert.doesNotMatch(
+      result.stdout,
+      /would be upgraded|All files are up to date|Processing:/,
+      "omits file-processing summary output",
+    )
+    assert.equal(result.status, 0, "exits successfully")
+  })
+
+  test("transform stdin with newly-available baseline", () => {
+    const result = spawnSync(
+      process.execPath,
+      [CLI_PATH, "-", "--baseline", "newly-available"],
+      {
+        encoding: "utf8",
+        input: "const p = new Promise((resolve) => resolve(getData()));",
+      },
+    )
+
+    assert.match(
+      result.stdout,
+      /Promise\.try/,
+      "writes transformations from the selected baseline",
+    )
+    assert.equal(result.status, 0, "exits successfully")
+  })
+
+  test("exit with 1 when --check finds stdin changes", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--check"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+    })
+
+    assert.equal(result.stdout, "", "omits transformed output in check mode")
+    assert.equal(result.status, 1, "exits with 1 when stdin needs upgrading")
+  })
+
+  test("exit with 0 when --check finds no stdin changes", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--check"], {
+      encoding: "utf8",
+      input: "const x = 1;",
+    })
+
+    assert.equal(result.stdout, "", "omits transformed output in check mode")
+    assert.equal(result.status, 0, "exits with 0 when stdin is up to date")
+  })
+
+  test("error when combining stdin with --write", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--write"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+    })
+
+    assert.match(
+      result.stderr,
+      /cannot be used with stdin/,
+      "displays stdin write error",
+    )
+    assert.equal(result.status, 1, "exits with 1")
+  })
+
+  test("error when stdin marker appears multiple times", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "-"], {
+      encoding: "utf8",
+      input: "var x = 1;",
+    })
+
+    assert.match(
+      result.stderr,
+      /cannot be combined with file paths/,
+      "displays input error",
+    )
+    assert.equal(result.status, 1, "exits with 1")
+  })
+
+  test("error when combining stdin with file arguments", () => {
+    const testFile = path.join(tempDir, "test.js")
+    fs.writeFileSync(testFile, "var x = 1;")
+
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", testFile], {
+      encoding: "utf8",
+      input: "var y = 2;",
+    })
+
+    assert.match(
+      result.stderr,
+      /cannot be combined with file paths/,
+      "displays input error",
+    )
+    assert.equal(result.status, 1, "exits with 1")
+  })
+
+  test("show stdin parse error with --verbose", () => {
+    const result = spawnSync(process.execPath, [CLI_PATH, "-", "--verbose"], {
+      encoding: "utf8",
+      input: "var x = {{{;",
+    })
+
+    assert.match(result.stderr, /Error:/, "displays error message")
+    assert.match(result.stderr, /\n\s*at /, "includes stack trace at verbosity level 1")
+    assert.equal(result.status, 128, "exits with 128 on stdin errors")
+  })
+
   test("check files without writing with --check", () => {
     const testFile = path.join(tempDir, "test.js")
     const originalCode = `var x = 1;`

package/tests/widelyAvailable/numeric-separators.test.js

@@ -40,10 +40,240 @@ suite("widely-available", () => {
       assert(!result.modified)
     })
 
-    test("skip non-decimal literals", () => {
-      const result = transform(
-        `const hexMask = 0xabcdef; const exponent = 1e12; const ratio = 10000.25;`,
-      )
+    test("skip small float and short exponent literals", () => {
+      const result = transform(`const ratio = 1000.25; const exponent = 1e12;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform float literals", () => {
+      const result = transform(`const ratio = 100000.25;`)
+
+      assert.match(result.code, /100_000\.25/)
+      assert(result.modified)
+    })
+
+    test("transform float literals with exact five-digit integer part", () => {
+      const result = transform(`const ratio = 10000.5;`)
+
+      assert.match(result.code, /10_000\.5/)
+      assert(result.modified)
+    })
+
+    test("transform float literals without decimal digits", () => {
+      const result = transform(`const ratio = 10000.;`)
+
+      assert.match(result.code, /10_000\./)
+      assert(result.modified)
+    })
+
+    test("skip float literals with short integer part", () => {
+      const result = transform(`const ratio = 1000.5;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform exponential literals with large exponent", () => {
+      const result = transform(`const n = 1e100000;`)
+
+      assert.match(result.code, /1e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with large mantissa", () => {
+      const result = transform(`const n = 10000e12;`)
+
+      assert.match(result.code, /10_000e12/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with large mantissa and exponent", () => {
+      const result = transform(`const n = 10000e100000;`)
+
+      assert.match(result.code, /10_000e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with float mantissa and large exponent", () => {
+      const result = transform(`const n = 1.5e100000;`)
+
+      assert.match(result.code, /1\.5e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with leading-dot mantissa", () => {
+      const result = transform(`const n = .5e100000;`)
+
+      assert.match(result.code, /\.5e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with trailing-dot mantissa", () => {
+      const result = transform(`const n = 10000.e100000;`)
+
+      assert.match(result.code, /10_000\.e100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with signed exponent", () => {
+      const result = transform(`const n = 1e+100000;`)
+
+      assert.match(result.code, /1e\+100_000/)
+      assert(result.modified)
+    })
+
+    test("transform exponential literals with negative exponent", () => {
+      const result = transform(`const n = 1e-100000;`)
+
+      assert.match(result.code, /1e-100_000/)
+      assert(result.modified)
+    })
+
+    test("transform float literals with leading-zero decimal part", () => {
+      const result = transform(`const ratio = 10000.05;`)
+
+      assert.match(result.code, /10_000\.05/)
+      assert(result.modified)
+    })
+
+    test("transform hex literals", () => {
+      const result = transform(`const mask = 0xabcdef;`)
+
+      assert.match(result.code, /0xab_cd_ef/)
+      assert(result.modified)
+    })
+
+    test("transform octal literals", () => {
+      const result = transform(`const permission = 0o1234567;`)
+
+      assert.match(result.code, /0o1_234_567/)
+      assert(result.modified)
+    })
+
+    test("transform uppercase octal literals", () => {
+      const result = transform(`const permission = 0O1234567;`)
+
+      assert.match(result.code, /0O1_234_567/)
+      assert(result.modified)
+    })
+
+    test("transform octal bigint literals", () => {
+      const result = transform(`const permission = 0o1234567n;`)
+
+      assert.match(result.code, /0o1_234_567n/)
+      assert(result.modified)
+    })
+
+    test("skip short octal literals", () => {
+      const result = transform(`const permission = 0o777;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip already formatted octal literals", () => {
+      const result = transform(`const permission = 0o1_234_567;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform uppercase hex literals", () => {
+      const result = transform(`const mask = 0xABCDEF;`)
+
+      assert.match(result.code, /0xAB_CD_EF/)
+      assert(result.modified)
+    })
+
+    test("transform hex literals with odd digit count", () => {
+      const result = transform(`const mask = 0xabcde;`)
+
+      assert.match(result.code, /0xa_bc_de/)
+      assert(result.modified)
+    })
+
+    test("transform hex bigint literals", () => {
+      const result = transform(`const id = 0xabcdefn;`)
+
+      assert.match(result.code, /0xab_cd_efn/)
+      assert(result.modified)
+    })
+
+    test("skip short hex literals", () => {
+      const result = transform(`const byte = 0xff;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip already formatted hex literals", () => {
+      const result = transform(`const mask = 0xab_cd_ef;`)
+
+      assert(!result.modified)
+    })
+
+    test("transform binary literals", () => {
+      const result = transform(`const flags = 0b1010000111000011;`)
+
+      assert.match(result.code, /0b10100001_11000011/)
+      assert(result.modified)
+    })
+
+    test("transform binary literals with partial leading byte", () => {
+      const result = transform(`const flags = 0b100000001;`)
+
+      assert.match(result.code, /0b1_00000001/)
+      assert(result.modified)
+    })
+
+    test("transform binary bigint literals", () => {
+      const result = transform(`const flags = 0b1010000111000011n;`)
+
+      assert.match(result.code, /0b10100001_11000011n/)
+      assert(result.modified)
+    })
+
+    test("skip short binary literals", () => {
+      const result = transform(`const byte = 0b11111111;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip already formatted binary literals", () => {
+      const result = transform(`const flags = 0b10100001_11000011;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip hex literals with non-byte grouping", () => {
+      const result = transform(`const mask = 0xabc_def;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip binary literals with non-byte grouping", () => {
+      const result = transform(`const flags = 0b1010_0001_1100_0011;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip decimal literals with non-thousand grouping", () => {
+      const result = transform(`const n = 1_0000_000;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip octal literals with non-triplet grouping", () => {
+      const result = transform(`const permission = 0o12_34567;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip float literals with non-standard existing separators", () => {
+      const result = transform(`const ratio = 100_00.25;`)
+
+      assert(!result.modified)
+    })
+
+    test("skip exponential literals with non-standard existing separators", () => {
+      const result = transform(`const n = 1_0000e12;`)
 
       assert(!result.modified)
     })