versacompiler 2.1.0 → 2.2.0

package/dist/utils/module-resolver.js

@@ -1 +1,466 @@
-import e,{readFileSync as t}from"node:fs";import{dirname as n,join as r,relative as i}from"node:path";import{cwd as a,env as o}from"node:process";import{logger as s}from"../servicios/logger.js";import{EXCLUDED_MODULES as c}from"./excluded-modules.js";function l(t,i){let a=n(i),c=(i.split(`/`).pop()||``).replace(/\.[^/.]+$/,``),l=r(t,a);if(!e.existsSync(l))return i;try{let t=e.readdirSync(l),n=[`${c}.esm-browser.js`,`${c}.esm.all.js`,`${c}.esm.js`,`${c}.module.js`,`${c}.browser.js`,`${c}.web.js`,`${c}.umd.js`,`${c}.global.js`,`${c}.esm-browser.min.js`,`${c}.esm-browser.prod.js`,`${c}.esm.all.min.js`,`${c}.esm.min.js`,`${c}.module.min.js`,`${c}.browser.min.js`,`${c}.browser.prod.js`,`${c}.web.min.js`,`${c}.umd.min.js`,`${c}.global.min.js`,`${c}.min.js`,`${c}.runtime.esm-browser.js`,`${c}.runtime.esm-browser.min.js`,`${c}.runtime.esm-browser.prod.js`];for(let e of n)if(t.includes(e))return r(a,e).replace(/\\/g,`/`);let i=t.filter(e=>{let t=e.toLowerCase();return(t.includes(`.esm-browser.`)||t.includes(`.esm.`)||t.includes(`.module.`)||t.includes(`.browser.`)||t.includes(`.web.`)||t.includes(`.runtime.esm-browser.`))&&(e.endsWith(`.js`)||e.endsWith(`.mjs`))});if(i.length>0){let e=i.filter(e=>e.toLowerCase().includes(`.esm-browser.`)&&!e.toLowerCase().includes(`.runtime.`));if(e.length>0){let t=e.filter(e=>!e.toLowerCase().includes(`.prod.`)&&!e.toLowerCase().includes(`.min.`));if(t.length>0&&t[0])return r(a,t[0]).replace(/\\/g,`/`);let n=e.filter(e=>e.toLowerCase().includes(`.prod.`));if(n.length>0&&n[0]){let e=r(a,n[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión ESM-Browser producción encontrada: ${e}`),e}let i=e.filter(e=>e.toLowerCase().includes(`.min.`));if(i.length>0&&i[0]){let e=r(a,i[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión ESM-Browser minificada encontrada: ${e}`),e}if(e[0]){let t=r(a,e[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión ESM-Browser encontrada: ${t}`),t}}let t=i.filter(e=>(e.toLowerCase().includes(`.esm.`)||e.toLowerCase().includes(`.module.`))&&!e.toLowerCase().includes(`.min.`)&&!e.toLowerCase().includes(`.prod.`)&&!e.toLowerCase().includes(`.runtime.`));if(t.length>0&&t[0]){let e=r(a,t[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión ESM dev encontrada: ${e}`),e}let n=i.filter(e=>(e.toLowerCase().includes(`.min.`)||e.toLowerCase().includes(`.prod.`))&&!e.toLowerCase().includes(`.runtime.`));if(n.length>0){let e=n.filter(e=>e.toLowerCase().includes(`.esm.`)||e.toLowerCase().includes(`.module.`));if(e.length>0&&e[0]){let t=r(a,e[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión ESM minificada encontrada: ${t}`),t}if(n[0]){let e=r(a,n[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión minificada encontrada: ${e}`),e}}let c=i.filter(e=>e.toLowerCase().includes(`.runtime.esm-browser.`));if(c.length>0){let e=c.filter(e=>!e.toLowerCase().includes(`.prod.`)&&!e.toLowerCase().includes(`.min.`));if(e.length>0&&e[0]){let t=r(a,e[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión Runtime ESM-Browser dev encontrada: ${t}`),t}if(c[0]){let e=r(a,c[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión Runtime ESM-Browser encontrada: ${e}`),e}}if(i[0]){let e=r(a,i[0]).replace(/\\/g,`/`);return o.VERBOSE===`true`&&s.info(`Versión browser encontrada: ${e}`),e}}}catch(e){o.VERBOSE===`true`&&s.warn(`No se pudo leer directorio ${l}:`,e instanceof Error?e.message:String(e))}return i}function u(i){try{let c=r(a(),`node_modules`,i),u;try{if(u=r(c,`package.json`),!e.existsSync(u))throw Error(`No se encontró package.json para ${i}`)}catch{return null}let d=JSON.parse(t(u,`utf-8`)),f=n(u),p=d.type===`module`,m=null;if(d.module)m=d.module;else if(d.exports){if(typeof d.exports==`string`)m=d.exports;else if(d.exports[`.`]){let e=d.exports[`.`];if(typeof e==`string`)m=e;else if(typeof e==`object`){let t=Object.keys(e).find(e=>e.includes(`browser`)&&(e.includes(`esm`)||e.includes(`module`)));m=t&&typeof e[t]==`string`?e[t]:(typeof e.import==`string`?e.import:null)||e.browser||(typeof e.default==`string`?e.default:null)}}}else d.browser?typeof d.browser==`string`?m=d.browser:typeof d.browser==`object`&&(m=d.browser[`.`]||d.browser[d.main]):d.main&&(m=d.main);m||(m=p?`index.js`:`index.cjs`),typeof m!=`string`&&(o.VERBOSE===`true`&&s.warn(`Entry point no es string para ${i}:`,m),m=p?`index.js`:`index.cjs`);let h=r(f,m),g=l(f,m);if(g&&g!==m&&(h=r(f,g)),p&&d.imports){let n=new Map;for(let[e,t]of Object.entries(d.imports))if(typeof t==`string`)n.set(e,r(f,t));else if(typeof t==`object`&&t){let i=t,a=i.browser||i.default||i.node;a&&n.set(e,r(f,a))}if(e.existsSync(h)){let e=t(h,`utf-8`),r=Array.from(e.matchAll(/from\s+['"]([#@][^'"]+)['"]/g));if(r.length>0){o.VERBOSE===`true`&&s.info(`Módulo ${i} usa imports privados:`,r.map(e=>e[1]));for(let e of r){let[,t]=e;n.has(t)||o.VERBOSE===`true`&&s.warn(`Import privado no resuelto: ${t} en ${i}`)}}}}if(!e.existsSync(h)){let t=[m,m.replace(`.js`,`.mjs`),m.replace(`.mjs`,`.js`),m.replace(`.js`,`.cjs`),`index.mjs`,`index.js`,`index.cjs`];for(let n of t){let t=r(f,n);if(e.existsSync(t)){h=t;break}}}return h}catch(e){return o.VERBOSE===`true`&&s.error(`Error resolviendo ${i}: ${e instanceof Error?e.message:String(e)}`),null}}function d(e,t){if(!e)return null;let n=e.indexOf(`node_modules`);if(n!==-1)return`/`+e.substring(n).replace(/\\/g,`/`);let r=i(a(),e).replace(/\\/g,`/`);return r||(r=`.`),r.startsWith(`/`)||(r=`/`+r),r}export function getModulePath(e,t){return c.has(e)?null:d(u(e),t)}export function getModuleSubPath(i,l){if(c.has(i))return null;if(i.includes(`/`)){let[c,...u]=i.split(`/`),f=u.join(`/`);if(!c)return null;try{let i=r(r(a(),`node_modules`,c),`package.json`);if(!e.existsSync(i))return null;let o=JSON.parse(t(i,`utf-8`)),s=n(i);if(o.exports&&typeof o.exports==`object`){let e=`./${f}`,t=o.exports[e];if(t){if(typeof t==`string`)return d(r(s,t),l);if(typeof t==`object`){let e=t.import||t.default;if(typeof e==`string`)return d(r(s,e),l)}}}let u=r(s,f);if(e.existsSync(u))return d(u,l);for(let t of[`.mjs`,`.js`,`.cjs`]){let n=u+t;if(e.existsSync(n))return d(n,l)}}catch(e){o.VERBOSE===`true`&&s.error(`Error resolviendo subpath ${i}:`,e instanceof Error?e.message:String(e))}}return getModulePath(i,l)}
+// Opción con librería '/node_modules/resolve/index.js' (npm install resolve)
+import fs, { readFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { cwd, env } from 'node:process';
+// import pkg from '/node_modules/enhanced-resolve/lib/index.js';
+// import resolve from '/node_modules/resolve/index.js';
+import { logger } from '../servicios/logger.js';
+import { EXCLUDED_MODULES } from './excluded-modules.js';
+// function resolveESMWithLibrary(moduleName: string): string | null {
+//     try {
+//         // Resolver el módulo
+//         const resolved = resolve.sync(moduleName, {
+//             basedir: process.cwd(),
+//             packageFilter: (pkg: any) => {
+//                 // Priorizar campos ESM
+//                 if (pkg.module) pkg.main = pkg.module;
+//                 else if (pkg.exports?.['.']?.import)
+//                     pkg.main = pkg.exports['.'].import;
+//                 else if (pkg.exports?.import) pkg.main = pkg.exports.import;
+//                 return pkg;
+//             },
+//         });
+//         return resolved;
+//     } catch (error) {
+//         if (env.VERBOSE === 'true')
+//             logger.error(
+//                 `Error resolviendo ${moduleName}:`,
+//                 error instanceof Error ? error.message : String(error),
+//             );
+//         return null;
+//     }
+// }
+// Opción con '/node_modules/enhanced-resolve/lib/index.js' (webpack's resolver)
+// npm install enhanced-resolve
+// const { ResolverFactory } = pkg;
+// const resolver = ResolverFactory.createResolver({
+//     fileSystem: {
+//         readFile,
+//         readlink,
+//         stat,
+//         readdir,
+//     },
+//     conditionNames: ['import', 'module', 'default'], // Priorizar ESM
+//     extensions: ['.mjs', '.js', '.json'],
+//     mainFields: ['module', 'main'], // Priorizar campo 'module'
+//     aliasFields: ['browser'],
+// });
+// function resolveESMEnhanced(moduleName: string): Promise<string | null> {
+//     return new Promise((resolve, reject) => {
+//         resolver.resolve({}, process.cwd(), moduleName, {}, (err, result) => {
+//             if (err) reject(err);
+//             else resolve(result as string);
+//         });
+//     });
+// }
+// Función para buscar la mejor versión ESM/browser optimizada de un archivo
+function findOptimalESMVersion(moduleDir, entryPoint) {
+    const dir = dirname(entryPoint);
+    const baseName = entryPoint.split('/').pop() || '';
+    const nameWithoutExt = baseName.replace(/\.[^/.]+$/, '');
+    // Directorio donde buscar
+    const searchDir = join(moduleDir, dir);
+    if (!fs.existsSync(searchDir)) {
+        return entryPoint;
+    }
+    try {
+        const files = fs.readdirSync(searchDir); // Patrones de prioridad para buscar versiones optimizadas
+        // Prioriza versiones completas de desarrollo para mejor debugging
+        const priorityPatterns = [
+            // Máxima prioridad: ESM-Browser completo (sin runtime, desarrollo)
+            `${nameWithoutExt}.esm-browser.js`,
+            // ESM puro sin minificar (desarrollo)
+            `${nameWithoutExt}.esm.all.js`,
+            `${nameWithoutExt}.esm.js`,
+            `${nameWithoutExt}.module.js`,
+            // Browser puro sin minificar (desarrollo)
+            `${nameWithoutExt}.browser.js`,
+            `${nameWithoutExt}.web.js`,
+            // UMD sin minificar (desarrollo)
+            `${nameWithoutExt}.umd.js`,
+            `${nameWithoutExt}.global.js`,
+            // Fallback a versiones minificadas sin runtime
+            `${nameWithoutExt}.esm-browser.min.js`,
+            `${nameWithoutExt}.esm-browser.prod.js`,
+            `${nameWithoutExt}.esm.all.min.js`,
+            `${nameWithoutExt}.esm.min.js`,
+            `${nameWithoutExt}.module.min.js`,
+            `${nameWithoutExt}.browser.min.js`,
+            `${nameWithoutExt}.browser.prod.js`,
+            `${nameWithoutExt}.web.min.js`,
+            `${nameWithoutExt}.umd.min.js`,
+            `${nameWithoutExt}.global.min.js`,
+            `${nameWithoutExt}.min.js`,
+            // Último recurso: versiones runtime (solo si no hay alternativas)
+            `${nameWithoutExt}.runtime.esm-browser.js`,
+            `${nameWithoutExt}.runtime.esm-browser.min.js`,
+            `${nameWithoutExt}.runtime.esm-browser.prod.js`,
+        ];
+        // Buscar archivos que coincidan exactamente con los patrones
+        for (const pattern of priorityPatterns) {
+            if (files.includes(pattern)) {
+                const optimizedPath = join(dir, pattern).replace(/\\/g, '/');
+                return optimizedPath;
+            }
+        } // Buscar archivos que contengan patrones ESM/browser dinámicamente
+        const esmBrowserFiles = files.filter((file) => {
+            const lowerFile = file.toLowerCase();
+            return ((lowerFile.includes('.esm-browser.') || // Prioridad alta: combinación esm-browser
+                lowerFile.includes('.esm.') ||
+                lowerFile.includes('.module.') ||
+                lowerFile.includes('.browser.') ||
+                lowerFile.includes('.web.') ||
+                lowerFile.includes('.runtime.esm-browser.')) && // Runtime como última opción
+                (file.endsWith('.js') || file.endsWith('.mjs')));
+        });
+        if (esmBrowserFiles.length > 0) {
+            // Primera prioridad: archivos que combinan ESM y Browser (sin runtime)
+            const esmBrowserCombined = esmBrowserFiles.filter((file) => file.toLowerCase().includes('.esm-browser.') &&
+                !file.toLowerCase().includes('.runtime.'));
+            if (esmBrowserCombined.length > 0) {
+                // Dentro de esm-browser, priorizar desarrollo > .prod > .min
+                const devFiles = esmBrowserCombined.filter((file) => !file.toLowerCase().includes('.prod.') &&
+                    !file.toLowerCase().includes('.min.'));
+                if (devFiles.length > 0 && devFiles[0]) {
+                    const optimizedPath = join(dir, devFiles[0]).replace(/\\/g, '/');
+                    return optimizedPath;
+                }
+                const prodFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.prod.'));
+                if (prodFiles.length > 0 && prodFiles[0]) {
+                    const optimizedPath = join(dir, prodFiles[0]).replace(/\\/g, '/');
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`Versión ESM-Browser producción encontrada: ${optimizedPath}`);
+                    }
+                    return optimizedPath;
+                }
+                const minFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.min.'));
+                if (minFiles.length > 0 && minFiles[0]) {
+                    const optimizedPath = join(dir, minFiles[0]).replace(/\\/g, '/');
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`Versión ESM-Browser minificada encontrada: ${optimizedPath}`);
+                    }
+                    return optimizedPath;
+                }
+                if (esmBrowserCombined[0]) {
+                    const optimizedPath = join(dir, esmBrowserCombined[0]).replace(/\\/g, '/');
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`Versión ESM-Browser encontrada: ${optimizedPath}`);
+                    }
+                    return optimizedPath;
+                }
+            }
+            // Segunda prioridad: cualquier versión ESM disponible (sin minificar)
+            const esmFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.esm.') ||
+                file.toLowerCase().includes('.module.')) &&
+                !file.toLowerCase().includes('.min.') &&
+                !file.toLowerCase().includes('.prod.') &&
+                !file.toLowerCase().includes('.runtime.'));
+            if (esmFiles.length > 0 && esmFiles[0]) {
+                const optimizedPath = join(dir, esmFiles[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true') {
+                    logger.info(`Versión ESM dev encontrada: ${optimizedPath}`);
+                }
+                return optimizedPath;
+            }
+            // Tercera prioridad: archivos minificados de cualquier tipo ESM/browser (sin runtime)
+            const minifiedFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.min.') ||
+                file.toLowerCase().includes('.prod.')) &&
+                !file.toLowerCase().includes('.runtime.'));
+            if (minifiedFiles.length > 0) {
+                // Priorizar ESM sobre browser sobre UMD
+                const esmFiles = minifiedFiles.filter((file) => file.toLowerCase().includes('.esm.') ||
+                    file.toLowerCase().includes('.module.'));
+                if (esmFiles.length > 0 && esmFiles[0]) {
+                    const optimizedPath = join(dir, esmFiles[0]).replace(/\\/g, '/');
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`Versión ESM minificada encontrada: ${optimizedPath}`);
+                    }
+                    return optimizedPath;
+                }
+                if (minifiedFiles[0]) {
+                    const optimizedPath = join(dir, minifiedFiles[0]).replace(/\\/g, '/');
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`Versión minificada encontrada: ${optimizedPath}`);
+                    }
+                    return optimizedPath;
+                }
+            }
+            // Cuarta prioridad: versiones runtime como último recurso
+            const runtimeFiles = esmBrowserFiles.filter((file) => file.toLowerCase().includes('.runtime.esm-browser.'));
+            if (runtimeFiles.length > 0) {
+                // Priorizar desarrollo sobre producción en runtime también
+                const devRuntimeFiles = runtimeFiles.filter((file) => !file.toLowerCase().includes('.prod.') &&
+                    !file.toLowerCase().includes('.min.'));
+                if (devRuntimeFiles.length > 0 && devRuntimeFiles[0]) {
+                    const optimizedPath = join(dir, devRuntimeFiles[0]).replace(/\\/g, '/');
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`Versión Runtime ESM-Browser dev encontrada: ${optimizedPath}`);
+                    }
+                    return optimizedPath;
+                }
+                if (runtimeFiles[0]) {
+                    const optimizedPath = join(dir, runtimeFiles[0]).replace(/\\/g, '/');
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`Versión Runtime ESM-Browser encontrada: ${optimizedPath}`);
+                    }
+                    return optimizedPath;
+                }
+            }
+            // Fallback: cualquier versión browser
+            if (esmBrowserFiles[0]) {
+                const optimizedPath = join(dir, esmBrowserFiles[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true') {
+                    logger.info(`Versión browser encontrada: ${optimizedPath}`);
+                }
+                return optimizedPath;
+            }
+        }
+    }
+    catch (error) {
+        if (env.VERBOSE === 'true') {
+            logger.warn(`No se pudo leer directorio ${searchDir}:`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    return entryPoint; // Fallback al entry point original
+}
+// Función mejorada para detectar automáticamente entry points browser-compatible
+function simpleESMResolver(moduleName) {
+    try {
+        const nodeModulesPath = join(cwd(), 'node_modules', moduleName);
+        let packagePath;
+        try {
+            packagePath = join(nodeModulesPath, 'package.json');
+            if (!fs.existsSync(packagePath)) {
+                throw new Error(`No se encontró package.json para ${moduleName}`);
+            }
+        }
+        catch {
+            return null;
+        }
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        const moduleDir = dirname(packagePath);
+        const isESM = packageJson.type === 'module'; // Determinar el entry point ESM/Browser optimizado
+        let entryPoint = null;
+        // 1. Prioridad máxima: campo module para ESM
+        if (packageJson.module) {
+            entryPoint = packageJson.module;
+        }
+        // 2. Revisar exports field con prioridad ESM
+        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') {
+                    // Priorizar import > browser > default para compatibilidad ESM
+                    // Buscar específicamente patrones esm-browser primero
+                    const exportKeys = Object.keys(dotExport);
+                    const esmBrowserKey = exportKeys.find(key => key.includes('browser') &&
+                        (key.includes('esm') || key.includes('module')));
+                    if (esmBrowserKey &&
+                        typeof dotExport[esmBrowserKey] === 'string') {
+                        entryPoint = dotExport[esmBrowserKey];
+                    }
+                    else {
+                        // Priorizar import > browser > default
+                        entryPoint =
+                            (typeof dotExport.import === 'string'
+                                ? dotExport.import
+                                : null) ||
+                                dotExport.browser ||
+                                (typeof dotExport.default === 'string'
+                                    ? dotExport.default
+                                    : null);
+                    }
+                }
+            }
+        }
+        // 3. Revisar browser field específico
+        else if (packageJson.browser) {
+            if (typeof packageJson.browser === 'string') {
+                entryPoint = packageJson.browser;
+            }
+            else if (typeof packageJson.browser === 'object') {
+                // Si browser es un objeto de mapeo, buscar la entrada principal
+                entryPoint =
+                    packageJson.browser['.'] ||
+                        packageJson.browser[packageJson.main];
+            }
+        }
+        // 4. Fallback a main field
+        else if (packageJson.main) {
+            entryPoint = packageJson.main;
+        }
+        // 5. Fallback por defecto según el tipo de módulo
+        if (!entryPoint) {
+            entryPoint = isESM ? 'index.js' : 'index.cjs';
+        }
+        // Asegurarse de que el entry point es una cadena
+        if (typeof entryPoint !== 'string') {
+            if (env.VERBOSE === 'true')
+                logger.warn(`Entry point no es string para ${moduleName}:`, entryPoint);
+            entryPoint = isESM ? 'index.js' : 'index.cjs';
+        } // Resolver la ruta final
+        let finalPath = join(moduleDir, entryPoint);
+        // Buscar una versión ESM/browser optimizada
+        const optimizedEntry = findOptimalESMVersion(moduleDir, entryPoint);
+        if (optimizedEntry && optimizedEntry !== entryPoint) {
+            finalPath = join(moduleDir, optimizedEntry);
+        }
+        // Si es ESM, verificar si hay imports privados que necesiten ser resueltos
+        if (isESM && packageJson.imports) {
+            const importMap = new Map();
+            for (const [key, value] of Object.entries(packageJson.imports)) {
+                if (typeof value === 'string') {
+                    importMap.set(key, join(moduleDir, value));
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    // Priorizar la versión browser
+                    const valueObj = value;
+                    const browserPath = valueObj.browser || valueObj.default || valueObj.node;
+                    if (browserPath) {
+                        importMap.set(key, join(moduleDir, browserPath));
+                    }
+                }
+            }
+            // Si el archivo existe, leer su contenido y verificar imports privados
+            if (fs.existsSync(finalPath)) {
+                const content = readFileSync(finalPath, 'utf-8');
+                const privateImports = Array.from(content.matchAll(/from\s+['"]([#@][^'"]+)['"]/g));
+                if (privateImports.length > 0) {
+                    if (env.VERBOSE === 'true')
+                        logger.info(`Módulo ${moduleName} usa imports privados:`, privateImports.map(m => m[1]));
+                    // Si usa imports privados, asegurarnos de que estén disponibles
+                    for (const match of privateImports) {
+                        const [, importPath] = match;
+                        if (!importMap.has(importPath)) {
+                            if (env.VERBOSE === 'true')
+                                logger.warn(`Import privado no resuelto: ${importPath} en ${moduleName}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Verificar que el archivo existe
+        if (!fs.existsSync(finalPath)) {
+            // Intentar alternativas comunes
+            const alternatives = [
+                entryPoint,
+                entryPoint.replace('.js', '.mjs'),
+                entryPoint.replace('.mjs', '.js'),
+                entryPoint.replace('.js', '.cjs'),
+                'index.mjs',
+                'index.js',
+                'index.cjs',
+            ];
+            for (const alt of alternatives) {
+                const altPath = join(moduleDir, alt);
+                if (fs.existsSync(altPath)) {
+                    finalPath = altPath;
+                    break;
+                }
+            }
+        }
+        return finalPath;
+    }
+    catch (error) {
+        if (env.VERBOSE === 'true')
+            logger.error(`Error resolviendo ${moduleName}: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+// Función utilitaria para obtener rutas absolutas desde la raíz del proyecto
+function getNodeModulesRelativePath(fullPath, _fromFile) {
+    if (!fullPath)
+        return null;
+    const idx = fullPath.indexOf('node_modules');
+    if (idx !== -1) {
+        // Extraer solo la parte desde node_modules en adelante
+        const relativePath = fullPath.substring(idx).replace(/\\/g, '/');
+        // Devolver ruta absoluta desde la raíz del proyecto (sin ../)
+        // Esto permite que los archivos compilados accedan directamente a node_modules
+        return '/' + relativePath;
+    }
+    // Para rutas que no están en node_modules, convertir a ruta absoluta desde la raíz
+    let rel = relative(cwd(), fullPath).replace(/\\/g, '/');
+    if (!rel)
+        rel = '.';
+    // Convertir a ruta absoluta desde la raíz
+    if (!rel.startsWith('/')) {
+        rel = '/' + rel;
+    }
+    return rel;
+}
+export function getModulePath(moduleName, fromFile) {
+    // Verificar si el módulo está en la lista de excluidos
+    if (EXCLUDED_MODULES.has(moduleName)) {
+        return null; // Retornar null para mantener la importación original
+    }
+    return getNodeModulesRelativePath(simpleESMResolver(moduleName), fromFile);
+}
+// Nueva función para resolver subpaths de módulos (ej: 'yargs/helpers')
+export function getModuleSubPath(moduleName, fromFile) {
+    // Verificar si el módulo está en la lista de excluidos
+    if (EXCLUDED_MODULES.has(moduleName)) {
+        return null; // Retornar null para mantener la importación original
+    } // Si contiene '/', es un subpath
+    if (moduleName.includes('/')) {
+        const [packageName, ...subPathParts] = moduleName.split('/');
+        const subPath = subPathParts.join('/');
+        // Verificar que packageName no esté vacío
+        if (!packageName) {
+            return null;
+        }
+        try {
+            const nodeModulesPath = join(cwd(), 'node_modules', packageName);
+            const packagePath = join(nodeModulesPath, 'package.json');
+            if (!fs.existsSync(packagePath)) {
+                return null;
+            }
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            const moduleDir = dirname(packagePath);
+            // Revisar exports field para subpaths
+            if (packageJson.exports &&
+                typeof packageJson.exports === 'object') {
+                const exportKey = `./${subPath}`;
+                const exportPath = packageJson.exports[exportKey];
+                if (exportPath) {
+                    if (typeof exportPath === 'string') {
+                        return getNodeModulesRelativePath(join(moduleDir, exportPath), fromFile);
+                    }
+                    else if (typeof exportPath === 'object') {
+                        // Priorizar import > default para ESM
+                        const importPath = exportPath.import || exportPath.default;
+                        if (typeof importPath === 'string') {
+                            return getNodeModulesRelativePath(join(moduleDir, importPath), fromFile);
+                        }
+                    }
+                }
+            }
+            // Fallback: intentar resolver directamente el subpath
+            const directPath = join(moduleDir, subPath);
+            if (fs.existsSync(directPath)) {
+                return getNodeModulesRelativePath(directPath, fromFile);
+            }
+            // Intentar con extensiones comunes
+            const extensions = ['.mjs', '.js', '.cjs'];
+            for (const ext of extensions) {
+                const pathWithExt = directPath + ext;
+                if (fs.existsSync(pathWithExt)) {
+                    return getNodeModulesRelativePath(pathWithExt, fromFile);
+                }
+            }
+        }
+        catch (error) {
+            if (env.VERBOSE === 'true')
+                logger.error(`Error resolviendo subpath ${moduleName}:`, error instanceof Error ? error.message : String(error));
+        }
+    }
+    // Si no es un subpath, usar el resolver normal
+    return getModulePath(moduleName, fromFile);
+}
+//# sourceMappingURL=module-resolver.js.map

package/dist/utils/promptUser.js

@@ -1,2 +1,48 @@
-import e,{stdin as t,stdout as n}from"node:process";import*as r from"node:readline/promises";import{logger as i}from"../servicios/logger.js";export async function promptUser(a,o=3e4){let s=r.createInterface({input:t,output:n});return new Promise((t,n)=>{let r=!1,c=setTimeout(()=>{r||(r=!0,s.close(),n(Error(`Timeout: No se recibió respuesta del usuario`)))},o),l=()=>{r||(r=!0,clearTimeout(c),s.close(),i.info(`
-🛑 Operación cancelada por el usuario.`),e.exit(0))};e.on(`SIGINT`,l),s.question(a).then(n=>{r||(r=!0,clearTimeout(c),e.removeListener(`SIGINT`,l),s.close(),t(n))}).catch(t=>{r||(r=!0,clearTimeout(c),e.removeListener(`SIGINT`,l),s.close(),n(t))})})}
+import process, { stdin as input, stdout as output } from 'node:process';
+import * as readline from 'node:readline/promises';
+import { logger } from '../servicios/logger.js';
+export async function promptUser(question, timeout = 30000) {
+    const rl = readline.createInterface({ input, output });
+    return new Promise((resolve, reject) => {
+        let isResolved = false;
+        // Timeout para evitar espera infinita
+        const timer = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                rl.close();
+                reject(new Error('Timeout: No se recibió respuesta del usuario'));
+            }
+        }, timeout);
+        // Manejar Ctrl+C
+        const handleSigint = () => {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(timer);
+                rl.close();
+                logger.info('\n🛑 Operación cancelada por el usuario.');
+                process.exit(0);
+            }
+        };
+        process.on('SIGINT', handleSigint);
+        rl.question(question)
+            .then((answer) => {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(timer);
+                process.removeListener('SIGINT', handleSigint);
+                rl.close();
+                resolve(answer);
+            }
+        })
+            .catch((error) => {
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(timer);
+                process.removeListener('SIGINT', handleSigint);
+                rl.close();
+                reject(error);
+            }
+        });
+    });
+}
+//# sourceMappingURL=promptUser.js.map

package/dist/utils/proxyValidator.js

@@ -1 +1,68 @@
-import{get as e}from"node:http";import{get as t}from"node:https";import{URL as n}from"node:url";export async function validateProxyAvailability(r,i=5e3){return new Promise(a=>{try{let o=new n(r),s=o.protocol===`https:`,c=(s?t:e)({hostname:o.hostname,port:o.port||(s?443:80),path:`/`,method:`HEAD`,timeout:i,headers:{"User-Agent":`VersaCompiler-ProxyValidator/1.0`}},e=>{a(!0)});c.on(`error`,()=>{a(!1)}),c.on(`timeout`,()=>{c.destroy(),a(!1)}),c.setTimeout(i),c.end()}catch{a(!1)}})}export function getProxyInfo(e){try{let t=new n(e);return{host:t.hostname,port:t.port||(t.protocol===`https:`?`443`:`80`),protocol:t.protocol.replace(`:`,``)}}catch{return{host:`unknown`,port:`unknown`,protocol:`unknown`}}}
+import { get as httpGet } from 'node:http';
+import { get as httpsGet } from 'node:https';
+import { URL } from 'node:url';
+/**
+ * Valida si un servidor proxy está disponible
+ * @param proxyUrl URL del proxy a validar
+ * @param timeout Timeout en milisegundos (default: 5000)
+ * @returns Promise que resuelve a true si el proxy está disponible
+ */
+export async function validateProxyAvailability(proxyUrl, timeout = 5000) {
+    return new Promise(resolve => {
+        try {
+            const url = new URL(proxyUrl);
+            const isHttps = url.protocol === 'https:';
+            const requestMethod = isHttps ? httpsGet : httpGet;
+            const options = {
+                hostname: url.hostname,
+                port: url.port || (isHttps ? 443 : 80),
+                path: '/',
+                method: 'HEAD',
+                timeout: timeout,
+                headers: {
+                    'User-Agent': 'VersaCompiler-ProxyValidator/1.0',
+                },
+            };
+            const req = requestMethod(options, (_res) => {
+                // Cualquier respuesta HTTP (incluso errores 4xx/5xx) indica que el servidor está arriba
+                resolve(true);
+            });
+            req.on('error', () => {
+                resolve(false);
+            });
+            req.on('timeout', () => {
+                req.destroy();
+                resolve(false);
+            });
+            req.setTimeout(timeout);
+            req.end();
+        }
+        catch {
+            // Error al parsear URL o crear request
+            resolve(false);
+        }
+    });
+}
+/**
+ * Extrae información legible del proxy URL para mostrar al usuario
+ * @param proxyUrl URL del proxy
+ * @returns Objeto con información del proxy
+ */
+export function getProxyInfo(proxyUrl) {
+    try {
+        const url = new URL(proxyUrl);
+        return {
+            host: url.hostname,
+            port: url.port || (url.protocol === 'https:' ? '443' : '80'),
+            protocol: url.protocol.replace(':', ''),
+        };
+    }
+    catch {
+        return {
+            host: 'unknown',
+            port: 'unknown',
+            protocol: 'unknown',
+        };
+    }
+}
+//# sourceMappingURL=proxyValidator.js.map

package/dist/utils/resolve-bin.js

@@ -1 +1,58 @@
-import*as e from"node:path";import*as t from"node:process";import n from"find-root";import r from"fs-extra";function i(t,n){for(let i of n)try{let n=e.join(i,`node_modules`,t);if(r.existsSync(n))return n}catch{}throw Error(`Cannot resolve module ${t} from paths: ${n.join(`, `)}`)}export function resolveBin(a,{executable:o=a,paths:s=[t.cwd()]}={}){let c;try{c=n(i(a,s))}catch{let n=s[0]||t.cwd(),i=e.join(n,`node_modules`,a,`package.json`);if(r.existsSync(i))c=e.dirname(i);else throw Error(`Cannot resolve module ${a}`)}let l=e.join(c,`package.json`),u=r.readJsonSync(l);if(!u.bin)throw Error(`no bin found in ${u.name}@${u.version} in path ${l}`);let d=typeof u.bin==`string`?u.bin:u.bin[o];return e.join(c,d)}
+import * as path from 'node:path';
+import * as process from 'node:process';
+import * as fs from 'fs-extra';
+// Reimplementación simple de findRoot para evitar dependencias problemáticas
+function findRoot(start) {
+    let current = start;
+    while (current !== path.dirname(current)) {
+        if (fs.existsSync(path.join(current, 'package.json'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    throw new Error(`Cannot find package.json from ${start}`);
+}
+// Función helper para resolver módulos sin createRequire
+function resolveModule(moduleName, paths) {
+    for (const searchPath of paths) {
+        try {
+            const nodeModulesPath = path.join(searchPath, 'node_modules', moduleName);
+            if (fs.existsSync(nodeModulesPath)) {
+                return nodeModulesPath;
+            }
+        }
+        catch {
+            // Continuar con el siguiente path
+        }
+    }
+    throw new Error(`Cannot resolve module ${moduleName} from paths: ${paths.join(', ')}`);
+}
+export function resolveBin(moduleName, { executable = moduleName, paths = [process.cwd()], } = {}) {
+    let rootDir;
+    try {
+        const resolved = resolveModule(moduleName, paths);
+        rootDir = findRoot(resolved);
+    }
+    catch {
+        // Intentar resolver package.json directamente
+        const basePath = paths[0] || process.cwd();
+        const packagePath = path.join(basePath, 'node_modules', moduleName, 'package.json');
+        if (fs.existsSync(packagePath)) {
+            rootDir = path.dirname(packagePath);
+        }
+        else {
+            throw new Error(`Cannot resolve module ${moduleName}`);
+        }
+    }
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    const packageJson = fs.readJsonSync(packageJsonPath);
+    if (!packageJson.bin) {
+        throw new Error(`no bin found in ${packageJson.name}@${packageJson.version} in path ${packageJsonPath}`);
+    }
+    const binProp = typeof packageJson.bin === 'string'
+        ? packageJson.bin
+        : packageJson.bin[executable];
+    const binPath = path.join(rootDir, binProp);
+    return binPath;
+}
+//# sourceMappingURL=resolve-bin.js.map