Compatibility Data

/**
 * Complete compatibility data for all core-js modules
 * Maps module names to their minimum browser support versions
 */
const data: CompatData;

interface CompatData {
  [module: ModuleName]: {
    [target in Target]?: TargetVersion
  };
}

const { data } = require('core-js-compat');

// Check support for specific module
const arrayAtSupport = data['es.array.at'];
console.log(arrayAtSupport);
// { chrome: '92', firefox: '90', safari: '15.4', ... }

// Find modules supporting specific browser
const chromeModules = Object.keys(data).filter(module => 
  data[module].chrome && data[module].chrome <= '80'
);

// Check if module needs polyfill for target
function needsPolyfill(moduleName, target, version) {
  const moduleData = data[moduleName];
  if (!moduleData || !moduleData[target]) return true;
  return compareVersions(version, '<', moduleData[target]);
}

// ES6+ Standard Features (es.*)
const esModules = Object.keys(data).filter(name => name.startsWith('es.'));
console.log(esModules.slice(0, 5));
// ['es.symbol', 'es.symbol.constructor', 'es.symbol.description', ...]

// Proposed Features (esnext.*)  
const esnextModules = Object.keys(data).filter(name => name.startsWith('esnext.'));
console.log(esnextModules.slice(0, 5));
// ['esnext.array.group', 'esnext.array.group-by', ...]

// Web Platform Features (web.*)
const webModules = Object.keys(data).filter(name => name.startsWith('web.'));
console.log(webModules.slice(0, 5));
// ['web.atob', 'web.btoa', 'web.dom-exception.constructor', ...]

// Find all supported targets for a module
function getTargetsForModule(moduleName) {
  const moduleData = data[moduleName];
  return moduleData ? Object.keys(moduleData) : [];
}

// Example usage
console.log(getTargetsForModule('es.array.at'));
// ['chrome', 'firefox', 'safari', 'ios', 'node', ...]

// Modern array methods
console.log(data['es.array.at']);
// { chrome: '92', firefox: '90', safari: '15.4', ios: '15.4', node: '16.6.0' }

console.log(data['es.array.find-last']);
// { chrome: '97', firefox: '104', safari: '15.4', ios: '15.4', node: '18.0.0' }

console.log(data['es.array.includes']);  
// { chrome: '47', firefox: '43', safari: '9.0', ios: '9.0', node: '6.0.0' }

// Object static methods
console.log(data['es.object.has-own']);
// { chrome: '93', firefox: '92', safari: '15.4', ios: '15.4', node: '16.9.0' }

console.log(data['es.object.keys']);
// { chrome: '5', firefox: '4', safari: '5.0', ios: '5.0', node: '0.10.0' }

// Promise API
console.log(data['es.promise.constructor']);
// { chrome: '32', firefox: '29', safari: '8.0', ios: '8.0', node: '0.12.0' }

console.log(data['es.promise.all-settled']);
// { chrome: '76', firefox: '71', safari: '13.0', ios: '13.0', node: '12.9.0' }

// Symbol functionality
console.log(data['es.symbol.constructor']);
// { chrome: '41', firefox: '36', safari: '9.0', ios: '9.0', node: '0.12.0' }

console.log(data['es.symbol.async-iterator']);
// { chrome: '63', firefox: '55', safari: '12.0', ios: '12.0', node: '10.0.0' }

const { data } = require('core-js-compat');

// Find modules compatible with specific browser version
function getCompatibleModules(target, version) {
  return Object.keys(data).filter(module => {
    const moduleData = data[module];
    return moduleData[target] && 
           compareVersions(version, '>=', moduleData[target]);
  });
}

// Find modules that need polyfills
function getRequiredModules(targets) {
  const required = [];
  
  Object.keys(data).forEach(module => {
    const moduleData = data[module];
    let needsPolyfill = false;
    
    Object.entries(targets).forEach(([target, version]) => {
      if (!moduleData[target] || 
          compareVersions(version, '<', moduleData[target])) {
        needsPolyfill = true;
      }
    });
    
    if (needsPolyfill) required.push(module);
  });
  
  return required;
}

// Count modules by category
const stats = {
  es: 0,
  esnext: 0, 
  web: 0,
  other: 0
};

Object.keys(data).forEach(module => {
  if (module.startsWith('es.')) stats.es++;
  else if (module.startsWith('esnext.')) stats.esnext++;
  else if (module.startsWith('web.')) stats.web++;
  else stats.other++;
});

console.log(stats);
// { es: 280, esnext: 45, web: 12, other: 3 }

// Find most/least supported modules
function getSupportStats() {
  const supportCounts = {};
  
  Object.entries(data).forEach(([module, targets]) => {
    supportCounts[module] = Object.keys(targets).length;
  });
  
  const sorted = Object.entries(supportCounts)
    .sort(([,a], [,b]) => b - a);
    
  return {
    mostSupported: sorted.slice(0, 10),
    leastSupported: sorted.slice(-10)
  };
}

// Version formats in data
const examples = {
  'es.array.at': data['es.array.at'],
  // { chrome: '92', firefox: '90', safari: '15.4', node: '16.6.0' }
  
  'es.symbol.async-dispose': data['es.symbol.async-dispose']
  // { chrome: '127', firefox: '135', node: '20.5.0' }
};

// Range versions (rare cases)
console.log(data['es.error.cause']);
// May include ranges like '14.5-14.8' for some targets

// Helper to compare versions (implementation depends on semver library)
function compareVersions(a, operator, b) {
  // This would typically use a library like 'semver' or 'compare-versions'
  // For basic comparison:
  const parseVersion = v => v.split('.').map(Number);
  const [aMajor, aMinor = 0, aPatch = 0] = parseVersion(a);
  const [bMajor, bMinor = 0, bPatch = 0] = parseVersion(b);
  
  const aNum = aMajor * 10000 + aMinor * 100 + aPatch;
  const bNum = bMajor * 10000 + bMinor * 100 + bPatch;
  
  switch (operator) {
    case '<': return aNum < bNum;
    case '<=': return aNum <= bNum;
    case '>': return aNum > bNum;
    case '>=': return aNum >= bNum;
    case '=': case '==': return aNum === bNum;
    default: return false;
  }
}