versacompiler 2.3.2 → 2.3.4

package/dist/compiler/compile.js

@@ -1036,7 +1036,9 @@ function registerCompilationResult(stage, errors, success, files = []) {
  */
 async function handleCompilationError(error, fileName, stage, mode, isVerbose = false) {
     const errorMessage = error instanceof Error ? error.message : error;
-    const errorDetails = error instanceof Error ? error.stack : undefined;
+    // No mostrar stack trace para errores de tipo TypeScript (son errores del usuario, no del compilador)
+    const isTypeError = error instanceof Error && error.isTypeError;
+    const errorDetails = error instanceof Error && !isTypeError ? error.stack : undefined;
     // Registrar el error en el sistema unificado
     registerCompilationError(fileName, stage, errorMessage, 'error', errorDetails);
     registerCompilationResult(stage, 1, 0, [fileName]); // Mostrar error inmediatamente solo en modo individual y watch
@@ -1628,7 +1630,8 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         if (typeof preCompileTS !== 'function') {
             throw new Error(`loadTypeScript devolvió ${typeof preCompileTS} en lugar de una función para archivo: ${inPath}`);
         }
-        tsResult = await preCompileTS(code, inPath);
+        // 🚀 OPTIMIZACIÓN: Pasar scriptInfo directamente sin crear objeto nuevo
+        tsResult = await preCompileTS(code, inPath, vueResult?.scriptInfo);
         timings.tsCompile = Date.now() - start;
         if (tsResult === undefined || tsResult === null) {
             throw new Error(`preCompileTS devolvió ${tsResult} para archivo: ${inPath}`);

package/dist/compiler/minify.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
-import { minify } from 'oxc-minify';
+import { minifySync } from 'oxc-minify';
+import { logger } from '../servicios/logger.js';
 import { minifyTemplate } from './minifyTemplate.js';
 class MinificationCache {
     static instance;
@@ -49,11 +50,18 @@ class MinificationCache {
         this.cacheMisses++;
         const originalSize = data.length;
         try {
-            const result = await minify(filename, data, options);
+            const result = minifySync(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`);
+                logger.warn(`⚠️  Minificación fallida para ${filename}, usando código original`);
+                if (process.env.VERBOSE === 'true') {
+                    logger.debug(`[Minify Debug] El resultado de oxc-minify fue un código vacío para un archivo de tamaño: ${data.length}`);
+                    // Si el objeto result tiene otros campos útiles (como errores), los mostramos
+                    if (Object.keys(result).length > 1) {
+                        logger.debug(`[Minify Debug] Información adicional del resultado:`, JSON.stringify({ ...result, code: '[REDACTED]' }, null, 2));
+                    }
+                }
                 return {
                     code: data, // Retornar código original
                     error: null, // No es un error crítico
@@ -81,8 +89,15 @@ class MinificationCache {
         }
         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`);
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            logger.warn(`⚠️  Error al minificar ${filename}: ${errorMsg}`);
+            logger.warn(`   Usando código original sin minificar`);
+            if (process.env.VERBOSE === 'true') {
+                if (error instanceof Error && error.stack) {
+                    logger.debug(`[Minify Debug] Stack trace: ${error.stack}`);
+                }
+                logger.debug(`[Minify Debug] Opciones de minificación:`, JSON.stringify(options, null, 2));
+            }
             return {
                 code: data, // Retornar código original
                 error: null, // No propagar el error
@@ -102,7 +117,7 @@ class MinificationCache {
             this.currentMemoryUsage += entrySize;
         }
         catch (error) {
-            console.warn('[MinificationCache] Error cacheando minificación:', error);
+            logger.warn('[MinificationCache] Error cacheando minificación:', error);
         }
     }
     /**
@@ -215,6 +230,10 @@ export const minifyJS = async (data, filename, isProd = true) => {
             },
             codegen: {
                 removeWhitespace: true,
+                normal: true,
+                jsdoc: true,
+                annotation: true,
+                legal: true
             },
             sourcemap: !isProd,
         };

package/dist/compiler/minifyTemplate.js

@@ -1,4 +1,5 @@
 import { minifyHTMLLiterals } from 'minify-html-literals';
+import { logger } from '../servicios/logger.js';
 const defaultMinifyOptions = {
     // Opciones esenciales para componentes Vue
     caseSensitive: true, // Preserva mayúsculas/minúsculas en nombres de componentes
@@ -96,7 +97,7 @@ const detectAndTagTemplateStrings = (code) => {
         });
     }
     catch (error) {
-        console.warn('[MinifyTemplate] Error detectando template strings:', error);
+        logger.warn('[MinifyTemplate] Error detectando template strings:', error);
         return code;
     }
 };
@@ -113,7 +114,7 @@ const removeTemporaryTags = (code) => {
         return code.replace(tempHtmlPattern, '`').replace(tempCssPattern, '`');
     }
     catch (error) {
-        console.warn('[MinifyTemplate] Error removiendo tags temporales:', error);
+        logger.warn('[MinifyTemplate] Error removiendo tags temporales:', error);
         return code;
     }
 };
@@ -163,7 +164,7 @@ const minifyCSS = (code) => {
         });
     }
     catch (error) {
-        console.warn('[MinifyTemplate] Error minificando CSS:', error);
+        logger.warn('[MinifyTemplate] Error minificando CSS:', error);
         return code;
     }
 };
@@ -208,7 +209,7 @@ const minifyTemplate = (data, fileName) => {
             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
+                logger.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
@@ -221,7 +222,7 @@ const minifyTemplate = (data, fileName) => {
         return { code: finalCode, error: null };
     }
     catch (error) {
-        console.warn(`[MinifyTemplate] Error minificando plantilla ${fileName}:`, error);
+        logger.warn(`[MinifyTemplate] Error minificando plantilla ${fileName}:`, error);
         return { code: data, error };
     }
 };

package/dist/compiler/transforms.js

@@ -6,6 +6,20 @@ 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';
+// ✨ OPTIMIZACIÓN CRÍTICA: Cache de PATH_ALIAS parseado
+let cachedPathAlias = null;
+let lastPathAliasString = null;
+function getParsedPathAlias() {
+    if (!env.PATH_ALIAS)
+        return null;
+    // Solo parsear si el string cambió
+    if (cachedPathAlias && lastPathAliasString === env.PATH_ALIAS) {
+        return cachedPathAlias;
+    }
+    cachedPathAlias = JSON.parse(env.PATH_ALIAS);
+    lastPathAliasString = env.PATH_ALIAS;
+    return cachedPathAlias;
+}
 // Módulos built-in de Node.js que no deben ser resueltos
 const NODE_BUILTIN_MODULES = new Set([
     'fs',
@@ -94,7 +108,7 @@ export async function replaceAliasImportStatic(file, code) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
     }
-    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    const pathAlias = getParsedPathAlias();
     let resultCode = code;
     // Usar regex para transformar imports estáticos
     const importRegex = /import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?['"`]([^'"`]+)['"`]/g;
@@ -206,7 +220,7 @@ export async function replaceAliasImportDynamic(code, _imports, file) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
     }
-    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    const pathAlias = getParsedPathAlias();
     const pathDist = env.PATH_DIST;
     let resultCode = code;
     // Regex para imports dinámicos normales con string (solo comillas simples y dobles)
@@ -391,7 +405,7 @@ async function replaceAliasInStrings(code) {
     if (!env.PATH_ALIAS || !env.PATH_DIST) {
         return code;
     }
-    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    const pathAlias = getParsedPathAlias();
     const pathDist = env.PATH_DIST;
     let resultCode = code; // Regex para encontrar strings que contengan posibles alias
     // Busca strings entre comillas simples, dobles o backticks que contengan alias
@@ -539,7 +553,7 @@ export async function estandarizaCode(code, file) {
         code = await replaceAliasInStrings(code);
         code = await removehtmlOfTemplateString(code);
         code = await removeCodeTagImport(code);
-        if (env.isProd === 'true') {
+        if (env.isPROD === 'true') {
             code = await removePreserverComent(code);
         }
         return { code, error: null };

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

@@ -1,12 +1,18 @@
+import { readFileSync } from 'node:fs';
 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
+ * 🚀 OPTIMIZADO: Sin split preventivo, sin enhance - solo lo esencial para máxima velocidad
+ * @param scriptInfo - Información de extracción de script para archivos Vue (opcional)
  */
-export function parseTypeScriptErrors(diagnostics, fileName, sourceCode) {
+export function parseTypeScriptErrors(diagnostics, fileName, sourceCode, scriptInfo) {
     return diagnostics.map(diagnostic => {
-        // Usar el mejorador de errores para obtener mensaje detallado
-        const enhancedMessage = enhanceErrorMessage(diagnostic, fileName, sourceCode); // Determinar la severidad
+        // Extraer mensaje básico sin enhance (más rápido)
+        const message = typeof diagnostic.messageText === 'string'
+            ? diagnostic.messageText
+            : typescript.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+        const cleanedMessage = cleanErrorMessage(message); // Determinar la severidad
         let severity;
         switch (diagnostic.category) {
             case typescript.DiagnosticCategory.Error:
@@ -20,32 +26,102 @@ export function parseTypeScriptErrors(diagnostics, fileName, sourceCode) {
                 break;
         } // Construir información de ubicación limpia
         let help = `Código TS${diagnostic.code}`;
-        if (diagnostic.file && diagnostic.start !== undefined) {
-            const sourceFile = diagnostic.file;
-            // Verificar que el método getLineAndCharacterOfPosition existe (para compatibilidad con mocks)
-            if (typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
+        if (diagnostic.start !== undefined) {
+            // Intentar usar el sourceFile si está disponible
+            if (diagnostic.file &&
+                typeof diagnostic.file.getLineAndCharacterOfPosition ===
+                    'function') {
                 try {
-                    const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                    help += ` | Línea ${lineAndChar.line + 1}, Columna ${lineAndChar.character + 1}`;
+                    const lineAndChar = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                    // Ajustar línea si es un archivo Vue con script extraído
+                    const adjustedLine = scriptInfo
+                        ? lineAndChar.line + scriptInfo.startLine
+                        : lineAndChar.line + 1;
+                    help += ` | Línea ${adjustedLine}, Columna ${lineAndChar.character + 1}`;
                 }
                 catch {
-                    // Si falla, solo mostrar la posición de carácter
-                    help += ` | Posición ${diagnostic.start}`;
+                    // Fallback: calcular posición leyendo el archivo
+                    try {
+                        const content = readFileSync(fileName, 'utf-8');
+                        const lines = content.split('\n');
+                        const { line, column } = getLineAndColumnFromOffset(lines, diagnostic.start);
+                        help += ` | Línea ${line}, Columna ${column}`;
+                    }
+                    catch {
+                        // Último fallback: solo mostrar posición
+                        help += ` | Posición ${diagnostic.start}`;
+                    }
                 }
             }
             else {
-                // Fallback para cuando no está disponible el método (como en tests)
-                help += ` | Posición ${diagnostic.start}`;
+                // Fallback: calcular posición y mostrar snippet de código
+                try {
+                    // Para archivos Vue con sourceCode, extraer el snippet del código compilado
+                    if (scriptInfo && sourceCode) {
+                        const compiledLines = sourceCode.split('\n');
+                        const { line: compiledLine, column } = getLineAndColumnFromOffset(compiledLines, diagnostic.start);
+                        // Extraer la línea donde está el error
+                        const errorLine = compiledLines[compiledLine - 1]?.trim() || '';
+                        // Truncar si es muy largo, centrando en el punto del error
+                        const maxSnippetLength = 80;
+                        let snippet = errorLine;
+                        if (snippet.length > maxSnippetLength) {
+                            // Tomar alrededor del punto del error
+                            const start = Math.max(0, column - 40);
+                            const end = Math.min(snippet.length, column + 40);
+                            snippet =
+                                (start > 0 ? '...' : '') +
+                                    snippet.substring(start, end) +
+                                    (end < snippet.length ? '...' : '');
+                        }
+                        // Para archivos Vue, mostrar snippet para buscar
+                        help += ` | Buscar en archivo: "${snippet}"`;
+                    }
+                    else {
+                        // No es Vue o no tenemos sourceCode, usar el archivo directamente
+                        const content = readFileSync(fileName, 'utf-8');
+                        const lines = content.split('\n');
+                        const { line, column } = getLineAndColumnFromOffset(lines, diagnostic.start);
+                        help += ` | Línea ${line}, Columna ${column}`;
+                    }
+                }
+                catch {
+                    // Último fallback: solo mostrar posición
+                    help += ` | Posición ${diagnostic.start}`;
+                }
             }
         }
         return {
             file: fileName,
-            message: enhancedMessage,
+            message: cleanedMessage,
             severity,
             help,
         };
     });
 }
+/**
+ * Calcula línea y columna desde un offset de caracteres
+ * @param lines - Array de líneas ya procesadas (para evitar múltiples splits)
+ * @param offset - Posición del carácter
+ */
+function getLineAndColumnFromOffset(lines, offset) {
+    let currentOffset = 0;
+    let line = 1;
+    let column = 1;
+    for (let i = 0; i < lines.length; i++) {
+        const currentLine = lines[i];
+        if (currentLine === undefined)
+            continue;
+        const lineLength = currentLine.length + 1; // +1 para el \n
+        if (currentOffset + lineLength > offset) {
+            line = i + 1;
+            column = offset - currentOffset + 1;
+            break;
+        }
+        currentOffset += lineLength;
+    }
+    return { line, column };
+}
 /**
  * Limpia el mensaje de error eliminando información redundante
  */
@@ -61,8 +137,11 @@ function cleanErrorMessage(message) {
 }
 /**
  * Mejora significativamente el mensaje de error TypeScript con contexto visual
+ * ⚠️ DEPRECATED: Ya no se usa en el flujo normal para evitar overhead de performance
+ * Se mantiene para compatibilidad futura o modo verbose avanzado
+ * @param scriptInfo - Información de extracción de script para archivos Vue (opcional)
  */
-function enhanceErrorMessage(diagnostic, fileName, sourceCode) {
+function enhanceErrorMessage(diagnostic, fileName, sourceCode, scriptInfo) {
     // Extraer el mensaje del error
     const message = typeof diagnostic.messageText === 'string'
         ? diagnostic.messageText
@@ -76,35 +155,43 @@ function enhanceErrorMessage(diagnostic, fileName, sourceCode) {
         if (typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
             try {
                 const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                const line = lineAndChar.line + 1;
+                // Ajustar línea si es un archivo Vue con script extraído
+                const line = scriptInfo
+                    ? lineAndChar.line + scriptInfo.startLine
+                    : lineAndChar.line + 1;
                 const column = lineAndChar.character + 1;
                 location = `Línea ${line}, Columna ${column} | Código TS${diagnostic.code}`;
             }
             catch {
-                // Si falla, solo mostrar la posición de carácter
-                location = `Posición ${diagnostic.start} | Código TS${diagnostic.code}`;
+                // Si falla, solo mostrar el código de error
+                location = `Código TS${diagnostic.code}`;
             }
         }
         else {
-            // Fallback para cuando no está disponible el método (como en tests)
-            location = `Posición ${diagnostic.start} | Código TS${diagnostic.code}`;
+            // Fallback: solo mostrar el código de error
+            location = `Código TS${diagnostic.code}`;
         } // Agregar contexto del código si está disponible
-        if ((sourceCode || sourceFile.text) &&
+        if ((sourceCode || scriptInfo?.originalData || sourceFile.text) &&
             typeof sourceFile.getLineAndCharacterOfPosition === 'function') {
             try {
                 const lineAndChar = sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
-                const text = sourceCode || sourceFile.text;
+                // Obtener código fuente apropiado
+                const text = scriptInfo?.originalData || sourceCode || sourceFile.text;
                 const lines = text.split('\n');
-                const errorLine = lines[lineAndChar.line];
+                // Calcular la línea real en el archivo original
+                const actualLineIndex = scriptInfo
+                    ? lineAndChar.line + scriptInfo.startLine - 1
+                    : lineAndChar.line;
+                const errorLine = lines[actualLineIndex];
                 if (errorLine) {
                     // Mostrar hasta 2 líneas antes y después para contexto
-                    const startLine = Math.max(0, lineAndChar.line - 2);
-                    const endLine = Math.min(lines.length - 1, lineAndChar.line + 2);
+                    const startLine = Math.max(0, actualLineIndex - 2);
+                    const endLine = Math.min(lines.length - 1, actualLineIndex + 2);
                     codeContext = '\n\n📝 Contexto del código:\n';
                     for (let i = startLine; i <= endLine; i++) {
                         const currentLine = i + 1;
                         const lineContent = lines[i] || '';
-                        const isErrorLine = i === lineAndChar.line;
+                        const isErrorLine = i === actualLineIndex;
                         if (isErrorLine) {
                             codeContext += `  ${currentLine.toString().padStart(3, ' ')} ❌ ${lineContent}\n`;
                             // Agregar flecha apuntando al error

package/dist/compiler/typescript-manager.js

@@ -213,9 +213,10 @@ const cleanupUnnecessaryExports = (compiledOutput, originalSource) => {
  * 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 {ScriptExtractionInfo} scriptInfo - Información de extracción de script para archivos Vue (opcional).
  * @returns {Promise<CompileResult>} - Un objeto con el código precompilado o un error.
  */
-export const preCompileTS = async (data, fileName) => {
+export const preCompileTS = async (data, fileName, scriptInfo) => {
     try {
         // Validación temprana: contenido vacío
         if (!data.trim()) {
@@ -241,6 +242,7 @@ export const preCompileTS = async (data, fileName) => {
                 // Modo más rápido
                 incremental: false, // No usar incremental en transpileModule
                 diagnostics: false,
+                removeComments: env.isPROD === 'true',
             },
             fileName,
             reportDiagnostics: env.VERBOSE === 'true', // Solo reportar en verbose
@@ -260,7 +262,7 @@ export const preCompileTS = async (data, fileName) => {
                     diag.code !== 6059);
             });
             if (criticalErrors.length > 0) {
-                const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(criticalErrors, fileName, data));
+                const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(criticalErrors, fileName, data, scriptInfo));
                 return {
                     error: new Error(errorMessage),
                     data: null,
@@ -274,9 +276,14 @@ export const preCompileTS = async (data, fileName) => {
                 const serializableOptions = createSerializableCompilerOptions(compilerOptions);
                 const typeCheckResult = await workerPool.typeCheck(fileName, data, serializableOptions);
                 if (typeCheckResult.hasErrors) {
-                    const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(typeCheckResult.diagnostics, fileName, data));
+                    const errorMessage = createUnifiedErrorMessage(parseTypeScriptErrors(typeCheckResult.diagnostics, fileName, data, scriptInfo));
+                    const error = new Error(errorMessage);
+                    // Marcar como error de tipo (no error del compilador)
+                    error.isTypeError = true;
+                    // Limpiar stack trace para no confundir con errores del compilador
+                    error.stack = undefined;
                     return {
-                        error: new Error(errorMessage),
+                        error,
                         data: null,
                         lang: 'ts',
                     };

package/dist/compiler/vuejs.js

@@ -158,8 +158,11 @@ export const preCompileVue = async (data, source, isProd = false) => {
                 error: null,
                 data: 'export default {};',
                 lang: 'js',
+                scriptInfo: undefined,
             };
         }
+        // Guardar el código original antes de inyectar HMR
+        const originalData = data;
         if (!isProd) {
             const { injectedData } = hmrInjectionCache.getOrGenerateHMRInjection(data, fileName);
             data = injectedData;
@@ -370,11 +373,22 @@ export const preCompileVue = async (data, source, isProd = false) => {
 
             export default ${componentName};        `;
         output = `${output}\n${finishComponent}`;
-        return {
+        // 🚀 OPTIMIZACIÓN CRÍTICA: Evitar crear scriptInfo si no hay script
+        const result = {
             lang: finalCompiledScript.lang,
             error: null,
             data: output,
         };
+        // Solo agregar scriptInfo cuando realmente hay script (evita overhead)
+        if (descriptor.script || descriptor.scriptSetup) {
+            result.scriptInfo = {
+                startLine: (descriptor.script || descriptor.scriptSetup).loc?.start
+                    .line || 1,
+                content: (descriptor.script || descriptor.scriptSetup).content,
+                originalData: originalData, // String directa, no closure
+            };
+        }
+        return result;
     }
     catch (error) {
         logger.error('Vue compilation error:', error);
@@ -382,6 +396,7 @@ export const preCompileVue = async (data, source, isProd = false) => {
             lang: null,
             error: error instanceof Error ? error : new Error(String(error)),
             data: null,
+            scriptInfo: undefined,
         };
     }
 };

package/dist/main.js

@@ -97,6 +97,7 @@ async function main() {
         default: false, // Por defecto, verbose está deshabilitado
     })
         .alias('v', 'verbose')
+        .alias('debug', 'verbose')
         .option('cleanOutput', {
         type: 'boolean',
         description: 'Limpiar el directorio de salida antes de compilar',

package/dist/utils/module-resolver.js

@@ -6,6 +6,48 @@ import { cwd, env } from 'node:process';
 // import resolve from '/node_modules/resolve/index.js';
 import { logger } from '../servicios/logger.js';
 import { EXCLUDED_MODULES } from './excluded-modules.js';
+class PackageJsonCache {
+    static instance;
+    cache = new Map();
+    MAX_CACHE_SIZE = 200;
+    static getInstance() {
+        if (!PackageJsonCache.instance) {
+            PackageJsonCache.instance = new PackageJsonCache();
+        }
+        return PackageJsonCache.instance;
+    }
+    get(packagePath) {
+        try {
+            if (!fs.existsSync(packagePath)) {
+                return null;
+            }
+            const stats = fs.statSync(packagePath);
+            const cached = this.cache.get(packagePath);
+            if (cached && cached.mtime === stats.mtimeMs) {
+                return cached.content;
+            }
+            const content = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            if (this.cache.size >= this.MAX_CACHE_SIZE) {
+                const firstKey = this.cache.keys().next().value;
+                if (firstKey) {
+                    this.cache.delete(firstKey);
+                }
+            }
+            this.cache.set(packagePath, {
+                content,
+                mtime: stats.mtimeMs,
+            });
+            return content;
+        }
+        catch {
+            return null;
+        }
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+const packageJsonCache = PackageJsonCache.getInstance();
 // function resolveESMWithLibrary(moduleName: string): string | null {
 //     try {
 //         // Resolver el módulo
@@ -141,166 +183,130 @@ function findOptimalESMVersion(moduleDir, entryPoint) {
                 }
                 return optimizedPath;
             }
-        } // Buscar archivos que contengan patrones ESM/browser dinámicamente
-        const esmBrowserFiles = files.filter((file) => {
+        }
+        // ✨ OPTIMIZACIÓN CRÍTICA: Clasificar archivos en un solo loop
+        const fileGroups = {
+            esmBrowserProd: [],
+            esmBrowserMin: [],
+            esmBrowserDev: [],
+            esmProd: [],
+            esmMin: [],
+            esmDev: [],
+            browserMin: [],
+            runtimeDev: [],
+            runtime: [],
+            other: [],
+        };
+        for (const file of files) {
+            if (!file.endsWith('.js') && !file.endsWith('.mjs'))
+                continue;
             const lowerFile = file.toLowerCase();
-            return ((lowerFile.includes('.esm-browser.') || // Prioridad alta: combinación esm-browser
-                lowerFile.includes('.esm.') ||
-                lowerFile.includes('.module.') ||
-                lowerFile.includes('.browser.') ||
-                lowerFile.includes('.web.') ||
-                lowerFile.includes('.runtime.esm-browser.')) && // Runtime como última opción
-                (file.endsWith('.js') || file.endsWith('.mjs')));
-        });
-        if (esmBrowserFiles.length > 0) {
-            // Primera prioridad: archivos que combinan ESM y Browser (sin runtime)
-            const esmBrowserCombined = esmBrowserFiles.filter((file) => file.toLowerCase().includes('.esm-browser.') &&
-                !file.toLowerCase().includes('.runtime.'));
-            if (esmBrowserCombined.length > 0) {
-                // ✨ MODO PRODUCCIÓN: Priorizar .prod.js o .min.js
-                if (env.isPROD === 'true') {
-                    // Primera opción: archivos .prod.js
-                    const prodFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.prod.'));
-                    if (prodFiles.length > 0 && prodFiles[0]) {
-                        const optimizedPath = join(dir, prodFiles[0]).replace(/\\/g, '/');
-                        if (env.VERBOSE === 'true') {
-                            logger.info(`🏭 Versión ESM-Browser producción encontrada: ${optimizedPath}`);
-                        }
-                        return optimizedPath;
-                    }
-                    // Segunda opción: archivos .min.js
-                    const minFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.min.'));
-                    if (minFiles.length > 0 && minFiles[0]) {
-                        const optimizedPath = join(dir, minFiles[0]).replace(/\\/g, '/');
-                        if (env.VERBOSE === 'true') {
-                            logger.info(`🗜️ Versión ESM-Browser minificada encontrada: ${optimizedPath}`);
-                        }
-                        return optimizedPath;
-                    }
-                    // Fallback: si no hay .prod ni .min, usar desarrollo
-                    if (env.VERBOSE === 'true') {
-                        logger.warn('⚠️ No se encontró versión de producción, usando desarrollo');
-                    }
-                }
-                // ✨ MODO DESARROLLO: Priorizar desarrollo > .prod > .min
-                const devFiles = esmBrowserCombined.filter((file) => !file.toLowerCase().includes('.prod.') &&
-                    !file.toLowerCase().includes('.min.'));
-                if (devFiles.length > 0 && devFiles[0]) {
-                    const optimizedPath = join(dir, devFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`🔧 Versión ESM-Browser desarrollo encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                // Fallback en desarrollo: si no hay versión dev, usar prod
-                const prodFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.prod.'));
-                if (prodFiles.length > 0 && prodFiles[0]) {
-                    const optimizedPath = join(dir, prodFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM-Browser producción encontrada (fallback): ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                const minFiles = esmBrowserCombined.filter((file) => file.toLowerCase().includes('.min.'));
-                if (minFiles.length > 0 && minFiles[0]) {
-                    const optimizedPath = join(dir, minFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM-Browser minificada encontrada (fallback): ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                if (esmBrowserCombined[0]) {
-                    const optimizedPath = join(dir, esmBrowserCombined[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM-Browser encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            const hasEsmBrowser = lowerFile.includes('.esm-browser.');
+            const hasEsm = lowerFile.includes('.esm.') || lowerFile.includes('.module.');
+            const hasBrowser = lowerFile.includes('.browser.') || lowerFile.includes('.web.');
+            const hasRuntime = lowerFile.includes('.runtime.');
+            const isProd = lowerFile.includes('.prod.');
+            const isMin = lowerFile.includes('.min.');
+            if (hasEsmBrowser && !hasRuntime) {
+                if (isProd)
+                    fileGroups.esmBrowserProd.push(file);
+                else if (isMin)
+                    fileGroups.esmBrowserMin.push(file);
+                else
+                    fileGroups.esmBrowserDev.push(file);
             }
-            // Segunda prioridad: cualquier versión ESM disponible
-            if (env.isPROD === 'true') {
-                // En producción, buscar versiones minificadas/prod primero
-                const esmProdFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.esm.') ||
-                    file.toLowerCase().includes('.module.')) &&
-                    (file.toLowerCase().includes('.prod.') ||
-                        file.toLowerCase().includes('.min.')) &&
-                    !file.toLowerCase().includes('.runtime.'));
-                if (esmProdFiles.length > 0 && esmProdFiles[0]) {
-                    const optimizedPath = join(dir, esmProdFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`🏭 Versión ESM producción encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasEsm && !hasRuntime) {
+                if (isProd)
+                    fileGroups.esmProd.push(file);
+                else if (isMin)
+                    fileGroups.esmMin.push(file);
+                else
+                    fileGroups.esmDev.push(file);
             }
-            else {
-                // En desarrollo, buscar versiones sin minificar
-                const esmFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.esm.') ||
-                    file.toLowerCase().includes('.module.')) &&
-                    !file.toLowerCase().includes('.min.') &&
-                    !file.toLowerCase().includes('.prod.') &&
-                    !file.toLowerCase().includes('.runtime.'));
-                if (esmFiles.length > 0 && esmFiles[0]) {
-                    const optimizedPath = join(dir, esmFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`🔧 Versión ESM desarrollo encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasBrowser && isMin) {
+                fileGroups.browserMin.push(file);
             }
-            // Tercera prioridad: archivos minificados de cualquier tipo ESM/browser (sin runtime)
-            const minifiedFiles = esmBrowserFiles.filter((file) => (file.toLowerCase().includes('.min.') ||
-                file.toLowerCase().includes('.prod.')) &&
-                !file.toLowerCase().includes('.runtime.'));
-            if (minifiedFiles.length > 0) {
-                // Priorizar ESM sobre browser sobre UMD
-                const esmFiles = minifiedFiles.filter((file) => file.toLowerCase().includes('.esm.') ||
-                    file.toLowerCase().includes('.module.'));
-                if (esmFiles.length > 0 && esmFiles[0]) {
-                    const optimizedPath = join(dir, esmFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión ESM minificada encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                if (minifiedFiles[0]) {
-                    const optimizedPath = join(dir, minifiedFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión minificada encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasRuntime && hasEsmBrowser) {
+                if (!isProd && !isMin)
+                    fileGroups.runtimeDev.push(file);
+                else
+                    fileGroups.runtime.push(file);
             }
-            // Cuarta prioridad: versiones runtime como último recurso
-            const runtimeFiles = esmBrowserFiles.filter((file) => file.toLowerCase().includes('.runtime.esm-browser.'));
-            if (runtimeFiles.length > 0) {
-                // Priorizar desarrollo sobre producción en runtime también
-                const devRuntimeFiles = runtimeFiles.filter((file) => !file.toLowerCase().includes('.prod.') &&
-                    !file.toLowerCase().includes('.min.'));
-                if (devRuntimeFiles.length > 0 && devRuntimeFiles[0]) {
-                    const optimizedPath = join(dir, devRuntimeFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión Runtime ESM-Browser dev encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
-                if (runtimeFiles[0]) {
-                    const optimizedPath = join(dir, runtimeFiles[0]).replace(/\\/g, '/');
-                    if (env.VERBOSE === 'true') {
-                        logger.info(`Versión Runtime ESM-Browser encontrada: ${optimizedPath}`);
-                    }
-                    return optimizedPath;
-                }
+            else if (hasEsm || hasBrowser) {
+                fileGroups.other.push(file);
             }
-            // Fallback: cualquier versión browser
-            if (esmBrowserFiles[0]) {
-                const optimizedPath = join(dir, esmBrowserFiles[0]).replace(/\\/g, '/');
-                if (env.VERBOSE === 'true') {
-                    logger.info(`Versión browser encontrada: ${optimizedPath}`);
-                }
+        }
+        // Seleccionar archivo según prioridad y modo
+        const isProd = env.isPROD === 'true';
+        // Prioridad 1: ESM-Browser
+        if (isProd) {
+            if (fileGroups.esmBrowserProd[0]) {
+                const optimizedPath = join(dir, fileGroups.esmBrowserProd[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`🏭 Versión ESM-Browser producción encontrada: ${optimizedPath}`);
+                return optimizedPath;
+            }
+            if (fileGroups.esmBrowserMin[0]) {
+                const optimizedPath = join(dir, fileGroups.esmBrowserMin[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`🗜️ Versión ESM-Browser minificada encontrada: ${optimizedPath}`);
                 return optimizedPath;
             }
         }
+        if (fileGroups.esmBrowserDev[0]) {
+            const optimizedPath = join(dir, fileGroups.esmBrowserDev[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`🔧 Versión ESM-Browser desarrollo encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Prioridad 2: ESM puro
+        if (isProd) {
+            if (fileGroups.esmProd[0]) {
+                const optimizedPath = join(dir, fileGroups.esmProd[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`Versión ESM producción encontrada: ${optimizedPath}`);
+                return optimizedPath;
+            }
+            if (fileGroups.esmMin[0]) {
+                const optimizedPath = join(dir, fileGroups.esmMin[0]).replace(/\\/g, '/');
+                if (env.VERBOSE === 'true')
+                    logger.info(`Versión ESM minificada encontrada: ${optimizedPath}`);
+                return optimizedPath;
+            }
+        }
+        if (fileGroups.esmDev[0]) {
+            const optimizedPath = join(dir, fileGroups.esmDev[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión ESM encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Prioridad 3: Browser minificado
+        if (fileGroups.browserMin[0]) {
+            const optimizedPath = join(dir, fileGroups.browserMin[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión browser minificada encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Prioridad 4: Runtime
+        if (fileGroups.runtimeDev[0]) {
+            const optimizedPath = join(dir, fileGroups.runtimeDev[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión Runtime ESM-Browser dev encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        if (fileGroups.runtime[0]) {
+            const optimizedPath = join(dir, fileGroups.runtime[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión Runtime ESM-Browser encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
+        // Fallback: otros archivos browser/esm
+        if (fileGroups.other[0]) {
+            const optimizedPath = join(dir, fileGroups.other[0]).replace(/\\/g, '/');
+            if (env.VERBOSE === 'true')
+                logger.info(`Versión browser encontrada: ${optimizedPath}`);
+            return optimizedPath;
+        }
     }
     catch (error) {
         if (env.VERBOSE === 'true') {
@@ -323,7 +329,9 @@ function simpleESMResolver(moduleName) {
         catch {
             return null;
         }
-        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        const packageJson = packageJsonCache.get(packagePath);
+        if (!packageJson)
+            return null;
         const moduleDir = dirname(packagePath);
         const isESM = packageJson.type === 'module'; // Determinar el entry point ESM/Browser optimizado
         let entryPoint = null;
@@ -392,7 +400,7 @@ function simpleESMResolver(moduleName) {
             entryPoint = isESM ? 'index.js' : 'index.cjs';
         } // Resolver la ruta final
         let finalPath = join(moduleDir, entryPoint);
-        // Buscar una versión ESM/browser optimizada
+        // Buscar una versión ESM/browser optimizada (garantizar que entryPoint es string)
         const optimizedEntry = findOptimalESMVersion(moduleDir, entryPoint);
         if (optimizedEntry && optimizedEntry !== entryPoint) {
             finalPath = join(moduleDir, optimizedEntry);
@@ -507,7 +515,9 @@ export function getModuleSubPath(moduleName, fromFile) {
             if (!fs.existsSync(packagePath)) {
                 return null;
             }
-            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            const packageJson = packageJsonCache.get(packagePath);
+            if (!packageJson)
+                return null;
             const moduleDir = dirname(packagePath);
             // Revisar exports field para subpaths
             if (packageJson.exports &&

package/package.json

@@ -1,110 +1,111 @@
-{
-    "name": "versacompiler",
-    "version": "2.3.2",
-    "description": "Una herramienta para compilar y minificar archivos .vue, .js y .ts para proyectos de Vue 3 con soporte para TypeScript.",
-    "main": "dist/main.js",
-    "bin": {
-        "versacompiler": "dist/main.js"
-    },
-    "publishConfig": {
-        "access": "public"
-    },
-    "files": [
-        "dist",
-        "LICENSE",
-        "README.md"
-    ],
-    "type": "module",
-    "scripts": {
-        "dev": "tsx --watch src/main.ts --watch --verbose --tailwind",
-        "file": "tsx src/main.ts ",
-        "compile": "tsx src/main.ts --all --cc -y --verbose --prod",
-        "compileDev": "tsx src/main.ts --all --cc -y --verbose",
-        "test": "vitest run",
-        "test:watch": "vitest",
-        "test:ui": "vitest --ui",
-        "test:coverage": "vitest run --coverage",
-        "build": "tsx src/main.ts --all -t --cc --co -y --verbose",
-        "lint": "oxlint --fix --config .oxlintrc.json",
-        "lint:eslint": "eslint --ext .js,.ts,.vue src/ --fix"
-    },
-    "keywords": [
-        "vue",
-        "compiler",
-        "minifier",
-        "vue3",
-        "versacompiler",
-        "typescript",
-        "linter"
-    ],
-    "author": "Jorge Jara H (kriollone@gmail.com)",
-    "license": "MIT",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/kriollo/versaCompiler.git"
-    },
-    "bugs": {
-        "url": "https://github.com/kriollo/versaCompiler/issues"
-    },
-    "homepage": "https://github.com/kriollo/versaCompiler#readme",
-    "dependencies": {
-        "@vue/compiler-dom": "^3.5.26",
-        "@vue/reactivity": "^3.5.26",
-        "@vue/runtime-core": "^3.5.26",
-        "@vue/runtime-dom": "^3.5.26",
-        "browser-sync": "^3.0.4",
-        "chalk": "5.6.2",
-        "chokidar": "^5.0.0",
-        "enhanced-resolve": "^5.18.4",
-        "execa": "^9.6.1",
-        "find-root": "^1.1.0",
-        "fs-extra": "^11.3.3",
-        "get-port": "^7.1.0",
-        "minify-html-literals": "^1.3.5",
-        "minimatch": "^10.1.1",
-        "oxc-minify": "^0.108.0",
-        "oxc-parser": "^0.108.0",
-        "oxc-transform": "^0.108.0",
-        "resolve": "^1.22.11",
-        "tsx": "^4.21.0",
-        "typescript": "^5.9.3",
-        "vue": "3.5.26",
-        "yargs": "^18.0.0"
-    },
-    "devDependencies": {
-        "@eslint/eslintrc": "^3.3.3",
-        "@tailwindcss/cli": "^4.1.18",
-        "@types/browser-sync": "^2.29.1",
-        "@types/find-root": "^1.1.4",
-        "@types/fs-extra": "^11.0.4",
-        "@types/jest": "^30.0.0",
-        "@types/mocha": "^10.0.10",
-        "@types/node": "^25.0.9",
-        "@types/resolve": "^1.20.6",
-        "@types/yargs": "^17.0.35",
-        "@typescript-eslint/eslint-plugin": "^8.53.0",
-        "@typescript-eslint/parser": "^8.53.0",
-        "@vitest/coverage-v8": "^4.0.17",
-        "@vitest/ui": "^4.0.17",
-        "@vue/eslint-config-typescript": "^14.6.0",
-        "@vue/test-utils": "^2.4.6",
-        "code-tag": "^1.2.0",
-        "eslint": "^9.39.2",
-        "eslint-import-resolver-typescript": "^4.4.4",
-        "eslint-plugin-import": "^2.32.0",
-        "eslint-plugin-oxlint": "^1.39.0",
-        "eslint-plugin-promise": "^7.2.1",
-        "eslint-plugin-unicorn": "^62.0.0",
-        "eslint-plugin-vue": "^10.6.2",
-        "oxlint": "^1.39.0",
-        "pinia": "^3.0.4",
-        "prettier": "3.8.0",
-        "rimraf": "^6.1.2",
-        "sweetalert2": "^11.26.17",
-        "tailwindcss": "^4.1.18",
-        "vitest": "^4.0.17",
-        "vue-eslint-parser": "^10.2.0",
-        "vue-router": "^4.6.4"
-    },
-    "packageManager": "pnpm@10.15.0+sha512.486ebc259d3e999a4e8691ce03b5cac4a71cbeca39372a9b762cb500cfdf0873e2cb16abe3d951b1ee2cf012503f027b98b6584e4df22524e0c7450d9ec7aa7b"
-}
+{
+    "name": "versacompiler",
+    "version": "2.3.4",
+    "description": "Una herramienta para compilar y minificar archivos .vue, .js y .ts para proyectos de Vue 3 con soporte para TypeScript.",
+    "main": "dist/main.js",
+    "bin": {
+        "versacompiler": "dist/main.js"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist",
+        "LICENSE",
+        "README.md"
+    ],
+    "type": "module",
+    "scripts": {
+        "dev": "tsx --watch src/main.ts --watch --verbose --tailwind",
+        "file": "tsx src/main.ts ",
+        "compile": "tsx src/main.ts --all --cc --co -y --verbose --prod",
+        "compileDev": "tsx src/main.ts --all --cc -y --linter -t --verbose",
+        "vtlint": "tsx src/main.ts --all --cc --co -y -t",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:ui": "vitest --ui",
+        "test:coverage": "vitest run --coverage",
+        "build": "tsx src/main.ts --all -t --cc --co -y --verbose",
+        "lint": "oxlint --fix --config .oxlintrc.json",
+        "lint:eslint": "eslint --ext .js,.ts,.vue src/ --fix"
+    },
+    "keywords": [
+        "vue",
+        "compiler",
+        "minifier",
+        "vue3",
+        "versacompiler",
+        "typescript",
+        "linter"
+    ],
+    "author": "Jorge Jara H (kriollone@gmail.com)",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/kriollo/versaCompiler.git"
+    },
+    "bugs": {
+        "url": "https://github.com/kriollo/versaCompiler/issues"
+    },
+    "homepage": "https://github.com/kriollo/versaCompiler#readme",
+    "dependencies": {
+        "@vue/compiler-dom": "^3.5.27",
+        "@vue/reactivity": "^3.5.27",
+        "@vue/runtime-core": "^3.5.27",
+        "@vue/runtime-dom": "^3.5.27",
+        "browser-sync": "^3.0.4",
+        "chalk": "5.6.2",
+        "chokidar": "^5.0.0",
+        "enhanced-resolve": "^5.19.0",
+        "execa": "^9.6.1",
+        "find-root": "^1.1.0",
+        "fs-extra": "^11.3.3",
+        "get-port": "^7.1.0",
+        "minify-html-literals": "^1.3.5",
+        "minimatch": "^10.1.2",
+        "oxc-minify": "^0.112.0",
+        "oxc-parser": "^0.112.0",
+        "oxc-transform": "^0.112.0",
+        "resolve": "^1.22.11",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "vue": "3.5.27",
+        "yargs": "^18.0.0"
+    },
+    "devDependencies": {
+        "@eslint/eslintrc": "^3.3.3",
+        "@tailwindcss/cli": "^4.1.18",
+        "@types/browser-sync": "^2.29.1",
+        "@types/find-root": "^1.1.4",
+        "@types/fs-extra": "^11.0.4",
+        "@types/jest": "^30.0.0",
+        "@types/mocha": "^10.0.10",
+        "@types/node": "^25.2.0",
+        "@types/resolve": "^1.20.6",
+        "@types/yargs": "^17.0.35",
+        "@typescript-eslint/eslint-plugin": "^8.54.0",
+        "@typescript-eslint/parser": "^8.54.0",
+        "@vitest/coverage-v8": "^4.0.18",
+        "@vitest/ui": "^4.0.18",
+        "@vue/eslint-config-typescript": "^14.6.0",
+        "@vue/test-utils": "^2.4.6",
+        "code-tag": "^1.2.0",
+        "eslint": "^9.39.2",
+        "eslint-import-resolver-typescript": "^4.4.4",
+        "eslint-plugin-import": "^2.32.0",
+        "eslint-plugin-oxlint": "^1.43.0",
+        "eslint-plugin-promise": "^7.2.1",
+        "eslint-plugin-unicorn": "^62.0.0",
+        "eslint-plugin-vue": "^10.7.0",
+        "oxlint": "^1.43.0",
+        "pinia": "^3.0.4",
+        "prettier": "3.8.1",
+        "rimraf": "^6.1.2",
+        "sweetalert2": "^11.26.18",
+        "tailwindcss": "^4.1.18",
+        "vitest": "^4.0.18",
+        "vue-eslint-parser": "^10.2.0",
+        "vue-router": "^5.0.2"
+    },
+    "packageManager": "pnpm@10.15.0+sha512.486ebc259d3e999a4e8691ce03b5cac4a71cbeca39372a9b762cb500cfdf0873e2cb16abe3d951b1ee2cf012503f027b98b6584e4df22524e0c7450d9ec7aa7b"
+}