es-check 9.6.4 → 9.7.2

package/README.md

@@ -118,7 +118,7 @@ Usage: index [options] [ecmaVersion] [files...]
 
 Arguments:
   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, es15/es2024, es16/es2025
+                                      es13/es2022, es14/es2023, es15/es2024, es16/es2025, es17/es2026
   files                               a glob of files to to test the EcmaScript version against
 
 ```
@@ -177,6 +177,8 @@ es-check es5 './src/**/*.{js,ts}' --typescript
 
 This is experimental functionality that strips TypeScript type annotations and tests the resulting JavaScript against the specified ES version.
 
+Runtime support for TypeScript checks is limited to Node.js v22.13.0+ through `module.stripTypeScriptTypes` and Bun v1.0.0+ through `Bun.Transpiler`. JavaScript checks still work on older supported Node.js versions.
+
 **Skipping specific files or directories:**
 
 ```sh
@@ -718,6 +720,7 @@ To update ES version support:
 To update ES feature detection:
 
 - Add features to [version-specific files](./lib/constants/es-features/) (e.g., `6.js` for ES6 features)
+- Update [ES globals](./lib/constants/es-features/globals.js) from [sindresorhus/globals](https://github.com/sindresorhus/globals/blob/main/globals.json) when global availability changes
 - Update [polyfill patterns](./lib/constants/es-features/polyfills.js) if needed
 - Feature detection uses AST traversal via [Acorn](https://github.com/acornjs/acorn/)
 

package/lib/browserslist.js

@@ -15,22 +15,26 @@ function getESVersionForBrowser(browser, version) {
   const targetVersion = parseFloat(version);
   let matchedVersion = null;
 
-  for (const v of browserVersions) {
+  let versionIndex = 0;
+  while (versionIndex < browserVersions.length) {
+    const v = browserVersions[versionIndex];
     if (v <= targetVersion) {
       matchedVersion = v.toString();
     } else {
       break;
     }
+    versionIndex += 1;
   }
 
-  if (
-    matchedVersion === null &&
-    (browser === "chrome" || browser === "firefox")
-  ) {
+  const hasNoMatchedVersion = matchedVersion === null;
+  const isModernDefaultBrowser = browser === "chrome" || browser === "firefox";
+  const shouldUseModernDefault = hasNoMatchedVersion && isModernDefaultBrowser;
+
+  if (shouldUseModernDefault) {
     return 6;
   }
 
-  if (matchedVersion === null) {
+  if (hasNoMatchedVersion) {
     return defaultVersion;
   }
 
@@ -46,24 +50,30 @@ function getESVersionFromBrowserslist(options = {}) {
       env: browserslistEnv,
     });
 
-    if (!browsers || browsers.length === 0) {
+    const hasNoBrowsers = !browsers || browsers.length === 0;
+    if (hasNoBrowsers) {
       return 5;
     }
 
     const hasIE = browsers.some((browser) => browser.includes("ie "));
     const hasOldEdge = browsers.some((browser) => {
       const [name, version] = browser.split(" ");
-      return name === "edge" && parseInt(version, 10) < 79;
+      const isEdge = name === "edge";
+      const edgeVersion = parseInt(version, 10);
+      const isOldEdge = edgeVersion < 79;
+      return isEdge && isOldEdge;
     });
 
-    if (hasIE || hasOldEdge) {
+    const hasLegacyBrowser = hasIE || hasOldEdge;
+    if (hasLegacyBrowser) {
       return 5;
     }
 
-    if (
-      (browserslistPath && browserslistPath.includes("legacy")) ||
-      (browserslistEnv && browserslistEnv.includes("legacy"))
-    ) {
+    const hasLegacyPath = browserslistPath && browserslistPath.includes("legacy");
+    const hasLegacyEnv = browserslistEnv && browserslistEnv.includes("legacy");
+    const hasLegacyConfig = hasLegacyPath || hasLegacyEnv;
+
+    if (hasLegacyConfig) {
       return 5;
     }
 

package/lib/cache.js

@@ -36,8 +36,9 @@ class SimpleCache {
   set(key, value) {
     const isFull = this.cache.size >= this.maxSize;
     const hasKey = this.cache.has(key);
+    const shouldEvict = isFull && !hasKey;
 
-    if (isFull && !hasKey) {
+    if (shouldEvict) {
       const firstKey = this.cache.keys().next().value;
       this.cache.delete(firstKey);
     }

package/lib/check-runner/index.js

@@ -2,9 +2,7 @@ const fs = require("fs");
 const { parseIgnoreList, processBatchedFiles } = require("../helpers");
 const { determineInvocationType } = require("../cli/utils");
 const { LATEST_PARSER_VERSION } = require("../constants/versions");
-const {
-  getMinimumParserVersion,
-} = require("../constants/featureParserMapping");
+const { getMinimumParserVersion } = require("../constants/featureParserMapping");
 const {
   parseFilePatterns,
   validateConfig,
@@ -33,13 +31,10 @@ function processConfig(config, context) {
 
   const ignoreFilePath = config.ignoreFile || config["ignore-file"];
   const ignoreFileExists = ignoreFilePath && fs.existsSync(ignoreFilePath);
-  const shouldWarnAboutIgnoreFile =
-    ignoreFilePath && !ignoreFileExists && isWarn;
+  const shouldWarnAboutIgnoreFile = ignoreFilePath && !ignoreFileExists && isWarn;
 
   if (shouldWarnAboutIgnoreFile) {
-    logger.warn(
-      `Warning: Ignore file '${ignoreFilePath}' does not exist or is not accessible`,
-    );
+    logger.warn(`Warning: Ignore file '${ignoreFilePath}' does not exist or is not accessible`);
   }
 
   const validationResult = validateConfig(config, {
@@ -88,14 +83,9 @@ function processConfig(config, context) {
   const targetEsVersion = parseInt(ecmaVersion, 10);
 
   const enableFeatureDetection = config.checkBrowser || config.checkFeatures;
-  const minRequiredParser = getMinimumParserVersion(
-    targetEsVersion,
-    enableFeatureDetection,
-  );
-
-  const parserEcmaVersion = useLatestForParsing
-    ? LATEST_PARSER_VERSION
-    : minRequiredParser;
+  const minRequiredParser = getMinimumParserVersion(targetEsVersion, enableFeatureDetection);
+
+  const parserEcmaVersion = useLatestForParsing ? LATEST_PARSER_VERSION : minRequiredParser;
   const acornOpts = { ecmaVersion: parserEcmaVersion, silent: true };
 
   if (isDebug) {
@@ -115,30 +105,22 @@ function processConfig(config, context) {
   }
 
   const pathsToIgnore = [].concat(config.not || []);
-  const filteredFiles = filterIgnoredFiles(
-    findFilesResult.files,
-    pathsToIgnore,
-    globOpts,
-  );
+  const filteredFiles = filterIgnoredFiles(findFilesResult.files, pathsToIgnore, globOpts);
 
   const ignoreList = parseIgnoreList(config);
   const hasIgnores = ignoreList.size > 0;
   const shouldDebugIgnores = hasIgnores && isDebug;
 
   if (shouldDebugIgnores) {
-    logger.debug(
-      "ES-Check: ignoring features:",
-      Array.from(ignoreList).join(", "),
-    );
+    logger.debug("ES-Check: ignoring features:", Array.from(ignoreList).join(", "));
   }
 
   const fileCount = filteredFiles.length;
   const hasLogger = logger !== null && logger !== undefined;
+  const shouldLogFileCount = hasLogger && fileCount > 0;
 
-  if (hasLogger && fileCount > 0) {
-    logger.info(
-      `ES-Check: checking ${fileCount} file${fileCount === 1 ? "" : "s"}...`,
-    );
+  if (shouldLogFileCount) {
+    logger.info(`ES-Check: checking ${fileCount} file${fileCount === 1 ? "" : "s"}...`);
   }
 
   const batchSize = parseInt(config.batchSize || "0", 10);
@@ -166,10 +148,10 @@ function runChecks(configs, loggerOrOptions) {
   const allErrors = [];
   const context = { logger, isDebug, isWarn, isNodeAPI, allErrors };
 
-  const results = [];
+  let results = [];
   for (const config of configs) {
     const result = processConfig(config, context);
-    results.push(result);
+    results = results.concat(result);
 
     const shouldBreak = result.hasErrors && !result.shouldContinue;
     if (shouldBreak) break;

package/lib/check-runner/utils.js

@@ -9,13 +9,22 @@ const {
   readFile,
   parseCode,
 } = require("../helpers");
-const {
-  ECMA_VERSION_MAP,
-  ECMA_VERSION_TO_NUMBER,
-} = require("../constants/versions");
+const { ECMA_VERSION_MAP, ECMA_VERSION_TO_NUMBER } = require("../constants/versions");
 
 let polyfillDetector = null;
 
+function appendError(allErrors, error) {
+  allErrors[allErrors.length] = error;
+}
+
+function appendErrors(allErrors, errors) {
+  let index = 0;
+  while (index < errors.length) {
+    appendError(allErrors, errors[index]);
+    index += 1;
+  }
+}
+
 function parseFilePatterns(configFilesValue) {
   const hasNoValue = !configFilesValue;
   if (hasNoValue) return [];
@@ -50,17 +59,13 @@ function validateConfig(config, options) {
   const isExiting = !isNodeAPI;
 
   if (hasLogger) {
-    logger.error(
-      "No ecmaScript version or checkBrowser option specified in configuration",
-    );
+    logger.error("No ecmaScript version or checkBrowser option specified in configuration");
   }
 
   if (isExiting) process.exit(1);
 
-  allErrors.push({
-    err: new Error(
-      "No ecmaScript version or checkBrowser option specified in configuration",
-    ),
+  appendError(allErrors, {
+    err: new Error("No ecmaScript version or checkBrowser option specified in configuration"),
     file: "config",
   });
 
@@ -73,14 +78,12 @@ function handleMissingFiles(pattern, options) {
   const isExiting = !isNodeAPI;
 
   if (hasLogger) {
-    logger.error(
-      `ES-Check: Did not find any files to check for pattern: ${pattern}.`,
-    );
+    logger.error(`ES-Check: Did not find any files to check for pattern: ${pattern}.`);
   }
 
   if (isExiting) process.exit(1);
 
-  allErrors.push({
+  appendError(allErrors, {
     err: new Error(`Did not find any files to check for pattern: ${pattern}`),
     file: "glob",
   });
@@ -93,15 +96,17 @@ function findFiles(patterns, options) {
   const shouldEnforceFilePatterns = !hasFilePatterns && !looseGlobMatching;
   const hasLogger = logger !== null && logger !== undefined;
   const isExiting = !isNodeAPI;
+  const shouldLogMissingPatterns = shouldEnforceFilePatterns && hasLogger;
+  const shouldExitMissingPatterns = shouldEnforceFilePatterns && isExiting;
 
-  if (shouldEnforceFilePatterns && hasLogger) {
+  if (shouldLogMissingPatterns) {
     logger.error("ES-Check: No file patterns specified to check.");
   }
 
-  if (shouldEnforceFilePatterns && isExiting) process.exit(1);
+  if (shouldExitMissingPatterns) process.exit(1);
 
   if (shouldEnforceFilePatterns) {
-    allErrors.push({
+    appendError(allErrors, {
       err: new Error("No file patterns specified to check"),
       file: "config",
     });
@@ -109,7 +114,7 @@ function findFiles(patterns, options) {
   }
 
   let hasPatternWithNoFiles = false;
-  const allMatchedFiles = patterns.flatMap((pattern) => {
+  const matchPattern = (pattern) => {
     const globbedFiles = glob.sync(pattern, globOpts);
     const noFilesFound = globbedFiles.length === 0;
     const shouldErrorOnNoFiles = noFilesFound && !looseGlobMatching;
@@ -120,35 +125,34 @@ function findFiles(patterns, options) {
     }
 
     return globbedFiles;
-  });
+  };
+  const allMatchedFiles = patterns.map(matchPattern).flat();
 
   const noMatchedFiles = allMatchedFiles.length === 0;
-  const shouldErrorOnNoMatchedFiles =
-    noMatchedFiles && hasFilePatterns && !looseGlobMatching;
+  const shouldErrorOnNoMatchedFiles = noMatchedFiles && hasFilePatterns && !looseGlobMatching;
   const shouldWarnOnNoMatchedFiles = noMatchedFiles && looseGlobMatching;
+  const shouldLogNoMatchedFiles = shouldErrorOnNoMatchedFiles && hasLogger;
+  const shouldExitNoMatchedFiles = shouldErrorOnNoMatchedFiles && isExiting;
+  const shouldLogNoMatchedFilesWarning = shouldWarnOnNoMatchedFiles && hasLogger;
 
-  if (shouldErrorOnNoMatchedFiles && hasLogger) {
+  if (shouldLogNoMatchedFiles) {
     logger.error(
       `ES-Check: Did not find any files to check across all patterns: ${patterns.join(", ")}.`,
     );
   }
 
-  if (shouldErrorOnNoMatchedFiles && isExiting) process.exit(1);
+  if (shouldExitNoMatchedFiles) process.exit(1);
 
   if (shouldErrorOnNoMatchedFiles) {
-    allErrors.push({
-      err: new Error(
-        `Did not find any files to check across all patterns: ${patterns.join(", ")}`,
-      ),
+    appendError(allErrors, {
+      err: new Error(`Did not find any files to check across all patterns: ${patterns.join(", ")}`),
       file: "glob",
     });
     return { files: [], hasError: true };
   }
 
-  if (shouldWarnOnNoMatchedFiles && hasLogger) {
-    logger.warn(
-      "ES-Check: No file patterns specified or no files found (running in loose mode).",
-    );
+  if (shouldLogNoMatchedFilesWarning) {
+    logger.warn("ES-Check: No file patterns specified or no files found (running in loose mode).");
   }
 
   return { files: allMatchedFiles, hasError: hasPatternWithNoFiles };
@@ -160,17 +164,13 @@ function handleBrowserslistError(browserslistError, options) {
   const isExiting = !isNodeAPI;
 
   if (hasLogger) {
-    logger.error(
-      `Error determining ES version from browserslist: ${browserslistError.message}`,
-    );
+    logger.error(`Error determining ES version from browserslist: ${browserslistError.message}`);
   }
 
   if (isExiting) process.exit(1);
 
-  allErrors.push({
-    err: new Error(
-      `Error determining ES version from browserslist: ${browserslistError.message}`,
-    ),
+  appendError(allErrors, {
+    err: new Error(`Error determining ES version from browserslist: ${browserslistError.message}`),
     file: "browserslist",
   });
 }
@@ -181,14 +181,12 @@ function handleInvalidVersion(options) {
   const isExiting = !isNodeAPI;
 
   if (hasLogger) {
-    logger.error(
-      "Invalid ecmaScript version, please pass a valid version, use --help for help",
-    );
+    logger.error("Invalid ecmaScript version, please pass a valid version, use --help for help");
   }
 
   if (isExiting) process.exit(1);
 
-  allErrors.push({
+  appendError(allErrors, {
     err: new Error("Invalid ecmaScript version"),
     file: "config",
   });
@@ -198,9 +196,7 @@ function determineEcmaVersion(config, options) {
   const { logger, isDebug, isWarn, isNodeAPI, allErrors } = options;
   const { ecmaVersion: expectedEcmaVersion, checkBrowser } = config;
 
-  const isBrowserslistCheck = Boolean(
-    expectedEcmaVersion === "checkBrowser" || checkBrowser,
-  );
+  const isBrowserslistCheck = Boolean(expectedEcmaVersion === "checkBrowser" || checkBrowser);
 
   if (isBrowserslistCheck) {
     const browserslistQuery = config.browserslistQuery;
@@ -224,9 +220,7 @@ function determineEcmaVersion(config, options) {
     const shouldDebug = hasNoError && isDebug;
 
     if (shouldDebug) {
-      logger.debug(
-        `ES-Check: Using ES${ecmaVersion} based on browserslist configuration`,
-      );
+      logger.debug(`ES-Check: Using ES${ecmaVersion} based on browserslist configuration`);
     }
 
     if (hasError) {
@@ -243,8 +237,7 @@ function determineEcmaVersion(config, options) {
 
   const mappedVersion = ECMA_VERSION_MAP[expectedEcmaVersion];
   const isInvalidVersion = !mappedVersion;
-  const isLegacyVersion =
-    expectedEcmaVersion === "es3" || expectedEcmaVersion === "es4";
+  const isLegacyVersion = expectedEcmaVersion === "es3" || expectedEcmaVersion === "es4";
   const hasLegacyWarning = isLegacyVersion && isWarn;
 
   if (hasLegacyWarning) {
@@ -274,42 +267,38 @@ function filterIgnoredFiles(files, pathsToIgnore, globOpts) {
   const hasNoExpandedIgnores = expandedPathsToIgnore.length === 0;
   if (hasNoExpandedIgnores) return files;
 
-  return files.filter((filePath) => {
-    return !expandedPathsToIgnore.some((ignoreValue) =>
-      filePath.includes(ignoreValue),
-    );
-  });
+  const shouldKeepFile = (filePath) => {
+    let index = 0;
+    while (index < expandedPathsToIgnore.length) {
+      const ignoreValue = expandedPathsToIgnore[index];
+      const pathParts = filePath.split(ignoreValue);
+      const includesIgnoreValue = pathParts.length > 1;
+      if (includesIgnoreValue) return false;
+      index += 1;
+    }
+
+    return true;
+  };
+
+  return files.filter(shouldKeepFile);
 }
 
-function processFullAST(
-  code,
-  acornOpts,
-  file,
-  config,
-  ignoreList,
-  ecmaVersion,
-  isDebug,
-  logger,
-) {
+function processFullAST(code, acornOpts, file, config, ignoreList, ecmaVersion, isDebug, logger) {
   const needsFullAST = config.checkFeatures;
   const parserOptions = needsFullAST
     ? acornOpts
-    : { ...acornOpts, locations: false, ranges: false, onComment: null };
+    : Object.assign({}, acornOpts, {
+        locations: false,
+        ranges: false,
+        onComment: null,
+      });
 
-  const { ast, error: parseError } = parseCode(
-    code,
-    parserOptions,
-    acorn,
-    file,
-    config,
-  );
+  const { ast, error: parseError } = parseCode(code, parserOptions, acorn, file, config);
   const hasParseError = parseError !== null;
   const shouldDebugError = hasParseError && isDebug;
 
   if (shouldDebugError) {
-    logger.debug(
-      `ES-Check: failed to parse file: ${file} \n - error: ${parseError.err}`,
-    );
+    logger.debug(`ES-Check: failed to parse file: ${file} \n - error: ${parseError.err}`);
   }
 
   if (hasParseError) return parseError;
@@ -324,17 +313,11 @@ function processFullAST(
   let unsupportedFeatures;
 
   try {
-    const result = detectFeatures(
-      code,
-      esVersion,
-      parseSourceType,
-      ignoreList,
-      {
-        ast,
-        checkForPolyfills: config.checkForPolyfills,
-        ignorePolyfillable: config.ignorePolyfillable,
-      },
-    );
+    const result = detectFeatures(code, esVersion, parseSourceType, ignoreList, {
+      ast,
+      checkForPolyfills: config.checkForPolyfills,
+      ignorePolyfillable: config.ignorePolyfillable,
+    });
     foundFeatures = result.foundFeatures;
     unsupportedFeatures = result.unsupportedFeatures;
   } catch (err) {
@@ -350,8 +333,7 @@ function processFullAST(
     logger.debug(`Features found in ${file}: ${stringifiedFeatures}`);
   }
 
-  const shouldCheckPolyfills =
-    config.checkForPolyfills && unsupportedFeatures.length > 0;
+  const shouldCheckPolyfills = config.checkForPolyfills && unsupportedFeatures.length > 0;
 
   if (!shouldCheckPolyfills) {
     const isSupported = unsupportedFeatures.length === 0;
@@ -378,8 +360,7 @@ function processFullAST(
   );
 
   const hasPolyfillReduction =
-    isDebug &&
-    filteredUnsupportedFeatures.length !== unsupportedFeatures.length;
+    isDebug && filteredUnsupportedFeatures.length !== unsupportedFeatures.length;
 
   if (hasPolyfillReduction) {
     logger.debug(
@@ -395,8 +376,7 @@ function processFullAST(
     );
 
     const hasPolyfillableReduction =
-      isDebug &&
-      filteredUnsupportedFeatures.length !== beforeIgnorePolyfillable;
+      isDebug && filteredUnsupportedFeatures.length !== beforeIgnorePolyfillable;
 
     if (hasPolyfillableReduction) {
       logger.debug(
@@ -431,16 +411,7 @@ function createFileProcessor(config, options) {
       logger.debug(`ES-Check: checking ${file}`);
     }
 
-    return processFullAST(
-      code,
-      acornOpts,
-      file,
-      config,
-      ignoreList,
-      ecmaVersion,
-      isDebug,
-      logger,
-    );
+    return processFullAST(code, acornOpts, file, config, ignoreList, ecmaVersion, isDebug, logger);
   };
 }
 
@@ -448,9 +419,7 @@ function logErrors(errors, logger) {
   const hasLogger = logger !== null && logger !== undefined;
   if (!hasLogger) return;
 
-  logger.error(
-    `ES-Check: there were ${errors.length} ES version matching errors.`,
-  );
+  logger.error(`ES-Check: there were ${errors.length} ES version matching errors.`);
 
   const { mapErrorPosition } = require("../helpers/sourcemap");
 
@@ -460,9 +429,7 @@ function logErrors(errors, logger) {
       ? mapErrorPosition(error.file, error.line, error.column)
       : { file: error.file, line: error.line, column: error.column };
 
-    const locationInfo = hasLocation
-      ? ` at ${mapped.file}:${mapped.line}:${mapped.column}`
-      : "";
+    const locationInfo = hasLocation ? ` at ${mapped.file}:${mapped.line}:${mapped.column}` : "";
 
     logger.info(`
       ES-Check Error:
@@ -476,18 +443,12 @@ function logErrors(errors, logger) {
   }
 }
 
-function processConfigResult(
-  errors,
-  logger,
-  isNodeAPI,
-  allErrors,
-  ecmaVersion,
-) {
+function processConfigResult(errors, logger, isNodeAPI, allErrors, ecmaVersion) {
   const hasFileErrors = errors.length > 0;
 
   if (hasFileErrors) {
     logErrors(errors, logger);
-    allErrors.push(...errors);
+    appendErrors(allErrors, errors);
 
     const isExiting = !isNodeAPI;
     if (isExiting) {
@@ -499,9 +460,7 @@ function processConfigResult(
 
   const hasLogger = logger !== null && logger !== undefined;
   if (hasLogger) {
-    const versionLabel = ecmaVersion
-      ? `ES${ecmaVersion}`
-      : "the specified ES version";
+    const versionLabel = ecmaVersion ? `ES${ecmaVersion}` : "the specified ES version";
     logger.info(`✓ ES-Check passed! All files are ${versionLabel} compatible.`);
   }
 

package/lib/cli/constants.js

@@ -1,7 +1,7 @@
 const CLI_DESCRIPTION = {
   main: "es-check 🏆 - Check JavaScript files against an ECMAScript version",
   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, es15/es2024, es16/es2025, 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, es17/es2026, checkBrowser",
   files: "a glob of files to to test the EcmaScript version against",
   completion: "generate shell completion script",
   shell: "shell type: bash, zsh",
@@ -25,8 +25,7 @@ const CLI_OPTIONS = [
   },
   {
     flags: "--files <files>",
-    description:
-      "a glob of files to to test the EcmaScript version against (alias for [files...])",
+    description: "a glob of files to to test the EcmaScript version against (alias for [files...])",
   },
   {
     flags: "--not <files>",
@@ -65,8 +64,7 @@ const CLI_OPTIONS = [
   },
   {
     flags: "--checkForPolyfills",
-    description:
-      "consider polyfills when checking features (only works with --checkFeatures)",
+    description: "consider polyfills when checking features (only works with --checkFeatures)",
     default: false,
   },
   {
@@ -77,8 +75,7 @@ const CLI_OPTIONS = [
   },
   {
     flags: "--ignore <features>",
-    description:
-      'comma-separated list of features to ignore, e.g., "ErrorCause,TopLevelAwait"',
+    description: 'comma-separated list of features to ignore, e.g., "ErrorCause,TopLevelAwait"',
   },
   {
     flags: "--ignore-file <path>",