@boruto_vk7/stickengine 1.2.0 → 2.0.1

package/dist/esm/StickEngine.js

@@ -1,84 +1,137 @@
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
+import os from 'node:os';
 import { execFile } from 'node:child_process';
 import { EventEmitter } from 'node:events';
+import Crypto from 'node:crypto';
 import axios from 'axios';
 import ffmpeg from 'fluent-ffmpeg';
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
 import webpMux from 'node-webpmux';
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
 import Jimp from 'jimp';
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import { removeBackgroundFromImageFile } from 'remove.bg';
-import { fileURLToPath as __stick_fileURLToPath } from 'node:url';
-const moduleDir = path.dirname(__stick_fileURLToPath(import.meta.url));
-// ── Helpers ────────────────────────────────────────────────────────────────
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+let ffmpegPath = null;
+let ffprobePath = null;
+try {
+    const require = createRequire(import.meta.url);
+    const installer = require('@ffmpeg-installer/ffmpeg');
+    if (installer?.path) {
+        ffmpegPath = installer.path;
+        ffmpeg.setFfmpegPath(ffmpegPath);
+    }
+} catch {}
+try {
+    const require = createRequire(import.meta.url);
+    const installer = require('@ffprobe-installer/ffprobe');
+    if (installer?.path) {
+        ffprobePath = installer.path;
+        ffmpeg.setFfprobePath(ffprobePath);
+    }
+} catch {}
 export async function getBuffer(url, options = {}) {
     try {
         const { data } = await axios({
             method: 'get',
             url,
             headers: {
-                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-                DNT: '1',
+                '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.headers || {})
             },
             ...options,
             responseType: 'arraybuffer',
-            timeout: 45000,
+            timeout: options.timeout || 45000
         });
-        return Buffer.from(data);
+        return Buffer.isBuffer(data) ? data : Buffer.from(data);
     }
     catch (err) {
-        const fallback = path.join(moduleDir, 'emror.jpg');
-        if (fs.existsSync(fallback))
-            return fs.readFileSync(fallback);
-        throw new Error(`Failed to download: ${err instanceof Error ? err.message : String(err)}`);
+        const candidates = [
+            path.join(moduleDir, 'emror.jpg'),
+            path.join(moduleDir, '../src/emror.jpg'),
+            path.join(moduleDir, 'logo.png'),
+            path.join(process.cwd(), 'src/emror.jpg'),
+            path.join(process.cwd(), 'dist/cjs/emror.jpg'),
+            path.join(process.cwd(), 'dist/esm/emror.jpg'),
+            path.join(os.tmpdir(), 'emror.jpg'),
+            path.resolve('./src/emror.jpg')
+        ];
+        for (const p of candidates) {
+            try {
+                if (fs.existsSync(p))
+                    return fs.readFileSync(p);
+            }
+            catch { }
+        }
+        return Buffer.alloc(0);
     }
 }
 function resolveWebpImage() {
-    const Image = webpMux.Image || webpMux.default?.Image;
+    const Image = webpMux.Image || webpMux.default?.Image || webpMux.default;
     if (!Image)
         throw new Error('node-webpmux Image class not found');
     return Image;
 }
 async function fileTypeFromBuf(buf) {
-    const ft = await import('file-type');
-    const mod = ft;
-    const fn = mod.fileTypeFromBuffer ||
-        mod.fromBuffer ||
-        mod.default?.fileTypeFromBuffer ||
-        mod.default?.fromBuffer;
-    if (!fn)
-        return undefined;
-    return fn(buf);
+    try {
+        const ft = await import('file-type');
+        const fn = ft.fileTypeFromBuffer || ft.fromBuffer || ft.default?.fileTypeFromBuffer || ft.default?.fromBuffer;
+        if (!fn)
+            return undefined;
+        return await fn(buf);
+    }
+    catch {
+        try {
+            const ft = eval("require")('file-type');
+            const fn = ft.fileTypeFromBuffer || ft.fromBuffer || ft.default?.fileTypeFromBuffer || ft.default?.fromBuffer;
+            if (!fn)
+                return undefined;
+            return await fn(buf);
+        }
+        catch {
+            return undefined;
+        }
+    }
 }
 function isHttp(s) {
     return /^https?:\/\//i.test(s);
 }
-// ── Engine ─────────────────────────────────────────────────────────────────
-/**
- * WhatsApp sticker engine (static + animated WebP + EXIF pack metadata).
- *
- * @example
- * ```ts
- * import StickEngine from '@boruto_vk7/stickengine';
- *
- * const sticker = await StickEngine.create('./cat.gif', {
- *   metadata: { pack: 'My Pack', author: 'Me' },
- * });
- * // sticker.buffer  → send to WhatsApp
- * // sticker.path    → temp file path
- * ```
- */
+function isDataURI(s) {
+    return /^data:.*?\/.*?;base64,/i.test(s);
+}
+function parseDataURItoBuffer(dataURI) {
+    const base64 = dataURI.split(',')[1];
+    return Buffer.from(base64, 'base64');
+}
+function normalizeMetadata(options = {}) {
+    const meta = options.metadata || options;
+    const pack = meta.packname || meta.pack || options.packname || options.pack || 'Lagos Solutions';
+    const author = meta.author || options.author || 'StickEngine';
+    const emojis = meta.categories || meta.emojis || options.categories || options.emojis || ['✨'];
+    const id = meta.id || options.id;
+    return { pack, author, emojis, id };
+}
+function resolveTempDir(options) {
+    const dir = options.tempDir || options.dirTemp || options.Dirtemp || options.DirTemp || options.dirtemp || options.TempDir || path.join(os.tmpdir(), 'stickengine');
+    return path.resolve(dir);
+}
+function resolveWatermark(options) {
+    const wm = options.watermark ?? options.marcaDagua ?? options.marca_agua ?? options.MarcaDaAgua ?? options.marcaDaAgua ?? false;
+    return wm;
+}
 export class StickEngine extends EventEmitter {
+    options;
+    tempDir;
+    queue = [];
+    createdFiles = [];
     constructor(options = {}) {
         super();
-        this.queue = [];
-        this.createdFiles = [];
+        const normalizedMeta = normalizeMetadata(options);
+        this.tempDir = resolveTempDir(options);
+        fs.mkdirSync(this.tempDir, { recursive: true });
+        const watermarkValue = resolveWatermark(options);
         this.options = {
             webp: true,
             edit: false,
@@ -88,44 +141,44 @@ export class StickEngine extends EventEmitter {
             quality: 75,
             maxDuration: 6,
             fit: 'natural',
-            metadata: {
-                pack: 'StickEngine',
-                author: 'Borutovk7',
-                emojis: ['✨'],
-            },
+            watermark: watermarkValue,
             ...options,
+            tempDir: this.tempDir,
+            dirTemp: this.tempDir,
+            metadata: {
+                pack: normalizedMeta.pack,
+                author: normalizedMeta.author,
+                emojis: normalizedMeta.emojis,
+                id: normalizedMeta.id,
+                ...(options.metadata || {})
+            }
         };
-        this.tempDir = path.resolve(options.tempDir || path.join(process.cwd(), 'tmp_stickengine'));
-        fs.mkdirSync(this.tempDir, { recursive: true });
+        if (options.packname)
+            this.options.metadata.pack = options.packname;
+        if (options.author)
+            this.options.metadata.author = options.author;
+        if (options.categories)
+            this.options.metadata.emojis = options.categories;
+        const wm = resolveWatermark(options);
+        if (wm !== undefined)
+            this.options.watermark = wm;
     }
-    // ── One-shot API (simplest) ──────────────────────────────────────────────
-    /**
-     * Create a sticker in one call. Returns path + buffer + base64.
-     */
     static async create(input, options = {}) {
         const engine = new StickEngine({ ...options, autoClean: false });
-        try {
-            return await engine.build(input);
-        }
-        finally {
-            // keep result file; drop other temps if any
-        }
+        return await engine.build(input);
     }
-    /**
-     * Create sticker and return only the Buffer (handy for bots).
-     */
     static async toBuffer(input, options = {}) {
         const r = await StickEngine.create(input, options);
         return r.buffer;
     }
-    /**
-     * Create sticker and return base64 string.
-     */
     static async toBase64String(input, options = {}) {
         const r = await StickEngine.create(input, options);
         return r.base64;
     }
-    /** Instance one-shot (uses constructor options). */
+    static async toFile(input, options = {}) {
+        const r = await StickEngine.create(input, options);
+        return r.path;
+    }
     async build(input) {
         const filePath = await this.processFile(input, 0);
         const buffer = await fsp.readFile(filePath);
@@ -138,12 +191,11 @@ export class StickEngine extends EventEmitter {
             animated,
             width: info.width || 512,
             height: info.height || 512,
-            size: buffer.length,
+            size: buffer.length
         };
         this.emit('st.done', result);
         return result;
     }
-    // ── Queue API (batch) ────────────────────────────────────────────────────
     addFile(file) {
         this.queue.push(file);
         return this;
@@ -152,81 +204,59 @@ export class StickEngine extends EventEmitter {
         this.queue.push(...files);
         return this;
     }
-    /**
-     * Process the queue. Returns settled results with `value` = absolute path.
-     * Prefer `build()` / `StickEngine.create()` for a simpler API.
-     */
     async start() {
         if (!this.queue.length)
-            throw new Error('Queue is empty. Use addFile() or StickEngine.create().');
-        const jobs = this.queue.map((file, i) => this.processFile(file, i));
+            throw new Error('Queue is empty');
+        const jobs = this.queue.map((f, i) => this.processFile(f, i));
         this.queue = [];
         return Promise.allSettled(jobs);
     }
-    /** Delete tracked temp files. */
     clean() {
         for (const file of this.createdFiles) {
             try {
                 if (fs.existsSync(file))
                     fs.unlinkSync(file);
             }
-            catch {
-                /* ignore */
-            }
+            catch { }
         }
         this.createdFiles = [];
     }
-    // ── Core pipeline ────────────────────────────────────────────────────────
     track(file) {
         this.createdFiles.push(file);
         return file;
     }
     async processFile(input, index) {
-        const ts = `${Date.now()}_${index}_${Math.random().toString(36).slice(2, 7)}`;
+        const ts = `${Date.now()}_${index}_${Crypto.randomBytes(3).toString('hex')}`;
         const local = [];
         try {
-            this.emit('st.start', { index, input: typeof input === 'string' ? input : '<buffer>' });
+            this.emit('st.start', { index, input: typeof input === 'string' ? (input.length > 100 ? input.slice(0, 100) + '...' : input) : '<buffer>' });
             const { filePath, extension } = await this.materializeInput(input, ts);
-            local.push(filePath);
+            if (filePath.includes(this.tempDir))
+                local.push(filePath);
             const mediaInfo = await this.getMediaInfo(filePath);
             this.emit('st.info', { index, ...mediaInfo, extension });
             let current = filePath;
-            let animated = mediaInfo.duration > 0.05 ||
-                ['gif', 'mp4', 'webm', 'mov', 'mkv', 'avi'].includes(extension) ||
-                (extension === 'webp' && (await this.detectAnimatedWebp(filePath)));
-            // Static edits only
+            let animated = mediaInfo.duration > 0.05 || ['gif', 'mp4', 'webm', 'mov', 'mkv', 'avi'].includes(extension) || (extension === 'webp' && await this.detectAnimatedWebp(filePath));
             if (this.options.edit && !animated) {
                 const edited = path.join(this.tempDir, `edited_${ts}.png`);
                 await this.applyJimpEdits(current, edited, this.options.edit);
                 local.push(edited);
                 current = edited;
             }
-            // remove.bg static only
-            if (this.options.transparent && !animated) {
-                const key = Array.isArray(this.options.transparent)
-                    ? this.options.transparent[Math.floor(Math.random() * this.options.transparent.length)]
-                    : this.options.transparent;
-                if (typeof key === 'string' && key.length > 5) {
-                    const out = path.join(this.tempDir, `nobg_${ts}.png`);
-                    const result = await removeBackgroundFromImageFile({
-                        path: current,
-                        apiKey: key,
-                        size: 'auto',
-                        type: 'auto',
-                    });
-                    fs.writeFileSync(out, Buffer.from(result.base64img, 'base64'));
-                    local.push(out);
-                    current = out;
-                }
+            const watermark = this.options.watermark;
+            if (watermark && !animated) {
+                const watermarked = path.join(this.tempDir, `wm_${ts}.png`);
+                await this.applyWatermark(current, watermarked, watermark);
+                local.push(watermarked);
+                current = watermarked;
             }
             const webpPath = path.join(this.tempDir, `sticker_${ts}.webp`);
             await this.convertToWebp(current, webpPath, animated);
             local.push(webpPath);
             current = webpPath;
-            // Re-check after ffmpeg (source of truth)
             animated = await this.detectAnimatedWebp(current);
-            if (this.options.metadata !== undefined && this.options.metadata !== null) {
-                await this.addExif(current, this.options.metadata || {});
+            if (this.options.metadata) {
+                await this.addExif(current, this.options.metadata);
             }
             for (const f of local)
                 this.track(f);
@@ -240,89 +270,93 @@ export class StickEngine extends EventEmitter {
                     if (fs.existsSync(f))
                         fs.unlinkSync(f);
                 }
-                catch {
-                    /* ignore */
-                }
+                catch { }
             }
             throw error;
         }
     }
     async materializeInput(input, ts) {
         if (Buffer.isBuffer(input)) {
+            if (input.length === 0)
+                throw new Error('Buffer vazio');
             const type = await fileTypeFromBuf(input);
-            const extension = type?.ext || 'bin';
+            const extension = type?.ext || 'png';
             const filePath = path.join(this.tempDir, `input_${ts}.${extension}`);
             fs.writeFileSync(filePath, input);
             return { filePath, extension };
         }
-        if (typeof input === 'string' && isHttp(input)) {
-            const buffer = await getBuffer(input);
-            const type = await fileTypeFromBuf(buffer);
-            const extension = type?.ext || 'bin';
-            const filePath = path.join(this.tempDir, `input_${ts}.${extension}`);
-            fs.writeFileSync(filePath, buffer);
-            return { filePath, extension };
-        }
-        if (typeof input === 'string' && fs.existsSync(input)) {
-            const filePath = path.resolve(input);
-            const extension = path.extname(filePath).replace('.', '').toLowerCase() || 'bin';
-            return { filePath, extension };
+        if (typeof input === 'string') {
+            if (isDataURI(input)) {
+                const buffer = parseDataURItoBuffer(input);
+                if (buffer.length === 0)
+                    throw new Error('Base64 inválido');
+                const type = await fileTypeFromBuf(buffer);
+                const extension = type?.ext || 'png';
+                const filePath = path.join(this.tempDir, `input_${ts}.${extension}`);
+                fs.writeFileSync(filePath, buffer);
+                return { filePath, extension };
+            }
+            if (isHttp(input)) {
+                const buffer = await getBuffer(input);
+                if (buffer.length === 0)
+                    throw new Error('Falha ao baixar');
+                const type = await fileTypeFromBuf(buffer);
+                const extension = type?.ext || path.extname(new URL(input).pathname).replace('.', '') || 'bin';
+                const filePath = path.join(this.tempDir, `input_${ts}.${extension}`);
+                fs.writeFileSync(filePath, buffer);
+                return { filePath, extension: extension.toLowerCase() };
+            }
+            if (fs.existsSync(input)) {
+                const filePath = path.resolve(input);
+                const extension = path.extname(filePath).replace('.', '').toLowerCase() || 'bin';
+                return { filePath, extension };
+            }
+            if (/^[A-Za-z0-9+/=]+$/.test(input.slice(0, 100)) && input.length > 100) {
+                try {
+                    const buffer = Buffer.from(input, 'base64');
+                    if (buffer.length > 50) {
+                        const type = await fileTypeFromBuf(buffer);
+                        if (type) {
+                            const filePath = path.join(this.tempDir, `input_${ts}.${type.ext}`);
+                            fs.writeFileSync(filePath, buffer);
+                            return { filePath, extension: type.ext };
+                        }
+                    }
+                }
+                catch { }
+            }
+            throw new Error('Invalid input: ' + input);
         }
-        throw new Error('Invalid input. Pass a file path, http(s) URL, or Buffer.');
+        throw new Error('Invalid input type');
     }
-    // ── EXIF (fixes animated save error) ─────────────────────────────────────
-    /**
-     * Write WhatsApp sticker pack EXIF.
-     * Animated WebP MUST use muxAnim — save() throws on animations.
-     */
     async addExif(webpPath, metadata) {
         const Image = resolveWebpImage();
         const img = new Image();
         const json = {
             'sticker-pack-id': metadata.id || `stickengine-${Date.now()}`,
-            'sticker-pack-name': metadata.pack || 'StickEngine',
-            'sticker-pack-publisher': metadata.author || 'Borutovk7',
-            emojis: metadata.emojis?.length ? metadata.emojis : ['✨'],
+            'sticker-pack-name': metadata.pack || 'Lagos Solutions',
+            'sticker-pack-publisher': metadata.author || 'StickEngine',
+            'emojis': metadata.emojis?.length ? metadata.emojis : metadata.categories?.length ? metadata.categories : ['✨']
         };
-        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 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 exif = Buffer.concat([exifAttr, jsonBuff]);
         exif.writeUIntLE(jsonBuff.length, 14, 4);
         await img.load(webpPath);
         img.exif = exif;
-        const frameCount = typeof img.frameCount === 'number'
-            ? img.frameCount
-            : Array.isArray(img.frames)
-                ? img.frames.length
-                : 0;
+        const frameCount = typeof img.frameCount === 'number' ? img.frameCount : Array.isArray(img.frames) ? img.frames.length : 0;
         const animated = !!img.hasAnim || frameCount > 1;
-        /**
-         * node-webpmux compatibility layer
-         *
-         * v3.x (current):
-         *   await img.save(path)  // works for static AND animated (passes frames)
-         *
-         * v1.x / early forks:
-         *   static  → img.save(path)
-         *   anim    → img.muxAnim({ path, exif: true })  OR  Image.muxAnim({ frames, exif, path })
-         *   calling save() on anim throws:
-         *   "Using `save` for animations is not currently supported. Use `muxAnim` instead"
-         */
         const saveV3 = async () => {
-            // v3 instance save supports both; pass exif explicitly when supported
             return img.save(webpPath, {
                 exif: true,
                 frames: animated ? img.frames : undefined,
                 width: img.width,
                 height: img.height,
                 loops: img.anim?.loops ?? img.anim?.loopCount ?? 0,
-                bgColor: img.anim?.bgColor ?? img.anim?.backgroundColor ?? [0, 0, 0, 0],
+                bgColor: img.anim?.bgColor ?? img.anim?.backgroundColor ?? [0, 0, 0, 0]
             });
         };
-        const saveLegacyMuxAnim = async () => {
+        const saveLegacy = async () => {
             const opts = {
                 path: webpPath,
                 frames: img.frames || [],
@@ -330,22 +364,12 @@ export class StickEngine extends EventEmitter {
                 height: img.height || 512,
                 loops: img.anim?.loopCount ?? img.anim?.loops ?? 0,
                 bgColor: img.anim?.backgroundColor ?? img.anim?.bgColor ?? [0, 0, 0, 0],
-                exif,
+                exif
             };
-            if (typeof img.muxAnim === 'function') {
-                return img.muxAnim({
-                    path: webpPath,
-                    exif: true,
-                    width: opts.width,
-                    height: opts.height,
-                    loops: opts.loops,
-                    bgColor: opts.bgColor,
-                });
-            }
-            if (typeof Image.muxAnim === 'function') {
+            if (typeof img.muxAnim === 'function')
+                return img.muxAnim({ path: webpPath, exif: true, width: opts.width, height: opts.height, loops: opts.loops, bgColor: opts.bgColor });
+            if (typeof Image.muxAnim === 'function')
                 return Image.muxAnim(opts);
-            }
-            // absolute last resort: try plain save (v3)
             return img.save(webpPath);
         };
         try {
@@ -355,41 +379,31 @@ export class StickEngine extends EventEmitter {
                 }
                 catch (err) {
                     const msg = String(err?.message || err);
-                    if (/muxAnim|animations is not currently supported|Using `save`/i.test(msg)) {
-                        await saveLegacyMuxAnim();
-                    }
+                    if (/muxAnim|not currently supported/i.test(msg))
+                        await saveLegacy();
                     else if (animated) {
-                        // some builds want save without second arg
                         try {
                             await img.save(webpPath);
                         }
-                        catch (err2) {
-                            const m2 = String(err2?.message || err2);
-                            if (/muxAnim|animations is not currently supported|Using `save`/i.test(m2)) {
-                                await saveLegacyMuxAnim();
-                            }
-                            else {
-                                throw err2;
-                            }
+                        catch (e2) {
+                            if (/muxAnim|not currently supported/i.test(String(e2?.message)))
+                                await saveLegacy();
+                            else
+                                throw e2;
                         }
                     }
-                    else {
+                    else
                         throw err;
-                    }
                 }
             }
-            else if (typeof Image.save === 'function') {
-                // very old static save(path, image)
+            else if (typeof Image.save === 'function')
                 await Image.save(webpPath, img);
-            }
-            else {
-                await saveLegacyMuxAnim();
-            }
+            else
+                await saveLegacy();
         }
         catch (err) {
-            const msg = String(err?.message || err);
-            if (/muxAnim|animations is not currently supported|Using `save`/i.test(msg)) {
-                await saveLegacyMuxAnim();
+            if (/muxAnim|not currently supported/i.test(String(err?.message))) {
+                await saveLegacy();
                 return;
             }
             throw err;
@@ -402,91 +416,51 @@ export class StickEngine extends EventEmitter {
             const Image = resolveWebpImage();
             const img = new Image();
             await img.load(filePath);
-            return (!!img.hasAnim ||
-                (typeof img.frameCount === 'number' && img.frameCount > 1) ||
-                (Array.isArray(img.frames) && img.frames.length > 1));
+            return !!img.hasAnim || (typeof img.frameCount === 'number' && img.frameCount > 1) || (Array.isArray(img.frames) && img.frames.length > 1);
         }
         catch {
             return false;
         }
     }
-    // ── FFmpeg / Jimp ────────────────────────────────────────────────────────
-    /**
-     * Build FFmpeg -vf chain.
-     *
-     * Normal WhatsApp stickers are NOT forced square:
-     * the longest side becomes 512 and the other side stays proportional
-     * (e.g. 512×320 or 280×512) with real alpha — same look as hand-made stickers.
-     */
     buildScaleFilter(isAnimated, fps) {
         const fit = this.options.fit || 'natural';
         const parts = ['format=rgba'];
-        if (isAnimated) {
+        if (isAnimated)
             parts.push(`fps=${Math.max(1, fps)}`);
-        }
         switch (fit) {
             case 'cover':
-                // Force square sticker: fill 512×512, center-crop overflow
                 parts.push('scale=512:512:force_original_aspect_ratio=increase:flags=lanczos', 'crop=512:512:(iw-ow)/2:(ih-oh)/2');
                 break;
             case 'contain':
-                // Full image inside a square 512×512 with transparent pad (no black bars)
                 parts.push('scale=512:512:force_original_aspect_ratio=decrease:flags=lanczos', 'pad=512:512:(ow-iw)/2:(oh-ih)/2:color=black@0');
                 break;
             case 'fill':
                 parts.push('scale=512:512:flags=lanczos');
                 break;
             case 'none':
-                // Shrink only if larger than 512; never upscale; keep ratio
                 parts.push("scale='min(512,iw)':'min(512,ih)':force_original_aspect_ratio=decrease:flags=lanczos");
                 break;
-            case 'natural':
             default:
-                // DEFAULT — real WhatsApp sticker geometry:
-                // longest side = 512, other side proportional, NO pad, NO crop
-                // Example: 1080×1920 → 288×512 | 1920×1080 → 512×288
-                parts.push(
-                // -2 keeps aspect and forces even dims (friendlier for some encoders)
-                "scale='if(gt(iw,ih),512,-2)':'if(gt(ih,iw),512,-2)':flags=lanczos");
+                parts.push("scale='if(gt(iw,ih),512,-2)':'if(gt(ih,iw),512,-2)':flags=lanczos");
                 break;
         }
-        // Ensure even width/height (webp/yuv safety) without changing aspect much
         parts.push("scale=trunc(iw/2)*2:trunc(ih/2)*2:flags=lanczos", 'setsar=1', 'format=rgba');
         return parts.join(',');
     }
     async convertToWebp(input, output, isAnimated) {
         const run = (quality, fps) => new Promise((resolve, reject) => {
-            const ff = ffmpeg(input).on('error', reject).on('end', () => resolve());
             const vf = this.buildScaleFilter(isAnimated, fps);
             const q = Math.max(1, Math.min(100, quality));
-            const opts = [
-                '-vcodec',
-                'libwebp',
-                '-vf',
-                vf,
-                '-loop',
-                '0',
-                '-an',
-                '-vsync',
-                '0',
-                '-preset',
-                'default',
-            ];
-            if (isAnimated) {
-                // Animated: lossy + size budget
+            const opts = ['-vcodec', 'libwebp', '-vf', vf, '-loop', '0', '-an', '-vsync', '0', '-preset', 'default'];
+            if (isAnimated)
                 opts.push('-lossless', '0', '-compression_level', '6', '-q:v', String(q), '-quality', String(q), '-t', String(this.options.maxDuration || 6));
-            }
-            else {
-                // Static anime/art stickers look much better near-lossless
+            else
                 opts.push('-lossless', q >= 90 ? '1' : '0', '-compression_level', '6', '-q:v', String(q), '-quality', String(q));
-            }
-            ff.addOutputOptions(opts).toFormat('webp').save(output);
+            ffmpeg(input).on('error', reject).on('end', () => resolve()).addOutputOptions(opts).toFormat('webp').save(output);
         });
-        // Static defaults higher quality; animated stays flexible for 1MB cap
         let quality = this.options.quality ?? (isAnimated ? 80 : 95);
         let fps = this.options.fps ?? 15;
         await run(quality, fps);
-        // WhatsApp animated stickers should stay under ~1MB
         if (isAnimated && fs.existsSync(output)) {
             let attempts = 0;
             while (fs.statSync(output).size > 1000000 && attempts < 4) {
@@ -496,9 +470,8 @@ export class StickEngine extends EventEmitter {
                 attempts++;
             }
         }
-        if (!fs.existsSync(output) || fs.statSync(output).size < 20) {
-            throw new Error('FFmpeg failed to produce a valid WebP sticker.');
-        }
+        if (!fs.existsSync(output) || fs.statSync(output).size < 20)
+            throw new Error('FFmpeg failed');
     }
     async applyJimpEdits(input, output, options) {
         const image = await Jimp.read(input);
@@ -521,98 +494,267 @@ export class StickEngine extends EventEmitter {
         if (options.text?.content) {
             const fontPath = options.text.color === 'BLACK' ? Jimp.FONT_SANS_32_BLACK : Jimp.FONT_SANS_32_WHITE;
             const font = await Jimp.loadFont(fontPath);
-            const printOptions = {
-                text: options.text.content,
-                alignmentX: options.text.alignmentX || Jimp.HORIZONTAL_ALIGN_CENTER,
-                alignmentY: options.text.alignmentY || Jimp.VERTICAL_ALIGN_BOTTOM,
-            };
+            const printOptions = { text: options.text.content, alignmentX: options.text.alignmentX || Jimp.HORIZONTAL_ALIGN_CENTER, alignmentY: options.text.alignmentY || Jimp.VERTICAL_ALIGN_BOTTOM };
             if (options.text.stroke) {
                 const strokeFont = await Jimp.loadFont(options.text.color === 'BLACK' ? Jimp.FONT_SANS_32_WHITE : Jimp.FONT_SANS_32_BLACK);
-                for (let x = -2; x <= 2; x++) {
-                    for (let y = -2; y <= 2; y++) {
-                        if (x !== 0 || y !== 0) {
+                for (let x = -2; x <= 2; x++)
+                    for (let y = -2; y <= 2; y++)
+                        if (x !== 0 || y !== 0)
                             image.print(strokeFont, x, y, printOptions, image.bitmap.width, image.bitmap.height);
-                        }
-                    }
-                }
             }
             image.print(font, 0, 0, printOptions, image.bitmap.width, image.bitmap.height);
         }
         await image.writeAsync(output);
     }
-    getMediaInfo(file) {
-        return new Promise((resolve) => {
-            const args = [
-                '-v',
-                'error',
-                '-select_streams',
-                'v:0',
-                '-show_entries',
-                'stream=width,height,duration',
-                '-of',
-                'csv=p=0:s=x',
-                file,
+    async applyWatermark(input, output, watermark) {
+        const findLogo = () => {
+            const candidates = [
+                path.join(moduleDir, 'logo.png'),
+                path.join(moduleDir, '../src/logo.png'),
+                path.join(moduleDir, '../logo.png'),
+                path.join(process.cwd(), 'logo.png'),
+                path.join(process.cwd(), 'src/logo.png'),
+                path.join(process.cwd(), 'dist/cjs/logo.png'),
+                path.join(process.cwd(), 'dist/esm/logo.png'),
+                path.resolve('./logo.png')
             ];
-            execFile('ffprobe', args, { timeout: 20000 }, (err, stdout) => {
+            for (const p of candidates) {
+                try {
+                    if (fs.existsSync(p) && fs.statSync(p).size > 100)
+                        return p;
+                }
+                catch { }
+            }
+            return null;
+        };
+        let isImageWatermark = false;
+        let logoPath = null;
+        let text = 'Lagos Solutions';
+        let position = 'bottom-right';
+        let margin = 10;
+        let sizePercent = 0.25;
+        if (watermark === true) {
+            isImageWatermark = true;
+            logoPath = findLogo();
+        }
+        else if (typeof watermark === 'string') {
+            const possiblePath = path.resolve(watermark);
+            if ((watermark.endsWith('.png') || watermark.endsWith('.jpg') || watermark.endsWith('.jpeg') || watermark.endsWith('.webp')) && fs.existsSync(possiblePath)) {
+                isImageWatermark = true;
+                logoPath = possiblePath;
+            }
+            else if (fs.existsSync(watermark)) {
+                isImageWatermark = true;
+                logoPath = watermark;
+            }
+            else {
+                text = watermark;
+                isImageWatermark = false;
+            }
+        }
+        else if (typeof watermark === 'object') {
+            text = watermark.text || text;
+            position = watermark.position || position;
+            margin = watermark.margin ?? margin;
+            sizePercent = watermark.size ?? watermark.sizePercent ?? sizePercent;
+            if (watermark.image || watermark.logo || watermark.path) {
+                isImageWatermark = true;
+                logoPath = watermark.image || watermark.logo || watermark.path;
+                if (logoPath && !fs.existsSync(logoPath)) {
+                    const resolved = path.resolve(logoPath);
+                    if (fs.existsSync(resolved))
+                        logoPath = resolved;
+                    else
+                        logoPath = findLogo();
+                }
+            }
+            else if (watermark.text) {
+                isImageWatermark = false;
+            }
+            else {
+                isImageWatermark = true;
+                logoPath = findLogo();
+            }
+        }
+        if (isImageWatermark) {
+            if (!logoPath)
+                logoPath = findLogo();
+            if (!logoPath || !fs.existsSync(logoPath)) {
+                fs.copyFileSync(input, output);
+                return;
+            }
+            try {
+                const main = await Jimp.read(input);
+                const logo = await Jimp.read(logoPath);
+                const mainWidth = main.bitmap.width;
+                const mainHeight = main.bitmap.height;
+                const logoTargetWidth = Math.floor(mainWidth * sizePercent);
+                logo.resize(logoTargetWidth, Jimp.AUTO);
+                if (typeof watermark === 'object' && watermark.opacity !== undefined) {
+                    logo.opacity(watermark.opacity);
+                }
+                else {
+                    logo.opacity(0.85);
+                }
+                let x = mainWidth - logo.bitmap.width - margin;
+                let y = mainHeight - logo.bitmap.height - margin;
+                if (position === 'bottom-left') {
+                    x = margin;
+                    y = mainHeight - logo.bitmap.height - margin;
+                }
+                if (position === 'top-right') {
+                    x = mainWidth - logo.bitmap.width - margin;
+                    y = margin;
+                }
+                if (position === 'top-left') {
+                    x = margin;
+                    y = margin;
+                }
+                if (position === 'center') {
+                    x = (mainWidth - logo.bitmap.width) / 2;
+                    y = (mainHeight - logo.bitmap.height) / 2;
+                }
+                main.composite(logo, x, y, { mode: Jimp.BLEND_SOURCE_OVER, opacitySource: 1, opacityDest: 1 });
+                await main.writeAsync(output);
+                return;
+            }
+            catch {
+                fs.copyFileSync(input, output);
+                return;
+            }
+        }
+        if (!text) {
+            fs.copyFileSync(input, output);
+            return;
+        }
+        const image = await Jimp.read(input);
+        const font = await Jimp.loadFont(Jimp.FONT_SANS_16_WHITE);
+        const textWidth = Jimp.measureText(font, text);
+        const textHeight = Jimp.measureTextHeight(font, text, image.bitmap.width);
+        let x = image.bitmap.width - textWidth - margin;
+        let y = image.bitmap.height - textHeight - margin;
+        if (position === 'bottom-left') {
+            x = margin;
+            y = image.bitmap.height - textHeight - margin;
+        }
+        if (position === 'top-right') {
+            x = image.bitmap.width - textWidth - margin;
+            y = margin;
+        }
+        if (position === 'top-left') {
+            x = margin;
+            y = margin;
+        }
+        if (position === 'center') {
+            x = (image.bitmap.width - textWidth) / 2;
+            y = (image.bitmap.height - textHeight) / 2;
+        }
+        const bg = new Jimp(textWidth + 10, textHeight + 6, 0x00000088);
+        image.composite(bg, x - 5, y - 3);
+        image.print(font, x, y, text);
+        await image.writeAsync(output);
+    }
+    getMediaInfo(file) {
+        const probePath = ffprobePath || 'ffprobe';
+        return new Promise(resolve => {
+            execFile(probePath, ['-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=width,height,duration', '-of', 'csv=p=0:s=x', file], { timeout: 20000 }, (err, stdout) => {
                 if (err)
                     return resolve({ width: 0, height: 0, duration: 0 });
                 const parts = String(stdout).trim().split('x');
-                resolve({
-                    width: parseInt(parts[0], 10) || 0,
-                    height: parseInt(parts[1], 10) || 0,
-                    duration: parseFloat(parts[2]) || 0,
-                });
+                resolve({ width: parseInt(parts[0], 10) || 0, height: parseInt(parts[1], 10) || 0, duration: parseFloat(parts[2]) || 0 });
             });
         });
     }
-    // ── Extras ───────────────────────────────────────────────────────────────
     static fileToBase64(filePath) {
         return fs.readFileSync(filePath).toString('base64');
     }
-    /** 96×96 tray icon WebP for sticker packs. */
-    async createTrayIcon(input) {
-        const ts = Date.now();
-        const pngPath = path.join(this.tempDir, `tray_${ts}.png`);
-        const webpPath = path.join(this.tempDir, `tray_${ts}.webp`);
-        let buffer;
-        if (Buffer.isBuffer(input))
-            buffer = input;
-        else if (typeof input === 'string' && isHttp(input))
-            buffer = await getBuffer(input);
-        else if (typeof input === 'string' && fs.existsSync(input))
-            buffer = fs.readFileSync(input);
-        else
-            throw new Error('Invalid tray icon input.');
-        const image = await Jimp.read(buffer);
-        await image.cover(96, 96).writeAsync(pngPath);
-        await new Promise((resolve, reject) => {
-            ffmpeg(pngPath)
-                .on('error', reject)
-                .on('end', () => resolve())
-                .addOutputOptions(['-vcodec', 'libwebp', '-lossless', '1', '-q:v', '80'])
-                .toFormat('webp')
-                .save(webpPath);
-        });
-        this.track(pngPath);
-        this.track(webpPath);
-        return webpPath;
+}
+export async function sendImageAsSticker(conn, jid, input, quoted, options = {}) {
+    const normalized = normalizeMetadata(options);
+    const engine = new StickEngine({
+        metadata: { pack: normalized.pack, author: normalized.author, emojis: normalized.emojis, id: normalized.id },
+        fit: options.fit || 'natural',
+        quality: options.quality ?? 95,
+        tempDir: resolveTempDir(options),
+        watermark: resolveWatermark(options),
+        ...options
+    });
+    let finalInput = input;
+    if (typeof input === 'string') {
+        if (isDataURI(input))
+            finalInput = parseDataURItoBuffer(input);
+        else if (isHttp(input))
+            finalInput = await getBuffer(input);
+    }
+    const result = await engine.build(finalInput);
+    await conn.sendMessage(jid, { sticker: { url: result.buffer }, ...options }, { quoted });
+    return result.buffer;
+}
+export async function sendVideoAsSticker(conn, jid, input, quoted, options = {}) {
+    const normalized = normalizeMetadata(options);
+    const engine = new StickEngine({
+        metadata: { pack: normalized.pack, author: normalized.author, emojis: normalized.emojis, id: normalized.id },
+        fit: options.fit || 'natural',
+        fps: options.fps || 15,
+        maxDuration: options.maxDuration || 6,
+        quality: options.quality ?? 80,
+        tempDir: resolveTempDir(options),
+        watermark: resolveWatermark(options),
+        ...options
+    });
+    let finalInput = input;
+    if (typeof input === 'string') {
+        if (isDataURI(input))
+            finalInput = parseDataURItoBuffer(input);
+        else if (isHttp(input))
+            finalInput = await getBuffer(input);
     }
-    /** Text-only sticker (transparent 512×512). */
-    async createTextSticker(text, options = {}) {
-        const ts = Date.now();
-        const pngPath = path.join(this.tempDir, `text_${ts}.png`);
-        const image = new Jimp(512, 512, options.background ?? 0x00000000);
-        const fontPath = options.color === 'BLACK' ? Jimp.FONT_SANS_64_BLACK : Jimp.FONT_SANS_64_WHITE;
-        const font = await Jimp.loadFont(fontPath);
-        image.print(font, 0, 0, {
-            text,
-            alignmentX: Jimp.HORIZONTAL_ALIGN_CENTER,
-            alignmentY: Jimp.VERTICAL_ALIGN_MIDDLE,
-        }, 512, 512);
-        await image.writeAsync(pngPath);
-        this.track(pngPath);
-        return this.build(pngPath);
+    const result = await engine.build(finalInput);
+    await conn.sendMessage(jid, { sticker: { url: result.buffer }, ...options }, { quoted });
+    return result.buffer;
+}
+export const sendImageAsSticker2 = sendImageAsSticker;
+export const sendVideoAsSticker2 = sendVideoAsSticker;
+export async function imageToWebp(media) {
+    const engine = new StickEngine({ fit: 'natural', quality: 95 });
+    const ts = `${Date.now()}_${Crypto.randomBytes(3).toString('hex')}`;
+    const filePath = path.join(engine.tempDir, `img_${ts}.png`);
+    fs.writeFileSync(filePath, media);
+    const out = path.join(engine.tempDir, `out_${ts}.webp`);
+    await engine.convertToWebp(filePath, out, false);
+    const buf = fs.readFileSync(out);
+    try {
+        fs.unlinkSync(filePath);
+        fs.unlinkSync(out);
     }
+    catch { }
+    return buf;
+}
+export async function videoToWebp(media) {
+    const engine = new StickEngine({ fit: 'natural', fps: 15, maxDuration: 5 });
+    const ts = `${Date.now()}_${Crypto.randomBytes(3).toString('hex')}`;
+    const filePath = path.join(engine.tempDir, `vid_${ts}.mp4`);
+    fs.writeFileSync(filePath, media);
+    const out = path.join(engine.tempDir, `out_${ts}.webp`);
+    await engine.convertToWebp(filePath, out, true);
+    const buf = fs.readFileSync(out);
+    try {
+        fs.unlinkSync(filePath);
+        fs.unlinkSync(out);
+    }
+    catch { }
+    return buf;
+}
+export async function writeExifImg(media, metadata) {
+    const result = await StickEngine.create(media, { metadata: { pack: metadata.packname || metadata.pack, author: metadata.author, emojis: metadata.categories || metadata.emojis } });
+    return result.path;
+}
+export async function writeExifVid(media, metadata) {
+    return writeExifImg(media, metadata);
 }
+export const imageToWebp2 = imageToWebp;
+export const videoToWebp2 = videoToWebp;
+export const writeExifImg2 = writeExifImg;
+export const writeExifVid2 = writeExifVid;
 export default StickEngine;
 //# sourceMappingURL=StickEngine.js.map