versacompiler 1.0.4 → 2.0.0

package/dist/compiler/typescript-worker.js

@@ -0,0 +1,309 @@
+/**
+ * TypeScript Worker Manager - Gestiona workers dedicados para type checking asíncrono
+ * Implementa el patrón Singleton para reutilizar workers entre compilaciones
+ */
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { Worker } from 'node:worker_threads';
+import { validateTypesWithLanguageService } from './typescript-sync-validator.js';
+/**
+ * Gestiona workers dedicados para type checking asíncrono de TypeScript
+ * Implementa patrón Singleton para eficiencia y reutilización de recursos
+ */
+export class TypeScriptWorkerManager {
+    static instance;
+    worker = null;
+    pendingTasks = new Map();
+    taskCounter = 0;
+    workerReady = false;
+    initPromise = null;
+    // Configuración del worker
+    WORKER_TIMEOUT = 30000; // 30 segundos timeout (incrementado)
+    MAX_RETRY_ATTEMPTS = 2;
+    // NUEVOS: Gestión de modo y estado para optimización
+    currentMode = null;
+    constructor() { }
+    /**
+     * NUEVO: Configura el modo de operación del worker
+     */
+    setMode(mode) {
+        this.currentMode = mode;
+        // En modo watch, el worker se mantiene activo más tiempo
+        // En otros modos, se puede optimizar la gestión de recursos
+        console.log(`[WorkerManager] Modo establecido: ${mode}`);
+    }
+    /**
+     * Obtiene la instancia singleton del Worker Manager
+     */
+    static getInstance() {
+        if (!TypeScriptWorkerManager.instance) {
+            TypeScriptWorkerManager.instance = new TypeScriptWorkerManager();
+        }
+        return TypeScriptWorkerManager.instance;
+    }
+    /**
+     * Inicializa el worker thread de TypeScript
+     */
+    async initializeWorker() {
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+        this.initPromise = this._performWorkerInitialization();
+        return this.initPromise;
+    } /**
+     * Realiza la inicialización del worker thread
+     */
+    async _performWorkerInitialization() {
+        try {
+            // Obtener ruta al worker thread (compatible con ES modules y Windows)
+            const workerPath = path.join(process.env.PATH_PROY || process.cwd(), 'compiler', 'typescript-worker-thread.cjs');
+            // console.log('[WorkerManager] Inicializando worker en:', workerPath);
+            // Crear el worker thread sin tsx para evitar dependencias externas
+            this.worker = new Worker(workerPath, {
+                env: {
+                    ...process.env,
+                    NODE_OPTIONS: '', // Limpiar NODE_OPTIONS para evitar conflictos con tsx
+                },
+            });
+            // Configurar listeners del worker
+            this.setupWorkerListeners();
+            // Esperar a que el worker esté listo
+            await this.waitForWorkerReady();
+            // console.log('[WorkerManager] Worker inicializado exitosamente');
+        }
+        catch (error) {
+            console.error('[WorkerManager] Error inicializando worker:', error);
+            this.worker = null;
+            this.workerReady = false;
+            throw error;
+        }
+    }
+    /**
+     * Configura los listeners del worker thread
+     */
+    setupWorkerListeners() {
+        if (!this.worker)
+            return;
+        this.worker.on('message', (response) => {
+            try {
+                // console.log('[WorkerManager] Mensaje recibido del worker:', {
+                //     id: response.id,
+                //     success: response.success,
+                //     hasErrors: response.hasErrors,
+                //     diagnosticsCount: response.diagnostics?.length,
+                // });
+                // Manejar mensaje de worker ready
+                if (response.id === 'worker-ready') {
+                    this.workerReady = true;
+                    return;
+                }
+                // Buscar la tarea pendiente correspondiente
+                const pendingTask = this.pendingTasks.get(response.id);
+                if (!pendingTask) {
+                    console.warn('[WorkerManager] Respuesta para tarea desconocida:', response.id);
+                    return;
+                }
+                // Limpiar timeout y eliminar tarea pendiente
+                clearTimeout(pendingTask.timeout);
+                this.pendingTasks.delete(response.id);
+                // Procesar respuesta
+                if (response.success &&
+                    response.diagnostics !== undefined &&
+                    response.hasErrors !== undefined) {
+                    pendingTask.resolve({
+                        diagnostics: response.diagnostics,
+                        hasErrors: response.hasErrors,
+                    });
+                }
+                else {
+                    const errorMessage = response.error || 'Error desconocido del worker';
+                    pendingTask.reject(new Error(errorMessage));
+                }
+            }
+            catch (error) {
+                console.error('[WorkerManager] Error procesando respuesta del worker:', error);
+            }
+        });
+        this.worker.on('error', error => {
+            console.error('[WorkerManager] Error en worker thread:', error);
+            this.handleWorkerError(error);
+        });
+        this.worker.on('exit', code => {
+            console.warn('[WorkerManager] Worker thread cerrado con código:', code);
+            this.workerReady = false;
+            // Rechazar todas las tareas pendientes
+            this.pendingTasks.forEach(task => {
+                clearTimeout(task.timeout);
+                task.reject(new Error(`Worker cerrado inesperadamente con código ${code}`));
+            });
+            this.pendingTasks.clear();
+        });
+    } /**
+     * Espera a que el worker esté listo para recibir tareas
+     */
+    async waitForWorkerReady() {
+        return new Promise((resolve, reject) => {
+            // Reducir timeout para inicialización a 5 segundos
+            const timeout = setTimeout(() => {
+                reject(new Error('Timeout esperando a que el worker esté listo'));
+            }, 5000);
+            const checkReady = () => {
+                if (this.workerReady) {
+                    clearTimeout(timeout);
+                    resolve();
+                }
+                else {
+                    setTimeout(checkReady, 50); // Verificar cada 50ms (más frecuente)
+                }
+            };
+            checkReady();
+        });
+    }
+    /**
+     * Maneja errores del worker thread
+     */
+    handleWorkerError(error) {
+        console.error('[WorkerManager] Manejando error del worker:', error);
+        // Rechazar todas las tareas pendientes
+        this.pendingTasks.forEach(task => {
+            clearTimeout(task.timeout);
+            task.reject(new Error(`Error en worker: ${error.message}`));
+        });
+        this.pendingTasks.clear();
+        // Marcar worker como no disponible
+        this.workerReady = false;
+    }
+    /**
+     * Genera un ID único para cada tarea
+     */
+    generateTaskId() {
+        return `task-${++this.taskCounter}-${Date.now()}`;
+    } /**
+     * Realiza type checking usando el worker thread (con fallback síncrono)
+     * @param fileName - Nombre del archivo TypeScript
+     * @param content - Contenido del archivo
+     * @param compilerOptions - Opciones del compilador TypeScript
+     * @returns Resultado de la validación de tipos
+     */
+    async typeCheck(fileName, content, compilerOptions) {
+        // En modo de testing o si hay problemas de inicialización, usar fallback directo
+        if (process.env.NODE_ENV === 'test' || !this.worker) {
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
+        try {
+            // Intentar usar el worker thread con timeout más corto
+            const workerPromise = this.typeCheckWithWorker(fileName, content, compilerOptions);
+            const timeoutPromise = new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    reject(new Error('Worker timeout - usando fallback'));
+                }, 5000); // 5 segundos max para worker
+            });
+            return await Promise.race([workerPromise, timeoutPromise]);
+        }
+        catch (workerError) {
+            const errorMessage = workerError instanceof Error
+                ? workerError.message
+                : String(workerError);
+            console.warn('[WorkerManager] Error en worker, usando fallback síncrono:', errorMessage);
+            // Fallback a validación síncrona
+            return this.typeCheckWithSyncFallback(fileName, content, compilerOptions);
+        }
+    }
+    /**
+     * Realiza type checking usando el worker thread
+     */
+    async typeCheckWithWorker(fileName, content, compilerOptions) {
+        // Asegurar que el worker esté inicializado
+        await this.initializeWorker();
+        if (!this.worker || !this.workerReady) {
+            throw new Error('Worker no disponible');
+        }
+        return new Promise((resolve, reject) => {
+            const taskId = this.generateTaskId();
+            // Configurar timeout para la tarea
+            const timeout = setTimeout(() => {
+                this.pendingTasks.delete(taskId);
+                reject(new Error(`Timeout en type checking para ${fileName}`));
+            }, this.WORKER_TIMEOUT);
+            // Agregar tarea a la lista de pendientes
+            this.pendingTasks.set(taskId, {
+                resolve,
+                reject,
+                timeout,
+            });
+            try {
+                // Crear mensaje para el worker
+                const message = {
+                    id: taskId,
+                    fileName,
+                    content,
+                    compilerOptions,
+                };
+                // console.log('[WorkerManager] Enviando tarea al worker:', {
+                //     id: taskId,
+                //     fileName,
+                //     contentLength: content.length,
+                //     compilerOptionsKeys: Object.keys(compilerOptions),
+                // });
+                // Enviar mensaje al worker
+                this.worker.postMessage(message);
+            }
+            catch (error) {
+                // Limpiar en caso de error
+                clearTimeout(timeout);
+                this.pendingTasks.delete(taskId);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Fallback síncrono para type checking cuando el worker no está disponible
+     */
+    typeCheckWithSyncFallback(fileName, content, compilerOptions) {
+        // console.log(
+        //     '[WorkerManager] Ejecutando type checking síncrono como fallback',
+        // );
+        try {
+            return validateTypesWithLanguageService(fileName, content, compilerOptions);
+        }
+        catch (error) {
+            console.error('[WorkerManager] Error en fallback síncrono:', error);
+            // Devolver resultado vacío en caso de error total
+            return {
+                diagnostics: [],
+                hasErrors: false,
+            };
+        }
+    }
+    /**
+     * Cierra el worker thread y limpia recursos
+     */
+    async terminate() {
+        if (this.worker) {
+            // console.log('[WorkerManager] Cerrando worker thread...');
+            // Rechazar todas las tareas pendientes
+            this.pendingTasks.forEach(task => {
+                clearTimeout(task.timeout);
+                task.reject(new Error('Worker manager cerrado'));
+            });
+            this.pendingTasks.clear();
+            // Cerrar worker
+            await this.worker.terminate();
+            this.worker = null;
+            this.workerReady = false;
+            this.initPromise = null;
+            // console.log('[WorkerManager] Worker cerrado exitosamente');
+        }
+    }
+    /**
+     * Obtiene estadísticas del worker manager
+     */
+    getStats() {
+        return {
+            workerReady: this.workerReady,
+            pendingTasks: this.pendingTasks.size,
+            taskCounter: this.taskCounter,
+        };
+    }
+}
+//# sourceMappingURL=typescript-worker.js.map

package/dist/compiler/typescript.js

@@ -0,0 +1,382 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { env } from 'node:process';
+import * as ts from 'typescript';
+import { createUnifiedErrorMessage, parseTypeScriptErrors, } from './typescript-error-parser.js';
+import { TypeScriptWorkerManager } from './typescript-worker.js';
+/**
+ * Cache para la configuración de TypeScript para evitar lecturas repetidas
+ */
+let configCache = {};
+/**
+ * Carga la configuración de TypeScript desde tsconfig.json
+ * @param fileName - Nombre del archivo para buscar el tsconfig.json relativo
+ * @returns Opciones del compilador TypeScript
+ */
+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');
+    // Usar cache si el path no ha cambiado
+    if (configCache.path === configPath && configCache.options) {
+        return configCache.options;
+    }
+    let compilerOptions;
+    if (configPath && fs.existsSync(configPath)) {
+        try {
+            const { config, error: configError } = ts.readConfigFile(configPath, ts.sys.readFile);
+            if (!configError) {
+                const parsedConfig = ts.parseJsonConfigFileContent(config, ts.sys, path.dirname(configPath));
+                compilerOptions = {
+                    ...parsedConfig.options,
+                    // Asegurar opciones básicas necesarias
+                    allowJs: parsedConfig.options.allowJs !== false,
+                    esModuleInterop: parsedConfig.options.esModuleInterop !== false,
+                    allowSyntheticDefaultImports: parsedConfig.options.allowSyntheticDefaultImports !==
+                        false,
+                    skipLibCheck: parsedConfig.options.skipLibCheck !== false,
+                };
+            }
+            else {
+                throw new Error(`Error al leer tsconfig.json: ${configError.messageText}`);
+            }
+        }
+        catch (error) {
+            console.warn(`[loadTypeScriptConfig] Error cargando ${configPath}:`, error);
+            // Fallback a opciones por defecto
+            compilerOptions = getDefaultCompilerOptions();
+        }
+    }
+    else {
+        // Opciones por defecto si no se encuentra tsconfig.json
+        compilerOptions = getDefaultCompilerOptions();
+    }
+    // Guardar en cache
+    configCache = { path: configPath, options: compilerOptions };
+    return compilerOptions;
+};
+/**
+ * Obtiene las opciones por defecto del compilador TypeScript
+ */
+const getDefaultCompilerOptions = () => ({
+    target: ts.ScriptTarget.ES2020,
+    module: ts.ModuleKind.ES2020,
+    lib: ['es2020', 'dom', 'dom.iterable'],
+    strict: false,
+    skipLibCheck: true,
+    allowJs: true,
+    esModuleInterop: true,
+    allowSyntheticDefaultImports: true,
+    isolatedModules: true,
+});
+/**
+ * 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;
+    return {
+        target,
+        module,
+        lib: Array.isArray(lib) ? lib : ['es2020', 'dom', 'dom.iterable'],
+        allowJs,
+        jsx,
+        strict,
+        skipLibCheck,
+        skipDefaultLibCheck: true,
+        esModuleInterop,
+        allowSyntheticDefaultImports,
+        isolatedModules,
+        noEmitOnError: false,
+        declaration: false,
+        sourceMap: false,
+    };
+};
+/**
+ * Crea un Language Service Host optimizado para validación de tipos eficiente.
+ */
+class TypeScriptLanguageServiceHost {
+    files = new Map();
+    compilerOptions;
+    fileSystemCache = new Map();
+    constructor(compilerOptions) {
+        this.compilerOptions = compilerOptions;
+    }
+    addFile(fileName, content) {
+        const existing = this.files.get(fileName);
+        this.files.set(fileName, {
+            version: existing ? existing.version + 1 : 1,
+            content,
+        });
+    }
+    getCompilationSettings() {
+        return this.compilerOptions;
+    }
+    getScriptFileNames() {
+        return Array.from(this.files.keys());
+    }
+    getScriptVersion(fileName) {
+        const file = this.files.get(fileName);
+        return file ? file.version.toString() : '0';
+    }
+    getScriptSnapshot(fileName) {
+        const file = this.files.get(fileName);
+        if (file) {
+            return ts.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)
+                : undefined;
+        }
+        // Intentar leer el archivo del sistema de archivos solo si es necesario
+        try {
+            if (fs.existsSync(fileName)) {
+                const content = fs.readFileSync(fileName, 'utf-8');
+                this.fileSystemCache.set(fileName, content);
+                return ts.ScriptSnapshot.fromString(content);
+            }
+        }
+        catch {
+            // Error al leer archivo
+        }
+        this.fileSystemCache.set(fileName, undefined);
+        return undefined;
+    }
+    getCurrentDirectory() {
+        return process.cwd();
+    }
+    getDefaultLibFileName(options) {
+        return ts.getDefaultLibFilePath(options);
+    }
+    fileExists(path) {
+        if (this.files.has(path))
+            return true;
+        if (this.fileSystemCache.has(path)) {
+            return this.fileSystemCache.get(path) !== undefined;
+        }
+        const exists = fs.existsSync(path);
+        if (!exists)
+            this.fileSystemCache.set(path, undefined);
+        return exists;
+    }
+    readFile(path) {
+        const file = this.files.get(path);
+        if (file)
+            return file.content;
+        if (this.fileSystemCache.has(path)) {
+            return this.fileSystemCache.get(path);
+        }
+        try {
+            if (fs.existsSync(path)) {
+                const content = fs.readFileSync(path, 'utf-8');
+                this.fileSystemCache.set(path, content);
+                return content;
+            }
+        }
+        catch {
+            // Error al leer archivo
+        }
+        this.fileSystemCache.set(path, undefined);
+        return undefined;
+    }
+    getNewLine() {
+        return ts.sys.newLine;
+    }
+}
+/**
+ * Realiza validación de tipos optimizada usando TypeScript Language Service.
+ * @param fileName - Nombre del archivo
+ * @param content - Contenido del archivo
+ * @param compilerOptions - Opciones del compilador
+ * @returns Resultado de la validación de tipos
+ */
+const validateTypesWithLanguageService = (fileName, content, compilerOptions) => {
+    try {
+        // Validación temprana: contenido vacío
+        if (!content.trim()) {
+            return { diagnostics: [], hasErrors: false };
+        }
+        // Crear Language Service Host optimizado
+        const host = new TypeScriptLanguageServiceHost(compilerOptions);
+        // Determinar nombre de archivo efectivo
+        let actualFileName = path.isAbsolute(fileName)
+            ? fileName
+            : path.resolve(fileName);
+        // Para archivos Vue, crear archivo virtual
+        if (fileName.endsWith('.vue')) {
+            actualFileName = actualFileName.replace('.vue', '.vue.ts');
+            host.addFile(actualFileName, content);
+            // Añadir declaraciones Vue básicas solo si es necesario
+            const vueTypesPath = path.join(path.dirname(actualFileName), 'vue-types.d.ts');
+            const vueTypesDeclaration = `
+declare global {
+    function ref<T>(value: T): { value: T };
+    function reactive<T extends object>(target: T): T;
+    function computed<T>(getter: () => T): { value: T };
+    function defineComponent<T>(options: T): T;
+    function defineProps<T = {}>(): T;
+    function defineEmits<T = {}>(): T;
+    function onMounted(fn: () => void): void;
+    function onUnmounted(fn: () => void): void;
+    function watch<T>(source: () => T, callback: (newValue: T, oldValue: T) => void): void;
+}
+export {};`;
+            host.addFile(vueTypesPath, vueTypesDeclaration);
+        }
+        else {
+            host.addFile(actualFileName, content);
+        }
+        // Crear Language Service
+        const languageService = ts.createLanguageService(host);
+        // Verificar existencia del archivo
+        if (!host.fileExists(actualFileName)) {
+            return { diagnostics: [], hasErrors: false };
+        }
+        // Obtener diagnósticos con manejo de errores optimizado
+        const allDiagnostics = [];
+        try {
+            allDiagnostics.push(...languageService.getSyntacticDiagnostics(actualFileName));
+            allDiagnostics.push(...languageService.getSemanticDiagnostics(actualFileName));
+        }
+        catch {
+            // Ignorar errores de diagnósticos
+            return { diagnostics: [], hasErrors: false };
+        }
+        // Filtrado optimizado de diagnósticos
+        const filteredDiagnostics = allDiagnostics.filter(diag => {
+            if (diag.category !== ts.DiagnosticCategory.Error)
+                return false;
+            const messageText = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+            // Lista optimizada de patrones a ignorar
+            const ignorePatterns = [
+                'Cannot find module',
+                'Could not find source file',
+                "Parameter '$props' implicitly has an 'any' type",
+                "Parameter '$setup' implicitly has an 'any' type",
+                "Parameter '_ctx' implicitly has an 'any' type",
+                "Parameter '_cache' implicitly has an 'any' type",
+            ];
+            return !ignorePatterns.some(pattern => messageText.includes(pattern));
+        });
+        return {
+            diagnostics: filteredDiagnostics,
+            hasErrors: filteredDiagnostics.length > 0,
+        };
+    }
+    catch (error) {
+        // Error handling simplificado
+        return {
+            diagnostics: [
+                {
+                    file: undefined,
+                    start: undefined,
+                    length: undefined,
+                    messageText: `Error en validación de tipos: ${error instanceof Error ? error.message : 'Error desconocido'}`,
+                    category: ts.DiagnosticCategory.Error,
+                    code: 0,
+                },
+            ],
+            hasErrors: true,
+        };
+    }
+};
+/**
+ * Valida tipos en archivos Vue antes de la compilación
+ * @param vueContent - Contenido del archivo Vue
+ * @param fileName - Nombre del archivo Vue
+ * @returns Resultado de la validación de tipos
+ */
+export const validateVueTypes = (vueContent, fileName) => {
+    const compilerOptions = loadTypeScriptConfig(fileName);
+    return validateTypesWithLanguageService(fileName, vueContent, compilerOptions);
+};
+/**
+ * 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.
+ * @returns {Promise<CompileResult>} - Un objeto con el código precompilado o un error.
+ */
+export const preCompileTS = async (data, fileName) => {
+    try {
+        // Validación temprana: contenido vacío
+        if (!data.trim()) {
+            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, {
+            compilerOptions: {
+                ...compilerOptions,
+                noLib: true,
+                skipLibCheck: true,
+                isolatedModules: true,
+            },
+            fileName,
+            reportDiagnostics: true,
+        });
+        // const transpileResult = traspileTStoJS(
+        //     fileName,data)
+        // Verificar errores críticos de sintaxis
+        if (transpileResult.diagnostics?.length) {
+            const criticalErrors = transpileResult.diagnostics.filter(diag => {
+                if (diag.category !== ts.DiagnosticCategory.Error)
+                    return false;
+                const messageText = ts.flattenDiagnosticMessageText(diag.messageText, '\n');
+                // Ignorar errores de módulo no encontrado
+                return (!messageText.includes('Cannot find module') &&
+                    !messageText.includes('Could not find source file') &&
+                    diag.code !== 2307 &&
+                    diag.code !== 6059);
+            });
+            if (criticalErrors.length > 0) {
+                const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(criticalErrors, fileName, data));
+                return {
+                    error: new Error(errorMessage),
+                    data: null,
+                    lang: 'ts',
+                };
+            }
+        }
+        // PASO 2: Type checking opcional (solo si está habilitado)
+        if (env.typeCheck === 'true') {
+            try {
+                const workerManager = TypeScriptWorkerManager.getInstance();
+                const serializableOptions = createSerializableCompilerOptions(compilerOptions);
+                const typeCheckResult = await workerManager.typeCheck(fileName, data, serializableOptions);
+                if (typeCheckResult.hasErrors) {
+                    const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(typeCheckResult.diagnostics, fileName, data));
+                    return {
+                        error: new Error(errorMessage),
+                        data: null,
+                        lang: 'ts',
+                    };
+                }
+            }
+            catch (typeCheckError) {
+                // Type checking falla, pero continuar con transpilación
+                console.warn('[preCompileTS] Type checking failed:', typeCheckError);
+            }
+        }
+        // PASO 3: Devolver resultado optimizado
+        const output = transpileResult.outputText;
+        // Limpiar output vacío
+        if (output.trim() === 'export {};') {
+            return { error: null, data: '', lang: 'ts' };
+        }
+        return { error: null, data: output, lang: 'ts' };
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error : new Error('Error desconocido'),
+            data: null,
+            lang: 'ts',
+        };
+    }
+};
+//# sourceMappingURL=typescript.js.map