versacompiler 2.0.7 → 2.0.8

package/dist/servicios/readConfig.js

@@ -1,430 +1,105 @@
-import { normalize, relative, resolve } from 'node:path';
-import * as process from 'node:process';
-import { env } from 'node:process';
-import { pathToFileURL } from 'node:url';
-import { logger } from './logger.js';
-/**
- * Utilidades de seguridad para validar configuraciones
- */
-class SecurityValidators {
-    static MAX_PATH_LENGTH = 260; // Windows MAX_PATH limit
-    static MAX_CONFIG_SIZE = 1024 * 1024; // 1MB max config size
-    static ALLOWED_PATH_CHARS = /^[a-zA-Z0-9.\-_/\\:@ ()[\]]+$/;
-    static DANGEROUS_PATTERNS = [
-        /\.\./, // Path traversal
-        /[;&|`$]/, // Command injection characters
-        /\$\(/, // Command substitution
-        /`.*`/, // Backtick execution
-        /\|\s*[a-zA-Z]/, // Pipe to commands
-    ];
-    /**
-     * Valida que una ruta no contenga path traversal
-     */
-    static validatePath(path) {
-        if (!path || typeof path !== 'string') {
-            return false;
-        }
-        if (path.length > this.MAX_PATH_LENGTH) {
-            logger.warn(`Ruta demasiado larga: ${path.length} caracteres`);
-            return false;
-        }
-        // Normalizar la ruta para detectar path traversal
-        const normalizedPath = normalize(path);
-        const resolvedPath = resolve(process.cwd(), normalizedPath);
-        const relativePath = relative(process.cwd(), resolvedPath);
-        // Verificar si la ruta trata de salir del directorio actual
-        if (relativePath.startsWith('..') || normalizedPath.includes('..')) {
-            logger.error(`Detectado intento de path traversal: ${path}`);
-            return false;
-        }
-        // Verificar caracteres permitidos
-        if (!this.ALLOWED_PATH_CHARS.test(path)) {
-            logger.error(`Caracteres no permitidos en la ruta: ${path}`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Valida que un comando no contenga inyección de código
-     */
-    static validateCommand(command) {
-        if (!command || typeof command !== 'string') {
-            return false;
-        }
-        if (command.length > this.MAX_PATH_LENGTH) {
-            logger.warn(`Comando demasiado largo: ${command.length} caracteres`);
-            return false;
-        }
-        // Verificar patrones peligrosos
-        for (const pattern of this.DANGEROUS_PATTERNS) {
-            if (pattern.test(command)) {
-                logger.error(`Detectado patrón peligroso en comando: ${command}`);
-                return false;
-            }
-        }
-        // Solo permitir comandos que terminen en extensiones seguras
-        const allowedExecutables = [
-            '.exe',
-            '.cmd',
-            '.bat',
-            '.sh',
-            '.js',
-            '.ts',
-        ];
-        const hasAllowedExtension = allowedExecutables.some(ext => command.toLowerCase().includes(ext) ||
-            command.startsWith('./node_modules/.bin/') ||
-            command.startsWith('npx '));
-        if (!hasAllowedExtension) {
-            logger.error(`Comando no permitido: ${command}`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Valida configuración de bundlers
-     */
-    static validateBundlers(bundlers) {
-        if (!Array.isArray(bundlers)) {
-            logger.error('bundlers debe ser un array');
-            return false;
-        }
-        for (const entry of bundlers) {
-            if (!entry || typeof entry !== 'object') {
-                logger.error('Cada entrada de bundler debe ser un objeto');
-                return false;
-            }
-            if (!entry.name || typeof entry.name !== 'string') {
-                logger.error('Cada entrada de bundler debe tener un nombre válido');
-                return false;
-            }
-            if (!entry.fileInput || typeof entry.fileInput !== 'string') {
-                logger.error('Cada entrada de bundler debe tener un fileInput válido');
-                return false;
-            }
-            if (!this.validatePath(entry.fileInput)) {
-                logger.error(`Ruta de entrada no válida: ${entry.fileInput}`);
-                return false;
-            }
-            if (!entry.fileOutput || typeof entry.fileOutput !== 'string') {
-                logger.error('Cada entrada de bundler debe tener un fileOutput válido');
-                return false;
-            }
-            if (!this.validatePath(entry.fileOutput)) {
-                logger.error(`Ruta de salida no válida: ${entry.fileOutput}`);
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Valida la estructura de configuración
-     */
-    static validateConfigStructure(config) {
-        if (!config || typeof config !== 'object') {
-            logger.error('La configuración debe ser un objeto');
-            return false;
-        }
-        if (!config.compilerOptions ||
-            typeof config.compilerOptions !== 'object') {
-            logger.error('compilerOptions es requerido y debe ser un objeto');
-            return false;
-        }
-        if (!config.compilerOptions.pathsAlias ||
-            typeof config.compilerOptions.pathsAlias !== 'object') {
-            logger.error('pathsAlias es requerido y debe ser un objeto');
-            return false;
-        }
-        // Validar pathsAlias
-        for (const [key, value] of Object.entries(config.compilerOptions.pathsAlias)) {
-            if (!Array.isArray(value)) {
-                logger.error(`pathsAlias["${key}"] debe ser un array`);
-                return false;
-            }
-            for (const path of value) {
-                if (typeof path !== 'string') {
-                    logger.error(`Todas las rutas en pathsAlias["${key}"] deben ser strings`);
-                    return false;
-                }
-                if (!this.validatePath(path.replace('/*', ''))) {
-                    logger.error(`Ruta no válida en pathsAlias["${key}"]: ${path}`);
-                    return false;
-                }
-            }
-        }
-        // Validar sourceRoot si existe
-        if (config.compilerOptions.sourceRoot &&
-            !this.validatePath(config.compilerOptions.sourceRoot)) {
-            return false;
-        }
-        // Validar outDir si existe
-        if (config.compilerOptions.outDir &&
-            !this.validatePath(config.compilerOptions.outDir)) {
-            return false;
-        }
-        // Validar linter si existe
-        if (config.linter && config.linter !== false) {
-            if (!Array.isArray(config.linter)) {
-                logger.error('linter debe ser un array o false');
-                return false;
-            }
-            for (const linter of config.linter) {
-                if (!this.validateLinter(linter)) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Valida configuración de linter
-     */
-    static validateLinter(linter) {
-        if (!linter || typeof linter !== 'object') {
-            logger.error('Cada linter debe ser un objeto');
-            return false;
-        }
-        if (!linter.name || typeof linter.name !== 'string') {
-            logger.error('Linter debe tener un nombre válido');
-            return false;
-        }
-        if (!linter.bin || typeof linter.bin !== 'string') {
-            logger.error('Linter debe tener un bin válido');
-            return false;
-        }
-        if (!this.validateCommand(linter.bin)) {
-            return false;
-        }
-        if (!linter.configFile || typeof linter.configFile !== 'string') {
-            logger.error('Linter debe tener un configFile válido');
-            return false;
-        }
-        if (!this.validatePath(linter.configFile)) {
-            return false;
-        }
-        if (linter.paths && !Array.isArray(linter.paths)) {
-            logger.error('linter.paths debe ser un array');
-            return false;
-        }
-        if (linter.paths) {
-            for (const path of linter.paths) {
-                if (typeof path !== 'string' || !this.validatePath(path)) {
-                    logger.error(`Ruta de linter no válida: ${path}`);
-                    return false;
-                }
-            }
-        }
-        if (linter.fix !== undefined && typeof linter.fix !== 'boolean') {
-            logger.error('Linter fix debe ser un booleano');
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Valida el tamaño del objeto de configuración
-     */
-    static validateConfigSize(config) {
-        try {
-            const configString = JSON.stringify(config);
-            if (configString.length > this.MAX_CONFIG_SIZE) {
-                logger.error(`Configuración demasiado grande: ${configString.length} bytes`);
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            logger.error('Error al serializar configuración (posible referencia circular):', error);
-            return false;
-        }
-    }
-}
-/**
- * Limpia y normaliza una ruta eliminando barras finales
- */
-function cleanPath(path) {
-    if (!path || typeof path !== 'string') {
-        return '';
-    }
-    return path.endsWith('/') || path.endsWith('\\') ? path.slice(0, -1) : path;
-}
-/**
- * Serializa de forma segura un objeto a JSON
- */
-function safeJsonStringify(obj, fallback = 'false') {
-    try {
-        if (obj === null || obj === undefined) {
-            return fallback;
-        }
-        return JSON.stringify(obj);
-    }
-    catch (error) {
-        logger.warn('Error al serializar objeto, usando valor por defecto:', error);
-        return fallback;
-    }
-}
-/**
- * Wrapper para el import dinámico que permite mejor testing
- */
-export async function dynamicImport(url) {
-    return import(url);
-}
-/**
- * Timeout wrapper para promises
- */
-export function withTimeout(promise, timeoutMs, errorMessage) {
-    const timeoutPromise = new Promise((resolve, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs));
-    return Promise.race([promise, timeoutPromise]);
-}
-/**
- * Lee y valida el archivo de configuración de forma segura
- */
-export async function readConfig() {
-    try {
-        // Validar variable de entorno
-        if (!env.PATH_CONFIG_FILE) {
-            throw new Error('La variable de entorno PATH_CONFIG_FILE no está definida.');
-        }
-        // Validar la ruta del archivo de configuración
-        if (!SecurityValidators.validatePath(env.PATH_CONFIG_FILE)) {
-            throw new Error(`Ruta de configuración no válida: ${env.PATH_CONFIG_FILE}`);
-        }
-        // Convertir la ruta del archivo a una URL file://
-        const configFileUrl = pathToFileURL(env.PATH_CONFIG_FILE).href;
-        // Importar con timeout para prevenir ataques DoS
-        const importPromise = dynamicImport(configFileUrl);
-        const data = await withTimeout(importPromise, 10000, 'Timeout al cargar configuración');
-        if (!data) {
-            throw new Error('No se pudo leer el archivo de configuración.');
-        }
-        const tsConfig = data.default || data;
-        // Validar tamaño de configuración
-        if (!SecurityValidators.validateConfigSize(tsConfig)) {
-            throw new Error('Configuración demasiado grande o contiene referencias circulares.');
-        }
-        // Validar estructura de configuración
-        if (!SecurityValidators.validateConfigStructure(tsConfig)) {
-            throw new Error('El archivo de configuración no tiene una estructura válida.');
-        }
-        // Procesar pathsAlias de forma segura
-        const pathAlias = { ...tsConfig.compilerOptions.pathsAlias }; // Eliminar /* de las rutas de alias
-        for (const key in pathAlias) {
-            const values = pathAlias[key];
-            if (values && Array.isArray(values)) {
-                for (let i = 0; i < values.length; i++) {
-                    if (typeof values[i] === 'string' &&
-                        values[i] !== undefined) {
-                        values[i] = values[i].replace('/*', '');
-                    }
-                }
-            }
-        }
-        // Establecer variables de entorno de forma segura
-        env.PATH_ALIAS = safeJsonStringify(pathAlias, '{}');
-        env.tailwindcss = safeJsonStringify(tsConfig?.tailwindConfig, 'false');
-        env.proxyUrl = (tsConfig?.proxyConfig?.proxyUrl || '').toString();
-        env.AssetsOmit = (tsConfig?.proxyConfig?.assetsOmit || false).toString();
-        env.linter = safeJsonStringify(tsConfig?.linter, 'false');
-        env.tsconfigFile = tsConfig?.tsconfig || './tsconfig.json';
-        // Validar y limpiar rutas
-        const sourceRoot = cleanPath(tsConfig?.compilerOptions?.sourceRoot || './src');
-        const outDir = cleanPath(tsConfig?.compilerOptions?.outDir || './dist');
-        if (!SecurityValidators.validatePath(sourceRoot)) {
-            throw new Error(`sourceRoot no válido: ${sourceRoot}`);
-        }
-        if (!SecurityValidators.validatePath(outDir)) {
-            throw new Error(`outDir no válido: ${outDir}`);
-        }
-        env.PATH_SOURCE = sourceRoot;
-        env.PATH_DIST = outDir;
-        env.aditionalWatch = safeJsonStringify(tsConfig?.aditionalWatch, '[]');
-        env.bundlers = safeJsonStringify(tsConfig?.bundlers, 'false');
-        // Configuración adicional para compatibilidad
-        if (!tsConfig.compilerOptions.sourceRoot) {
-            env.tsConfig = safeJsonStringify(tsConfig, '{}');
-        }
-        logger.info('✅ Configuration loaded and validated successfully');
-        return true;
-    }
-    catch (error) {
-        logger.error(`🚩 Error al leer el archivo ${env.PATH_CONFIG_FILE}: ${error}`, error);
-        return false;
-    }
-}
-/**
- * Inicializa un archivo de configuración seguro por defecto
- */
-export async function initConfig() {
-    try {
-        const fs = await dynamicImport('fs');
-        const path = await dynamicImport('path');
-        const configPath = path.resolve(process.cwd(), env.PATH_CONFIG_FILE || 'versacompile.config.ts');
-        // Validar que la ruta de destino sea segura
-        if (!SecurityValidators.validatePath(configPath)) {
-            throw new Error(`Ruta de configuración no válida: ${configPath}`);
-        }
-        if (fs.existsSync(configPath)) {
-            logger.warn(`🚩 El archivo de configuración '${env.PATH_CONFIG_FILE}' ya existe.`);
-            return true;
-        }
-        const configContent = `// Archivo de configuración de VersaCompiler
-export default {
-    tsconfig: './tsconfig.json',
-    compilerOptions: {
-        sourceRoot: './src',
-        outDir: './dist',
-        pathsAlias: {
-            '/dist/examples/*': ['src/*'],
-            '/dist/public/*': ['public/*'],
-        },
-    },
-    proxyConfig: {
-        proxyUrl: '',
-        assetsOmit: true,
-    },
-    aditionalWatch: ['./app/templates/**/*.twig', './app/templates/**/*.html'],
-    // puede dejar en false o no agregarlo si no quiere que se ejecute el compilador de tailwind
-    tailwindConfig: {
-        bin: './node_modules/.bin/tailwindcss',
-        input: './src/css/input.css',
-        output: './public/css/output.css',
-    },
-    linter: [
-        {
-            name: 'eslint',
-            bin: './node_modules/.bin/eslint',
-            configFile: './.eslintrc.json',
-            fix: false,
-            paths: ['src/']
-        },
-        {
-            name: 'oxlint',
-            bin: './node_modules/.bin/oxlint',
-            configFile: './.oxlintrc.json',
-            fix: false,
-            paths: ['src/']
-        },
-    ],
-    // Configuración de bundlers
-    bundlers: [
-        {
-            name: 'appLoader',
-            fileInput: './public/module/appLoader.js',
-            fileOutput: './public/module/appLoader.prod.js',
-        },
-        {
-            name: 'mainApp',
-            fileInput: './src/main.ts',
-            fileOutput: './dist/main.bundle.js',
-        }
-    ],
-};
-`;
-        fs.writeFileSync(configPath, configContent, 'utf8');
-        logger.info(`🚩 Archivo de configuración '${env.PATH_CONFIG_FILE}' creado correctamente.`);
-        return true;
-    }
-    catch (error) {
-        logger.error(`🚩 Error al crear el archivo de configuración: ${error}`, error);
-        return false;
-    }
-}
-//# sourceMappingURL=readConfig.js.map
+import{normalize as e,relative as d,resolve as f}from"node:path";import*as p from"node:process";import{env as m}from"node:process";import{pathToFileURL as h}from"node:url";import{logger as g}from"./logger.js";const _=260,v=1024*1024,y=/^[a-zA-Z0-9.\-_/\\:@ ()[\]]+$/,b=[/\.\./,/[;&|`$]/,/\$\(/,/`.*`/,/\|\s*[a-zA-Z]/];export function validatePath(m){if(!m||typeof m!=`string`)return!1;if(m.length>260)return g.warn(`Ruta demasiado larga: ${m.length} caracteres`),!1;let h=e(m),_=f(p.cwd(),h),v=d(p.cwd(),_);return v.startsWith(`..`)||h.includes(`..`)?(g.error(`Detectado intento de path traversal: ${m}`),!1):y.test(m)?!0:(g.error(`Caracteres no permitidos en la ruta: ${m}`),!1)}export function validateCommand(e){if(!e||typeof e!=`string`)return!1;if(e.length>260)return g.warn(`Comando demasiado largo: ${e.length} caracteres`),!1;for(let d of b)if(d.test(e))return g.error(`Detectado patrón peligroso en comando: ${e}`),!1;let d=[`.exe`,`.cmd`,`.bat`,`.sh`,`.js`,`.ts`],f=d.some(d=>e.toLowerCase().includes(d)||e.startsWith(`./node_modules/.bin/`)||e.startsWith(`npx `));return f?!0:(g.error(`Comando no permitido: ${e}`),!1)}export function validateBundlers(e){if(!Array.isArray(e))return g.error(`bundlers debe ser un array`),!1;for(let d of e){if(!d||typeof d!=`object`)return g.error(`Cada entrada de bundler debe ser un objeto`),!1;if(!d.name||typeof d.name!=`string`)return g.error(`Cada entrada de bundler debe tener un nombre válido`),!1;if(!d.fileInput||typeof d.fileInput!=`string`)return g.error(`Cada entrada de bundler debe tener un fileInput válido`),!1;if(!validatePath(d.fileInput))return g.error(`Ruta de entrada no válida: ${d.fileInput}`),!1;if(!d.fileOutput||typeof d.fileOutput!=`string`)return g.error(`Cada entrada de bundler debe tener un fileOutput válido`),!1;if(!validatePath(d.fileOutput))return g.error(`Ruta de salida no válida: ${d.fileOutput}`),!1}return!0}export function validateConfigStructure(e){if(!e||typeof e!=`object`)return g.error(`La configuración debe ser un objeto`),!1;if(!e.compilerOptions||typeof e.compilerOptions!=`object`)return g.error(`compilerOptions es requerido y debe ser un objeto`),!1;if(!e.compilerOptions.pathsAlias||typeof e.compilerOptions.pathsAlias!=`object`)return g.error(`pathsAlias es requerido y debe ser un objeto`),!1;for(let[d,f]of Object.entries(e.compilerOptions.pathsAlias)){if(!Array.isArray(f))return g.error(`pathsAlias["${d}"] debe ser un array`),!1;for(let e of f){if(typeof e!=`string`)return g.error(`Todas las rutas en pathsAlias["${d}"] deben ser strings`),!1;if(!validatePath(e.replace(`/*`,``)))return g.error(`Ruta no válida en pathsAlias["${d}"]: ${e}`),!1}}if(e.compilerOptions.sourceRoot&&!validatePath(e.compilerOptions.sourceRoot)||e.compilerOptions.outDir&&!validatePath(e.compilerOptions.outDir))return!1;if(e.linter&&e.linter!==!1){if(!Array.isArray(e.linter))return g.error(`linter debe ser un array o false`),!1;for(let d of e.linter)if(!validateLinter(d))return!1}return!0}export function validateLinter(e){if(!e||typeof e!=`object`)return g.error(`Cada linter debe ser un objeto`),!1;if(!e.name||typeof e.name!=`string`)return g.error(`Linter debe tener un nombre válido`),!1;if(!e.bin||typeof e.bin!=`string`)return g.error(`Linter debe tener un bin válido`),!1;if(!validateCommand(e.bin))return!1;if(!e.configFile||typeof e.configFile!=`string`)return g.error(`Linter debe tener un configFile válido`),!1;if(!validatePath(e.configFile))return!1;if(e.paths&&!Array.isArray(e.paths))return g.error(`linter.paths debe ser un array`),!1;if(e.paths){for(let d of e.paths)if(typeof d!=`string`||!validatePath(d))return g.error(`Ruta de linter no válida: ${d}`),!1}return e.fix!==void 0&&typeof e.fix!=`boolean`?(g.error(`Linter fix debe ser un booleano`),!1):!0}export function validateConfigSize(e){try{let d=JSON.stringify(e);return d.length>1048576?(g.error(`Configuración demasiado grande: ${d.length} bytes`),!1):!0}catch(e){return g.error(`Error al serializar configuración (posible referencia circular):`,e),!1}}function x(e){return!e||typeof e!=`string`?``:e.endsWith(`/`)||e.endsWith(`\\`)?e.slice(0,-1):e}function S(e,d=`false`){try{return e==null?d:JSON.stringify(e)}catch(e){return g.warn(`Error al serializar objeto, usando valor por defecto:`,e),d}}export async function dynamicImport(e){return import(e)}export function withTimeout(e,d,f){let p=new Promise((e,p)=>setTimeout(()=>p(Error(f)),d));return Promise.race([e,p])}export async function readConfig(){try{if(!m.PATH_CONFIG_FILE)throw Error(`La variable de entorno PATH_CONFIG_FILE no está definida.`);if(!validatePath(m.PATH_CONFIG_FILE))throw Error(`Ruta de configuración no válida: ${m.PATH_CONFIG_FILE}`);let e=h(m.PATH_CONFIG_FILE).href,d=dynamicImport(e),f=await withTimeout(d,1e4,`Timeout al cargar configuración`);if(!f)throw Error(`No se pudo leer el archivo de configuración.`);let p=f.default||f;if(!validateConfigSize(p))throw Error(`Configuración demasiado grande o contiene referencias circulares.`);if(!validateConfigStructure(p))throw Error(`El archivo de configuración no tiene una estructura válida.`);let _={...p.compilerOptions.pathsAlias};for(let e in _){let d=_[e];if(d&&Array.isArray(d))for(let e=0;e<d.length;e++)typeof d[e]==`string`&&d[e]!==void 0&&(d[e]=d[e].replace(`/*`,``))}m.PATH_ALIAS=S(_,`{}`),m.tailwindcss=S(p?.tailwindConfig,`false`),m.proxyUrl=String(p?.proxyConfig?.proxyUrl||``),m.AssetsOmit=String(p?.proxyConfig?.assetsOmit||!1),m.linter=S(p?.linter,`false`),m.tsconfigFile=p?.tsconfig||`./tsconfig.json`;let v=x(p?.compilerOptions?.sourceRoot||`./src`),y=x(p?.compilerOptions?.outDir||`./dist`);if(!validatePath(v))throw Error(`sourceRoot no válido: ${v}`);if(!validatePath(y))throw Error(`outDir no válido: ${y}`);return m.PATH_SOURCE=v,m.PATH_DIST=y,m.aditionalWatch=S(p?.aditionalWatch,`[]`),m.bundlers=S(p?.bundlers,`false`),p.compilerOptions.sourceRoot||(m.tsConfig=S(p,`{}`)),g.info(`✅ Configuration loaded and validated successfully`),!0}catch(e){return g.error(`🚩 Error al leer el archivo ${m.PATH_CONFIG_FILE}: ${e}`,e),!1}}export async function initConfig(){try{let e=await dynamicImport(`fs`),d=await dynamicImport(`path`),f=d.resolve(p.cwd(),m.PATH_CONFIG_FILE||`versacompile.config.ts`);if(!validatePath(f))throw Error(`Ruta de configuración no válida: ${f}`);if(e.existsSync(f))return g.warn(`🚩 El archivo de configuración '${m.PATH_CONFIG_FILE}' ya existe.`),!0;let h=`// Archivo de configuración de VersaCompiler
+export default {
+    tsconfig: './tsconfig.json',
+    compilerOptions: {
+        sourceRoot: './src',
+        outDir: './dist',
+        pathsAlias: {
+            '/dist/examples/*': ['src/*'],
+            '/dist/public/*': ['public/*'],
+        },
+    },
+    proxyConfig: {
+        proxyUrl: '',
+        assetsOmit: true,
+    },
+    aditionalWatch: ['./app/templates/**/*.twig', './app/templates/**/*.html'],
+    // puede dejar en false o no agregarlo si no quiere que se ejecute el compilador de tailwind
+    tailwindConfig: {
+        bin: './node_modules/.bin/tailwindcss',
+        input: './src/css/input.css',
+        output: './public/css/output.css',
+    },
+    linter: [
+        {
+            name: 'eslint',
+            bin: './node_modules/.bin/eslint',
+            configFile: './.eslintrc.json',
+            fix: false,
+            paths: ['src/']
+        },
+        {
+            name: 'oxlint',
+            bin: './node_modules/.bin/oxlint',
+            configFile: './.oxlintrc.json',
+            fix: false,
+            paths: ['src/']
+        },
+    ],
+    // Configuración de bundlers
+    bundlers: [
+        {
+            name: 'appLoader',
+            fileInput: './public/module/appLoader.js',
+            fileOutput: './public/module/appLoader.prod.js',
+        },
+        {
+            name: 'mainApp',
+            fileInput: './src/main.ts',
+            fileOutput: './dist/main.bundle.js',
+        }
+    ],
+};
+`;return e.writeFileSync(f,`// Archivo de configuración de VersaCompiler
+export default {
+    tsconfig: './tsconfig.json',
+    compilerOptions: {
+        sourceRoot: './src',
+        outDir: './dist',
+        pathsAlias: {
+            '/dist/examples/*': ['src/*'],
+            '/dist/public/*': ['public/*'],
+        },
+    },
+    proxyConfig: {
+        proxyUrl: '',
+        assetsOmit: true,
+    },
+    aditionalWatch: ['./app/templates/**/*.twig', './app/templates/**/*.html'],
+    // puede dejar en false o no agregarlo si no quiere que se ejecute el compilador de tailwind
+    tailwindConfig: {
+        bin: './node_modules/.bin/tailwindcss',
+        input: './src/css/input.css',
+        output: './public/css/output.css',
+    },
+    linter: [
+        {
+            name: 'eslint',
+            bin: './node_modules/.bin/eslint',
+            configFile: './.eslintrc.json',
+            fix: false,
+            paths: ['src/']
+        },
+        {
+            name: 'oxlint',
+            bin: './node_modules/.bin/oxlint',
+            configFile: './.oxlintrc.json',
+            fix: false,
+            paths: ['src/']
+        },
+    ],
+    // Configuración de bundlers
+    bundlers: [
+        {
+            name: 'appLoader',
+            fileInput: './public/module/appLoader.js',
+            fileOutput: './public/module/appLoader.prod.js',
+        },
+        {
+            name: 'mainApp',
+            fileInput: './src/main.ts',
+            fileOutput: './dist/main.bundle.js',
+        }
+    ],
+};
+`,`utf8`),g.info(`🚩 Archivo de configuración '${m.PATH_CONFIG_FILE}' creado correctamente.`),!0}catch(e){return g.error(`🚩 Error al crear el archivo de configuración: ${e}`,e),!1}}

package/dist/utils/excluded-modules.js

@@ -1,36 +1 @@
-/**
- * Lista centralizada de módulos excluidos de la resolución automática
- * Estos módulos se mantienen con su importación original sin transformar
- */
-export const EXCLUDED_MODULES = new Set([
-    // Módulos de Vue.js que requieren resolución específica
-    'vue/compiler-sfc',
-    'vue/dist/vue.runtime.esm-bundler',
-    '@vue/compiler-sfc',
-    '@vue/compiler-dom',
-    '@vue/runtime-core',
-    '@vue/runtime-dom',
-    // Módulos de oxc-parser que tienen dependencias específicas de WASM
-    'oxc-parser',
-    'oxc-parser/wasm',
-    'oxc-minify',
-    'oxc-minify/browser',
-    '@oxc-parser/binding-wasm32-wasi',
-    '@oxc-minify/binding-wasm32-wasi',
-    // Módulos de TypeScript que pueden tener resoluciones complejas
-    'typescript',
-    'typescript/lib/typescript',
-    // Módulos de herramientas de build y utilidades que deben mantenerse originales
-    'yargs',
-    'yargs/helpers',
-    'yargs-parser',
-    'chalk',
-    'browser-sync',
-    'chokidar',
-    'get-port',
-    'execa',
-    'find-root',
-    'fs-extra',
-    'minimatch', // ✅ Incluir minimatch aquí
-]);
-//# sourceMappingURL=excluded-modules.js.map
+export const EXCLUDED_MODULES=new Set([`vue/compiler-sfc`,`vue/dist/vue.runtime.esm-bundler`,`@vue/compiler-sfc`,`@vue/compiler-dom`,`@vue/runtime-core`,`@vue/runtime-dom`,`oxc-parser`,`oxc-parser/wasm`,`oxc-minify`,`oxc-minify/browser`,`@oxc-parser/binding-wasm32-wasi`,`@oxc-minify/binding-wasm32-wasi`,`typescript`,`typescript/lib/typescript`,`yargs`,`yargs/helpers`,`yargs-parser`,`chalk`,`browser-sync`,`chokidar`,`get-port`,`execa`,`find-root`,`fs-extra`,`minimatch`]);