@semacode/cli 1.5.16 → 1.5.18

package/node_modules/@sema/nucleo/dist/parser/parser.js

@@ -0,0 +1,767 @@
+import { criarDiagnostico, } from "../diagnosticos/index.js";
+const PALAVRAS_BLOCO_NOMEADO_LIVRE = new Set([
+    "table",
+    "view",
+    "query",
+    "transaction",
+    "index",
+    "constraint",
+    "relationship",
+    "collection",
+    "document",
+    "keyspace",
+    "stream",
+    "lock",
+    "retention",
+    "replication",
+]);
+function decodificarTextoLiteral(valor) {
+    let resultado = "";
+    for (let indice = 0; indice < valor.length; indice += 1) {
+        const atual = valor[indice];
+        if (atual !== "\\") {
+            resultado += atual;
+            continue;
+        }
+        const proximo = valor[indice + 1];
+        if (!proximo) {
+            resultado += atual;
+            continue;
+        }
+        switch (proximo) {
+            case "\"":
+                resultado += "\"";
+                indice += 1;
+                break;
+            case "\\":
+                resultado += "\\";
+                indice += 1;
+                break;
+            case "n":
+                resultado += "\n";
+                indice += 1;
+                break;
+            case "r":
+                resultado += "\r";
+                indice += 1;
+                break;
+            case "t":
+                resultado += "\t";
+                indice += 1;
+                break;
+            default:
+                resultado += `${atual}${proximo}`;
+                indice += 1;
+                break;
+        }
+    }
+    return resultado;
+}
+class Parser {
+    tokens;
+    indice = 0;
+    diagnosticos = [];
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    analisar() {
+        this.ignorarRuido();
+        const modulo = this.parseModulo();
+        return { modulo, diagnosticos: this.diagnosticos };
+    }
+    atual() {
+        return this.tokens[this.indice];
+    }
+    anterior() {
+        return this.tokens[Math.max(0, this.indice - 1)];
+    }
+    avancar() {
+        const token = this.atual();
+        if (this.indice < this.tokens.length - 1) {
+            this.indice += 1;
+        }
+        return token;
+    }
+    ignorarRuido() {
+        while (["nova_linha", "comentario"].includes(this.atual().tipo)) {
+            this.avancar();
+        }
+    }
+    tokenNaFrente(distancia = 1) {
+        return this.tokens[this.indice + distancia];
+    }
+    iniciaBlocoSimples(keyword) {
+        if (this.atual().valor !== keyword) {
+            return false;
+        }
+        return this.tokenNaFrente()?.valor === "{";
+    }
+    iniciaBlocoComNomeObrigatorio(keyword) {
+        if (this.atual().valor !== keyword) {
+            return false;
+        }
+        return this.tokenNaFrente()?.tipo === "identificador" && this.tokenNaFrente(2)?.valor === "{";
+    }
+    iniciaBlocoState() {
+        if (this.atual().valor !== "state") {
+            return false;
+        }
+        return this.tokenNaFrente()?.valor === "{"
+            || (this.tokenNaFrente()?.tipo === "identificador" && this.tokenNaFrente(2)?.valor === "{");
+    }
+    iniciaSubblocoConhecido() {
+        if (this.atual().tipo !== "palavra_chave") {
+            return false;
+        }
+        if (["state"].includes(this.atual().valor)) {
+            return this.iniciaBlocoState();
+        }
+        return [
+            "docs",
+            "comments",
+            "fields",
+            "invariants",
+            "transitions",
+            "input",
+            "output",
+            "rules",
+            "effects",
+            "impl",
+            "vinculos",
+            "execucao",
+            "auth",
+            "authz",
+            "dados",
+            "audit",
+            "segredos",
+            "forbidden",
+            "guarantees",
+            "tests",
+            "error",
+            "given",
+            "when",
+            "expect",
+        ].includes(this.atual().valor) && this.iniciaBlocoSimples(this.atual().valor);
+    }
+    consumirValor(valor, mensagem) {
+        const token = this.atual();
+        if (token.valor === valor) {
+            this.avancar();
+            return token;
+        }
+        this.registrarErro("PAR001", mensagem, token.intervalo, `Esperado "${valor}", recebido "${token.valor}".`);
+        return token;
+    }
+    consumirTipo(tipo, mensagem) {
+        const token = this.atual();
+        if (token.tipo === tipo) {
+            this.avancar();
+            return token;
+        }
+        this.registrarErro("PAR002", mensagem, token.intervalo, `Esperado token do tipo "${tipo}".`);
+        return token;
+    }
+    registrarErro(codigo, mensagem, intervalo, contexto) {
+        this.diagnosticos.push(criarDiagnostico(codigo, mensagem, "erro", intervalo, "Revise a sintaxe do bloco e a ordem das declaracoes.", contexto));
+    }
+    parseModulo() {
+        if (this.atual().valor !== "module") {
+            this.registrarErro("PAR003", "Arquivo .sema deve iniciar com um bloco module.", this.atual().intervalo);
+            return undefined;
+        }
+        const inicio = this.avancar().intervalo.inicio;
+        const nome = this.consumirTipo("identificador", "Era esperado o nome do modulo.").valor;
+        this.consumirValor("{", "Era esperado abrir o corpo do modulo com {.");
+        const uses = [];
+        let vinculos;
+        const databases = [];
+        const types = [];
+        const entities = [];
+        const enums = [];
+        const tasks = [];
+        const flows = [];
+        const routes = [];
+        const workers = [];
+        const eventos = [];
+        const filas = [];
+        const crons = [];
+        const webhooks = [];
+        const caches = [];
+        const storages = [];
+        const policies = [];
+        const states = [];
+        const extras = [];
+        let docs;
+        let comments;
+        let tests;
+        while (this.atual().tipo !== "fim_arquivo" && this.atual().valor !== "}") {
+            this.ignorarRuido();
+            const token = this.atual();
+            if (token.valor === "}") {
+                break;
+            }
+            switch (token.valor) {
+                case "use":
+                    if (this.tokenNaFrente()?.tipo === "identificador") {
+                        uses.push(this.parseUse());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "docs":
+                    if (this.iniciaBlocoSimples("docs")) {
+                        docs = this.parseBlocoGenerico("docs");
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "comments":
+                    if (this.iniciaBlocoSimples("comments")) {
+                        comments = this.parseBlocoGenerico("comments");
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "vinculos":
+                    if (this.iniciaBlocoSimples("vinculos")) {
+                        vinculos = this.parseBlocoGenerico("vinculos");
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "database":
+                    if (this.iniciaBlocoComNomeObrigatorio("database")) {
+                        databases.push(this.parseBlocoGenerico("database"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "type":
+                    if (this.iniciaBlocoComNomeObrigatorio("type")) {
+                        types.push(this.parseType());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "entity":
+                    if (this.iniciaBlocoComNomeObrigatorio("entity")) {
+                        entities.push(this.parseEntity());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "enum":
+                    if (this.iniciaBlocoComNomeObrigatorio("enum")) {
+                        enums.push(this.parseEnum());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "task":
+                    if (this.iniciaBlocoComNomeObrigatorio("task")) {
+                        tasks.push(this.parseTask());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "flow":
+                    if (this.iniciaBlocoComNomeObrigatorio("flow")) {
+                        flows.push(this.parseFlow());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "route":
+                    if (this.iniciaBlocoComNomeObrigatorio("route")) {
+                        routes.push(this.parseRoute());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "worker":
+                    if (this.iniciaBlocoComNomeObrigatorio("worker")) {
+                        workers.push(this.parseBlocoGenerico("worker"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "evento":
+                    if (this.iniciaBlocoComNomeObrigatorio("evento")) {
+                        eventos.push(this.parseBlocoGenerico("evento"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "fila":
+                    if (this.iniciaBlocoComNomeObrigatorio("fila")) {
+                        filas.push(this.parseBlocoGenerico("fila"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "cron":
+                    if (this.iniciaBlocoComNomeObrigatorio("cron")) {
+                        crons.push(this.parseBlocoGenerico("cron"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "webhook":
+                    if (this.iniciaBlocoComNomeObrigatorio("webhook")) {
+                        webhooks.push(this.parseBlocoGenerico("webhook"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "cache":
+                    if (this.iniciaBlocoComNomeObrigatorio("cache")) {
+                        caches.push(this.parseBlocoGenerico("cache"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "storage":
+                    if (this.iniciaBlocoComNomeObrigatorio("storage")) {
+                        storages.push(this.parseBlocoGenerico("storage"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "policy":
+                    if (this.iniciaBlocoComNomeObrigatorio("policy")) {
+                        policies.push(this.parseBlocoGenerico("policy"));
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "state":
+                    if (this.iniciaBlocoState()) {
+                        states.push(this.parseState());
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                case "tests":
+                    if (this.iniciaBlocoSimples("tests")) {
+                        tests = this.parseBlocoGenerico("tests");
+                        break;
+                    }
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+                default:
+                    extras.push(this.parseBlocoGenerico("desconhecido"));
+                    break;
+            }
+            this.ignorarRuido();
+        }
+        const fim = this.consumirValor("}", "Era esperado fechar o bloco module com }.").intervalo.fim;
+        return {
+            tipo: "module",
+            nome,
+            uses,
+            vinculos,
+            docs,
+            comments,
+            databases,
+            types,
+            entities,
+            enums,
+            tasks,
+            flows,
+            routes,
+            workers,
+            eventos,
+            filas,
+            crons,
+            webhooks,
+            caches,
+            storages,
+            policies,
+            states,
+            tests,
+            extras,
+            intervalo: { inicio, fim },
+        };
+    }
+    parseUse() {
+        const inicio = this.avancar().intervalo.inicio;
+        const primeiro = this.consumirTipo("identificador", "Era esperado o caminho do use.");
+        let origem = "sema";
+        let caminho = primeiro.valor;
+        const origemNormalizada = normalizarOrigemUse(primeiro.valor);
+        if (origemNormalizada && this.atual().tipo === "identificador") {
+            origem = origemNormalizada;
+            caminho = this.avancar().valor;
+        }
+        const fim = this.anterior().intervalo.fim;
+        return { tipo: "use", origem, caminho, intervalo: { inicio, fim } };
+    }
+    parseType() {
+        const inicio = this.avancar().intervalo.inicio;
+        const nome = this.consumirTipo("identificador", "Era esperado o nome do type.").valor;
+        const corpo = this.parseBlocoComNomeOpcional("type");
+        return { tipo: "type", nome, corpo, intervalo: { inicio, fim: corpo.intervalo?.fim ?? this.anterior().intervalo.fim } };
+    }
+    parseEntity() {
+        const inicio = this.avancar().intervalo.inicio;
+        const nome = this.consumirTipo("identificador", "Era esperado o nome da entity.").valor;
+        const corpo = this.parseBlocoComNomeOpcional("entity");
+        return { tipo: "entity", nome, corpo, intervalo: { inicio, fim: corpo.intervalo?.fim ?? this.anterior().intervalo.fim } };
+    }
+    parseEnum() {
+        const inicio = this.avancar().intervalo.inicio;
+        const nome = this.consumirTipo("identificador", "Era esperado o nome do enum.").valor;
+        this.consumirValor("{", "Era esperado abrir o corpo do enum.");
+        const valores = [];
+        let docs;
+        while (this.atual().tipo !== "fim_arquivo" && this.atual().valor !== "}") {
+            this.ignorarRuido();
+            if (this.atual().valor === "}") {
+                break;
+            }
+            if (this.atual().valor === "docs") {
+                docs = this.parseBlocoGenerico("docs");
+                continue;
+            }
+            if (["identificador", "palavra_chave"].includes(this.atual().tipo)) {
+                valores.push(this.avancar().valor);
+                if (this.atual().valor === ",") {
+                    this.avancar();
+                }
+                continue;
+            }
+            this.avancar();
+        }
+        const fim = this.consumirValor("}", "Era esperado fechar o enum.").intervalo.fim;
+        return { tipo: "enum", nome, valores, docs, intervalo: { inicio, fim } };
+    }
+    parseTask() {
+        const inicio = this.avancar().intervalo.inicio;
+        const nome = this.consumirTipo("identificador", "Era esperado o nome da task.").valor;
+        const corpo = this.parseBlocoComNomeOpcional("task");
+        const localizar = (palavraChave) => corpo.blocos.find((bloco) => bloco.tipo === "bloco_generico" && bloco.palavraChave === palavraChave);
+        return {
+            tipo: "task",
+            nome,
+            corpo,
+            input: localizar("input"),
+            output: localizar("output"),
+            rules: localizar("rules"),
+            effects: localizar("effects"),
+            impl: localizar("impl"),
+            vinculos: localizar("vinculos"),
+            execucao: localizar("execucao"),
+            auth: localizar("auth"),
+            authz: localizar("authz"),
+            dados: localizar("dados"),
+            audit: localizar("audit"),
+            segredos: localizar("segredos"),
+            forbidden: localizar("forbidden"),
+            guarantees: localizar("guarantees"),
+            state: localizar("state"),
+            tests: localizar("tests"),
+            error: localizar("error"),
+            docs: localizar("docs"),
+            comments: localizar("comments"),
+            intervalo: { inicio, fim: corpo.intervalo?.fim ?? this.anterior().intervalo.fim },
+        };
+    }
+    parseFlow() {
+        const inicio = this.avancar().intervalo.inicio;
+        const nome = this.consumirTipo("identificador", "Era esperado o nome do flow.").valor;
+        const corpo = this.parseBlocoComNomeOpcional("flow");
+        const vinculos = corpo.blocos.find((bloco) => bloco.tipo === "bloco_generico" && bloco.palavraChave === "vinculos");
+        return { tipo: "flow", nome, corpo, vinculos, intervalo: { inicio, fim: corpo.intervalo?.fim ?? this.anterior().intervalo.fim } };
+    }
+    parseRoute() {
+        const inicio = this.avancar().intervalo.inicio;
+        const nome = this.consumirTipo("identificador", "Era esperado o nome da route.").valor;
+        const corpo = this.parseBlocoComNomeOpcional("route");
+        const vinculos = corpo.blocos.find((bloco) => bloco.tipo === "bloco_generico" && bloco.palavraChave === "vinculos");
+        return { tipo: "route", nome, corpo, vinculos, intervalo: { inicio, fim: corpo.intervalo?.fim ?? this.anterior().intervalo.fim } };
+    }
+    parseState() {
+        const inicioToken = this.avancar();
+        let nome;
+        if (this.atual().tipo === "identificador") {
+            nome = this.avancar().valor;
+        }
+        this.consumirValor("{", "Era esperado abrir o bloco state.");
+        const corpo = this.parseCorpoBloco("state", nome, inicioToken.intervalo.inicio);
+        return {
+            tipo: "state",
+            nome,
+            corpo,
+            intervalo: { inicio: inicioToken.intervalo.inicio, fim: corpo.intervalo?.fim ?? this.anterior().intervalo.fim },
+        };
+    }
+    parseBlocoComNomeOpcional(nomeBloco) {
+        this.consumirValor("{", `Era esperado abrir o bloco ${nomeBloco}.`);
+        return this.parseCorpoBloco(nomeBloco);
+    }
+    parseBlocoGenerico(palavraChave) {
+        const inicioToken = this.avancar();
+        let nome;
+        if (this.atual().tipo === "identificador") {
+            nome = this.avancar().valor;
+        }
+        this.consumirValor("{", `Era esperado abrir o bloco ${inicioToken.valor}.`);
+        return this.parseCorpoBloco((palavraChave === "desconhecido" ? "desconhecido" : inicioToken.valor), nome, inicioToken.intervalo.inicio);
+    }
+    parseBlocoNomeadoLivre() {
+        const inicioToken = this.avancar();
+        const nome = inicioToken.valor;
+        this.consumirValor("{", `Era esperado abrir o bloco ${nome}.`);
+        return this.parseCorpoBloco("desconhecido", nome, inicioToken.intervalo.inicio);
+    }
+    parseBlocoNomeadoComPalavraChaveLivre() {
+        const palavraChaveToken = this.avancar();
+        const nomeToken = this.avancar();
+        this.consumirValor("{", `Era esperado abrir o bloco ${palavraChaveToken.valor} ${nomeToken.valor}.`);
+        return this.parseCorpoBloco(palavraChaveToken.valor, nomeToken.valor, palavraChaveToken.intervalo.inicio);
+    }
+    parseCorpoBloco(palavraChave, nome, inicioManual) {
+        const inicio = inicioManual ?? this.anterior().intervalo.inicio;
+        const campos = [];
+        const linhas = [];
+        const blocos = [];
+        while (this.atual().tipo !== "fim_arquivo" && this.atual().valor !== "}") {
+            this.ignorarRuido();
+            if (this.atual().valor === "}") {
+                break;
+            }
+            if (palavraChave === "tests" && this.atual().valor === "caso") {
+                blocos.push(this.parseCasoTeste());
+                continue;
+            }
+            if (this.iniciaSubblocoConhecido()) {
+                blocos.push(this.parseBlocoGenerico(this.atual().valor));
+                continue;
+            }
+            if (["identificador", "palavra_chave"].includes(this.atual().tipo)
+                && PALAVRAS_BLOCO_NOMEADO_LIVRE.has(this.atual().valor)
+                && ["identificador", "palavra_chave"].includes(this.tokens[this.indice + 1]?.tipo ?? "")
+                && this.tokens[this.indice + 2]?.valor === "{") {
+                blocos.push(this.parseBlocoNomeadoComPalavraChaveLivre());
+                continue;
+            }
+            if (["identificador", "palavra_chave"].includes(this.atual().tipo) && this.tokens[this.indice + 1]?.valor === "{") {
+                blocos.push(this.parseBlocoNomeadoLivre());
+                continue;
+            }
+            if (["identificador", "palavra_chave"].includes(this.atual().tipo) && this.tokens[this.indice + 1]?.valor === ":") {
+                campos.push(this.parseCampo());
+                continue;
+            }
+            const linha = this.parseLinhaDeclarativa();
+            if (linha.conteudo.trim().length > 0) {
+                linhas.push(linha);
+            }
+        }
+        const fim = this.consumirValor("}", "Era esperado fechar o bloco com }.").intervalo.fim;
+        return {
+            tipo: "bloco_generico",
+            palavraChave,
+            nome,
+            campos,
+            linhas,
+            blocos,
+            intervalo: { inicio, fim },
+        };
+    }
+    parseCampo() {
+        const inicio = this.atual().intervalo.inicio;
+        const nome = this.avancar().valor;
+        this.consumirValor(":", "Era esperado ':' depois do nome do campo.");
+        const partes = [];
+        let profundidade = 0;
+        while (this.atual().tipo !== "fim_arquivo" && this.atual().tipo !== "nova_linha" && this.atual().valor !== "}") {
+            const proximoToken = this.tokens[this.indice + 1];
+            const iniciaNovoCampo = profundidade === 0
+                && partes.length > 0
+                && ["identificador", "palavra_chave"].includes(this.atual().tipo)
+                && proximoToken?.valor === ":";
+            if (iniciaNovoCampo) {
+                break;
+            }
+            const token = this.avancar();
+            partes.push(token);
+            if (["<", "[", "("].includes(token.valor)) {
+                profundidade += 1;
+            }
+            else if ([">", "]", ")"].includes(token.valor)) {
+                profundidade = Math.max(0, profundidade - 1);
+            }
+        }
+        const segmentos = partes.filter((token) => token.valor.length > 0);
+        const possuiTextoLiteral = segmentos.some((token) => token.tipo === "texto");
+        if (possuiTextoLiteral) {
+            const valorLiteral = segmentos.map((token) => token.tipo === "texto" ? decodificarTextoLiteral(token.valor) : token.valor).join(" ");
+            if (this.atual().tipo === "nova_linha") {
+                this.avancar();
+            }
+            return {
+                tipo: "campo",
+                nome,
+                valor: valorLiteral,
+                modificadores: [],
+                intervalo: { inicio, fim: this.anterior().intervalo.fim },
+            };
+        }
+        const tipoTokens = [];
+        const modificadores = [];
+        let profundidadeTipo = 0;
+        let iniciouModificadores = false;
+        for (const token of segmentos) {
+            const segmento = token.valor;
+            if (!iniciouModificadores) {
+                if (["<", "[", "("].includes(segmento)) {
+                    profundidadeTipo += 1;
+                    tipoTokens.push(segmento);
+                    continue;
+                }
+                if ([">", "]", ")"].includes(segmento)) {
+                    profundidadeTipo = Math.max(0, profundidadeTipo - 1);
+                    tipoTokens.push(segmento);
+                    continue;
+                }
+                const pareceModificador = profundidadeTipo === 0
+                    && tipoTokens.length > 0
+                    && /^[a-z_][a-z0-9_]*$/u.test(segmento);
+                if (pareceModificador) {
+                    iniciouModificadores = true;
+                    modificadores.push(segmento);
+                    continue;
+                }
+                tipoTokens.push(segmento);
+                continue;
+            }
+            modificadores.push(segmento);
+        }
+        let valor = tipoTokens
+            .join(" ")
+            .replace(/\s*([<>\[\](),|?])\s*/g, "$1")
+            .trim();
+        if (valor.includes("/")) {
+            valor = valor.replace(/\s*\/\s*/g, "/");
+        }
+        if (this.atual().tipo === "nova_linha") {
+            this.avancar();
+        }
+        return {
+            tipo: "campo",
+            nome,
+            valor,
+            modificadores,
+            intervalo: { inicio, fim: this.anterior().intervalo.fim },
+        };
+    }
+    parseLinhaDeclarativa() {
+        const inicio = this.atual().intervalo.inicio;
+        const partes = [];
+        while (this.atual().tipo !== "fim_arquivo" && this.atual().tipo !== "nova_linha" && this.atual().valor !== "}") {
+            partes.push(this.avancar().valor);
+        }
+        if (this.atual().tipo === "nova_linha") {
+            this.avancar();
+        }
+        return {
+            tipo: "linha_declarativa",
+            conteudo: partes.join(" ").trim(),
+            intervalo: { inicio, fim: this.anterior().intervalo.fim },
+        };
+    }
+    parseCasoTeste() {
+        const inicio = this.avancar().intervalo.inicio;
+        const nomeToken = this.atual();
+        const nome = nomeToken.tipo === "texto"
+            ? this.avancar().valor
+            : this.consumirTipo("identificador", "Era esperado o nome textual do caso de teste.").valor;
+        this.consumirValor("{", "Era esperado abrir o bloco do caso de teste.");
+        let given;
+        let when;
+        let expect;
+        let error;
+        let docs;
+        let comments;
+        while (this.atual().tipo !== "fim_arquivo" && this.atual().valor !== "}") {
+            this.ignorarRuido();
+            if (this.atual().valor === "}") {
+                break;
+            }
+            switch (this.atual().valor) {
+                case "given":
+                    given = this.parseBlocoGenerico("given");
+                    break;
+                case "when":
+                    when = this.parseBlocoGenerico("when");
+                    break;
+                case "expect":
+                    expect = this.parseBlocoGenerico("expect");
+                    break;
+                case "error":
+                    error = this.parseBlocoGenerico("error");
+                    break;
+                case "docs":
+                    docs = this.parseBlocoGenerico("docs");
+                    break;
+                case "comments":
+                    comments = this.parseBlocoGenerico("comments");
+                    break;
+                default:
+                    this.avancar();
+                    break;
+            }
+        }
+        const fim = this.consumirValor("}", "Era esperado fechar o caso de teste.").intervalo.fim;
+        return {
+            tipo: "caso_teste",
+            nome,
+            given,
+            when,
+            expect,
+            error,
+            docs,
+            comments,
+            intervalo: { inicio, fim },
+        };
+    }
+}
+function normalizarOrigemUse(valor) {
+    switch (valor.toLowerCase()) {
+        case "sema":
+            return "sema";
+        case "ts":
+        case "typescript":
+            return "ts";
+        case "py":
+        case "python":
+            return "py";
+        case "dart":
+            return "dart";
+        case "cs":
+        case "csharp":
+        case "dotnet":
+            return "cs";
+        case "java":
+            return "java";
+        case "go":
+        case "golang":
+            return "go";
+        case "rust":
+        case "rs":
+            return "rust";
+        case "cpp":
+        case "cxx":
+        case "cc":
+        case "c++":
+            return "cpp";
+        default:
+            return undefined;
+    }
+}
+export function parsear(tokens) {
+    const parser = new Parser(tokens);
+    return parser.analisar();
+}
+//# sourceMappingURL=parser.js.map