@designliquido/delegua-node 1.16.1 → 1.17.0

package/bibliotecas/dialetos/portugol-studio/graficos.js

@@ -0,0 +1,642 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Graficos = exports.ErroExcessoOperacoes = exports.CANAL_B = exports.CANAL_G = exports.CANAL_R = exports.GRADIENTE_SUPERIOR_ESQUERDO = exports.GRADIENTE_SUPERIOR_DIREITO = exports.GRADIENTE_INFERIOR_ESQUERDO = exports.GRADIENTE_INFERIOR_DIREITO = exports.GRADIENTE_ABAIXO = exports.GRADIENTE_ACIMA = exports.GRADIENTE_ESQUERDA = exports.GRADIENTE_DIREITA = exports.COR_AMARELO = exports.COR_VERDE = exports.COR_VERMELHO = exports.COR_AZUL = exports.COR_BRANCO = exports.COR_PRETO = void 0;
+const canvas_1 = require("canvas");
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const excecoes_1 = require("../../../excecoes");
+exports.COR_PRETO = 0xff000000;
+exports.COR_BRANCO = 0xffffffff;
+exports.COR_AZUL = 0xff0000ff;
+exports.COR_VERMELHO = 0xffff0000;
+exports.COR_VERDE = 0xff00ff00;
+exports.COR_AMARELO = 0xffffff00;
+exports.GRADIENTE_DIREITA = 0;
+exports.GRADIENTE_ESQUERDA = 1;
+exports.GRADIENTE_ACIMA = 2;
+exports.GRADIENTE_ABAIXO = 3;
+exports.GRADIENTE_INFERIOR_DIREITO = 4;
+exports.GRADIENTE_INFERIOR_ESQUERDO = 5;
+exports.GRADIENTE_SUPERIOR_DIREITO = 6;
+exports.GRADIENTE_SUPERIOR_ESQUERDO = 7;
+exports.CANAL_R = 0;
+exports.CANAL_G = 1;
+exports.CANAL_B = 2;
+class ErroExcessoOperacoes extends excecoes_1.ErroExecucaoBiblioteca {
+    constructor() {
+        super("A função Graficos.renderizar() não foi chamada nenhuma vez " +
+            "ou o número de operações de desenho que foi chamada antes do Graficos.renderizar() foi muito grande");
+        this.name = "ErroExcessoOperacoes";
+    }
+}
+exports.ErroExcessoOperacoes = ErroExcessoOperacoes;
+class CacheImagens {
+    constructor() {
+        this.imagens = new Map();
+        this.gifs = new Map();
+        this.proximoEndereco = 1;
+    }
+    adicionarImagem(imagem) {
+        const endereco = this.proximoEndereco++;
+        this.imagens.set(endereco, imagem);
+        return endereco;
+    }
+    adicionarGif(gif) {
+        const endereco = this.proximoEndereco++;
+        this.gifs.set(endereco, gif);
+        return endereco;
+    }
+    obterImagem(endereco) {
+        const imagem = this.imagens.get(endereco);
+        if (!imagem)
+            throw new excecoes_1.ErroExecucaoBiblioteca(`Imagem com endereço ${endereco} não encontrada`);
+        return imagem;
+    }
+    obterGif(endereco) {
+        const gif = this.gifs.get(endereco);
+        if (!gif)
+            throw new excecoes_1.ErroExecucaoBiblioteca(`GIF com endereço ${endereco} não encontrado`);
+        return gif;
+    }
+    liberarImagem(endereco) {
+        this.imagens.delete(endereco);
+        this.gifs.delete(endereco);
+    }
+    liberar() {
+        this.imagens.clear();
+        this.gifs.clear();
+    }
+}
+class ImagemGifInterna {
+    constructor(quadros, intervalos, largura, altura) {
+        this.quadros = [];
+        this.intervalos = [];
+        this.indiceAtual = 0;
+        this.quadros = quadros;
+        this.intervalos = intervalos;
+        this.largura = largura;
+        this.altura = altura;
+    }
+    avancarQuadro() {
+        this.indiceAtual = (this.indiceAtual + 1) % this.quadros.length;
+    }
+    getQuadroAtual() {
+        return this.quadros[this.indiceAtual];
+    }
+    getQuadro(indice) {
+        if (indice < 0 || indice >= this.quadros.length) {
+            throw new excecoes_1.ErroExecucaoBiblioteca(`Quadro ${indice} não existe no GIF`);
+        }
+        return this.quadros[indice];
+    }
+    irParaQuadro(indice) {
+        if (indice < 0 || indice >= this.quadros.length) {
+            throw new excecoes_1.ErroExecucaoBiblioteca(`Quadro ${indice} não existe no GIF`);
+        }
+        this.indiceAtual = indice;
+    }
+    getIntervalo() {
+        var _a;
+        return (_a = this.intervalos[this.indiceAtual]) !== null && _a !== void 0 ? _a : 100;
+    }
+    getNumeroFrames() {
+        return this.quadros.length;
+    }
+    getIndiceQuadroAtual() {
+        return this.indiceAtual;
+    }
+    clonar() {
+        return new ImagemGifInterna([...this.quadros], [...this.intervalos], this.largura, this.altura);
+    }
+    setDimensoes(largura, altura) {
+        this.largura = largura;
+        this.altura = altura;
+        this.quadros = this.quadros.map((quadro) => {
+            const canvas = (0, canvas_1.createCanvas)(largura, altura);
+            const ctx = canvas.getContext("2d");
+            ctx.drawImage(quadro, 0, 0, largura, altura);
+            return canvas;
+        });
+    }
+}
+class SuperficieDesenho {
+    constructor(canvas) {
+        this.corAtual = "#000000";
+        this.opacidadeAtual = 1;
+        this.rotacaoAtual = 0;
+        this.canvas = canvas;
+        this.ctx = canvas.getContext("2d");
+        this.backBuffer = (0, canvas_1.createCanvas)(canvas.width, canvas.height);
+        this.backCtx = this.backBuffer.getContext("2d");
+    }
+    limpar() {
+        this.backCtx.fillStyle = this.corAtual;
+        this.backCtx.fillRect(0, 0, this.backBuffer.width, this.backBuffer.height);
+    }
+    renderizar() {
+        this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+        this.ctx.drawImage(this.backBuffer, 0, 0);
+    }
+    renderizarImagem(largura, altura) {
+        const novaImagem = (0, canvas_1.createCanvas)(largura, altura);
+        const ctx = novaImagem.getContext("2d");
+        ctx.drawImage(this.backBuffer, 0, 0, largura, altura);
+        return novaImagem;
+    }
+    aplicarTransformacao(ctx, x, y, largura, altura, fn) {
+        ctx.save();
+        ctx.globalAlpha = this.opacidadeAtual;
+        if (this.rotacaoAtual !== 0) {
+            ctx.translate(x + largura / 2, y + altura / 2);
+            ctx.rotate((this.rotacaoAtual * Math.PI) / 180);
+            ctx.translate(-(x + largura / 2), -(y + altura / 2));
+        }
+        fn();
+        ctx.restore();
+    }
+    desenharRetangulo(x, y, largura, altura, arredondarCantos, preencher) {
+        this.aplicarTransformacao(this.backCtx, x, y, largura, altura, () => {
+            this.backCtx.fillStyle = this.corAtual;
+            this.backCtx.strokeStyle = this.corAtual;
+            if (arredondarCantos) {
+                const raio = Math.min(largura, altura) * 0.1;
+                this.backCtx.beginPath();
+                this.backCtx.roundRect(x, y, largura, altura, raio);
+                preencher ? this.backCtx.fill() : this.backCtx.stroke();
+            }
+            else {
+                preencher
+                    ? this.backCtx.fillRect(x, y, largura, altura)
+                    : this.backCtx.strokeRect(x, y, largura, altura);
+            }
+        });
+    }
+    desenharPoligono(pontos, preencher) {
+        if (pontos.length < 2)
+            return;
+        this.backCtx.save();
+        this.backCtx.globalAlpha = this.opacidadeAtual;
+        this.backCtx.fillStyle = this.corAtual;
+        this.backCtx.strokeStyle = this.corAtual;
+        this.backCtx.beginPath();
+        this.backCtx.moveTo(pontos[0][0], pontos[0][1]);
+        for (let i = 1; i < pontos.length; i++) {
+            this.backCtx.lineTo(pontos[i][0], pontos[i][1]);
+        }
+        this.backCtx.closePath();
+        preencher ? this.backCtx.fill() : this.backCtx.stroke();
+        this.backCtx.restore();
+    }
+    desenharElipse(x, y, largura, altura, preencher) {
+        this.aplicarTransformacao(this.backCtx, x, y, largura, altura, () => {
+            this.backCtx.fillStyle = this.corAtual;
+            this.backCtx.strokeStyle = this.corAtual;
+            this.backCtx.beginPath();
+            this.backCtx.ellipse(x + largura / 2, y + altura / 2, largura / 2, altura / 2, 0, 0, 2 * Math.PI);
+            preencher ? this.backCtx.fill() : this.backCtx.stroke();
+        });
+    }
+    desenharPonto(x, y) {
+        this.backCtx.save();
+        this.backCtx.globalAlpha = this.opacidadeAtual;
+        this.backCtx.fillStyle = this.corAtual;
+        this.backCtx.fillRect(x, y, 1, 1);
+        this.backCtx.restore();
+    }
+    desenharLinha(x1, y1, x2, y2) {
+        this.backCtx.save();
+        this.backCtx.globalAlpha = this.opacidadeAtual;
+        this.backCtx.strokeStyle = this.corAtual;
+        this.backCtx.beginPath();
+        this.backCtx.moveTo(x1, y1);
+        this.backCtx.lineTo(x2, y2);
+        this.backCtx.stroke();
+        this.backCtx.restore();
+    }
+    desenharImagem(x, y, imagem) {
+        this.backCtx.save();
+        this.backCtx.globalAlpha = this.opacidadeAtual;
+        if (this.rotacaoAtual !== 0) {
+            const w = imagem.width;
+            const h = imagem.height;
+            this.backCtx.translate(x + w / 2, y + h / 2);
+            this.backCtx.rotate((this.rotacaoAtual * Math.PI) / 180);
+            this.backCtx.drawImage(imagem, -w / 2, -h / 2);
+        }
+        else {
+            this.backCtx.drawImage(imagem, x, y);
+        }
+        this.backCtx.restore();
+    }
+    desenharPorcaoImagem(x, y, xi, yi, largura, altura, imagem) {
+        this.backCtx.save();
+        this.backCtx.globalAlpha = this.opacidadeAtual;
+        this.backCtx.drawImage(imagem, xi, yi, largura, altura, x, y, largura, altura);
+        this.backCtx.restore();
+    }
+    desenharTexto(texto, x, y) {
+        this.backCtx.save();
+        this.backCtx.globalAlpha = this.opacidadeAtual;
+        this.backCtx.fillStyle = this.corAtual;
+        this.backCtx.fillText(texto, x, y);
+        this.backCtx.restore();
+    }
+    definirCor(cor) {
+        this.corAtual = corParaCss(cor);
+    }
+    definirGradiente(tipo, cor1, cor2) {
+        const w = this.backBuffer.width;
+        const h = this.backBuffer.height;
+        let gradiente;
+        switch (tipo) {
+            case exports.GRADIENTE_DIREITA:
+                gradiente = this.backCtx.createLinearGradient(0, 0, w, 0);
+                break;
+            case exports.GRADIENTE_ESQUERDA:
+                gradiente = this.backCtx.createLinearGradient(w, 0, 0, 0);
+                break;
+            case exports.GRADIENTE_ACIMA:
+                gradiente = this.backCtx.createLinearGradient(0, h, 0, 0);
+                break;
+            case exports.GRADIENTE_ABAIXO:
+                gradiente = this.backCtx.createLinearGradient(0, 0, 0, h);
+                break;
+            case exports.GRADIENTE_INFERIOR_DIREITO:
+                gradiente = this.backCtx.createLinearGradient(0, 0, w, h);
+                break;
+            case exports.GRADIENTE_INFERIOR_ESQUERDO:
+                gradiente = this.backCtx.createLinearGradient(w, 0, 0, h);
+                break;
+            case exports.GRADIENTE_SUPERIOR_DIREITO:
+                gradiente = this.backCtx.createLinearGradient(0, h, w, 0);
+                break;
+            case exports.GRADIENTE_SUPERIOR_ESQUERDO:
+                gradiente = this.backCtx.createLinearGradient(w, h, 0, 0);
+                break;
+            default:
+                gradiente = this.backCtx.createLinearGradient(0, 0, w, 0);
+        }
+        gradiente.addColorStop(0, corParaCss(cor1));
+        gradiente.addColorStop(1, corParaCss(cor2));
+        this.corAtual = gradiente;
+    }
+    definirFonteTexto(nome) {
+        const fonteAtual = this.backCtx.font;
+        const partes = fonteAtual.match(/(\d+)px\s(.+)/);
+        const tamanho = partes ? partes[1] : "16";
+        this.backCtx.font = `${tamanho}px ${nome}`;
+    }
+    definirTamanhoTexto(tamanho) {
+        const fonteAtual = this.backCtx.font;
+        const partes = fonteAtual.match(/\d+px\s(.+)/);
+        const nome = partes ? partes[1] : "sans-serif";
+        this.backCtx.font = `${tamanho}px ${nome}`;
+    }
+    definirEstiloTexto(italico, negrito, _sublinhado) {
+        const fonteAtual = this.backCtx.font;
+        const partes = fonteAtual.match(/(\d+)px\s(.+)/);
+        const tamanho = partes ? partes[1] : "16";
+        const nome = partes ? partes[2] : "sans-serif";
+        const prefixo = [italico ? "italic" : "", negrito ? "bold" : ""]
+            .filter(Boolean)
+            .join(" ");
+        this.backCtx.font = `${prefixo} ${tamanho}px ${nome}`.trim();
+    }
+    larguraTexto(texto) {
+        return this.backCtx.measureText(texto).width;
+    }
+    alturaTexto(_texto) {
+        const metrics = this.backCtx.measureText("M");
+        return metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+    }
+    definirOpacidade(opacidade) {
+        if (opacidade < 0 || opacidade > 255) {
+            throw new excecoes_1.ErroExecucaoBiblioteca("O valor da opacidade deve estar entre 0 e 255");
+        }
+        this.opacidadeAtual = opacidade / 255;
+    }
+    definirRotacao(rotacao) {
+        this.rotacaoAtual = rotacao;
+    }
+}
+class Graficos {
+    constructor() {
+        this.canvas = null;
+        this.superficieDesenho = null;
+        this.cacheImagens = new CacheImagens();
+        this.inicializado = false;
+    }
+    iniciar_modo_grafico() {
+        if (this.inicializado)
+            return;
+        this.canvas = (0, canvas_1.createCanvas)(640, 480);
+        this.superficieDesenho = new SuperficieDesenho(this.canvas);
+        this.inicializado = true;
+    }
+    definir_dimensoes_janela(largura, altura) {
+        const janela = this.obterJanela();
+        janela.width = largura;
+        janela.height = altura;
+    }
+    limpar() {
+        this.obterSuperficie().limpar();
+    }
+    renderizar() {
+        this.obterSuperficie().renderizar();
+    }
+    renderizar_imagem(largura, altura) {
+        const canvas = this.obterSuperficie().renderizarImagem(largura, altura);
+        return this.cacheImagens.adicionarImagem(canvas);
+    }
+    desenhar_retangulo(x, y, largura, altura, arredondarCantos, preencher) {
+        this
+            .obterSuperficie()
+            .desenharRetangulo(x, y, largura, altura, arredondarCantos, preencher);
+    }
+    desenhar_poligono(pontos, preencher) {
+        this.obterSuperficie().desenharPoligono(pontos, preencher);
+    }
+    desenhar_elipse(x, y, largura, altura, preencher) {
+        this.obterSuperficie().desenharElipse(x, y, largura, altura, preencher);
+    }
+    desenhar_ponto(x, y) {
+        this.obterSuperficie().desenharPonto(x, y);
+    }
+    desenhar_linha(x1, y1, x2, y2) {
+        this.obterSuperficie().desenharLinha(x1, y1, x2, y2);
+    }
+    async carregar_imagem(caminho) {
+        try {
+            const img = await (0, canvas_1.loadImage)(caminho);
+            return this.cacheImagens.adicionarImagem(img);
+        }
+        catch (_a) {
+            throw new excecoes_1.ErroExecucaoBiblioteca(`A imagem '${caminho}' não foi encontrada`);
+        }
+    }
+    proximo_frame_gif(endereco) {
+        this.cacheImagens.obterGif(endereco).avancarQuadro();
+    }
+    transformar_imagem(endereco, espelhamentoHorizontal, espelhamentoVertical, rotacao, corIgnorada) {
+        const original = this.cacheImagens.obterImagem(endereco);
+        let canvas = imagemParaCanvas(original);
+        canvas = aplicarChromaKey(canvas, corIgnorada);
+        canvas = espelharImagem(canvas, espelhamentoHorizontal, espelhamentoVertical);
+        canvas = rotacionarImagem(canvas, rotacao);
+        return this.cacheImagens.adicionarImagem(canvas);
+    }
+    redimensionar_imagem(endereco, largura, altura) {
+        if (largura <= 0 && altura <= 0) {
+            throw new excecoes_1.ErroExecucaoBiblioteca("Impossível transformar imagem para estas dimensões");
+        }
+        const original = this.cacheImagens.obterImagem(endereco);
+        const w = original.width;
+        const h = original.height;
+        if (altura === 0 && largura !== 0) {
+            altura = Math.round(h * (largura / w));
+        }
+        else if (largura === 0 && altura !== 0) {
+            largura = Math.round(w * (altura / h));
+        }
+        const canvas = (0, canvas_1.createCanvas)(largura, altura);
+        const ctx = canvas.getContext("2d");
+        ctx.drawImage(original, 0, 0, largura, altura);
+        return this.cacheImagens.adicionarImagem(canvas);
+    }
+    obter_cor_pixel(endereco, x, y) {
+        const imagem = this.cacheImagens.obterImagem(endereco);
+        const canvas = imagemParaCanvas(imagem);
+        const ctx = canvas.getContext("2d");
+        const pixel = ctx.getImageData(x, y, 1, 1).data;
+        return ((pixel[3] << 24) | (pixel[0] << 16) | (pixel[1] << 8) | pixel[2]) >>> 0;
+    }
+    obter_RGB(cor, canal) {
+        switch (canal) {
+            case exports.CANAL_R:
+                return (cor & 0xff0000) >> 16;
+            case exports.CANAL_G:
+                return (cor & 0x00ff00) >> 8;
+            case exports.CANAL_B:
+                return cor & 0x0000ff;
+            default:
+                return 0;
+        }
+    }
+    transformar_porcao_imagem(endereco, x, y, largura, altura, espelhamentoHorizontal, espelhamentoVertical, rotacao, corIgnorada) {
+        const original = this.cacheImagens.obterImagem(endereco);
+        const porcao = (0, canvas_1.createCanvas)(largura, altura);
+        const ctx = porcao.getContext("2d");
+        ctx.drawImage(original, x, y, largura, altura, 0, 0, largura, altura);
+        let canvas = aplicarChromaKey(porcao, corIgnorada);
+        canvas = espelharImagem(canvas, espelhamentoHorizontal, espelhamentoVertical);
+        canvas = rotacionarImagem(canvas, rotacao);
+        return this.cacheImagens.adicionarImagem(canvas);
+    }
+    desenhar_imagem(x, y, endereco) {
+        const imagem = this.cacheImagens.obterImagem(endereco);
+        this.obterSuperficie().desenharImagem(x, y, imagem);
+    }
+    salvar_imagem(endereco, caminho) {
+        const imagem = this.cacheImagens.obterImagem(endereco);
+        const canvas = imagemParaCanvas(imagem);
+        const buffer = canvas.toBuffer("image/png");
+        fs.writeFileSync(caminho, buffer);
+    }
+    desenhar_quadro_atual_gif(x, y, endereco) {
+        const quadro = this.cacheImagens.obterGif(endereco).getQuadroAtual();
+        this.obterSuperficie().desenharImagem(x, y, quadro);
+    }
+    desenhar_porcao_imagem(x, y, xi, yi, largura, altura, endereco) {
+        const imagem = this.cacheImagens.obterImagem(endereco);
+        this.obterSuperficie().desenharPorcaoImagem(x, y, xi, yi, largura, altura, imagem);
+    }
+    obter_intervalo_gif(endereco) {
+        return this.cacheImagens.obterGif(endereco).getIntervalo();
+    }
+    obter_numero_quadros_gif(endereco) {
+        return this.cacheImagens.obterGif(endereco).getNumeroFrames();
+    }
+    obter_numero_quadro_atual_gif(endereco) {
+        return this.cacheImagens.obterGif(endereco).getIndiceQuadroAtual();
+    }
+    obter_quadro_gif(endereco, quadro) {
+        const canvas = this.cacheImagens.obterGif(endereco).getQuadro(quadro);
+        return this.cacheImagens.adicionarImagem(canvas);
+    }
+    definir_quadro_gif(endereco, quadro) {
+        this.cacheImagens.obterGif(endereco).irParaQuadro(quadro);
+    }
+    liberar_imagem(endereco) {
+        this.cacheImagens.liberarImagem(endereco);
+    }
+    desenhar_texto(x, y, texto) {
+        this.obterSuperficie().desenharTexto(texto, x, y);
+    }
+    definir_cor(cor) {
+        this.obterSuperficie().definirCor(cor);
+    }
+    definir_gradiente(tipo, cor1, cor2) {
+        this.obterSuperficie().definirGradiente(tipo, cor1, cor2);
+    }
+    definir_fonte_texto(nome) {
+        this.obterSuperficie().definirFonteTexto(nome);
+    }
+    definir_tamanho_texto(tamanho) {
+        this.obterSuperficie().definirTamanhoTexto(tamanho);
+    }
+    definir_estilo_texto(italico, negrito, sublinhado) {
+        this.obterSuperficie().definirEstiloTexto(italico, negrito, sublinhado);
+    }
+    largura_texto(texto) {
+        return this.obterSuperficie().larguraTexto(texto);
+    }
+    altura_texto(texto) {
+        return this.obterSuperficie().alturaTexto(texto);
+    }
+    largura_imagem(endereco) {
+        const img = this.cacheImagens.obterImagem(endereco);
+        return img.width;
+    }
+    altura_imagem(endereco) {
+        const img = this.cacheImagens.obterImagem(endereco);
+        return img.height;
+    }
+    criar_cor(vermelho, verde, azul) {
+        if (vermelho < 0 || vermelho > 255 ||
+            verde < 0 || verde > 255 ||
+            azul < 0 || azul > 255) {
+            throw new excecoes_1.ErroExecucaoBiblioteca("Erro ao criar a cor, os valores dos tons devem estar entre 0 e 255");
+        }
+        return ((0xff << 24) | (vermelho << 16) | (verde << 8) | azul) >>> 0;
+    }
+    carregar_fonte(caminhoFonte) {
+        if (!fs.existsSync(caminhoFonte)) {
+            throw new excecoes_1.ErroExecucaoBiblioteca(`A fonte '${caminhoFonte}' não foi encontrada`);
+        }
+        const nome = path_1.default.basename(caminhoFonte, path_1.default.extname(caminhoFonte));
+        (0, canvas_1.registerFont)(caminhoFonte, { family: nome });
+    }
+    definir_opacidade(opacidade) {
+        this.obterSuperficie().definirOpacidade(opacidade);
+    }
+    definir_rotacao(rotacao) {
+        this.obterSuperficie().definirRotacao(rotacao);
+    }
+    largura_janela() {
+        return this.obterJanela().width;
+    }
+    altura_janela() {
+        return this.obterJanela().height;
+    }
+    obterJanela() {
+        if (!this.inicializado || !this.canvas) {
+            throw new excecoes_1.ErroExecucaoBiblioteca("O modo gráfico não foi inicializado");
+        }
+        return this.canvas;
+    }
+    obterSuperficie() {
+        if (!this.inicializado || !this.superficieDesenho) {
+            throw new excecoes_1.ErroExecucaoBiblioteca("O modo gráfico não foi inicializado");
+        }
+        return this.superficieDesenho;
+    }
+}
+exports.Graficos = Graficos;
+function corParaCss(cor) {
+    const a = (cor >>> 24) & 0xff;
+    const r = (cor >>> 16) & 0xff;
+    const g = (cor >>> 8) & 0xff;
+    const b = cor & 0xff;
+    return a < 255
+        ? `rgba(${r}, ${g}, ${b}, ${(a / 255).toFixed(3)})`
+        : `rgb(${r}, ${g}, ${b})`;
+}
+function imagemParaCanvas(imagem) {
+    if (imagem instanceof canvas_1.Canvas)
+        return imagem;
+    const canvas = (0, canvas_1.createCanvas)(imagem.width, imagem.height);
+    canvas.getContext("2d").drawImage(imagem, 0, 0);
+    return canvas;
+}
+function aplicarChromaKey(canvas, cor) {
+    if (cor === 0)
+        return canvas;
+    const r = (cor >>> 16) & 0xff;
+    const g = (cor >>> 8) & 0xff;
+    const b = cor & 0xff;
+    const ctx = canvas.getContext("2d");
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const data = imageData.data;
+    for (let i = 0; i < data.length; i += 4) {
+        if (data[i] === r && data[i + 1] === g && data[i + 2] === b) {
+            data[i] = 0;
+            data[i + 1] = 0;
+            data[i + 2] = 0;
+            data[i + 3] = 0;
+        }
+    }
+    ctx.putImageData(imageData, 0, 0);
+    return canvas;
+}
+function espelharImagem(canvas, horizontal, vertical) {
+    if (!horizontal && !vertical)
+        return canvas;
+    const novo = (0, canvas_1.createCanvas)(canvas.width, canvas.height);
+    const ctx = novo.getContext("2d");
+    ctx.translate(horizontal ? canvas.width : 0, vertical ? canvas.height : 0);
+    ctx.scale(horizontal ? -1 : 1, vertical ? -1 : 1);
+    ctx.drawImage(canvas, 0, 0);
+    return novo;
+}
+function rotacionarImagem(canvas, graus) {
+    if (graus % 360 === 0)
+        return canvas;
+    const rad = (graus * Math.PI) / 180;
+    const cos = Math.abs(Math.cos(rad));
+    const sin = Math.abs(Math.sin(rad));
+    const novaLargura = Math.round(canvas.width * cos + canvas.height * sin);
+    const novaAltura = Math.round(canvas.width * sin + canvas.height * cos);
+    const novo = (0, canvas_1.createCanvas)(novaLargura, novaAltura);
+    const ctx = novo.getContext("2d");
+    ctx.translate(novaLargura / 2, novaAltura / 2);
+    ctx.rotate(rad);
+    ctx.drawImage(canvas, -canvas.width / 2, -canvas.height / 2);
+    return novo;
+}
+//# sourceMappingURL=graficos.js.map