versacompiler 2.1.0 → 2.3.0

package/dist/compiler/minify.js

@@ -1 +1,272 @@
-import{createHash as e}from"node:crypto";import{minify as i}from"oxc-minify";import{minifyTemplate as a}from"./minifyTemplate.js";import{removehtmlOfTemplateString as o}from"./transforms.js";class s{static instance;cache=new Map;MAX_CACHE_SIZE=100;MAX_CACHE_MEMORY=20*1024*1024;CACHE_TTL=1800*1e3;currentMemoryUsage=0;cacheHits=0;cacheMisses=0;totalMinifications=0;totalOriginalSize=0;totalMinifiedSize=0;static getInstance(){return s.instance||(s.instance=new s),s.instance}generateCacheKey(i,a){let o=`${i}||${JSON.stringify(a)}`;return e(`sha256`).update(o).digest(`hex`)}async getOrMinify(e,a,o){this.totalMinifications++;let s=this.generateCacheKey(e,o),c=this.cache.get(s);if(c&&Date.now()-c.timestamp<this.CACHE_TTL)return c.timestamp=Date.now(),this.cacheHits++,{code:c.minifiedCode,error:null,cached:!0};this.cacheMisses++;let l=e.length;try{let c=await i(a,e,o);if(e.trim()&&!c.code.trim())return{code:``,error:Error(`Minification failed: likely syntax error in ${a}`),cached:!1};let u=c.code.length;return this.addToCache(s,{contentHash:s,options:o,minifiedCode:c.code,timestamp:Date.now(),originalSize:l,minifiedSize:u}),this.totalOriginalSize+=l,this.totalMinifiedSize+=u,{code:c.code,error:null,cached:!1}}catch(e){return{error:e instanceof Error?e:Error(String(e)),code:``,cached:!1}}}addToCache(e,i){try{let a=i.originalSize+i.minifiedSize;this.evictIfNeeded(a),this.cache.set(e,i),this.currentMemoryUsage+=a}catch(e){console.warn(`[MinificationCache] Error cacheando minificación:`,e)}}evictIfNeeded(e){for(;this.cache.size>=this.MAX_CACHE_SIZE;)this.evictLRU();for(;this.currentMemoryUsage+e>this.MAX_CACHE_MEMORY&&this.cache.size>0;)this.evictLRU()}evictLRU(){let e=``,i=1/0;for(let[a,o]of this.cache)o.timestamp<i&&(i=o.timestamp,e=a);if(e){let i=this.cache.get(e);i&&(this.currentMemoryUsage-=i.originalSize+i.minifiedSize,this.cache.delete(e))}}cleanExpired(){let e=Date.now();for(let[i,a]of this.cache.entries())e-a.timestamp>this.CACHE_TTL&&(this.currentMemoryUsage-=a.originalSize+a.minifiedSize,this.cache.delete(i))}getStats(){let e=this.totalMinifications>0?Math.round(this.cacheHits/this.totalMinifications*100):0,i=this.totalOriginalSize>0?Math.round((this.totalOriginalSize-this.totalMinifiedSize)/this.totalOriginalSize*100):0;return{cacheHits:this.cacheHits,cacheMisses:this.cacheMisses,hitRate:e,totalMinifications:this.totalMinifications,cacheSize:this.cache.size,maxCacheSize:this.MAX_CACHE_SIZE,memoryUsage:this.currentMemoryUsage,maxMemoryUsage:this.MAX_CACHE_MEMORY,totalOriginalSize:this.totalOriginalSize,totalMinifiedSize:this.totalMinifiedSize,avgCompressionRatio:i}}clear(){this.cache.clear(),this.currentMemoryUsage=0,this.cacheHits=0,this.cacheMisses=0,this.totalMinifications=0,this.totalOriginalSize=0,this.totalMinifiedSize=0}}const c=s.getInstance();export const minifyJS=async(e,i,a=!0)=>{try{let o={compress:{target:`es2020`},mangle:{toplevel:!0,debug:!a},codegen:{removeWhitespace:!0},sourcemap:!a},s=await c.getOrMinify(e,i,o);return{code:s.code,error:s.error}}catch(e){return{error:e,code:``}}};export const getMinificationCacheStats=()=>c.getStats();export const clearMinificationCache=()=>{c.clear()};export const cleanExpiredMinificationCache=()=>{c.cleanExpired()};export const minifyWithTemplates=async(e,i,s=!0)=>{try{let c=a(e,i);if(c.error&&!c.code){let e=c.error instanceof Error?c.error.message:String(c.error);return{code:``,error:Error(`Template minification failed: ${e}`)}}let u=await minifyJS(c.code,i,s);return u.code=await o(u.code),u}catch(e){return{error:e instanceof Error?e:Error(String(e)),code:``}}};
+import { createHash } from 'node:crypto';
+import { minify } from 'oxc-minify';
+import { minifyTemplate } from './minifyTemplate.js';
+class MinificationCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 100; // Máximo archivos minificados en cache
+    MAX_CACHE_MEMORY = 20 * 1024 * 1024; // 20MB límite
+    CACHE_TTL = 30 * 60 * 1000; // 30 minutos
+    currentMemoryUsage = 0;
+    // Métricas
+    cacheHits = 0;
+    cacheMisses = 0;
+    totalMinifications = 0;
+    totalOriginalSize = 0;
+    totalMinifiedSize = 0;
+    static getInstance() {
+        if (!MinificationCache.instance) {
+            MinificationCache.instance = new MinificationCache();
+        }
+        return MinificationCache.instance;
+    }
+    /**
+     * Genera un hash del contenido y opciones de minificación
+     */
+    generateCacheKey(data, options) {
+        const content = `${data}||${JSON.stringify(options)}`;
+        return createHash('sha256').update(content).digest('hex');
+    }
+    /**
+     * Obtiene resultado de minificación desde cache o lo genera
+     */
+    async getOrMinify(data, filename, options) {
+        this.totalMinifications++;
+        const cacheKey = this.generateCacheKey(data, options);
+        // 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 {
+                code: cached.minifiedCode,
+                error: null,
+                cached: true,
+            };
+        }
+        // Cache miss - minificar código
+        this.cacheMisses++;
+        const originalSize = data.length;
+        try {
+            const result = await minify(filename, data, options);
+            // Si el código de entrada no estaba vacío pero el resultado sí,
+            // retornar código original sin minificar con advertencia
+            if (data.trim() && !result.code.trim()) {
+                console.warn(`⚠️  Minificación fallida para ${filename}, usando código original`);
+                return {
+                    code: data, // Retornar código original
+                    error: null, // No es un error crítico
+                    cached: false,
+                };
+            }
+            const minifiedSize = result.code.length;
+            // Cachear resultado exitoso
+            this.addToCache(cacheKey, {
+                contentHash: cacheKey,
+                options,
+                minifiedCode: result.code,
+                timestamp: Date.now(),
+                originalSize,
+                minifiedSize,
+            });
+            // Actualizar métricas globales
+            this.totalOriginalSize += originalSize;
+            this.totalMinifiedSize += minifiedSize;
+            return {
+                code: result.code,
+                error: null,
+                cached: false,
+            };
+        }
+        catch (error) {
+            // En caso de excepción, retornar código original con advertencia
+            console.warn(`⚠️  Error al minificar ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+            console.warn(`   Usando código original sin minificar`);
+            return {
+                code: data, // Retornar código original
+                error: null, // No propagar el error
+                cached: false,
+            };
+        }
+    }
+    /**
+     * Añade resultado al cache con gestión de memoria
+     */
+    addToCache(cacheKey, entry) {
+        try {
+            const entrySize = entry.originalSize + entry.minifiedSize;
+            // Aplicar políticas de eviction si es necesario
+            this.evictIfNeeded(entrySize);
+            this.cache.set(cacheKey, entry);
+            this.currentMemoryUsage += entrySize;
+        }
+        catch (error) {
+            console.warn('[MinificationCache] Error cacheando minificación:', 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.originalSize + entry.minifiedSize;
+                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.originalSize + entry.minifiedSize;
+                this.cache.delete(key);
+            }
+        }
+    }
+    /**
+     * Obtiene estadísticas del cache
+     */
+    getStats() {
+        const hitRate = this.totalMinifications > 0
+            ? Math.round((this.cacheHits / this.totalMinifications) * 100)
+            : 0;
+        const avgCompressionRatio = this.totalOriginalSize > 0
+            ? Math.round(((this.totalOriginalSize - this.totalMinifiedSize) /
+                this.totalOriginalSize) *
+                100)
+            : 0;
+        return {
+            cacheHits: this.cacheHits,
+            cacheMisses: this.cacheMisses,
+            hitRate,
+            totalMinifications: this.totalMinifications,
+            cacheSize: this.cache.size,
+            maxCacheSize: this.MAX_CACHE_SIZE,
+            memoryUsage: this.currentMemoryUsage,
+            maxMemoryUsage: this.MAX_CACHE_MEMORY,
+            totalOriginalSize: this.totalOriginalSize,
+            totalMinifiedSize: this.totalMinifiedSize,
+            avgCompressionRatio,
+        };
+    }
+    /**
+     * Limpia todo el cache
+     */
+    clear() {
+        this.cache.clear();
+        this.currentMemoryUsage = 0;
+        this.cacheHits = 0;
+        this.cacheMisses = 0;
+        this.totalMinifications = 0;
+        this.totalOriginalSize = 0;
+        this.totalMinifiedSize = 0;
+    }
+}
+// Instancia global del cache de minificación
+const minificationCache = MinificationCache.getInstance();
+/**
+ * Minifica el codigo JavaScript usando opciones especificas.
+ *
+ * @param {string} data - The JavaScript code to be minified.
+ * @param {string} filename - The name of the file containing the JavaScript code.
+ * @param {boolean} isProd - Indica si está en modo producción.
+ * @returns {Promise<Object>} The result of the minification process.
+ */
+export const minifyJS = async (data, filename, isProd = true) => {
+    try {
+        const options = {
+            compress: {
+                target: 'es2020',
+            },
+            mangle: {
+                toplevel: true,
+                debug: !isProd,
+            },
+            codegen: {
+                removeWhitespace: true,
+            },
+            sourcemap: !isProd,
+        };
+        const result = await minificationCache.getOrMinify(data, filename, options);
+        return { code: result.code, error: result.error };
+    }
+    catch (error) {
+        return { error, code: '' };
+    }
+};
+// ✨ NUEVAS FUNCIONES: Exportar funcionalidades del cache de minificación para uso externo
+export const getMinificationCacheStats = () => {
+    return minificationCache.getStats();
+};
+export const clearMinificationCache = () => {
+    minificationCache.clear();
+};
+export const cleanExpiredMinificationCache = () => {
+    minificationCache.cleanExpired();
+};
+/**
+ * ✨ Minifica templates HTML/Vue ANTES de minificar JavaScript
+ * Esta función combina la minificación de templates con la minificación JS en el orden correcto:
+ * 1. Primero minifica templates HTML usando minify-html-literals
+ * 2. Luego minifica el JavaScript resultante usando oxc-minify
+ *
+ * @param {string} data - El código a minificar (puede contener templates HTML)
+ * @param {string} filename - El nombre del archivo
+ * @param {boolean} isProd - Indica si está en modo producción
+ * @returns {Promise<Object>} El resultado de la minificación combinada { code, error }
+ */
+export const minifyWithTemplates = async (data, filename, isProd = true) => {
+    try {
+        // PASO 1: Minificar templates HTML primero
+        const templateResult = minifyTemplate(data, filename);
+        // Si hay error en la minificación de templates, pero tenemos código, continuar
+        if (templateResult.error && !templateResult.code) {
+            const errorMsg = templateResult.error instanceof Error
+                ? templateResult.error.message
+                : String(templateResult.error);
+            return {
+                code: '',
+                error: new Error(`Template minification failed: ${errorMsg}`),
+            };
+        }
+        // PASO 2: Minificar el JavaScript resultante
+        return await minifyJS(templateResult.code, filename, isProd);
+    }
+    catch (error) {
+        return {
+            error: error instanceof Error ? error : new Error(String(error)),
+            code: '',
+        };
+    }
+};
+//# sourceMappingURL=minify.js.map

package/dist/compiler/minifyTemplate.js

@@ -1 +1,230 @@
-import{minifyHTMLLiterals as e}from"/node_modules/minify-html-literals/index.js";const t={caseSensitive:!0,keepClosingSlash:!0,collapseWhitespace:!0,removeComments:!0,minifyCSS:!0,minifyJS:!0,conservativeCollapse:!1,preserveLineBreaks:!1,removeAttributeQuotes:!1,removeEmptyAttributes:!1,removeRedundantAttributes:!1,removeScriptTypeAttributes:!0,removeStyleLinkTypeAttributes:!0,useShortDoctype:!0},n=e=>{try{return e.replace(/=`([^`]+)`/g,(e,t)=>t.includes(`{`)&&t.includes(`}`)?`=html\`${t.replace(/\/\*[\s\S]*?\*\//g,``).replace(/\s+/g,` `).replace(/\s*{\s*/g,`{`).replace(/\s*}\s*/g,`}`).replace(/\s*:\s*/g,`:`).replace(/\s*;\s*/g,`;`).replace(/;\s*}/g,`}`).replace(/,\s*/g,`,`).trim()}\``:e)}catch(t){return console.warn(`[MinifyTemplate] Error minificando CSS:`,t),e}},r=(r,i)=>{try{let a=n(r);return{code:e(a,{fileName:i,...t})?.code||a,error:null}}catch(e){return console.warn(`[MinifyTemplate] Error minificando plantilla ${i}:`,e),{code:r,error:e}}};export{t as defaultMinifyOptions,r as minifyTemplate};
+import { minifyHTMLLiterals } from 'minify-html-literals';
+const defaultMinifyOptions = {
+    // Opciones esenciales para componentes Vue
+    caseSensitive: true, // Preserva mayúsculas/minúsculas en nombres de componentes
+    keepClosingSlash: true, // ✅ MANTIENE el slash de cierre <component />
+    collapseWhitespace: true, // Elimina espacios en blanco
+    removeComments: true, // Elimina comentarios HTML
+    minifyCSS: true, // ✅ Minifica CSS inline (importante para estilos Vue)
+    minifyJS: true, // Minifica JS inline en atributos
+    // Configuración para frameworks (Vue/React)
+    conservativeCollapse: false, // Colapso más agresivo de espacios
+    preserveLineBreaks: false, // No preservar saltos de línea
+    // Importante: NO remover atributos necesarios de Vue
+    removeAttributeQuotes: false, // NO quitar comillas (Vue las necesita en :prop y @event)
+    removeEmptyAttributes: false, // NO quitar atributos vacíos (Vue los usa)
+    removeRedundantAttributes: false, // NO quitar atributos redundantes
+    // Optimizaciones seguras
+    removeScriptTypeAttributes: true, // Quitar type="text/javascript"
+    removeStyleLinkTypeAttributes: true, // Quitar type="text/css"
+    useShortDoctype: true, // Usar <!DOCTYPE html> corto
+};
+// Marcadores únicos para identificar tags temporales
+const TEMP_TAG_MARKER = '__VERSA_TEMP__';
+const TEMP_HTML_TAG = `${TEMP_TAG_MARKER}`;
+const TEMP_CSS_TAG = `${TEMP_TAG_MARKER}css`;
+/**
+ * Detecta el tipo de contenido dentro de un template string
+ * @param content - Contenido del template string
+ * @returns 'css' | 'html' | 'mixed' | 'unknown'
+ */
+const detectContentType = (content) => {
+    // Remover template expressions ${...} para análisis más preciso
+    const cleanContent = content.replace(/\$\{[^}]+\}/g, '');
+    // Detectar CSS: Buscar selectores y propiedades CSS
+    const hasCSSBraces = cleanContent.includes('{') && cleanContent.includes('}');
+    const hasCSSProperties = /[a-z-]+\s*:\s*[^;]+;/.test(cleanContent);
+    const hasMediaQueries = /@media|@keyframes|@import/.test(cleanContent);
+    const isCSSLike = hasCSSBraces && (hasCSSProperties || hasMediaQueries);
+    // Detectar código TypeScript (para evitar falsos positivos)
+    const hasTypeScriptSyntax = /\b(function|const|let|var|interface|type|declare|export|import)\b/.test(cleanContent);
+    const hasTypeScriptGenerics = /<[A-Z][^>]*>|<\{/.test(cleanContent); // <T>, <T extends Foo>, <{}>
+    // Si parece código TypeScript, no intentar minificar
+    if (hasTypeScriptSyntax && hasTypeScriptGenerics) {
+        return 'unknown';
+    }
+    // Detectar HTML: Buscar tags HTML REALES (no genéricos TypeScript)
+    // Tags HTML comunes para evitar falsos positivos
+    const hasHTMLElements = /<(div|span|p|a|button|input|form|table|ul|ol|li|h[1-6]|section|article|nav|header|footer|main|aside|style|script)[^>]*>/i.test(cleanContent);
+    const hasHTMLClosingTags = /<\/(div|span|p|a|button|input|form|table|ul|ol|li|h[1-6]|section|article|nav|header|footer|main|aside|style|script)>/i.test(cleanContent);
+    const isHTMLLike = hasHTMLElements || hasHTMLClosingTags;
+    // Detectar contenido mixto (CSS + HTML juntos)
+    if (isCSSLike && isHTMLLike) {
+        return 'mixed';
+    }
+    if (isCSSLike) {
+        return 'css';
+    }
+    if (isHTMLLike) {
+        return 'html';
+    }
+    return 'unknown';
+};
+/**
+ * Detecta template strings sin tags y les agrega tags temporales según su contenido
+ * @param code - Código fuente a procesar
+ * @returns Código con tags temporales agregados
+ */
+const detectAndTagTemplateStrings = (code) => {
+    try {
+        // Patrón para detectar template strings sin tag `` o css``
+        // Busca: = ` ... ` o : ` ... ` pero NO ` o css`
+        // Negative lookbehind: (?<!html|css|TEMP_TAG_MARKER)
+        const templateStringPattern = new RegExp(`(?<!html|css|${TEMP_TAG_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})\\\`([^\`]+?)\\\``, 'gs');
+        return code.replace(templateStringPattern, (match, content) => {
+            // No procesar si ya tiene un tag (doble verificación)
+            if (match.includes('`') ||
+                match.includes('css`') ||
+                match.includes(TEMP_TAG_MARKER)) {
+                return match;
+            }
+            // No procesar template strings vacíos o muy cortos (probablemente strings simples)
+            if (content.trim().length < 10) {
+                return match;
+            }
+            // Detectar tipo de contenido
+            const contentType = detectContentType(content);
+            // Solo agregar tag si es CSS o HTML (contenido minificable)
+            if (contentType === 'css') {
+                return `${TEMP_CSS_TAG}\`${content}\``;
+            }
+            else if (contentType === 'html' || contentType === 'mixed') {
+                return `${TEMP_HTML_TAG}\`${content}\``;
+            }
+            // Si es unknown o JavaScript, no agregar tag
+            return match;
+        });
+    }
+    catch (error) {
+        console.warn('[MinifyTemplate] Error detectando template strings:', error);
+        return code;
+    }
+};
+/**
+ * Remueve los tags temporales agregados por detectAndTagTemplateStrings
+ * @param code - Código con tags temporales
+ * @returns Código limpio sin tags temporales
+ */
+const removeTemporaryTags = (code) => {
+    try {
+        // Remover tags temporales: __VERSA_TEMP__` -> `
+        const tempHtmlPattern = new RegExp(`${TEMP_HTML_TAG}\\\``, 'g');
+        const tempCssPattern = new RegExp(`${TEMP_CSS_TAG}\\\``, 'g');
+        return code.replace(tempHtmlPattern, '`').replace(tempCssPattern, '`');
+    }
+    catch (error) {
+        console.warn('[MinifyTemplate] Error removiendo tags temporales:', error);
+        return code;
+    }
+};
+/**
+ * Minifica CSS dentro de tagged templates
+ * Ahora soporta múltiples formatos: =`...`, :`...`, =css`...`, etc.
+ */
+const minifyCSS = (code) => {
+    try {
+        // Patrón expandido para detectar diferentes contextos:
+        // - Asignaciones: =` o =css`
+        // - Propiedades de objeto: : ` o : css`
+        // - Template strings standalone: ` o css`
+        // - Tags temporales: __VERSA_TEMP__css` o __VERSA_TEMP__`
+        const cssPattern = /(?:=|:|\s)(html|css|__VERSA_TEMP__html|__VERSA_TEMP__css)?`([^`]+)`/g;
+        return code.replace(cssPattern, (match, tag, content) => {
+            const looksLikeCSS = content.includes('{') &&
+                content.includes('}') &&
+                /[a-z-]+\s*:\s*[^;]+;/.test(content);
+            // Si no tiene tag, no procesar aquí (se procesará en detectAndTagTemplateStrings)
+            if (!tag && !looksLikeCSS) {
+                return match;
+            }
+            // Solo minificar si parece ser CSS (contiene { y })
+            if (content.includes('{') && content.includes('}')) {
+                // Minificar CSS: remover espacios innecesarios
+                const minified = content
+                    .replace(/\/\*[\s\S]*?\*\//g, '') // Remover comentarios CSS
+                    .replace(/\s+/g, ' ') // Normalizar múltiples espacios a uno
+                    .replace(/\s*{\s*/g, '{') // Remover espacios alrededor de {
+                    .replace(/\s*}\s*/g, '}') // Remover espacios alrededor de }
+                    .replace(/\s*:\s*/g, ':') // Remover espacios alrededor de :
+                    .replace(/\s*;\s*/g, ';') // Remover espacios alrededor de ;
+                    .replace(/;\s*}/g, '}') // Remover ; antes de }
+                    .replace(/,\s*/g, ',') // Remover espacios después de ,
+                    .replace(/\s*>\s*/g, '>') // Remover espacios en selectores >
+                    .replace(/\s*\+\s*/g, '+') // Remover espacios en selectores +
+                    .replace(/\s*~\s*/g, '~') // Remover espacios en selectores ~
+                    .trim();
+                // Preservar el prefijo original (=, :, espacio)
+                const prefix = match.charAt(0);
+                const tagPart = tag || ''; // Si no hay tag, usar string vacío
+                return `${prefix}${tagPart}\`${minified}\``;
+            }
+            // Si no es CSS, devolver sin cambios
+            return match;
+        });
+    }
+    catch (error) {
+        console.warn('[MinifyTemplate] Error minificando CSS:', error);
+        return code;
+    }
+};
+const minifyTemplate = (data, fileName) => {
+    try {
+        // ⚠️ SKIP: Archivos de definiciones de tipos TypeScript
+        // Estos archivos NO contienen template strings HTML/CSS para minificar
+        if (fileName.endsWith('.d.ts') ||
+            fileName.includes('types') ||
+            fileName.includes('type-')) {
+            return { code: data, error: null };
+        }
+        // ⚠️ SKIP: Archivos sin backticks (no tienen template strings)
+        if (!data.includes('`')) {
+            return { code: data, error: null };
+        }
+        // ✨ NUEVO FLUJO DE TRES PASOS:
+        // PASO 1: Detectar y etiquetar template strings sin tags
+        // Esto agrega tags temporales (__VERSA_TEMP__` o __VERSA_TEMP__css`)
+        // a template strings que contienen HTML o CSS pero no tienen tag
+        let code = detectAndTagTemplateStrings(data);
+        // PASO 2: Minificar CSS en tagged templates (`...` y css`...`)
+        // Esto incluye los tags temporales agregados en el paso 1
+        code = minifyCSS(code);
+        // PASO 3: Minificar templates HTML con minify-html-literals
+        // Esta librería procesa todos los template strings con tags `` y css``
+        // Solo procesar si realmente hay tags `` o css`` en el código
+        let minifiedCode = code;
+        if (code.includes('`') ||
+            code.includes('css`') ||
+            code.includes(TEMP_HTML_TAG) ||
+            code.includes(TEMP_CSS_TAG)) {
+            try {
+                const minified = minifyHTMLLiterals(code, {
+                    fileName,
+                    ...defaultMinifyOptions,
+                });
+                if (minified && minified.code) {
+                    minifiedCode = minified.code;
+                }
+            }
+            catch (parseError) {
+                // Si minifyHTMLLiterals falla (ej: encuentra código TypeScript en vez de HTML),
+                // devolver el código sin minificar en lugar de fallar completamente
+                console.warn(`[MinifyTemplate] minifyHTMLLiterals falló para ${fileName}, usando código sin minificar:`, parseError instanceof Error
+                    ? parseError.message
+                    : String(parseError));
+                // minifiedCode ya tiene el valor de code
+            }
+        }
+        // PASO 4: Remover tags temporales agregados en el paso 1
+        // Esto convierte __VERSA_TEMP__` de vuelta a ` para que el código
+        // final no contenga los marcadores temporales
+        const finalCode = removeTemporaryTags(minifiedCode);
+        return { code: finalCode, error: null };
+    }
+    catch (error) {
+        console.warn(`[MinifyTemplate] Error minificando plantilla ${fileName}:`, error);
+        return { code: data, error };
+    }
+};
+// ✨ Exportar funciones y configuración
+export { defaultMinifyOptions, detectAndTagTemplateStrings, detectContentType, minifyTemplate, removeTemporaryTags, };
+//# sourceMappingURL=minifyTemplate.js.map