versacompiler 2.0.0 → 2.0.2

package/dist/compiler/transforms.js

@@ -1,8 +1,10 @@
 import path from 'node:path';
 import { env } from 'node:process';
 import { logger } from '../servicios/logger.js';
+import { EXCLUDED_MODULES } from '../utils/excluded-modules.js';
 import { getModuleSubPath } from '../utils/module-resolver.js';
 import { analyzeAndFormatMultipleErrors } from './error-reporter.js';
+import { getOptimizedAliasPath, getOptimizedModulePath, } from './module-resolution-optimizer.js';
 import { parser } from './parser.js';
 // Módulos built-in de Node.js que no deben ser resueltos
 const NODE_BUILTIN_MODULES = new Set([
@@ -69,21 +71,6 @@ function isExternalModule(moduleRequest, pathAlias) {
     } // NUEVA LÓGICA: Verificar PRIMERO si es un módulo excluido antes de verificar alias
     // Esto es importante porque algunos módulos excluidos pueden tener nombres que
     // coinciden con patrones de alias (como @vue/compiler-sfc con @/*)
-    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/lib/typescript',
-    ]);
     if (EXCLUDED_MODULES.has(moduleRequest)) {
         return true;
     } // Descartar alias conocidos
@@ -118,50 +105,77 @@ export async function replaceAliasImportStatic(file, code) {
         if (!moduleRequest)
             continue; // Skip if moduleRequest is undefined
         let newPath = null;
-        let transformed = false;
-        // 1. PRIMERO: Verificar si es un módulo excluido (prioridad máxima)
+        let transformed = false; // 1. PRIMERO: Verificar si es un módulo excluido (prioridad máxima)
         if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
             try {
-                const modulePath = getModuleSubPath(moduleRequest, file);
-                if (modulePath === null) {
-                    // Si getModuleSubPath retorna null, significa que es un módulo excluido
-                    // No transformar y continuar con el siguiente import
+                // Usar el sistema optimizado primero
+                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedPath === null) {
+                    // Si el optimizador retorna null, significa que es un módulo excluido
                     continue;
                 }
-                if (modulePath) {
-                    newPath = modulePath;
+                if (optimizedPath) {
+                    newPath = optimizedPath;
                     transformed = true;
                 }
+                else {
+                    // Fallback al sistema anterior
+                    const modulePath = getModuleSubPath(moduleRequest, file);
+                    if (modulePath === null) {
+                        continue;
+                    }
+                    if (modulePath) {
+                        newPath = modulePath;
+                        transformed = true;
+                    }
+                }
             }
             catch (error) {
                 if (env.VERBOSE === 'true')
                     logger.warn(`Error resolviendo módulo ${moduleRequest}: ${error instanceof Error ? error.message : String(error)}`);
             }
-        }
-        // 2. Si no es módulo externo/excluido, verificar si es un alias conocido
+        } // 2. Si no es módulo externo/excluido, verificar si es un alias conocido
         if (!transformed) {
-            for (const [alias] of Object.entries(pathAlias)) {
-                const aliasPattern = alias.replace('/*', '');
-                if (moduleRequest.startsWith(aliasPattern)) {
-                    // Reemplazar el alias con la ruta del target
-                    const relativePath = moduleRequest.replace(aliasPattern, '');
-                    // Para alias que apuntan a la raíz (como @/* -> /src/*),
-                    // solo usamos PATH_DIST + relativePath
-                    let newImportPath = path.join('/', env.PATH_DIST, relativePath);
-                    // Normalizar la ruta para eliminar ./ extra y separadores de Windows
-                    newImportPath = newImportPath
-                        .replace(/\/\.\//g, '/')
-                        .replace(/\\/g, '/');
-                    if (newImportPath.endsWith('.ts') ||
-                        newImportPath.endsWith('.vue')) {
-                        newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
-                    }
-                    else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
-                        newImportPath += '.js';
+            // Usar el sistema optimizado de alias
+            const aliasPath = getOptimizedAliasPath(moduleRequest);
+            if (aliasPath) {
+                let newImportPath = aliasPath;
+                // Transformar extensiones
+                if (newImportPath.endsWith('.ts') ||
+                    newImportPath.endsWith('.vue')) {
+                    newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                }
+                else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                    newImportPath += '.js';
+                }
+                newPath = newImportPath;
+                transformed = true;
+            }
+            else {
+                // Fallback al sistema anterior
+                for (const [alias] of Object.entries(pathAlias)) {
+                    const aliasPattern = alias.replace('/*', '');
+                    if (moduleRequest.startsWith(aliasPattern)) {
+                        // Reemplazar el alias con la ruta del target
+                        const relativePath = moduleRequest.replace(aliasPattern, '');
+                        // Para alias que apuntan a la raíz (como @/* -> /src/*),
+                        // solo usamos PATH_DIST + relativePath
+                        let newImportPath = path.join('/', env.PATH_DIST, relativePath);
+                        // Normalizar la ruta para eliminar ./ extra y separadores de Windows
+                        newImportPath = newImportPath
+                            .replace(/\/\.\//g, '/')
+                            .replace(/\\/g, '/');
+                        if (newImportPath.endsWith('.ts') ||
+                            newImportPath.endsWith('.vue')) {
+                            newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                        }
+                        else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                            newImportPath += '.js';
+                        }
+                        newPath = newImportPath;
+                        transformed = true;
+                        break;
                     }
-                    newPath = newImportPath;
-                    transformed = true;
-                    break;
                 }
             }
         }
@@ -206,50 +220,77 @@ async function replaceAliasImportDynamic(code, _imports, file) {
         if (!moduleRequest)
             continue; // Skip if moduleRequest is undefined
         let newPath = null;
-        let transformed = false;
-        // 1. PRIMERO: Verificar si es un módulo excluido (prioridad máxima)
+        let transformed = false; // 1. PRIMERO: Verificar si es un módulo excluido (prioridad máxima)
         if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
             try {
-                const modulePath = getModuleSubPath(moduleRequest, file);
-                if (modulePath === null) {
-                    // Si getModuleSubPath retorna null, significa que es un módulo excluido
-                    // No transformar y continuar con el siguiente import
+                // Usar el sistema optimizado primero
+                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedPath === null) {
+                    // Si el optimizador retorna null, significa que es un módulo excluido
                     continue;
                 }
-                if (modulePath) {
-                    newPath = modulePath;
+                if (optimizedPath) {
+                    newPath = optimizedPath;
                     transformed = true;
                 }
+                else {
+                    // Fallback al sistema anterior
+                    const modulePath = getModuleSubPath(moduleRequest, file);
+                    if (modulePath === null) {
+                        continue;
+                    }
+                    if (modulePath) {
+                        newPath = modulePath;
+                        transformed = true;
+                    }
+                }
             }
             catch (error) {
                 if (env.VERBOSE === 'true')
                     logger.warn(`Error resolviendo módulo dinámico ${moduleRequest}: ${error instanceof Error ? error.message : String(error)}`);
             }
-        }
-        // 2. Si no es módulo externo/excluido, verificar si es un alias conocido
+        } // 2. Si no es módulo externo/excluido, verificar si es un alias conocido
         if (!transformed) {
-            for (const [alias] of Object.entries(pathAlias)) {
-                const aliasPattern = alias.replace('/*', '');
-                if (moduleRequest.startsWith(aliasPattern)) {
-                    // Reemplazar el alias con la ruta del target
-                    const relativePath = moduleRequest.replace(aliasPattern, '');
-                    // Para alias que apuntan a la raíz (como @/* -> /src/*),
-                    // solo usamos PATH_DIST + relativePath
-                    let newImportPath = path.join('/', pathDist, relativePath);
-                    // Normalizar la ruta para eliminar ./ extra y separadores de Windows
-                    newImportPath = newImportPath
-                        .replace(/\/\.\//g, '/')
-                        .replace(/\\/g, '/');
-                    if (newImportPath.endsWith('.ts') ||
-                        newImportPath.endsWith('.vue')) {
-                        newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
-                    }
-                    else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
-                        newImportPath += '.js';
+            // Usar el sistema optimizado de alias
+            const aliasPath = getOptimizedAliasPath(moduleRequest);
+            if (aliasPath) {
+                let newImportPath = aliasPath;
+                // Transformar extensiones
+                if (newImportPath.endsWith('.ts') ||
+                    newImportPath.endsWith('.vue')) {
+                    newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                }
+                else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                    newImportPath += '.js';
+                }
+                newPath = newImportPath;
+                transformed = true;
+            }
+            else {
+                // Fallback al sistema anterior
+                for (const [alias] of Object.entries(pathAlias)) {
+                    const aliasPattern = alias.replace('/*', '');
+                    if (moduleRequest.startsWith(aliasPattern)) {
+                        // Reemplazar el alias con la ruta del target
+                        const relativePath = moduleRequest.replace(aliasPattern, '');
+                        // Para alias que apuntan a la raíz (como @/* -> /src/*),
+                        // solo usamos PATH_DIST + relativePath
+                        let newImportPath = path.join('/', pathDist, relativePath);
+                        // Normalizar la ruta para eliminar ./ extra y separadores de Windows
+                        newImportPath = newImportPath
+                            .replace(/\/\.\//g, '/')
+                            .replace(/\\/g, '/');
+                        if (newImportPath.endsWith('.ts') ||
+                            newImportPath.endsWith('.vue')) {
+                            newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                        }
+                        else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                            newImportPath += '.js';
+                        }
+                        newPath = newImportPath;
+                        transformed = true;
+                        break;
                     }
-                    newPath = newImportPath;
-                    transformed = true;
-                    break;
                 }
             }
         }
@@ -374,48 +415,25 @@ async function replaceAliasInStrings(code) {
                 // IMPORTANTE: Verificar si es un módulo excluido antes de transformar
                 if (isExternalModule(stringContent, pathAlias)) {
                     // Para strings que parecen ser módulos externos, verificar si están excluidos
-                    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/lib/typescript',
-                    ]);
                     if (EXCLUDED_MODULES.has(stringContent)) {
                         // Es un módulo excluido, no transformar
                         continue;
                     }
-                } // Reemplazar el alias con la ruta del target
+                }
+                // Reemplazar el alias con la ruta del target
                 const relativePath = stringContent.replace(aliasPattern, '');
                 // Construir la nueva ruta basada en la configuración del target
                 let newPath;
                 // El target puede ser un array de strings o un string
                 const targetArray = Array.isArray(target) ? target : [target];
                 const targetPath = targetArray[0];
-                // Debug logs
-                if (env.VERBOSE === 'true') {
-                    console.log(`🔍 DEBUG replaceAliasInStrings:
-  - stringContent: "${stringContent}"
-  - aliasPattern: "${aliasPattern}"
-  - relativePath: "${relativePath}"
-  - targetPath: "${targetPath}"
-  - pathDist: "${pathDist}"`);
-                }
                 if (targetPath.startsWith('/')) {
                     // Si el target empieza con /, es una ruta absoluta desde la raíz del proyecto
-                    // Remover /* del final si existe
-                    const cleanTarget = targetPath.replace('/*', '');
-                    newPath = path.join(cleanTarget, relativePath);
+                    // Para targets como "/src/*", solo usamos PATH_DIST + relativePath
+                    // sin incluir el directorio del target en la ruta final
+                    newPath = path.join('/', pathDist, relativePath);
                     if (env.VERBOSE === 'true') {
-                        console.log(`  ✅ Ruta absoluta: cleanTarget="${cleanTarget}", newPath="${newPath}"`);
+                        console.log(`  ✅ Ruta absoluta: pathDist="${pathDist}", relativePath="${relativePath}", newPath="${newPath}"`);
                     }
                 }
                 else {
@@ -424,22 +442,13 @@ async function replaceAliasInStrings(code) {
                         .replace('./', '')
                         .replace('/*', '');
                     const normalizedPathDist = pathDist.replace('./', '');
-                    if (env.VERBOSE === 'true') {
-                        console.log(`  🔍 Ruta relativa: cleanTarget="${cleanTarget}", normalizedPathDist="${normalizedPathDist}"`);
-                    }
                     if (cleanTarget === normalizedPathDist) {
                         // Si el target es el mismo que PATH_DIST, no duplicar
                         newPath = path.join('/', normalizedPathDist, relativePath);
-                        if (env.VERBOSE === 'true') {
-                            console.log(`  ✅ Sin duplicación: newPath="${newPath}"`);
-                        }
                     }
                     else {
                         // Si es diferente, usar PATH_DIST como base
                         newPath = path.join('/', normalizedPathDist, cleanTarget, relativePath);
-                        if (env.VERBOSE === 'true') {
-                            console.log(`  ✅ Con PATH_DIST: newPath="${newPath}"`);
-                        }
                     }
                 }
                 // Normalizar la ruta para eliminar ./ extra y separadores de Windows
@@ -460,9 +469,6 @@ async function replaceAliasInStrings(code) {
             const escapedOriginal = fullMatch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
             const specificRegex = new RegExp(escapedOriginal, 'g');
             resultCode = resultCode.replace(specificRegex, newFullMatch);
-            if (env.VERBOSE === 'true') {
-                logger.info(`Alias en string transformado: ${stringContent} -> ${newStringContent}`);
-            }
         }
     }
     return resultCode;

package/dist/compiler/{typescript.js → typescript-compiler.js}

@@ -1,7 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import * as process from 'node:process';
 import { env } from 'node:process';
-import * as ts from 'typescript';
+import * as typescript from 'typescript';
 import { createUnifiedErrorMessage, parseTypeScriptErrors, } from './typescript-error-parser.js';
 import { TypeScriptWorkerManager } from './typescript-worker.js';
 /**
@@ -15,8 +16,7 @@ let configCache = {};
  */
 export const loadTypeScriptConfig = (fileName) => {
     const fileDir = path.dirname(fileName);
-    const configPath = ts.findConfigFile(fileDir, ts.sys.fileExists, 'tsconfig.json') ||
-        path.resolve(process.cwd(), 'tsconfig.json');
+    const configPath = typescript.findConfigFile(fileDir, typescript.sys.fileExists, 'tsconfig.json') || path.resolve(process.cwd(), 'tsconfig.json');
     // Usar cache si el path no ha cambiado
     if (configCache.path === configPath && configCache.options) {
         return configCache.options;
@@ -24,9 +24,9 @@ export const loadTypeScriptConfig = (fileName) => {
     let compilerOptions;
     if (configPath && fs.existsSync(configPath)) {
         try {
-            const { config, error: configError } = ts.readConfigFile(configPath, ts.sys.readFile);
+            const { config, error: configError } = typescript.readConfigFile(configPath, typescript.sys.readFile);
             if (!configError) {
-                const parsedConfig = ts.parseJsonConfigFileContent(config, ts.sys, path.dirname(configPath));
+                const parsedConfig = typescript.parseJsonConfigFileContent(config, typescript.sys, path.dirname(configPath));
                 compilerOptions = {
                     ...parsedConfig.options,
                     // Asegurar opciones básicas necesarias
@@ -59,8 +59,8 @@ export const loadTypeScriptConfig = (fileName) => {
  * Obtiene las opciones por defecto del compilador TypeScript
  */
 const getDefaultCompilerOptions = () => ({
-    target: ts.ScriptTarget.ES2020,
-    module: ts.ModuleKind.ES2020,
+    target: typescript.ScriptTarget.ES2020,
+    module: typescript.ModuleKind.ES2020,
     lib: ['es2020', 'dom', 'dom.iterable'],
     strict: false,
     skipLibCheck: true,
@@ -70,13 +70,13 @@ const getDefaultCompilerOptions = () => ({
     isolatedModules: true,
 });
 /**
- * Crea una versión optimizada y serializable de las opciones del compilador TypeScript.
+ * Crea una versión optimizada y serializable de las opciones del compilador typescript.
  * @param options - Opciones originales del compilador
  * @returns Opciones serializables seguras para workers
  */
 const createSerializableCompilerOptions = (options) => {
     // Usar las opciones del tsconfig.json pero con optimizaciones para el worker
-    const { target = ts.ScriptTarget.ES2020, module = ts.ModuleKind.ES2020, lib = ['es2020', 'dom', 'dom.iterable'], allowJs = true, jsx, strict = false, skipLibCheck = true, esModuleInterop = true, allowSyntheticDefaultImports = true, isolatedModules = true, } = options;
+    const { target = typescript.ScriptTarget.ES2020, module = typescript.ModuleKind.ES2020, lib = ['es2020', 'dom', 'dom.iterable'], allowJs = true, jsx, strict = false, skipLibCheck = true, esModuleInterop = true, allowSyntheticDefaultImports = true, isolatedModules = true, } = options;
     return {
         target,
         module,
@@ -124,13 +124,13 @@ class TypeScriptLanguageServiceHost {
     getScriptSnapshot(fileName) {
         const file = this.files.get(fileName);
         if (file) {
-            return ts.ScriptSnapshot.fromString(file.content);
+            return typescript.ScriptSnapshot.fromString(file.content);
         }
         // Cache de sistema de archivos para evitar lecturas repetidas
         if (this.fileSystemCache.has(fileName)) {
             const cachedContent = this.fileSystemCache.get(fileName);
             return cachedContent
-                ? ts.ScriptSnapshot.fromString(cachedContent)
+                ? typescript.ScriptSnapshot.fromString(cachedContent)
                 : undefined;
         }
         // Intentar leer el archivo del sistema de archivos solo si es necesario
@@ -138,7 +138,7 @@ class TypeScriptLanguageServiceHost {
             if (fs.existsSync(fileName)) {
                 const content = fs.readFileSync(fileName, 'utf-8');
                 this.fileSystemCache.set(fileName, content);
-                return ts.ScriptSnapshot.fromString(content);
+                return typescript.ScriptSnapshot.fromString(content);
             }
         }
         catch {
@@ -151,7 +151,7 @@ class TypeScriptLanguageServiceHost {
         return process.cwd();
     }
     getDefaultLibFileName(options) {
-        return ts.getDefaultLibFilePath(options);
+        return typescript.getDefaultLibFilePath(options);
     }
     fileExists(path) {
         if (this.files.has(path))
@@ -185,7 +185,7 @@ class TypeScriptLanguageServiceHost {
         return undefined;
     }
     getNewLine() {
-        return ts.sys.newLine;
+        return typescript.sys.newLine;
     }
 }
 /**
@@ -230,9 +230,8 @@ export {};`;
         }
         else {
             host.addFile(actualFileName, content);
-        }
-        // Crear Language Service
-        const languageService = ts.createLanguageService(host);
+        } // Crear Language Service
+        const languageService = typescript.createLanguageService(host);
         // Verificar existencia del archivo
         if (!host.fileExists(actualFileName)) {
             return { diagnostics: [], hasErrors: false };
@@ -246,12 +245,11 @@ export {};`;
         catch {
             // Ignorar errores de diagnósticos
             return { diagnostics: [], hasErrors: false };
-        }
-        // Filtrado optimizado de diagnósticos
+        } // Filtrado optimizado de diagnósticos
         const filteredDiagnostics = allDiagnostics.filter(diag => {
-            if (diag.category !== ts.DiagnosticCategory.Error)
+            if (diag.category !== typescript.DiagnosticCategory.Error)
                 return false;
-            const messageText = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+            const messageText = typescript.flattenDiagnosticMessageText(diag.messageText, '\n');
             // Lista optimizada de patrones a ignorar
             const ignorePatterns = [
                 'Cannot find module',
@@ -277,7 +275,7 @@ export {};`;
                     start: undefined,
                     length: undefined,
                     messageText: `Error en validación de tipos: ${error instanceof Error ? error.message : 'Error desconocido'}`,
-                    category: ts.DiagnosticCategory.Error,
+                    category: typescript.DiagnosticCategory.Error,
                     code: 0,
                 },
             ],
@@ -298,7 +296,7 @@ export const validateVueTypes = (vueContent, fileName) => {
 /**
  * Precompila el código TypeScript con pipeline optimizado para máxima performance.
  * @param {string} data - El código TypeScript a precompilar.
- * @param {string} fileName - El nombre del archivo que contiene el código TypeScript.
+ * @param {string} fileName - El nombre del archivo que contiene el código typescript.
  * @returns {Promise<CompileResult>} - Un objeto con el código precompilado o un error.
  */
 export const preCompileTS = async (data, fileName) => {
@@ -308,9 +306,8 @@ export const preCompileTS = async (data, fileName) => {
             return { error: null, data: data, lang: 'ts' };
         }
         // Cargar configuración de TypeScript desde tsconfig.json
-        const compilerOptions = loadTypeScriptConfig(fileName);
-        // PASO 1: Transpilación rápida con detección de errores críticos
-        const transpileResult = ts.transpileModule(data, {
+        const compilerOptions = loadTypeScriptConfig(fileName); // PASO 1: Transpilación rápida con detección de errores críticos
+        const transpileResult = typescript.transpileModule(data, {
             compilerOptions: {
                 ...compilerOptions,
                 noLib: true,
@@ -324,10 +321,10 @@ export const preCompileTS = async (data, fileName) => {
         //     fileName,data)
         // Verificar errores críticos de sintaxis
         if (transpileResult.diagnostics?.length) {
-            const criticalErrors = transpileResult.diagnostics.filter(diag => {
-                if (diag.category !== ts.DiagnosticCategory.Error)
+            const criticalErrors = transpileResult.diagnostics.filter((diag) => {
+                if (diag.category !== typescript.DiagnosticCategory.Error)
                     return false;
-                const messageText = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+                const messageText = typescript.flattenDiagnosticMessageText(diag.messageText, '\n');
                 // Ignorar errores de módulo no encontrado
                 return (!messageText.includes('Cannot find module') &&
                     !messageText.includes('Could not find source file') &&
@@ -379,4 +376,4 @@ export const preCompileTS = async (data, fileName) => {
         };
     }
 };
-//# sourceMappingURL=typescript.js.map
+//# sourceMappingURL=typescript-compiler.js.map

package/dist/compiler/typescript-error-parser.js

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import * as typescript from 'typescript';
 /**
  * Parsea errores de TypeScript y los convierte a un formato limpio
  * que incluye solo: archivo, mensaje, severidad y ubicación como ayuda
@@ -6,14 +6,13 @@ import * as ts from 'typescript';
 export function parseTypeScriptErrors(diagnostics, fileName, sourceCode) {
     return diagnostics.map(diagnostic => {
         // Usar el mejorador de errores para obtener mensaje detallado
-        const enhancedMessage = enhanceErrorMessage(diagnostic, fileName, sourceCode);
-        // Determinar la severidad
+        const enhancedMessage = enhanceErrorMessage(diagnostic, fileName, sourceCode); // Determinar la severidad
         let severity;
         switch (diagnostic.category) {
-            case ts.DiagnosticCategory.Error:
+            case typescript.DiagnosticCategory.Error:
                 severity = 'error';
                 break;
-            case ts.DiagnosticCategory.Warning:
+            case typescript.DiagnosticCategory.Warning:
                 severity = 'warning';
                 break;
             default:
@@ -67,7 +66,7 @@ function enhanceErrorMessage(diagnostic, fileName, sourceCode) {
     // Extraer el mensaje del error
     const message = typeof diagnostic.messageText === 'string'
         ? diagnostic.messageText
-        : ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+        : typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
     let enhancedMessage = cleanErrorMessage(message); // Información de ubicación
     let location = `Código TS${diagnostic.code}`;
     let codeContext = '';
@@ -242,7 +241,7 @@ export function createSimpleErrorMessage(diagnostics, _fileName) {
     const firstDiagnostic = diagnostics[0];
     if (!firstDiagnostic)
         return '';
-    const message = ts.flattenDiagnosticMessageText(firstDiagnostic.messageText, '\n');
+    const message = typescript.flattenDiagnosticMessageText(firstDiagnostic.messageText, '\n');
     // Extraer solo la primera línea del mensaje para simplicidad
     const simplifiedMessage = message.split('\n')[0];
     let location = '';