@boruto_vk7/stickengine 0.0.2-alpha → 0.0.4

package/README.md

@@ -1,135 +1,121 @@
-# StickEngine
+# 🚀 StickEngine
 
-[![npm](https://img.shields.io/npm/v/@boruto_vk7/stickengine)](https://www.npmjs.com/package/@boruto_vk7/stickengine)
-[![license](https://img.shields.io/npm/l/@boruto_vk7/stickengine)](https://github.com/Borutovk7/StickEngine/blob/main/LICENSE)
+**StickEngine** é um motor poderoso e leve para criação de figurinhas do WhatsApp (estáticas e animadas) com suporte integrado a filtros de imagem, adição de texto e remoção de fundo. Projetado para funcionar em qualquer lugar, do **Termux** a servidores dedicados.
 
-Módulo Node.js para criação de stickers para WhatsApp — feito pra funcionar em qualquer lugar, do **Termux no seu celular** até um servidor dedicado. Sem dependências nativas complicadas, sem dor de cabeça na instalação.
+[![NPM Version](https://img.shields.io/npm/v/@boruto_vk7/stickengine?style=flat-square)](https://www.npmjs.com/package/@boruto_vk7/stickengine)
+[![License](https://img.shields.io/npm/l/@boruto_vk7/stickengine?style=flat-square)](https://github.com/Borutovk7/StickEngine)
 
-> Sabe aquele sofrimento de tentar rodar um módulo de sticker no Termux e quebrar tudo por causa do `sharp` ou de alguma lib nativa? O StickEngine foi criado exatamente pra resolver isso. Aqui funciona.
+---
 
-## Por que o StickEngine?
+## ✨ Funcionalidades
 
-- ✅ **Funciona no Termux** — sem `sharp`, sem compilação nativa, sem erro de permissão
-- ✅ **Funciona em VPS, Replit, Railway, servidor dedicado** — em qualquer ambiente
-- ✅ **Zero configuração extra** — instala e já usa
-- ✅ **Suporte a ESM e CJS** — compatível com qualquer projeto
-- ✅ **Entrada flexível** — URL, Buffer ou caminho local, tanto faz
+- 🎞️ **Figurinhas Animadas**: Suporte automático para GIFs e Vídeos (MP4).
+- 🎨 **Filtros Profissionais**: Sépia, Tons de Cinza, Inversão e Desfoque (Blur).
+- ✍️ **Texto Customizado**: Adicione legendas diretamente na figurinha.
+- ✂️ **Remoção de Fundo**: Integração com a API `remove.bg`.
+- 🧹 **Limpeza Automática**: Sistema de gerenciamento de arquivos temporários com o método `.clean()`.
+- 🏷️ **Metadados (Exif)**: Personalize o nome do pacote e o autor sem complicação.
+- 📱 **Termux Friendly**: Sem dependências nativas pesadas como `sharp`.
 
-## Requisitos
+---
 
-- Node.js 16+
-- [ffmpeg](https://ffmpeg.org/) instalado no sistema
+## 🖼️ Exemplos Visuais
 
-```bash
-# Termux
-pkg install ffmpeg
+| Filtro Séia + Texto | Figurinha Animada (Mockup) |
+| :---: | :---: |
+| ![Sepia Preview](assets/preview_sepia.png) | ![Animated Preview](assets/preview_animated.png) |
 
-# Debian/Ubuntu/VPS
-sudo apt install ffmpeg
-```
+---
 
-## Instalação
+## 📦 Instalação
 
 ```bash
 npm install @boruto_vk7/stickengine
 ```
 
-## Uso
+> **Requisito:** Certifique-se de ter o [FFmpeg](https://ffmpeg.org/) instalado no seu sistema. No Termux: `pkg install ffmpeg`.
+
+---
 
-### ESM
+## 🚀 Como Usar (Exemplos Técnicos)
 
+### 1. Criando uma Figurinha Estática Simples
 ```javascript
 import StickEngine from '@boruto_vk7/stickengine';
 
-const engine = new StickEngine({
-  metadata: {
-    pack: 'Meu Pack de Stickers',
-    author: 'Borutovk7',
-    emojis: ['✨', '🚀']
-  },
-  // Opcional: chaves da API remove.bg para remoção de fundo
-  // transparent: ['SUA_API_KEY']
-});
+const engine = new StickEngine();
+engine.addFile('https://exemplo.com/foto.jpg');
 
-engine.on('st.start', (data) => console.log(`Processando:`, data.input));
-engine.on('st.data',  (data) => console.log(`Sticker gerado:`, data.file));
-engine.on('st.error', (data) => console.error(`Erro:`, data.error));
+const results = await engine.start();
+console.log('Caminho do WebP:', results[0].value);
+engine.clean();
+```
 
-const results = await engine
-  .addFile('https://picsum.photos/512') // URL
-  .addFile('caminho/para/video.mp4')    // caminho local
-  .addFile(buffer)                      // Buffer
-  .start();
+### 2. Figurinha Animada (GIF ou Vídeo)
+O motor detecta automaticamente a duração e converte para WebP animado.
+```javascript
+const engine = new StickEngine({
+  fps: 20, // Aumenta a fluidez
+  quality: 70 // Otimiza o tamanho para o WhatsApp
+});
 
-console.log(results);
+engine.addFile('./video_engracado.mp4');
+await engine.start();
+engine.clean();
 ```
 
-### CJS
-
+### 3. Aplicando Filtros e Texto
 ```javascript
-const StickEngine = require('@boruto_vk7/stickengine');
-
 const engine = new StickEngine({
-  metadata: {
-    pack: 'Meu Pack',
-    author: 'Borutovk7',
-    emojis: ['🎉']
+  edit: {
+    sepia: true,
+    blur: 5,
+    text: {
+      content: 'MUITO BOM!',
+      alignmentY: 2 // 0: Topo, 1: Meio, 2: Baixo
+    }
   }
 });
 
-engine.on('st.start', (data) => console.log(`Processando:`, data.input));
-engine.on('st.data',  (data) => console.log(`Sticker gerado:`, data.file));
-engine.on('st.error', (data) => console.error(`Erro:`, data.error));
-
-engine.addFile('https://picsum.photos/200')
-  .start()
-  .then(results => console.log(results))
-  .catch(err => console.error(err));
+engine.addFile(bufferDeImagem);
+await engine.start();
+engine.clean();
 ```
 
-## Eventos
-
-| Evento | Descrição |
-|--------|-----------|
-| `st.start` | Disparado ao iniciar o processamento de um arquivo |
-| `st.info` | Metadados do arquivo sendo processado |
-| `st.data` | Sticker gerado com sucesso |
-| `st.error` | Erro ao processar um arquivo |
-
-## API
-
-### `new StickEngine(options)`
-
-| Opção | Tipo | Descrição |
-|-------|------|-----------|
-| `metadata.pack` | `string` | Nome do pacote de stickers |
-| `metadata.author` | `string` | Nome do autor |
-| `metadata.emojis` | `string[]` | Emojis associados ao sticker |
-| `transparent` | `string[]` | Chaves da API remove.bg para remoção de fundo |
-
-### `.addFile(input)`
-
-Adiciona um arquivo à fila. Aceita URL, Buffer ou caminho local. Retorna a instância para encadeamento.
+### 4. Remoção de Fundo (Remove.bg)
+```javascript
+const engine = new StickEngine({
+  transparent: 'SUA_API_KEY_AQUI'
+});
 
-### `.start()`
+engine.addFile('foto_com_fundo.png');
+await engine.start();
+engine.clean();
+```
 
-Inicia o processamento da fila. Retorna uma Promise com os resultados.
+---
 
-### `getBuffer(url)`
+## ⚙️ Opções do Construtor
 
-Utilitário para baixar uma URL como Buffer.
+| Opção | Tipo | Padrão | Descrição |
+| :--- | :--- | :--- | :--- |
+| `metadata` | `Object` | `{ pack: 'StickEngine', author: 'Borutovk7' }` | Nome do pacote e autor. |
+| `edit` | `Object` | `false` | Filtros (`sepia`, `greyscale`, `invert`, `blur`) e `text`. |
+| `transparent` | `String` | `false` | Chave da API `remove.bg` para remover fundo. |
+| `autoClean` | `Boolean` | `true` | Habilita o rastreio de arquivos para limpeza. |
+| `quality` | `Number` | `80` | Qualidade do WebP (1-100). |
+| `fps` | `Number` | `15` | Frames por segundo para animações. |
 
-```javascript
-import { getBuffer } from '@boruto_vk7/stickengine';
+---
 
-const buffer = await getBuffer('https://example.com/image.png');
-```
+## 🤝 Contribuições
 
-## Créditos
+Contribuições são sempre bem-vindas! Sinta-se à vontade para abrir uma **Issue** ou enviar um **Pull Request**.
 
-- [Eduh dev](https://github.com/Borutovk7)
+Desenvolvido por [Borutovk7](https://github.com/Borutovk7) e [Eduh Dev](https://github.com/EduhDev).
 
+---
 
-## Licença
+## 📄 Licença
 
-ISC
+Este projeto está sob a licença [ISC](LICENSE).

package/dist/StickEngine.d.ts

@@ -5,25 +5,46 @@ export interface StickerMetadata {
     author?: string;
     emojis?: string[];
 }
+export interface JimpOptions {
+    greyscale?: boolean;
+    invert?: boolean;
+    sepia?: boolean;
+    blur?: number;
+    resize?: {
+        width: number;
+        height: number;
+    };
+    text?: {
+        content: string;
+        alignmentX?: number;
+        alignmentY?: number;
+        color?: string;
+    };
+}
 export interface StickEngineOptions {
     webp?: boolean;
-    edit?: string | boolean;
+    edit?: JimpOptions | boolean;
     convert?: boolean;
     transparent?: string | string[] | false;
     metadata?: StickerMetadata;
+    autoClean?: boolean;
+    fps?: number;
+    quality?: number;
 }
 /**
  * Faz GET em uma URL e retorna o corpo como Buffer.
- * Fornecido pelo usuário para integração.
  */
 export declare const getBuffer: (url: string, options?: AxiosRequestConfig) => Promise<Buffer>;
 export declare class StickEngine extends EventEmitter {
     options: StickEngineOptions;
     private tempDir;
     private queue;
+    private createdFiles;
     constructor(options?: StickEngineOptions);
     addFile(file: string | Buffer): this;
+    clean(): void;
     private processFile;
+    private applyJimpEdits;
     private getMediaInfo;
     private convertToWebp;
     private addExif;

package/dist/StickEngine.js

@@ -7,13 +7,14 @@ import ffmpeg from 'fluent-ffmpeg';
 // @ts-ignore
 import webpMux from 'node-webpmux';
 // @ts-ignore
+import Jimp from 'jimp';
+// @ts-ignore
 import { removeBackgroundFromImageFile } from 'remove.bg';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
  * Faz GET em uma URL e retorna o corpo como Buffer.
- * Fornecido pelo usuário para integração.
  */
 export const getBuffer = async (url, options = {}) => {
     try {
@@ -32,7 +33,7 @@ export const getBuffer = async (url, options = {}) => {
     }
     catch (err) {
         console.error(`Erro em getBuffer: ${err}`);
-        const errorImagePath = path.join(__dirname, 'src', 'emror.jpg');
+        const errorImagePath = path.join(__dirname, 'emror.jpg');
         if (fs.existsSync(errorImagePath)) {
             return fs.readFileSync(errorImagePath);
         }
@@ -43,6 +44,7 @@ export class StickEngine extends EventEmitter {
     options;
     tempDir;
     queue;
+    createdFiles;
     constructor(options = {}) {
         super();
         this.options = {
@@ -50,6 +52,9 @@ export class StickEngine extends EventEmitter {
             edit: false,
             convert: false,
             transparent: false,
+            autoClean: true,
+            fps: 15,
+            quality: 80,
             metadata: {
                 pack: 'StickEngine',
                 author: 'Borutovk7 & Eduh Dev',
@@ -62,15 +67,30 @@ export class StickEngine extends EventEmitter {
             fs.mkdirSync(this.tempDir, { recursive: true });
         }
         this.queue = [];
+        this.createdFiles = [];
     }
     addFile(file) {
         this.queue.push(file);
         return this;
     }
+    clean() {
+        for (const file of this.createdFiles) {
+            try {
+                if (fs.existsSync(file)) {
+                    fs.unlinkSync(file);
+                }
+            }
+            catch (err) {
+                console.error(`Erro ao deletar arquivo temporário ${file}:`, err);
+            }
+        }
+        this.createdFiles = [];
+    }
     async processFile(input, index) {
-        let filePath;
-        let extension;
+        let filePath = '';
+        let extension = '';
         const timestamp = Date.now();
+        const localCreatedFiles = [];
         try {
             this.emit('st.start', { index, input });
             const ft = await import('file-type');
@@ -80,6 +100,7 @@ export class StickEngine extends EventEmitter {
                 extension = type ? type.ext : 'bin';
                 filePath = path.join(this.tempDir, `input_${timestamp}_${index}.${extension}`);
                 fs.writeFileSync(filePath, input);
+                localCreatedFiles.push(filePath);
             }
             else if (typeof input === 'string' && input.startsWith('http')) {
                 const buffer = await getBuffer(input);
@@ -87,18 +108,27 @@ export class StickEngine extends EventEmitter {
                 extension = type ? type.ext : 'bin';
                 filePath = path.join(this.tempDir, `input_${timestamp}_${index}.${extension}`);
                 fs.writeFileSync(filePath, buffer);
+                localCreatedFiles.push(filePath);
             }
             else if (typeof input === 'string' && fs.existsSync(input)) {
-                extension = path.extname(input).slice(1);
                 filePath = input;
             }
             else {
                 throw new Error('Tipo de entrada inválido ou arquivo não encontrado.');
             }
-            const metadata = await this.getMediaInfo(filePath);
-            this.emit('st.info', { index, ...metadata });
+            const mediaInfo = await this.getMediaInfo(filePath);
+            this.emit('st.info', { index, ...mediaInfo });
             let currentFile = filePath;
-            if (this.options.transparent) {
+            const isAnimated = mediaInfo.duration > 0 || extension === 'gif' || extension === 'mp4' || extension === 'webp';
+            // Aplicar Edições Jimp (Apenas para Imagens Estáticas por enquanto)
+            if (this.options.edit && !isAnimated) {
+                const editedPath = path.join(this.tempDir, `edited_${timestamp}_${index}.png`);
+                await this.applyJimpEdits(currentFile, editedPath, this.options.edit);
+                localCreatedFiles.push(editedPath);
+                currentFile = editedPath;
+            }
+            // Remoção de fundo (Apenas para Imagens Estáticas)
+            if (this.options.transparent && !isAnimated) {
                 const apiKey = Array.isArray(this.options.transparent)
                     ? this.options.transparent[Math.floor(Math.random() * this.options.transparent.length)]
                     : this.options.transparent;
@@ -111,60 +141,97 @@ export class StickEngine extends EventEmitter {
                         type: 'auto'
                     });
                     fs.writeFileSync(bgRemovedPath, Buffer.from(result.base64img, 'base64'));
+                    localCreatedFiles.push(bgRemovedPath);
                     currentFile = bgRemovedPath;
                 }
             }
+            // Conversão para WebP (Suporta Estático e Animado)
             const webpPath = path.join(this.tempDir, `sticker_${timestamp}_${index}.webp`);
-            await this.convertToWebp(currentFile, webpPath);
+            await this.convertToWebp(currentFile, webpPath, isAnimated);
+            localCreatedFiles.push(webpPath);
             currentFile = webpPath;
+            // Adição de Metadados (Exif)
             if (this.options.metadata) {
                 await this.addExif(currentFile, this.options.metadata);
             }
+            this.createdFiles.push(...localCreatedFiles);
             this.emit('st.data', { index, file: currentFile });
             return currentFile;
         }
         catch (error) {
             this.emit('st.error', { index, error: error.message });
+            for (const f of localCreatedFiles) {
+                if (fs.existsSync(f))
+                    fs.unlinkSync(f);
+            }
             throw error;
         }
     }
+    async applyJimpEdits(input, output, options) {
+        const image = await Jimp.read(input);
+        if (options.greyscale)
+            image.greyscale();
+        if (options.invert)
+            image.invert();
+        if (options.sepia)
+            image.sepia();
+        if (options.blur)
+            image.blur(options.blur);
+        if (options.resize)
+            image.resize(options.resize.width, options.resize.height);
+        if (options.text) {
+            const font = await Jimp.loadFont(Jimp.FONT_SANS_32_WHITE);
+            image.print(font, 0, 0, {
+                text: options.text.content,
+                alignmentX: options.text.alignmentX || Jimp.HORIZONTAL_ALIGN_CENTER,
+                alignmentY: options.text.alignmentY || Jimp.VERTICAL_ALIGN_BOTTOM
+            }, image.bitmap.width, image.bitmap.height);
+        }
+        await image.writeAsync(output);
+    }
     getMediaInfo(file) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve) => {
             exec(`ffprobe -v error -select_streams v:0 -show_entries stream=width,height,duration -of csv=p=0:s=x ${file}`, (err, stdout) => {
                 if (err)
-                    return reject(err);
-                const [width, height, duration] = stdout.split('x');
+                    return resolve({ width: 0, height: 0, duration: 0 });
+                const parts = stdout.trim().split('x');
                 resolve({
-                    width: parseInt(width) || 0,
-                    height: parseInt(height) || 0,
-                    duration: parseFloat(duration) || 0
+                    width: parseInt(parts[0]) || 0,
+                    height: parseInt(parts[1]) || 0,
+                    duration: parseFloat(parts[2]) || 0
                 });
             });
         });
     }
-    convertToWebp(input, output) {
+    convertToWebp(input, output, isAnimated) {
         return new Promise((resolve, reject) => {
-            ffmpeg(input)
+            const ff = ffmpeg(input)
                 .on('error', reject)
-                .on('end', () => resolve())
-                .addOutputOptions([
+                .on('end', () => resolve());
+            const videoOptions = [
                 '-vcodec', 'libwebp',
-                '-vf', 'scale=512:512:force_original_aspect_ratio=decrease,fps=15,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1',
+                '-vf', `scale=512:512:force_original_aspect_ratio=decrease,fps=${this.options.fps},pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1`,
                 '-lossless', '1',
                 '-loop', '0',
                 '-preset', 'default',
                 '-an',
                 '-vsync', '0'
-            ])
+            ];
+            if (isAnimated) {
+                // Opções específicas para animação para manter o peso baixo (limite do WhatsApp é 1MB)
+                videoOptions.push('-t', '6'); // Limita a 6 segundos
+                videoOptions.push('-q:v', String(this.options.quality));
+            }
+            ff.addOutputOptions(videoOptions)
                 .toFormat('webp')
                 .save(output);
         });
     }
     async addExif(webpPath, metadata) {
         const json = {
-            'sticker-pack-id': 'StickEngine-Manus',
+            'sticker-pack-id': 'StickEngine-Official',
             'sticker-pack-name': metadata.pack || 'StickEngine',
-            'sticker-pack-publisher': metadata.author || 'Borutovk7 & Eduh Dev',
+            'sticker-pack-publisher': metadata.author || 'Borutovk7',
             'emojis': metadata.emojis || ['🥶']
         };
         const Image = webpMux.Image || (webpMux.default && webpMux.default.Image);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boruto_vk7/stickengine",
-  "version": "0.0.2-alpha",
+  "version": "0.0.4",
   "description": "StickEngine module for creating WhatsApp stickers",
   "type": "module",
   "main": "dist/StickEngine.js",

package/README.md.bak

@@ -1,131 +0,0 @@
-# StickEngine: Gerador de Stickers para WhatsApp
-
-Bem-vindo ao **StickEngine**, um módulo Node.js robusto e flexível para a criação de stickers personalizados para WhatsApp. Desenvolvido para ser eficiente e compatível com diversos ambientes, o StickEngine permite transformar imagens e vídeos em stickers WebP com metadados personalizados, além de oferecer funcionalidades como remoção de fundo.
-
-## Funcionalidades Principais
-
--   **Geração de Stickers WebP**: Converte imagens (JPG, PNG, GIF) e vídeos (MP4, WebM) para o formato WebP, otimizado para stickers do WhatsApp.
--   **Metadados Personalizados (EXIF)**: Adiciona informações como nome do pacote, autor e emojis diretamente no sticker.
--   **Suporte a URLs, Buffers e Caminhos Locais**: Flexibilidade na entrada de dados para a criação dos stickers.
--   **Remoção de Fundo (Opcional)**: Integração com a API `remove.bg` para remover o fundo de imagens, ideal para criar stickers transparentes.
--   **Compatibilidade CJS e ESM**: O módulo pode ser utilizado tanto em projetos CommonJS (`require`) quanto em módulos ES (`import`).
-
-## Instalação
-
-Para utilizar o StickEngine, você precisará ter o Node.js e o `ffmpeg` instalados em seu sistema. O `ffmpeg` é essencial para a conversão de mídia.
-
-```bash
-# Instale as dependências do Node.js
-pnpm install axios fluent-ffmpeg node-webpmux file-type jimp remove.bg node-fetch
-
-# Certifique-se de ter o ffmpeg instalado e acessível no PATH do seu sistema.
-# Para sistemas baseados em Debian/Ubuntu:
-sudo apt update && sudo apt install ffmpeg
-# Para outras plataformas, consulte a documentação oficial do ffmpeg.
-```
-
-## Uso
-
-O StickEngine é projetado para ser fácil de usar, com uma API baseada em classes e eventos para feedback de progresso.
-
-### Exemplo de Uso (ESM - `index.js`)
-
-```javascript
-import StickEngine from './index.js';
-
-const engine = new StickEngine({
-  metadata: {
-    pack: 'Meu Pack de Stickers',
-    author: 'Borutovk7 & Eduh Dev',
-    emojis: ['✨', '🚀'] // Emojis opcionais
-  },
-  // Para remover o fundo, forneça uma ou mais chaves de API do remove.bg
-  // transparent: ['SUA_API_KEY_REMOVEBG_1', 'SUA_API_KEY_REMOVEBG_2']
-});
-
-// Eventos para acompanhar o progresso
-engine.on('st.start', (data) => console.log(`[START] Processando arquivo ${data.index}:`, data.input));
-engine.on('st.info', (data) => console.log(`[INFO] Metadados do arquivo ${data.index}:`, data));
-engine.on('st.data', (data) => console.log(`[DATA] Sticker ${data.index} gerado em:`, data.file));
-engine.on('st.error', (data) => console.error(`[ERROR] Falha no arquivo ${data.index}:`, data.error));
-
-// Adicione arquivos à fila (pode ser URL, Buffer ou caminho local)
-engine.addFile('https://picsum.photos/512') // Exemplo de URL de imagem
-      .addFile('caminho/para/seu/video.mp4') // Exemplo de caminho local para vídeo
-      .addFile(Buffer.from('...')) // Exemplo de Buffer
-  .start()
-  .then(results => {
-    console.log('Processamento concluído. Resultados:', results);
-  })
-  .catch(err => {
-    console.error('Ocorreu um erro geral no processamento:', err);
-  });
-```
-
-### Exemplo de Uso (CommonJS - `index.cjs`)
-
-```javascript
-const StickEngine = require('./index.cjs');
-
-const engine = new StickEngine({
-  metadata: {
-    pack: 'Meu Pack CJS',
-    author: 'Borutovk7 & Eduh Dev',
-    emojis: ['🎉']
-  }
-});
-
-// Os eventos e a forma de adicionar arquivos são os mesmos do exemplo ESM.
-engine.on('st.start', (data) => console.log(`[START CJS] Processando arquivo ${data.index}:`, data.input));
-// ... (outros eventos)
-
-engine.addFile('https://picsum.photos/200')
-  .start()
-  .then(results => {
-    console.log('Processamento CJS concluído. Resultados:', results);
-  })
-  .catch(err => {
-    console.error('Ocorreu um erro geral no processamento CJS:', err);
-  });
-```
-
-### Função `getBuffer`
-
-A função `getBuffer` fornecida pelo usuário foi integrada ao módulo para lidar com o download de URLs de forma robusta. Ela pode ser importada e utilizada separadamente, se necessário:
-
-```javascript
-// ESM
-import { getBuffer } from './index.js';
-
-// CJS
-const { getBuffer } = require('./index.cjs');
-
-async function downloadAndProcess() {
-  try {
-    const buffer = await getBuffer('https://example.com/image.png');
-    console.log('Buffer obtido com sucesso:', buffer.length, 'bytes');
-    // Faça algo com o buffer
-  } catch (error) {
-    console.error('Erro ao obter buffer:', error);
-  }
-}
-downloadAndProcess();
-```
-
-## Notas Importantes
-
-*   **Diretrizes `async`**: Lembre-se de que as operações do StickEngine são assíncronas. Certifique-se de usar `async/await` ou `.then().catch()` para lidar com as Promises retornadas, garantindo um código funcional e sem bloqueios.
-*   **`extractMetadata` (EXIF) sem `sharp`**: A implementação da manipulação de metadados (EXIF) foi cuidadosamente desenvolvida para **não depender da biblioteca `sharp`**. Esta decisão foi tomada para garantir a máxima compatibilidade e leveza do módulo, especialmente para usuários que executam o código em ambientes com recursos limitados, como o Termux, ou em hosts que não suportam a compilação de dependências nativas como o `sharp`. Agradecemos a compreensão, caro usuário! 👊🏻
-*   **Verificação de Atualizações**: Caso encontre algum erro na execução ou comportamento inesperado, verifique se os módulos e dependências foram atualizados. Em alguns casos, pode ser necessário obter a versão mais recente do arquivo.
-
-## Créditos
-
-Este módulo foi desenvolvido com base nas contribuições e inspiração de:
-
--   **Borutovk7** (GitHub: [Borutovk7](https://github.com/Borutovk7))
--   **Eduh Dev**
--   **Manus AI** (Adaptação e refatoração)
-
-## Licença
-
-Este projeto está licenciado sob a licença ISC. Veja o arquivo `LICENSE` para mais detalhes.

package/package.json.bak

@@ -1,49 +0,0 @@
-{
-  "name": "@boruto_vk7/stickengine",
-  "version": "0.0.1-alpha",
-  "description": "StickEngine module for creating WhatsApp stickers",
-  "type": "module",
-  "main": "dist/StickEngine.js",
-  "module": "dist/StickEngine.js",
-  "types": "dist/StickEngine.d.ts",
-  "exports": {
-    ".": {
-      "require": "./dist/StickEngine.js",
-      "import": "./dist/StickEngine.js",
-      "types": "./dist/StickEngine.d.ts"
-    }
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-    "sticker",
-    "whatsapp",
-    "stickengine"
-  ],
-  "author": "Borutovk7 <https://github.com/Borutovk7>",
-  "contributors": [
-    "Eduh Dev",
-    "Manus AI"
-  ],
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Borutovk7/StickEngine.git"
-  },
-  "dependencies": {
-    "axios": "^1.6.0",
-    "file-type": "^16.5.3",
-    "fluent-ffmpeg": "^2.1.2",
-    "jimp": "^0.22.10",
-    "node-fetch": "^2.6.1",
-    "node-webpmux": "^1.0.7",
-    "remove.bg": "^1.3.0"
-  },
-  "devDependencies": {
-    "@types/fluent-ffmpeg": "^2.1.28",
-    "@types/node": "^25.9.2",
-    "@types/node-fetch": "2.6.1",
-    "typescript": "^6.0.3"
-  }
-}

package/src/StickEngine.ts

@@ -1,221 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import axios, { AxiosRequestConfig } from 'axios';
-import { exec } from 'child_process';
-import { EventEmitter } from 'events';
-import ffmpeg from 'fluent-ffmpeg';
-// @ts-ignore
-import webpMux from 'node-webpmux';
-// @ts-ignore
-import Jimp from 'jimp';
-// @ts-ignore
-import { removeBackgroundFromImageFile } from 'remove.bg';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export interface StickerMetadata {
-  pack?: string;
-  author?: string;
-  emojis?: string[];
-}
-
-export interface StickEngineOptions {
-  webp?: boolean;
-  edit?: string | boolean;
-  convert?: boolean;
-  transparent?: string | string[] | false;
-  metadata?: StickerMetadata;
-}
-
-/**
- * Faz GET em uma URL e retorna o corpo como Buffer.
- * Fornecido pelo usuário para integração.
- */
-export const getBuffer = async (url: string, options: AxiosRequestConfig = {}): Promise<Buffer> => {
-  try {
-    const { data } = await axios({
-      method: 'get',
-      url,
-      headers: {
-        'user-agent': 'Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.128 Safari/537.36',
-        'DNT': '1',
-        'Upgrade-Insecure-Request': '1',
-      },
-      ...options,
-      responseType: 'arraybuffer',
-    });
-    return Buffer.from(data);
-  } catch (err) {
-    console.error(`Erro em getBuffer: ${err}`);
-    const errorImagePath = path.join(__dirname, 'src', 'emror.jpg');
-    if (fs.existsSync(errorImagePath)) {
-      return fs.readFileSync(errorImagePath);
-    }
-    return Buffer.alloc(0);
-  }
-};
-
-export class StickEngine extends EventEmitter {
-  public options: StickEngineOptions;
-  private tempDir: string;
-  private queue: any[];
-
-  constructor(options: StickEngineOptions = {}) {
-    super();
-    this.options = {
-      webp: true,
-      edit: false,
-      convert: false,
-      transparent: false,
-      metadata: {
-        pack: 'StickEngine',
-        author: 'Borutovk7 & Eduh Dev',
-        emojis: ['🥶']
-      },
-      ...options
-    };
-    this.tempDir = path.join(process.cwd(), 'tmp_stickengine');
-    if (!fs.existsSync(this.tempDir)) {
-      fs.mkdirSync(this.tempDir, { recursive: true });
-    }
-    this.queue = [];
-  }
-
-  public addFile(file: string | Buffer): this {
-    this.queue.push(file);
-    return this;
-  }
-
-  private async processFile(input: string | Buffer, index: number): Promise<string> {
-    let filePath: string;
-    let extension: string;
-    const timestamp = Date.now();
-
-    try {
-      this.emit('st.start', { index, input });
-
-      const ft = await import('file-type');
-      const fileTypeFunc = (ft as any).fromBuffer || (ft as any).fileTypeFromBuffer || (ft.default && ((ft.default as any).fromBuffer || (ft.default as any).fileTypeFromBuffer));
-
-      if (Buffer.isBuffer(input)) {
-        const type = await fileTypeFunc(input);
-        extension = type ? type.ext : 'bin';
-        filePath = path.join(this.tempDir, `input_${timestamp}_${index}.${extension}`);
-        fs.writeFileSync(filePath, input);
-      } else if (typeof input === 'string' && input.startsWith('http')) {
-        const buffer = await getBuffer(input);
-        const type = await fileTypeFunc(buffer);
-        extension = type ? type.ext : 'bin';
-        filePath = path.join(this.tempDir, `input_${timestamp}_${index}.${extension}`);
-        fs.writeFileSync(filePath, buffer);
-      } else if (typeof input === 'string' && fs.existsSync(input)) {
-        extension = path.extname(input).slice(1);
-        filePath = input;
-      } else {
-        throw new Error('Tipo de entrada inválido ou arquivo não encontrado.');
-      }
-
-      const metadata = await this.getMediaInfo(filePath);
-      this.emit('st.info', { index, ...metadata });
-
-      let currentFile = filePath;
-
-      if (this.options.transparent) {
-        const apiKey = Array.isArray(this.options.transparent) 
-          ? this.options.transparent[Math.floor(Math.random() * this.options.transparent.length)]
-          : this.options.transparent;
-        
-        if (typeof apiKey === 'string') {
-          const bgRemovedPath = path.join(this.tempDir, `nobg_${timestamp}_${index}.png`);
-          const result = await removeBackgroundFromImageFile({
-            path: currentFile,
-            apiKey,
-            size: 'auto',
-            type: 'auto'
-          });
-          fs.writeFileSync(bgRemovedPath, Buffer.from(result.base64img, 'base64'));
-          currentFile = bgRemovedPath;
-        }
-      }
-
-      const webpPath = path.join(this.tempDir, `sticker_${timestamp}_${index}.webp`);
-      await this.convertToWebp(currentFile, webpPath);
-      currentFile = webpPath;
-
-      if (this.options.metadata) {
-        await this.addExif(currentFile, this.options.metadata);
-      }
-
-      this.emit('st.data', { index, file: currentFile });
-      return currentFile;
-
-    } catch (error: any) {
-      this.emit('st.error', { index, error: error.message });
-      throw error;
-    }
-  }
-
-  private getMediaInfo(file: string): Promise<any> {
-    return new Promise((resolve, reject) => {
-      exec(`ffprobe -v error -select_streams v:0 -show_entries stream=width,height,duration -of csv=p=0:s=x ${file}`, (err, stdout) => {
-        if (err) return reject(err);
-        const [width, height, duration] = stdout.split('x');
-        resolve({
-          width: parseInt(width) || 0,
-          height: parseInt(height) || 0,
-          duration: parseFloat(duration) || 0
-        });
-      });
-    });
-  }
-
-  private convertToWebp(input: string, output: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-      ffmpeg(input)
-        .on('error', reject)
-        .on('end', () => resolve())
-        .addOutputOptions([
-          '-vcodec', 'libwebp',
-          '-vf', 'scale=512:512:force_original_aspect_ratio=decrease,fps=15,pad=512:512:(ow-iw)/2:(oh-ih)/2:color=#00000000,setsar=1',
-          '-lossless', '1',
-          '-loop', '0',
-          '-preset', 'default',
-          '-an',
-          '-vsync', '0'
-        ])
-        .toFormat('webp')
-        .save(output);
-    });
-  }
-
-  private async addExif(webpPath: string, metadata: StickerMetadata): Promise<void> {
-    const json = {
-      'sticker-pack-id': 'StickEngine-Manus',
-      'sticker-pack-name': metadata.pack || 'StickEngine',
-      'sticker-pack-publisher': metadata.author || 'Borutovk7 & Eduh Dev',
-      'emojis': metadata.emojis || ['🥶']
-    };
-
-    const Image = webpMux.Image || (webpMux.default && webpMux.default.Image);
-    const img = new Image();
-    const exifAttr = Buffer.from([0x49, 0x49, 0x2A, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00]);
-    const jsonBuff = Buffer.from(JSON.stringify(json), 'utf-8');
-    const exifBuffer = Buffer.concat([exifAttr, jsonBuff]);
-    exifBuffer.writeUIntLE(jsonBuff.length, 14, 4);
-
-    await img.load(webpPath);
-    img.exif = exifBuffer;
-    await img.save(webpPath);
-  }
-
-  public async start(): Promise<PromiseSettledResult<string>[]> {
-    if (this.queue.length === 0) throw new Error('Nenhum arquivo na fila.');
-    const results = await Promise.allSettled(this.queue.map((file, i) => this.processFile(file, i)));
-    this.queue = [];
-    return results;
-  }
-}
-
-export default StickEngine;

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "allowJs": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}