es-check 9.5.4 → 9.6.0-1

package/README.md

@@ -132,6 +132,7 @@ Here's a comprehensive list of all available options:
 | `-V, --version`               | Output the version number                                                                                                   |
 | `--module`                    | Use ES modules (default: false)                                                                                             |
 | `--allowHashBang`             | If the code starts with #! treat it as a comment (default: false)                                                           |
+| `--typescript, --ts`          | Enable TypeScript file support (default: false)                                                                             |
 | `--files <files>`             | A glob of files to test the ECMAScript version against (alias for [files...])                                               |
 | `--not <files>`               | Folder or file names to skip                                                                                                |
 | `--noColor`                   | Disable use of colors in output (default: false)                                                                            |
@@ -167,6 +168,14 @@ es-check es6 './dist/**/*.js' --module
 es-check es6 './tests/*.js' --allowHashBang
 ```
 
+**Checking TypeScript files:**
+
+```sh
+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.
+
 **Skipping specific files or directories:**
 
 ```sh

package/lib/browserslist.js

@@ -1,12 +1,6 @@
 const browserslist = require("browserslist");
 const { BROWSER_TO_ES_VERSION } = require("./constants/versions");
 
-/**
- * Determines the ES version supported by a specific browser and version
- * @param {string} browser - Browser name
- * @param {string} version - Browser version
- * @returns {number} - ES version (5, 6, etc.)
- */
 function getESVersionForBrowser(browser, version) {
   const defaultVersion = 5;
 
@@ -43,14 +37,6 @@ function getESVersionForBrowser(browser, version) {
   return BROWSER_TO_ES_VERSION[browser][matchedVersion];
 }
 
-/**
- * Determines the minimum ES version required to support all browsers in the browserslist
- * @param {Object} options - Options object
- * @param {string} [options.browserslistQuery]
- * @param {string} [options.browserslistPath] - Optional custom path to browserslist config
- * @param {string} [options.browserslistEnv] - Optional browserslist environment to use
- * @returns {number} - The ES version to use (e.g., 5, 6, etc.)
- */
 function getESVersionFromBrowserslist(options = {}) {
   const { browserslistPath, browserslistEnv, browserslistQuery } = options;
 

package/lib/check-runner/index.js

@@ -1,6 +1,10 @@
 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 {
   parseFilePatterns,
   validateConfig,
@@ -81,9 +85,17 @@ function processConfig(config, context) {
 
   const { ecmaVersion } = versionResult;
   const useLatestForParsing = config.checkFeatures;
+  const targetEsVersion = parseInt(ecmaVersion, 10);
+
+  const enableFeatureDetection = config.checkBrowser || config.checkFeatures;
+  const minRequiredParser = getMinimumParserVersion(
+    targetEsVersion,
+    enableFeatureDetection,
+  );
+
   const parserEcmaVersion = useLatestForParsing
-    ? 2025
-    : parseInt(ecmaVersion, 10);
+    ? LATEST_PARSER_VERSION
+    : minRequiredParser;
   const acornOpts = { ecmaVersion: parserEcmaVersion, silent: true };
 
   if (isDebug) {

package/lib/check-runner/utils.js

@@ -301,6 +301,7 @@ function processFullAST(
     parserOptions,
     acorn,
     file,
+    config,
   );
   const hasParseError = parseError !== null;
   const shouldDebugError = hasParseError && isDebug;
@@ -367,21 +368,39 @@ function processFullAST(
     logger || { debug: () => {}, isLevelEnabled: () => false },
   );
 
-  const filteredUnsupportedFeatures = polyfillDetector.filterPolyfilled(
+  let filteredUnsupportedFeatures = polyfillDetector.filterPolyfilled(
     unsupportedFeatures,
     polyfills,
   );
 
-  const hasReduction =
+  const hasPolyfillReduction =
     isDebug &&
     filteredUnsupportedFeatures.length !== unsupportedFeatures.length;
 
-  if (hasReduction) {
+  if (hasPolyfillReduction) {
     logger.debug(
       `ES-Check: Polyfills reduced unsupported features from ${unsupportedFeatures.length} to ${filteredUnsupportedFeatures.length}`,
     );
   }
 
+  if (config.ignorePolyfillable) {
+    const beforeIgnorePolyfillable = filteredUnsupportedFeatures.length;
+    filteredUnsupportedFeatures = polyfillDetector.filterPolyfillableFeatures(
+      filteredUnsupportedFeatures,
+      config.ignorePolyfillable,
+    );
+
+    const hasPolyfillableReduction =
+      isDebug &&
+      filteredUnsupportedFeatures.length !== beforeIgnorePolyfillable;
+
+    if (hasPolyfillableReduction) {
+      logger.debug(
+        `ES-Check: Ignoring polyfillable features reduced unsupported features from ${beforeIgnorePolyfillable} to ${filteredUnsupportedFeatures.length}`,
+      );
+    }
+  }
+
   const isSupported = filteredUnsupportedFeatures.length === 0;
 
   if (!isSupported) {

package/lib/cli/constants.js

@@ -133,6 +133,11 @@ const CLI_OPTIONS = [
       "lightweight mode: faster checking with pattern matching only (skips full AST parsing)",
     default: false,
   },
+  {
+    flags: "--typescript, --ts",
+    description: "enable TypeScript file support",
+    default: false,
+  },
 ];
 
 const SUPPORTED_SHELLS = ["bash", "zsh"];
@@ -162,6 +167,8 @@ const COMPLETION_OPTIONS = [
   "config",
   "batchSize",
   "noCache",
+  "typescript",
+  "ts",
 ];
 
 module.exports = {

package/lib/cli/handler.js

@@ -16,8 +16,10 @@ function buildConfig(ecmaVersionArg, filesArg, options, baseConfig) {
     ...baseConfig,
     module: options.module,
     allowHashBang: options.allowHashBang || options["allow-hash-bang"],
+    typescript: options.typescript || options.ts,
     checkFeatures: options.checkFeatures,
     checkForPolyfills: options.checkForPolyfills,
+    ignorePolyfillable: options.ignorePolyfillable,
     ignore: options.ignore !== undefined ? options.ignore : baseConfig.ignore,
     ignoreFile:
       ignoreFilePath !== undefined ? ignoreFilePath : baseConfig.ignoreFile,

package/lib/cli/parser.js

@@ -2,6 +2,8 @@ const BOOLEAN_FLAGS = new Set([
   "module",
   "allowHashBang",
   "allow-hash-bang",
+  "typescript",
+  "ts",
   "noColor",
   "no-color",
   "verbose",
@@ -104,6 +106,7 @@ OPTIONS:
   --module                         Use ES modules
   --light                          Fast checking using pattern matching only
   --allowHashBang                  Treat #! as comment
+  --typescript, -ts                Enable TypeScript file support
   --files <files>                  Files to check (comma-separated)
   --not <files>                    Files/folders to skip (comma-separated)
   --noColor                        Disable colors
@@ -113,6 +116,7 @@ OPTIONS:
   --looseGlobMatching              Don't fail if no files found
   --checkFeatures                  Check for ES version specific features
   --checkForPolyfills              Consider polyfills when checking features
+  --ignorePolyfillable [library]   Ignore polyfillable features (optionally specify library: core-js)
   --ignore <features>              Features to ignore (comma-separated)
   --ignoreFile <path>              JSON file with features to ignore
   --allowList <features>           Features to allow (comma-separated)
@@ -128,8 +132,11 @@ EXAMPLES:
   es-check es5 './dist/**/*.js'
   es-check es6 './src/*.js' --module
   es-check es2020 './build/**/*.js' --checkFeatures
+  es-check es2017 './dist/*.js' --checkFeatures --ignorePolyfillable=core-js
   es-check checkBrowser './dist/*.js' --browserslistQuery="last 2 versions"
   es-check es5 './dist/*.js' --not=./dist/vendor,./dist/legacy
+  es-check es5 './src/**/*.{js,ts}' --typescript
+  es-check es2020 './src/**/*.ts' --module -ts
 
 COMPLETION:
   es-check completion          Generate bash completion

package/lib/constants/es-features/13.js

@@ -46,6 +46,7 @@ const ES13_FEATURES = {
     astInfo: {
       nodeType: "CallExpression",
       property: "at",
+      excludeCallerTypes: ["ObjectExpression"],
     },
   },
   ObjectHasOwn: {

package/lib/constants/es-features/17.js

@@ -0,0 +1,47 @@
+const ES17_FEATURES = {
+  ArrayFromAsync: {
+    minVersion: 17,
+    example: "Array.fromAsync(asyncIterable)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Array",
+      property: "fromAsync",
+    },
+  },
+  ErrorIsError: {
+    minVersion: 17,
+    example: "Error.isError(value)",
+    astInfo: {
+      nodeType: "CallExpression",
+      object: "Error",
+      property: "isError",
+    },
+  },
+  ArrayBufferTransfer: {
+    minVersion: 17,
+    example: "buffer.transfer(newByteLength)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "transfer",
+    },
+  },
+  ArrayBufferTransferToFixedLength: {
+    minVersion: 17,
+    example: "buffer.transferToFixedLength(newByteLength)",
+    astInfo: {
+      nodeType: "CallExpression",
+      property: "transferToFixedLength",
+    },
+  },
+  IntlDurationFormat: {
+    minVersion: 17,
+    example: "new Intl.DurationFormat('en')",
+    astInfo: {
+      nodeType: "NewExpression",
+      object: "Intl",
+      property: "DurationFormat",
+    },
+  },
+};
+
+module.exports = { ES17_FEATURES };

package/lib/constants/es-features/index.js

@@ -9,6 +9,7 @@ const { ES13_FEATURES } = require("./13");
 const { ES14_FEATURES } = require("./14");
 const { ES15_FEATURES } = require("./15");
 const { ES16_FEATURES } = require("./16");
+const { ES17_FEATURES } = require("./17");
 const {
   POLYFILL_PATTERNS,
   IMPORT_PATTERNS,
@@ -27,6 +28,7 @@ const ES_FEATURES = {
   ...ES14_FEATURES,
   ...ES15_FEATURES,
   ...ES16_FEATURES,
+  ...ES17_FEATURES,
 };
 
 module.exports = {

package/lib/constants/es-features/polyfills.js

@@ -1,86 +1,86 @@
 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['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.to-sorted['"]/,
     feature: "ArrayToSorted",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.array\.find-last['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.find-last['"]/,
     feature: "ArrayFindLast",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.array\.find-last-index['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.find-last-index['"]/,
     feature: "ArrayFindLastIndex",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.array\.at['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.array\.at['"]/,
     feature: "ArrayAt",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.string\.replace-all['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.string\.replace-all['"]/,
     feature: "StringReplaceAll",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.string\.match-all['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.string\.match-all['"]/,
     feature: "StringMatchAll",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.string\.at['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.string\.at['"]/,
     feature: "StringAt",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.object\.has-own['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.object\.has-own['"]/,
     feature: "ObjectHasOwn",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.promise\.any['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.promise\.any['"]/,
     feature: "PromiseAny",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.regexp\.exec['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.regexp\.exec['"]/,
     feature: "RegExpExec",
   },
   {
-    pattern: /from\s+['"]core-js\/modules\/es\.global-this['"]/,
+    pattern:
+      /(?:from\s+|require\s*\(\s*)['"]core-js\/modules\/es\.global-this['"]/,
     feature: "GlobalThis",
   },
 ];
 
-/**
- * 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 = {
-  // ES2015 (ES6)
   "Array.from": [
     /\bArray\.from\s*=/,
     /['"]core-js\/modules\/es\.array\.from['"]/,
+    /['"]core-js\/actual\/array\/from['"]/,
+  ],
+  "Array.of": [
+    /\bArray\.of\s*=/,
+    /['"]core-js\/modules\/es\.array\.of['"]/,
+    /['"]core-js\/actual\/array\/of['"]/,
   ],
-  "Array.of": [/\bArray\.of\s*=/, /['"]core-js\/modules\/es\.array\.of['"]/],
   "Array.prototype.find": [
     /\bArray\.prototype\.find\s*=/,
     /['"]core-js\/modules\/es\.array\.find['"]/,
@@ -92,7 +92,7 @@ const FEATURE_TO_POLYFILL_MAP = {
   "Object.assign": [
     /\bObject\.assign\s*=/,
     /['"]core-js\/modules\/es\.object\.assign['"]/,
-    /object-assign/,
+    /\bobject-assign\b/,
   ],
   Promise: [
     /\bPromise\s*=/,
@@ -117,13 +117,11 @@ const FEATURE_TO_POLYFILL_MAP = {
   WeakMap: [/\bWeakMap\s*=/, /['"]core-js\/modules\/es\.weak-map['"]/],
   WeakSet: [/\bWeakSet\s*=/, /['"]core-js\/modules\/es\.weak-set['"]/],
 
-  // ES2016
   "Array.prototype.includes": [
     /\bArray\.prototype\.includes\s*=/,
     /['"]core-js\/modules\/es\.array\.includes['"]/,
   ],
 
-  // ES2017
   "Object.values": [
     /\bObject\.values\s*=/,
     /['"]core-js\/modules\/es\.object\.values['"]/,
@@ -145,13 +143,11 @@ const FEATURE_TO_POLYFILL_MAP = {
     /['"]core-js\/modules\/es\.string\.pad-end['"]/,
   ],
 
-  // ES2018
   "Promise.prototype.finally": [
     /\bPromise\.prototype\.finally\s*=/,
     /['"]core-js\/modules\/es\.promise\.finally['"]/,
   ],
 
-  // ES2019
   "Array.prototype.flat": [
     /\bArray\.prototype\.flat\s*=/,
     /['"]core-js\/modules\/es\.array\.flat['"]/,
@@ -173,7 +169,6 @@ const FEATURE_TO_POLYFILL_MAP = {
     /['"]core-js\/modules\/es\.string\.trim-end['"]/,
   ],
 
-  // ES2020
   "Promise.allSettled": [
     /\bPromise\.allSettled\s*=/,
     /['"]core-js\/modules\/es\.promise\.all-settled['"]/,
@@ -182,10 +177,9 @@ const FEATURE_TO_POLYFILL_MAP = {
     /\bString\.prototype\.matchAll\s*=/,
     /['"]core-js\/modules\/es\.string\.match-all['"]/,
   ],
-  globalThis: [/globalThis\s*=/, /['"]core-js\/modules\/es\.global-this['"]/],
+  globalThis: [/\bglobalThis\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['"]/,
@@ -195,17 +189,17 @@ const FEATURE_TO_POLYFILL_MAP = {
     /['"]core-js\/modules\/es\.string\.replace-all['"]/,
   ],
 
-  // ES2022
   "Array.prototype.at": [
     /\bArray\.prototype\.at\s*=/,
     /['"]core-js\/modules\/es\.array\.at['"]/,
+    /['"]core-js\/actual\/array\/at['"]/,
   ],
   "String.prototype.at": [
     /\bString\.prototype\.at\s*=/,
     /['"]core-js\/modules\/es\.string\.at['"]/,
+    /['"]core-js\/actual\/string\/at['"]/,
   ],
 
-  // ES2023
   "Array.prototype.findLast": [
     /\bArray\.prototype\.findLast\s*=/,
     /['"]core-js\/modules\/es\.array\.find-last['"]/,
@@ -217,21 +211,33 @@ const FEATURE_TO_POLYFILL_MAP = {
   "Array.prototype.toReversed": [
     /\bArray\.prototype\.toReversed\s*=/,
     /['"]core-js\/modules\/es\.array\.to-reversed['"]/,
+    /['"]core-js\/actual\/array\/to-reversed['"]/,
+    /['"]core-js\/stable\/array\/to-reversed['"]/,
+    /(?:__webpack_require__\([^)]*core-js[^)]*to-reversed|core[-_]js[^/\n]*toReversed)/,
+    /\bcore[-_]js[-_]modules[-_][^/\n]*to[-_]reversed/,
   ],
   "Array.prototype.toSorted": [
     /\bArray\.prototype\.toSorted\s*=/,
     /['"]core-js\/modules\/es\.array\.to-sorted['"]/,
+    /['"]core-js\/actual\/array\/to-sorted['"]/,
+    /['"]core-js\/stable\/array\/to-sorted['"]/,
+    /__webpack_require__\([^)]*core-js\/modules\/es\.array\.to-sorted[^)]*\)/,
+    /\bcore[-_]js[-_]modules[-_][^/\n]*to[-_]sorted/,
   ],
   "Array.prototype.toSpliced": [
     /\bArray\.prototype\.toSpliced\s*=/,
     /['"]core-js\/modules\/es\.array\.to-spliced['"]/,
+    /['"]core-js\/actual\/array\/to-spliced['"]/,
   ],
   "Array.prototype.with": [
     /\bArray\.prototype\.with\s*=/,
     /['"]core-js\/modules\/es\.array\.with['"]/,
+    /['"]core-js\/actual\/array\/with['"]/,
+    /['"]core-js\/stable\/array\/with['"]/,
+    /(?:__webpack_require__\([^)]*core-js[^)]*array[^)]*with|core[-_]js[^/\n]*array[-_]with)/,
+    /\bcore[-_]js[-_]modules[-_][^/\n]*array[-_]with/,
   ],
 
-  // ES2024
   "Object.hasOwn": [
     /\bObject\.hasOwn\s*=/,
     /['"]core-js\/modules\/es\.object\.has-own['"]/,
@@ -245,7 +251,6 @@ const FEATURE_TO_POLYFILL_MAP = {
     /['"]core-js\/modules\/es\.string\.to-well-formed['"]/,
   ],
 
-  // ES2025
   "Array.prototype.group": [
     /\bArray\.prototype\.group\s*=/,
     /['"]core-js\/modules\/es\.array\.group['"]/,
@@ -258,6 +263,47 @@ const FEATURE_TO_POLYFILL_MAP = {
     /\bPromise\.try\s*=/,
     /['"]core-js\/modules\/es\.promise\.try['"]/,
   ],
+
+  "Array.fromAsync": [
+    /\bArray\.fromAsync\s*=/,
+    /['"]core-js\/modules\/es\.array\.from-async['"]/,
+    /['"]core-js\/actual\/array\/from-async['"]/,
+  ],
+  "Error.isError": [
+    /\bError\.isError\s*=/,
+    /['"]core-js\/modules\/es\.error\.is-error['"]/,
+    /['"]core-js\/actual\/error\/is-error['"]/,
+  ],
+  "Intl.DurationFormat": [
+    /\bIntl\.DurationFormat\s*=/,
+    /['"]core-js\/modules\/es\.intl\.duration-format['"]/,
+    /['"]@formatjs\/intl-durationformat['"]/,
+  ],
+
+  ArrayToSorted: [
+    /\bArray\.prototype\.toSorted\s*=/,
+    /['"]core-js\/modules\/es\.array\.to-sorted['"]/,
+    /['"]core-js\/actual\/array\/to-sorted['"]/,
+    /['"]core-js\/stable\/array\/to-sorted['"]/,
+    /__webpack_require__\([^)]*core-js\/modules\/es\.array\.to-sorted[^)]*\)/,
+    /\bcore[-_]js[-_]modules[-_]es[-_]array[-_]toSorted\b/,
+  ],
+  ArrayToReversed: [
+    /\bArray\.prototype\.toReversed\s*=/,
+    /['"]core-js\/modules\/es\.array\.to-reversed['"]/,
+    /['"]core-js\/actual\/array\/to-reversed['"]/,
+    /['"]core-js\/stable\/array\/to-reversed['"]/,
+    /(?:__webpack_require__\([^)]*core-js[^)]*to-reversed|core[-_]js[^/\n]*toReversed)/,
+    /\bcore[-_]js[-_]modules[-_][^/\n]*to[-_]reversed/,
+  ],
+  ArrayWith: [
+    /\bArray\.prototype\.with\s*=/,
+    /['"]core-js\/modules\/es\.array\.with['"]/,
+    /['"]core-js\/actual\/array\/with['"]/,
+    /['"]core-js\/stable\/array\/with['"]/,
+    /(?:__webpack_require__\([^)]*core-js[^)]*array[^)]*with|core[-_]js[-_]array[-_]with)/,
+    /\bcore[-_]js[-_]modules[-_][^/\n]*array[-_]with/,
+  ],
 };
 
 module.exports = {

package/lib/constants/featureParserMapping.js

@@ -0,0 +1,50 @@
+const FEATURE_PARSER_REQUIREMENTS = {
+  SpreadInArrays: 6,
+  ObjectSpread: 9,
+  PrivateFields: 9,
+  BigInt: 9,
+  NumericSeparators: 10,
+  OptionalChaining: 11,
+  NullishCoalescing: 11,
+  LogicalAssignment: 12,
+  LogicalAssignmentOr: 12,
+  LogicalAssignmentNullish: 12,
+  TopLevelAwait: 12,
+  StaticInitializationBlocks: 13,
+};
+
+function getParserVersionForFeature(featureName, targetEsVersion) {
+  const requiredParser = FEATURE_PARSER_REQUIREMENTS[featureName];
+  if (!requiredParser) {
+    return targetEsVersion;
+  }
+
+  return Math.max(targetEsVersion, requiredParser);
+}
+
+function getMinimumParserVersion(
+  targetEsVersion,
+  enableFeatureDetection = false,
+) {
+  if (!enableFeatureDetection) {
+    return targetEsVersion;
+  }
+
+  let minParserVersion = targetEsVersion;
+
+  for (const [_feature, requiredParser] of Object.entries(
+    FEATURE_PARSER_REQUIREMENTS,
+  )) {
+    if (targetEsVersion >= requiredParser) {
+      minParserVersion = Math.max(minParserVersion, requiredParser);
+    }
+  }
+
+  return minParserVersion;
+}
+
+module.exports = {
+  FEATURE_PARSER_REQUIREMENTS,
+  getParserVersionForFeature,
+  getMinimumParserVersion,
+};

package/lib/constants/polyfillableFeatures.js

@@ -0,0 +1,133 @@
+const POLYFILLABLE_FEATURES = new Set([
+  "Array.from",
+  "Array.of",
+  "Array.prototype.find",
+  "Array.prototype.findIndex",
+  "Array.prototype.includes",
+  "Array.prototype.at",
+  "Array.prototype.findLast",
+  "Array.prototype.findLastIndex",
+  "Array.prototype.toSorted",
+  "Array.prototype.toReversed",
+  "Array.prototype.with",
+  "Array.prototype.flatMap",
+  "Array.prototype.flat",
+  "ArrayToSorted",
+  "ArrayToReversed",
+  "ArrayWith",
+  "ArrayFindLast",
+  "ArrayFindLastIndex",
+  "ArrayAt",
+  "String.prototype.includes",
+  "String.prototype.startsWith",
+  "String.prototype.endsWith",
+  "String.prototype.repeat",
+  "String.prototype.padStart",
+  "String.prototype.padEnd",
+  "String.prototype.trimStart",
+  "String.prototype.trimEnd",
+  "String.prototype.replaceAll",
+  "String.prototype.matchAll",
+  "String.prototype.at",
+  "StringReplaceAll",
+  "StringMatchAll",
+  "StringAt",
+  "Object.assign",
+  "Object.keys",
+  "Object.values",
+  "Object.entries",
+  "Object.fromEntries",
+  "Object.hasOwn",
+  "ObjectHasOwn",
+  "Promise.resolve",
+  "Promise.reject",
+  "Promise.all",
+  "Promise.race",
+  "Promise.allSettled",
+  "Promise.any",
+  "PromiseAny",
+  "PromiseAllSettled",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "Symbol.iterator",
+  "Symbol.asyncIterator",
+  "globalThis",
+  "GlobalThis",
+  "Number.isNaN",
+  "Number.isFinite",
+  "Number.isInteger",
+  "Number.isSafeInteger",
+  "Number.parseFloat",
+  "Number.parseInt",
+  "Math.trunc",
+  "Math.sign",
+  "Math.cbrt",
+  "Math.hypot",
+  "RegExp.prototype.flags",
+]);
+
+const CORE_JS_POLYFILLABLE = new Set([
+  "Array.from",
+  "Array.of",
+  "Array.prototype.find",
+  "Array.prototype.findIndex",
+  "Array.prototype.includes",
+  "Array.prototype.at",
+  "Array.prototype.findLast",
+  "Array.prototype.findLastIndex",
+  "Array.prototype.toSorted",
+  "Array.prototype.toReversed",
+  "Array.prototype.with",
+  "ArrayToSorted",
+  "ArrayToReversed",
+  "ArrayWith",
+  "ArrayFindLast",
+  "ArrayFindLastIndex",
+  "ArrayAt",
+  "String.prototype.includes",
+  "String.prototype.startsWith",
+  "String.prototype.endsWith",
+  "String.prototype.repeat",
+  "String.prototype.padStart",
+  "String.prototype.padEnd",
+  "String.prototype.trimStart",
+  "String.prototype.trimEnd",
+  "String.prototype.replaceAll",
+  "String.prototype.matchAll",
+  "String.prototype.at",
+  "StringReplaceAll",
+  "StringMatchAll",
+  "StringAt",
+  "Object.assign",
+  "Object.keys",
+  "Object.values",
+  "Object.entries",
+  "Object.fromEntries",
+  "Object.hasOwn",
+  "ObjectHasOwn",
+  "Promise.resolve",
+  "Promise.reject",
+  "Promise.all",
+  "Promise.race",
+  "Promise.allSettled",
+  "Promise.any",
+  "PromiseAny",
+  "PromiseAllSettled",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "Symbol.iterator",
+  "Symbol.asyncIterator",
+  "globalThis",
+  "GlobalThis",
+]);
+
+module.exports = {
+  POLYFILLABLE_FEATURES,
+  CORE_JS_POLYFILLABLE,
+};

package/lib/constants/versions.js

@@ -13,6 +13,7 @@ const ECMA_VERSION_MAP = {
   14: "es2023",
   15: "es2024",
   16: "es2025",
+  17: "es2026",
   2015: "es2015",
   2016: "es2016",
   2017: "es2017",
@@ -24,6 +25,7 @@ const ECMA_VERSION_MAP = {
   2023: "es2023",
   2024: "es2024",
   2025: "es2025",
+  2026: "es2026",
   es3: "es5",
   es4: "es5",
   es5: "es5",
@@ -38,6 +40,7 @@ const ECMA_VERSION_MAP = {
   es14: "es2023",
   es15: "es2024",
   es16: "es2025",
+  es17: "es2026",
   es2015: "es2015",
   es2016: "es2016",
   es2017: "es2017",
@@ -49,6 +52,7 @@ const ECMA_VERSION_MAP = {
   es2023: "es2023",
   es2024: "es2024",
   es2025: "es2025",
+  es2026: "es2026",
 };
 
 const ECMA_VERSION_TO_NUMBER = {
@@ -64,6 +68,7 @@ const ECMA_VERSION_TO_NUMBER = {
   es2023: 14,
   es2024: 15,
   es2025: 16,
+  es2026: 17,
 };
 
 const BROWSER_TO_ES_VERSION = {
@@ -82,6 +87,7 @@ const BROWSER_TO_ES_VERSION = {
     97: 14,
     117: 15,
     136: 16,
+    150: 17,
   },
   firefox: {
     52: 6,
@@ -95,6 +101,7 @@ const BROWSER_TO_ES_VERSION = {
     104: 14,
     119: 15,
     134: 16,
+    145: 17,
   },
   chrome: {
     51: 6,
@@ -108,6 +115,7 @@ const BROWSER_TO_ES_VERSION = {
     97: 14,
     117: 15,
     136: 16,
+    150: 17,
   },
   safari: {
     10: 6,
@@ -121,6 +129,7 @@ const BROWSER_TO_ES_VERSION = {
     15.4: 14,
     17: 15,
     18.2: 16,
+    19.1: 17,
   },
   opera: {
     38: 6,
@@ -134,6 +143,7 @@ const BROWSER_TO_ES_VERSION = {
     83: 14,
     103: 15,
     121: 16,
+    135: 17,
   },
   ios_saf: {
     10: 6,
@@ -147,6 +157,7 @@ const BROWSER_TO_ES_VERSION = {
     15.4: 14,
     17: 15,
     18.2: 16,
+    19.1: 17,
   },
   android: {
     67: 6,
@@ -160,6 +171,7 @@ const BROWSER_TO_ES_VERSION = {
     97: 14,
     117: 15,
     136: 16,
+    150: 17,
   },
 };
 
@@ -189,6 +201,8 @@ const JS_VERSIONS = [
   "es2024",
   "es16",
   "es2025",
+  "es17",
+  "es2026",
   "checkBrowser",
 ];
 
@@ -205,12 +219,16 @@ const VERSION_ORDER = [
   "es2023",
   "es2024",
   "es2025",
+  "es2026",
 ];
 
+const LATEST_PARSER_VERSION = 2025;
+
 module.exports = {
   ECMA_VERSION_MAP,
   ECMA_VERSION_TO_NUMBER,
   BROWSER_TO_ES_VERSION,
   JS_VERSIONS,
   VERSION_ORDER,
+  LATEST_PARSER_VERSION,
 };

package/lib/detectFeatures.js

@@ -4,8 +4,34 @@ const {
   IMPORT_PATTERNS,
   FEATURE_TO_POLYFILL_MAP,
 } = require("./constants");
+const {
+  POLYFILLABLE_FEATURES,
+  CORE_JS_POLYFILLABLE,
+} = require("./constants/polyfillableFeatures");
 const { detectFeaturesFromAST } = require("./helpers/astDetector");
 
+function getPolyfillableFeatures(library) {
+  if (!library) {
+    return POLYFILLABLE_FEATURES;
+  }
+
+  let normalizedLibrary;
+  try {
+    normalizedLibrary =
+      typeof library === "string"
+        ? library.toLowerCase()
+        : String(library).toLowerCase();
+  } catch {
+    return POLYFILLABLE_FEATURES;
+  }
+
+  if (normalizedLibrary === "core-js") {
+    return CORE_JS_POLYFILLABLE;
+  }
+
+  return POLYFILLABLE_FEATURES;
+}
+
 const detectPolyfills = (
   code,
   polyfills,
@@ -19,7 +45,10 @@ const detectPolyfills = (
       if (pattern.test(code)) polyfills.add(feature);
     }
 
-    if (code.includes("import") && code.includes("core-js")) {
+    const hasCoreJsModuleRef =
+      (code.includes("import") || code.includes("require")) &&
+      code.includes("core-js");
+    if (hasCoreJsModuleRef) {
       for (const { pattern, feature } of importPatterns) {
         if (pattern.test(code)) polyfills.add(feature);
       }
@@ -82,9 +111,6 @@ function detectPolyfillsForFeatures(
   const polyfills = new Set();
   if (!code || !featureMap) return polyfills;
 
-  if (logger?.isLevelEnabled?.("debug")) {
-  }
-
   const polyfillFeatures = Object.entries(featureMap);
   polyfillFeatures.forEach(([feature, patterns]) => {
     const isPolyfilled = patterns.some((pattern) => pattern.test(code));
@@ -109,6 +135,18 @@ const filterPolyfilled = (unsupportedFeatures, polyfills) => {
   return unsupportedFeatures.filter((feature) => !polyfills.has(feature));
 };
 
+const filterPolyfillableFeatures = (
+  unsupportedFeatures,
+  ignorePolyfillable,
+) => {
+  if (!ignorePolyfillable) return unsupportedFeatures;
+
+  const polyfillableSet = getPolyfillableFeatures(ignorePolyfillable);
+  return unsupportedFeatures.filter((feature) => !polyfillableSet.has(feature));
+};
+
 module.exports = detectFeatures;
 module.exports.detectPolyfills = detectPolyfillsForFeatures;
 module.exports.filterPolyfilled = filterPolyfilled;
+module.exports.filterPolyfillableFeatures = filterPolyfillableFeatures;
+module.exports.getPolyfillableFeatures = getPolyfillableFeatures;

package/lib/helpers/ast.js

@@ -14,21 +14,25 @@ function hasOptionsCause(node) {
 }
 
 function checkMap(node, astInfo) {
+  const callee = node.callee;
+  const calleeObject = callee?.object;
+  const calleeProperty = callee?.property;
+  const calleeObjectName = calleeObject?.name;
+  const calleePropertyName = calleeProperty?.name;
+
   const hasKindMismatch = astInfo.kind && node.kind !== astInfo.kind;
   const hasOperatorMismatch =
     astInfo.operator && node.operator !== astInfo.operator;
   const hasCalleeMismatch =
-    astInfo.callee && (!node.callee || node.callee.name !== astInfo.callee);
+    astInfo.callee && (!callee || callee.name !== astInfo.callee);
 
-  const hasCalleeObject = node.callee?.object?.name === astInfo.object;
+  const hasCalleeObject = calleeObjectName === astInfo.object;
   const hasCalleeIdentifier =
-    node.callee?.type === "Identifier" && node.callee?.name === astInfo.object;
+    callee?.type === "Identifier" && callee?.name === astInfo.object;
   const hasPropertyMismatch =
-    astInfo.property && node.callee?.property?.name !== astInfo.property;
-  const hasPropertyMatch = node.callee?.property?.name === astInfo.property;
-  const shouldExclude = astInfo.excludeObjects?.includes(
-    node.callee?.object?.name,
-  );
+    astInfo.property && calleePropertyName !== astInfo.property;
+  const hasPropertyMatch = calleePropertyName === astInfo.property;
+  const shouldExclude = astInfo.excludeObjects?.includes(calleeObjectName);
 
   const needsObjectAndProperty = astInfo.object && astInfo.property;
   const hasObjectAndPropertyMismatch =
@@ -52,6 +56,10 @@ function checkMap(node, astInfo) {
   const hasOptionsCauseMismatch =
     astInfo.hasOptionsCause && !hasOptionsCause(node);
 
+  const callerType = calleeObject?.type;
+  const hasExcludedCallerType =
+    astInfo.excludeCallerTypes?.includes(callerType);
+
   const hasMismatch =
     hasKindMismatch ||
     hasOperatorMismatch ||
@@ -61,7 +69,8 @@ function checkMap(node, astInfo) {
     hasPropertyWithoutMatch ||
     hasPropertyWithExclusion ||
     hasObjectAndPropertyMismatch ||
-    hasOptionsCauseMismatch;
+    hasOptionsCauseMismatch ||
+    hasExcludedCallerType;
 
   if (hasMismatch) return false;
 

package/lib/helpers/astDetector.js

@@ -41,6 +41,7 @@ const CHILD_KEYS = [
   "key",
   "value",
   "superClass",
+  "expressions",
 ];
 
 function normalizeNodeType(nodeType) {
@@ -108,6 +109,10 @@ function matchesFeature(node, astInfo, context = {}) {
     return node.left?.type === "PrivateIdentifier";
   }
 
+  if (astInfo.noParam) {
+    return node.type === "CatchClause" && node.param == null;
+  }
+
   if (node.type === "CallExpression" || node.type === "NewExpression") {
     return checkMap(node, astInfo);
   }

package/lib/helpers/index.js

@@ -22,6 +22,8 @@ module.exports = Object.assign(
     polyfillDetector: {
       detectPolyfills: detectFeaturesModule.detectPolyfills,
       filterPolyfilled: detectFeaturesModule.filterPolyfilled,
+      filterPolyfillableFeatures:
+        detectFeaturesModule.filterPolyfillableFeatures,
     },
   },
 );

package/lib/helpers/parsers.js

@@ -1,11 +1,134 @@
-function parseCode(code, acornOpts, acorn, file) {
+function detectRuntime() {
+  if (typeof Deno !== "undefined") {
+    return "deno";
+  }
+  if (typeof Bun !== "undefined") {
+    return "bun";
+  }
+  return "node";
+}
+
+function stripTypesInNode(code) {
+  const moduleAPI = require("module");
+  if (typeof moduleAPI.stripTypeScriptTypes === "function") {
+    return moduleAPI.stripTypeScriptTypes(code, { mode: "strip" });
+  }
+  throw new Error(
+    "es-check execution on TypeScript files requires Node.js v22.13.0+",
+  );
+}
+
+function buildLineOffsets(original, stripped) {
+  const originalLines = original.split("\n");
+  const strippedLines = stripped.split("\n");
+  const lineCount = Math.max(originalLines.length, strippedLines.length);
+
+  const offsets = [];
+  for (let i = 0; i < lineCount; i++) {
+    const origLen = (originalLines[i] || "").length;
+    const stripLen = (strippedLines[i] || "").length;
+    offsets.push(origLen - stripLen);
+  }
+  return offsets;
+}
+
+function mapPosition(line, column, lineOffsets) {
+  const hasNoOffsets = !lineOffsets || lineOffsets.length === 0;
+  if (hasNoOffsets) return { line, column };
+
+  const lineIndex = line - 1;
+  const isBelowRange = lineIndex < 0;
+  const isAboveRange = lineIndex >= lineOffsets.length;
+  const isOutOfBounds = isBelowRange || isAboveRange;
+  if (isOutOfBounds) return { line, column };
+
+  const offset = lineOffsets[lineIndex];
+  const adjustedColumn = column + offset;
+  return { line, column: adjustedColumn };
+}
+
+function stripTypesInBun(code) {
+  if (typeof Bun !== "undefined" && typeof Bun.Transpiler !== "undefined") {
+    const transpiler = new Bun.Transpiler({ loader: "ts" });
+    const stripped = transpiler.transformSync(code);
+    const lineOffsets = buildLineOffsets(code, stripped);
+    return { code: stripped, lineOffsets };
+  }
+  throw new Error(
+    "es-check execution on TypeScript files requires Bun v1.0.0+",
+  );
+}
+
+function stripTypesInDeno() {
+  throw new Error(
+    "es-check execution on TypeScript files is not supported in Deno (Deno has native TypeScript support)",
+  );
+}
+
+function stripTypeScript(code) {
+  const isInvalidCode = !code || typeof code !== "string";
+  if (isInvalidCode) {
+    return { code, lineOffsets: null };
+  }
+
+  const runtime = detectRuntime();
+  const isNodeRuntime = runtime === "node";
+  const isBunRuntime = runtime === "bun";
+  const isDenoRuntime = runtime === "deno";
+
+  if (isNodeRuntime) {
+    return { code: stripTypesInNode(code), lineOffsets: null };
+  }
+
+  if (isBunRuntime) {
+    return stripTypesInBun(code);
+  }
+
+  if (isDenoRuntime) {
+    return stripTypesInDeno();
+  }
+
+  throw new Error(
+    "es-check execution on TypeScript files is not supported in this runtime",
+  );
+}
+
+function parseCode(code, acornOpts, acorn, file, options = {}) {
+  let processedCode = code;
+  let lineOffsets = null;
+
+  const hasTypeScriptOption = options.typescript || options.ts;
+  const hasTsExtension = file?.endsWith(".ts");
+  const hasTsxExtension = file?.endsWith(".tsx");
+  const isTypeScriptFile = hasTsExtension || hasTsxExtension;
+  const shouldProcessTypeScript = hasTypeScriptOption && isTypeScriptFile;
+
+  if (shouldProcessTypeScript) {
+    const result = stripTypeScript(code);
+    processedCode = result.code;
+    lineOffsets = result.lineOffsets;
+  }
+
   try {
-    const ast = acorn.parse(code, acornOpts);
+    const ast = acorn.parse(processedCode, acornOpts);
     return { ast, error: null };
   } catch (err) {
-    const hasLocation = err.loc && err.loc.line && err.loc.column;
-    const line = hasLocation ? err.loc.line : null;
-    const column = hasLocation ? err.loc.column : null;
+    const errorLocation = err.loc;
+    const hasValidLocation = errorLocation?.line && errorLocation?.column;
+    const hasLineOffsets = lineOffsets !== null;
+    const shouldMapPosition = hasValidLocation && hasLineOffsets;
+
+    const mappedPosition = shouldMapPosition
+      ? mapPosition(errorLocation.line, errorLocation.column, lineOffsets)
+      : null;
+
+    let line = null;
+    let column = null;
+
+    if (hasValidLocation) {
+      line = mappedPosition?.line ?? errorLocation.line;
+      column = mappedPosition?.column ?? errorLocation.column;
+    }
 
     return {
       ast: null,
@@ -22,4 +145,11 @@ function parseCode(code, acornOpts, acorn, file) {
 
 module.exports = {
   parseCode,
+  stripTypeScript,
+  detectRuntime,
+  stripTypesInNode,
+  stripTypesInBun,
+  stripTypesInDeno,
+  buildLineOffsets,
+  mapPosition,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "es-check",
-  "version": "9.5.4",
+  "version": "9.6.0-1",
   "description": "Checks the ECMAScript version of .js glob against a specified version of ECMAScript with a shell command",
   "main": "lib/index.js",
   "license": "MIT",
@@ -27,14 +27,18 @@
     "prepare": "node scripts/install-hooks.mjs",
     "prepublishOnly": "pnpm test",
     "release": "release-it --no-git.requireUpstream",
-    "report:coverage": "mkdir -p coverage && node --test --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage/lcov.info tests/unit/*.test.js tests/unit/helpers/*.test.js tests/unit/helpers/**/*.test.js tests/unit/constants/*.test.js tests/unit/cli/*.test.js tests/unit/check-runner/*.test.js --test-timeout=10000",
-    "test": "node --test tests/unit/*.test.js tests/unit/helpers/*.test.js tests/unit/helpers/**/*.test.js tests/unit/constants/*.test.js tests/unit/cli/*.test.js tests/unit/check-runner/*.test.js --test-timeout=10000 && npm run test:e2e",
+    "report:coverage": "mkdir -p coverage && node tests/scripts/test-runner.js unit --coverage --reporter=lcov",
+    "test": "node tests/scripts/test-runner.js unit && npm run test:e2e",
+    "test:unit": "node tests/scripts/test-runner.js unit",
+    "test:unit:verbose": "node tests/scripts/test-runner.js unit --verbose",
     "test:e2e": "npm run test:e2e:cli && npm run test:e2e:esm && npm run test:e2e:package-files && npm run test:e2e:sourcemap",
+    "test:e2e:typescript": "tests/e2e/typescript/run-tests.sh",
     "test:e2e:cli": "node tests/e2e/test-cli.js",
     "test:e2e:esm": "node tests/e2e/test-esm-import.mjs",
     "test:e2e:package-files": "node tests/e2e/test-package-files.mjs",
     "test:e2e:sourcemap": "node --test tests/e2e/test-sourcemap.js --test-timeout=10000",
-    "update": "codependence --update && pastoralist",
+    "generate-parser-requirements": "node scripts/generate-parser-requirements.js",
+    "update": "codependence --update && pastoralist && pnpm run generate-parser-requirements",
     "benchmark": "./tests/benchmarks/run-benchmarks.sh",
     "site:dev": "pnpm --filter es-check-docs run dev",
     "site:build": "pnpm --filter es-check-docs run build",
@@ -52,15 +56,16 @@
   "homepage": "https://github.com/yowainwright/es-check#readme",
   "website": "https://jeffry.in/es-check",
   "devDependencies": {
-    "codependence": "1.0.0-1",
-    "oxlint": "^1.29.0",
+    "@mdn/browser-compat-data": "^7.3.3",
+    "browserslist": "^4.28.1",
+    "codependence": "0.3.1",
+    "oxlint": "^1.49.0",
     "pastoralist": "1.10.0-1",
-    "prettier": "3.7.4",
-    "release-it": "19.2.3"
+    "prettier": "3.8.1",
+    "release-it": "19.2.4"
   },
   "dependencies": {
-    "acorn": "8.15.0",
-    "browserslist": "^4.28.0",
+    "acorn": "8.16.0",
     "fast-glob": "^3.3.3"
   },
   "engines": {
@@ -109,7 +114,7 @@
       "after:release": "echo Successfully released ${name} v${version} to ${repo.repository}."
     }
   },
-  "packageManager": "pnpm@10.27.0",
+  "packageManager": "pnpm@10.30.0",
   "pastoralist": {
     "appendix": {
       "vite@6.4.1": {
@@ -159,6 +164,50 @@
           "severity": "low",
           "url": "https://github.com/yowainwright/es-check/security/dependabot/57"
         }
+      },
+      "devalue@5.6.3": {
+        "dependents": {
+          "es-check": "devalue (transitive dependency)"
+        },
+        "ledger": {
+          "addedDate": "2026-02-21T00:23:12.264Z",
+          "reason": "Security fix: devalue `uneval`ed code can create objects with polluted prototypes when `eval`ed (low)",
+          "securityChecked": true,
+          "securityCheckDate": "2026-02-21T00:23:12.264Z",
+          "securityProvider": "github",
+          "severity": "low",
+          "url": "https://github.com/yowainwright/es-check/security/dependabot/66"
+        }
+      },
+      "lodash@4.17.23": {
+        "dependents": {
+          "es-check": "lodash (transitive dependency)"
+        },
+        "ledger": {
+          "addedDate": "2026-02-21T00:23:12.264Z",
+          "reason": "Security fix: Lodash has Prototype Pollution Vulnerability in `_.unset` and `_.omit` functions (medium)",
+          "securityChecked": true,
+          "securityCheckDate": "2026-02-21T00:23:12.264Z",
+          "securityProvider": "github",
+          "cve": "CVE-2025-13465",
+          "severity": "medium",
+          "url": "https://github.com/yowainwright/es-check/security/dependabot/63"
+        }
+      },
+      "diff@5.2.2": {
+        "dependents": {
+          "es-check": "diff (transitive dependency)"
+        },
+        "ledger": {
+          "addedDate": "2026-02-21T00:23:12.264Z",
+          "reason": "Security fix: jsdiff has a Denial of Service vulnerability in parsePatch and applyPatch (low)",
+          "securityChecked": true,
+          "securityCheckDate": "2026-02-21T00:23:12.264Z",
+          "securityProvider": "github",
+          "cve": "CVE-2026-24001",
+          "severity": "low",
+          "url": "https://github.com/yowainwright/es-check/security/dependabot/61"
+        }
       }
     },
     "depPaths": [
@@ -174,13 +223,17 @@
       "hasWorkspaceSecurityChecks": true
     }
   },
-  "pnpm": {
-    "overrides": {
-      "vite": "6.4.1",
-      "tmp": "0.2.4",
-      "js-yaml": "4.1.1",
-      "mdast-util-to-hast": "13.2.1",
-      "undici": "6.23.0"
-    }
-  }
+  "overrides": {
+    "vite": "6.4.1",
+    "tmp": "0.2.4",
+    "js-yaml": "4.1.1",
+    "mdast-util-to-hast": "13.2.1",
+    "undici": "6.23.0",
+    "devalue": "5.6.3",
+    "lodash": "4.17.23",
+    "diff": "5.2.2"
+  },
+  "workspaces": [
+    "site"
+  ]
 }