es-check 9.1.3 → 9.1.5-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,10 +91,12 @@ 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.
@@ -248,6 +259,18 @@ es-check --checkBrowser --browserslistQuery="last 2 versions" ./dist/**/*.js
 es-check --checkBrowser --browserslistQuery=">0.5%, not dead" --checkFeatures ./dist/**/*.js
 ```
 
+**Using browserlist just like an es version**
+
+```sh
+es-check checkBrowser ./dist/**/*.js --browserslistQuery=">0.5%, not dead"
+```
+
+**Using browserlist with a pre-defined browserlist**
+
+```sh
+es-check checkBrowser ./dist/**/*.js
+```
+
 ---
 
 ## Usage
@@ -442,6 +465,9 @@ es-check --checkBrowser --browserslistQuery="last 2 versions" ./dist/**/*.js
 
 # Using 'checkBrowser' as the ES version argument
 es-check checkBrowser --browserslistQuery="last 2 versions" ./dist/**/*.js
+
+# Using a pre-defined browserslist configuration
+es-check checkBrowser ./dist/**/*.js
 ```
 
 This will read your browserslist configuration (from `.browserslistrc`, `package.json`, etc.) and determine the appropriate ES version based on your targeted browsers.
@@ -466,7 +492,7 @@ es-check --checkBrowser --browserslistEnv="production" ./dist/**/*.js
 es-check --checkBrowser --checkFeatures ./dist/**/*.js
 ```
 
-⚠️ **NOTE:** When using `--checkBrowser`, you must also provide a `--browserslistQuery` or have a valid browserslist configuration in your project.
+⚠️ **NOTE:** When using `--checkBrowser`, you must also provide a `--browserslistQuery` or have a valid browserslist configuration in your project. You cannot have a files directly after your `--checkBrowser` option; it will read as 
 
 ---
 

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
@@ -574,71 +707,93 @@ const BROWSER_TO_ES_VERSION = {
   }
 };
 
+const JS_VERSIONS = [
+  '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'
+];
+
 /**
- * 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
+  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,47 +8,21 @@ 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);
       }
     }
   }
@@ -58,9 +32,7 @@ const detectFeatures = (code, ecmaVersion, sourceType, ignoreList = new Set(), o
   const { checkForPolyfills } = options;
 
   const polyfills = new Set();
-  if (checkForPolyfills) {
-    detectPolyfills(code, polyfills);
-  }
+  if (checkForPolyfills) detectPolyfills(code, polyfills);
 
   const ast = acorn.parse(code, {
     ecmaVersion: 'latest',

package/index.js

@@ -10,6 +10,7 @@ const detectFeatures = require('./detectFeatures')
 let polyfillDetector = null;
 const pkg = require('./package.json')
 const { lilconfig } = require('lilconfig');
+const { JS_VERSIONS } = require('./constants');
 const { parseIgnoreList, createLogger, generateBashCompletion, generateZshCompletion } = require('./utils');
 
 program.configureOutput({
@@ -69,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')
@@ -92,7 +93,7 @@ program
   .addOption(new Option('--ignore-file <path>', 'path to JSON file containing features to ignore').hideHelp())
   .option('--ignoreFile <path>', 'path to JSON file containing features to ignore')
   .option('--allowList <features>', 'comma-separated list of features to allow even in lower ES versions, e.g., "const,let"')
-  .addOption(new Option('--checkBrowser', 'use browserslist configuration to determine ES version, use checkBrowser argument instead of ecmaVersion').hideHelp())
+  .addOption(new Option('--checkBrowser', 'use browserslist configuration to determine ES version, use checkBrowser argument instead of ecmaVersion', false).hideHelp())
   .option('--browserslistQuery <query>', 'browserslist query')
   .option('--browserslistPath <path>', 'path to custom browserslist configuration')
   .option('--browserslistEnv <env>', 'browserslist environment to use')
@@ -145,6 +146,13 @@ program
       process.exit(1)
     }
 
+    const validEcmaVersionValues = new Set(JS_VERSIONS);
+
+    if (options.checkBrowser && ecmaVersionArg && !validEcmaVersionValues.has(ecmaVersionArg)) {
+      filesArg.unshift(ecmaVersionArg);
+      ecmaVersionArg = 'checkBrowser';
+    }
+
     const configs = await loadConfig(options.config);
     const baseConfig = configs[0] || {};
 
@@ -257,7 +265,7 @@ async function runChecks(configs, logger) {
 
     let ecmaVersion
 
-    const isBrowserslistCheck = Boolean(expectedEcmaVersion === 'checkBrowser' || checkBrowser);
+    const isBrowserslistCheck = Boolean(expectedEcmaVersion === 'checkBrowser' || checkBrowser !== undefined);
     if (isBrowserslistCheck) {
       const browserslistQuery = config.browserslistQuery;
       try {
@@ -324,6 +332,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.1.3",
+  "version": "9.1.5-0",
   "description": "Checks the ECMAScript version of .js glob against a specified version of ECMAScript with a shell command",
   "main": "index.js",
   "license": "MIT",
@@ -52,19 +52,19 @@
     "codependence": "^0.3.1",
     "commitizen": "4.3.1",
     "conventional-changelog-cli": "^5.0.0",
-    "eslint": "9.28.0",
+    "eslint": "9.30.0",
     "eslint-config-prettier": "10.1.5",
     "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",
+    "prettier": "3.6.2",
     "release-it": "19.0.3"
   },
   "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