versacompiler 2.1.0 → 2.2.0

package/dist/compiler/transforms.js

@@ -1 +1,554 @@
-import e from"node:path";import{env as n}from"node:process";import{logger as r}from"../servicios/logger.js";import{EXCLUDED_MODULES as i}from"../utils/excluded-modules.js";import{getModuleSubPath as a}from"../utils/module-resolver.js";import{analyzeAndFormatMultipleErrors as o}from"./error-reporter.js";import{getOptimizedAliasPath as s,getOptimizedModulePath as c}from"./module-resolution-optimizer.js";import{parser as l}from"./parser.js";const u=new Set(`fs.path.os.crypto.http.https.url.util.events.stream.buffer.child_process.cluster.dgram.dns.net.readline.repl.tls.tty.vm.zlib.assert.module.process.querystring.string_decoder.timers.v8.worker_threads`.split(`.`));function d(e,n){if(e.startsWith(`./`)||e.startsWith(`../`)||e.startsWith(`/`)||[`public/`,`src/`,`dist/`,`components/`,`utils/`,`assets/`,`styles/`].some(n=>e.startsWith(n)))return!1;let r=e.replace(/^node:/,``);if(u.has(r))return!1;if(i.has(e))return!0;for(let r of Object.keys(n)){let n=r.replace(`/*`,``);if(e.startsWith(n))return!1}return!(e.includes(`.js`)||e.includes(`.ts`)||e.includes(`.vue`)||e.includes(`.css`)||e.includes(`.json`))}export async function replaceAliasImportStatic(i,o){if(!n.PATH_ALIAS||!n.PATH_DIST)return o;let l=JSON.parse(n.PATH_ALIAS),u=o,f=Array.from(u.matchAll(/import\s+(?:(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?['"`]([^'"`]+)['"`]/g));for(let o of f){let[,f]=o;if(!f)continue;let p=null,m=!1;if(!m&&d(f,l))try{let e=await c(f,i);if(e===null)continue;if(e)p=e,m=!0;else{let e=a(f,i);if(e===null)continue;e&&(p=e,m=!0)}}catch(e){n.VERBOSE===`true`&&r.warn(`Error resolviendo módulo ${f}: ${e instanceof Error?e.message:String(e)}`)}if(!m){let r=s(f);if(r){let e=r;e.endsWith(`.ts`)||e.endsWith(`.vue`)?e=e.replace(/\.(ts|vue)$/,`.js`):/\.(js|mjs|css|json)$/.test(e)||(e+=`.js`),p=e,m=!0}else for(let[r]of Object.entries(l)){let i=r.replace(`/*`,``);if(f.startsWith(i)){let r=f.replace(i,``),a=e.join(`/`,n.PATH_DIST,r);a=a.replace(/\/\.\//g,`/`).replace(/\\/g,`/`),a.endsWith(`.ts`)||a.endsWith(`.vue`)?a=a.replace(/\.(ts|vue)$/,`.js`):/\.(js|mjs|css|json)$/.test(a)||(a+=`.js`),p=a,m=!0;break}}}if(!m&&(f.startsWith(`./`)||f.startsWith(`../`))){let e=f;e.endsWith(`.ts`)||e.endsWith(`.vue`)?(e=e.replace(/\.(ts|vue)$/,`.js`),p=e,m=!0):/\.(js|mjs|css|json)$/.test(e)||(p=e+`.js`,m=!0)}if(m&&p){let e=RegExp(`(['"\`])${f.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}\\1`,`g`);u=u.replace(e,`$1${p}$1`)}}return u}async function p(i,o,l){if(!n.PATH_ALIAS||!n.PATH_DIST)return i;let u=JSON.parse(n.PATH_ALIAS),f=n.PATH_DIST,p=i,m=/import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,h=/import\s*\(\s*`([^`]+)`\s*\)/g,g=Array.from(p.matchAll(m));for(let i of g){let[,o]=i;if(!o)continue;let m=null,h=!1;if(!h&&d(o,u))try{let e=await c(o,l);if(e===null)continue;if(e)m=e,h=!0;else{let e=a(o,l);if(e===null)continue;e&&(m=e,h=!0)}}catch(e){n.VERBOSE===`true`&&r.warn(`Error resolviendo módulo dinámico ${o}: ${e instanceof Error?e.message:String(e)}`)}if(!h){let n=s(o);if(n){let e=n;e.endsWith(`.ts`)||e.endsWith(`.vue`)?e=e.replace(/\.(ts|vue)$/,`.js`):/\.(js|mjs|css|json)$/.test(e)||(e+=`.js`),m=e,h=!0}else for(let[n]of Object.entries(u)){let r=n.replace(`/*`,``);if(o.startsWith(r)){let n=o.replace(r,``),i=e.join(`/`,f,n);i=i.replace(/\/\.\//g,`/`).replace(/\\/g,`/`),i.endsWith(`.ts`)||i.endsWith(`.vue`)?i=i.replace(/\.(ts|vue)$/,`.js`):/\.(js|mjs|css|json)$/.test(i)||(i+=`.js`),m=i,h=!0;break}}}if(!h&&(o.startsWith(`./`)||o.startsWith(`../`))){let e=o;e.endsWith(`.ts`)||e.endsWith(`.vue`)?(e=e.replace(/\.(ts|vue)$/,`.js`),m=e,h=!0):/\.(js|mjs|css|json)$/.test(e)||(m=e+`.js`,h=!0)}if(h&&m){let e=RegExp(`import\\s*\\(\\s*(['"])${o.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}\\1\\s*\\)`,`g`);p=p.replace(e,`import($1${m}$1)`)}}return p=p.replace(h,(i,o)=>{let s=!1,c=i;if(!s&&d(o,u))try{let e=a(o,l);if(e===null)return i;e&&(c=i.replace(o,e),s=!0)}catch(e){n.VERBOSE===`true`&&r.warn(`Error resolviendo módulo template literal ${o}: ${e instanceof Error?e.message:String(e)}`)}if(!s)for(let[n]of Object.entries(u)){let r=n.replace(`/*`,``);if(o.includes(r)){let n=o.replace(r,``),a=e.join(`/`,f,n);a=a.replace(/\/\.\//g,`/`).replace(/\/+/g,`/`).replace(/\\/g,`/`),c=i.replace(o,a),s=!0;break}}if(!s){let e=o;(o.includes(`./`)||o.includes(`../`))&&(e=o.replace(/\.ts(\b|`)/g,`.js$1`).replace(/\.vue(\b|`)/g,`.js$1`),e!==o&&(c=i.replace(o,e)))}return c}),p}async function m(r){if(!n.PATH_ALIAS||!n.PATH_DIST)return r;let a=JSON.parse(n.PATH_ALIAS),o=n.PATH_DIST,s=r,c=Array.from(s.matchAll(/(['"`])([^'"`]+)(['"`])/g));for(let r of c){let[c,l,u,f]=r;if(l!==f||!u)continue;let p=!1,m=u,h=Object.entries(a).sort((e,n)=>{let r=e[0].replace(`/*`,``);return n[0].replace(`/*`,``).length-r.length});for(let[r,s]of h){let c=r.replace(`/*`,``);if(RegExp(`^${c.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`)}(?=/|$)`).test(u)){if(d(u,a)&&i.has(u))continue;let r=u.replace(c,``),l,f=(Array.isArray(s)?s:[s])[0];if(f.startsWith(`/`))l=e.join(`/`,o,r),n.VERBOSE===`true`&&console.log(`  ✅ Ruta absoluta: pathDist="${o}", relativePath="${r}", newPath="${l}"`);else{let n=f.replace(`./`,``).replace(`/*`,``),i=o.replace(`./`,``);l=n===i?e.join(`/`,i,r):e.join(`/`,i,n,r)}l=l.replace(/\/\.\//g,`/`).replace(/\\/g,`/`).replace(/\/+/g,`/`),m=l,p=!0;break}}if(p){let e=`${l}${m}${f}`,n=c.replace(/[.*+?^${}()|[\]\\]/g,`\\$&`),r=new RegExp(n,`g`);s=s.replace(r,e)}}return s}export const removehtmlOfTemplateString=async e=>(e=e.replace(/(?:^|[^.])html\s*`/g,e=>(e.charAt(0)===`h`?``:e.charAt(0))+"`"),e=e.replace(/,\s*get\s+html\(\)\s*{\s*return\s*html\s*}/g,``),e);const g=async e=>(e=e.replace(/\/\*[\s\S]*?@preserve[\s\S]*?\*\/|\/\/.*?@preserve.*?(?=\n|$)/g,e=>e.replace(/@preserve/g,``)),e),_=async e=>(e=e.replace(/import\s+{.*}\s+from\s+['"].*code-tag.*['"];/g,``),e);export async function estandarizaCode(e,i){try{let a=await l(i,e);if(a&&a.errors&&a.errors.length>0){n.VERBOSE===`true`&&console.info(`DEBUG - Estructura del error:`,JSON.stringify(a.errors[0],null,2));let s=o(a.errors,e,i);n.VERBOSE===`true`&&r.error(s);let c=a.errors[0];throw Error(c?.message||`Error sin mensaje`)}return e=await replaceAliasImportStatic(i,e),e=await p(e,a?.module.dynamicImports,i),e=await m(e),e=await _(e),n.isProd===`true`&&(e=await g(e)),{code:e,error:null}}catch(e){return{code:``,error:e instanceof Error?e.message:`Unknown error`}}}
+import path from 'node:path';
+import { env } from 'node:process';
+import { logger } from '../servicios/logger.js';
+import { EXCLUDED_MODULES } from '../utils/excluded-modules.js';
+import { getModuleSubPath } from '../utils/module-resolver.js';
+import { analyzeAndFormatMultipleErrors } from './error-reporter.js';
+import { getOptimizedAliasPath, getOptimizedModulePath, } from './module-resolution-optimizer.js';
+import { parser } from './parser.js';
+// Módulos built-in de Node.js que no deben ser resueltos
+const NODE_BUILTIN_MODULES = new Set([
+    'fs',
+    'path',
+    'os',
+    'crypto',
+    'http',
+    'https',
+    'url',
+    'util',
+    'events',
+    'stream',
+    'buffer',
+    'child_process',
+    'cluster',
+    'dgram',
+    'dns',
+    'net',
+    'readline',
+    'repl',
+    'tls',
+    'tty',
+    'vm',
+    'zlib',
+    'assert',
+    'module',
+    'process',
+    'querystring',
+    'string_decoder',
+    'timers',
+    'v8',
+    'worker_threads',
+]);
+/**
+ * Determina si un moduleRequest es un módulo externo que debe ser resuelto
+ * @param moduleRequest - El string del import (ej: 'vue', './local', '/absolute')
+ * @param pathAlias - Objeto con los alias definidos
+ * @returns true si es un módulo externo que debe resolverse
+ */
+function isExternalModule(moduleRequest, pathAlias) {
+    // Descartar rutas relativas y absolutas
+    if (moduleRequest.startsWith('./') ||
+        moduleRequest.startsWith('../') ||
+        moduleRequest.startsWith('/')) {
+        return false;
+    }
+    // Descartar rutas que parecen ser locales (contienen carpetas conocidas del proyecto)
+    const localPaths = [
+        'public/',
+        'src/',
+        'dist/',
+        'components/',
+        'utils/',
+        'assets/',
+        'styles/',
+    ];
+    if (localPaths.some(localPath => moduleRequest.startsWith(localPath))) {
+        return false;
+    } // Descartar módulos built-in de Node.js (incluyendo node: prefix)
+    const cleanModuleName = moduleRequest.replace(/^node:/, '');
+    if (NODE_BUILTIN_MODULES.has(cleanModuleName)) {
+        return false;
+    } // NUEVA LÓGICA: Verificar PRIMERO si es un módulo excluido antes de verificar alias
+    // Esto es importante porque algunos módulos excluidos pueden tener nombres que
+    // coinciden con patrones de alias (como @vue/compiler-sfc con @/*)
+    if (EXCLUDED_MODULES.has(moduleRequest)) {
+        return true;
+    } // Descartar alias conocidos
+    for (const alias of Object.keys(pathAlias)) {
+        const aliasPattern = alias.replace('/*', '');
+        if (moduleRequest.startsWith(aliasPattern)) {
+            return false;
+        }
+    } // Verificar si parece ser un módulo npm (no contiene extensiones de archivo)
+    if (moduleRequest.includes('.js') ||
+        moduleRequest.includes('.ts') ||
+        moduleRequest.includes('.vue') ||
+        moduleRequest.includes('.css') ||
+        moduleRequest.includes('.json')) {
+        return false;
+    }
+    // Si llegamos aquí, es probablemente un módulo externo
+    return true;
+}
+export async function replaceAliasImportStatic(file, code) {
+    if (!env.PATH_ALIAS || !env.PATH_DIST) {
+        return code;
+    }
+    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    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;
+    // Crear un array para procesar transformaciones async
+    const matches = Array.from(resultCode.matchAll(importRegex));
+    for (const match of matches) {
+        const [, moduleRequest] = match;
+        if (!moduleRequest)
+            continue; // Skip if moduleRequest is undefined
+        let newPath = null;
+        let transformed = false; // 1. PRIMERO: Verificar si es un módulo excluido (prioridad máxima)
+        if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
+            try {
+                // Usar el sistema optimizado primero
+                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedPath === null) {
+                    // Si el optimizador retorna null, significa que es un módulo excluido
+                    continue;
+                }
+                if (optimizedPath) {
+                    newPath = optimizedPath;
+                    transformed = true;
+                }
+                else {
+                    // Fallback al sistema anterior
+                    const modulePath = getModuleSubPath(moduleRequest, file);
+                    if (modulePath === null) {
+                        continue;
+                    }
+                    if (modulePath) {
+                        newPath = modulePath;
+                        transformed = true;
+                    }
+                }
+            }
+            catch (error) {
+                if (env.VERBOSE === 'true')
+                    logger.warn(`Error resolviendo módulo ${moduleRequest}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        } // 2. Si no es módulo externo/excluido, verificar si es un alias conocido
+        if (!transformed) {
+            // Usar el sistema optimizado de alias
+            const aliasPath = getOptimizedAliasPath(moduleRequest);
+            if (aliasPath) {
+                let newImportPath = aliasPath;
+                // Transformar extensiones
+                if (newImportPath.endsWith('.ts') ||
+                    newImportPath.endsWith('.vue')) {
+                    newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                }
+                else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                    newImportPath += '.js';
+                }
+                newPath = newImportPath;
+                transformed = true;
+            }
+            else {
+                // Fallback al sistema anterior
+                for (const [alias] of Object.entries(pathAlias)) {
+                    const aliasPattern = alias.replace('/*', '');
+                    if (moduleRequest.startsWith(aliasPattern)) {
+                        // Reemplazar el alias con la ruta del target
+                        const relativePath = moduleRequest.replace(aliasPattern, '');
+                        // Para alias que apuntan a la raíz (como @/* -> /src/*),
+                        // solo usamos PATH_DIST + relativePath
+                        let newImportPath = path.join('/', env.PATH_DIST, relativePath);
+                        // Normalizar la ruta para eliminar ./ extra y separadores de Windows
+                        newImportPath = newImportPath
+                            .replace(/\/\.\//g, '/')
+                            .replace(/\\/g, '/');
+                        if (newImportPath.endsWith('.ts') ||
+                            newImportPath.endsWith('.vue')) {
+                            newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                        }
+                        else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                            newImportPath += '.js';
+                        }
+                        newPath = newImportPath;
+                        transformed = true;
+                        break;
+                    }
+                }
+            }
+        }
+        // 3. Si no es alias ni módulo externo, verificar si es ruta relativa que necesita extensión .js
+        if (!transformed &&
+            (moduleRequest.startsWith('./') || moduleRequest.startsWith('../'))) {
+            let relativePath = moduleRequest;
+            if (relativePath.endsWith('.ts') || relativePath.endsWith('.vue')) {
+                relativePath = relativePath.replace(/\.(ts|vue)$/, '.js');
+                newPath = relativePath;
+                transformed = true;
+            }
+            else if (!/\.(js|mjs|css|json)$/.test(relativePath)) {
+                newPath = relativePath + '.js';
+                transformed = true;
+            }
+        }
+        // 4. Reemplazar solo el path en las comillas, no toda la línea
+        if (transformed && newPath) {
+            // Buscar y reemplazar solo la parte entre comillas
+            const pathRegex = new RegExp(`(['"\`])${moduleRequest.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\1`, 'g');
+            resultCode = resultCode.replace(pathRegex, `$1${newPath}$1`);
+        }
+    }
+    return resultCode;
+}
+export async function replaceAliasImportDynamic(code, _imports, file) {
+    if (!env.PATH_ALIAS || !env.PATH_DIST) {
+        return code;
+    }
+    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    const pathDist = env.PATH_DIST;
+    let resultCode = code;
+    // Regex para imports dinámicos normales con string (solo comillas simples y dobles)
+    const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    // Regex para template literals (solo backticks)
+    const templateLiteralRegex = /import\s*\(\s*`([^`]+)`\s*\)/g;
+    // Manejar imports dinámicos normales con string
+    const dynamicMatches = Array.from(resultCode.matchAll(dynamicImportRegex));
+    for (const match of dynamicMatches) {
+        const [, moduleRequest] = match;
+        if (!moduleRequest)
+            continue; // Skip if moduleRequest is undefined
+        let newPath = null;
+        let transformed = false; // 1. PRIMERO: Verificar si es un módulo excluido (prioridad máxima)
+        if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
+            try {
+                // Usar el sistema optimizado primero
+                const optimizedPath = await getOptimizedModulePath(moduleRequest, file);
+                if (optimizedPath === null) {
+                    // Si el optimizador retorna null, significa que es un módulo excluido
+                    continue;
+                }
+                if (optimizedPath) {
+                    newPath = optimizedPath;
+                    transformed = true;
+                }
+                else {
+                    // Fallback al sistema anterior
+                    const modulePath = getModuleSubPath(moduleRequest, file);
+                    if (modulePath === null) {
+                        continue;
+                    }
+                    if (modulePath) {
+                        newPath = modulePath;
+                        transformed = true;
+                    }
+                }
+            }
+            catch (error) {
+                if (env.VERBOSE === 'true')
+                    logger.warn(`Error resolviendo módulo dinámico ${moduleRequest}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        } // 2. Si no es módulo externo/excluido, verificar si es un alias conocido
+        if (!transformed) {
+            // Usar el sistema optimizado de alias
+            const aliasPath = getOptimizedAliasPath(moduleRequest);
+            if (aliasPath) {
+                let newImportPath = aliasPath;
+                // Transformar extensiones
+                if (newImportPath.endsWith('.ts') ||
+                    newImportPath.endsWith('.vue')) {
+                    newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                }
+                else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                    newImportPath += '.js';
+                }
+                newPath = newImportPath;
+                transformed = true;
+            }
+            else {
+                // Fallback al sistema anterior
+                for (const [alias] of Object.entries(pathAlias)) {
+                    const aliasPattern = alias.replace('/*', '');
+                    if (moduleRequest.startsWith(aliasPattern)) {
+                        // Reemplazar el alias con la ruta del target
+                        const relativePath = moduleRequest.replace(aliasPattern, '');
+                        // Para alias que apuntan a la raíz (como @/* -> /src/*),
+                        // solo usamos PATH_DIST + relativePath
+                        let newImportPath = path.join('/', pathDist, relativePath);
+                        // Normalizar la ruta para eliminar ./ extra y separadores de Windows
+                        newImportPath = newImportPath
+                            .replace(/\/\.\//g, '/')
+                            .replace(/\\/g, '/');
+                        if (newImportPath.endsWith('.ts') ||
+                            newImportPath.endsWith('.vue')) {
+                            newImportPath = newImportPath.replace(/\.(ts|vue)$/, '.js');
+                        }
+                        else if (!/\.(js|mjs|css|json)$/.test(newImportPath)) {
+                            newImportPath += '.js';
+                        }
+                        newPath = newImportPath;
+                        transformed = true;
+                        break;
+                    }
+                }
+            }
+        }
+        // 3. Si no es alias ni módulo externo, verificar si es ruta relativa que necesita extensión .js
+        if (!transformed &&
+            (moduleRequest.startsWith('./') || moduleRequest.startsWith('../'))) {
+            let relativePath = moduleRequest;
+            if (relativePath.endsWith('.ts') || relativePath.endsWith('.vue')) {
+                relativePath = relativePath.replace(/\.(ts|vue)$/, '.js');
+                newPath = relativePath;
+                transformed = true;
+            }
+            else if (!/\.(js|mjs|css|json)$/.test(relativePath)) {
+                newPath = relativePath + '.js';
+                transformed = true;
+            }
+        }
+        // 4. Reemplazar solo el path en las comillas, no toda la expresión
+        if (transformed && newPath) {
+            // Buscar y reemplazar solo la parte entre comillas en import()
+            const pathRegex = new RegExp(`import\\s*\\(\\s*(['"])${moduleRequest.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\1\\s*\\)`, 'g');
+            resultCode = resultCode.replace(pathRegex, `import($1${newPath}$1)`);
+        }
+    }
+    // Manejar template literals - versión mejorada
+    resultCode = resultCode.replace(templateLiteralRegex, (match, moduleRequest) => {
+        let transformed = false;
+        let result = match;
+        // 1. PRIMERO: Verificar si es un módulo excluido (prioridad máxima)
+        if (!transformed && isExternalModule(moduleRequest, pathAlias)) {
+            try {
+                const modulePath = getModuleSubPath(moduleRequest, file);
+                if (modulePath === null) {
+                    // Si getModuleSubPath retorna null, significa que es un módulo excluido
+                    // No transformar y retornar el match original
+                    return match;
+                }
+                if (modulePath) {
+                    result = match.replace(moduleRequest, modulePath);
+                    transformed = true;
+                }
+            }
+            catch (error) {
+                if (env.VERBOSE === 'true')
+                    logger.warn(`Error resolviendo módulo template literal ${moduleRequest}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // 2. Verificar aliases en template literals
+        if (!transformed) {
+            for (const [alias] of Object.entries(pathAlias)) {
+                const aliasPattern = alias.replace('/*', '');
+                if (moduleRequest.includes(aliasPattern)) {
+                    const relativePath = moduleRequest.replace(aliasPattern, '');
+                    // Para alias que apuntan a la raíz (como @/* -> /src/*),
+                    // solo usamos PATH_DIST + relativePath
+                    let newModuleRequest = path.join('/', pathDist, relativePath);
+                    // Normalizar la ruta para eliminar ./ extra y barras duplicadas
+                    newModuleRequest = newModuleRequest
+                        .replace(/\/\.\//g, '/')
+                        .replace(/\/+/g, '/')
+                        .replace(/\\/g, '/'); // Normalizar separadores de Windows a Unix
+                    // Transformar extensiones .ts y .vue a .js en template literals
+                    newModuleRequest = newModuleRequest
+                        .replace(/\.ts(\b|`|\$)/g, '.js$1')
+                        .replace(/\.vue(\b|`|\$)/g, '.js$1');
+                    result = match.replace(moduleRequest, newModuleRequest);
+                    transformed = true;
+                    break;
+                }
+            }
+        }
+        // 3. Si no es alias ni módulo externo, verificar si necesita transformación de extensión para rutas relativas
+        if (!transformed) {
+            // Para template literals que contienen rutas relativas, solo transformar extensiones
+            let newModuleRequest = moduleRequest;
+            if (moduleRequest.includes('./') ||
+                moduleRequest.includes('../')) {
+                // Transformar extensiones .ts y .vue a .js en template literals relativos
+                newModuleRequest = moduleRequest
+                    .replace(/\.ts(\b|`)/g, '.js$1')
+                    .replace(/\.vue(\b|`)/g, '.js$1');
+                if (newModuleRequest !== moduleRequest) {
+                    result = match.replace(moduleRequest, newModuleRequest);
+                }
+            }
+        }
+        return result;
+    });
+    return resultCode;
+}
+/**
+ * Reemplaza alias en strings del código JavaScript (no solo en imports)
+ * Maneja casos como: link.href = 'P@/vendor/sweetalert2/sweetalert2.dark.min.css';
+ * @param code - El código JavaScript a transformar
+ * @returns El código con los alias reemplazados en strings
+ */
+async function replaceAliasInStrings(code) {
+    if (!env.PATH_ALIAS || !env.PATH_DIST) {
+        return code;
+    }
+    const pathAlias = JSON.parse(env.PATH_ALIAS);
+    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
+    const stringRegex = /(['"`])([^'"`]+)(['"`])/g;
+    // Crear un array para procesar todas las coincidencias
+    const matches = Array.from(resultCode.matchAll(stringRegex));
+    for (const match of matches) {
+        const [fullMatch, openQuote, stringContent, closeQuote] = match;
+        // Verificar que las comillas de apertura y cierre coincidan
+        if (openQuote !== closeQuote || !stringContent)
+            continue; // Verificar si el string contiene algún alias
+        let transformed = false;
+        let newStringContent = stringContent;
+        // Ordenar alias por longitud (más largos primero) para priorizar alias más específicos
+        const sortedAliases = Object.entries(pathAlias).sort((a, b) => {
+            const aliasA = a[0].replace('/*', '');
+            const aliasB = b[0].replace('/*', '');
+            return aliasB.length - aliasA.length;
+        });
+        for (const [alias, target] of sortedAliases) {
+            const aliasPattern = alias.replace('/*', '');
+            // Verificar coincidencia exacta del alias seguido de '/' o al final del string
+            const aliasRegex = new RegExp(`^${aliasPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=/|$)`);
+            if (aliasRegex.test(stringContent)) {
+                // IMPORTANTE: Verificar si es un módulo excluido antes de transformar
+                if (isExternalModule(stringContent, pathAlias)) {
+                    // Para strings que parecen ser módulos externos, verificar si están excluidos
+                    if (EXCLUDED_MODULES.has(stringContent)) {
+                        // Es un módulo excluido, no transformar
+                        continue;
+                    }
+                }
+                // Reemplazar el alias con la ruta del target
+                const relativePath = stringContent.replace(aliasPattern, '');
+                // Construir la nueva ruta basada en la configuración del target
+                let newPath;
+                // El target puede ser un array de strings o un string
+                const targetArray = Array.isArray(target) ? target : [target];
+                const targetPath = targetArray[0];
+                if (targetPath.startsWith('/')) {
+                    // Si el target empieza con /, es una ruta absoluta desde la raíz del proyecto
+                    // Para targets como "/src/*", solo usamos PATH_DIST + relativePath
+                    // sin incluir el directorio del target en la ruta final
+                    newPath = path.join('/', pathDist, relativePath);
+                    if (env.VERBOSE === 'true') {
+                        console.log(`  ✅ Ruta absoluta: pathDist="${pathDist}", relativePath="${relativePath}", newPath="${newPath}"`);
+                    }
+                }
+                else {
+                    // Si es una ruta relativa, verificar si ya apunta al directorio de distribución
+                    const cleanTarget = targetPath
+                        .replace('./', '')
+                        .replace('/*', '');
+                    const normalizedPathDist = pathDist.replace('./', '');
+                    if (cleanTarget === normalizedPathDist) {
+                        // Si el target es el mismo que PATH_DIST, no duplicar
+                        newPath = path.join('/', normalizedPathDist, relativePath);
+                    }
+                    else {
+                        // Si es diferente, usar PATH_DIST como base
+                        newPath = path.join('/', normalizedPathDist, cleanTarget, relativePath);
+                    }
+                }
+                // Normalizar la ruta para eliminar ./ extra y separadores de Windows
+                newPath = newPath
+                    .replace(/\/\.\//g, '/')
+                    .replace(/\\/g, '/')
+                    .replace(/\/+/g, '/');
+                // Para archivos estáticos (CSS, JS, imágenes, etc.), mantener la extensión original
+                // No agregar .js automáticamente como hacemos con imports
+                newStringContent = newPath;
+                transformed = true;
+                break;
+            }
+        } // Si se transformó, reemplazar en el código
+        if (transformed) {
+            const newFullMatch = `${openQuote}${newStringContent}${closeQuote}`;
+            // Usar una expresión regular más específica para evitar reemplazos accidentales
+            const escapedOriginal = fullMatch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const specificRegex = new RegExp(escapedOriginal, 'g');
+            resultCode = resultCode.replace(specificRegex, newFullMatch);
+        }
+    }
+    return resultCode;
+}
+/**
+ * Elimina la etiqueta "html" de una cadena de plantilla.
+ * @param {string} data - La cadena de plantilla de la cual eliminar la etiqueta "html".
+ * @returns {Promise<string>} - La cadena de plantilla modificada sin la etiqueta "html".
+ */
+const removehtmlOfTemplateString = async (data) => {
+    // Regex más específico que busca la etiqueta html seguida de un template literal
+    // Debe estar al inicio de línea o después de espacios/operadores, no después de punto
+    const htmlRegExp = /(?:^|[^.])html\s*`/g;
+    data = data.replace(htmlRegExp, match => {
+        // Preservar el carácter que no es punto antes de html
+        const beforeHtml = match.charAt(0) !== 'h' ? match.charAt(0) : '';
+        return beforeHtml + '`';
+    });
+    //remove ""
+    const htmlGetterRegExp = /,\s*get\s+html\(\)\s*{\s*return\s*html\s*}/g;
+    data = data.replace(htmlGetterRegExp, '');
+    return data;
+};
+/**
+ * Elimina los comentarios con la etiqueta @preserve de la cadena de datos proporcionada.
+ * @param {string} data - La cadena de entrada que contiene el código JavaScript.
+ * @returns {Promise<string>} - Una promesa que se resuelve con la cadena modificada sin los comentarios @preserve.
+ */
+const removePreserverComent = async (data) => {
+    const preserverRegExp = /\/\*[\s\S]*?@preserve[\s\S]*?\*\/|\/\/.*?@preserve.*?(?=\n|$)/g;
+    data = data.replace(preserverRegExp, (match) => match.replace(/@preserve/g, ''));
+    return data;
+};
+/**
+ * Elimina la declaración de importación para 'code-tag' de la cadena de datos proporcionada.
+ * @param {string} data - La cadena de entrada que contiene el código JavaScript.
+ * @returns {Promise<string>} - Una promesa que se resuelve con la cadena modificada sin la importación de 'code-tag'.
+ */
+const removeCodeTagImport = async (data) => {
+    // remove import if exist code-tag
+    const codeTagRegExp = /import\s+{.*}\s+from\s+['"].*code-tag.*['"];/g;
+    data = data.replace(codeTagRegExp, '');
+    return data;
+};
+export async function estandarizaCode(code, file) {
+    try {
+        const ast = await parser(file, code);
+        if (ast && ast.errors && ast.errors.length > 0) {
+            // Debug: mostrar la estructura del error para entender mejor qué información tenemos
+            if (env.VERBOSE === 'true') {
+                console.info('DEBUG - Estructura del error:', JSON.stringify(ast.errors[0], null, 2));
+            }
+            // Usar el nuevo sistema de reporte de errores
+            const detailedErrorReport = analyzeAndFormatMultipleErrors(ast.errors, code, file);
+            if (env.VERBOSE === 'true') {
+                logger.error(detailedErrorReport);
+            }
+            // También mantener el mensaje simple para el sistema existente
+            const firstError = ast.errors[0];
+            throw new Error(firstError?.message || 'Error sin mensaje');
+        }
+        code = await replaceAliasImportStatic(file, code);
+        code = await replaceAliasImportDynamic(code, ast?.module.dynamicImports, file);
+        code = await replaceAliasInStrings(code);
+        code = await removehtmlOfTemplateString(code);
+        code = await removeCodeTagImport(code);
+        if (env.isProd === 'true') {
+            code = await removePreserverComent(code);
+        }
+        return { code, error: null };
+    }
+    catch (error) {
+        return {
+            code: '',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+//# sourceMappingURL=transforms.js.map