versacompiler 2.0.7 → 2.0.8

package/dist/utils/module-resolver.js

@@ -1,466 +1 @@
-// 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
+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()||``,l=c.replace(/\.[^/.]+$/,``),u=r(t,a);if(!e.existsSync(u))return i;try{let t=e.readdirSync(u),n=[`${l}.esm-browser.js`,`${l}.esm.all.js`,`${l}.esm.js`,`${l}.module.js`,`${l}.browser.js`,`${l}.web.js`,`${l}.umd.js`,`${l}.global.js`,`${l}.esm-browser.min.js`,`${l}.esm-browser.prod.js`,`${l}.esm.all.min.js`,`${l}.esm.min.js`,`${l}.module.min.js`,`${l}.browser.min.js`,`${l}.browser.prod.js`,`${l}.web.min.js`,`${l}.umd.min.js`,`${l}.global.min.js`,`${l}.min.js`,`${l}.runtime.esm-browser.js`,`${l}.runtime.esm-browser.min.js`,`${l}.runtime.esm-browser.prod.js`];for(let e of n)if(t.includes(e)){let t=r(a,e).replace(/\\/g,`/`);return t}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]){let e=r(a,t[0]).replace(/\\/g,`/`);return e}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 ${u}:`,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),n=t.find(e=>e.includes(`browser`)&&(e.includes(`esm`)||e.includes(`module`)));m=n&&typeof e[n]==`string`?e[n]:(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||=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){let t=e.substring(n).replace(/\\/g,`/`);return`/`+t}let r=i(a(),e).replace(/\\/g,`/`);return 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(a(),`node_modules`,c),o=r(i,`package.json`);if(!e.existsSync(o))return null;let s=JSON.parse(t(o,`utf-8`)),u=n(o);if(s.exports&&typeof s.exports==`object`){let e=`./${f}`,t=s.exports[e];if(t){if(typeof t==`string`)return d(r(u,t),l);if(typeof t==`object`){let e=t.import||t.default;if(typeof e==`string`)return d(r(u,e),l)}}}let p=r(u,f);if(e.existsSync(p))return d(p,l);let m=[`.mjs`,`.js`,`.cjs`];for(let t of m){let n=p+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)}

package/dist/utils/promptUser.js

@@ -1,48 +1,2 @@
-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
+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))})})}

package/dist/utils/proxyValidator.js

@@ -1,68 +1 @@
-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
+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,l={hostname:o.hostname,port:o.port||(s?443:80),path:`/`,method:`HEAD`,timeout:i,headers:{"User-Agent":`VersaCompiler-ProxyValidator/1.0`}},u=c(l,e=>{a(!0)});u.on(`error`,()=>{a(!1)}),u.on(`timeout`,()=>{u.destroy(),a(!1)}),u.setTimeout(i),u.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`}}}

package/dist/utils/resolve-bin.js

@@ -1,48 +1 @@
-import * as path from 'node:path';
-import * as process from 'node:process';
-import findRoot from 'find-root';
-import fs from 'fs-extra';
-// 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
+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{let e=i(a,s);c=n(e)}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],f=e.join(c,d);return f}