raizcode-ofc 1.10.0 → 1.10.2

package/compilador.js

@@ -1,299 +1,727 @@
 #!/usr/bin/env node
+'use strict';
 
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const http = require('http');
-const { execSync, exec } = require('child_process');
+const Module = require('module');
+const { spawn } = require('child_process');
 
+const VERSAO_INTERNA = '1.10.1';
 const args = process.argv.slice(2);
+const flags = new Set(args.filter((arg) => arg.startsWith('--')));
+const posicionais = args.filter((arg) => !arg.startsWith('--'));
 const arquivoOuCmd = args[0];
 
-// ─────────────────────────────────────────
-// SETUP DO VSCODE
-// ─────────────────────────────────────────
-if (arquivoOuCmd === '--setup') {
-    const extDir = path.join(os.homedir(), '.vscode', 'extensions', 'raizcode-extension');
+class ErroRaizcode extends Error {
+    constructor(mensagem, arquivo, numeroLinha, codigoLinha = '') {
+        super(mensagem);
+        this.name = 'ErroRaizcode';
+        this.arquivo = arquivo;
+        this.numeroLinha = numeroLinha;
+        this.codigoLinha = codigoLinha;
+    }
+}
+
+function obterVersao() {
+    return VERSAO_INTERNA;
+}
+
+function estaNoTermux() {
+    return Boolean(
+        process.env.TERMUX_VERSION ||
+        process.env.PREFIX?.includes('com.termux') ||
+        fs.existsSync('/data/data/com.termux')
+    );
+}
+
+function copiarRecursivo(origem, destino) {
+    if (typeof fs.cpSync === 'function') {
+        fs.cpSync(origem, destino, { recursive: true });
+        return;
+    }
+
+    const status = fs.statSync(origem);
+    if (status.isDirectory()) {
+        fs.mkdirSync(destino, { recursive: true });
+        for (const item of fs.readdirSync(origem)) {
+            copiarRecursivo(path.join(origem, item), path.join(destino, item));
+        }
+        return;
+    }
+
+    fs.copyFileSync(origem, destino);
+}
+
+function encontrarPastaExtensoes() {
+    const home = os.homedir();
+    const candidatos = [
+        process.env.VSCODE_EXTENSIONS,
+        path.join(home, '.local', 'share', 'code-server', 'extensions'),
+        path.join(home, '.vscode-server', 'extensions'),
+        path.join(home, '.vscode', 'extensions')
+    ].filter(Boolean);
+
+    const existente = candidatos.find((pasta) => fs.existsSync(path.dirname(pasta)) || fs.existsSync(pasta));
+    return existente || path.join(home, '.vscode', 'extensions');
+}
+
+function instalarExtensaoVSCode() {
+    const extDir = path.join(encontrarPastaExtensoes(), `riquefla.raizcode-${obterVersao()}`);
+
     try {
-        if (!fs.existsSync(extDir)) fs.mkdirSync(extDir, { recursive: true });
-
-        // Copia arquivos necessários
-        ['syntaxes', 'icons'].forEach(pasta => {
-            const src = path.join(__dirname, pasta);
-            const dest = path.join(extDir, pasta);
-            if (fs.existsSync(src)) {
-                fs.cpSync(src, dest, { recursive: true });
-            }
-        });
+        fs.mkdirSync(extDir, { recursive: true });
+
+        for (const pasta of ['syntaxes', 'icons']) {
+            const origem = path.join(__dirname, pasta);
+            const destino = path.join(extDir, pasta);
+            if (fs.existsSync(origem)) copiarRecursivo(origem, destino);
+        }
+
+        const gramaticaRC = './syntaxes/raizcode.tmLanguage.json';
+        const gramaticaRCX = './syntaxes/raizcode-estrutura.tmLanguage.json';
+        const gramaticaRCC = './syntaxes/raizcode-estilo.tmLanguage.json';
+
+        const grammars = [];
+        if (fs.existsSync(path.join(extDir, gramaticaRC))) {
+            grammars.push({ language: 'raizcode', scopeName: 'source.rc', path: gramaticaRC });
+        }
+        if (fs.existsSync(path.join(extDir, gramaticaRCX))) {
+            grammars.push({ language: 'raizcode-estrutura', scopeName: 'source.rcx', path: gramaticaRCX });
+        }
+        if (fs.existsSync(path.join(extDir, gramaticaRCC))) {
+            grammars.push({ language: 'raizcode-estilo', scopeName: 'source.rcc', path: gramaticaRCC });
+        }
 
-        // Gera o package.json da extensão VSCode com suporte a Temas de Ícones
         const pkgExtensao = {
-            name: "raizcode-extension",
-            displayName: "Raizcode",
-            version: "1.9.0",
-            publisher: "riquefla",
-            engines: { vscode: "^1.60.0" },
+            name: 'raizcode-extension',
+            displayName: 'Raizcode',
+            description: 'Suporte aos arquivos .rc, .rcx e .rcc',
+            version: obterVersao(),
+            publisher: 'riquefla',
+            engines: { vscode: '^1.60.0' },
+            categories: ['Programming Languages'],
             contributes: {
                 languages: [
-                    {
-                        id: "raizcode",
-                        aliases: ["Raizcode", "rc"],
-                        extensions: [".rc"]
-                    },
-                    {
-                        id: "raizcode-estrutura",
-                        aliases: ["Raizcode Estrutura", "rcx"],
-                        extensions: [".rcx"]
-                    },
-                    {
-                        id: "raizcode-estilo",
-                        aliases: ["Raizcode Estilo", "rcc"],
-                        extensions: [".rcc"]
-                    }
-                ],
-                grammars: [
-                    {
-                        language: "raizcode",
-                        scopeName: "source.rc",
-                        path: "./syntaxes/raizcode.tmLanguage.json"
-                    }
+                    { id: 'raizcode', aliases: ['Raizcode', 'rc'], extensions: ['.rc'] },
+                    { id: 'raizcode-estrutura', aliases: ['Raizcode Estrutura', 'rcx'], extensions: ['.rcx'] },
+                    { id: 'raizcode-estilo', aliases: ['Raizcode Estilo', 'rcc'], extensions: ['.rcc'] }
                 ],
-                // Ativa o suporte oficial aos seus ícones no VS Code
-                iconThemes: [
-                    {
-                        id: "raizcode-icons",
-                        label: "Raizcode Icons",
-                        path: "./icons/raizcode-icon-theme.json"
-                    }
-                ]
+                grammars,
+                iconThemes: fs.existsSync(path.join(extDir, 'icons', 'raizcode-icon-theme.json'))
+                    ? [{ id: 'raizcode-icons', label: 'Raizcode Icons', path: './icons/raizcode-icon-theme.json' }]
+                    : []
             }
         };
 
-        fs.writeFileSync(
-            path.join(extDir, 'package.json'),
-            JSON.stringify(pkgExtensao, null, 2)
-        );
+        fs.writeFileSync(path.join(extDir, 'package.json'), JSON.stringify(pkgExtensao, null, 2));
 
-        console.log("✅ Extensão Raizcode instalada! Reinicie o VS Code.");
-        console.log("💡 Lembre-se de selecionar 'Raizcode Icons' em: Arquivo > Preferências > Tema de Ícone de Arquivo");
-    } catch (e) {
-        console.error("❌ Erro no setup:", e.message);
+        console.log('✅ Extensão Raizcode instalada.');
+        console.log(`📁 Local: ${extDir}`);
+        if (estaNoTermux()) {
+            console.log('💡 No Termux, use code-server ou um editor compatível com extensões do VS Code.');
+        } else {
+            console.log('💡 Reinicie o VS Code e selecione o tema "Raizcode Icons", caso ele esteja disponível.');
+        }
+    } catch (erro) {
+        console.error(`❌ Não foi possível instalar a extensão: ${erro.message}`);
+        process.exitCode = 1;
     }
-    process.exit();
 }
 
-// ─────────────────────────────────────────
-// UTILITÁRIOS
-// ─────────────────────────────────────────
+function mostrarAjuda() {
+    console.log(`🌱 Raizcode v${obterVersao()} — A linguagem brasileira\n`);
+    console.log('Uso:');
+    console.log('  raizcode arquivo.rc');
+    console.log('  raizcode arquivo.rc 3000');
+    console.log('  raizcode arquivo.rc --no-open');
+    console.log('  raizcode --setup');
+    console.log('  raizcode --version');
+    console.log('  raizcode --help');
+    console.log('\nOpções:');
+    console.log('  --no-open       Não abre o navegador automaticamente.');
+    console.log('  --permitir-js   Permite JavaScript puro sem o prefixo "js".');
+    console.log('  --estrito       Recusa comandos desconhecidos.');
+}
 
-// Abre o navegador de forma correta em qualquer sistema
 function abrirNavegador(url) {
     const plataforma = os.platform();
-    if (plataforma === 'win32') exec(`start ${url}`);
-    else if (plataforma === 'darwin') exec(`open ${url}`);
-    else if (process.env.TERM === 'xterm-termux' || fs.existsSync('/data/data/com.termux')) exec(`termux-open ${url}`);
-    else exec(`xdg-open ${url}`);
+    let comandos;
+
+    if (plataforma === 'win32') {
+        comandos = [['cmd', ['/c', 'start', '', url]]];
+    } else if (plataforma === 'darwin') {
+        comandos = [['open', [url]]];
+    } else if (estaNoTermux()) {
+        comandos = [
+            ['termux-open-url', [url]],
+            ['termux-open', [url]]
+        ];
+    } else {
+        comandos = [['xdg-open', [url]]];
+    }
+
+    const tentar = (indice) => {
+        if (indice >= comandos.length) {
+            console.log(`ℹ️ Abra manualmente no navegador: ${url}`);
+            return;
+        }
+
+        const [comando, argumentos] = comandos[indice];
+        let iniciou = false;
+
+        try {
+            const processo = spawn(comando, argumentos, {
+                detached: true,
+                stdio: 'ignore'
+            });
+
+            processo.once('spawn', () => {
+                iniciou = true;
+                processo.unref();
+            });
+
+            processo.once('error', () => {
+                if (!iniciou) tentar(indice + 1);
+            });
+        } catch (_) {
+            tentar(indice + 1);
+        }
+    };
+
+    tentar(0);
+}
+
+function criarErro(mensagem, arquivo, numeroLinha, codigoLinha = '') {
+    throw new ErroRaizcode(mensagem, arquivo, numeroLinha, codigoLinha);
 }
 
-// Reporta erros com número de linha para o usuário
-function erroDeCompilacao(mensagem, numeroLinha) {
-    console.error(`\n❌ Erro na linha ${numeroLinha}: ${mensagem}`);
-    console.error(`   Verifique seu código .rc e tente novamente.\n`);
-    process.exit(1);
+function escaparHTML(valor) {
+    return String(valor)
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
 }
 
-// ─────────────────────────────────────────
-// TRADUTORES DE ESTRUTURA (RCX) E ESTILO (RCC)
-// ─────────────────────────────────────────
+function escaparAtributo(valor) {
+    return escaparHTML(valor).replace(/`/g, '&#96;');
+}
 
-function traduzirEstrutura(conteudo) {
-    if (!conteudo) return "";
+function substituirForaDeStrings(texto, transformador) {
+    let resultado = '';
+    let trecho = '';
+    let aspas = null;
+    let escapado = false;
 
-    return conteudo.split('\n').map((linha, idx) => {
-        let t = linha.trim();
-        if (!t || t.startsWith('//')) return "";
+    const descarregar = () => {
+        if (!trecho) return;
+        resultado += aspas ? trecho : transformador(trecho);
+        trecho = '';
+    };
 
-        // Captura string entre aspas de forma segura
-        const pegarTexto = (cmd) => {
-            const match = t.match(new RegExp(`^${cmd}\\s+"(.*)"`));
-            return match ? match[1] : t.replace(cmd + ' ', '').replace(/"/g, '');
-        };
+    for (const caractere of texto) {
+        trecho += caractere;
+
+        if (escapado) {
+            escapado = false;
+            continue;
+        }
+
+        if (caractere === '\\') {
+            escapado = true;
+            continue;
+        }
+
+        if (aspas) {
+            if (caractere === aspas) {
+                descarregar();
+                aspas = null;
+            }
+            continue;
+        }
 
-        if (t.startsWith('titulo '))   return `<h1>${pegarTexto('titulo')}</h1>`;
-        if (t.startsWith('subtitulo ')) return `<h2>${pegarTexto('subtitulo')}</h2>`;
-        if (t.startsWith('texto '))    return `<p>${pegarTexto('texto')}</p>`;
-        if (t.startsWith('link ')) {
-            // link "Clique aqui" url "https://..."
-            const m = t.match(/^link\s+"(.+?)"\s+url\s+"(.+?)"/);
-            if (m) return `<a href="${m[2]}" target="_blank">${m[1]}</a>`;
-        }
-        if (t.startsWith('imagem '))   return `<img src="${pegarTexto('imagem')}" alt="imagem" style="max-width:100%;">`;
-        if (t.startsWith('botao ')) {
-            const m = t.match(/^botao\s+"(.+?)"\s+id\s+"(.+?)"/);
-            if (m) return `<button id="${m[2]}">${m[1]}</button>`;
-            return `<button>${pegarTexto('botao')}</button>`;
-        }
-        if (t.startsWith('entrada ')) {
-            const m = t.match(/^entrada\s+id\s+"(.+?)"\s+dica\s+"(.+?)"/);
-            if (m) return `<input id="${m[1]}" placeholder="${m[2]}">`;
-            return `<input placeholder="${pegarTexto('entrada')}">`;
-        }
-        if (t.startsWith('caixa '))    return `<div class="${pegarTexto('caixa')}">`;
-        if (t === 'fim')               return `</div>`;
-
-        return ``;
-    }).join('\n');
+        if (caractere === '"' || caractere === "'" || caractere === '`') {
+            trecho = trecho.slice(0, -1);
+            descarregar();
+            aspas = caractere;
+            trecho = caractere;
+        }
+    }
+
+    descarregar();
+    return resultado;
+}
+
+function traduzirExpressao(expressao) {
+    return substituirForaDeStrings(expressao, (trecho) => trecho
+        .replace(/\bverdadeiro\b/g, 'true')
+        .replace(/\bfalso\b/g, 'false')
+        .replace(/\bnulo\b/g, 'null')
+        .replace(/\bnao\b/g, '!')
+        .replace(/\be\b/g, '&&')
+        .replace(/\bou\b/g, '||'));
+}
+
+function extrairTextoEntreAspas(linha, comando, arquivo, numeroLinha) {
+    const padrao = new RegExp(`^${comando}\\s+"([\\s\\S]*)"$`);
+    const resultado = linha.match(padrao);
+    if (!resultado) {
+        criarErro(`Sintaxe inválida. Use: ${comando} "texto"`, arquivo, numeroLinha, linha);
+    }
+    return resultado[1];
+}
+
+function traduzirEstrutura(conteudo, arquivo) {
+    if (!conteudo) return '';
+
+    const linhas = conteudo.replace(/^\uFEFF/, '').split(/\r\n|\n|\r/);
+    const pilha = [];
+    const saida = [];
+
+    linhas.forEach((linhaOriginal, indice) => {
+        const numeroLinha = indice + 1;
+        const linha = linhaOriginal.trim();
+
+        if (!linha || linha.startsWith('//')) {
+            saida.push('');
+            return;
+        }
+
+        if (linha.startsWith('titulo ')) {
+            saida.push(`<h1>${escaparHTML(extrairTextoEntreAspas(linha, 'titulo', arquivo, numeroLinha))}</h1>`);
+            return;
+        }
+
+        if (linha.startsWith('subtitulo ')) {
+            saida.push(`<h2>${escaparHTML(extrairTextoEntreAspas(linha, 'subtitulo', arquivo, numeroLinha))}</h2>`);
+            return;
+        }
+
+        if (linha.startsWith('texto ')) {
+            saida.push(`<p>${escaparHTML(extrairTextoEntreAspas(linha, 'texto', arquivo, numeroLinha))}</p>`);
+            return;
+        }
+
+        if (linha.startsWith('link ')) {
+            const resultado = linha.match(/^link\s+"(.+?)"\s+url\s+"(.+?)"$/);
+            if (!resultado) criarErro('Use: link "Texto" url "https://exemplo.com"', arquivo, numeroLinha, linhaOriginal);
+            saida.push(`<a href="${escaparAtributo(resultado[2])}" target="_blank" rel="noopener noreferrer">${escaparHTML(resultado[1])}</a>`);
+            return;
+        }
+
+        if (linha.startsWith('imagem ')) {
+            const endereco = extrairTextoEntreAspas(linha, 'imagem', arquivo, numeroLinha);
+            saida.push(`<img src="${escaparAtributo(endereco)}" alt="imagem" style="max-width:100%;">`);
+            return;
+        }
+
+        if (linha.startsWith('botao ')) {
+            const comId = linha.match(/^botao\s+"(.+?)"\s+id\s+"([A-Za-z][\w:-]*)"$/);
+            const semId = linha.match(/^botao\s+"(.+?)"$/);
+            if (comId) {
+                saida.push(`<button id="${escaparAtributo(comId[2])}">${escaparHTML(comId[1])}</button>`);
+                return;
+            }
+            if (semId) {
+                saida.push(`<button>${escaparHTML(semId[1])}</button>`);
+                return;
+            }
+            criarErro('Use: botao "Texto" id "meuBotao"', arquivo, numeroLinha, linhaOriginal);
+        }
+
+        if (linha.startsWith('entrada ')) {
+            const resultado = linha.match(/^entrada\s+id\s+"([A-Za-z][\w:-]*)"\s+dica\s+"(.+?)"$/);
+            if (!resultado) criarErro('Use: entrada id "nome" dica "Digite seu nome"', arquivo, numeroLinha, linhaOriginal);
+            saida.push(`<input id="${escaparAtributo(resultado[1])}" placeholder="${escaparAtributo(resultado[2])}">`);
+            return;
+        }
+
+        if (linha.startsWith('caixa ')) {
+            const classe = extrairTextoEntreAspas(linha, 'caixa', arquivo, numeroLinha);
+            pilha.push({ tipo: 'caixa', linha: numeroLinha });
+            saida.push(`<div class="${escaparAtributo(classe)}">`);
+            return;
+        }
+
+        if (linha === 'fim') {
+            if (pilha.length === 0) criarErro('Existe um "fim" sem uma caixa aberta.', arquivo, numeroLinha, linhaOriginal);
+            pilha.pop();
+            saida.push('</div>');
+            return;
+        }
+
+        criarErro(`Comando de estrutura desconhecido: "${linha}"`, arquivo, numeroLinha, linhaOriginal);
+    });
+
+    if (pilha.length > 0) {
+        const aberto = pilha[pilha.length - 1];
+        criarErro(`A caixa aberta na linha ${aberto.linha} não foi fechada com "fim".`, arquivo, linhas.length, linhas[linhas.length - 1] || '');
+    }
+
+    return saida.join('\n');
+}
+
+const PROPRIEDADES_RCC = {
+    'fundo': 'background',
+    'cor-texto': 'color',
+    'tamanho-texto': 'font-size',
+    'familia-fonte': 'font-family',
+    'peso-fonte': 'font-weight',
+    'margem': 'margin',
+    'margem-interna': 'padding',
+    'borda': 'border',
+    'arredondado': 'border-radius',
+    'largura': 'width',
+    'altura': 'height',
+    'largura-maxima': 'max-width',
+    'altura-minima': 'min-height',
+    'exibir': 'display',
+    'alinhar-itens': 'align-items',
+    'justificar': 'justify-content',
+    'direcao': 'flex-direction',
+    'espaco': 'gap',
+    'sombra': 'box-shadow',
+    'cursor': 'cursor',
+    'opacidade': 'opacity',
+    'transicao': 'transition',
+    'posicao': 'position',
+    'topo': 'top',
+    'direita': 'right',
+    'baixo': 'bottom',
+    'esquerda': 'left'
+};
+
+const VALORES_RCC = {
+    'preto': '#000000',
+    'branco': '#ffffff',
+    'cinza': '#808080',
+    'vermelho': '#ff0000',
+    'verde': '#00a650',
+    'azul': '#0066ff',
+    'transparente': 'transparent',
+    'verde-neon': '#00ff88',
+    'amarelo-neon': '#ffff00',
+    'azul-neon': '#00cfff',
+    'vermelho-neon': '#ff4444'
+};
+
+function traduzirSeletor(texto, arquivo, numeroLinha, linhaOriginal) {
+    const seletor = texto.trim();
+    if (!seletor) criarErro('Informe um seletor depois de "estilo".', arquivo, numeroLinha, linhaOriginal);
+
+    if (seletor === 'corpo') return 'body';
+    if (seletor === 'raiz') return '#raiz-app';
+    if (seletor.startsWith('classe ')) return `.${seletor.slice(7).trim()}`;
+    if (seletor.startsWith('id ')) return `#${seletor.slice(3).trim()}`;
+    if (seletor.startsWith('elemento ')) return seletor.slice(9).trim();
+    if (/^[.#[:*]/.test(seletor)) return seletor;
+    return `.${seletor}`;
+}
+
+function traduzirValorCSS(valor) {
+    let resultado = valor.trim();
+    for (const [portugues, css] of Object.entries(VALORES_RCC)) {
+        resultado = resultado.replace(new RegExp(`\\b${portugues}\\b`, 'g'), css);
+    }
+    return resultado;
 }
 
-function traduzirEstilo(conteudo) {
-    if (!conteudo) return "";
-    return conteudo
-        .replace(/fundo:/g, 'background:')
-        .replace(/cor-texto:/g, 'color:')
-        .replace(/tamanho-texto:/g, 'font-size:')
-        .replace(/margem:/g, 'margin:')
-        .replace(/borda:/g, 'border:')
-        .replace(/arredondado:/g, 'border-radius:')
-        .replace(/verde-neon/g, '#00ff88')
-        .replace(/amarelo-neon/g, '#ffff00')
-        .replace(/azul-neon/g, '#00cfff')
-        .replace(/vermelho-neon/g, '#ff4444')
-        .replace(/ao-passar-mouse:/g, '&:hover')
-        .replace(/estilo\s+/g, '.')
-        .replace(/\bfim\b/g, '}');
+function traduzirEstilo(conteudo, arquivo) {
+    if (!conteudo) return '';
+
+    const linhas = conteudo.replace(/^\uFEFF/, '').split(/\r\n|\n|\r/);
+    const pilha = [];
+    const saida = [];
+
+    linhas.forEach((linhaOriginal, indice) => {
+        const numeroLinha = indice + 1;
+        const linha = linhaOriginal.trim();
+
+        if (!linha || linha.startsWith('//')) {
+            saida.push('');
+            return;
+        }
+
+        if (linha.startsWith('estilo ')) {
+            const seletor = traduzirSeletor(linha.slice(7), arquivo, numeroLinha, linhaOriginal);
+            pilha.push({ seletor, linha: numeroLinha });
+            saida.push(`${seletor} {`);
+            return;
+        }
+
+        if (linha.startsWith('ao-passar-mouse ')) {
+            const seletor = traduzirSeletor(linha.slice('ao-passar-mouse '.length), arquivo, numeroLinha, linhaOriginal);
+            pilha.push({ seletor: `${seletor}:hover`, linha: numeroLinha });
+            saida.push(`${seletor}:hover {`);
+            return;
+        }
+
+        if (linha === 'fim') {
+            if (pilha.length === 0) criarErro('Existe um "fim" sem um estilo aberto.', arquivo, numeroLinha, linhaOriginal);
+            pilha.pop();
+            saida.push('}');
+            return;
+        }
+
+        if (pilha.length === 0) {
+            criarErro('Propriedade encontrada fora de um bloco "estilo".', arquivo, numeroLinha, linhaOriginal);
+        }
+
+        const propriedade = linha.match(/^([\w-]+)\s*:\s*(.+?);?$/);
+        if (!propriedade) criarErro('Use o formato: propriedade: valor', arquivo, numeroLinha, linhaOriginal);
+
+        const nome = PROPRIEDADES_RCC[propriedade[1]] || propriedade[1];
+        const valor = traduzirValorCSS(propriedade[2].replace(/;$/, ''));
+        saida.push(`    ${nome}: ${valor};`);
+    });
+
+    if (pilha.length > 0) {
+        const aberto = pilha[pilha.length - 1];
+        criarErro(`O estilo aberto na linha ${aberto.linha} não foi fechado com "fim".`, arquivo, linhas.length, linhas[linhas.length - 1] || '');
+    }
+
+    return saida.join('\n');
 }
 
-// ─────────────────────────────────────────
-// TRADUTOR PRINCIPAL (RC → JS)
-// ─────────────────────────────────────────
+function validarBlocos(linhas, arquivo) {
+    const pilha = [];
+
+    linhas.forEach((linhaOriginal, indice) => {
+        const numeroLinha = indice + 1;
+        const linha = linhaOriginal.trim();
+        if (!linha || linha.startsWith('//')) return;
+
+        let tipo = null;
+        if (linha.startsWith('se ')) tipo = 'se';
+        else if (linha.startsWith('enquanto ')) tipo = 'enquanto';
+        else if (linha.startsWith('funcao ')) tipo = 'funcao';
+        else if (linha.startsWith('repetir ')) tipo = 'repetir';
+        else if (linha.startsWith('para cada ')) tipo = 'para';
+        else if (linha.startsWith('ao_clicar ')) tipo = 'evento';
+
+        if (tipo) {
+            pilha.push({ tipo, linha: numeroLinha });
+            return;
+        }
+
+        if (linha === 'senao' || linha.startsWith('senaose ')) {
+            const atual = pilha[pilha.length - 1];
+            if (!atual || atual.tipo !== 'se') {
+                criarErro(`"${linha.split(' ')[0]}" só pode ser usado dentro de um bloco "se".`, arquivo, numeroLinha, linhaOriginal);
+            }
+            return;
+        }
+
+        if (linha === 'fim') {
+            if (pilha.length === 0) criarErro('Existe um "fim" sem bloco aberto.', arquivo, numeroLinha, linhaOriginal);
+            pilha.pop();
+        }
+    });
+
+    if (pilha.length > 0) {
+        const aberto = pilha[pilha.length - 1];
+        criarErro(`O bloco "${aberto.tipo}" aberto na linha ${aberto.linha} não foi fechado com "fim".`, arquivo, linhas.length, linhas[linhas.length - 1] || '');
+    }
+}
 
-function traduzir(linha, numeroLinha, contexto) {
-    let t = linha.trim();
-    if (!t || t.startsWith("//")) return linha; // preserva indentação
+function traduzirLinha(linhaOriginal, numeroLinha, contexto) {
+    const linha = linhaOriginal.trim();
+    if (!linha || linha.startsWith('//')) return linhaOriginal;
 
-    // Título da página
-    if (t.startsWith('pagina ')) {
+    if (linha.startsWith('pagina ')) {
         contexto.ehSite = true;
-        const titulo = t.replace(/^pagina\s+/, '');
+        const valor = linha.slice(7).trim();
+        const titulo = /^(["'`]).*\1$/.test(valor) ? traduzirExpressao(valor) : JSON.stringify(valor);
         return `document.title = ${titulo};`;
     }
 
-    // UI: mostrar elemento na tela pelo id
-    if (t.startsWith('mostrar_tela ')) {
-        const m = t.match(/^mostrar_tela\s+"(.+?)"\s+em\s+"(.+?)"/);
-        if (m) return `document.getElementById("${m[2]}").innerText = "${m[1]}";`;
+    if (linha.startsWith('mostrar_tela ')) {
+        contexto.ehSite = true;
+        const resultado = linha.match(/^mostrar_tela\s+(.+)\s+em\s+"([A-Za-z][\w:-]*)"$/);
+        if (!resultado) criarErro('Use: mostrar_tela "Texto" em "elementoId"', contexto.arquivo, numeroLinha, linhaOriginal);
+        const valor = traduzirExpressao(resultado[1]);
+        const id = resultado[2];
+        return `(()=>{const __el=document.getElementById(${JSON.stringify(id)});if(!__el)throw new Error(${JSON.stringify(`Elemento #${id} não encontrado.`)});__el.innerText=String(${valor});})();`;
     }
 
-    // Ao clicar: evento de clique
-    if (t.startsWith('ao_clicar ')) {
-        const m = t.match(/^ao_clicar\s+"(.+?)"/);
-        if (m) return `document.getElementById("${m[1]}").addEventListener("click", function() {`;
+    if (linha.startsWith('ao_clicar ')) {
+        contexto.ehSite = true;
+        const resultado = linha.match(/^ao_clicar\s+"([A-Za-z][\w:-]*)"$/);
+        if (!resultado) criarErro('Use: ao_clicar "elementoId"', contexto.arquivo, numeroLinha, linhaOriginal);
+        const id = resultado[1];
+        contexto.pilhaTraducao.push({ tipo: 'evento', linha: numeroLinha });
+        return `(()=>{const __el=document.getElementById(${JSON.stringify(id)});if(!__el)throw new Error(${JSON.stringify(`Elemento #${id} não encontrado.`)});__el.addEventListener("click",function(){`;
     }
 
-    // Comandos básicos
-    if (t.startsWith('alerta '))      return `alert(${t.replace(/^alerta\s+/, '')});`;
-    if (t.startsWith('mudar_fundo ')) return `document.body.style.background = ${t.replace(/^mudar_fundo\s+/, '')};`;
-    if (t.startsWith('mostrar '))     return `console.log(${t.replace(/^mostrar\s+/, '')});`;
+    if (linha.startsWith('alerta ')) {
+        const valor = traduzirExpressao(linha.slice(7));
+        return `(typeof alert==="function"?alert(${valor}):console.log(${valor}));`;
+    }
 
-    // Variável com parsing correto de strings com espaços
-    if (t.startsWith('variavel ')) {
-        const m = t.match(/^variavel\s+(\w+)\s+(.*)/);
-        if (!m) erroDeCompilacao(`Sintaxe incorreta: "${t}" — Use: variavel nome "valor"`, numeroLinha);
-        return `let ${m[1]} = ${m[2]};`;
+    if (linha.startsWith('mudar_fundo ')) {
+        contexto.ehSite = true;
+        const valor = traduzirExpressao(linha.slice('mudar_fundo '.length));
+        return `document.body.style.background=${valor};`;
     }
 
-    if (t.startsWith('constante ')) {
-        const m = t.match(/^constante\s+(\w+)\s+(.*)/);
-        if (!m) erroDeCompilacao(`Sintaxe incorreta: "${t}" — Use: constante nome "valor"`, numeroLinha);
-        return `const ${m[1]} = ${m[2]};`;
+    if (linha.startsWith('mostrar ')) {
+        return `console.log(${traduzirExpressao(linha.slice(8))});`;
     }
 
-    // Estruturas de controle
-    if (t.startsWith('se '))      return `if (${t.replace(/^se\s+/, '').replace(/\bend\b/, '')}) {`;
-    if (t === 'senao')            return `} else {`;
-    if (t.startsWith('senaose ')) return `} else if (${t.replace(/^senaose\s+/, '')}) {`;
-    if (t === 'fim')              return `}`;
+    if (linha.startsWith('variavel ')) {
+        const resultado = linha.match(/^variavel\s+([A-Za-z_$][\w$]*)\s*(?:=\s*)?(.+)$/);
+        if (!resultado) criarErro('Use: variavel nome = "valor"', contexto.arquivo, numeroLinha, linhaOriginal);
+        return `let ${resultado[1]} = ${traduzirExpressao(resultado[2])};`;
+    }
 
-    // Loops
-    if (t.startsWith('repetir ')) {
-        const m = t.match(/^repetir\s+(\d+)\s+vezes/);
-        if (m) return `for (let _i = 0; _i < ${m[1]}; _i++) {`;
+    if (linha.startsWith('constante ')) {
+        const resultado = linha.match(/^constante\s+([A-Za-z_$][\w$]*)\s*(?:=\s*)?(.+)$/);
+        if (!resultado) criarErro('Use: constante nome = "valor"', contexto.arquivo, numeroLinha, linhaOriginal);
+        return `const ${resultado[1]} = ${traduzirExpressao(resultado[2])};`;
     }
-    if (t.startsWith('enquanto ')) return `while (${t.replace(/^enquanto\s+/, '')}) {`;
 
-    // Funções
-    if (t.startsWith('funcao ')) {
-        const m = t.match(/^funcao\s+(\w+)\s*\((.*)\)/);
-        if (m) return `function ${m[1]}(${m[2]}) {`;
+    if (linha.startsWith('lista ')) {
+        const resultado = linha.match(/^lista\s+([A-Za-z_$][\w$]*)\s*(?:=\s*)?(\[.*\])$/);
+        if (!resultado) criarErro('Use: lista nomes = ["Ana", "Rique"]', contexto.arquivo, numeroLinha, linhaOriginal);
+        return `let ${resultado[1]} = ${traduzirExpressao(resultado[2])};`;
     }
-    if (t.startsWith('retornar ')) return `return ${t.replace(/^retornar\s+/, '')};`;
 
-    return t; // passa JS puro direto
-}
+    if (linha.startsWith('definir ')) {
+        const resultado = linha.match(/^definir\s+([A-Za-z_$][\w$.[\]]*)\s*=\s*(.+)$/);
+        if (!resultado) criarErro('Use: definir nome = "novo valor"', contexto.arquivo, numeroLinha, linhaOriginal);
+        return `${resultado[1]} = ${traduzirExpressao(resultado[2])};`;
+    }
 
-// ─────────────────────────────────────────
-// VALIDAÇÃO DE BLOCOS
-// ─────────────────────────────────────────
-function validarBlocos(linhas) {
-    let pilha = 0;
-    linhas.forEach((linha, idx) => {
-        const t = linha.trim();
-        if (t.startsWith('se ') || t.startsWith('enquanto ') || t.startsWith('funcao ') || t.startsWith('repetir ') || t.startsWith('ao_clicar ')) pilha++;
-        if (t === 'fim') pilha--;
-        if (pilha < 0) erroDeCompilacao(`"fim" sobrando sem um bloco aberto.`, idx + 1);
-    });
-    if (pilha > 0) erroDeCompilacao(`Faltam ${pilha} "fim" para fechar bloco(s) abertos.`, linhas.length);
-}
+    if (linha.startsWith('senaose ')) {
+        return `} else if (${traduzirExpressao(linha.slice(8))}) {`;
+    }
 
-// ─────────────────────────────────────────
-// PONTO DE ENTRADA
-// ─────────────────────────────────────────
-if (!arquivoOuCmd) {
-    console.log("🌱 Raizcode v1.9 — A linguagem brasileira");
-    console.log("   Uso: raizcode <arquivo.rc>");
-    console.log("   Setup VSCode: raizcode --setup");
-    process.exit();
-}
+    if (linha === 'senao') return '} else {';
 
-const caminho = path.resolve(arquivoOuCmd);
-const nomeBase = caminho.substring(0, caminho.lastIndexOf('.'));
+    if (linha.startsWith('se ')) {
+        contexto.pilhaTraducao.push({ tipo: 'se', linha: numeroLinha });
+        return `if (${traduzirExpressao(linha.slice(3))}) {`;
+    }
 
-if (!fs.existsSync(caminho)) {
-    console.error(`❌ Arquivo não encontrado: ${arquivoOuCmd}`);
-    process.exit(1);
-}
+    if (linha.startsWith('repetir ')) {
+        const resultado = linha.match(/^repetir\s+(.+)\s+vezes$/);
+        if (!resultado) criarErro('Use: repetir 5 vezes', contexto.arquivo, numeroLinha, linhaOriginal);
+        contexto.pilhaTraducao.push({ tipo: 'repetir', linha: numeroLinha });
+        const indice = `__raiz_i_${numeroLinha}`;
+        return `for (let ${indice}=0;${indice}<(${traduzirExpressao(resultado[1])});${indice}++) {`;
+    }
 
-try {
-    const arqRcx = nomeBase + '.rcx';
-    const arqRcc = nomeBase + '.rcc';
+    if (linha.startsWith('enquanto ')) {
+        contexto.pilhaTraducao.push({ tipo: 'enquanto', linha: numeroLinha });
+        return `while (${traduzirExpressao(linha.slice(9))}) {`;
+    }
 
-    let htmlExtra = "";
-    let cssExtra = "";
-    const contexto = { ehSite: false };
+    if (linha.startsWith('para cada ')) {
+        const resultado = linha.match(/^para\s+cada\s+([A-Za-z_$][\w$]*)\s+em\s+(.+)$/);
+        if (!resultado) criarErro('Use: para cada item em lista', contexto.arquivo, numeroLinha, linhaOriginal);
+        contexto.pilhaTraducao.push({ tipo: 'para', linha: numeroLinha });
+        return `for (const ${resultado[1]} of ${traduzirExpressao(resultado[2])}) {`;
+    }
 
-    if (fs.existsSync(arqRcx)) {
-        htmlExtra = traduzirEstrutura(fs.readFileSync(arqRcx, 'utf-8'));
-        contexto.ehSite = true;
+    if (linha.startsWith('funcao ')) {
+        const resultado = linha.match(/^funcao\s+([A-Za-z_$][\w$]*)\s*\((.*)\)$/);
+        if (!resultado) criarErro('Use: funcao nome(parametro)', contexto.arquivo, numeroLinha, linhaOriginal);
+        contexto.pilhaTraducao.push({ tipo: 'funcao', linha: numeroLinha });
+        return `function ${resultado[1]}(${resultado[2]}) {`;
     }
-    if (fs.existsSync(arqRcc)) {
-        cssExtra = traduzirEstilo(fs.readFileSync(arqRcc, 'utf-8'));
-        contexto.ehSite = true;
+
+    if (linha.startsWith('retornar ')) {
+        return `return ${traduzirExpressao(linha.slice(9))};`;
     }
 
-    const codigo = fs.readFileSync(caminho, 'utf-8');
-    const linhas = codigo.split('\n');
+    if (linha === 'parar') return 'break;';
+    if (linha === 'continuar') return 'continue;';
 
-    // Valida antes de compilar
-    validarBlocos(linhas);
+    if (linha === 'fim') {
+        const bloco = contexto.pilhaTraducao.pop();
+        if (!bloco) criarErro('Existe um "fim" sem bloco aberto.', contexto.arquivo, numeroLinha, linhaOriginal);
+        if (bloco.tipo === 'evento') return '});})();';
+        return '}';
+    }
+
+    if (linha.startsWith('js ')) return linha.slice(3);
+
+    if (contexto.estrito && !contexto.permitirJs) {
+        criarErro(`Comando desconhecido: "${linha}"`, contexto.arquivo, numeroLinha, linhaOriginal);
+    }
+
+    return linhaOriginal;
+}
 
-    const js = linhas.map((linha, idx) => traduzir(linha, idx + 1, contexto)).join('\n');
+function compilarRC(codigo, arquivo, opcoes = {}) {
+    const linhas = codigo.replace(/^\uFEFF/, '').split(/\r\n|\n|\r/);
+    validarBlocos(linhas, arquivo);
 
-    const saidaJS   = nomeBase + '.js';
-    const saidaHTML = nomeBase + '.html';
+    const contexto = {
+        arquivo,
+        ehSite: false,
+        pilhaTraducao: [],
+        permitirJs: Boolean(opcoes.permitirJs),
+        estrito: Boolean(opcoes.estrito)
+    };
 
-    if (contexto.ehSite) {
-        const porta = args[1] ? parseInt(args[1]) : 3000;
-        const estruturaHTML = `<!DOCTYPE html>
+    const javascript = linhas
+        .map((linha, indice) => traduzirLinha(linha, indice + 1, contexto))
+        .join('\n');
+
+    return { javascript, ehSite: contexto.ehSite };
+}
+
+function executarComoModulo(javascript, arquivo) {
+    const moduloRaizcode = new Module(arquivo, module);
+    moduloRaizcode.filename = arquivo;
+    moduloRaizcode.paths = Module._nodeModulePaths(path.dirname(arquivo));
+    moduloRaizcode._compile(javascript, arquivo);
+}
+
+function obterLinhaDoErro(erro, arquivo) {
+    if (!erro || !erro.stack) return null;
+    const arquivoEscapado = arquivo.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const resultado = erro.stack.match(new RegExp(`${arquivoEscapado}:(\\d+):(\\d+)`));
+    if (!resultado) return null;
+    return { linha: Number(resultado[1]), coluna: Number(resultado[2]) };
+}
+
+function mostrarErro(erro, arquivo, codigoFonte = '') {
+    if (erro instanceof ErroRaizcode) {
+        console.error(`\n❌ Erro Raizcode em ${path.basename(erro.arquivo)}:${erro.numeroLinha}`);
+        console.error(`   ${erro.message}`);
+        if (erro.codigoLinha) {
+            console.error(`\n   ${erro.numeroLinha} | ${erro.codigoLinha}`);
+        }
+        console.error('');
+        return;
+    }
+
+    const local = obterLinhaDoErro(erro, arquivo);
+    const linhas = codigoFonte.split(/\r\n|\n|\r/);
+
+    if (local) {
+        console.error(`\n❌ Erro ao executar ${path.basename(arquivo)}:${local.linha}:${local.coluna}`);
+        console.error(`   ${erro.name || 'Erro'}: ${erro.message}`);
+        if (linhas[local.linha - 1] !== undefined) {
+            console.error(`\n   ${local.linha} | ${linhas[local.linha - 1]}`);
+            console.error(`       ${' '.repeat(Math.max(0, local.coluna - 1))}^`);
+        }
+        console.error('');
+        return;
+    }
+
+    console.error(`\n❌ ${erro.name || 'Erro'}: ${erro.message}\n`);
+    if (flags.has('--debug') && erro.stack) console.error(erro.stack);
+}
+
+function montarHTML(javascript, htmlExtra, cssExtra, nomeArquivo) {
+    const origemSegura = String(nomeArquivo).replace(/[\r\n]/g, '');
+    return `<!DOCTYPE html>
 <html lang="pt-br">
 <head>
     <meta charset="UTF-8">
@@ -304,7 +732,7 @@ try {
         body {
             background: #0d0d0d;
             color: #f0f0f0;
-            font-family: sans-serif;
+            font-family: Arial, sans-serif;
             display: flex;
             justify-content: center;
             align-items: center;
@@ -318,13 +746,12 @@ try {
             padding: 40px;
             border-radius: 20px;
             background: #1a1a1a;
-            box-shadow: 0 0 30px rgba(0,255,136,0.2);
             max-width: 800px;
             width: 100%;
         }
-        h1 { color: #00ff88; text-shadow: 0 0 10px #00ff88; }
+        h1 { color: #00ff88; }
         h2 { color: #00cfff; }
-        a  { color: #00ff88; }
+        a { color: #00ff88; }
         button {
             background: #00ff88;
             color: #000;
@@ -335,7 +762,6 @@ try {
             cursor: pointer;
             margin: 8px;
             font-size: 1rem;
-            transition: opacity 0.2s;
         }
         button:hover { opacity: 0.8; }
         input {
@@ -347,52 +773,138 @@ try {
             margin: 8px;
             font-size: 1rem;
         }
-        ${cssExtra}
+${cssExtra}
     </style>
 </head>
 <body>
-    <div id="raiz-app">${htmlExtra}</div>
+    <div id="raiz-app">
+${htmlExtra}
+    </div>
     <script>
-${js}
+window.addEventListener('error', function(event) {
+    console.error('Erro Raizcode:', event.message, 'linha', event.lineno);
+});
+${javascript}
+//# sourceURL=${origemSegura}
     </script>
 </body>
 </html>`;
+}
 
-        // Salva HTML para inspeção (opcional)
-        fs.writeFileSync(saidaHTML, estruturaHTML);
+function iniciarServidor(html, porta, abrirAutomaticamente) {
+    const servidor = http.createServer((requisicao, resposta) => {
+        if (requisicao.url === '/favicon.ico') {
+            resposta.writeHead(204);
+            resposta.end();
+            return;
+        }
 
-        const server = http.createServer((req, res) => {
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(estruturaHTML);
+        resposta.writeHead(200, {
+            'Content-Type': 'text/html; charset=utf-8',
+            'Cache-Control': 'no-store'
         });
+        resposta.end(html);
+    });
 
-        server.listen(porta, () => {
-            console.log(`\n🌱 Raizcode — Servidor ativo!`);
-            console.log(`🌐 Acesse: http://localhost:${porta}`);
-            console.log(`⏹  Pressione Ctrl+C para encerrar.\n`);
-            abrirNavegador(`http://localhost:${porta}`);
-        });
+    servidor.on('error', (erro) => {
+        if (erro.code === 'EADDRINUSE') {
+            console.error(`\n❌ A porta ${porta} já está sendo usada.`);
+            console.error(`   Tente: raizcode seu-arquivo.rc ${porta + 1}\n`);
+        } else {
+            console.error(`\n❌ Erro no servidor: ${erro.message}\n`);
+        }
+        process.exitCode = 1;
+    });
+
+    servidor.listen(porta, '127.0.0.1', () => {
+        const url = `http://127.0.0.1:${porta}`;
+        console.log('\n🌱 Raizcode — servidor ativo!');
+        console.log(`🌐 Acesse: ${url}`);
+        console.log('⏹  Pressione Ctrl+C para encerrar.\n');
+        if (abrirAutomaticamente) abrirNavegador(url);
+    });
 
-        // Mantém servidor vivo até Ctrl+C
-        process.on('SIGINT', () => {
-            console.log('\n👋 Servidor encerrado.');
-            if (fs.existsSync(saidaHTML)) fs.unlinkSync(saidaHTML);
-            process.exit();
+    process.once('SIGINT', () => {
+        console.log('\n👋 Servidor encerrado.');
+        servidor.close(() => process.exit(0));
+    });
+}
+
+function executarProjeto() {
+    if (!arquivoOuCmd || flags.has('--help') || arquivoOuCmd === '-h') {
+        mostrarAjuda();
+        return;
+    }
+
+    if (flags.has('--version') || arquivoOuCmd === '-v') {
+        console.log(obterVersao());
+        return;
+    }
+
+    if (arquivoOuCmd === '--setup') {
+        instalarExtensaoVSCode();
+        return;
+    }
+
+    const arquivoEntrada = posicionais[0];
+    if (!arquivoEntrada) {
+        mostrarAjuda();
+        return;
+    }
+
+    const caminho = path.resolve(arquivoEntrada);
+    if (!fs.existsSync(caminho)) {
+        console.error(`❌ Arquivo não encontrado: ${arquivoEntrada}`);
+        process.exitCode = 1;
+        return;
+    }
+
+    if (path.extname(caminho).toLowerCase() !== '.rc') {
+        console.error('❌ O arquivo principal precisa ter a extensão .rc');
+        process.exitCode = 1;
+        return;
+    }
+
+    const nomeBase = caminho.slice(0, -path.extname(caminho).length);
+    const arqRcx = `${nomeBase}.rcx`;
+    const arqRcc = `${nomeBase}.rcc`;
+    const saidaHTML = `${nomeBase}.html`;
+    let codigoFonte = '';
+
+    try {
+        const htmlExtra = fs.existsSync(arqRcx)
+            ? traduzirEstrutura(fs.readFileSync(arqRcx, 'utf8'), arqRcx)
+            : '';
+        const cssExtra = fs.existsSync(arqRcc)
+            ? traduzirEstilo(fs.readFileSync(arqRcc, 'utf8'), arqRcc)
+            : '';
+
+        codigoFonte = fs.readFileSync(caminho, 'utf8');
+        const compilado = compilarRC(codigoFonte, caminho, {
+            permitirJs: flags.has('--permitir-js'),
+            estrito: flags.has('--estrito')
         });
 
-    } else {
-        // Modo script: executa e apaga
-        fs.writeFileSync(saidaJS, js);
-        try {
-            execSync(`node "${saidaJS}"`, { stdio: 'inherit' });
-        } finally {
-            if (fs.existsSync(saidaJS)) fs.unlinkSync(saidaJS);
+        const ehSite = compilado.ehSite || Boolean(htmlExtra) || Boolean(cssExtra);
+        if (!ehSite) {
+            executarComoModulo(compilado.javascript, caminho);
+            return;
+        }
+
+        const portaInformada = posicionais[1] || '3000';
+        const porta = Number(portaInformada);
+        if (!Number.isInteger(porta) || porta < 1 || porta > 65535) {
+            criarErro(`Porta inválida: ${portaInformada}`, caminho, 1, codigoFonte.split(/\r\n|\n|\r/)[0] || '');
         }
-    }
 
-} catch (err) {
-    if (!err.already_reported) {
-        console.error(`\n❌ Erro inesperado: ${err.message}\n`);
+        const html = montarHTML(compilado.javascript, htmlExtra, cssExtra, path.basename(caminho));
+        fs.writeFileSync(saidaHTML, html, 'utf8');
+        console.log(`✅ Página gerada: ${saidaHTML}`);
+        iniciarServidor(html, porta, !flags.has('--no-open'));
+    } catch (erro) {
+        mostrarErro(erro, caminho, codigoFonte);
+        process.exitCode = 1;
     }
-    process.exit(1);
-}
+}
+
+executarProjeto();