@designliquido/delegua 1.6.0 → 1.7.1

package/umd/delegua.js

@@ -3854,8 +3854,11 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaEscopos.definirInformacoesVariavel('texto', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('texto', 'texto', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('valorParaConverter', 'qualquer'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('todos', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todos', 'lógico', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer')
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('todosEmCondicao', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todosEmCondicao', 'lógico', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoCondicional', 'função'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('tupla', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'tupla', true, [
@@ -4813,14 +4816,23 @@ class AvaliadorSintaticoPitugues {
     }
     async declaracaoImplicitaVariaveis() {
         const identificador = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome de variável.');
+        let tipo = 'qualquer';
+        let tipoExplicito = false;
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)) {
+            tipo = this.verificarDefinicaoTipoAtual();
+            tipoExplicito = true;
+            this.avancarEDevolverAnterior();
+        }
         this.consumir(pitugues_2.default.IGUAL, "Esperado '=' após identificador.");
         if (this.estaNoFinal()) {
             throw this.erro(this.simboloAnterior(), 'Esperado valor após o símbolo de igual.');
         }
         const valor = await this.expressao();
-        const tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(valor, 'qualquer');
+        if (!tipoExplicito) {
+            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(valor, 'qualquer');
+        }
         this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
-        return new declaracoes_1.Var(identificador, valor, tipo);
+        return new declaracoes_1.Var(identificador, valor, tipo, tipoExplicito);
     }
     temPadraoMultiplaAtribuicao() {
         // Verifica padrão: IDENTIFICADOR, VIRGULA, IDENTIFICADOR, ..., IGUAL
@@ -5238,26 +5250,27 @@ class AvaliadorSintaticoPitugues {
                 expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             }
             else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_ESQUERDO)) {
+                const inicio = !this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS)
+                    ? await this.expressao()
+                    : null;
                 let ehFatiamento = false;
-                let indiceInicio = null;
-                let indiceFim = null;
-                if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS)) {
-                    indiceInicio = await this.expressao();
-                }
+                let fim = null;
+                let passo = null;
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)) {
                     ehFatiamento = true;
-                    // Se o próximo não é ':', nem ']', então é o índice fim
-                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS) &&
-                        !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO)) {
-                        indiceFim = await this.expressao();
-                    }
+                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS)
+                        && !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
+                        fim = await this.expressao();
+                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)
+                        && !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO))
+                        passo = await this.expressao();
                 }
                 const simboloFechamento = this.consumir(pitugues_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 if (ehFatiamento) {
-                    expressao = new construtos_1.AcessoIntervaloVariavel(this.hashArquivo, expressao, indiceInicio, indiceFim, simboloFechamento);
+                    expressao = new construtos_1.AcessoIntervaloVariavel(this.hashArquivo, expressao, inicio, fim, passo, simboloFechamento);
                 }
                 else {
-                    expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indiceInicio, simboloFechamento);
+                    expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, inicio, simboloFechamento);
                 }
             }
             else {
@@ -5614,34 +5627,61 @@ class AvaliadorSintaticoPitugues {
         return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
     }
     async declaracaoPara() {
+        const simboloPara = this.simboloAnterior();
+        this.blocos += 1;
         try {
-            const simboloPara = this.simboloAnterior();
-            this.blocos += 1;
             this.consumir(pitugues_2.default.CADA, `Esperado palavra reservada 'cada' após 'para'. Atual: ${this.simbolos[this.atual].lexema}.`);
-            const nomeVariavelIteracao = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
+            const primeiraVariavel = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
+            let simboloSegundaVariavel = null;
+            if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA)) {
+                simboloSegundaVariavel = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado identificador após a vírgula.');
+            }
+            let variavelIteracao;
+            const v1 = new construtos_1.Variavel(this.hashArquivo, primeiraVariavel, 'qualquer');
+            if (simboloSegundaVariavel) {
+                const v2 = new construtos_1.Variavel(this.hashArquivo, simboloSegundaVariavel, 'qualquer');
+                variavelIteracao = new construtos_1.Dupla(v1, v2);
+            }
+            else {
+                variavelIteracao = v1;
+            }
             if (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DE, pitugues_2.default.EM)) {
                 throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'.");
             }
-            const vetor = await this.expressao();
-            if (!vetor.hasOwnProperty('tipo')) {
-                throw this.erro(simboloPara, `Variável ou constante em 'para cada' não parece possuir um tipo iterável.`);
-            }
-            const tipoVetor = vetor.tipo;
-            if (!tipoVetor.endsWith('[]') && !['qualquer', 'texto', 'vetor'].includes(tipoVetor)) {
-                throw this.erro(simboloPara, `Variável ou constante em 'para cada' não é iterável. Tipo resolvido: ${tipoVetor}.`);
+            const alvoIteracao = await this.expressao();
+            this.validarSeAlvoEIteravel(simboloPara, alvoIteracao, !!simboloSegundaVariavel);
+            this.pilhaEscopos.definirInformacoesVariavel(primeiraVariavel.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(primeiraVariavel.lexema, 'qualquer'));
+            if (simboloSegundaVariavel) {
+                this.pilhaEscopos.definirInformacoesVariavel(simboloSegundaVariavel.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloSegundaVariavel.lexema, 'qualquer'));
             }
-            this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVetor.slice(0, -2)));
             // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
             const corpo = await this.resolverDeclaracao();
-            return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
-        }
-        catch (erro) {
-            throw erro;
+            return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), variavelIteracao, alvoIteracao, corpo);
         }
         finally {
             this.blocos -= 1;
         }
     }
+    /**
+     * Função auxiliar para validar se o alvo pode ser iterado.
+     */
+    validarSeAlvoEIteravel(simboloPara, alvo, temDuasVariaveis) {
+        if (!alvo || !alvo.tipo)
+            return;
+        const tipo = alvo.tipo;
+        const tiposValidos = ['qualquer', 'vetor', 'dicionário', 'texto'];
+        const eVetor = tipo.endsWith('[]') || tipo === 'vetor';
+        if (temDuasVariaveis) {
+            if (!eVetor && tipo !== 'dicionário' && tipo !== 'qualquer') {
+                throw this.erro(simboloPara, `Para iterar com duas variáveis, o objeto deve ser um dicionário ou lista. Tipo atual: ${tipo}.`);
+            }
+        }
+        else {
+            if (!eVetor && !tiposValidos.includes(tipo)) {
+                throw this.erro(simboloPara, `O objeto do tipo '${tipo}' não é iterável.`);
+            }
+        }
+    }
     async declaracaoSe() {
         const condicao = await this.expressao();
         const caminhoEntao = await this.resolverDeclaracao();
@@ -5994,6 +6034,9 @@ class AvaliadorSintaticoPitugues {
                 if (!this.variavelJaDeclarada(simboloAtual.lexema))
                     return this.declaracaoImplicitaVariaveis();
             }
+            if (proximoSimbolo && proximoSimbolo.tipo === pitugues_2.default.DOIS_PONTOS) {
+                return this.declaracaoImplicitaVariaveis();
+            }
         }
         switch (simboloAtual.tipo) {
             case pitugues_2.default.COMENTARIO:
@@ -6147,8 +6190,11 @@ class AvaliadorSintaticoPitugues {
         this.pilhaEscopos.definirInformacoesVariavel('tipo', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tipo', 'qualquer', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('elemento', 'qualquer'),
         ]));
+        this.pilhaEscopos.definirInformacoesVariavel('todos', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todos', 'lógico', true, [
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer')
+        ]));
         this.pilhaEscopos.definirInformacoesVariavel('todosEmCondicao', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('todosEmCondicao', 'lógico', true, [
-            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
+            new informacao_elemento_sintatico_1.InformacaoElementoSintatico('iteravel', 'qualquer'),
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('funcaoCondicional', 'função'),
         ]));
         this.pilhaEscopos.definirInformacoesVariavel('tupla', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'tupla', true, [
@@ -8940,6 +8986,7 @@ exports.reduzir = reduzir;
 exports.somar = somar;
 exports.tamanho = tamanho;
 exports.texto = texto;
+exports.todos = todos;
 exports.todosEmCondicao = todosEmCondicao;
 exports.tupla = tupla;
 exports.vetor = vetor;
@@ -9937,40 +9984,68 @@ async function tamanho(interpretador, objeto) {
 async function texto(interpretador, valorParaConverter) {
     return Promise.resolve(`${valorParaConverter.hasOwnProperty('valor') ? valorParaConverter.valor : valorParaConverter}`);
 }
+/**
+ * Retorna verdadeiro se todos os elementos do iterável forem truly.
+ * @param {InterpretadorInterface} interpretador A instância do interpretador.
+ * @param {VariavelInterface | any} iteravel O primeiro parâmetro, qualquer dado que seja iterável (vetores, tuplas, dicionários etc.).
+ * @returns {Promise<boolean>} Verdadeiro, se todos os valores do iterável forem Truly.
+ */
+async function todos(interpretador, iteravel) {
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const ehObjetoOuDicionario = valorIteravel && typeof valorIteravel === 'object' && !Array.isArray(valorIteravel);
+    const ehIteravelNativo = valorIteravel && typeof valorIteravel[Symbol.iterator] === 'function';
+    if (!ehIteravelNativo && !ehObjetoOuDicionario) {
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
+            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+            linha: interpretador.linhaDeclaracaoAtual,
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.'));
+    }
+    const itens = ehIteravelNativo ? valorIteravel : Object.values(valorIteravel);
+    for (const valor of itens) {
+        const valorResolvido = interpretador.resolverValor(valor);
+        if (!interpretador.eVerdadeiro(valorResolvido))
+            return false;
+    }
+    return true;
+}
 /**
  * Retorna verdadeiro se todos os elementos do primeiro parâmetro retornam verdadeiro ao
  * serem aplicados como argumentos da função passada como segundo parâmetro.
  * @param {InterpretadorInterface} interpretador A instância do interpretador.
- * @param {VariavelInterface | any} vetor O primeiro parâmetro, um vetor.
+ * @param {VariavelInterface | any} iteravel O primeiro parâmetro, qualquer dado que seja iterável (vetores, tuplas, dicionários etc.).
  * @param {VariavelInterface | any} funcaoCondicional A função que será executada com cada
- *                                  valor do vetor passado como primeiro parâmetro.
- * @returns {Promise<boolean>} Verdadeiro, se todos os valores do vetor fazem a função passada
+ *                                  valor do iterável passado como primeiro parâmetro.
+ * @returns {Promise<boolean>} Verdadeiro, se todos os valores do iterável fazem a função passada
  *                             por parâmetro devolver verdadeiro, ou falso em caso contrário.
  */
-async function todosEmCondicao(interpretador, vetor, funcaoCondicional) {
-    if (vetor === null || vetor === undefined)
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
-            hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
-            linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() não pode ser nulo.'));
-    const valorVetor = vetor.hasOwnProperty('valor') ? vetor.valor : vetor;
-    const valorFuncaoCondicional = funcaoCondicional.hasOwnProperty('valor')
-        ? funcaoCondicional.valor
-        : funcaoCondicional;
-    if (!Array.isArray(valorVetor)) {
+async function todosEmCondicao(interpretador, iteravel, funcaoCondicional) {
+    const simboloChamada = {
+        linha: interpretador.linhaDeclaracaoAtual,
+        hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
+    };
+    const valorIteravel = interpretador.resolverValor(iteravel);
+    const ehObjetoOuDicionario = valorIteravel && typeof valorIteravel === 'object' && !Array.isArray(valorIteravel);
+    const ehIteravelNativo = valorIteravel && typeof valorIteravel[Symbol.iterator] === 'function';
+    if (!ehIteravelNativo && !ehObjetoOuDicionario) {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O primeiro parâmetro da função todosEmCondicao() deve ser um vetor.'));
+        }, 'Parâmetro inválido. O primeiro parâmetro deve ser um iterável.'));
     }
-    if (valorFuncaoCondicional.constructor !== estruturas_1.DeleguaFuncao) {
+    const valorFuncao = interpretador.resolverValor(funcaoCondicional);
+    const ehFuncaoValida = valorFuncao instanceof estruturas_1.DeleguaFuncao ||
+        valorFuncao instanceof funcao_padrao_1.FuncaoPadrao;
+    if (!ehFuncaoValida) {
         return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao({
             hashArquivo: interpretador.hashArquivoDeclaracaoAtual,
             linha: interpretador.linhaDeclaracaoAtual,
-        }, 'Parâmetro inválido. O segundo parâmetro da função todosEmCondicao() deve ser uma função.'));
+        }, 'Parâmetro inválido. O segundo parâmetro deve ser uma função.'));
     }
-    for (let indice = 0; indice < valorVetor.length; ++indice) {
-        if (!(await valorFuncaoCondicional.chamar(interpretador, [valorVetor[indice]])))
+    const itens = ehIteravelNativo ? valorIteravel : Object.values(valorIteravel);
+    for (const valor of itens) {
+        const resultadoChamada = await valorFuncao.chamar(interpretador, [valor], simboloChamada);
+        const resultadoResolvido = interpretador.resolverValor(resultadoChamada);
+        if (!interpretador.eVerdadeiro(resultadoResolvido))
             return false;
     }
     return true;
@@ -11003,16 +11078,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AcessoIntervaloVariavel = void 0;
 /**
  * Construto para acesso de intervalos (fatiamento/slicing) em vetores.
- * Ex: vetor[1:4], vetor[1:], vetor[:3] ou vetor[:]
+ * Ex: vetor[1:4], vetor[1:4:2], vetor[1:], vetor[:3] ou vetor[:]
  */
 class AcessoIntervaloVariavel {
-    constructor(hashArquivo, entidadeChamada, indiceInicio, indiceFim, simboloFechamento, tipo = 'qualquer') {
+    constructor(hashArquivo, entidadeChamada, indiceInicio, indiceFim, indicePasso, simboloFechamento, tipo = 'qualquer') {
         this.tipo = 'qualquer';
         this.linha = entidadeChamada.linha;
         this.hashArquivo = hashArquivo;
         this.entidadeChamada = entidadeChamada;
         this.indiceInicio = indiceInicio;
         this.indiceFim = indiceFim;
+        this.indicePasso = indicePasso;
         this.simboloFechamento = simboloFechamento;
         this.tipo = tipo;
     }
@@ -11022,9 +11098,11 @@ class AcessoIntervaloVariavel {
     paraTexto() {
         const inicio = this.indiceInicio ? this.indiceInicio.paraTexto() : 'sem-início';
         const fim = this.indiceFim ? this.indiceFim.paraTexto() : 'sem-fim';
+        const passo = this.indicePasso ? this.indicePasso.paraTexto() : 'sem-passo';
         return (`<acesso-índice-variável entidadeChamada=${this.entidadeChamada.paraTexto()} ` +
             `inicio=${inicio} ` +
             `fim=${fim}` +
+            `passo=${passo}` +
             `/>`);
     }
     paraTextoSaida() {
@@ -15763,7 +15841,7 @@ function carregarBibliotecasGlobais(pilhaEscoposExecucao) {
     pilhaEscoposExecucao.definirVariavel('somar', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.somar));
     pilhaEscoposExecucao.definirVariavel('tamanho', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.tamanho));
     pilhaEscoposExecucao.definirVariavel('texto', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.texto));
-    pilhaEscoposExecucao.definirVariavel('todos', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
+    pilhaEscoposExecucao.definirVariavel('todos', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.todos));
     pilhaEscoposExecucao.definirVariavel('todosEmCondicao', new funcao_padrao_1.FuncaoPadrao(2, bibliotecaGlobal.todosEmCondicao));
     pilhaEscoposExecucao.definirVariavel('tupla', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.tupla));
     pilhaEscoposExecucao.definirVariavel('vetor', new funcao_padrao_1.FuncaoPadrao(1, bibliotecaGlobal.vetor));
@@ -39275,7 +39353,9 @@ class TradutorAssemblyScript {
         this.indentacao = 0;
         this.dicionarioConstrutos = {
             AcessoIndiceVariavel: this.traduzirConstrutoAcessoIndiceVariavel.bind(this),
+            AcessoMetodo: this.traduzirConstrutoAcessoMetodo.bind(this),
             AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodo.bind(this),
+            AcessoPropriedade: this.traduzirConstrutoAcessoPropriedade.bind(this),
             Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
             ArgumentoReferenciaFuncao: this.traduzirConstrutoArgumentoReferenciaFuncao.bind(this),
             AtribuicaoPorIndice: this.traduzirConstrutoAtribuicaoPorIndice.bind(this),
@@ -39283,19 +39363,34 @@ class TradutorAssemblyScript {
             Binario: this.traduzirConstrutoBinario.bind(this),
             Chamada: this.traduzirConstrutoChamada.bind(this),
             ComentarioComoConstruto: this.traduzirConstrutoComentario.bind(this),
+            Deceto: this.traduzirConstrutoDeceto.bind(this),
             DefinirValor: this.traduzirConstrutoDefinirValor.bind(this),
+            Dicionario: this.traduzirConstrutoDicionario.bind(this),
+            Dupla: this.traduzirConstrutoDupla.bind(this),
+            Elvis: this.traduzirConstrutoElvis.bind(this),
+            ExpressaoRegular: this.traduzirConstrutoExpressaoRegular.bind(this),
             FuncaoConstruto: this.traduzirFuncaoConstruto.bind(this),
             Isto: () => 'this',
             Literal: this.traduzirConstrutoLiteral.bind(this),
             Logico: this.traduzirConstrutoLogico.bind(this),
+            Noneto: this.traduzirConstrutoNoneto.bind(this),
+            Octeto: this.traduzirConstrutoOcteto.bind(this),
+            Quarteto: this.traduzirConstrutoQuarteto.bind(this),
+            Quinteto: this.traduzirConstrutoQuinteto.bind(this),
             ReferenciaFuncao: this.traduzirConstrutoReferenciaFuncao.bind(this),
             Separador: this.traduzirConstrutoSeparador.bind(this),
+            SeTernario: this.traduzirConstrutoSeTernario.bind(this),
+            Sexteto: this.traduzirConstrutoSexteto.bind(this),
+            Septeto: this.traduzirConstrutoSepteto.bind(this),
             TipoDe: this.traduzirConstrutoTipoDe.bind(this),
+            Trio: this.traduzirConstrutoTrio.bind(this),
+            TuplaN: this.traduzirConstrutoTuplaN.bind(this),
             Unario: this.traduzirConstrutoUnario.bind(this),
             Variavel: this.traduzirConstrutoVariavel.bind(this),
             Vetor: this.traduzirConstrutoVetor.bind(this),
         };
         this.dicionarioDeclaracoes = {
+            Ajuda: this.traduzirDeclaracaoAjuda.bind(this),
             Bloco: this.traduzirDeclaracaoBloco.bind(this),
             Enquanto: this.traduzirDeclaracaoEnquanto.bind(this),
             Comentario: this.traduzirConstrutoComentario.bind(this),
@@ -39315,8 +39410,13 @@ class TradutorAssemblyScript {
             Classe: this.traduzirDeclaracaoClasse.bind(this),
             Tente: this.traduzirDeclaracaoTente.bind(this),
             Const: this.traduzirDeclaracaoConst.bind(this),
+            ConstMultiplo: this.traduzirDeclaracaoConstMultiplo.bind(this),
             Var: this.traduzirDeclaracaoVar.bind(this),
+            VarMultiplo: this.traduzirDeclaracaoVarMultiplo.bind(this),
             Escreva: this.traduzirDeclaracaoEscreva.bind(this),
+            EscrevaMesmaLinha: this.traduzirDeclaracaoEscrevaMesmaLinha.bind(this),
+            TendoComo: this.traduzirDeclaracaoTendoComo.bind(this),
+            TextoDocumentacao: this.traduzirDeclaracaoTextoDocumentacao.bind(this),
         };
     }
     traduzirSimboloOperador(operador) {
@@ -39332,7 +39432,7 @@ class TradutorAssemblyScript {
             case delegua_1.default.BIT_NOT:
                 return '~';
             case delegua_1.default.DIFERENTE:
-                return '!==';
+                return '!=';
             case delegua_1.default.DIVISAO:
                 return '/';
             case delegua_1.default.E:
@@ -39342,7 +39442,7 @@ class TradutorAssemblyScript {
             case delegua_1.default.IGUAL:
                 return '=';
             case delegua_1.default.IGUAL_IGUAL:
-                return '===';
+                return '==';
             case delegua_1.default.MAIOR:
                 return '>';
             case delegua_1.default.MAIOR_IGUAL:
@@ -39363,6 +39463,7 @@ class TradutorAssemblyScript {
     }
     traduzirFuncoesNativas(metodo) {
         switch (metodo.toLowerCase()) {
+            // Array methods
             case 'adicionar':
             case 'empilhar':
                 return 'push';
@@ -39371,6 +39472,7 @@ class TradutorAssemblyScript {
             case 'fatiar':
                 return 'slice';
             case 'inclui':
+            case 'incluido':
                 return 'includes';
             case 'inverter':
                 return 'reverse';
@@ -39384,16 +39486,126 @@ class TradutorAssemblyScript {
                 return 'pop';
             case 'tamanho':
                 return 'length';
+            case 'indice':
+            case 'indiceode':
+                return 'indexOf';
+            // String methods
             case 'maiusculo':
                 return 'toUpperCase';
             case 'minusculo':
                 return 'toLowerCase';
             case 'substituir':
                 return 'replace';
+            case 'trimcomeco':
+                return 'trimStart';
+            case 'trimfim':
+                return 'trimEnd';
+            case 'trim':
+                return 'trim';
+            case 'comeca':
+                return 'startsWith';
+            case 'termina':
+                return 'endsWith';
+            case 'contém':
+            case 'contem':
+                return 'includes';
+            // Math constants and methods (would need Math. prefix in AS)
+            case 'abs':
+            case 'absoluto':
+                return 'Math.abs';
+            case 'ceil':
+            case 'teto':
+                return 'Math.ceil';
+            case 'floor':
+            case 'piso':
+                return 'Math.floor';
+            case 'round':
+            case 'arredondar':
+                return 'Math.round';
+            case 'sqrt':
+            case 'raizquadrada':
+                return 'Math.sqrt';
+            case 'pow':
+            case 'potencia':
+                return 'Math.pow';
+            case 'max':
+            case 'maximo':
+                return 'Math.max';
+            case 'min':
+            case 'minimo':
+                return 'Math.min';
+            case 'sin':
+            case 'seno':
+                return 'Math.sin';
+            case 'cos':
+            case 'cosseno':
+                return 'Math.cos';
+            case 'tan':
+            case 'tangente':
+                return 'Math.tan';
+            case 'pi':
+                return 'Math.PI';
+            case 'e':
+                return 'Math.E';
             default:
                 return metodo;
         }
     }
+    traduzirFuncaoNativaGlobal(nomeFuncao, argumentos) {
+        switch (nomeFuncao.toLowerCase()) {
+            // Math functions
+            case 'aleatorio':
+                return `Math.random()`;
+            case 'aleatorioEntre':
+            case 'aleatorioente':
+                if (argumentos.length >= 2) {
+                    return `(Math.random() * (${argumentos[1]} - ${argumentos[0]}) + ${argumentos[0]})`;
+                }
+                return null;
+            case 'arredondar':
+                return argumentos.length > 0 ? `Math.round(${argumentos[0]})` : null;
+            case 'inteiro':
+                return argumentos.length > 0 ? `Math.trunc(${argumentos[0]})` : null;
+            case 'numero':
+                return argumentos.length > 0 ? `Number(${argumentos[0]})` : null;
+            case 'texto':
+                return argumentos.length > 0 ? `String(${argumentos[0]})` : null;
+            case 'longo':
+                return argumentos.length > 0 ? `parseInt(${argumentos[0]})` : null;
+            case 'real':
+                return argumentos.length > 0 ? `parseFloat(${argumentos[0]})` : null;
+            // Array functions
+            case 'tamanho':
+                return argumentos.length > 0 ? `(${argumentos[0]}).length` : null;
+            case 'intervalo':
+                // intervalo(inicio, fim, passo?) - returns array of numbers
+                if (argumentos.length >= 2) {
+                    if (argumentos.length >= 3) {
+                        return `Array.from({length: (${argumentos[1]} - ${argumentos[0]}) / ${argumentos[2]}}, (_, i) => ${argumentos[0]} + i * ${argumentos[2]})`;
+                    }
+                    return `Array.from({length: ${argumentos[1]} - ${argumentos[0]}}, (_, i) => ${argumentos[0]} + i)`;
+                }
+                return null;
+            case 'maximo':
+                return argumentos.length > 0 ? `Math.max(...${argumentos[0]})` : null;
+            case 'minimo':
+                return argumentos.length > 0 ? `Math.min(...${argumentos[0]})` : null;
+            // These need custom implementation or are too complex for Phase 5
+            case 'mapear':
+            case 'filtrarPor':
+            case 'reduzir':
+            case 'ordenar':
+            case 'encontrar':
+            case 'encontrarIndice':
+            case 'incluido':
+            case 'todos':
+            case 'algum':
+                // These would require closures/lambda support - not easily translated
+                return null;
+            default:
+                return null;
+        }
+    }
     traduzirConstrutoArgumentoReferenciaFuncao(argumentoReferenciaFuncao, argumentos) {
         const argumentosResolvidos = [];
         for (const argumento of argumentos) {
@@ -39418,7 +39630,7 @@ class TradutorAssemblyScript {
         return `${separador.conteudo} `;
     }
     traduzirDeclaracaoEscreva(declaracaoEscreva) {
-        let resultado = 'console.log(';
+        let resultado = 'trace(';
         for (const argumento of declaracaoEscreva.argumentos) {
             const valor = this.dicionarioConstrutos[argumento.constructor.name](argumento);
             resultado += valor + ', ';
@@ -39429,7 +39641,7 @@ class TradutorAssemblyScript {
     }
     traduzirConstrutoLiteral(literal) {
         if (typeof literal.valor === 'string')
-            return `'${literal.valor}'`;
+            return `"${literal.valor}"`;
         return String(literal.valor);
     }
     resolveTipoDeclaracaoVarEContante(tipo) {
@@ -39437,25 +39649,67 @@ class TradutorAssemblyScript {
             case 'texto':
                 return ': string';
             case 'inteiro':
+                return ': i32';
+            case 'longo':
+                return ': i64';
+            case 'inteiro_curto':
+            case 'inteiroCurto':
+                return ': i16';
+            case 'byte':
+                return ': i8';
             case 'numero':
             case 'número':
             case 'real':
                 return ': f64';
+            case 'real_curto':
+            case 'realCurto':
+                return ': f32';
             case 'logico':
             case 'lógico':
                 return ': bool';
+            case 'vazio':
+            case 'nada':
+                return ': void';
             case 'nulo':
-                return ': null';
+                throw new Error(`Tipo 'nulo' não é válido no AssemblyScript. Use 'Type | null' para tipos anuláveis.`);
             case 'inteiro[]':
+                return ': i32[]';
+            case 'longo[]':
+                return ': i64[]';
             case 'real[]':
+            case 'numero[]':
+            case 'número[]':
                 return ': f64[]';
             case 'texto[]':
                 return ': string[]';
             case 'logico[]':
             case 'lógico[]':
                 return ': bool[]';
+            case 'dicionario':
+            case 'dicionário':
+                return ': Map<string, i32>';
+            case 'dupla':
+                return ': i32[]';
+            case 'trio':
+                return ': i32[]';
+            case 'quarteto':
+                return ': i32[]';
+            case 'quinteto':
+                return ': i32[]';
+            case 'sexteto':
+                return ': i32[]';
+            case 'septeto':
+                return ': i32[]';
+            case 'octeto':
+                return ': i32[]';
+            case 'noneto':
+                return ': i32[]';
+            case 'deceto':
+                return ': i32[]';
+            case 'tupla':
+                return ': i32[]';
             default:
-                return ': any';
+                throw new Error(`Tipo não reconhecido ou não suportado no AssemblyScript: '${tipo}'. AssemblyScript requer anotações de tipo explícitas.`);
         }
     }
     traduzirDeclaracaoVar(declaracaoVar) {
@@ -39495,7 +39749,8 @@ class TradutorAssemblyScript {
         return resultado;
     }
     traduzirDeclaracaoTente(declaracaoTente) {
-        let resultado = 'try {\n';
+        let resultado = '/* AVISO: AssemblyScript não suporta try/catch/finally. Este código pode não funcionar como esperado. */\n';
+        resultado += 'try {\n';
         this.indentacao += 4;
         resultado += ' '.repeat(this.indentacao);
         for (let condicao of declaracaoTente.caminhoTente) {
@@ -39531,6 +39786,81 @@ class TradutorAssemblyScript {
         }
         return resultado;
     }
+    traduzirDeclaracaoVarMultiplo(declaracaoVarMultiplo) {
+        const variaveis = declaracaoVarMultiplo.simbolos.map(s => s.lexema).join(', ');
+        let resultado = 'let ';
+        resultado += variaveis;
+        resultado += this.resolveTipoDeclaracaoVarEContante(declaracaoVarMultiplo.tipo);
+        if (!(declaracaoVarMultiplo === null || declaracaoVarMultiplo === void 0 ? void 0 : declaracaoVarMultiplo.inicializador))
+            resultado += ';';
+        else {
+            resultado += ' = ';
+            if (this.dicionarioConstrutos[declaracaoVarMultiplo.inicializador.constructor.name]) {
+                resultado += this.dicionarioConstrutos[declaracaoVarMultiplo.inicializador.constructor.name](declaracaoVarMultiplo.inicializador);
+            }
+            else {
+                resultado += this.dicionarioDeclaracoes[declaracaoVarMultiplo.inicializador.constructor.name](declaracaoVarMultiplo.inicializador);
+            }
+            resultado += ';';
+        }
+        return resultado;
+    }
+    traduzirDeclaracaoConstMultiplo(declaracaoConstMultiplo) {
+        const constantes = declaracaoConstMultiplo.simbolos.map(s => s.lexema).join(', ');
+        let resultado = 'const ';
+        resultado += constantes;
+        resultado += this.resolveTipoDeclaracaoVarEContante(declaracaoConstMultiplo.tipo);
+        if (!(declaracaoConstMultiplo === null || declaracaoConstMultiplo === void 0 ? void 0 : declaracaoConstMultiplo.inicializador))
+            resultado += ';';
+        else {
+            resultado += ' = ';
+            if (this.dicionarioConstrutos[declaracaoConstMultiplo.inicializador.constructor.name]) {
+                resultado += this.dicionarioConstrutos[declaracaoConstMultiplo.inicializador.constructor.name](declaracaoConstMultiplo.inicializador);
+            }
+            else {
+                resultado += this.dicionarioDeclaracoes[declaracaoConstMultiplo.inicializador.constructor.name](declaracaoConstMultiplo.inicializador);
+            }
+            resultado += ';';
+        }
+        return resultado;
+    }
+    traduzirDeclaracaoEscrevaMesmaLinha(declaracaoEscrevaMesmaLinha) {
+        let resultado = 'trace(';
+        for (const argumento of declaracaoEscrevaMesmaLinha.argumentos) {
+            const valor = this.dicionarioConstrutos[argumento.constructor.name](argumento);
+            resultado += valor + ', ';
+        }
+        resultado = resultado.slice(0, -2);
+        resultado += ')';
+        return resultado;
+    }
+    traduzirDeclaracaoTendoComo(declaracaoTendoComo) {
+        // TendoComo is a resource management pattern (like try-with-resources in Java)
+        // AssemblyScript doesn't have built-in support, so we'll just treat it as a scope
+        let resultado = `// tendo ${declaracaoTendoComo.simboloVariavel.lexema} como recurso\n`;
+        resultado += ' '.repeat(this.indentacao);
+        resultado += `let ${declaracaoTendoComo.simboloVariavel.lexema} = `;
+        if (this.dicionarioConstrutos[declaracaoTendoComo.inicializacaoVariavel.constructor.name]) {
+            resultado += this.dicionarioConstrutos[declaracaoTendoComo.inicializacaoVariavel.constructor.name](declaracaoTendoComo.inicializacaoVariavel);
+        }
+        else {
+            resultado += this.dicionarioDeclaracoes[declaracaoTendoComo.inicializacaoVariavel.constructor.name](declaracaoTendoComo.inicializacaoVariavel);
+        }
+        resultado += ';\n';
+        resultado += ' '.repeat(this.indentacao);
+        resultado += this.dicionarioDeclaracoes[declaracaoTendoComo.corpo.constructor.name](declaracaoTendoComo.corpo);
+        return resultado;
+    }
+    traduzirDeclaracaoAjuda(declaracaoAjuda) {
+        // Ajuda is a help/documentation statement
+        // In AssemblyScript, we'll just comment it out
+        return '// ajuda' + '\n';
+    }
+    traduzirDeclaracaoTextoDocumentacao(declaracaoTextoDoc) {
+        // TextoDocumentacao is documentation text
+        // We'll convert it to a comment
+        return `/** ${declaracaoTextoDoc} */\n`;
+    }
     logicaComumBlocoEscopo(declaracoes) {
         let resultado = '{\n';
         this.indentacao += 4;
@@ -39614,10 +39944,38 @@ class TradutorAssemblyScript {
         return (resultado += this.dicionarioConstrutos[nomeConstrutor](declaracaoRetorna === null || declaracaoRetorna === void 0 ? void 0 : declaracaoRetorna.valor));
     }
     traduzirDeclaracaoParaCada(declaracaoParaCada) {
-        let resultado = `for (let ${declaracaoParaCada.variavelIteracao} of `;
+        // AssemblyScript não suporta for...of. Convertendo para loop baseado em índice.
+        if (declaracaoParaCada.variavelIteracao.constructor.name !== 'Variavel') {
+            throw new Error('Desestruturação em paraCada não é suportada no AssemblyScript. Use uma variável simples.');
+        }
+        const nomeVariavel = declaracaoParaCada.variavelIteracao.simbolo.lexema;
+        const nomeVetor = `__arr_${nomeVariavel}`;
+        let resultado = `const ${nomeVetor} = `;
         resultado +=
-            this.dicionarioConstrutos[declaracaoParaCada.vetorOuDicionario.constructor.name](declaracaoParaCada.vetorOuDicionario) + ') ';
-        resultado += this.dicionarioDeclaracoes[declaracaoParaCada.corpo.constructor.name](declaracaoParaCada.corpo);
+            this.dicionarioConstrutos[declaracaoParaCada.vetorOuDicionario.constructor.name](declaracaoParaCada.vetorOuDicionario) + ';';
+        resultado += '\n';
+        resultado += ' '.repeat(this.indentacao);
+        resultado += `for (let __i_${nomeVariavel} = 0; __i_${nomeVariavel} < ${nomeVetor}.length; __i_${nomeVariavel}++) `;
+        // Injeta a atribuição da variável de iteração no início do corpo do bloco
+        const corpoBloco = declaracaoParaCada.corpo;
+        const declaracoesCorpo = corpoBloco.declaracoes || [];
+        let resultadoCorpo = '{\n';
+        this.indentacao += 4;
+        resultadoCorpo += ' '.repeat(this.indentacao) + `const ${nomeVariavel} = ${nomeVetor}[__i_${nomeVariavel}];\n`;
+        for (const declaracaoOuConstruto of declaracoesCorpo) {
+            resultadoCorpo += ' '.repeat(this.indentacao);
+            const nomeConstrutor = declaracaoOuConstruto.constructor.name;
+            if (this.dicionarioConstrutos.hasOwnProperty(nomeConstrutor)) {
+                resultadoCorpo += this.dicionarioConstrutos[nomeConstrutor](declaracaoOuConstruto);
+            }
+            else {
+                resultadoCorpo += this.dicionarioDeclaracoes[nomeConstrutor](declaracaoOuConstruto);
+            }
+            resultadoCorpo += '\n';
+        }
+        this.indentacao -= 4;
+        resultadoCorpo += ' '.repeat(this.indentacao) + '}\n';
+        resultado += resultadoCorpo;
         return resultado;
     }
     traduzirDeclaracaoPara(declaracaoPara) {
@@ -39646,19 +40004,89 @@ class TradutorAssemblyScript {
     }
     traduzirDeclaracaoFuncao(declaracaoFuncao) {
         let resultado = 'function ';
-        resultado += declaracaoFuncao.simbolo.lexema + ' (';
+        resultado += declaracaoFuncao.simbolo.lexema + '(';
+        // Adiciona parâmetros com tipos
         for (const parametro of declaracaoFuncao.funcao.parametros) {
-            resultado += parametro.nome.lexema + ', ';
+            resultado += parametro.nome.lexema;
+            // Adiciona tipo do parâmetro se disponível
+            if (parametro.tipoDado) {
+                try {
+                    resultado += this.resolveTipoDeclaracaoVarEContante(parametro.tipoDado);
+                }
+                catch (e) {
+                    // Se não conseguir resolver o tipo, lança erro mais específico
+                    throw new Error(`Parâmetro '${parametro.nome.lexema}' da função '${declaracaoFuncao.simbolo.lexema}' tem tipo não suportado: '${parametro.tipoDado}'`);
+                }
+            }
+            else {
+                // AssemblyScript requer tipos explícitos em todos os parâmetros
+                throw new Error(`Parâmetro '${parametro.nome.lexema}' da função '${declaracaoFuncao.simbolo.lexema}' não tem tipo definido. AssemblyScript requer tipos explícitos.`);
+            }
+            resultado += ', ';
         }
         if (declaracaoFuncao.funcao.parametros.length > 0) {
             resultado = resultado.slice(0, -2);
         }
-        resultado += ') ';
+        resultado += ')';
+        // Adiciona tipo de retorno
+        const tipoRetorno = this.inferirTipoRetornoFuncao(declaracaoFuncao.funcao);
+        resultado += tipoRetorno;
+        resultado += ' ';
         resultado += this.logicaComumBlocoEscopo(declaracaoFuncao.funcao.corpo);
         return resultado;
     }
+    inferirTipoRetornoFuncao(funcao) {
+        // Se a função tem tipo de retorno explícito, usa ele
+        if (funcao.tipo && funcao.tipo !== 'qualquer') {
+            try {
+                return this.resolveTipoDeclaracaoVarEContante(funcao.tipo);
+            }
+            catch (e) {
+                // Se não conseguir resolver, retorna void por padrão
+                return ': void';
+            }
+        }
+        // Procura por declarações de retorno no corpo e infere tipo a partir delas
+        const tipoInferido = this.inferirTipoDeRetorno(funcao.corpo);
+        if (tipoInferido) {
+            try {
+                return this.resolveTipoDeclaracaoVarEContante(tipoInferido);
+            }
+            catch (e) {
+                return ': void';
+            }
+        }
+        return ': void';
+    }
+    inferirTipoDeRetorno(corpo) {
+        if (!corpo)
+            return null;
+        for (const declaracao of corpo) {
+            if (declaracao.constructor.name === 'Retorna') {
+                const retorna = declaracao;
+                if (retorna.tipo && retorna.tipo !== 'vazio') {
+                    return retorna.tipo;
+                }
+            }
+            // Verifica recursivamente em blocos aninhados
+            if (declaracao.corpo) {
+                const corpoInterno = declaracao.corpo;
+                if (Array.isArray(corpoInterno)) {
+                    const tipo = this.inferirTipoDeRetorno(corpoInterno);
+                    if (tipo)
+                        return tipo;
+                }
+                else if (corpoInterno.declaracoes) {
+                    const tipo = this.inferirTipoDeRetorno(corpoInterno.declaracoes);
+                    if (tipo)
+                        return tipo;
+                }
+            }
+        }
+        return null;
+    }
     traduzirDeclaracaoFalhar(falhar) {
-        return `throw '${falhar.explicacao.valor}'`;
+        return `abort('${falhar.explicacao.valor}')`;
     }
     traduzirDeclaracaoFazer(declaracaoFazer) {
         let resultado = 'do ';
@@ -39737,6 +40165,146 @@ class TradutorAssemblyScript {
         resultado += ']';
         return resultado;
     }
+    traduzirConstrutoDicionario(dicionario) {
+        // AssemblyScript Maps são inicializados via construtor
+        // Map<K, V>() requer: new Map<string, ValueType>()
+        if (!dicionario.chaves.length) {
+            return 'new Map<string, i32>()';
+        }
+        // AssemblyScript não suporta literal syntax para Map, precisa usar constructor
+        // Gerar algo como: { let m = new Map<string, i32>(); m.set("key", value); ... return m; }
+        let resultado = '(() => { let m = new Map<string, i32>(); ';
+        for (let i = 0; i < dicionario.chaves.length; i++) {
+            const chave = dicionario.chaves[i];
+            const valor = dicionario.valores[i];
+            // A chave pode ser um Construto (como Literal) ou um valor simples
+            let chaveStr;
+            if (typeof chave === 'string') {
+                chaveStr = `"${chave}"`;
+            }
+            else if (chave && chave.constructor && this.dicionarioConstrutos[chave.constructor.name]) {
+                // Se for um Construto, traduzi-lo
+                chaveStr = this.dicionarioConstrutos[chave.constructor.name](chave);
+            }
+            else {
+                // Fallback: converter para string
+                chaveStr = `"${String(chave)}"`;
+            }
+            resultado += `m.set(${chaveStr}, ${this.dicionarioConstrutos[valor.constructor.name](valor)}); `;
+        }
+        resultado += 'return m; })()';
+        return resultado;
+    }
+    traduzirConstrutoDupla(dupla) {
+        const primeiro = this.dicionarioConstrutos[dupla.primeiro.constructor.name](dupla.primeiro);
+        const segundo = this.dicionarioConstrutos[dupla.segundo.constructor.name](dupla.segundo);
+        return `[${primeiro}, ${segundo}]`;
+    }
+    traduzirConstrutoTrio(trio) {
+        const primeiro = this.dicionarioConstrutos[trio.primeiro.constructor.name](trio.primeiro);
+        const segundo = this.dicionarioConstrutos[trio.segundo.constructor.name](trio.segundo);
+        const terceiro = this.dicionarioConstrutos[trio.terceiro.constructor.name](trio.terceiro);
+        return `[${primeiro}, ${segundo}, ${terceiro}]`;
+    }
+    traduzirConstrutoQuarteto(quarteto) {
+        const primeiro = this.dicionarioConstrutos[quarteto.primeiro.constructor.name](quarteto.primeiro);
+        const segundo = this.dicionarioConstrutos[quarteto.segundo.constructor.name](quarteto.segundo);
+        const terceiro = this.dicionarioConstrutos[quarteto.terceiro.constructor.name](quarteto.terceiro);
+        const quarto = this.dicionarioConstrutos[quarteto.quarto.constructor.name](quarteto.quarto);
+        return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}]`;
+    }
+    traduzirConstrutoQuinteto(quinteto) {
+        const primeiro = this.dicionarioConstrutos[quinteto.primeiro.constructor.name](quinteto.primeiro);
+        const segundo = this.dicionarioConstrutos[quinteto.segundo.constructor.name](quinteto.segundo);
+        const terceiro = this.dicionarioConstrutos[quinteto.terceiro.constructor.name](quinteto.terceiro);
+        const quarto = this.dicionarioConstrutos[quinteto.quarto.constructor.name](quinteto.quarto);
+        const quinto = this.dicionarioConstrutos[quinteto.quinto.constructor.name](quinteto.quinto);
+        return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}, ${quinto}]`;
+    }
+    traduzirConstrutoSexteto(sexteto) {
+        const primeiro = this.dicionarioConstrutos[sexteto.primeiro.constructor.name](sexteto.primeiro);
+        const segundo = this.dicionarioConstrutos[sexteto.segundo.constructor.name](sexteto.segundo);
+        const terceiro = this.dicionarioConstrutos[sexteto.terceiro.constructor.name](sexteto.terceiro);
+        const quarto = this.dicionarioConstrutos[sexteto.quarto.constructor.name](sexteto.quarto);
+        const quinto = this.dicionarioConstrutos[sexteto.quinto.constructor.name](sexteto.quinto);
+        const sexto = this.dicionarioConstrutos[sexteto.sexto.constructor.name](sexteto.sexto);
+        return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}, ${quinto}, ${sexto}]`;
+    }
+    traduzirConstrutoSepteto(septeto) {
+        const primeiro = this.dicionarioConstrutos[septeto.primeiro.constructor.name](septeto.primeiro);
+        const segundo = this.dicionarioConstrutos[septeto.segundo.constructor.name](septeto.segundo);
+        const terceiro = this.dicionarioConstrutos[septeto.terceiro.constructor.name](septeto.terceiro);
+        const quarto = this.dicionarioConstrutos[septeto.quarto.constructor.name](septeto.quarto);
+        const quinto = this.dicionarioConstrutos[septeto.quinto.constructor.name](septeto.quinto);
+        const sexto = this.dicionarioConstrutos[septeto.sexto.constructor.name](septeto.sexto);
+        const setimo = this.dicionarioConstrutos[septeto.setimo.constructor.name](septeto.setimo);
+        return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}, ${quinto}, ${sexto}, ${setimo}]`;
+    }
+    traduzirConstrutoOcteto(octeto) {
+        const primeiro = this.dicionarioConstrutos[octeto.primeiro.constructor.name](octeto.primeiro);
+        const segundo = this.dicionarioConstrutos[octeto.segundo.constructor.name](octeto.segundo);
+        const terceiro = this.dicionarioConstrutos[octeto.terceiro.constructor.name](octeto.terceiro);
+        const quarto = this.dicionarioConstrutos[octeto.quarto.constructor.name](octeto.quarto);
+        const quinto = this.dicionarioConstrutos[octeto.quinto.constructor.name](octeto.quinto);
+        const sexto = this.dicionarioConstrutos[octeto.sexto.constructor.name](octeto.sexto);
+        const setimo = this.dicionarioConstrutos[octeto.setimo.constructor.name](octeto.setimo);
+        const oitavo = this.dicionarioConstrutos[octeto.oitavo.constructor.name](octeto.oitavo);
+        return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}, ${quinto}, ${sexto}, ${setimo}, ${oitavo}]`;
+    }
+    traduzirConstrutoNoneto(noneto) {
+        const primeiro = this.dicionarioConstrutos[noneto.primeiro.constructor.name](noneto.primeiro);
+        const segundo = this.dicionarioConstrutos[noneto.segundo.constructor.name](noneto.segundo);
+        const terceiro = this.dicionarioConstrutos[noneto.terceiro.constructor.name](noneto.terceiro);
+        const quarto = this.dicionarioConstrutos[noneto.quarto.constructor.name](noneto.quarto);
+        const quinto = this.dicionarioConstrutos[noneto.quinto.constructor.name](noneto.quinto);
+        const sexto = this.dicionarioConstrutos[noneto.sexto.constructor.name](noneto.sexto);
+        const setimo = this.dicionarioConstrutos[noneto.setimo.constructor.name](noneto.setimo);
+        const oitavo = this.dicionarioConstrutos[noneto.oitavo.constructor.name](noneto.oitavo);
+        const nono = this.dicionarioConstrutos[noneto.nono.constructor.name](noneto.nono);
+        return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}, ${quinto}, ${sexto}, ${setimo}, ${oitavo}, ${nono}]`;
+    }
+    traduzirConstrutoDeceto(deceto) {
+        const primeiro = this.dicionarioConstrutos[deceto.primeiro.constructor.name](deceto.primeiro);
+        const segundo = this.dicionarioConstrutos[deceto.segundo.constructor.name](deceto.segundo);
+        const terceiro = this.dicionarioConstrutos[deceto.terceiro.constructor.name](deceto.terceiro);
+        const quarto = this.dicionarioConstrutos[deceto.quarto.constructor.name](deceto.quarto);
+        const quinto = this.dicionarioConstrutos[deceto.quinto.constructor.name](deceto.quinto);
+        const sexto = this.dicionarioConstrutos[deceto.sexto.constructor.name](deceto.sexto);
+        const setimo = this.dicionarioConstrutos[deceto.setimo.constructor.name](deceto.setimo);
+        const oitavo = this.dicionarioConstrutos[deceto.oitavo.constructor.name](deceto.oitavo);
+        const nono = this.dicionarioConstrutos[deceto.nono.constructor.name](deceto.nono);
+        const decimo = this.dicionarioConstrutos[deceto.decimo.constructor.name](deceto.decimo);
+        return `[${primeiro}, ${segundo}, ${terceiro}, ${quarto}, ${quinto}, ${sexto}, ${setimo}, ${oitavo}, ${nono}, ${decimo}]`;
+    }
+    traduzirConstrutoTuplaN(tuplaN) {
+        const elementos = tuplaN.elementos.map(elemento => this.dicionarioConstrutos[elemento.constructor.name](elemento));
+        return `[${elementos.join(', ')}]`;
+    }
+    traduzirConstrutoSeTernario(seTernario) {
+        const condicao = this.dicionarioConstrutos[seTernario.condicao.constructor.name](seTernario.condicao);
+        const expressaoSe = this.dicionarioConstrutos[seTernario.expressaoSe.constructor.name](seTernario.expressaoSe);
+        const expressaoSenao = this.dicionarioConstrutos[seTernario.expressaoSenao.constructor.name](seTernario.expressaoSenao);
+        return `${condicao} ? ${expressaoSe} : ${expressaoSenao}`;
+    }
+    traduzirConstrutoElvis(elvis) {
+        const esquerda = this.dicionarioConstrutos[elvis.esquerda.constructor.name](elvis.esquerda);
+        const direita = this.dicionarioConstrutos[elvis.direita.constructor.name](elvis.direita);
+        // Elvis operator (?:) is equivalent to || in JavaScript for null-coalescing
+        return `${esquerda} || ${direita}`;
+    }
+    traduzirConstrutoAcessoPropriedade(acessoPropriedade) {
+        const objeto = this.dicionarioConstrutos[acessoPropriedade.objeto.constructor.name](acessoPropriedade.objeto);
+        return `${objeto}.${acessoPropriedade.nomePropriedade}`;
+    }
+    traduzirConstrutoExpressaoRegular(expressaoRegular) {
+        // AssemblyScript doesn't have native regex support like JavaScript
+        // Return the pattern as a string for now
+        const valor = expressaoRegular.valor;
+        if (typeof valor === 'string') {
+            return `"${valor}"`;
+        }
+        return String(valor);
+    }
     traduzirConstrutoVariavel(variavel) {
         return variavel.simbolo.lexema;
     }
@@ -39754,20 +40322,13 @@ class TradutorAssemblyScript {
         return resultado;
     }
     traduzirConstrutoTipoDe(tipoDe) {
-        let resultado = 'typeof ';
-        if (typeof tipoDe.valor === 'string')
-            resultado += `'${tipoDe.valor}'`;
-        else if (tipoDe.valor instanceof construtos_1.Vetor)
-            resultado += this.traduzirConstrutoVetor(tipoDe.valor);
-        else
-            resultado += this.dicionarioConstrutos[tipoDe.valor.constructor.name](tipoDe.valor);
-        return resultado;
+        throw new Error('O operador typeof não é suportado no AssemblyScript. Use verificações de tipo em tempo de compilação como instanceof ou is<T>() em vez disso.');
     }
     traduzirConstrutoLogico(logico) {
-        let direita = this.dicionarioConstrutos[logico.direita.constructor.name](logico.direita);
-        let operador = this.traduzirSimboloOperador(logico.operador);
         let esquerda = this.dicionarioConstrutos[logico.esquerda.constructor.name](logico.esquerda);
-        return `${direita} ${operador} ${esquerda}`;
+        let operador = this.traduzirSimboloOperador(logico.operador);
+        let direita = this.dicionarioConstrutos[logico.direita.constructor.name](logico.direita);
+        return `${esquerda} ${operador} ${direita}`;
     }
     traduzirFuncaoConstruto(funcaoConstruto) {
         let resultado = 'function(';
@@ -39792,6 +40353,15 @@ class TradutorAssemblyScript {
     }
     traduzirConstrutoChamada(chamada) {
         let resultado = '';
+        // Check if this is a native library function call
+        if (chamada.entidadeChamada instanceof construtos_1.Variavel) {
+            const nomeVariavel = chamada.entidadeChamada.simbolo.lexema;
+            const argumentosTexto = chamada.argumentos.map(arg => this.dicionarioConstrutos[arg.constructor.name](arg));
+            const funcaoNativa = this.traduzirFuncaoNativaGlobal(nomeVariavel, argumentosTexto);
+            if (funcaoNativa) {
+                return funcaoNativa;
+            }
+        }
         const retorno = `${this.dicionarioConstrutos[chamada.entidadeChamada.constructor.name](chamada.entidadeChamada, chamada.argumentos)}`;
         const instanciaClasse = this.declaracoesDeClasses.some((declaracao) => { var _a; return ((_a = declaracao === null || declaracao === void 0 ? void 0 : declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) === retorno; });
         if (instanciaClasse) {
@@ -39827,6 +40397,12 @@ class TradutorAssemblyScript {
         return resultado;
     }
     traduzirConstrutoBinario(binario) {
+        // Tratamento especial para exponenciação no AssemblyScript
+        if (binario.operador.tipo === delegua_1.default.EXPONENCIACAO) {
+            const esquerda = this.dicionarioConstrutos[binario.esquerda.constructor.name](binario.esquerda);
+            const direita = this.dicionarioConstrutos[binario.direita.constructor.name](binario.direita);
+            return `Math.pow(${esquerda}, ${direita})`;
+        }
         let resultado = '';
         if (binario.esquerda.constructor.name === 'Agrupamento')
             resultado +=
@@ -39852,16 +40428,23 @@ class TradutorAssemblyScript {
             ' = ' + this.dicionarioConstrutos[atribuir.valor.constructor.name](atribuir.valor);
         return resultado;
     }
-    // TODO: Eliminar o soft cast para `any`.
     traduzirConstrutoAtribuicaoPorIndice(AtribuicaoPorIndice) {
-        var _a;
         let resultado = '';
-        resultado += AtribuicaoPorIndice.objeto.simbolo.lexema + '[';
+        // Traduz o objeto (array ou coleção)
+        if (AtribuicaoPorIndice.objeto instanceof construtos_1.Variavel) {
+            resultado += AtribuicaoPorIndice.objeto.simbolo.lexema;
+        }
+        else {
+            resultado += this.dicionarioConstrutos[AtribuicaoPorIndice.objeto.constructor.name](AtribuicaoPorIndice.objeto);
+        }
+        // Adiciona o índice
+        resultado += '[';
         resultado +=
             this.dicionarioConstrutos[AtribuicaoPorIndice.indice.constructor.name](AtribuicaoPorIndice.indice) + ']';
         resultado += ' = ';
-        if ((_a = (AtribuicaoPorIndice === null || AtribuicaoPorIndice === void 0 ? void 0 : AtribuicaoPorIndice.valor).simbolo) === null || _a === void 0 ? void 0 : _a.lexema) {
-            resultado += `${AtribuicaoPorIndice.valor.simbolo.lexema}`;
+        // Traduz o valor a ser atribuído
+        if (AtribuicaoPorIndice.valor instanceof construtos_1.Variavel) {
+            resultado += AtribuicaoPorIndice.valor.simbolo.lexema;
         }
         else {
             resultado += this.dicionarioConstrutos[AtribuicaoPorIndice.valor.constructor.name](AtribuicaoPorIndice.valor);