versacompiler 2.1.0 → 2.3.0

package/dist/compiler/module-resolution-optimizer.js

@@ -1 +1,888 @@
-import{createHash as e}from"node:crypto";import{existsSync as i,readFileSync as a,readdirSync as o,statSync as s}from"node:fs";import{dirname as c,join as l,relative as u}from"node:path";import{cwd as d,env as f}from"node:process";import{logger as p}from"../servicios/logger.js";import{EXCLUDED_MODULES as m}from"../utils/excluded-modules.js";export class ModuleResolutionOptimizer{static instance;moduleIndex=new Map;resolutionCache=new Map;cacheOrder=[];aliasIndex=[];nodeModulesCache=new Map;metrics={totalResolutions:0,cacheHits:0,cacheMisses:0,averageResolveTime:0,indexLookups:0,filesystemAccess:0,aliasMatches:0};maxCacheSize=500;cacheMaxAge=300*1e3;indexRefreshInterval=600*1e3;excludedModules=m;lastIndexUpdate=0;constructor(){this.initializeIndexes(),this.setupPeriodicRefresh()}static getInstance(){return ModuleResolutionOptimizer.instance||(ModuleResolutionOptimizer.instance=new ModuleResolutionOptimizer),ModuleResolutionOptimizer.instance}initializeIndexes(){let e=performance.now();try{this.buildModuleIndex(),this.buildAliasIndex(),this.lastIndexUpdate=Date.now();let i=performance.now()-e;f.VERBOSE===`true`&&(p.info(`🚀 Índices de resolución construidos en ${i.toFixed(2)}ms`),p.info(`📦 ${this.moduleIndex.size} módulos indexados`),p.info(`🔗 ${this.aliasIndex.length} alias indexados`))}catch(e){p.error(`Error inicializando índices de resolución:`,e)}}buildModuleIndex(){let e=l(d(),`node_modules`);if(i(e))try{let i=this.discoverModules(e);for(let e of i)this.moduleIndex.set(e.name,{fullPath:e.fullPath,entryPoint:e.entryPoint,packageJson:e.packageJson,isESM:e.isESM,hasExports:e.hasExports,optimizedEntry:e.optimizedEntry,lastModified:e.lastModified});f.VERBOSE===`true`&&p.info(`📚 Índice de módulos construido: ${this.moduleIndex.size} entradas`)}catch(e){p.error(`Error construyendo índice de módulos:`,e)}}discoverModules(e){let i=[];try{let a=o(e);this.metrics.filesystemAccess++;for(let s of a){let a=l(e,s);try{if(s.startsWith(`/dist/examples`)){let e=o(a);this.metrics.filesystemAccess++;for(let o of e){let e=l(a,o),c=this.analyzeModule(`${s}/${o}`,e);c&&i.push(c)}}else{let e=this.analyzeModule(s,a);e&&i.push(e)}}catch{continue}}}catch(e){p.error(`Error descubriendo módulos:`,e)}return i}analyzeModule(e,o){try{let c=l(o,`package.json`);if(!i(c))return null;let u=s(c);this.metrics.filesystemAccess++;let d=JSON.parse(a(c,`utf-8`));this.metrics.filesystemAccess++;let f=d.type===`module`,p=!!d.exports,m=this.determineOptimalEntryPoint(d),h;return m&&(h=this.findOptimalESMVersion(o,m)),{name:e,fullPath:o,entryPoint:m||`index.js`,packageJson:d,isESM:f,hasExports:p,optimizedEntry:h,lastModified:u.mtime.getTime()}}catch{return null}}determineOptimalEntryPoint(e){let i=null;if(e.module)i=e.module;else if(e.exports){if(typeof e.exports==`string`)i=e.exports;else if(e.exports[`.`]){let a=e.exports[`.`];typeof a==`string`?i=a:typeof a==`object`&&(i=a.import||a.browser||a.default)}}else i=e.browser&&typeof e.browser==`string`?e.browser:e.main||null;return i&&(i=this.validateAndOptimizeEntryPoint(i,e)),i}validateAndOptimizeEntryPoint(e,i){let a=f.isProd===`true`,o=e.toLowerCase();if(!a&&(o.includes(`.min.`)||o.includes(`.prod.`))){let a=this.findDevelopmentAlternatives(e,i);if(a)return a}if(o.includes(`runtime`)&&!o.includes(`browser`)){let a=this.findBrowserAlternative(e,i);if(a)return a}return e}findDevelopmentAlternatives(e,i){let a=e.replace(`.min.`,`.`).replace(`.prod.`,`.`);if(i.exports&&typeof i.exports==`object`){let e=i.exports[`.`];if(e&&typeof e==`object`){let i=[e.development,e.import,e.browser,e.default].filter(Boolean);for(let e of i)if(typeof e==`string`&&!e.includes(`.min.`)&&!e.includes(`.prod.`))return e}}if(i.browser&&typeof i.browser==`object`){for(let e of Object.values(i.browser))if(typeof e==`string`&&!e.includes(`.min.`)&&!e.includes(`.prod.`)&&(e.includes(`browser`)||e.includes(`esm`)))return e}return a===e?null:a}findBrowserAlternative(e,i){if(i.exports&&typeof i.exports==`object`){let e=i.exports[`.`];if(e&&typeof e==`object`){let i=Object.keys(e).filter(e=>e.includes(`browser`)&&(e.includes(`esm`)||e.includes(`module`)));if(i.length>0){let a=i[0];if(a&&typeof e[a]==`string`)return e[a]}if(e.browser&&typeof e.browser==`string`)return e.browser}}let a=e.replace(/\.[^/.]+$/,``),o=[a.replace(`runtime`,`esm-browser`),a.replace(`runtime`,`browser`),a.replace(`runtime.esm-bundler`,`esm-browser`),e.replace(`runtime`,`esm-browser`),e.replace(`runtime`,`browser`)];return e.includes(`vue.runtime.esm-bundler`)&&o.unshift(`dist/vue.esm-browser.js`,`dist/vue.browser.esm.js`),o.find(i=>i!==e)||null}findOptimalESMVersion(e,a){let s=c(a),u=(a.split(`/`).pop()||``).replace(/\.[^/.]+$/,``),d=l(e,s);if(i(d))try{let e=o(d);this.metrics.filesystemAccess++;let i=[`${u}.esm-browser.js`,`${u}.esm.js`,`${u}.module.js`,`${u}.browser.js`];for(let a of i)if(e.includes(a))return l(s,a)}catch{}}buildAliasIndex(){if(f.PATH_ALIAS)try{let e=JSON.parse(f.PATH_ALIAS);this.aliasIndex=[];for(let[i,a]of Object.entries(e)){let e=i.replace(`/*`,``),o=e.length;this.aliasIndex.push({pattern:e,target:Array.isArray(a)?a:[a],regex:RegExp(`^${e.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}(?=/|$)`),priority:o})}this.aliasIndex.sort((e,i)=>i.priority-e.priority),f.VERBOSE===`true`&&p.info(`🔗 Índice de alias construido: ${this.aliasIndex.length} patrones`)}catch(e){p.error(`Error construyendo índice de alias:`,e)}}async resolveModule(e,i){let a=performance.now();if(this.metrics.totalResolutions++,this.excludedModules.has(e))return{path:null,cached:!1,resolveTime:performance.now()-a};let o=this.createCacheKey(e,i),s=this.getFromCache(o);if(s!==void 0)return this.metrics.cacheHits++,{path:s,cached:!0,resolveTime:performance.now()-a,fromCache:!0};this.metrics.cacheMisses++;let c=null;try{c=e.includes(`/`)?await this.resolveSubPath(e):this.resolveFromIndex(e),c||(c=this.fallbackResolve(e)),c&&(c=this.getNodeModulesRelativePath(c))}catch(i){f.VERBOSE===`true`&&p.warn(`Error resolviendo ${e}:`,i)}this.setCache(o,c);let l=performance.now()-a;return this.updateMetrics(l),{path:c,cached:!1,resolveTime:l}}resolveFromIndex(e){this.metrics.indexLookups++;let i=this.moduleIndex.get(e);if(!i)return null;let a=i.optimizedEntry||i.entryPoint;return l(i.fullPath,a)}async resolveSubPath(e){let[a,...o]=e.split(`/`),s=o.join(`/`);if(!a)return null;this.metrics.indexLookups++;let c=this.moduleIndex.get(a);if(!c)return null;if(c.hasExports&&c.packageJson.exports){let e=`./${s}`,i=c.packageJson.exports[e];if(i){if(typeof i==`string`)return l(c.fullPath,i);if(typeof i==`object`){let e=i.import||i.default;if(typeof e==`string`)return l(c.fullPath,e)}}}let u=l(c.fullPath,s);if(i(u))return this.metrics.filesystemAccess++,u;for(let e of[`.mjs`,`.js`,`.cjs`]){let a=u+e;if(i(a))return this.metrics.filesystemAccess++,a}return null}fallbackResolve(e){let o=l(d(),`node_modules`,e),s=l(o,`package.json`);if(!i(s))return this.metrics.filesystemAccess++,null;try{let e=JSON.parse(a(s,`utf-8`));this.metrics.filesystemAccess++;let c=l(o,this.determineOptimalEntryPoint(e)||`index.js`);if(i(c))return this.metrics.filesystemAccess++,c}catch{}return null}findMatchingAlias(e){this.metrics.aliasMatches++;for(let i of this.aliasIndex)if(i.regex.test(e))return i;return null}resolveAlias(e){let i=this.findMatchingAlias(e);if(!i||!f.PATH_DIST)return null;let a=e.replace(i.pattern,``),o=i.target[0];if(!o)return null;let s,c=f.PATH_DIST.replace(`./`,``);if(a===``&&!o.includes(`*`))if(o.startsWith(`/`))s=l(`/`,c,o.substring(1));else{let e=o.replace(`./`,``);s=e.startsWith(`src/`)?l(`/`,c,e.replace(`src/`,``)):l(`/`,c,e)}else if(o.startsWith(`/`)){let e=o.substring(1).replace(`/*`,``);s=(e===`src`||e.startsWith(`src/`),l(`/`,c,a))}else{let e=o.replace(`./`,``).replace(`/*`,``);s=e===c?l(`/`,c,a):e.startsWith(c+`/`)?l(`/`,e,a):e.startsWith(`src/`)?l(`/`,c,e.replace(`src/`,``),a):[`examples`,`src`,`app`,`lib`].includes(e)?l(`/`,c,a):l(`/`,c,e,a)}return s.replace(/\\/g,`/`)}getFromCache(e){let i=this.resolutionCache.get(e);if(i){if(Date.now()-i.timestamp>this.cacheMaxAge){this.resolutionCache.delete(e),this.cacheOrder=this.cacheOrder.filter(i=>i!==e);return}return i.hits++,this.cacheOrder=this.cacheOrder.filter(i=>i!==e),this.cacheOrder.push(e),i.result}}setCache(e,i){if(this.resolutionCache.size>=this.maxCacheSize){let e=this.cacheOrder.shift();e&&this.resolutionCache.delete(e)}this.resolutionCache.set(e,{result:i,timestamp:Date.now(),hits:0}),this.cacheOrder.push(e)}createCacheKey(i,a){let o=e(`md5`);return o.update(i),a&&o.update(a),o.digest(`hex`)}getNodeModulesRelativePath(e){let i=e.indexOf(`node_modules`);if(i!==-1)return`/`+e.substring(i).replace(/\\/g,`/`);let a=u(d(),e).replace(/\\/g,`/`);return a.startsWith(`/`)?a:`/`+a}updateMetrics(e){this.metrics.averageResolveTime=(this.metrics.averageResolveTime*(this.metrics.totalResolutions-1)+e)/this.metrics.totalResolutions}setupPeriodicRefresh(){setInterval(()=>{Date.now()-this.lastIndexUpdate>this.indexRefreshInterval&&(f.VERBOSE===`true`&&p.info(`🔄 Actualizando índices de resolución de módulos`),this.refreshIndexes())},this.indexRefreshInterval)}refreshIndexes(){try{let e=this.moduleIndex.size;this.buildModuleIndex(),this.buildAliasIndex(),this.lastIndexUpdate=Date.now(),f.VERBOSE===`true`&&p.info(`📚 Índices actualizados: ${e} → ${this.moduleIndex.size} módulos`)}catch(e){p.error(`Error actualizando índices:`,e)}}clearExpiredCache(){let e=Date.now(),i=[];for(let[a,o]of this.resolutionCache.entries())e-o.timestamp>this.cacheMaxAge&&i.push(a);for(let e of i)this.resolutionCache.delete(e),this.cacheOrder=this.cacheOrder.filter(i=>i!==e);f.VERBOSE===`true`&&i.length>0&&p.info(`🧹 Limpiado caché expirado: ${i.length} entradas`)}getMetrics(){return{...this.metrics,cacheSize:this.resolutionCache.size,moduleIndexSize:this.moduleIndex.size,aliasIndexSize:this.aliasIndex.length,cacheHitRate:this.metrics.totalResolutions>0?this.metrics.cacheHits/this.metrics.totalResolutions*100:0}}resetMetrics(){this.metrics={totalResolutions:0,cacheHits:0,cacheMisses:0,averageResolveTime:0,indexLookups:0,filesystemAccess:0,aliasMatches:0}}forceRefresh(){this.initializeIndexes(),this.resolutionCache.clear(),this.cacheOrder=[],f.VERBOSE===`true`&&p.info(`🔄 Índices de resolución reconstruidos forzosamente`)}cleanup(){this.moduleIndex.clear(),this.resolutionCache.clear(),this.cacheOrder=[],this.aliasIndex=[],this.nodeModulesCache.clear(),f.VERBOSE===`true`&&p.info(`🧹 Sistema de resolución de módulos limpiado`)}}export async function getOptimizedModulePath(e,i){return(await ModuleResolutionOptimizer.getInstance().resolveModule(e,i)).path}export function getOptimizedAliasPath(e){return ModuleResolutionOptimizer.getInstance().resolveAlias(e)}export function getModuleResolutionMetrics(){return ModuleResolutionOptimizer.getInstance().getMetrics()}
+/**
+ * Module Resolution Optimizer
+ *
+ * Optimiza la resolución de módulos mediante:
+ * - Sistema de indexación O(1) para búsquedas de módulos
+ * - Caché LRU para resoluciones repetidas
+ * - Indexación de alias para búsquedas rápidas
+ * - Batch processing para múltiples resoluciones
+ * - Monitoreo de performance y métricas
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { cwd, env } from 'node:process';
+import { logger } from '../servicios/logger.js';
+import { EXCLUDED_MODULES } from '../utils/excluded-modules.js';
+/**
+ * Sistema de optimización de resolución de módulos
+ * Implementa indexación, caché y búsquedas O(1)
+ */
+export class ModuleResolutionOptimizer {
+    static instance;
+    // Índice principal de módulos para búsquedas O(1)
+    moduleIndex = new Map();
+    // Caché LRU para resoluciones repetidas
+    resolutionCache = new Map();
+    cacheOrder = [];
+    // Índice de alias optimizado
+    aliasIndex = [];
+    // Caché de rutas de node_modules descubiertas
+    nodeModulesCache = new Map();
+    // Métricas de rendimiento
+    metrics = {
+        totalResolutions: 0,
+        cacheHits: 0,
+        cacheMisses: 0,
+        averageResolveTime: 0,
+        indexLookups: 0,
+        filesystemAccess: 0,
+        aliasMatches: 0,
+    };
+    // Configuración
+    maxCacheSize = 500;
+    cacheMaxAge = 5 * 60 * 1000; // 5 minutos
+    indexRefreshInterval = 10 * 60 * 1000; // 10 minutos    // Lista de módulos excluidos - usar la lista centralizada
+    excludedModules = EXCLUDED_MODULES;
+    lastIndexUpdate = 0;
+    constructor() {
+        this.initializeIndexes();
+        this.setupPeriodicRefresh();
+    }
+    static getInstance() {
+        if (!ModuleResolutionOptimizer.instance) {
+            ModuleResolutionOptimizer.instance =
+                new ModuleResolutionOptimizer();
+        }
+        return ModuleResolutionOptimizer.instance;
+    }
+    /**
+     * Resetea la instancia del singleton (útil para tests)
+     */
+    static resetInstance() {
+        ModuleResolutionOptimizer.instance = null;
+    }
+    /**
+     * Inicializa los índices de módulos y alias
+     */
+    initializeIndexes() {
+        const startTime = performance.now();
+        try {
+            this.buildModuleIndex();
+            this.buildAliasIndex();
+            this.lastIndexUpdate = Date.now();
+            const indexTime = performance.now() - startTime;
+            if (env.VERBOSE === 'true') {
+                logger.info(`🚀 Índices de resolución construidos en ${indexTime.toFixed(2)}ms`);
+                logger.info(`📦 ${this.moduleIndex.size} módulos indexados`);
+                logger.info(`🔗 ${this.aliasIndex.length} alias indexados`);
+            }
+        }
+        catch (error) {
+            logger.error('Error inicializando índices de resolución:', error);
+        }
+    }
+    /**
+     * Construye el índice principal de módulos para búsquedas O(1)
+     */
+    buildModuleIndex() {
+        const nodeModulesPath = join(cwd(), 'node_modules');
+        if (!existsSync(nodeModulesPath)) {
+            return;
+        }
+        try {
+            const modules = this.discoverModules(nodeModulesPath);
+            for (const moduleData of modules) {
+                this.moduleIndex.set(moduleData.name, {
+                    fullPath: moduleData.fullPath,
+                    entryPoint: moduleData.entryPoint,
+                    packageJson: moduleData.packageJson,
+                    isESM: moduleData.isESM,
+                    hasExports: moduleData.hasExports,
+                    optimizedEntry: moduleData.optimizedEntry,
+                    lastModified: moduleData.lastModified,
+                });
+            }
+            if (env.VERBOSE === 'true') {
+                logger.info(`📚 Índice de módulos construido: ${this.moduleIndex.size} entradas`);
+            }
+        }
+        catch (error) {
+            logger.error('Error construyendo índice de módulos:', error);
+        }
+    }
+    /**
+     * Descubre módulos disponibles en node_modules con información optimizada
+     */
+    discoverModules(nodeModulesPath) {
+        const modules = [];
+        try {
+            const entries = readdirSync(nodeModulesPath);
+            this.metrics.filesystemAccess++;
+            for (const entry of entries) {
+                const modulePath = join(nodeModulesPath, entry);
+                try {
+                    if (entry.startsWith('/dist/examples')) {
+                        // Scoped packages
+                        const scopedModules = readdirSync(modulePath);
+                        this.metrics.filesystemAccess++;
+                        for (const scopedModule of scopedModules) {
+                            const scopedPath = join(modulePath, scopedModule);
+                            const moduleData = this.analyzeModule(`${entry}/${scopedModule}`, scopedPath);
+                            if (moduleData) {
+                                modules.push(moduleData);
+                            }
+                        }
+                    }
+                    else {
+                        // Regular packages
+                        const moduleData = this.analyzeModule(entry, modulePath);
+                        if (moduleData) {
+                            modules.push(moduleData);
+                        }
+                    }
+                }
+                catch {
+                    // Ignorar módulos que no se puedan analizar
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            logger.error('Error descubriendo módulos:', error);
+        }
+        return modules;
+    }
+    /**
+     * Analiza un módulo individual y extrae información relevante
+     */
+    analyzeModule(name, modulePath) {
+        try {
+            const packageJsonPath = join(modulePath, 'package.json');
+            if (!existsSync(packageJsonPath)) {
+                return null;
+            }
+            const stats = statSync(packageJsonPath);
+            this.metrics.filesystemAccess++;
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            this.metrics.filesystemAccess++;
+            const isESM = packageJson.type === 'module';
+            const hasExports = !!packageJson.exports; // Determinar entry point optimizado
+            const entryPoint = this.determineOptimalEntryPoint(packageJson);
+            let optimizedEntry;
+            // Buscar versión ESM/browser optimizada
+            if (entryPoint) {
+                optimizedEntry = this.findOptimalESMVersion(modulePath, entryPoint);
+            }
+            return {
+                name,
+                fullPath: modulePath,
+                entryPoint: entryPoint || 'index.js',
+                packageJson,
+                isESM,
+                hasExports,
+                optimizedEntry,
+                lastModified: stats.mtime.getTime(),
+            };
+        }
+        catch {
+            return null;
+        }
+    } /**
+     * Determina el entry point óptimo basado en package.json
+     */
+    determineOptimalEntryPoint(packageJson) {
+        // Prioridad: module > exports > browser > main
+        let entryPoint = null;
+        if (packageJson.module) {
+            entryPoint = packageJson.module;
+        }
+        else if (packageJson.exports) {
+            if (typeof packageJson.exports === 'string') {
+                entryPoint = packageJson.exports;
+            }
+            else if (packageJson.exports['.']) {
+                const dotExport = packageJson.exports['.'];
+                if (typeof dotExport === 'string') {
+                    entryPoint = dotExport;
+                }
+                else if (typeof dotExport === 'object') {
+                    entryPoint =
+                        dotExport.import ||
+                            dotExport.browser ||
+                            dotExport.default;
+                }
+            }
+        }
+        else if (packageJson.browser &&
+            typeof packageJson.browser === 'string') {
+            entryPoint = packageJson.browser;
+        }
+        else {
+            entryPoint = packageJson.main || null;
+        }
+        // ✨ NUEVA VALIDACIÓN POST-RESOLUCIÓN
+        // Verificar si el archivo resuelto cumple con criterios de desarrollo
+        if (entryPoint) {
+            entryPoint = this.validateAndOptimizeEntryPoint(entryPoint, packageJson);
+        }
+        return entryPoint;
+    }
+    /**
+     * ✨ NUEVA FUNCIÓN: Valida y optimiza el entry point basado en criterios de desarrollo
+     */
+    validateAndOptimizeEntryPoint(entryPoint, packageJson) {
+        const isProd = env.isProd === 'true';
+        const fileName = entryPoint.toLowerCase();
+        // Si estamos en desarrollo, evitar archivos .min o .prod
+        if (!isProd &&
+            (fileName.includes('.min.') || fileName.includes('.prod.'))) {
+            // Buscar alternativas mejores en el package.json
+            const alternatives = this.findDevelopmentAlternatives(entryPoint, packageJson);
+            if (alternatives) {
+                return alternatives;
+            }
+        }
+        // Priorizar versiones browser y esm para mejor compatibilidad
+        if (fileName.includes('runtime') && !fileName.includes('browser')) {
+            const browserAlternative = this.findBrowserAlternative(entryPoint, packageJson);
+            if (browserAlternative) {
+                return browserAlternative;
+            }
+        }
+        return entryPoint;
+    } /**
+     * ✨ NUEVA FUNCIÓN: Busca alternativas de desarrollo (no minificadas)
+     */
+    findDevelopmentAlternatives(entryPoint, packageJson) {
+        // Crear versión de desarrollo basada en el entry point actual
+        const devVersion = entryPoint
+            .replace('.min.', '.')
+            .replace('.prod.', '.');
+        // Si hay exports, buscar en diferentes condiciones
+        if (packageJson.exports && typeof packageJson.exports === 'object') {
+            const dotExport = packageJson.exports['.'];
+            if (dotExport && typeof dotExport === 'object') {
+                // Buscar versiones development, import, browser
+                const candidates = [
+                    dotExport.development,
+                    dotExport.import,
+                    dotExport.browser,
+                    dotExport.default,
+                ].filter(Boolean);
+                for (const candidate of candidates) {
+                    if (typeof candidate === 'string' &&
+                        !candidate.includes('.min.') &&
+                        !candidate.includes('.prod.')) {
+                        return candidate;
+                    }
+                }
+            }
+        } // Si browser field es un objeto, buscar alternativas
+        if (packageJson.browser && typeof packageJson.browser === 'object') {
+            for (const value of Object.values(packageJson.browser)) {
+                if (typeof value === 'string' &&
+                    !value.includes('.min.') &&
+                    !value.includes('.prod.') &&
+                    (value.includes('browser') || value.includes('esm'))) {
+                    return value;
+                }
+            }
+        }
+        return devVersion !== entryPoint ? devVersion : null;
+    }
+    /**
+     * ✨ NUEVA FUNCIÓN: Busca alternativas browser para versiones runtime
+     */
+    findBrowserAlternative(entryPoint, packageJson) {
+        // Primero intentar con exports
+        if (packageJson.exports && typeof packageJson.exports === 'object') {
+            const dotExport = packageJson.exports['.'];
+            if (dotExport && typeof dotExport === 'object') {
+                // Buscar specific browser+esm combinations
+                const browserKeys = Object.keys(dotExport).filter(key => key.includes('browser') &&
+                    (key.includes('esm') || key.includes('module')));
+                if (browserKeys.length > 0) {
+                    const firstBrowserKey = browserKeys[0];
+                    if (firstBrowserKey &&
+                        typeof dotExport[firstBrowserKey] === 'string') {
+                        return dotExport[firstBrowserKey];
+                    }
+                }
+                // Fallback a browser general
+                if (dotExport.browser &&
+                    typeof dotExport.browser === 'string') {
+                    return dotExport.browser;
+                }
+            }
+        }
+        // Buscar en directorio dist versiones browser
+        const baseName = entryPoint.replace(/\.[^/.]+$/, '');
+        const browserCandidates = [
+            baseName.replace('runtime', 'esm-browser'),
+            baseName.replace('runtime', 'browser'),
+            baseName.replace('runtime.esm-bundler', 'esm-browser'),
+            entryPoint.replace('runtime', 'esm-browser'),
+            entryPoint.replace('runtime', 'browser'),
+        ];
+        // Para Vue específicamente
+        if (entryPoint.includes('vue.runtime.esm-bundler')) {
+            browserCandidates.unshift('dist/vue.esm-browser.js', 'dist/vue.browser.esm.js');
+        }
+        return (browserCandidates.find(candidate => candidate !== entryPoint) ||
+            null);
+    }
+    /**
+     * Busca versión ESM/browser optimizada (simplificada del module-resolver)
+     */
+    findOptimalESMVersion(moduleDir, entryPoint) {
+        const dir = dirname(entryPoint);
+        const baseName = entryPoint.split('/').pop() || '';
+        const nameWithoutExt = baseName.replace(/\.[^/.]+$/, '');
+        // Determinar el nombre base sin sufijos como .runtime, .bundler, etc.
+        // Por ejemplo: vue.runtime.esm-bundler -> vue
+        const coreBaseName = nameWithoutExt.split('.')[0];
+        const searchDir = join(moduleDir, dir);
+        if (!existsSync(searchDir)) {
+            return undefined;
+        }
+        try {
+            const files = readdirSync(searchDir);
+            this.metrics.filesystemAccess++;
+            // ✨ Patrones de prioridad dinámicos según modo producción
+            const patterns = env.isPROD === 'true'
+                ? [
+                    // 🏭 MODO PRODUCCIÓN: Priorizar versiones optimizadas
+                    // Primero intentar con el nombre exacto
+                    `${nameWithoutExt}.esm-browser.prod.js`,
+                    `${nameWithoutExt}.esm-browser.min.js`,
+                    // Luego con el nombre base (para casos como vue.runtime.esm-bundler -> vue.esm-browser.prod.js)
+                    `${coreBaseName}.esm-browser.prod.js`,
+                    `${coreBaseName}.esm-browser.min.js`,
+                    `${coreBaseName}.runtime.esm-browser.prod.js`,
+                    `${coreBaseName}.runtime.esm-browser.min.js`,
+                    // Otros patrones ESM optimizados
+                    `${nameWithoutExt}.esm.prod.js`,
+                    `${nameWithoutExt}.esm.min.js`,
+                    `${nameWithoutExt}.module.prod.js`,
+                    `${nameWithoutExt}.module.min.js`,
+                    `${nameWithoutExt}.browser.prod.js`,
+                    `${nameWithoutExt}.browser.min.js`,
+                    // Fallback a versiones de desarrollo
+                    `${coreBaseName}.esm-browser.js`,
+                    `${coreBaseName}.runtime.esm-browser.js`,
+                    `${nameWithoutExt}.esm-browser.js`,
+                    `${nameWithoutExt}.esm.js`,
+                    `${nameWithoutExt}.module.js`,
+                    `${nameWithoutExt}.browser.js`,
+                ]
+                : [
+                    // 🔧 MODO DESARROLLO: Priorizar versiones sin minificar
+                    // Primero con nombre exacto
+                    `${nameWithoutExt}.esm-browser.js`,
+                    // Luego con nombre base
+                    `${coreBaseName}.esm-browser.js`,
+                    `${coreBaseName}.runtime.esm-browser.js`,
+                    // Otros patrones ESM
+                    `${nameWithoutExt}.esm.js`,
+                    `${nameWithoutExt}.module.js`,
+                    `${nameWithoutExt}.browser.js`,
+                    // Fallback a versiones de producción si no hay desarrollo
+                    `${coreBaseName}.esm-browser.prod.js`,
+                    `${coreBaseName}.runtime.esm-browser.prod.js`,
+                    `${nameWithoutExt}.esm-browser.prod.js`,
+                    `${nameWithoutExt}.esm.prod.js`,
+                ];
+            for (const pattern of patterns) {
+                if (files.includes(pattern)) {
+                    if (env.VERBOSE === 'true') {
+                        const mode = env.isPROD === 'true' ? '🏭 PROD' : '🔧 DEV';
+                        logger.info(`${mode} Versión optimizada encontrada (${coreBaseName}): ${join(dir, pattern)}`);
+                    }
+                    return join(dir, pattern);
+                }
+            }
+        }
+        catch {
+            // Ignorar errores de filesystem
+        }
+        return undefined;
+    }
+    /**
+     * Construye el índice de alias optimizado para búsquedas rápidas
+     */
+    buildAliasIndex() {
+        if (!env.PATH_ALIAS) {
+            return;
+        }
+        try {
+            const pathAlias = JSON.parse(env.PATH_ALIAS);
+            this.aliasIndex = [];
+            // Convertir alias a índice con prioridad
+            for (const [alias, target] of Object.entries(pathAlias)) {
+                const pattern = alias.replace('/*', '');
+                const priority = pattern.length; // Patrones más largos tienen prioridad
+                // El regex debe coincidir con el patrón al inicio, seguido de cualquier cosa o fin de cadena
+                // Por ejemplo, para "@/" debe coincidir con "@/cualquier-cosa" o solo "@/"
+                this.aliasIndex.push({
+                    pattern,
+                    target: Array.isArray(target) ? target : [target],
+                    regex: new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`),
+                    priority,
+                });
+            }
+            // Ordenar por prioridad (patrones más largos primero)
+            this.aliasIndex.sort((a, b) => b.priority - a.priority);
+            if (env.VERBOSE === 'true') {
+                logger.info(`🔗 Índice de alias construido: ${this.aliasIndex.length} patrones`);
+            }
+        }
+        catch (error) {
+            logger.error('Error construyendo índice de alias:', error);
+        }
+    }
+    /**
+     * Resuelve un módulo utilizando el sistema optimizado
+     */
+    async resolveModule(moduleName, fromFile) {
+        const startTime = performance.now();
+        this.metrics.totalResolutions++;
+        // Verificar si está excluido
+        if (this.excludedModules.has(moduleName)) {
+            return {
+                path: null,
+                cached: false,
+                resolveTime: performance.now() - startTime,
+            };
+        }
+        // Crear clave de caché
+        const cacheKey = this.createCacheKey(moduleName, fromFile);
+        // Verificar caché
+        const cached = this.getFromCache(cacheKey);
+        if (cached !== undefined) {
+            this.metrics.cacheHits++;
+            return {
+                path: cached,
+                cached: true,
+                resolveTime: performance.now() - startTime,
+                fromCache: true,
+            };
+        }
+        this.metrics.cacheMisses++;
+        // Resolver módulo
+        let resolvedPath = null;
+        try {
+            // 1. Verificar si es subpath de módulo (ej: 'vue/dist/vue.esm-bundler')
+            if (moduleName.includes('/')) {
+                resolvedPath = await this.resolveSubPath(moduleName);
+            }
+            else {
+                // 2. Búsqueda O(1) en el índice
+                resolvedPath = this.resolveFromIndex(moduleName);
+            }
+            // 3. Si no se encuentra en índice, intentar resolución tradicional
+            if (!resolvedPath) {
+                resolvedPath = this.fallbackResolve(moduleName);
+            }
+            // Convertir a ruta relativa desde node_modules
+            if (resolvedPath) {
+                resolvedPath = this.getNodeModulesRelativePath(resolvedPath);
+            }
+        }
+        catch (error) {
+            if (env.VERBOSE === 'true') {
+                logger.warn(`Error resolviendo ${moduleName}:`, error);
+            }
+        }
+        // Guardar en caché
+        this.setCache(cacheKey, resolvedPath);
+        const resolveTime = performance.now() - startTime;
+        this.updateMetrics(resolveTime);
+        return {
+            path: resolvedPath,
+            cached: false,
+            resolveTime,
+        };
+    }
+    /**
+     * Busca módulo en el índice (O(1))
+     */
+    resolveFromIndex(moduleName) {
+        this.metrics.indexLookups++;
+        const moduleInfo = this.moduleIndex.get(moduleName);
+        if (!moduleInfo) {
+            return null;
+        }
+        // Usar versión optimizada si está disponible
+        const entryPoint = moduleInfo.optimizedEntry || moduleInfo.entryPoint;
+        return join(moduleInfo.fullPath, entryPoint);
+    }
+    /**
+     * Resuelve subpaths de módulos (ej: 'vue/dist/vue.esm-bundler')
+     */
+    async resolveSubPath(moduleName) {
+        const [packageName, ...subPathParts] = moduleName.split('/');
+        const subPath = subPathParts.join('/');
+        if (!packageName) {
+            return null;
+        }
+        this.metrics.indexLookups++;
+        const moduleInfo = this.moduleIndex.get(packageName);
+        if (!moduleInfo) {
+            return null;
+        }
+        // Verificar exports field para subpaths
+        if (moduleInfo.hasExports && moduleInfo.packageJson.exports) {
+            const exportKey = `./${subPath}`;
+            const exportPath = moduleInfo.packageJson.exports[exportKey];
+            if (exportPath) {
+                if (typeof exportPath === 'string') {
+                    return join(moduleInfo.fullPath, exportPath);
+                }
+                else if (typeof exportPath === 'object') {
+                    const importPath = exportPath.import || exportPath.default;
+                    if (typeof importPath === 'string') {
+                        return join(moduleInfo.fullPath, importPath);
+                    }
+                }
+            }
+        }
+        // Fallback: resolver directamente el subpath
+        const directPath = join(moduleInfo.fullPath, subPath);
+        if (existsSync(directPath)) {
+            this.metrics.filesystemAccess++;
+            return directPath;
+        }
+        // Intentar con extensiones comunes
+        const extensions = ['.mjs', '.js', '.cjs'];
+        for (const ext of extensions) {
+            const pathWithExt = directPath + ext;
+            if (existsSync(pathWithExt)) {
+                this.metrics.filesystemAccess++;
+                return pathWithExt;
+            }
+        }
+        return null;
+    }
+    /**
+     * Resolución de fallback cuando no se encuentra en índice
+     */
+    fallbackResolve(moduleName) {
+        const nodeModulesPath = join(cwd(), 'node_modules', moduleName);
+        const packagePath = join(nodeModulesPath, 'package.json');
+        if (!existsSync(packagePath)) {
+            this.metrics.filesystemAccess++;
+            return null;
+        }
+        try {
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            this.metrics.filesystemAccess++;
+            const entryPoint = this.determineOptimalEntryPoint(packageJson) || 'index.js';
+            const finalPath = join(nodeModulesPath, entryPoint);
+            if (existsSync(finalPath)) {
+                this.metrics.filesystemAccess++;
+                return finalPath;
+            }
+        }
+        catch {
+            // Ignorar errores
+        }
+        return null;
+    }
+    /**
+     * Encuentra alias que coincida con el path dado
+     */
+    findMatchingAlias(path) {
+        this.metrics.aliasMatches++;
+        for (const alias of this.aliasIndex) {
+            if (alias.regex.test(path)) {
+                return alias;
+            }
+        }
+        return null;
+    } /**
+     * Resuelve un alias a su ruta correspondiente
+     */
+    resolveAlias(path) {
+        const alias = this.findMatchingAlias(path);
+        if (!alias || !env.PATH_DIST) {
+            return null;
+        }
+        // El relativePath es lo que queda después del pattern
+        // Por ejemplo: '@/components/Button.vue' con pattern '@/components' → '/Button.vue'
+        const relativePath = path.replace(alias.pattern, '');
+        const targetPath = alias.target[0];
+        if (!targetPath) {
+            return null;
+        }
+        // Construir ruta final
+        let finalPath;
+        const pathDist = env.PATH_DIST.replace('./', '');
+        // Manejar caso especial: alias exacto sin wildcard (como #config -> config/index.js)
+        if (relativePath === '' && !targetPath.includes('*')) {
+            // Es un alias exacto, usar el target tal como está
+            if (targetPath.startsWith('/')) {
+                finalPath = join('/', pathDist, targetPath.substring(1));
+            }
+            else {
+                const cleanTarget = targetPath.replace('./', '');
+                if (cleanTarget.startsWith('src/')) {
+                    const targetWithoutSrc = cleanTarget.replace('src/', '');
+                    finalPath = join('/', pathDist, targetWithoutSrc);
+                }
+                else {
+                    finalPath = join('/', pathDist, cleanTarget);
+                }
+            }
+        }
+        else if (targetPath.startsWith('/')) {
+            // Si el target empieza con /, es una ruta absoluta desde la raíz del proyecto
+            // Extraer la parte del target después de /src
+            const targetWithoutSlash = targetPath
+                .substring(1)
+                .replace('/*', '');
+            // El target puede ser:
+            // - "/src/*" → queremos mapear a "/dist/*"
+            // - "/src/components/*" → queremos mapear a "/dist/components/*"
+            if (targetWithoutSlash === 'src') {
+                // Para "/src/*", mapear directamente a "/pathDist/relativePath"
+                finalPath = join('/', pathDist, relativePath);
+            }
+            else if (targetWithoutSlash.startsWith('src/')) {
+                // Para "/src/components/*", extraer "components" y usarlo
+                // targetWithoutSlash = 'src/components'
+                // Queremos: 'components'
+                const targetSubpath = targetWithoutSlash.replace(/^src\/?/, '');
+                // relativePath ya incluye la barra inicial
+                finalPath = join('/', pathDist, targetSubpath, relativePath);
+            }
+            else {
+                // Para otros casos como "/examples/*"
+                finalPath = join('/', pathDist, targetWithoutSlash, relativePath);
+            }
+        }
+        else {
+            // Si es una ruta relativa, construir basándose en el target
+            const cleanTarget = targetPath.replace('./', '').replace('/*', '');
+            // Si el target ya incluye el directorio de distribución, no duplicar
+            if (cleanTarget === pathDist) {
+                finalPath = join('/', pathDist, relativePath);
+            }
+            else if (cleanTarget.startsWith(pathDist + '/')) {
+                // Si el target ya contiene PATH_DIST como prefijo
+                finalPath = join('/', cleanTarget, relativePath);
+            }
+            else {
+                // Caso normal: mapear manteniendo la estructura relativa al target
+                if (cleanTarget.startsWith('src/')) {
+                    // Para "src/components/*" -> "/pathDist/components/*"
+                    const targetWithoutSrc = cleanTarget.replace('src/', '');
+                    finalPath = join('/', pathDist, targetWithoutSrc, relativePath);
+                }
+                else {
+                    // Para casos como "examples/*" -> "/pathDist/*"
+                    // No incluir el directorio raíz en la ruta final
+                    const isRootDirectory = [
+                        'examples',
+                        'src',
+                        'app',
+                        'lib',
+                    ].includes(cleanTarget);
+                    if (isRootDirectory) {
+                        finalPath = join('/', pathDist, relativePath);
+                    }
+                    else {
+                        // Para subdirectorios específicos, mantener la estructura
+                        finalPath = join('/', pathDist, cleanTarget, relativePath);
+                    }
+                }
+            }
+        }
+        return finalPath.replace(/\\/g, '/');
+    }
+    /**
+     * Gestión de caché LRU
+     */
+    getFromCache(key) {
+        const entry = this.resolutionCache.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        // Verificar expiración
+        if (Date.now() - entry.timestamp > this.cacheMaxAge) {
+            this.resolutionCache.delete(key);
+            this.cacheOrder = this.cacheOrder.filter(k => k !== key);
+            return undefined;
+        }
+        // Actualizar orden LRU
+        entry.hits++;
+        this.cacheOrder = this.cacheOrder.filter(k => k !== key);
+        this.cacheOrder.push(key);
+        return entry.result;
+    }
+    setCache(key, result) {
+        // Implementar límite de caché LRU
+        if (this.resolutionCache.size >= this.maxCacheSize) {
+            const oldestKey = this.cacheOrder.shift();
+            if (oldestKey) {
+                this.resolutionCache.delete(oldestKey);
+            }
+        }
+        this.resolutionCache.set(key, {
+            result,
+            timestamp: Date.now(),
+            hits: 0,
+        });
+        this.cacheOrder.push(key);
+    }
+    createCacheKey(moduleName, fromFile) {
+        const hash = createHash('md5');
+        hash.update(moduleName);
+        if (fromFile) {
+            hash.update(fromFile);
+        }
+        return hash.digest('hex');
+    }
+    /**
+     * Convierte ruta absoluta a ruta relativa desde node_modules
+     */
+    getNodeModulesRelativePath(fullPath) {
+        const idx = fullPath.indexOf('node_modules');
+        if (idx !== -1) {
+            return '/' + fullPath.substring(idx).replace(/\\/g, '/');
+        }
+        // Para rutas que no están en node_modules
+        const rel = relative(cwd(), fullPath).replace(/\\/g, '/');
+        return rel.startsWith('/') ? rel : '/' + rel;
+    }
+    /**
+     * Actualiza métricas de rendimiento
+     */
+    updateMetrics(resolveTime) {
+        this.metrics.averageResolveTime =
+            (this.metrics.averageResolveTime *
+                (this.metrics.totalResolutions - 1) +
+                resolveTime) /
+                this.metrics.totalResolutions;
+    }
+    /**
+     * Configura actualización periódica de índices
+     */
+    setupPeriodicRefresh() {
+        setInterval(() => {
+            if (Date.now() - this.lastIndexUpdate > this.indexRefreshInterval) {
+                if (env.VERBOSE === 'true') {
+                    logger.info('🔄 Actualizando índices de resolución de módulos');
+                }
+                this.refreshIndexes();
+            }
+        }, this.indexRefreshInterval);
+    }
+    /**
+     * Actualiza los índices manteniendo el caché válido
+     */
+    refreshIndexes() {
+        try {
+            const oldSize = this.moduleIndex.size;
+            this.buildModuleIndex();
+            this.buildAliasIndex();
+            this.lastIndexUpdate = Date.now();
+            if (env.VERBOSE === 'true') {
+                logger.info(`📚 Índices actualizados: ${oldSize} → ${this.moduleIndex.size} módulos`);
+            }
+        }
+        catch (error) {
+            logger.error('Error actualizando índices:', error);
+        }
+    }
+    /**
+     * Limpia caché expirado
+     */
+    clearExpiredCache() {
+        const now = Date.now();
+        const keysToDelete = [];
+        for (const [key, entry] of this.resolutionCache.entries()) {
+            if (now - entry.timestamp > this.cacheMaxAge) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.resolutionCache.delete(key);
+            this.cacheOrder = this.cacheOrder.filter(k => k !== key);
+        }
+        if (env.VERBOSE === 'true' && keysToDelete.length > 0) {
+            logger.info(`🧹 Limpiado caché expirado: ${keysToDelete.length} entradas`);
+        }
+    }
+    /**
+     * Obtiene métricas de rendimiento
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            cacheSize: this.resolutionCache.size,
+            moduleIndexSize: this.moduleIndex.size,
+            aliasIndexSize: this.aliasIndex.length,
+            cacheHitRate: this.metrics.totalResolutions > 0
+                ? (this.metrics.cacheHits / this.metrics.totalResolutions) *
+                    100
+                : 0,
+        };
+    }
+    /**
+     * Resetea métricas de rendimiento
+     */
+    resetMetrics() {
+        this.metrics = {
+            totalResolutions: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            averageResolveTime: 0,
+            indexLookups: 0,
+            filesystemAccess: 0,
+            aliasMatches: 0,
+        };
+    }
+    /**
+     * Forzar reconstrucción de índices
+     */
+    forceRefresh() {
+        this.initializeIndexes();
+        this.resolutionCache.clear();
+        this.cacheOrder = [];
+        if (env.VERBOSE === 'true') {
+            logger.info('🔄 Índices de resolución reconstruidos forzosamente');
+        }
+    }
+    /**
+     * Limpia todos los cachés y índices
+     */
+    cleanup() {
+        this.moduleIndex.clear();
+        this.resolutionCache.clear();
+        this.cacheOrder = [];
+        this.aliasIndex = [];
+        this.nodeModulesCache.clear();
+        if (env.VERBOSE === 'true') {
+            logger.info('🧹 Sistema de resolución de módulos limpiado');
+        }
+    }
+}
+// Funciones de compatibilidad con el sistema existente
+export async function getOptimizedModulePath(moduleName, fromFile) {
+    const optimizer = ModuleResolutionOptimizer.getInstance();
+    const result = await optimizer.resolveModule(moduleName, fromFile);
+    return result.path;
+}
+export function getOptimizedAliasPath(path) {
+    const optimizer = ModuleResolutionOptimizer.getInstance();
+    return optimizer.resolveAlias(path);
+}
+export function getModuleResolutionMetrics() {
+    const optimizer = ModuleResolutionOptimizer.getInstance();
+    return optimizer.getMetrics();
+}
+export function resetModuleResolutionOptimizer() {
+    ModuleResolutionOptimizer.resetInstance();
+}
+//# sourceMappingURL=module-resolution-optimizer.js.map