@shibam/sticker-maker 1.0.10 → 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { MetaDataType } from './types/metaInfoType.js';
+import { StickerTypes } from './types/StickerTypes.js';
+declare class Sticker {
+    private data;
+    metaInfo: Partial<MetaDataType>;
+    private buffer;
+    private mimeType;
+    private extType;
+    private utils;
+    private outBuffer;
+    private activeBuff;
+    private activeMeta;
+    constructor(data: Buffer | string | Readable, metaInfo?: Partial<MetaDataType>);
+    /**
+     * Initializes the Sticker instance.
+     * - Sets default values for metaInfo.
+     * - Reads and analyzes input data to determine MIME type and extension type.
+     * - Generates ID and quality metadata if not provided.
+     */
+    private initialize;
+    /**
+     * Converts input data to a Buffer containing the converted content.
+     * @returns Promise<Buffer> A Promise resolving to the converted content as Buffer.
+     */
+    toBuffer(): Promise<Buffer>;
+    /**
+     * Converts input data and writes it to a file at the specified outputPath.
+     * @param outputPath The path where the converted file will be saved.
+     * @returns Promise<void> A Promise resolving when the file is successfully written.
+     */
+    toFile(outputPath: string): Promise<void>;
+    /**
+     * Changes the metadata of the sticker.
+     * @param newMetaInfo Partial metadata to update.
+     * @returns Promise<Buffer> A Promise resolving to the Buffer with updated metadata.
+     */
+    changeMetaInfo(): Promise<Buffer>;
+    /**
+     * Extracts metadata from the provided data.
+     * @param data Buffer containing the data to extract metadata from.
+     * @returns Promise<Partial<MetaDataType>> A Promise resolving to the extracted metadata.
+     */
+    extractMetaData(data: Buffer): Promise<Partial<MetaDataType>>;
+}
+export { Sticker, StickerTypes };

package/dist/index.js

@@ -0,0 +1,223 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StickerTypes = exports.Sticker = void 0;
+var fs_1 = __importDefault(require("fs"));
+var utils_js_1 = __importDefault(require("./lib/utils.js"));
+var ToWebp_js_1 = __importDefault(require("./lib/ToWebp.js"));
+var StickerTypes_js_1 = require("./types/StickerTypes.js");
+Object.defineProperty(exports, "StickerTypes", { enumerable: true, get: function () { return StickerTypes_js_1.StickerTypes; } });
+var changeMetaInfo_js_1 = __importDefault(require("./lib/changeMetaInfo.js"));
+var extractMetaData_js_1 = __importDefault(require("./lib/extractMetaData.js"));
+var Sticker = /** @class */ (function () {
+    function Sticker(data, metaInfo) {
+        if (metaInfo === void 0) { metaInfo = {}; }
+        this.data = data;
+        this.metaInfo = metaInfo;
+        this.utils = new utils_js_1.default();
+        this.buffer = Buffer.from([]);
+        this.outBuffer = Buffer.from([]);
+        this.activeBuff = false;
+        this.activeMeta = false;
+        this.mimeType = '';
+        this.extType = '';
+    }
+    /**
+     * Initializes the Sticker instance.
+     * - Sets default values for metaInfo.
+     * - Reads and analyzes input data to determine MIME type and extension type.
+     * - Generates ID and quality metadata if not provided.
+     */
+    Sticker.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, fileType, error_1;
+            var _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0:
+                        _l.trys.push([0, 3, , 4]);
+                        _a = this;
+                        return [4 /*yield*/, this.utils.buffer(this.data)];
+                    case 1:
+                        _a.buffer = _l.sent();
+                        return [4 /*yield*/, this.utils.getMimeType(this.buffer)];
+                    case 2:
+                        fileType = _l.sent();
+                        this.mimeType = (_b = fileType === null || fileType === void 0 ? void 0 : fileType.mime) !== null && _b !== void 0 ? _b : '';
+                        this.extType = (_c = fileType === null || fileType === void 0 ? void 0 : fileType.ext) !== null && _c !== void 0 ? _c : '';
+                        this.metaInfo.pack = (_d = this.metaInfo.pack) !== null && _d !== void 0 ? _d : '';
+                        this.metaInfo.author = (_e = this.metaInfo.author) !== null && _e !== void 0 ? _e : '';
+                        this.metaInfo.id = (_f = this.metaInfo.id) !== null && _f !== void 0 ? _f : this.utils.getId();
+                        this.metaInfo.category = (_g = this.metaInfo.category) !== null && _g !== void 0 ? _g : [];
+                        this.metaInfo.type = (_h = this.metaInfo.type) !== null && _h !== void 0 ? _h : StickerTypes_js_1.StickerTypes.DEFAULT;
+                        this.metaInfo.quality = (_k = (_j = this.metaInfo) === null || _j === void 0 ? void 0 : _j.quality) !== null && _k !== void 0 ? _k : this.utils.getQuality(this.buffer);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _l.sent();
+                        throw new Error("Initialization error: ".concat(error_1));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Converts input data to a Buffer containing the converted content.
+     * @returns Promise<Buffer> A Promise resolving to the converted content as Buffer.
+     */
+    Sticker.prototype.toBuffer = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var buffer, _a, error_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, this.initialize()];
+                    case 1:
+                        _b.sent();
+                        return [4 /*yield*/, (0, ToWebp_js_1.default)(this.buffer, this.metaInfo, this.extType, this.mimeType)];
+                    case 2:
+                        buffer = _b.sent();
+                        _a = this;
+                        return [4 /*yield*/, new changeMetaInfo_js_1.default(this.metaInfo).add(buffer)];
+                    case 3:
+                        _a.outBuffer = _b.sent();
+                        this.activeBuff = true;
+                        return [2 /*return*/, this.outBuffer];
+                    case 4:
+                        error_2 = _b.sent();
+                        this.activeBuff = false;
+                        throw new Error("Conversion to buffer failed: ".concat(error_2));
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Converts input data and writes it to a file at the specified outputPath.
+     * @param outputPath The path where the converted file will be saved.
+     * @returns Promise<void> A Promise resolving when the file is successfully written.
+     */
+    Sticker.prototype.toFile = function (outputPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_3;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 6, , 7]);
+                        if (!(!this.activeBuff && !this.activeMeta && ((_a = this.extType) === null || _a === void 0 ? void 0 : _a.includes('webp')))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.changeMetaInfo()];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.toBuffer()];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4: return [4 /*yield*/, fs_1.default.promises.writeFile(outputPath, this.outBuffer)];
+                    case 5:
+                        _b.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        error_3 = _b.sent();
+                        throw new Error("Conversion to file failed: ".concat(error_3));
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Changes the metadata of the sticker.
+     * @param newMetaInfo Partial metadata to update.
+     * @returns Promise<Buffer> A Promise resolving to the Buffer with updated metadata.
+     */
+    Sticker.prototype.changeMetaInfo = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, error_4;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, this.initialize()];
+                    case 1:
+                        _b.sent();
+                        _a = this;
+                        return [4 /*yield*/, new changeMetaInfo_js_1.default(this.metaInfo).add(this.buffer)];
+                    case 2:
+                        _a.outBuffer = _b.sent();
+                        this.activeMeta = true;
+                        return [2 /*return*/, this.outBuffer];
+                    case 3:
+                        error_4 = _b.sent();
+                        this.activeMeta = false;
+                        throw new Error("Error changing meta info: ".concat(error_4));
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Extracts metadata from the provided data.
+     * @param data Buffer containing the data to extract metadata from.
+     * @returns Promise<Partial<MetaDataType>> A Promise resolving to the extracted metadata.
+     */
+    Sticker.prototype.extractMetaData = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var error_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.initialize()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, (0, extractMetaData_js_1.default)(data)];
+                    case 2:
+                        error_5 = _a.sent();
+                        throw new Error("Error extracting meta data: ".concat(error_5));
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return Sticker;
+}());
+exports.Sticker = Sticker;

package/dist/lib/ToWebp.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { MetaDataType } from '../types/metaInfoType.js';
+/**
+ * Converts a given buffer to WebP format with optional transformations.
+ *
+ * @param {Buffer} buffer - The input buffer to be converted.
+ * @param {Partial<MetaDataType>} metaInfo - Metadata information for the conversion.
+ * @param {string} mimeExt - The MIME extension of the input buffer.
+ * @param {string} mimeType - The MIME type of the input buffer.
+ * @returns {Promise<Buffer>} - A promise that resolves to the converted WebP buffer.
+ */
+declare const ToWebp: (buffer: Buffer, metaInfo: Partial<MetaDataType>, mimeExt: string, mimeType: string) => Promise<Buffer>;
+export default ToWebp;

package/dist/lib/ToWebp.js

@@ -0,0 +1,128 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var sharp_1 = __importStar(require("sharp"));
+var StickerTypes_js_1 = require("../types/StickerTypes.js");
+var toGif_js_1 = __importDefault(require("./toGif.js"));
+/**
+ * Converts a given buffer to WebP format with optional transformations.
+ *
+ * @param {Buffer} buffer - The input buffer to be converted.
+ * @param {Partial<MetaDataType>} metaInfo - Metadata information for the conversion.
+ * @param {string} mimeExt - The MIME extension of the input buffer.
+ * @param {string} mimeType - The MIME type of the input buffer.
+ * @returns {Promise<Buffer>} - A promise that resolves to the converted WebP buffer.
+ */
+var ToWebp = function (buffer, metaInfo, mimeExt, mimeType) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, _a, isAnimated, res, error_1;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _b.trys.push([0, 4, , 5]);
+                if (mimeExt === 'webp' || mimeExt === 'webm')
+                    return [2 /*return*/, buffer];
+                if (!(mimeType === null || mimeType === void 0 ? void 0 : mimeType.includes('video'))) return [3 /*break*/, 2];
+                return [4 /*yield*/, (0, toGif_js_1.default)(buffer, mimeExt, metaInfo.type || StickerTypes_js_1.StickerTypes.DEFAULT)];
+            case 1:
+                _a = _b.sent();
+                return [3 /*break*/, 3];
+            case 2:
+                _a = buffer;
+                _b.label = 3;
+            case 3:
+                data = _a;
+                isAnimated = (mimeType === null || mimeType === void 0 ? void 0 : mimeType.includes('video')) || (mimeExt === null || mimeExt === void 0 ? void 0 : mimeExt.includes('gif'));
+                res = (0, sharp_1.default)(data, { animated: isAnimated });
+                if (metaInfo.type === StickerTypes_js_1.StickerTypes.CIRCLE) {
+                    res.resize(512, 512, {
+                        fit: sharp_1.fit.cover
+                    }).composite([
+                        {
+                            input: Buffer.from("<svg width=\"512\" height=\"512\"><circle cx=\"256\" cy=\"256\" r=\"256\" fill=\"\"/></svg>"),
+                            blend: 'dest-in',
+                            gravity: 'northeast',
+                            tile: true
+                        }
+                    ]);
+                }
+                else if (metaInfo.type === StickerTypes_js_1.StickerTypes.SQUARE && !(mimeType === null || mimeType === void 0 ? void 0 : mimeType.includes('video'))) {
+                    res.resize(512, 512, {
+                        fit: sharp_1.fit.fill
+                    });
+                }
+                return [2 /*return*/, res
+                        .toFormat('webp')
+                        .webp({
+                        quality: metaInfo.quality,
+                        lossless: true
+                    })
+                        .toBuffer()];
+            case 4:
+                error_1 = _b.sent();
+                throw new Error("Conversion failed: ".concat(error_1));
+            case 5: return [2 /*return*/];
+        }
+    });
+}); };
+exports.default = ToWebp;

package/dist/lib/changeMetaInfo.d.ts

@@ -0,0 +1,33 @@
+/// <reference path="../../src/lib/node-webpmux.d.ts" />
+/// <reference types="node" />
+import Image from 'node-webpmux';
+/**
+ * The Exif class is responsible for handling the metadata (Exif data)
+ * for sticker images, particularly those used in messaging applications.
+ */
+export default class Exif {
+    private data;
+    private exif;
+    /**
+     * Constructs an Exif instance with the given options.
+     * @param options - An object containing metadata for the sticker.
+     */
+    constructor(options: any);
+    /**
+     * Builds the Exif metadata as a Buffer.
+     * @returns A Buffer containing the constructed Exif data.
+     */
+    build: () => Buffer;
+    /**
+     * Adds the Exif metadata to the given image.
+     * @param image - A Buffer or Image instance representing the image to which Exif data should be added.
+     * @returns A Promise that resolves to a Buffer containing the image with the added Exif data.
+     */
+    add: (image: Buffer | Image.Image) => Promise<Buffer>;
+    /**
+     * Loads the image from a Buffer or string and returns an Image instance.
+     * @param image - A Buffer or string representing the image to be loaded.
+     * @returns A Promise that resolves to an Image instance.
+     */
+    load: (image: Buffer | string) => Promise<Image.Image>;
+}

package/dist/lib/changeMetaInfo.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_webpmux_1 = __importDefault(require("node-webpmux"));
+var util_1 = require("util");
+/**
+ * The Exif class is responsible for handling the metadata (Exif data)
+ * for sticker images, particularly those used in messaging applications.
+ */
+var Exif = /** @class */ (function () {
+    /**
+     * Constructs an Exif instance with the given options.
+     * @param options - An object containing metadata for the sticker.
+     */
+    function Exif(options) {
+        var _this = this;
+        this.data = {};
+        this.exif = null;
+        /**
+         * Builds the Exif metadata as a Buffer.
+         * @returns A Buffer containing the constructed Exif data.
+         */
+        this.build = function () {
+            var data = JSON.stringify(_this.data);
+            var exif = Buffer.concat([
+                Buffer.from([
+                    0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, 0x00, 0x41, 0x57, 0x07, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x16, 0x00, 0x00, 0x00
+                ]),
+                Buffer.from(data, 'utf-8')
+            ]);
+            exif.writeUIntLE(new util_1.TextEncoder().encode(data).length, 14, 4);
+            return exif;
+        };
+        /**
+         * Adds the Exif metadata to the given image.
+         * @param image - A Buffer or Image instance representing the image to which Exif data should be added.
+         * @returns A Promise that resolves to a Buffer containing the image with the added Exif data.
+         */
+        this.add = function (image) { return __awaiter(_this, void 0, void 0, function () {
+            var exif, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        exif = this.exif || this.build();
+                        if (!(image instanceof node_webpmux_1.default.Image)) return [3 /*break*/, 1];
+                        _a = image;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.load(image)
+                        // Set the Exif data on the image and save it.
+                    ];
+                    case 2:
+                        _a = _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        // Load the image if it is not already an instance of Image.Image.
+                        image = _a;
+                        // Set the Exif data on the image and save it.
+                        image.exif = exif;
+                        return [4 /*yield*/, image.save(null)];
+                    case 4: return [2 /*return*/, _b.sent()];
+                }
+            });
+        }); };
+        /**
+         * Loads the image from a Buffer or string and returns an Image instance.
+         * @param image - A Buffer or string representing the image to be loaded.
+         * @returns A Promise that resolves to an Image instance.
+         */
+        this.load = function (image) { return __awaiter(_this, void 0, void 0, function () {
+            var img;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        img = new node_webpmux_1.default.Image();
+                        return [4 /*yield*/, img.load(image)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, img];
+                }
+            });
+        }); };
+        this.data['sticker-pack-id'] = options.id || '';
+        this.data['sticker-pack-name'] = options.pack || '';
+        this.data['sticker-pack-publisher'] = options.author || '';
+        this.data['emojis'] = options.category || ['😹'];
+    }
+    return Exif;
+}());
+exports.default = Exif;

package/dist/lib/extractMetaData.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+/**
+ * Extracts metadata from a WebP image.
+ * @param {Buffer}image - The image buffer to extract metadata from
+ */
+declare const extractMetadata: (image: Buffer) => Promise<any>;
+export default extractMetadata;

package/dist/lib/extractMetaData.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var node_webpmux_1 = __importDefault(require("node-webpmux"));
+/**
+ * Extracts metadata from a WebP image.
+ * @param {Buffer}image - The image buffer to extract metadata from
+ */
+var extractMetadata = function (image) { return __awaiter(void 0, void 0, void 0, function () {
+    var img, exif;
+    var _a, _b, _c;
+    return __generator(this, function (_d) {
+        switch (_d.label) {
+            case 0:
+                img = new node_webpmux_1.default.Image();
+                return [4 /*yield*/, img.load(image)];
+            case 1:
+                _d.sent();
+                exif = (_b = (_a = img.exif) === null || _a === void 0 ? void 0 : _a.toString('utf-8')) !== null && _b !== void 0 ? _b : '{}';
+                return [2 /*return*/, JSON.parse((_c = exif.substring(exif.indexOf('{'), exif.lastIndexOf('}') + 1)) !== null && _c !== void 0 ? _c : '{}')];
+        }
+    });
+}); };
+exports.default = extractMetadata;

package/dist/lib/toGif.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { StickerTypes } from '../types/StickerTypes.js';
+declare const videoToGif: (buffer: Buffer, extType: string, type: StickerTypes) => Promise<Buffer>;
+export default videoToGif;

package/dist/lib/toGif.js

@@ -0,0 +1,92 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+var ffmpeg_1 = __importDefault(require("@ffmpeg-installer/ffmpeg"));
+var stream_1 = require("stream");
+var StickerTypes_js_1 = require("../types/StickerTypes.js");
+fluent_ffmpeg_1.default.setFfmpegPath(ffmpeg_1.default.path);
+var videoToGif = function (buffer, extType, type) {
+    return new Promise(function (resolve, reject) { return __awaiter(void 0, void 0, void 0, function () {
+        var outputStream, inputStream, chunks_1, shape;
+        return __generator(this, function (_a) {
+            try {
+                outputStream = new stream_1.PassThrough();
+                inputStream = new stream_1.PassThrough();
+                inputStream.end(buffer);
+                chunks_1 = [];
+                outputStream.on('data', function (chunk) {
+                    chunks_1.push(chunk);
+                });
+                outputStream.on('end', function () { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        resolve(Buffer.concat(chunks_1));
+                        return [2 /*return*/];
+                    });
+                }); });
+                outputStream.on('error', function (err) { return __awaiter(void 0, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, videoToGif(buffer, extType, type)];
+                            case 1:
+                                _a.sent();
+                                reject(err);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
+                shape = type === StickerTypes_js_1.StickerTypes.SQUARE
+                    ? 'scale=320:-1:flags=lanczos,fps=10,crop=min(iw\\,ih):min(iw\\,ih)'
+                    : 'scale=320:-1:flags=lanczos,fps=10';
+                (0, fluent_ffmpeg_1.default)(inputStream)
+                    .inputFormat(extType)
+                    .outputOptions(['-vf', shape, '-loop', '0', '-lossless', '0', '-t', '6', '-preset', 'ultrafast'])
+                    .toFormat('gif')
+                    .pipe(outputStream, { end: true });
+            }
+            catch (error) {
+                reject(error);
+            }
+            return [2 /*return*/];
+        });
+    }); });
+};
+exports.default = videoToGif;

package/dist/lib/utils.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Readable } from 'stream';
+export default class Utils {
+    constructor();
+    /**
+     * Converts various types of input data to a Buffer.
+     * @param data Input data as Buffer, string (file path), or Readable stream.
+     * @returns Promise<Buffer> A Promise resolving to the converted Buffer.
+     * @throws Error if conversion fails.
+     */
+    buffer(data: Buffer | string | Readable): Promise<Buffer>;
+    /**
+     * Converts a Readable stream to a Buffer.
+     * @param stream Readable stream to convert.
+     * @returns Promise<Buffer> A Promise resolving to the converted Buffer.
+     */
+    streamToBuffer(stream: Readable): Promise<Buffer>;
+    /**
+     * Determines the quality of the data based on its size.
+     * @param data Buffer containing the data.
+     * @returns number Quality value based on data size.
+     */
+    getQuality(data: Buffer): number;
+    /**
+     * Determines the MIME type of the data buffer.
+     * @param data Buffer containing the data.
+     * @returns Promise<{ mime: string; ext: string }> A Promise resolving to an object with MIME type and extension.
+     */
+    getMimeType(data: Buffer): Promise<{
+        mime: string;
+        ext: string;
+    } | undefined>;
+    /**
+     * Generates a random ID.
+     * @returns string A random alphanumeric ID.
+     */
+    getId(): string;
+}

package/dist/lib/utils.js

@@ -0,0 +1,172 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var stream_1 = require("stream");
+var fs_1 = __importDefault(require("fs"));
+var file_type_1 = require("file-type");
+var Utils = /** @class */ (function () {
+    function Utils() {
+    }
+    /**
+     * Converts various types of input data to a Buffer.
+     * @param data Input data as Buffer, string (file path), or Readable stream.
+     * @returns Promise<Buffer> A Promise resolving to the converted Buffer.
+     * @throws Error if conversion fails.
+     */
+    Utils.prototype.buffer = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var buffer, _a, _b, error_1;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 7, , 8]);
+                        if (!(typeof data === 'string')) return [3 /*break*/, 2];
+                        return [4 /*yield*/, fs_1.default.promises.readFile(data)];
+                    case 1:
+                        _a = _c.sent();
+                        return [3 /*break*/, 6];
+                    case 2:
+                        if (!(data instanceof stream_1.Readable)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.streamToBuffer(data)];
+                    case 3:
+                        _b = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _b = Buffer.from(data);
+                        _c.label = 5;
+                    case 5:
+                        _a = _b;
+                        _c.label = 6;
+                    case 6:
+                        buffer = _a;
+                        return [2 /*return*/, buffer];
+                    case 7:
+                        error_1 = _c.sent();
+                        throw new Error("Error converting to buffer: ".concat(error_1));
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Converts a Readable stream to a Buffer.
+     * @param stream Readable stream to convert.
+     * @returns Promise<Buffer> A Promise resolving to the converted Buffer.
+     */
+    Utils.prototype.streamToBuffer = function (stream) {
+        return __awaiter(this, void 0, void 0, function () {
+            var chunks;
+            return __generator(this, function (_a) {
+                chunks = [];
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        stream.on('data', function (chunk) {
+                            if (Buffer.isBuffer(chunk)) {
+                                chunks.push(chunk);
+                            }
+                            else {
+                                chunks.push(Buffer.from(chunk));
+                            }
+                        });
+                        stream.on('end', function () {
+                            resolve(Buffer.concat(chunks));
+                        });
+                        stream.on('error', function (err) {
+                            reject(err);
+                        });
+                    })];
+            });
+        });
+    };
+    /**
+     * Determines the quality of the data based on its size.
+     * @param data Buffer containing the data.
+     * @returns number Quality value based on data size.
+     */
+    Utils.prototype.getQuality = function (data) {
+        var buffer = Buffer.from(data);
+        var bytes = buffer.length / 1024;
+        var quality = bytes > 4 * 1024 ? 8 : bytes > 3 * 1024 ? 10 : bytes > 2 * 1024 ? 12 : 15;
+        return quality;
+    };
+    /**
+     * Determines the MIME type of the data buffer.
+     * @param data Buffer containing the data.
+     * @returns Promise<{ mime: string; ext: string }> A Promise resolving to an object with MIME type and extension.
+     */
+    Utils.prototype.getMimeType = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var fileType, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, (0, file_type_1.fromBuffer)(data)];
+                    case 1:
+                        fileType = _a.sent();
+                        return [2 /*return*/, fileType];
+                    case 2:
+                        error_2 = _a.sent();
+                        console.error("Error getting MIME type: ".concat(error_2));
+                        return [2 /*return*/, undefined];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Generates a random ID.
+     * @returns string A random alphanumeric ID.
+     */
+    Utils.prototype.getId = function () {
+        return __spreadArray([], Array(5), true).map(function () { return Math.random().toString(36).substring(2, 15); }).join('');
+    };
+    return Utils;
+}());
+exports.default = Utils;

package/dist/types/StickerTypes.d.ts

@@ -0,0 +1,5 @@
+export declare enum StickerTypes {
+    DEFAULT = 0,
+    SQUARE = 1,
+    CIRCLE = 2
+}

package/dist/types/StickerTypes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StickerTypes = void 0;
+var StickerTypes;
+(function (StickerTypes) {
+    StickerTypes[StickerTypes["DEFAULT"] = 0] = "DEFAULT";
+    StickerTypes[StickerTypes["SQUARE"] = 1] = "SQUARE";
+    StickerTypes[StickerTypes["CIRCLE"] = 2] = "CIRCLE";
+})(StickerTypes || (exports.StickerTypes = StickerTypes = {}));

package/dist/types/categoryType.d.ts

@@ -0,0 +1,8 @@
+type LoveEmojis = '❤' | '😍' | '😘' | '💕' | '😻' | '💑' | '👩‍❤‍👩' | '👨‍❤‍👨' | '💏' | '👩‍❤‍💋‍👩' | '👨‍❤‍💋‍👨' | '🧡' | '💛' | '💚' | '💙' | '💜' | '🖤' | '💔' | '❣' | '💞' | '💓' | '💗' | '💖' | '💘' | '💝' | '💟' | '♥' | '💌' | '💋' | '👩‍❤️‍💋‍👩' | '👨‍❤️‍💋‍👨' | '👩‍❤️‍👨' | '👩‍❤️‍👩' | '👨‍❤️‍👨' | '👩‍❤️‍💋‍👨' | '👬' | '👭' | '👫' | '🥰' | '😚' | '😙' | '👄' | '🌹' | '😽' | '❣️' | '❤️';
+type HappyEmojis = '😀' | '😃' | '😄' | '😁' | '😆' | '😅' | '😂' | '🤣' | '🙂' | '😛' | '😝' | '😜' | '🤪' | '🤗' | '😺' | '😸' | '😹' | '☺' | '😌' | '😉' | '🤗' | '😊';
+type SadEmojis = '☹' | '😣' | '😖' | '😫' | '😩' | '😢' | '😭' | '😞' | '😔' | '😟' | '😕' | '😤' | '😠' | '😥' | '😰' | '😨' | '😿' | '😾' | '😓' | '🙍‍♂️' | '🙍‍♀️' | '💔' | '🙁' | '🥺' | '🤕' | '☔️' | '⛈' | '🌩' | '🌧';
+type AngryEmojis = '😯' | '😦' | '😧' | '😮' | '😲' | '🙀' | '😱' | '🤯' | '😳' | '❗' | '❕' | '🤬' | '😡' | '😠' | '🙄' | '👿' | '😾' | '😤' | '💢' | '👺' | '🗯️' | '😒' | '🥵';
+type GreetEmojis = '👋';
+type CelebrateEmojis = '🎊' | '🎉' | '🎁' | '🎈' | '👯‍♂️' | '👯' | '👯‍♀️' | '💃' | '🕺' | '🔥' | '⭐️' | '✨' | '💫' | '🎇' | '🎆' | '🍻' | '🥂' | '🍾' | '🎂' | '🍰';
+export type category = LoveEmojis | HappyEmojis | SadEmojis | AngryEmojis | GreetEmojis | CelebrateEmojis;
+export {};

package/dist/types/categoryType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/metaInfoType.d.ts

@@ -0,0 +1,10 @@
+import { category } from './categoryType.js';
+import { StickerTypes } from './StickerTypes.js';
+export interface MetaDataType {
+    pack?: string;
+    author?: string;
+    id?: string;
+    category?: category[];
+    type?: StickerTypes;
+    quality?: number;
+}

package/dist/types/metaInfoType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shibam/sticker-maker",
-  "version": "1.0.10",
+  "version": "1.1.0",
   "description": "A package for creating stickers",
   "main": "dist/index.js",
   "type": "commonjs",
@@ -33,8 +33,12 @@
     "typescript"
   ],
   "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@types/fluent-ffmpeg": "^2.1.24",
     "file-type": "16.5.0",
-    "node-webpmux": "^3.2.0"
+    "fluent-ffmpeg": "^2.1.3",
+    "node-webpmux": "^3.2.0",
+    "sharp": "^0.33.4"
   },
   "devDependencies": {
     "@types/node": "^20.10.0",

package/readme.md

@@ -1,13 +1,12 @@
 # @shibam/sticker-maker
 
-`@shibam/sticker-maker` is a lightweight utility library designed for converting images and videos into stickers while allowing customization of metadata. It supports various input types and ensures high-quality sticker conversion. This module has minimal dependencies, ensuring efficient performance. If you encounter any issues, please feel free to open an issue. However, please check if a similar issue has already been reported before creating a new one. Happy Coding (⁠≧⁠▽⁠≦⁠).
+`@shibam/sticker-maker` is a lightweight utility library designed for converting images and videos into stickers while allowing customization of metadata. you don't have to download ffmpeg in terminal. It supports various input types and ensures high-quality sticker conversion. This module has minimal dependencies, ensuring efficient performance. If you encounter any issues, please feel free to open an issue. However, please check if a similar issue has already been reported before creating a new one. Happy Coding (⁠≧⁠▽⁠≦⁠).
 
 # Sticker Class
 
 The `Sticker` class is a utility for converting images and videos into sticker format, with options for metadata customization and manipulation.
 
 ## Installation
-# ⚠️ Before installing this make sure you have downloaded ffmpeg 
    
 You can install the package using npm:
 
@@ -31,7 +30,6 @@ const sticker = new Sticker("path/to/image.png", {
   category: ['😂','😹'],
   type: StickerTypes.DEFAULT,
   quality: 30,
-  background: "red"
 });
 
 try {
@@ -49,7 +47,6 @@ const sticker2 = new Sticker("path/to/another/image.png", {
   category: ['😊','👍'],
   type: StickerTypes.CIRCLE,
   quality: 50,
-  background: "blue"
 });
 
 try {
@@ -100,7 +97,6 @@ enum StickerTypes {
   DEFAULT,
   CIRCLE,
   SQUARE,
-  FIT
 }
 ```
 
@@ -110,7 +106,7 @@ This package is licensed under the MIT License.
 
 ## Contributing
 
-Contributions are welcome. Feel free to open issues or submit pull requests on [GitHub](https://github.com/your/repository).
+Contributions are welcome. Feel free to open issues or submit pull requests on [GitHub](https://github.com/NekoSenpai69/Sticker-Maker).
 
 ---