Entry Points

/**
 * Maps core-js entry points to required modules
 * Each entry point corresponds to a core-js import path
 */
const entries: {
  [entry_point: string]: readonly ModuleName[]
};

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

// Get modules for specific entry point
const actualModules = entries['core-js/actual'];
console.log(actualModules.slice(0, 5));
// ['es.symbol', 'es.symbol.description', 'es.symbol.async-iterator', ...]

// Find entry points containing specific module
function findEntryPoints(moduleName) {
  return Object.keys(entries).filter(entry => 
    entries[entry].includes(moduleName)
  );
}

console.log(findEntryPoints('es.array.at'));
// ['core-js/actual', 'core-js/stable', 'core-js/es', ...]

// All stable and proposed features
const actual = entries['core-js/actual'];
console.log(`${actual.length} modules in core-js/actual`);

// Only stable features
const stable = entries['core-js/stable'];  
console.log(`${stable.length} modules in core-js/stable`);

// All ES standard features
const es = entries['core-js/es'];
console.log(`${es.length} modules in core-js/es`);

// Proposed features only
const proposals = entries['core-js/proposals'];
console.log(`${proposals.length} modules in core-js/proposals`);

// Array methods
const arrayMethods = entries['core-js/actual/array'];
console.log(arrayMethods);
// ['es.array.at', 'es.array.concat', 'es.array.find', ...]

// Object methods  
const objectMethods = entries['core-js/actual/object'];
console.log(objectMethods);
// ['es.object.assign', 'es.object.create', 'es.object.keys', ...]

// Promise features
const promiseFeatures = entries['core-js/actual/promise'];
console.log(promiseFeatures);
// ['es.promise', 'es.promise.all-settled', 'es.promise.any', ...]

// Web platform features
const webFeatures = entries['core-js/web'];
console.log(webFeatures);
// ['web.atob', 'web.btoa', 'web.dom-exception.constructor', ...]

// Stage 4 proposals (becoming standard)
const stage4 = entries['core-js/stage/4'];
console.log(stage4);

// Stage 3 proposals  
const stage3 = entries['core-js/stage/3'];
console.log(stage3);

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

// Analyze entry point hierarchy
function analyzeEntryPoints() {
  const analysis = {
    total: Object.keys(entries).length,
    byPath: {},
    byModuleCount: {}
  };
  
  Object.entries(entries).forEach(([path, modules]) => {
    // Group by path prefix
    const prefix = path.split('/')[1] || 'root';
    if (!analysis.byPath[prefix]) analysis.byPath[prefix] = 0;
    analysis.byPath[prefix]++;
    
    // Group by module count
    const count = modules.length;
    const range = count < 10 ? 'small' : count < 50 ? 'medium' : 'large';
    if (!analysis.byModuleCount[range]) analysis.byModuleCount[range] = 0;
    analysis.byModuleCount[range]++;
  });
  
  return analysis;
}

console.log(analyzeEntryPoints());
// { total: 156, byPath: { actual: 45, stable: 42, ... }, ... }

// Find smallest entry point containing required modules
function findMinimalEntryPoint(requiredModules) {
  let best = null;
  let minSize = Infinity;
  
  Object.entries(entries).forEach(([entry, modules]) => {
    const hasAll = requiredModules.every(mod => modules.includes(mod));
    if (hasAll && modules.length < minSize) {
      best = entry;
      minSize = modules.length;
    }
  });
  
  return best;
}

// Example usage
const needed = ['es.array.at', 'es.object.has-own'];
const minimal = findMinimalEntryPoint(needed);
console.log(`Best entry point: ${minimal}`);

// Categorize entry points by stability
function categorizeByStability() {
  const categories = {
    stable: [],      // Standardized features
    stage4: [],      // Stage 4 proposals (becoming standard)
    stage3: [],      // Stage 3 proposals
    stage2: [],      // Stage 2 proposals  
    stage1: [],      // Stage 1 proposals
    experimental: [] // Earlier stage or experimental
  };
  
  Object.keys(entries).forEach(entry => {
    if (entry.includes('/stable')) categories.stable.push(entry);
    else if (entry.includes('/stage/4')) categories.stage4.push(entry);
    else if (entry.includes('/stage/3')) categories.stage3.push(entry);
    else if (entry.includes('/stage/2')) categories.stage2.push(entry);
    else if (entry.includes('/stage/1')) categories.stage1.push(entry);
    else if (entry.includes('proposals')) categories.experimental.push(entry);
  });
  
  return categories;
}

// Group entry points by feature area
function groupByFeature() {
  const features = {};
  
  Object.keys(entries).forEach(entry => {
    const parts = entry.split('/');
    if (parts.length >= 3) {
      const feature = parts[2]; // e.g., 'array', 'object', 'promise'
      if (!features[feature]) features[feature] = [];
      features[feature].push(entry);
    }
  });
  
  return features;
}

console.log(Object.keys(groupByFeature()));
// ['array', 'object', 'promise', 'string', 'symbol', ...]

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

// Get required modules for specific entry point
function getRequiredFromEntry(entryPoint, targets) {
  const entryModules = entries[entryPoint];
  if (!entryModules) return null;
  
  const result = compat({
    targets,
    modules: entryModules
  });
  
  return result;
}

// Example: Only load array polyfills needed for IE 11
const arrayPolyfills = getRequiredFromEntry('core-js/es/array', { ie: '11' });
console.log(arrayPolyfills.list);

// Find best entry points for bundle size optimization
function optimizeBundle(requiredModules, targets) {
  // Find all entry points that cover required modules
  const candidates = Object.entries(entries).filter(([entry, modules]) =>
    requiredModules.every(req => modules.includes(req))
  );
  
  // Analyze each candidate
  const analysis = candidates.map(([entry, modules]) => {
    const result = compat({
      targets,
      modules: modules
    });
    
    return {
      entry,
      totalModules: modules.length,
      requiredModules: result.list.length,
      efficiency: result.list.length / modules.length
    };
  });
  
  // Sort by efficiency (most required modules per total module)
  return analysis.sort((a, b) => b.efficiency - a.efficiency);
}

// Different strategies for different environments
const strategies = {
  development: {
    // Use comprehensive entry points for better debugging
    entryPoint: 'core-js/actual',
    rationale: 'Include all features for development convenience'
  },
  
  production: {
    // Use targeted entry points for smaller bundles
    analyze: (targets) => {
      const result = compat({ targets });
      return {
        entryPoint: findMinimalEntryPoint(result.list),
        savings: `Reduced from ${entries['core-js/actual'].length} to ${result.list.length} modules`
      };
    }
  }
};