es-check 9.1.4 → 9.2.0

package/README.md

@@ -24,10 +24,19 @@ Ensuring that JavaScript files can pass ES Check is important in a [modular and
 
 **ES Check** version 9 is a major release update that can enforce more ES version specific features checks, implements initial browserslist integration, basic (naive) polyfill detection, and supports an allowlist. To enable ecmaVersion specific checks, pass the `--checkFeatures` flag. To enable browserslist integration, pass the `--checkBrowser` flag. To enable polyfill detection, pass the `--checkForPolyfills` flag. There is also more config file support. Besides this, there are other feature updates based on user feedback. This version should not break any existing scripts but, as significant changes/features have been added and it's know that es-check supports protecting against breaking errors going to production, a major version bump feels appropriate. Please report any issues!
 
+
+### `--checkFeatures`
+
 ```sh
 es-check es6 './dist/**/*.js' --checkFeatures
 ```
 
+### `checkBrowser --browserslistQuery='<broswerslist query>'`
+
+```sh
+es-check checkBrowser ./dist/**/*.js --browserslistQuery="last 2 versions"
+```
+
 ---
 
 <p align="center">
@@ -82,22 +91,20 @@ ES Check checks syntax out of the box—to protect against breaking errors going
 
 The images below demonstrate command line scripts and their corresponding logged results.
 
-Pass
+### Pass
+
 ![pass](https://user-images.githubusercontent.com/1074042/31471487-d7be22ee-ae9d-11e7-86e2-2c0f71cfffe6.jpg)
 
-Fail
+### Fail
+
 ![fail](https://user-images.githubusercontent.com/1074042/31471486-d65c3a80-ae9d-11e7-94fd-68b7acdb2d89.jpg)
 
-**ES Check** is run above with node commands. It can also be run within npm scripts, ci tools, or testing suites.
+**ES Check** is run above with node commands. It can also be run within npm scripts, ci tools, or testing suites. It also provide minimal support for use in node apps. 
 
 ---
 
 ## API
 
-**ES Check** provides the necessities. It accepts its place as a JavaScript matcher/tester.
-
-### General Information
-
 ```sh
 
 # USAGE
@@ -145,6 +152,7 @@ Here's a comprehensive list of all available options:
 | `--browserslistPath <path>` | Path to custom browserslist configuration (default: uses standard browserslist config resolution) |
 | `--browserslistEnv <env>` | Browserslist environment to use (default: production) |
 | `--config <path>` | Path to custom .escheckrc config file |
+| `--batchSize <number>` | Number of files to process concurrently (0 for unlimited, default: 0) |
 | `-h, --help` | Display help for command |
 
 ### Shell Completion
@@ -264,7 +272,7 @@ es-check checkBrowser ./dist/**/*.js
 
 ## Usage
 
-ES Check is a shell command CLI. It is run in [shell tool](http://linuxcommand.org/lc3_learning_the_shell.php) like Terminal, ITerm, or Hyper. It takes in two arguments: an [ECMAScript version](https://www.w3schools.com/js/js_versions.asp) (`<ECMAScript version>`) and files (`[files]`) in [globs](http://searchsecurity.techtarget.com/definition/globbing).
+ES Check is mainly a shell command CLI. It is run in [shell tool](http://linuxcommand.org/lc3_learning_the_shell.php) like Terminal, ITerm, or Hyper. It takes in two arguments: an [ECMAScript version](https://www.w3schools.com/js/js_versions.asp) (`<ECMAScript version>`) and files (`[files]`) in [globs](http://searchsecurity.techtarget.com/definition/globbing).
 
 Here are some example of **es check** scripts that could be run:
 
@@ -276,6 +284,36 @@ es-check es6 ./js/*.js
 es-check es6 ./js/*.js ./dist/*.js
 ```
 
+### Using ES Check in Node
+
+In addition to its CLI utility, ES Check can be used programmatically in Node.js applications:
+
+```javascript
+const { runChecks, loadConfig } = require('es-check');
+
+async function checkMyFiles() {
+  const config = {
+    ecmaVersion: 'es5',
+    files: ['dist/**/*.js'],
+    module: false,
+    checkFeatures: true
+  };
+  
+  try {
+    await runChecks([config], logger);
+    console.log('All files passed ES5 check!');
+  } catch (error) {
+    console.error('Some files failed the ES check');
+    process.exit(1);
+  }
+}
+
+async function checkWithConfig() {
+  const configs = await loadConfig('./.escheckrc');
+  await runChecks(configs, logger);
+}
+```
+
 ---
 
 ## Configuration
@@ -485,6 +523,40 @@ es-check --checkBrowser --checkFeatures ./dist/**/*.js
 
 ---
 
+## Performance Optimization
+
+ES Check provides the `--batchSize` option to optimize performance for different scenarios:
+
+```sh
+# Process all files in parallel (default)
+es-check es5 './dist/**/*.js' --batchSize 0
+
+# Process 10 files at a time (memory-constrained environments)
+es-check es5 './dist/**/*.js' --batchSize 10
+
+# Process 50 files at a time (balanced approach)
+es-check es5 './dist/**/*.js' --batchSize 50
+```
+
+### Performance Guidelines
+
+| Scenario | Recommended `--batchSize` | Reason |
+|----------|---------------------------|---------|
+| Small codebases (< 100 files) | `0` (unlimited) | Maximum parallelism for fastest results |
+| Medium codebases (100-500 files) | `0` or `50` | Balance between speed and memory |
+| Large codebases (> 500 files) | `50-100` | Prevent memory spikes |
+| CI/CD with limited memory | `10-20` | Conservative memory usage |
+| Local development | `0` (default) | Utilize available hardware |
+
+### Recent Performance Improvements
+
+As of August 2025, ES Check has been optimized with:
+- **Single-parse optimization**: Files are parsed once and the AST is reused
+- **Async file processing**: Non-blocking I/O for better performance
+- **Configurable batch processing**: Fine-tune based on your needs
+
+---
+
 ## Checking node_modules Dependencies
 
 To check node_modules dependencies for ES compatibility:
@@ -503,13 +575,13 @@ A simple example script is available in `examples/check-node-modules.js`.
 
 ## Acknowledgements
 
-ES Check is a small utility using powerful tools that [Isaac Z. Schlueter](https://github.com/isaacs), [Marijn Haverbeke](https://github.com/marijnh), and [Matthias Etienne](https://github.com/mattallty) built. [ES Checker](https://github.com/ruanyf/es-checker) by [Ruan YiFeng](https://github.com/ruanyf) checks the JavaScript version supported within a [browser](http://ruanyf.github.io/es-checker/) at run time. ES Check offers similar feedback to ES Checker but at build time and is specific to the product that is using it. ES Check was started after reading this [post](https://philipwalton.com/articles/deploying-es2015-code-in-production-today/) about [deploying es2015 code to production today] by [Philip Walton](https://github.com/philipwalton).
+ES Check is a small utility using powerful tools that [Isaac Z. Schlueter](https://github.com/isaacs), [Marijn Haverbeke](https://github.com/marijnh), and [Matthias Etienne](https://github.com/mattallty) built. [ES Checker](https://github.com/ruanyf/es-checker) by [Ruan YiFeng](https://github.com/ruanyf) checks the JavaScript version supported within a [browser](http://ruanyf.github.io/es-checker/) at run time. ES Check offers similar feedback to ES Checker but at build time and is specific to the product that is using it. ES Check was started after reading [Philip Walton](https://github.com/philipwalton)'s post about [deploying es2015 code to production today](https://philipwalton.com/articles/deploying-es2015-code-in-production-today/).
 
 ---
 
 ## Contributing
 
-ES Check has 7 dependencies: [acorn and acorn-walk](https://github.com/ternjs/acorn/), [fast-glob](https://github.com/mrmlnc/fast-glob), [supports-color](github.com/chalk/supports-color), [winston](https://github.com/winstonjs/winston), [browserslist](https://github.com/browserslist/browserslist), and [commander](https://github.com/tj/commander). To contribute, file an [issue](https://github.com/yowainwright/es-check/issues) or submit a pull request.
+ES Check has 7 dependencies: [acorn and acorn-walk](https://github.com/ternjs/acorn/), [fast-glob](https://github.com/mrmlnc/fast-glob), [supports-color](https://github.com/chalk/supports-color), [winston](https://github.com/winstonjs/winston), [browserslist](https://github.com/browserslist/browserslist), and [commander](https://github.com/tj/commander). To contribute, file an [issue](https://github.com/yowainwright/es-check/issues) or submit a pull request.
 
 To update es versions, check out these lines of code [here](https://github.com/yowainwright/es-check/blob/main/index.js#L92-L153) and [here (in acorn.js)](https://github.com/acornjs/acorn/blob/3221fa54f9dea30338228b97210c4f1fd332652d/acorn/src/acorn.d.ts#L586).
 

package/constants.js

@@ -502,6 +502,100 @@ const ES_FEATURES = {
       property: 'with',
     },
   },
+
+  // ----------------------------------------------------------
+  // ES14 / ES2023 (continued)
+  // ----------------------------------------------------------
+  ArrayFindLast: {
+    minVersion: 14,
+    example: 'arr.findLast(x => x > 5)',
+    astInfo: {
+      nodeType: 'CallExpression',
+      property: 'findLast',
+    },
+  },
+  ArrayFindLastIndex: {
+    minVersion: 14,
+    example: 'arr.findLastIndex(x => x > 5)',
+    astInfo: {
+      nodeType: 'CallExpression',
+      property: 'findLastIndex',
+    },
+  },
+
+  // ----------------------------------------------------------
+  // ES15 / ES2024
+  // ----------------------------------------------------------
+  ObjectHasOwn: {
+    minVersion: 13,
+    example: 'Object.hasOwn(obj, "prop")',
+    astInfo: {
+      nodeType: 'CallExpression',
+      object: 'Object',
+      property: 'hasOwn',
+    },
+  },
+  StringIsWellFormed: {
+    minVersion: 15,
+    example: 'str.isWellFormed()',
+    astInfo: {
+      nodeType: 'CallExpression',
+      property: 'isWellFormed',
+    },
+  },
+  StringToWellFormed: {
+    minVersion: 15,
+    example: 'str.toWellFormed()',
+    astInfo: {
+      nodeType: 'CallExpression',
+      property: 'toWellFormed',
+    },
+  },
+  RegExpUnicodeSetFlag: {
+    minVersion: 15,
+    example: '/pattern/v',
+    astInfo: {
+      nodeType: 'RegExpLiteral',
+      flags: 'v',
+    },
+  },
+
+  // ----------------------------------------------------------
+  // ES16 / ES2025
+  // ----------------------------------------------------------
+  ArrayGroup: {
+    minVersion: 16,
+    example: 'arr.group(x => x.category)',
+    astInfo: {
+      nodeType: 'CallExpression',
+      property: 'group',
+    },
+  },
+  ArrayGroupToMap: {
+    minVersion: 16,
+    example: 'arr.groupToMap(x => x.category)',
+    astInfo: {
+      nodeType: 'CallExpression',
+      property: 'groupToMap',
+    },
+  },
+  PromiseTry: {
+    minVersion: 16,
+    example: 'Promise.try(() => syncOrAsyncFunction())',
+    astInfo: {
+      nodeType: 'CallExpression',
+      object: 'Promise',
+      property: 'try',
+    },
+  },
+  DuplicateNamedCaptureGroups: {
+    minVersion: 16,
+    example: '/(?<name>a)|(?<name>b)/',
+    astInfo: {
+      nodeType: 'RegExpLiteral',
+      duplicateNamedGroups: true,
+    },
+  },
 };
 
 const NODE_TYPES = {
@@ -512,6 +606,45 @@ const NODE_TYPES = {
   NEW_EXPRESSION: 'NewExpression',
 };
 
+const POLYFILL_PATTERNS = [
+  // Array methods
+  { pattern: /Array\.prototype\.toSorted/, feature: 'ArrayToSorted' },
+  { pattern: /Array\.prototype\.findLast/, feature: 'ArrayFindLast' },
+  { pattern: /Array\.prototype\.findLastIndex/, feature: 'ArrayFindLastIndex' },
+  { pattern: /Array\.prototype\.at/, feature: 'ArrayAt' },
+
+  // String methods
+  { pattern: /String\.prototype\.replaceAll/, feature: 'StringReplaceAll' },
+  { pattern: /String\.prototype\.matchAll/, feature: 'StringMatchAll' },
+  { pattern: /String\.prototype\.at/, feature: 'StringAt' },
+
+  // Object methods
+  { pattern: /Object\.hasOwn/, feature: 'ObjectHasOwn' },
+
+  // Promise methods
+  { pattern: /Promise\.any/, feature: 'PromiseAny' },
+
+  // RegExp methods
+  { pattern: /RegExp\.prototype\.exec/, feature: 'RegExpExec' },
+
+  // Global methods
+  { pattern: /globalThis/, feature: 'GlobalThis' },
+];
+
+const IMPORT_PATTERNS = [
+  { pattern: /from\s+['"]core-js\/modules\/es\.array\.to-sorted['"]/, feature: 'ArrayToSorted' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.array\.find-last['"]/, feature: 'ArrayFindLast' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.array\.find-last-index['"]/, feature: 'ArrayFindLastIndex' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.array\.at['"]/, feature: 'ArrayAt' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.string\.replace-all['"]/, feature: 'StringReplaceAll' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.string\.match-all['"]/, feature: 'StringMatchAll' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.string\.at['"]/, feature: 'StringAt' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.object\.has-own['"]/, feature: 'ObjectHasOwn' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.promise\.any['"]/, feature: 'PromiseAny' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.regexp\.exec['"]/, feature: 'RegExpExec' },
+  { pattern: /from\s+['"]core-js\/modules\/es\.global-this['"]/, feature: 'GlobalThis' },
+];
+
 const BROWSER_TO_ES_VERSION = {
   ie: {
     '11': 5
@@ -578,74 +711,88 @@ const JS_VERSIONS = [
   'es3', 'es4', 'es5', 'es6', 'es2015',
   'es7', 'es2016', 'es8', 'es2017', 'es9', 'es2018',
   'es10', 'es2019', 'es11', 'es2020', 'es12', 'es2021',
-  'es13', 'es2022', 'es14', 'es2023', 'checkBrowser'
+  'es13', 'es2022', 'es14', 'es2023', 'es15', 'es2024', 'es16', 'es2025', 'checkBrowser'
 ];
 
 /**
- * Maps feature names from ES_FEATURES to their polyfill patterns
- * This helps us identify which features are being polyfilled
+ * Maps feature names from ES_FEATURES to their polyfill patterns.
+ * This version uses standardized keys and robust regex for both manual and module polyfills.
  */
 const FEATURE_TO_POLYFILL_MAP = {
-  // Array methods
-  'ArrayToSorted': [
-    /Array\.prototype\.toSorted/,
-    /from\s+['"]core-js\/modules\/es\.array\.to-sorted['"]/
-  ],
-  'ArrayFindLast': [
-    /Array\.prototype\.findLast/,
-    /from\s+['"]core-js\/modules\/es\.array\.find-last['"]/
-  ],
-  'ArrayFindLastIndex': [
-    /Array\.prototype\.findLastIndex/,
-    /from\s+['"]core-js\/modules\/es\.array\.find-last-index['"]/
-  ],
-  'ArrayAt': [
-    /Array\.prototype\.at/,
-    /from\s+['"]core-js\/modules\/es\.array\.at['"]/
-  ],
+    // ES2015 (ES6)
+    'Array.from': [/\bArray\.from\s*=/, /['"]core-js\/modules\/es\.array\.from['"]/],
+    'Array.of': [/\bArray\.of\s*=/, /['"]core-js\/modules\/es\.array\.of['"]/],
+    'Array.prototype.find': [/\bArray\.prototype\.find\s*=/, /['"]core-js\/modules\/es\.array\.find['"]/],
+    'Array.prototype.findIndex': [/\bArray\.prototype\.findIndex\s*=/, /['"]core-js\/modules\/es\.array\.find-index['"]/],
+    'Object.assign': [/\bObject\.assign\s*=/, /['"]core-js\/modules\/es\.object\.assign['"]/, /object-assign/],
+    'Promise': [/\bPromise\s*=/, /['"]core-js\/modules\/es\.promise['"]/, /es6-promise/],
+    'String.prototype.startsWith': [/\bString\.prototype\.startsWith\s*=/, /['"]core-js\/modules\/es\.string\.starts-with['"]/],
+    'String.prototype.endsWith': [/\bString\.prototype\.endsWith\s*=/, /['"]core-js\/modules\/es\.string\.ends-with['"]/],
+    'String.prototype.includes': [/\bString\.prototype\.includes\s*=/, /['"]core-js\/modules\/es\.string\.includes['"]/],
+    'Symbol': [/\bSymbol\s*=/, /['"]core-js\/modules\/es\.symbol['"]/],
+    'Map': [/\bMap\s*=/, /['"]core-js\/modules\/es\.map['"]/],
+    'Set': [/\bSet\s*=/, /['"]core-js\/modules\/es\.set['"]/],
+    'WeakMap': [/\bWeakMap\s*=/, /['"]core-js\/modules\/es\.weak-map['"]/],
+    'WeakSet': [/\bWeakSet\s*=/, /['"]core-js\/modules\/es\.weak-set['"]/],
 
-  // String methods
-  'StringReplaceAll': [
-    /String\.prototype\.replaceAll/,
-    /from\s+['"]core-js\/modules\/es\.string\.replace-all['"]/
-  ],
-  'StringMatchAll': [
-    /String\.prototype\.matchAll/,
-    /from\s+['"]core-js\/modules\/es\.string\.match-all['"]/
-  ],
-  'StringAt': [
-    /String\.prototype\.at/,
-    /from\s+['"]core-js\/modules\/es\.string\.at['"]/
-  ],
+    // ES2016
+    'Array.prototype.includes': [/\bArray\.prototype\.includes\s*=/, /['"]core-js\/modules\/es\.array\.includes['"]/],
 
-  // Object methods
-  'ObjectHasOwn': [
-    /Object\.hasOwn/,
-    /from\s+['"]core-js\/modules\/es\.object\.has-own['"]/
-  ],
+    // ES2017
+    'Object.values': [/\bObject\.values\s*=/, /['"]core-js\/modules\/es\.object\.values['"]/],
+    'Object.entries': [/\bObject\.entries\s*=/, /['"]core-js\/modules\/es\.object\.entries['"]/],
+    'Object.getOwnPropertyDescriptors': [/\bObject\.getOwnPropertyDescriptors\s*=/, /['"]core-js\/modules\/es\.object\.get-own-property-descriptors['"]/],
+    'String.prototype.padStart': [/\bString\.prototype\.padStart\s*=/, /['"]core-js\/modules\/es\.string\.pad-start['"]/],
+    'String.prototype.padEnd': [/\bString\.prototype\.padEnd\s*=/, /['"]core-js\/modules\/es\.string\.pad-end['"]/],
 
-  // Promise methods
-  'PromiseAny': [
-    /Promise\.any/,
-    /from\s+['"]core-js\/modules\/es\.promise\.any['"]/
-  ],
+    // ES2018
+    'Promise.prototype.finally': [/\bPromise\.prototype\.finally\s*=/, /['"]core-js\/modules\/es\.promise\.finally['"]/],
 
-  // RegExp methods
-  'RegExpExec': [
-    /RegExp\.prototype\.exec/,
-    /from\s+['"]core-js\/modules\/es\.regexp\.exec['"]/
-  ],
+    // ES2019
+    'Array.prototype.flat': [/\bArray\.prototype\.flat\s*=/, /['"]core-js\/modules\/es\.array\.flat['"]/],
+    'Array.prototype.flatMap': [/\bArray\.prototype\.flatMap\s*=/, /['"]core-js\/modules\/es\.array\.flat-map['"]/],
+    'Object.fromEntries': [/\bObject\.fromEntries\s*=/, /['"]core-js\/modules\/es\.object\.from-entries['"]/],
+    'String.prototype.trimStart': [/\bString\.prototype\.trimStart\s*=/, /['"]core-js\/modules\/es\.string\.trim-start['"]/],
+    'String.prototype.trimEnd': [/\bString\.prototype\.trimEnd\s*=/, /['"]core-js\/modules\/es\.string\.trim-end['"]/],
 
-  // Global methods
-  'GlobalThis': [
-    /globalThis/,
-    /from\s+['"]core-js\/modules\/es\.global-this['"]/
-  ],
+    // ES2020
+    'Promise.allSettled': [/\bPromise\.allSettled\s*=/, /['"]core-js\/modules\/es\.promise\.all-settled['"]/],
+    'String.prototype.matchAll': [/\bString\.prototype\.matchAll\s*=/, /['"]core-js\/modules\/es\.string\.match-all['"]/],
+    'globalThis': [/globalThis\s*=/, /['"]core-js\/modules\/es\.global-this['"]/],
+    'BigInt': [/\bBigInt\s*=/, /['"]core-js\/modules\/es\.bigint['"]/],
+
+    // ES2021
+    'Promise.any': [/\bPromise\.any\s*=/, /['"]core-js\/modules\/es\.promise\.any['"]/],
+    'String.prototype.replaceAll': [/\bString\.prototype\.replaceAll\s*=/, /['"]core-js\/modules\/es\.string\.replace-all['"]/],
+
+    // ES2022
+    'Array.prototype.at': [/\bArray\.prototype\.at\s*=/, /['"]core-js\/modules\/es\.array\.at['"]/],
+    'String.prototype.at': [/\bString\.prototype\.at\s*=/, /['"]core-js\/modules\/es\.string\.at['"]/],
+
+    // ES2023
+    'Array.prototype.findLast': [/\bArray\.prototype\.findLast\s*=/, /['"]core-js\/modules\/es\.array\.find-last['"]/],
+    'Array.prototype.findLastIndex': [/\bArray\.prototype\.findLastIndex\s*=/, /['"]core-js\/modules\/es\.array\.find-last-index['"]/],
+    'Array.prototype.toReversed': [/\bArray\.prototype\.toReversed\s*=/, /['"]core-js\/modules\/es\.array\.to-reversed['"]/],
+    'Array.prototype.toSorted': [/\bArray\.prototype\.toSorted\s*=/, /['"]core-js\/modules\/es\.array\.to-sorted['"]/],
+    'Array.prototype.toSpliced': [/\bArray\.prototype\.toSpliced\s*=/, /['"]core-js\/modules\/es\.array\.to-spliced['"]/],
+    'Array.prototype.with': [/\bArray\.prototype\.with\s*=/, /['"]core-js\/modules\/es\.array\.with['"]/],
+
+    // ES2024
+    'Object.hasOwn': [/\bObject\.hasOwn\s*=/, /['"]core-js\/modules\/es\.object\.has-own['"]/],
+    'String.prototype.isWellFormed': [/\bString\.prototype\.isWellFormed\s*=/, /['"]core-js\/modules\/es\.string\.is-well-formed['"]/],
+    'String.prototype.toWellFormed': [/\bString\.prototype\.toWellFormed\s*=/, /['"]core-js\/modules\/es\.string\.to-well-formed['"]/],
+
+    // ES2025
+    'Array.prototype.group': [/\bArray\.prototype\.group\s*=/, /['"]core-js\/modules\/es\.array\.group['"]/],
+    'Array.prototype.groupToMap': [/\bArray\.prototype\.groupToMap\s*=/, /['"]core-js\/modules\/es\.array\.group-to-map['"]/],
+    'Promise.try': [/\bPromise\.try\s*=/, /['"]core-js\/modules\/es\.promise\.try['"]/],
 };
 
 module.exports = {
   ES_FEATURES,
   NODE_TYPES,
+  POLYFILL_PATTERNS,
+  IMPORT_PATTERNS,
   BROWSER_TO_ES_VERSION,
   FEATURE_TO_POLYFILL_MAP,
   JS_VERSIONS,

package/detectFeatures.js

@@ -1,6 +1,6 @@
 const acorn = require('acorn');
 const walk = require('acorn-walk');
-const { ES_FEATURES } = require('./constants');
+const { ES_FEATURES, POLYFILL_PATTERNS, IMPORT_PATTERNS } = require('./constants');
 const { checkMap } = require('./utils');
 
 /**
@@ -8,61 +8,33 @@ const { checkMap } = require('./utils');
  * @param {string} code - The source code to check
  * @param {Set} polyfills - Set to store detected polyfills
  */
-function detectPolyfills(code, polyfills) {
+const detectPolyfills = (
+  code,
+  polyfills,
+  {
+    polyfillPatterns = POLYFILL_PATTERNS,
+    importPatterns = IMPORT_PATTERNS
+  } = {}) => {
   if (code.includes('core-js') || code.includes('polyfill')) {
-    const polyfillPatterns = [
-      { pattern: /Array\.prototype\.toSorted/, feature: 'ArrayToSorted' },
-      { pattern: /Array\.prototype\.findLast/, feature: 'ArrayFindLast' },
-      { pattern: /Array\.prototype\.findLastIndex/, feature: 'ArrayFindLastIndex' },
-      { pattern: /Array\.prototype\.at/, feature: 'ArrayAt' },
-      { pattern: /String\.prototype\.replaceAll/, feature: 'StringReplaceAll' },
-      { pattern: /String\.prototype\.matchAll/, feature: 'StringMatchAll' },
-      { pattern: /String\.prototype\.at/, feature: 'StringAt' },
-      { pattern: /Object\.hasOwn/, feature: 'ObjectHasOwn' },
-      { pattern: /Promise\.any/, feature: 'PromiseAny' },
-      { pattern: /RegExp\.prototype\.exec/, feature: 'RegExpExec' },
-      { pattern: /globalThis/, feature: 'GlobalThis' },
-    ];
-
     for (const { pattern, feature } of polyfillPatterns) {
-      if (pattern.test(code)) {
-        polyfills.add(feature);
-      }
+      if (pattern.test(code)) polyfills.add(feature);
     }
 
     if (code.includes('import') && code.includes('core-js')) {
-      const importPatterns = [
-        { pattern: /from\s+['"]core-js\/modules\/es\.array\.to-sorted['"]/, feature: 'ArrayToSorted' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.array\.find-last['"]/, feature: 'ArrayFindLast' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.array\.find-last-index['"]/, feature: 'ArrayFindLastIndex' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.array\.at['"]/, feature: 'ArrayAt' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.string\.replace-all['"]/, feature: 'StringReplaceAll' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.string\.match-all['"]/, feature: 'StringMatchAll' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.string\.at['"]/, feature: 'StringAt' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.object\.has-own['"]/, feature: 'ObjectHasOwn' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.promise\.any['"]/, feature: 'PromiseAny' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.regexp\.exec['"]/, feature: 'RegExpExec' },
-        { pattern: /from\s+['"]core-js\/modules\/es\.global-this['"]/, feature: 'GlobalThis' },
-      ];
-
       for (const { pattern, feature } of importPatterns) {
-        if (pattern.test(code)) {
-          polyfills.add(feature);
-        }
+        if (pattern.test(code)) polyfills.add(feature);
       }
     }
   }
 }
 
 const detectFeatures = (code, ecmaVersion, sourceType, ignoreList = new Set(), options = {}) => {
-  const { checkForPolyfills } = options;
+  const { checkForPolyfills, ast: providedAst } = options;
 
   const polyfills = new Set();
-  if (checkForPolyfills) {
-    detectPolyfills(code, polyfills);
-  }
+  if (checkForPolyfills) detectPolyfills(code, polyfills);
 
-  const ast = acorn.parse(code, {
+  const ast = providedAst || acorn.parse(code, {
     ecmaVersion: 'latest',
     sourceType,
   });

package/index.js

@@ -11,7 +11,7 @@ let polyfillDetector = null;
 const pkg = require('./package.json')
 const { lilconfig } = require('lilconfig');
 const { JS_VERSIONS } = require('./constants');
-const { parseIgnoreList, createLogger, generateBashCompletion, generateZshCompletion } = require('./utils');
+const { parseIgnoreList, createLogger, generateBashCompletion, generateZshCompletion, processBatchedFiles, readFileAsync, parseCode } = require('./utils');
 
 program.configureOutput({
   writeOut: (str) => process.stdout.write(str),
@@ -70,7 +70,7 @@ program
   .version(pkg.version)
   .argument(
     '[ecmaVersion]',
-    'ecmaVersion to check files against. Can be: es3, es4, es5, es6/es2015, es7/es2016, es8/es2017, es9/es2018, es10/es2019, es11/es2020, es12/es2021, es13/es2022, es14/es2023, checkBrowser',
+    'ecmaVersion to check files against. Can be: es3, es4, es5, es6/es2015, es7/es2016, es8/es2017, es9/es2018, es10/es2019, es11/es2020, es12/es2021, es13/es2022, es14/es2023, es15/es2024, es16/es2025, checkBrowser',
   )
   .argument('[files...]', 'a glob of files to to test the EcmaScript version against')
   .option('--module', 'use ES modules')
@@ -98,6 +98,7 @@ program
   .option('--browserslistPath <path>', 'path to custom browserslist configuration')
   .option('--browserslistEnv <env>', 'browserslist environment to use')
   .option('--config <path>', 'path to custom .escheckrc config file')
+  .option('--batchSize <number>', 'number of files to process concurrently (0 for unlimited)', '0')
 
 async function loadConfig(customConfigPath) {
   const logger = createLogger();
@@ -178,6 +179,7 @@ program
         browserslistQuery: options.browserslistQuery !== undefined ? options.browserslistQuery : baseConfig.browserslistQuery,
         browserslistPath: options.browserslistPath !== undefined ? options.browserslistPath : baseConfig.browserslistPath,
         browserslistEnv: options.browserslistEnv !== undefined ? options.browserslistEnv : baseConfig.browserslistEnv,
+        batchSize: options.batchSize !== undefined ? options.batchSize : baseConfig.batchSize,
       };
 
       if (ecmaVersionArg !== undefined) {
@@ -332,6 +334,14 @@ async function runChecks(configs, logger) {
       case 'es2023':
         ecmaVersion = '14'
         break
+      case 'es15':
+      case 'es2024':
+        ecmaVersion = '15'
+        break
+      case 'es16':
+      case 'es2025':
+        ecmaVersion = '16'
+        break
       default:
         logger.error('Invalid ecmaScript version, please pass a valid version, use --help for help')
         process.exit(1)
@@ -359,20 +369,22 @@ async function runChecks(configs, logger) {
       }
     }
 
-    const expandedPathsToIgnore = pathsToIgnore.reduce((result, path) =>
-      path.includes('*') ? result.concat(glob.sync(path, globOpts)) : result.concat(path)
-    , [])
-
-    const filterForIgnore = (globbedFiles) => {
-      if (expandedPathsToIgnore && expandedPathsToIgnore.length > 0) {
-        return globbedFiles.filter(
-          (filePath) => !expandedPathsToIgnore.some((ignoreValue) => filePath.includes(ignoreValue))
-        );
-      }
-      return globbedFiles;
+    let expandedPathsToIgnore = [];
+    if (pathsToIgnore.length > 0) {
+      expandedPathsToIgnore = pathsToIgnore.reduce((result, path) => {
+        if (path.includes('*')) {
+          return result.concat(glob.sync(path, globOpts));
+        }
+        return result.concat(path);
+      }, []);
     }
 
-    const filteredFiles = filterForIgnore(allMatchedFiles)
+    let filteredFiles = allMatchedFiles;
+    if (expandedPathsToIgnore.length > 0) {
+      filteredFiles = allMatchedFiles.filter((filePath) => {
+        return !expandedPathsToIgnore.some((ignoreValue) => filePath.includes(ignoreValue));
+      });
+    }
 
     const ignoreList = parseIgnoreList(config);
 
@@ -380,27 +392,27 @@ async function runChecks(configs, logger) {
       logger.debug('ES-Check: ignoring features:', Array.from(ignoreList).join(', '));
     }
 
-    filteredFiles.forEach((file) => {
-      const code = fs.readFileSync(file, 'utf8')
+    const batchSize = parseInt(config.batchSize || '0', 10);
+    
+    const processFile = async (file) => {
+      const { content: code, error: readError } = await readFileAsync(file, fs);
+      if (readError) {
+        return readError;
+      }
+
       if (logger.isLevelEnabled('debug')) {
         logger.debug(`ES-Check: checking ${file}`)
       }
-      try {
-        acorn.parse(code, acornOpts)
-      } catch (err) {
+
+      const { ast, error: parseError } = parseCode(code, acornOpts, acorn, file);
+      if (parseError) {
         if (logger.isLevelEnabled('debug')) {
-          logger.debug(`ES-Check: failed to parse file: ${file} \n - error: ${err}`)
+          logger.debug(`ES-Check: failed to parse file: ${file} \n - error: ${parseError.err}`)
         }
-        const errorObj = {
-          err,
-          stack: err.stack,
-          file,
-        }
-        errArray.push(errorObj);
-        return;
+        return parseError;
       }
 
-      if (!checkFeatures) return;
+      if (!checkFeatures) return null;
       const parseSourceType = acornOpts.sourceType || 'script';
       const esVersion = parseInt(ecmaVersion, 10);
 
@@ -408,7 +420,8 @@ async function runChecks(configs, logger) {
         code,
         esVersion,
         parseSourceType,
-        ignoreList
+        ignoreList,
+        { ast, checkForPolyfills }
       );
 
       if (logger.isLevelEnabled('debug')) {
@@ -434,13 +447,18 @@ async function runChecks(configs, logger) {
       const isSupported = filteredUnsupportedFeatures.length === 0;
       if (!isSupported) {
         const error = new Error(`Unsupported features used: ${filteredUnsupportedFeatures.join(', ')} but your target is ES${ecmaVersion}.`);
-        errArray.push({
+        return {
           err: error,
           file,
           stack: error.stack
-        });
+        };
       }
-    })
+      return null;
+    };
+
+    const results = await processBatchedFiles(filteredFiles, processFile, batchSize);
+    const errors = results.filter(result => result !== null);
+    errArray.push(...errors);
 
     if (errArray.length > 0) {
       logger.error(`ES-Check: there were ${errArray.length} ES version matching errors.`)
@@ -467,4 +485,11 @@ async function runChecks(configs, logger) {
   }
 }
 
-program.parse()
+if (require.main === module) {
+  program.parse()
+}
+
+module.exports = {
+  runChecks,
+  loadConfig
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.1.4",
+  "version": "9.2.0",
   "description": "Checks the ECMAScript version of .js glob against a specified version of ECMAScript with a shell command",
   "main": "index.js",
   "license": "MIT",
@@ -18,6 +18,7 @@
   "scripts": {
     "commit": "git-cz",
     "commit-msg": "commitlint --edit $1",
+    "dev": "pnpm site:dev",
     "lint": "eslint index.js --fix",
     "lint:ci": "eslint index.js utils.js detectFeatures.js constants.js browserslist.js polyfillDetector.js",
     "pre-commit": "pnpm lint && pnpm test",
@@ -28,7 +29,11 @@
     "setup": "pnpm install --reporter=silent",
     "test": "nyc mocha test.js utils.test.js browserslist.test.js polyfillDetector.test.js detectFeatures.test.js --timeout 10s",
     "update": "codependence --update",
-    "benchmark": "./benchmarks/run-benchmarks.sh"
+    "benchmark": "./benchmarks/run-benchmarks.sh",
+    "site:dev": "pnpm --filter es-check-docs run dev",
+    "site:build": "pnpm --filter es-check-docs run build",
+    "site:preview": "pnpm --filter es-check-docs run preview",
+    "site:install": "pnpm --filter es-check-docs install"
   },
   "repository": {
     "type": "git",
@@ -52,19 +57,19 @@
     "codependence": "^0.3.1",
     "commitizen": "4.3.1",
     "conventional-changelog-cli": "^5.0.0",
-    "eslint": "9.28.0",
-    "eslint-config-prettier": "10.1.5",
+    "eslint": "9.32.0",
+    "eslint-config-prettier": "10.1.8",
     "eslint-plugin-es5": "^1.5.0",
     "husky": "9.1.7",
     "is-ci": "^3.0.1",
-    "mocha": "11.5.0",
+    "mocha": "11.7.1",
     "nyc": "^17.1.0",
     "path-exists-cli": "^2.0.0",
-    "prettier": "3.5.3",
-    "release-it": "19.0.3"
+    "prettier": "3.6.2",
+    "release-it": "19.0.4"
   },
   "dependencies": {
-    "acorn": "8.14.1",
+    "acorn": "8.15.0",
     "acorn-walk": "^8.3.4",
     "browserslist": "^4.23.3",
     "commander": "14.0.0",

package/polyfillDetector.js

@@ -1,77 +1,47 @@
 const { FEATURE_TO_POLYFILL_MAP } = require('./constants');
 
 /**
- * Detects polyfills in the code and returns a set of polyfilled feature names
- * @param {string} code - The source code to check
- * @param {Object} logger - Winston logger instance for debug output
- * @returns {Set<string>} - Set of polyfilled feature names
+ * Detects polyfills in the code and returns a set of polyfilled feature names.
+ *
+ * @param {string} code - The source code to check.
+ * @param {object} logger - A required logger instance.
+ * @param {object} [featureMap=FEATURE_TO_POLYFILL_MAP] - The map of features.
+ * @returns {Set<string>} - A set of polyfilled feature names.
  */
-function detectPolyfills(code, logger) {
-  const polyfills = new Set();
-
-  if (!code) {
-    return polyfills;
-  }
-
-  if (code.includes('import') && code.includes('core-js')) {
-    if (code.includes('core-js/modules/es.array.to-sorted')) {
-      polyfills.add('ArrayToSorted');
-    }
-    if (code.includes('core-js/modules/es.object.has-own')) {
-      polyfills.add('ObjectHasOwn');
-    }
-    if (code.includes('core-js/modules/es.string.replace-all')) {
-      polyfills.add('StringReplaceAll');
+function detectPolyfills(code, logger, featureMap = FEATURE_TO_POLYFILL_MAP) {
+    const polyfills = new Set();
+    if (!code || !featureMap) return polyfills;
+
+    // Since logger is required, we can use it without checking for its existence.
+    // The optional chaining (?.) is still good practice for properties like isLevelEnabled.
+    if (logger?.isLevelEnabled?.('debug')) {
+        // We can log at the beginning if needed, or at the end.
     }
 
-    if (polyfills.size > 0) {
-      return polyfills;
-    }
+    const polyfillFeatures = Object.entries(featureMap);
+    polyfillFeatures.forEach(([feature, patterns]) => {
+      const isPolyfilled = patterns.some(pattern => pattern.test(code));
+      if (isPolyfilled) polyfills.add(feature);
+    });
 
-    for (const [featureName, patterns] of Object.entries(FEATURE_TO_POLYFILL_MAP)) {
-      for (const pattern of patterns) {
-        if (pattern.test(code)) {
-          polyfills.add(featureName);
-          break;
-        }
-      }
+    if (logger?.isLevelEnabled?.('debug')) {
+      const hasPolyfills = polyfills.size > 0;
+      if (hasPolyfills) logger.debug(`ES-Check: Detected polyfills: ${Array.from(polyfills).join(', ')}`);
+      else logger.debug('ES-Check: No polyfills detected.');
     }
-  }
 
-  if (polyfills.size === 0 && (code.includes('polyfill') || code.includes('Array.prototype') || code.includes('Object.') || code.includes('String.prototype'))) {
-  } else if (polyfills.size > 0) {
     return polyfills;
-  } else if (!code.includes('core-js') && !code.includes('polyfill') && !code.includes('Array.prototype')) {
-    return polyfills;
-  }
-
-  for (const [featureName, patterns] of Object.entries(FEATURE_TO_POLYFILL_MAP)) {
-    for (const pattern of patterns) {
-      if (pattern.test(code)) {
-        polyfills.add(featureName);
-        break;
-      }
-    }
-  }
-
-  if (logger?.isLevelEnabled?.('debug') && polyfills.size > 0) {
-    logger.debug(`ES-Check: Detected polyfills: ${Array.from(polyfills).join(', ')}`);
-  }
-
-  return polyfills;
 }
 
 /**
- * Filters unsupported features by removing those that have been polyfilled
+ * Filters unsupported features by removing those that have been polyfilled.
  * @param {Array<string>} unsupportedFeatures - List of unsupported features
  * @param {Set<string>} polyfills - Set of polyfilled feature names
  * @returns {Array<string>} - Filtered list of unsupported features
  */
-function filterPolyfilled(unsupportedFeatures, polyfills) {
-  if (!polyfills || polyfills.size === 0) {
-    return unsupportedFeatures;
-  }
-
+const filterPolyfilled = (unsupportedFeatures, polyfills) => {
+  const hasPolyfills = polyfills && polyfills.size > 0;
+  if (!hasPolyfills) return unsupportedFeatures;
   return unsupportedFeatures.filter(feature => !polyfills.has(feature));
 }
 

package/utils.js

@@ -113,6 +113,12 @@ const checkMap = {
           node.callee.property.type === 'Identifier' &&
           node.callee.property.name === astInfo.property
         );
+      } else if (astInfo.property) {
+        // Check for method calls with any object when only property is specified
+        return (
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === astInfo.property
+        );
       }
 
       return false;
@@ -180,7 +186,7 @@ function createLogger(options = {}) {
         level,
         stderrLevels: ['error', 'warn'],
         format: winston.format.combine(
-          ...(supportsColor.stdout || !noColor ? [winston.format.colorize()] : []),
+          ...(supportsColor.stdout && !noColor ? [winston.format.colorize()] : []),
           winston.format.simple(),
         ),
       })
@@ -217,7 +223,7 @@ _${cmdName.replace(/-/g, '_')}_completion() {
   opts="${optsStr}"
 
   # ES versions
-  es_versions="es3 es5 es6 es2015 es7 es2016 es8 es2017 es9 es2018 es10 es2019 es11 es2020 es12 es2021 es13 es2022 es14 es2023"
+  es_versions="es3 es5 es6 es2015 es7 es2016 es8 es2017 es9 es2018 es10 es2019 es11 es2020 es12 es2021 es13 es2022 es14 es2023 es15 es2024 es16 es2025"
 
   # Handle special cases based on previous argument
   case "\$prev" in
@@ -288,6 +294,10 @@ _${cmdName.replace(/-/g, '_')}() {
     "es2022:ECMAScript 2022"
     "es14:ECMAScript 2023"
     "es2023:ECMAScript 2023"
+    "es15:ECMAScript 2024"
+    "es2024:ECMAScript 2024"
+    "es16:ECMAScript 2025"
+    "es2025:ECMAScript 2025"
   )
 
   # Commands
@@ -328,6 +338,75 @@ _${cmdName.replace(/-/g, '_')}
 `;
 }
 
+/**
+ * Process files in batches for better performance
+ * @param {string[]} files - Array of file paths to process
+ * @param {Function} processor - Async function to process each file
+ * @param {number} batchSize - Number of files to process concurrently (0 for unlimited)
+ * @returns {Promise<Array>} Array of results from processing all files
+ */
+async function processBatchedFiles(files, processor, batchSize = 0) {
+  if (batchSize <= 0) {
+    return Promise.all(files.map(processor));
+  }
+  
+  const results = [];
+  
+  for (let i = 0; i < files.length; i += batchSize) {
+    const batch = files.slice(i, i + batchSize);
+    const batchResults = await Promise.all(batch.map(processor));
+    results.push(...batchResults);
+  }
+  
+  return results;
+}
+
+/**
+ * Read file asynchronously with error handling
+ * @param {string} file - File path to read
+ * @param {Object} fs - File system module
+ * @returns {Promise<{content: string, error: null} | {content: null, error: Object}>}
+ */
+async function readFileAsync(file, fs) {
+  try {
+    const content = await fs.promises.readFile(file, 'utf8');
+    return { content, error: null };
+  } catch (err) {
+    return { 
+      content: null, 
+      error: {
+        err,
+        file,
+        stack: err.stack
+      }
+    };
+  }
+}
+
+/**
+ * Parse code with acorn and handle errors
+ * @param {string} code - Code to parse
+ * @param {Object} acornOpts - Acorn parsing options
+ * @param {Object} acorn - Acorn module
+ * @param {string} file - File path for error reporting
+ * @returns {{ast: Object, error: null} | {ast: null, error: Object}}
+ */
+function parseCode(code, acornOpts, acorn, file) {
+  try {
+    const ast = acorn.parse(code, acornOpts);
+    return { ast, error: null };
+  } catch (err) {
+    return {
+      ast: null,
+      error: {
+        err,
+        stack: err.stack,
+        file
+      }
+    };
+  }
+}
+
 module.exports = {
   parseIgnoreList,
   checkVarKindMatch,
@@ -337,5 +416,8 @@ module.exports = {
   checkMap,
   createLogger,
   generateBashCompletion,
-  generateZshCompletion
+  generateZshCompletion,
+  processBatchedFiles,
+  readFileAsync,
+  parseCode
 };