versacompiler 2.1.0 → 2.2.0

package/dist/servicios/readConfig.js

@@ -1,53 +1,399 @@
-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 _=/^[a-zA-Z0-9.\-_/\\:@ ()[\]]+$/,v=[/\.\./,/[;&|`$]/,/\$\(/,/`.*`/,/\|\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),v=f(p.cwd(),h);return d(p.cwd(),v).startsWith(`..`)||h.includes(`..`)?(g.error(`Detectado intento de path traversal: ${m}`),!1):_.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 v)if(d.test(e))return g.error(`Detectado patrón peligroso en comando: ${e}`),!1;return[`.exe`,`.cmd`,`.bat`,`.sh`,`.js`,`.ts`].some(d=>e.toLowerCase().includes(d)||e.startsWith(`./node_modules/.bin/`)||e.startsWith(`npx `))?!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 y(e){return!e||typeof e!=`string`?``:e.endsWith(`/`)||e.endsWith(`\\`)?e.slice(0,-1):e}function b(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=await withTimeout(dynamicImport(e),1e4,`Timeout al cargar configuración`);if(!d)throw Error(`No se pudo leer el archivo de configuración.`);let f=d.default||d;if(!validateConfigSize(f))throw Error(`Configuración demasiado grande o contiene referencias circulares.`);if(!validateConfigStructure(f))throw Error(`El archivo de configuración no tiene una estructura válida.`);let p={...f.compilerOptions.pathsAlias};for(let e in p){let d=p[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=b(p,`{}`),m.tailwindcss=b(f?.tailwindConfig,`false`),m.proxyUrl=String(f?.proxyConfig?.proxyUrl||``),m.AssetsOmit=String(f?.proxyConfig?.assetsOmit||!1),m.linter=b(f?.linter,`false`),m.tsconfigFile=f?.tsconfig||`./tsconfig.json`;let _=y(f?.compilerOptions?.sourceRoot||`./src`),v=y(f?.compilerOptions?.outDir||`./dist`);if(!validatePath(_))throw Error(`sourceRoot no válido: ${_}`);if(!validatePath(v))throw Error(`outDir no válido: ${v}`);return m.PATH_SOURCE=_,m.PATH_DIST=v,m.aditionalWatch=b(f?.aditionalWatch,`[]`),m.bundlers=b(f?.bundlers,`false`),f.compilerOptions.sourceRoot||(m.tsConfig=b(f,`{}`)),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`)).resolve(p.cwd(),m.PATH_CONFIG_FILE||`versacompile.config.ts`);if(!validatePath(d))throw Error(`Ruta de configuración no válida: ${d}`);return e.existsSync(d)?(g.warn(`🚩 El archivo de configuración '${m.PATH_CONFIG_FILE}' ya existe.`),!0):(e.writeFileSync(d,`// 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}}
+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
+ */
+const MAX_PATH_LENGTH = 260; // Windows MAX_PATH limit
+const MAX_CONFIG_SIZE = 1024 * 1024; // 1MB max config size
+const ALLOWED_PATH_CHARS = /^[a-zA-Z0-9.\-_/\\:@ ()[\]]+$/;
+const DANGEROUS_PATTERNS = [
+    /\.\./, // Path traversal
+    /[;&|`$]/, // Command injection characters
+    /\$\(/, // Command substitution
+    /`.*`/, // Backtick execution
+    /\|\s*[a-zA-Z]/, // Pipe to commands
+];
+export function validatePath(pathStr) {
+    if (!pathStr || typeof pathStr !== 'string') {
+        return false;
+    }
+    if (pathStr.length > MAX_PATH_LENGTH) {
+        logger.warn(`Ruta demasiado larga: ${pathStr.length} caracteres`);
+        return false;
+    }
+    // Normalizar la ruta para detectar path traversal
+    const normalizedPath = normalize(pathStr);
+    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: ${pathStr}`);
+        return false;
+    }
+    // Verificar caracteres permitidos
+    if (!ALLOWED_PATH_CHARS.test(pathStr)) {
+        logger.error(`Caracteres no permitidos en la ruta: ${pathStr}`);
+        return false;
+    }
+    return true;
+}
+export function validateCommand(command) {
+    if (!command || typeof command !== 'string') {
+        return false;
+    }
+    if (command.length > MAX_PATH_LENGTH) {
+        logger.warn(`Comando demasiado largo: ${command.length} caracteres`);
+        return false;
+    }
+    // Verificar patrones peligrosos
+    for (const pattern of 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;
+}
+export function 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 (!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 (!validatePath(entry.fileOutput)) {
+            logger.error(`Ruta de salida no válida: ${entry.fileOutput}`);
+            return false;
+        }
+    }
+    return true;
+}
+export function 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 p of value) {
+            if (typeof p !== 'string') {
+                logger.error(`Todas las rutas en pathsAlias["${key}"] deben ser strings`);
+                return false;
+            }
+            if (!validatePath(p.replace('/*', ''))) {
+                logger.error(`Ruta no válida en pathsAlias["${key}"]: ${p}`);
+                return false;
+            }
+        }
+    }
+    // Validar sourceRoot si existe
+    if (config.compilerOptions.sourceRoot && !validatePath(config.compilerOptions.sourceRoot)) {
+        return false;
+    }
+    // Validar outDir si existe
+    if (config.compilerOptions.outDir && !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 (!validateLinter(linter)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+export function 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 (!validateCommand(linter.bin)) {
+        return false;
+    }
+    if (!linter.configFile || typeof linter.configFile !== 'string') {
+        logger.error('Linter debe tener un configFile válido');
+        return false;
+    }
+    if (!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 p of linter.paths) {
+            if (typeof p !== 'string' || !validatePath(p)) {
+                logger.error(`Ruta de linter no válida: ${p}`);
+                return false;
+            }
+        }
+    }
+    if (linter.fix !== undefined && typeof linter.fix !== 'boolean') {
+        logger.error('Linter fix debe ser un booleano');
+        return false;
+    }
+    return true;
+}
+export function validateConfigSize(config) {
+    try {
+        const configString = JSON.stringify(config);
+        if (configString.length > 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 (!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 (!validateConfigSize(tsConfig)) {
+            throw new Error('Configuración demasiado grande o contiene referencias circulares.');
+        }
+        // Validar estructura de configuración
+        if (!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 = String(tsConfig?.proxyConfig?.proxyUrl || '');
+        env.AssetsOmit = String(tsConfig?.proxyConfig?.assetsOmit || false);
+        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 (!validatePath(sourceRoot)) {
+            throw new Error(`sourceRoot no válido: ${sourceRoot}`);
+        }
+        if (!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 (!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

package/dist/utils/excluded-modules.js

@@ -1 +1,37 @@
-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`]);
+/**
+ * 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í
+    'minify-html-literals',
+]);
+//# sourceMappingURL=excluded-modules.js.map