versacompiler 2.0.0 → 2.0.1

package/dist/compiler/parser.js

@@ -1,6 +1,173 @@
+import { createHash } from 'node:crypto';
 import fs, { readFile } from 'node:fs/promises';
 import oxc from 'oxc-parser';
-// import { simple as walk } from 'acorn-walk';
+class ParserASTCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 150; // Máximo ASTs en cache
+    MAX_CACHE_MEMORY = 30 * 1024 * 1024; // 30MB límite
+    CACHE_TTL = 10 * 60 * 1000; // 10 minutos
+    currentMemoryUsage = 0;
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalParses = 0;
+    static getInstance() {
+        if (!ParserASTCache.instance) {
+            ParserASTCache.instance = new ParserASTCache();
+        }
+        return ParserASTCache.instance;
+    }
+    /**
+     * Genera un hash del contenido del código
+     */
+    generateContentHash(code, astType) {
+        return createHash('sha256').update(`${code}:${astType}`).digest('hex');
+    }
+    /**
+     * Estima el tamaño en memoria de un AST
+     */
+    estimateASTSize(ast) {
+        try {
+            return JSON.stringify(ast).length * 2; // UTF-16 characters
+        }
+        catch {
+            return 10000; // Estimación por defecto
+        }
+    }
+    /**
+     * Obtiene AST desde cache o lo parsea
+     */
+    async getOrParseAST(filename, code, astType = 'js') {
+        this.totalParses++;
+        const contentHash = this.generateContentHash(code, astType);
+        const cacheKey = `${filename}:${contentHash}`;
+        // Verificar cache
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.CACHE_TTL) {
+            // Actualizar timestamp de uso (LRU)
+            cached.timestamp = Date.now();
+            this.cacheHits++;
+            return {
+                ast: cached.ast,
+                cached: true,
+            };
+        }
+        // Cache miss - parsear nuevo AST
+        this.cacheMisses++;
+        const ast = oxc.parseSync(filename, code, {
+            sourceType: 'module',
+            showSemanticErrors: true,
+            astType,
+        });
+        // Cachear resultado si es válido
+        if (ast && !ast.errors?.length) {
+            this.addToCache(cacheKey, ast, astType);
+        }
+        return {
+            ast,
+            cached: false,
+        };
+    }
+    /**
+     * Añade AST al cache con gestión de memoria
+     */
+    addToCache(cacheKey, ast, astType) {
+        try {
+            const size = this.estimateASTSize(ast);
+            // Aplicar políticas de eviction si es necesario
+            this.evictIfNeeded(size);
+            const entry = {
+                contentHash: cacheKey.split(':')[1] || '',
+                ast,
+                astType,
+                timestamp: Date.now(),
+                size,
+            };
+            this.cache.set(cacheKey, entry);
+            this.currentMemoryUsage += size;
+        }
+        catch (error) {
+            console.warn('[ParserASTCache] Error cacheando AST:', error);
+        }
+    }
+    /**
+     * Aplica políticas de eviction LRU si es necesario
+     */
+    evictIfNeeded(newEntrySize) {
+        // Verificar límite de entradas
+        while (this.cache.size >= this.MAX_CACHE_SIZE) {
+            this.evictLRU();
+        }
+        // Verificar límite de memoria
+        while (this.currentMemoryUsage + newEntrySize > this.MAX_CACHE_MEMORY &&
+            this.cache.size > 0) {
+            this.evictLRU();
+        }
+    }
+    /**
+     * Elimina la entrada menos recientemente usada
+     */
+    evictLRU() {
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.timestamp < oldestTime) {
+                oldestTime = entry.timestamp;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.cache.get(oldestKey);
+            if (entry) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(oldestKey);
+            }
+        }
+    }
+    /**
+     * Limpia entradas expiradas
+     */
+    cleanExpired() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.CACHE_TTL) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Obtiene estadísticas del cache
+     */
+    getStats() {
+        const hitRate = this.totalParses > 0
+            ? Math.round((this.cacheHits / this.totalParses) * 100)
+            : 0;
+        return {
+            cacheHits: this.cacheHits,
+            cacheMisses: this.cacheMisses,
+            hitRate,
+            totalParses: this.totalParses,
+            cacheSize: this.cache.size,
+            maxCacheSize: this.MAX_CACHE_SIZE,
+            memoryUsage: this.currentMemoryUsage,
+            maxMemoryUsage: this.MAX_CACHE_MEMORY,
+        };
+    }
+    /**
+     * Limpia todo el cache
+     */
+    clear() {
+        this.cache.clear();
+        this.currentMemoryUsage = 0;
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        this.totalParses = 0;
+    }
+}
+// Instancia global del cache AST
+const astCache = ParserASTCache.getInstance();
 /**
  * Parses the given JavaScript code using Acorn and returns the Abstract Syntax Tree (AST).
  *
@@ -9,11 +176,7 @@ import oxc from 'oxc-parser';
  * @throws {Error} If there is an error during parsing, it logs the error details and stack trace.
  */
 export const parser = async (filename, code, astType = 'js') => {
-    const ast = oxc.parseSync(filename, code, {
-        sourceType: 'module',
-        showSemanticErrors: true,
-        astType,
-    });
+    const { ast } = await astCache.getOrParseAST(filename, code, astType);
     return ast;
 };
 export const getCodeFile = async (filename) => {
@@ -27,4 +190,14 @@ export const getCodeFile = async (filename) => {
         return { code: null, error };
     }
 };
+// ✨ NUEVAS FUNCIONES: Exportar funcionalidades del cache AST para uso externo
+export const getParserCacheStats = () => {
+    return astCache.getStats();
+};
+export const clearParserCache = () => {
+    astCache.clear();
+};
+export const cleanExpiredParserCache = () => {
+    astCache.cleanExpired();
+};
 //# sourceMappingURL=parser.js.map

package/dist/compiler/performance-monitor.js

@@ -0,0 +1,192 @@
+/**
+ * Performance Monitor - Sistema centralizado de monitoreo de optimizaciones
+ * Reúne todas las métricas de cache y performance del VersaCompiler
+ */
+import { clearBrowserSyncCache, getBrowserSyncCacheStats, } from '../servicios/browserSync.js';
+import { cleanExpiredMinificationCache, clearMinificationCache, getMinificationCacheStats, } from './minify.js';
+import { getModuleResolutionMetrics } from './module-resolution-optimizer.js';
+import { cleanExpiredParserCache, clearParserCache, getParserCacheStats, } from './parser.js';
+import { TransformOptimizer } from './transform-optimizer.js';
+import { cleanExpiredVueHMRCache, clearVueHMRCache, getVueHMRCacheStats, } from './vuejs.js';
+export class PerformanceMonitor {
+    static instance;
+    static getInstance() {
+        if (!PerformanceMonitor.instance) {
+            PerformanceMonitor.instance = new PerformanceMonitor();
+        }
+        return PerformanceMonitor.instance;
+    }
+    /**
+     * Obtiene todas las estadísticas de performance de manera unificada
+     */
+    getAllStats() {
+        const vueHMRCache = getVueHMRCacheStats();
+        const parserCache = getParserCacheStats();
+        const browserSyncCache = getBrowserSyncCacheStats();
+        const minificationCache = getMinificationCacheStats();
+        const transformOptimizer = TransformOptimizer.getInstance().getStats();
+        const moduleResolution = getModuleResolutionMetrics();
+        // Calcular resumen general
+        const totalCacheHits = (parserCache.cacheHits || 0) +
+            (browserSyncCache.cacheHits || 0) +
+            (minificationCache.cacheHits || 0) +
+            (transformOptimizer.cacheHits || 0) +
+            (moduleResolution.cacheHits || 0);
+        const totalCacheMisses = (parserCache.cacheMisses || 0) +
+            (browserSyncCache.cacheMisses || 0) +
+            (minificationCache.cacheMisses || 0) +
+            (transformOptimizer.cacheMisses || 0) +
+            (moduleResolution.cacheMisses || 0);
+        const totalRequests = totalCacheHits + totalCacheMisses;
+        const overallHitRate = totalRequests > 0
+            ? Math.round((totalCacheHits / totalRequests) * 100)
+            : 0;
+        const totalMemoryUsage = (parserCache.memoryUsage || 0) +
+            (browserSyncCache.memoryUsage || 0) +
+            (minificationCache.memoryUsage || 0) +
+            (transformOptimizer.memoryUsage || 0);
+        const totalCacheEntries = (vueHMRCache.size || 0) +
+            (parserCache.cacheSize || 0) +
+            (browserSyncCache.cacheSize || 0) +
+            (minificationCache.cacheSize || 0) +
+            (transformOptimizer.cacheSize || 0) +
+            (moduleResolution.cacheSize || 0);
+        return {
+            vueHMRCache,
+            parserCache,
+            browserSyncCache,
+            minificationCache,
+            transformOptimizer,
+            moduleResolution,
+            summary: {
+                totalCacheHits,
+                totalCacheMisses,
+                overallHitRate,
+                totalMemoryUsage,
+                totalCacheEntries,
+            },
+        };
+    }
+    /**
+     * Genera un reporte detallado de performance
+     */
+    generateReport() {
+        const stats = this.getAllStats();
+        const formatBytes = (bytes) => {
+            if (bytes === 0)
+                return '0 B';
+            const k = 1024;
+            const sizes = ['B', 'KB', 'MB', 'GB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return (parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]);
+        };
+        const report = `
+🚀 VERSACOMPILER PERFORMANCE REPORT
+=====================================
+
+📊 RESUMEN GENERAL
+Hit Rate Total: ${stats.summary.overallHitRate}%
+Cache Hits: ${stats.summary.totalCacheHits}
+Cache Misses: ${stats.summary.totalCacheMisses}
+Memoria Total: ${formatBytes(stats.summary.totalMemoryUsage)}
+Entradas Cache: ${stats.summary.totalCacheEntries}
+
+🎯 VUE HMR CACHE
+Size: ${stats.vueHMRCache.size}/${stats.vueHMRCache.maxSize}
+TTL: ${Math.round(stats.vueHMRCache.ttl / 1000 / 60)}min
+
+📝 PARSER AST CACHE
+Hit Rate: ${stats.parserCache.hitRate}%
+Cache Hits: ${stats.parserCache.cacheHits}
+Cache Misses: ${stats.parserCache.cacheMisses}
+Size: ${stats.parserCache.cacheSize}/${stats.parserCache.maxCacheSize}
+Memoria: ${formatBytes(stats.parserCache.memoryUsage)}/${formatBytes(stats.parserCache.maxMemoryUsage)}
+
+🌐 BROWSERSYNC FILE CACHE
+Hit Rate: ${stats.browserSyncCache.hitRate}%
+Cache Hits: ${stats.browserSyncCache.cacheHits}
+Cache Misses: ${stats.browserSyncCache.cacheMisses}
+Size: ${stats.browserSyncCache.cacheSize}/${stats.browserSyncCache.maxCacheSize}
+Memoria: ${formatBytes(stats.browserSyncCache.memoryUsage)}/${formatBytes(stats.browserSyncCache.maxMemoryUsage)}
+
+🗜️ MINIFICATION CACHE
+Hit Rate: ${stats.minificationCache.hitRate}%
+Cache Hits: ${stats.minificationCache.cacheHits}
+Cache Misses: ${stats.minificationCache.cacheMisses}
+Size: ${stats.minificationCache.cacheSize}/${stats.minificationCache.maxCacheSize}
+Memoria: ${formatBytes(stats.minificationCache.memoryUsage)}/${formatBytes(stats.minificationCache.maxMemoryUsage)}
+Compresión Promedio: ${stats.minificationCache.avgCompressionRatio}%
+
+🔄 TRANSFORM OPTIMIZER
+Hit Rate: ${stats.transformOptimizer.hitRate}%
+Cache Hits: ${stats.transformOptimizer.cacheHits}
+Cache Misses: ${stats.transformOptimizer.cacheMisses}
+Transformaciones: ${stats.transformOptimizer.totalTransforms}
+Size: ${stats.transformOptimizer.cacheSize}
+Memoria: ${formatBytes(stats.transformOptimizer.memoryUsage)}
+
+📦 MODULE RESOLUTION
+Hit Rate: ${stats.moduleResolution.cacheHitRate?.toFixed(1)}%
+Cache Hits: ${stats.moduleResolution.cacheHits}
+Cache Misses: ${stats.moduleResolution.cacheMisses}
+Resoluciones: ${stats.moduleResolution.totalResolutions}
+Índice Módulos: ${stats.moduleResolution.moduleIndexSize}
+Índice Alias: ${stats.moduleResolution.aliasIndexSize}
+Tiempo Promedio: ${stats.moduleResolution.averageResolveTime?.toFixed(2)}ms
+
+=====================================
+        `;
+        return report;
+    }
+    /**
+     * Limpia todos los caches
+     */
+    clearAllCaches() {
+        clearVueHMRCache();
+        clearParserCache();
+        clearBrowserSyncCache();
+        clearMinificationCache();
+        TransformOptimizer.getInstance().clear();
+        console.log('🧹 Todos los caches han sido limpiados');
+    }
+    /**
+     * Limpia entradas expiradas de todos los caches
+     */
+    cleanExpiredCaches() {
+        cleanExpiredVueHMRCache();
+        cleanExpiredParserCache();
+        cleanExpiredMinificationCache();
+        console.log('🧹 Entradas expiradas limpiadas de todos los caches');
+    }
+    /**
+     * Configura limpieza automática periódica
+     */
+    setupAutomaticCleanup(intervalMinutes = 30) {
+        setInterval(() => {
+            this.cleanExpiredCaches();
+            console.log(`🔄 Limpieza automática ejecutada cada ${intervalMinutes} minutos`);
+        }, intervalMinutes * 60 * 1000);
+    }
+    /**
+     * Obtiene métricas simplificadas para logging
+     */
+    getSimpleMetrics() {
+        const stats = this.getAllStats();
+        return {
+            hitRate: stats.summary.overallHitRate,
+            totalHits: stats.summary.totalCacheHits,
+            totalMisses: stats.summary.totalCacheMisses,
+            memoryUsage: stats.summary.totalMemoryUsage,
+            cacheEntries: stats.summary.totalCacheEntries,
+        };
+    }
+}
+// Exportar instancia singleton
+export const performanceMonitor = PerformanceMonitor.getInstance();
+// Funciones de conveniencia
+export const getAllPerformanceStats = () => performanceMonitor.getAllStats();
+export const generatePerformanceReport = () => performanceMonitor.generateReport();
+export const clearAllCaches = () => performanceMonitor.clearAllCaches();
+export const cleanExpiredCaches = () => performanceMonitor.cleanExpiredCaches();
+export const getSimpleMetrics = () => performanceMonitor.getSimpleMetrics();
+//# sourceMappingURL=performance-monitor.js.map

package/dist/compiler/transform-optimizer.js

@@ -0,0 +1,287 @@
+/**
+ * Transform Optimizer - Sistema de optimización de transformaciones AST
+ * Implementa procesamiento paralelo y caching inteligente para transformaciones
+ */
+import { createHash } from 'node:crypto';
+import * as os from 'node:os';
+/**
+ * Sistema de optimización de transformaciones con paralelización y caching
+ */
+export class TransformOptimizer {
+    static instance;
+    transformCache = new Map();
+    workers = [];
+    workerQueue = [];
+    pendingTasks = new Map();
+    // Configuración de performance
+    MAX_CACHE_SIZE = 200; // Máximo transformaciones en cache
+    MAX_CACHE_MEMORY = 50 * 1024 * 1024; // 50MB límite
+    WORKER_POOL_SIZE = Math.min(os.cpus().length, 4);
+    TASK_TIMEOUT = 10000; // 10 segundos timeout
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalTransforms = 0;
+    currentMemoryUsage = 0;
+    constructor() {
+        this.initializeWorkers();
+    }
+    static getInstance() {
+        if (!TransformOptimizer.instance) {
+            TransformOptimizer.instance = new TransformOptimizer();
+        }
+        return TransformOptimizer.instance;
+    }
+    /**
+     * Inicializa el pool de workers para transformaciones paralelas
+     */
+    async initializeWorkers() {
+        // Por ahora, implementaremos sin workers para evitar complejidad adicional
+        // En el futuro se puede añadir worker pool específico para transformaciones
+        console.log('[TransformOptimizer] Inicializado sin workers (procesamiento síncrono optimizado)');
+    }
+    /**
+     * Aplica transformaciones con caching y optimización
+     */
+    async transform(code, transforms, options = {}) {
+        this.totalTransforms++;
+        // 1. Generar hash para cache lookup
+        const cacheKey = this.generateCacheKey(code, transforms, options);
+        // 2. Verificar cache
+        const cached = await this.getFromCache(cacheKey);
+        if (cached) {
+            this.cacheHits++;
+            return cached;
+        }
+        this.cacheMisses++;
+        // 3. Aplicar transformaciones
+        const result = await this.applyTransforms(code, transforms, options);
+        // 4. Cachear resultado
+        await this.addToCache(cacheKey, code, transforms, options, result);
+        return result;
+    }
+    /**
+     * Genera clave de cache basada en contenido y transformaciones
+     */
+    generateCacheKey(code, transforms, options) {
+        const content = `${code}||${transforms.join(',')}||${JSON.stringify(options)}`;
+        return createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * Obtiene resultado del cache si es válido
+     */
+    async getFromCache(cacheKey) {
+        const entry = this.transformCache.get(cacheKey);
+        if (!entry)
+            return null;
+        // Actualizar tiempo de uso para LRU
+        entry.lastUsed = Date.now();
+        return entry.result;
+    }
+    /**
+     * Añade resultado al cache con gestión de memoria
+     */
+    async addToCache(cacheKey, code, transforms, options, result) {
+        try {
+            const size = this.estimateSize(code, result);
+            // Aplicar políticas de eviction si es necesario
+            this.evictIfNeeded(size);
+            const entry = {
+                inputHash: createHash('sha256').update(code).digest('hex'),
+                transformHash: createHash('sha256')
+                    .update(transforms.join(','))
+                    .digest('hex'),
+                result,
+                lastUsed: Date.now(),
+                size,
+            };
+            this.transformCache.set(cacheKey, entry);
+            this.currentMemoryUsage += size;
+        }
+        catch (error) {
+            console.warn('[TransformOptimizer] Error cacheando transformación:', error);
+        }
+    }
+    /**
+     * Aplica las transformaciones reales al código
+     */
+    async applyTransforms(code, transforms, options) {
+        try {
+            let currentCode = code;
+            let currentMap;
+            const dependencies = [];
+            // Aplicar transformaciones secuencialmente (por ahora)
+            // En el futuro se puede paralelizar transformaciones independientes
+            for (const transform of transforms) {
+                const transformResult = await this.applySingleTransform(currentCode, transform, options, currentMap);
+                currentCode = transformResult.code;
+                if (transformResult.map) {
+                    currentMap = transformResult.map;
+                }
+                if (transformResult.dependencies) {
+                    dependencies.push(...transformResult.dependencies);
+                }
+            }
+            return {
+                code: currentCode,
+                map: currentMap,
+                dependencies: [...new Set(dependencies)], // Deduplicar dependencias
+            };
+        }
+        catch (error) {
+            throw new Error(`Error aplicando transformaciones: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Aplica una transformación individual
+     */
+    async applySingleTransform(code, transform, options, sourceMap) {
+        // Importar dinámicamente el módulo de transformación necesario
+        switch (transform) {
+            case 'typescript':
+                return this.applyTypeScriptTransform(code, options, sourceMap);
+            case 'vue':
+                return this.applyVueTransform(code, options, sourceMap);
+            case 'minify':
+                return this.applyMinifyTransform(code, options, sourceMap);
+            case 'babel':
+                return this.applyBabelTransform(code, options, sourceMap);
+            default:
+                throw new Error(`Transformación desconocida: ${transform}`);
+        }
+    } /**
+     * Aplica transformación TypeScript
+     */
+    async applyTypeScriptTransform(code, options, sourceMap) {
+        // Importación dinámica para evitar carga innecesaria
+        const { preCompileTS } = await import('./typescript-manager.js');
+        const result = await preCompileTS(code, 'temp.ts');
+        if (result.error) {
+            throw result.error;
+        }
+        return {
+            code: result.data || code,
+            map: sourceMap, // Mantener source map existente por ahora
+            dependencies: [], // TypeScript puede extraer dependencias en el futuro
+        };
+    } /**
+     * Aplica transformación Vue
+     */
+    async applyVueTransform(code, options, sourceMap) {
+        const { preCompileVue } = await import('./vuejs.js');
+        const result = await preCompileVue(code, 'temp.vue', false);
+        if (result.error) {
+            throw result.error;
+        }
+        return {
+            code: result.data || code,
+            map: sourceMap,
+            dependencies: [],
+        };
+    } /**
+     * Aplica transformación de minificación
+     */
+    async applyMinifyTransform(code, options, sourceMap) {
+        const { minifyJS } = await import('./minify.js');
+        const result = await minifyJS(code, 'temp.js', true);
+        if (result.error) {
+            throw result.error;
+        }
+        return {
+            code: result.code || code,
+            map: sourceMap, // minifyJS no devuelve map, mantener el existente
+            dependencies: [],
+        };
+    }
+    /**
+     * Aplica transformación Babel (futuro)
+     */
+    async applyBabelTransform(code, options, sourceMap) {
+        // Placeholder para transformaciones Babel futuras
+        return {
+            code,
+            map: sourceMap,
+            dependencies: [],
+        };
+    }
+    /**
+     * Estima el tamaño en memoria de una entrada de cache
+     */
+    estimateSize(code, result) {
+        return (code.length * 2 + // UTF-16 characters
+            result.code.length * 2 +
+            (result.map?.length || 0) * 2 +
+            (result.dependencies?.join('').length || 0) * 2 +
+            200 // Overhead de objetos
+        );
+    }
+    /**
+     * Aplica políticas de eviction LRU si es necesario
+     */
+    evictIfNeeded(newEntrySize) {
+        // Verificar límite de entradas
+        while (this.transformCache.size >= this.MAX_CACHE_SIZE) {
+            this.evictLRU();
+        }
+        // Verificar límite de memoria
+        while (this.currentMemoryUsage + newEntrySize > this.MAX_CACHE_MEMORY &&
+            this.transformCache.size > 0) {
+            this.evictLRU();
+        }
+    }
+    /**
+     * Elimina la entrada menos recientemente usada
+     */
+    evictLRU() {
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.transformCache) {
+            if (entry.lastUsed < oldestTime) {
+                oldestTime = entry.lastUsed;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.transformCache.get(oldestKey);
+            if (entry) {
+                this.currentMemoryUsage -= entry.size;
+                this.transformCache.delete(oldestKey);
+            }
+        }
+    }
+    /**
+     * Obtiene estadísticas del optimizador
+     */
+    getStats() {
+        const hitRate = this.totalTransforms > 0
+            ? Math.round((this.cacheHits / this.totalTransforms) * 100)
+            : 0;
+        return {
+            cacheHits: this.cacheHits,
+            cacheMisses: this.cacheMisses,
+            hitRate,
+            totalTransforms: this.totalTransforms,
+            cacheSize: this.transformCache.size,
+            memoryUsage: this.currentMemoryUsage,
+        };
+    }
+    /**
+     * Limpia el cache y reinicia estadísticas
+     */
+    clear() {
+        this.transformCache.clear();
+        this.currentMemoryUsage = 0;
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        this.totalTransforms = 0;
+    }
+    /**
+     * Cierra el optimizador y limpia recursos
+     */
+    async terminate() {
+        // Limpiar workers si se implementan en el futuro
+        this.clear();
+        console.log('[TransformOptimizer] Cerrado exitosamente');
+    }
+}
+//# sourceMappingURL=transform-optimizer.js.map