es-check 9.6.4 → 9.7.2

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

@@ -10,29 +10,29 @@ 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,
-  FEATURE_TO_POLYFILL_MAP,
-} = require("./polyfills");
+const { ES_GLOBAL_MIN_VERSION, ES_GLOBALS_SOURCE } = require("./globals");
+const { POLYFILL_PATTERNS, IMPORT_PATTERNS, FEATURE_TO_POLYFILL_MAP } = require("./polyfills");
 
-const ES_FEATURES = {
-  ...ES6_FEATURES,
-  ...ES7_FEATURES,
-  ...ES8_FEATURES,
-  ...ES9_FEATURES,
-  ...ES10_FEATURES,
-  ...ES11_FEATURES,
-  ...ES12_FEATURES,
-  ...ES13_FEATURES,
-  ...ES14_FEATURES,
-  ...ES15_FEATURES,
-  ...ES16_FEATURES,
-  ...ES17_FEATURES,
-};
+const ES_FEATURES = Object.assign(
+  {},
+  ES6_FEATURES,
+  ES7_FEATURES,
+  ES8_FEATURES,
+  ES9_FEATURES,
+  ES10_FEATURES,
+  ES11_FEATURES,
+  ES12_FEATURES,
+  ES13_FEATURES,
+  ES14_FEATURES,
+  ES15_FEATURES,
+  ES16_FEATURES,
+  ES17_FEATURES,
+);
 
 module.exports = {
   ES_FEATURES,
+  ES_GLOBAL_MIN_VERSION,
+  ES_GLOBALS_SOURCE,
   POLYFILL_PATTERNS,
   IMPORT_PATTERNS,
   FEATURE_TO_POLYFILL_MAP,

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

@@ -14,13 +14,11 @@ const POLYFILL_PATTERNS = [
 
 const IMPORT_PATTERNS = [
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.to-sorted['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.to-sorted['"]/,
     feature: "ArrayToSorted",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.find-last['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.find-last['"]/,
     feature: "ArrayFindLast",
   },
   {
@@ -29,8 +27,7 @@ const IMPORT_PATTERNS = [
     feature: "ArrayFindLastIndex",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.at['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.array\.at['"]/,
     feature: "ArrayAt",
   },
   {
@@ -39,33 +36,27 @@ const IMPORT_PATTERNS = [
     feature: "StringReplaceAll",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.string\.match-all['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.string\.match-all['"]/,
     feature: "StringMatchAll",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.string\.at['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.string\.at['"]/,
     feature: "StringAt",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.object\.has-own['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.object\.has-own['"]/,
     feature: "ObjectHasOwn",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.promise\.any['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.promise\.any['"]/,
     feature: "PromiseAny",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.regexp\.exec['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.regexp\.exec['"]/,
     feature: "RegExpExec",
   },
   {
-    pattern:
-      /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.global-this['"]/,
+    pattern: /(?:from\s+|require\s*\(\s*|import\s+)['"]core-js\/modules\/es\.global-this['"]/,
     feature: "GlobalThis",
   },
 ];
@@ -94,11 +85,7 @@ const FEATURE_TO_POLYFILL_MAP = {
     /['"]core-js\/modules\/es\.object\.assign['"]/,
     /\bobject-assign\b/,
   ],
-  Promise: [
-    /\bPromise\s*=/,
-    /['"]core-js\/modules\/es\.promise['"]/,
-    /es6-promise/,
-  ],
+  Promise: [/\bPromise\s*=/, /['"]core-js\/modules\/es\.promise['"]/, /es6-promise/],
   "String.prototype.startsWith": [
     /\bString\.prototype\.startsWith\s*=/,
     /['"]core-js\/modules\/es\.string\.starts-with['"]/,
@@ -122,14 +109,8 @@ const FEATURE_TO_POLYFILL_MAP = {
     /['"]core-js\/modules\/es\.array\.includes['"]/,
   ],
 
-  "Object.values": [
-    /\bObject\.values\s*=/,
-    /['"]core-js\/modules\/es\.object\.values['"]/,
-  ],
-  "Object.entries": [
-    /\bObject\.entries\s*=/,
-    /['"]core-js\/modules\/es\.object\.entries['"]/,
-  ],
+  "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['"]/,
@@ -180,10 +161,7 @@ const FEATURE_TO_POLYFILL_MAP = {
   globalThis: [/\bglobalThis\s*=/, /['"]core-js\/modules\/es\.global-this['"]/],
   BigInt: [/\bBigInt\s*=/, /['"]core-js\/modules\/es\.bigint['"]/],
 
-  "Promise.any": [
-    /\bPromise\.any\s*=/,
-    /['"]core-js\/modules\/es\.promise\.any['"]/,
-  ],
+  "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['"]/,
@@ -238,10 +216,7 @@ const FEATURE_TO_POLYFILL_MAP = {
     /\bcore[-_]js[-_]modules[-_][^/\n]*array[-_]with/,
   ],
 
-  "Object.hasOwn": [
-    /\bObject\.hasOwn\s*=/,
-    /['"]core-js\/modules\/es\.object\.has-own['"]/,
-  ],
+  "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['"]/,
@@ -259,10 +234,7 @@ const FEATURE_TO_POLYFILL_MAP = {
     /\bArray\.prototype\.groupToMap\s*=/,
     /['"]core-js\/modules\/es\.array\.group-to-map['"]/,
   ],
-  "Promise.try": [
-    /\bPromise\.try\s*=/,
-    /['"]core-js\/modules\/es\.promise\.try['"]/,
-  ],
+  "Promise.try": [/\bPromise\.try\s*=/, /['"]core-js\/modules\/es\.promise\.try['"]/],
 
   "Array.fromAsync": [
     /\bArray\.fromAsync\s*=/,

package/lib/constants/featureParserMapping.js

@@ -20,19 +20,14 @@ function getParserVersionForFeature(featureName, targetEsVersion) {
   return Math.max(targetEsVersion, requiredParser);
 }
 
-function getMinimumParserVersion(
-  targetEsVersion,
-  enableFeatureDetection = false,
-) {
+function getMinimumParserVersion(targetEsVersion, enableFeatureDetection = false) {
   if (!enableFeatureDetection) {
     return targetEsVersion;
   }
 
   let minParserVersion = targetEsVersion;
 
-  for (const [_feature, requiredParser] of Object.entries(
-    FEATURE_PARSER_REQUIREMENTS,
-  )) {
+  for (const [_feature, requiredParser] of Object.entries(FEATURE_PARSER_REQUIREMENTS)) {
     if (targetEsVersion >= requiredParser) {
       minParserVersion = Math.max(minParserVersion, requiredParser);
     }

package/lib/constants/index.js

@@ -1,4 +1,62 @@
 const versions = require("./versions");
 const esFeatures = require("./es-features");
 
-module.exports = Object.assign({}, versions, esFeatures);
+const receiverHeuristics = {
+  ARRAY_CONSTRUCTOR_FUNCTIONS: new Set(["Array", "from", "of", "slice", "filter", "map", "concat"]),
+  ARRAY_LIKE_NAMES: new Set(["arr", "array", "list", "items", "values", "arguments"]),
+  ARRAY_METHODS: new Set(["slice", "filter", "map", "concat", "from", "of"]),
+  COMMON_NON_ARRAY_NAMES: new Set([
+    "obj",
+    "object",
+    "foo",
+    "bar",
+    "baz",
+    "data",
+    "config",
+    "options",
+    "params",
+    "props",
+    "state",
+    "item",
+    "element",
+    "node",
+    "target",
+    "source",
+    "result",
+    "response",
+    "request",
+    "payload",
+    "model",
+    "view",
+    "controller",
+    "service",
+    "utils",
+    "helpers",
+    "custom",
+  ]),
+  COMMON_NON_SET_NAMES: new Set([
+    "settings",
+    "setup",
+    "setter",
+    "setstate",
+    "setvalue",
+    "setdata",
+    "setitem",
+    "setinterval",
+    "settimeout",
+    "offset",
+    "dataset",
+    "reset",
+    "asset",
+    "charset",
+    "onset",
+    "subset",
+    "mindset",
+    "closet",
+    "baseset",
+  ]),
+  MAP_CONSTRUCTORS: new Set(["Map", "WeakMap"]),
+  SET_LIKE_NAMES: new Set(["set", "sets", "seta", "setb", "set1", "set2"]),
+};
+
+module.exports = Object.assign({}, versions, esFeatures, receiverHeuristics);

package/lib/constants/polyfillableFeatures.js

@@ -22,10 +22,16 @@ const coreJsPolyfillable = new Set([
   "ArrayToSorted",
   "ArrayToSpliced",
   "ArrayWith",
+  "DataViewGetFloat16",
+  "DataViewSetFloat16",
   "ErrorCause",
   "ErrorIsError",
+  "IteratorConcat",
   "Map",
+  "MapGetOrInsert",
+  "MapGetOrInsertComputed",
   "MapGroupBy",
+  "MathSumPrecise",
   "ObjectEntries",
   "ObjectFromEntries",
   "ObjectGroupBy",
@@ -55,6 +61,12 @@ const coreJsPolyfillable = new Set([
   "StringReplaceAll",
   "StringToWellFormed",
   "Symbol",
+  "Uint8ArrayFromBase64",
+  "Uint8ArrayFromHex",
+  "Uint8ArraySetFromBase64",
+  "Uint8ArraySetFromHex",
+  "Uint8ArrayToBase64",
+  "Uint8ArrayToHex",
   "WeakMap",
   "WeakSet",
   "globalThis",

package/lib/constants/versions.js

@@ -223,7 +223,7 @@ const VERSION_ORDER = [
   "es2026",
 ];
 
-const LATEST_PARSER_VERSION = 2025;
+const LATEST_PARSER_VERSION = 2026;
 
 module.exports = {
   ECMA_VERSION_MAP,

package/lib/detectFeatures.js

@@ -4,10 +4,8 @@ const {
   IMPORT_PATTERNS,
   FEATURE_TO_POLYFILL_MAP,
 } = require("./constants");
-const {
-  POLYFILLABLE_FEATURES,
-  CORE_JS_POLYFILLABLE,
-} = require("./constants/polyfillableFeatures");
+const { ES_GLOBAL_MIN_VERSION } = require("./constants/es-features/globals");
+const { POLYFILLABLE_FEATURES, CORE_JS_POLYFILLABLE } = require("./constants/polyfillableFeatures");
 const { detectFeaturesFromAST } = require("./helpers/astDetector");
 
 function getPolyfillableFeatures(library) {
@@ -18,9 +16,7 @@ function getPolyfillableFeatures(library) {
   let normalizedLibrary;
   try {
     normalizedLibrary =
-      typeof library === "string"
-        ? library.toLowerCase()
-        : String(library).toLowerCase();
+      typeof library === "string" ? library.toLowerCase() : String(library).toLowerCase();
   } catch {
     return POLYFILLABLE_FEATURES;
   }
@@ -35,19 +31,16 @@ function getPolyfillableFeatures(library) {
 const detectPolyfills = (
   code,
   polyfills,
-  {
-    polyfillPatterns = POLYFILL_PATTERNS,
-    importPatterns = IMPORT_PATTERNS,
-  } = {},
+  { polyfillPatterns = POLYFILL_PATTERNS, importPatterns = IMPORT_PATTERNS } = {},
 ) => {
-  if (code.includes("core-js") || code.includes("polyfill")) {
+  const hasPolyfillHint = code.includes("core-js") || code.includes("polyfill");
+  if (hasPolyfillHint) {
     for (const { pattern, feature } of polyfillPatterns) {
       if (pattern.test(code)) polyfills.add(feature);
     }
 
     const hasCoreJsModuleRef =
-      (code.includes("import") || code.includes("require")) &&
-      code.includes("core-js");
+      (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);
@@ -56,13 +49,7 @@ const detectPolyfills = (
   }
 };
 
-const detectFeatures = (
-  code,
-  ecmaVersion,
-  sourceType,
-  ignoreList = new Set(),
-  options = {},
-) => {
+const detectFeatures = (code, ecmaVersion, sourceType, ignoreList = new Set(), options = {}) => {
   const { checkForPolyfills, ast, ignorePolyfillable } = options;
 
   if (!ast) {
@@ -76,21 +63,32 @@ const detectFeatures = (
 
   const foundFeatures = detectFeaturesFromAST(ast);
 
-  const polyfillableSet = ignorePolyfillable
-    ? getPolyfillableFeatures(ignorePolyfillable)
-    : null;
-
-  const unsupportedFeatures = Object.entries(ES_FEATURES)
-    .filter(
-      ([name, { minVersion }]) =>
-        foundFeatures[name] &&
-        minVersion > ecmaVersion &&
-        !ignoreList.has(name) &&
-        !(checkForPolyfills && polyfills.has(name)) &&
-        !(polyfillableSet && polyfillableSet.has(name)),
-    )
+  const polyfillableSet = ignorePolyfillable ? getPolyfillableFeatures(ignorePolyfillable) : null;
+
+  function isUnsupportedFeature(name, minVersion) {
+    const wasFound = foundFeatures[name];
+    const requiresHigherVersion = minVersion > ecmaVersion;
+    const isIgnored = ignoreList.has(name);
+    const isPolyfilled = checkForPolyfills && polyfills.has(name);
+    const isPolyfillableIgnored = polyfillableSet && polyfillableSet.has(name);
+
+    const isAllowed = isIgnored || isPolyfilled || isPolyfillableIgnored;
+    const shouldReport = wasFound && requiresHigherVersion;
+    if (!shouldReport) return false;
+    return !isAllowed;
+  }
+
+  const unsupportedStandardFeatures = Object.entries(ES_FEATURES)
+    .filter(([name, { minVersion }]) => isUnsupportedFeature(name, minVersion))
+    .map(([name]) => name);
+
+  const unsupportedGlobalFeatures = Object.entries(ES_GLOBAL_MIN_VERSION)
+    .filter(([name]) => !ES_FEATURES[name])
+    .filter(([name, minVersion]) => isUnsupportedFeature(name, minVersion))
     .map(([name]) => name);
 
+  const unsupportedFeatures = unsupportedStandardFeatures.concat(unsupportedGlobalFeatures);
+
   if (unsupportedFeatures.length > 0) {
     const error = new Error(
       `Unsupported features detected: ${unsupportedFeatures.join(", ")}. ` +
@@ -108,42 +106,48 @@ const detectFeatures = (
   };
 };
 
-function detectPolyfillsForFeatures(
-  code,
-  logger,
-  featureMap = FEATURE_TO_POLYFILL_MAP,
-) {
+function detectPolyfillsForFeatures(code, logger, featureMap = FEATURE_TO_POLYFILL_MAP) {
   const polyfills = new Set();
-  if (!code || !featureMap) return polyfills;
+  const hasNoPolyfillInput = !code || !featureMap;
+  if (hasNoPolyfillInput) return polyfills;
 
   const polyfillFeatures = Object.entries(featureMap);
-  polyfillFeatures.forEach(([feature, patterns]) => {
-    const isPolyfilled = patterns.some((pattern) => pattern.test(code));
+  let index = 0;
+  while (index < polyfillFeatures.length) {
+    const [feature, patterns] = polyfillFeatures[index];
+    const isPolyfilled = hasMatchingPattern(code, patterns);
     if (isPolyfilled) polyfills.add(feature);
-  });
+    index += 1;
+  }
 
   if (logger?.isLevelEnabled?.("debug")) {
     const hasPolyfills = polyfills.size > 0;
     if (hasPolyfills)
-      logger.debug(
-        `ES-Check: Detected polyfills: ${Array.from(polyfills).join(", ")}`,
-      );
+      logger.debug(`ES-Check: Detected polyfills: ${Array.from(polyfills).join(", ")}`);
     else logger.debug("ES-Check: No polyfills detected.");
   }
 
   return polyfills;
 }
 
+function hasMatchingPattern(code, patterns) {
+  let index = 0;
+  while (index < patterns.length) {
+    const pattern = patterns[index];
+    if (pattern.test(code)) return true;
+    index += 1;
+  }
+
+  return false;
+}
+
 const filterPolyfilled = (unsupportedFeatures, polyfills) => {
   const hasPolyfills = polyfills && polyfills.size > 0;
   if (!hasPolyfills) return unsupportedFeatures;
   return unsupportedFeatures.filter((feature) => !polyfills.has(feature));
 };
 
-const filterPolyfillableFeatures = (
-  unsupportedFeatures,
-  ignorePolyfillable,
-) => {
+const filterPolyfillableFeatures = (unsupportedFeatures, ignorePolyfillable) => {
   if (!ignorePolyfillable) return unsupportedFeatures;
 
   const polyfillableSet = getPolyfillableFeatures(ignorePolyfillable);