apexify.js 1.2.7 → 1.2.9

package/lib/canvas/ApexPainter.js

@@ -1,1194 +1,1399 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
+const { createCanvas, loadImage, GlobalFonts } = require("@napi-rs/canvas");
+const path = require("path");
+const axios = require("axios");
+const sharp = require("sharp");
+const fs = require("fs");
+const Jimp = require("jimp");
+const FormData = require("form-data");
+const GIFEncoder = require("gifencoder");
+const stream = require("stream");
+
+class ApexPainter {
+  constructor() {
+    this.defaultTextOptions = {
+      text: "Add Text Here",
+      x: 50,
+      y: 50,
+      fontPath: null,
+      fontName: "Arial",
+      fontSize: 20,
+      color: "black",
+      maxWidth: null,
+      lineHeight: null,
+      textAlign: "left",
+      textBaseline: "top",
+      shadow: {
+        color: null,
+        offsetX: 0,
+        offsetY: 0,
+        blur: 0,
+      },
+      stroke: {
+        color: null,
+        width: 0,
+      },
+    };
+
+    this.frames = [];
+
+    this.defaultImageOptions = {
+      source: null,
+      x: 0,
+      y: 0,
+      width: null,
+      height: null,
+      filled: null,
+      borderRadius: null,
+      color: null,
+      gradient: null,
+      rotate: null,
+      shadow: {
+        color: null,
+        offsetX: 0,
+        offsetY: 0,
+        opacity: 0,
+        blur: 0,
+        borderRadius: null,
+      },
+      stroke: {
+        color: null,
+        width: null,
+        borderRadius: null,
+      },
     };
-    return __assign.apply(this, arguments);
-};
-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 };
+
+    this.defaultCanvasOptions = {
+      width: 500,
+      height: 300,
+      x: 0,
+      y: 0,
+      backgroundColor: null,
+      borderRadius: null,
+      backgroundGradient: null,
+      customBg: null,
+    };
+  }
+
+  validateCanvasOptions(canvasOptions) {
+    if (!canvasOptions || typeof canvasOptions !== "object") {
+      throw new Error(
+        "Invalid canvas options. Provide a valid object for canvas configuration.",
+      );
     }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApexPainter = void 0;
-var canvas_1 = require("@napi-rs/canvas");
-var path_1 = require("path");
-var axios_1 = require("axios");
-var sharp_1 = require("sharp");
-var fs_1 = require("fs");
-var jimp_1 = require("jimp");
-var form_data_1 = require("form-data");
-var gifencoder_1 = require("gifencoder");
-var stream_1 = require("stream");
-var ApexPainter = /** @class */ (function () {
-    function ApexPainter() {
-        this.defaultTextOptions = {
-            text: "Add Text Here",
-            x: 50,
-            y: 50,
-            fontPath: null,
-            fontName: "Arial",
-            fontSize: 20,
-            color: "black",
-            maxWidth: null,
-            lineHeight: null,
-            textAlign: "left",
-            textBaseline: "top",
-            shadow: {
-                color: null,
-                offsetX: 0,
-                offsetY: 0,
-                blur: 0,
-                opacity: 0,
-                borderRadius: 0,
-            },
-            stroke: {
-                color: null,
-                width: 0,
-                borderRadius: 0,
-            },
-        };
-        this.frames = [];
-        this.defaultImageOptions = {
-            source: null,
-            x: 0,
-            y: 0,
-            width: null,
-            height: null,
-            filled: null,
-            borderRadius: null,
-            color: null,
-            gradient: null,
-            rotate: null,
-            shadow: {
-                color: null,
-                offsetX: 0,
-                offsetY: 0,
-                opacity: 0,
-                blur: 0,
-                borderRadius: null,
-            },
-            stroke: {
-                color: null,
-                width: null,
-                borderRadius: null,
-            },
-        };
-        this.defaultCanvasOptions = {
-            width: 500,
-            height: 300,
-            x: 0,
-            y: 0,
-            backgroundColor: null,
-            borderRadius: null,
-            backgroundGradient: null,
-            customBg: null,
-        };
+
+    if (
+      typeof canvasOptions.width !== "number" ||
+      typeof canvasOptions.height !== "number"
+    ) {
+      throw new Error("Canvas width and height must be numbers.");
     }
-    ApexPainter.prototype.validateFrameOptions = function (frame) {
-        if (!frame || typeof frame !== "object") {
-            throw new Error("Invalid frame options. Provide a valid object for frame configuration.");
-        }
-        if (typeof frame.delay !== "number" || frame.delay < 0) {
-            throw new Error("Frame delay must be a non-negative number.");
-        }
-        if (typeof frame.quality !== "number" ||
-            frame.quality < 1 ||
-            frame.quality > 100) {
-            throw new Error("Frame quality must be a number between 1 and 100.");
-        }
-        if (typeof frame.loop !== "number" || frame.loop < 0) {
-            throw new Error("Frame loop count must be a non-negative number.");
-        }
-        return true;
-    };
-    ApexPainter.prototype.validateImageOptions = function (imageOptions) {
-        if (!imageOptions || typeof imageOptions !== "object") {
-            throw new Error("Invalid image options. Provide a valid object for image configuration.");
-        }
-        if (!imageOptions.source) {
-            throw new Error("Image source is required.");
-        }
-        if (typeof imageOptions.x !== "number" ||
-            typeof imageOptions.y !== "number") {
-            throw new Error("Image x and y coordinates must be numbers.");
-        }
-        if (imageOptions.width &&
-            (typeof imageOptions.width !== "number" || imageOptions.width <= 0)) {
-            throw new Error("Image width must be a positive number.");
-        }
-        if (imageOptions.height &&
-            (typeof imageOptions.height !== "number" || imageOptions.height <= 0)) {
-            throw new Error("Image height must be a positive number.");
+
+    if (canvasOptions.width <= 0 || canvasOptions.height <= 0) {
+      throw new Error("Canvas width and height must be positive values.");
+    }
+
+    return true;
+  }
+
+  validateFrameOptions(frame) {
+    if (!frame || typeof frame !== "object") {
+      throw new Error(
+        "Invalid frame options. Provide a valid object for frame configuration.",
+      );
+    }
+
+    if (typeof frame.delay !== "number" || frame.delay < 0) {
+      throw new Error("Frame delay must be a non-negative number.");
+    }
+
+    if (
+      typeof frame.quality !== "number" ||
+      frame.quality < 1 ||
+      frame.quality > 100
+    ) {
+      throw new Error("Frame quality must be a number between 1 and 100.");
+    }
+
+    if (typeof frame.loop !== "number" || frame.loop < 0) {
+      throw new Error("Frame loop count must be a non-negative number.");
+    }
+
+    return true;
+  }
+
+  validateImageOptions(imageOptions) {
+    if (!imageOptions || typeof imageOptions !== "object") {
+      throw new Error(
+        "Invalid image options. Provide a valid object for image configuration.",
+      );
+    }
+
+    if (!imageOptions.source) {
+      throw new Error("Image source is required.");
+    }
+
+    if (
+      typeof imageOptions.x !== "number" ||
+      typeof imageOptions.y !== "number"
+    ) {
+      throw new Error("Image x and y coordinates must be numbers.");
+    }
+
+    if (
+      imageOptions.width &&
+      (typeof imageOptions.width !== "number" || imageOptions.width <= 0)
+    ) {
+      throw new Error("Image width must be a positive number.");
+    }
+
+    if (
+      imageOptions.height &&
+      (typeof imageOptions.height !== "number" || imageOptions.height <= 0)
+    ) {
+      throw new Error("Image height must be a positive number.");
+    }
+    return true;
+  }
+
+  validateTextOptions(textOptions) {
+    if (!textOptions || typeof textOptions !== "object") {
+      throw new Error(
+        "Invalid text options. Provide a valid object for text configuration.",
+      );
+    }
+    if (
+      typeof textOptions.x !== "number" ||
+      typeof textOptions.y !== "number"
+    ) {
+      throw new Error("Text x and y coordinates must be numbers.");
+    }
+
+    if (
+      textOptions.fontSize &&
+      (typeof textOptions.fontSize !== "number" || textOptions.fontSize <= 0)
+    ) {
+      throw new Error("Text fontSize must be a positive number.");
+    }
+
+    return true;
+  }
+
+  //////////drawing image using canvas
+  async drawImages(imagesOptions, canvasOptions, baseDir) {
+    // Merge canvas options with default options
+    const mergedCanvasOptions = this.mergeOptions(
+      this.defaultCanvasOptions,
+      canvasOptions,
+    );
+
+    // Validate canvas options
+    if (!mergedCanvasOptions || typeof mergedCanvasOptions !== "object") {
+      throw new Error(
+        "Invalid canvas options. Provide a valid object for canvas configuration.",
+      );
+    }
+
+    if (
+      typeof mergedCanvasOptions.width !== "number" ||
+      typeof mergedCanvasOptions.height !== "number"
+    ) {
+      throw new Error("Canvas width and height must be numbers.");
+    }
+
+    if (mergedCanvasOptions.width <= 0 || mergedCanvasOptions.height <= 0) {
+      throw new Error("Canvas width and height must be positive values.");
+    }
+
+    let canvas;
+    let ctx;
+
+    if (mergedCanvasOptions.customBg) {
+
+      if (typeof mergedCanvasOptions.customBg !== 'string' || !mergedCanvasOptions.customBg.startsWith('http')) {
+  throw new Error('Invalid customBg URL');
+}
+
+const customBgImage = await loadImage(mergedCanvasOptions.customBg);
+canvas = createCanvas(customBgImage.width, customBgImage.height);
+ctx = canvas.getContext("2d");
+
+this.drawRoundedRect(
+  ctx,
+  mergedCanvasOptions.x,
+  mergedCanvasOptions.y,
+  mergedCanvasOptions.width,
+  mergedCanvasOptions.height,
+  mergedCanvasOptions.borderRadius,
+);
+
+ctx.clip();
+      
+ctx.drawImage(customBgImage, 0, 0);
+    } else {
+      // Create a canvas based on the specified width and height
+      canvas = createCanvas(
+        mergedCanvasOptions.width,
+        mergedCanvasOptions.height,
+      );
+      ctx = canvas.getContext("2d");
+
+      // Customize the canvas drawing based on other options (background color, gradient, etc.)
+      if (mergedCanvasOptions.backgroundGradient) {
+        const gradient = this.createGradient(
+          ctx,
+          mergedCanvasOptions.backgroundGradient,
+          mergedCanvasOptions.x,
+          mergedCanvasOptions.y,
+          mergedCanvasOptions.width,
+          mergedCanvasOptions.height,
+        );
+        ctx.fillStyle = gradient;
+        this.drawRoundedRect(
+          ctx,
+          mergedCanvasOptions.x,
+          mergedCanvasOptions.y,
+          mergedCanvasOptions.width,
+          mergedCanvasOptions.height,
+          mergedCanvasOptions.borderRadius,
+        );
+        ctx.fill();
+      } else if (mergedCanvasOptions.backgroundColor) {
+        if (mergedCanvasOptions.borderRadius) {
+          // Draw a rounded rectangle for the background
+          this.drawRoundedRect(
+            ctx,
+            mergedCanvasOptions.x,
+            mergedCanvasOptions.y,
+            mergedCanvasOptions.width,
+            mergedCanvasOptions.height,
+            mergedCanvasOptions.borderRadius,
+          );
+          ctx.fillStyle = mergedCanvasOptions.backgroundColor;
+          ctx.fill();
+        } else {
+          ctx.fillStyle = mergedCanvasOptions.backgroundColor;
+          ctx.fillRect(
+            mergedCanvasOptions.x,
+            mergedCanvasOptions.y,
+            mergedCanvasOptions.width,
+            mergedCanvasOptions.height,
+          );
         }
-        return true;
-    };
-    ApexPainter.prototype.validateTextOptions = function (textOptions) {
-        if (!textOptions || typeof textOptions !== "object") {
-            throw new Error("Invalid text options. Provide a valid object for text configuration.");
+      }
+    }
+
+    // Draw each image on the canvas if options are provided
+    if (imagesOptions && imagesOptions.length > 0) {
+      for (const imageOptions of imagesOptions) {
+        await this.drawSingleImage(ctx, imageOptions, baseDir);
+      }
+    }
+    
+    // Return the buffer directly
+    return canvas.toBuffer("image/png");
+  }//////////////////////
+
+  ///////Drawing single images
+  async drawSingleImage(ctx, imageOptions, baseDir) {
+    const mergedImageOptions = this.mergeOptions(
+      this.defaultImageOptions,
+      imageOptions,
+    );
+    this.validateImageOptions(imageOptions);
+
+    // Check if the source is a shape name
+    if (
+      mergedImageOptions.source &&
+      this.isShapeName(mergedImageOptions.source)
+    ) {
+      this.drawShape(ctx, mergedImageOptions);
+      return;
+    }
+
+    if (mergedImageOptions.source) {
+      let image;
+
+      if (baseDir) {
+        const imagePath = path.join(baseDir, mergedImageOptions.source);
+
+        if (
+          mergedImageOptions.source.startsWith("http") ||
+          mergedImageOptions.source.startsWith("https")
+        ) {
+          image = await loadImage(mergedImageOptions.source);
+        } else {
+          image = await loadImage(imagePath);
         }
-        if (typeof textOptions.x !== "number" ||
-            typeof textOptions.y !== "number") {
-            throw new Error("Text x and y coordinates must be numbers.");
+      } else {
+        if (
+          mergedImageOptions.source.startsWith("http") ||
+          mergedImageOptions.source.startsWith("https")
+        ) {
+          image = await loadImage(mergedImageOptions.source);
+        } else {
+          image = await loadImage(mergedImageOptions.source);
         }
-        if (textOptions.fontSize &&
-            (typeof textOptions.fontSize !== "number" || textOptions.fontSize <= 0)) {
-            throw new Error("Text fontSize must be a positive number.");
+      }
+
+      // Save the initial context state
+      ctx.save();
+
+      // Apply shadow if provided
+      if (
+        mergedImageOptions.shadow &&
+        mergedImageOptions.shadow.offsetX &&
+        mergedImageOptions.shadow.offsetY
+      ) {
+        ctx.globalAlpha = mergedImageOptions.shadow.opacity || null;
+        ctx.filter = `blur(${mergedImageOptions.shadow.blur || null}px)`;
+
+        // Draw a rounded rectangle as a shadow
+        const shadowX =
+          mergedImageOptions.x + (mergedImageOptions.shadow.offsetX || 0);
+        const shadowY =
+          mergedImageOptions.y + (mergedImageOptions.shadow.offsetY || 0);
+
+        this.drawRoundedRect(
+          ctx,
+          shadowX,
+          shadowY,
+          mergedImageOptions.width,
+          mergedImageOptions.height,
+          mergedImageOptions.shadow.borderRadius || 0,
+        );
+
+        ctx.fillStyle = mergedImageOptions.shadow.color || "transparent";
+        ctx.fill();
+      }
+
+      // Reset filter and opacity properties
+      ctx.filter = "none";
+      ctx.globalAlpha = 1;
+
+      // Draw the actual image
+      this.drawRoundedImage(
+        ctx,
+        image,
+        mergedImageOptions.x,
+        mergedImageOptions.y,
+        mergedImageOptions.width,
+        mergedImageOptions.height,
+        mergedImageOptions.borderRadius || 0,
+      );
+
+      // Restore the context state
+      ctx.restore();
+
+      // Apply stroke if provided
+      if (
+        mergedImageOptions.stroke &&
+        mergedImageOptions.stroke.color &&
+        mergedImageOptions.stroke.width
+      ) {
+        ctx.strokeStyle = mergedImageOptions.stroke.color || "transparent"; // Change color as needed
+        ctx.lineWidth = mergedImageOptions.stroke.width || 1;
+
+        // Draw the rounded rectangle for stroke
+        this.drawRoundedRect(
+          ctx,
+          mergedImageOptions.x,
+          mergedImageOptions.y,
+          mergedImageOptions.width,
+          mergedImageOptions.height,
+          mergedImageOptions.stroke.borderRadius || 0,
+        );
+        ctx.stroke();
+      }
+      ctx.restore();
+    }
+  }
+
+  isShapeName(source) {
+    // Check if the source is a valid shape name
+    const validShapes = ["square", "circle", "triangle", "rectangle"];
+    return validShapes.includes(source.toLowerCase());
+  }
+
+  drawShape(ctx, shapeOptions, canvasBackgroundColor) {
+    const {
+      source,
+      x,
+      y,
+      width,
+      height,
+      borderRadius,
+      stroke,
+      color,
+      rotate,
+      filled,
+      gradient,
+      shadow,
+    } = shapeOptions;
+    const isFilled = filled !== undefined ? filled : true;
+
+    // Save the initial context state
+    ctx.save();
+
+    // Apply shadow if provided
+    if (shadow && shadow.offsetX && shadow.offsetY) {
+      ctx.globalAlpha = shadow.opacity || null;
+      ctx.filter = `blur(${shadow.blur || null}px)`;
+
+      const shadowX = x + (shadow.offsetX || 0);
+      const shadowY = y + (shadow.offsetY || 0);
+
+      this.drawRoundedRect(
+        ctx,
+        shadowX,
+        shadowY,
+        width,
+        height,
+        shadow.borderRadius || 0,
+      );
+
+      ctx.fillStyle = shadow.color || "transparent";
+      ctx.fill();
+    }
+
+    // Reset filter property
+    ctx.filter = "none";
+    ctx.globalAlpha = 1;
+
+    if (rotate) {
+      const centerX = x + width / 2;
+      const centerY = y + height / 2;
+      ctx.translate(centerX, centerY);
+      ctx.rotate((rotate * Math.PI) / 180);
+      ctx.translate(-centerX, -centerY);
+    }
+
+    if (gradient) {
+      const gradientFill = this.createGradient(
+        ctx,
+        gradient,
+        x,
+        y,
+        x + width,
+        y + height,
+      );
+      ctx.fillStyle = gradientFill;
+    } else {
+      ctx.fillStyle = color || "transparent";
+    }
+
+    ctx.beginPath();
+
+    switch (source.toLowerCase()) {
+      case "square":
+        this.drawRoundedRect(ctx, x, y, width, height, borderRadius || 0);
+        break;
+      case "circle":
+        const circleRadius = Math.min(width, height) / 2;
+        ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
+        break;
+      case "triangle":
+        ctx.moveTo(x + width / 2, y);
+        ctx.lineTo(x + width, y + height);
+        ctx.lineTo(x, y + height);
+        ctx.closePath();
+        break;
+      case "pentagon":
+        const sideLength = Math.min(width, height);
+        for (let i = 0; i < 5; i++) {
+          const angle = (i * 2 * Math.PI) / 5;
+          const px = x + width / 2 + sideLength * Math.cos(angle);
+          const py = y + height / 2 + sideLength * Math.sin(angle);
+          if (i === 0) {
+            ctx.moveTo(px, py);
+          } else {
+            ctx.lineTo(px, py);
+          }
         }
-        return true;
-    };
-    ApexPainter.prototype.validateCanvasOptions = function (canvasOptions) {
-        if (!canvasOptions || typeof canvasOptions !== "object") {
-            throw new Error("Invalid canvas options. Provide a valid object for canvas configuration.");
+        ctx.closePath();
+        break;
+      // Add cases for other shapes
+      default:
+        console.error(`Unsupported shape: ${source}`);
+    }
+
+    if (isFilled) {
+      ctx.fill();
+    } else {
+      ctx.stroke();
+    }
+
+    ctx.restore();
+
+    if (stroke && stroke.color !== undefined && stroke.width !== undefined) {
+      ctx.strokeStyle = stroke.color || "transparent";
+      ctx.lineWidth = stroke.width || 1;
+      ctx.save();
+
+      if (rotate) {
+        const centerX = x + width / 2;
+        const centerY = y + height / 2;
+        ctx.translate(centerX, centerY);
+        ctx.rotate((rotate * Math.PI) / 180);
+        ctx.translate(-centerX, -centerY);
+      }
+
+      ctx.fillStyle = "transparent";
+      this.drawRoundedRect(
+        ctx,
+        x,
+        y,
+        width,
+        height,
+        stroke.borderRadius || 0,
+        isFilled,
+      );
+      ctx.stroke();
+
+      ctx.restore();
+    }
+
+    ctx.restore();
+  }////////////////////////
+
+  async addText(textOptionsArray, buffer, baseDir) {
+    try {
+
+      const existingImage = await loadImage(buffer);
+      const canvas = createCanvas(existingImage.width, existingImage.height);
+      const ctx = canvas.getContext("2d");
+
+      // Draw the existing image buffer onto the new canvas
+      ctx.drawImage(existingImage, 0, 0);
+
+      // Loop through each text option and draw it on the canvas
+      for (const textOptions of textOptionsArray) {
+        this.validateTextOptions(textOptions);
+
+        // Merge text options with default options
+        const mergedTextOptions = this.mergeOptions(
+          this.defaultTextOptions,
+          textOptions,
+        );
+
+        if (mergedTextOptions.fontPath) {
+          if (!baseDir)
+            throw new Error("You need to mention __dirname in the textOptions");
+          GlobalFonts.registerFromPath(
+            path.join(baseDir, mergedTextOptions.fontPath),
+            mergedTextOptions.fontName,
+          );
+          ctx.font = `${mergedTextOptions.fontSize}px ${mergedTextOptions.fontName || "Arial"}`;
+        } else {
+          ctx.font = `${mergedTextOptions.fontSize}px ${mergedTextOptions.fontName || "Arial"}`;
         }
-        if (typeof canvasOptions.width !== "number" ||
-            typeof canvasOptions.height !== "number") {
-            throw new Error("Canvas width and height must be numbers.");
+
+        // Draw the text on top of the existing image
+        this.drawText(ctx, mergedTextOptions);
+      }
+
+      // Return the buffer with both image and text
+      return canvas.toBuffer("image/png");
+    } catch (error) {
+      // Handle the case where the buffer is not a valid image
+      console.error("Error loading existing image:", error);
+      throw new Error("Invalid image buffer");
+    }
+  }
+
+  drawText(ctx, textOptions) {
+    const mergedTextOptions = this.mergeOptions(
+      this.defaultTextOptions,
+      textOptions,
+    );
+
+    // Save the initial context state
+    ctx.save();
+
+    ctx.font = `${mergedTextOptions.fontSize}px ${mergedTextOptions.fontName}`;
+    ctx.textAlign = mergedTextOptions.textAlign;
+    ctx.textBaseline = mergedTextOptions.textBaseline;
+
+    // Apply shadow if provided
+    if (
+      mergedTextOptions.shadow &&
+      mergedTextOptions.shadow.offsetX !== undefined &&
+      mergedTextOptions.shadow.offsetY !== undefined
+    ) {
+      ctx.shadowColor = mergedTextOptions.shadow.color || "transparent";
+      ctx.shadowOffsetX = mergedTextOptions.shadow.offsetX;
+      ctx.shadowOffsetY = mergedTextOptions.shadow.offsetY;
+      ctx.shadowBlur = mergedTextOptions.shadow.blur || 0;
+    }
+
+    // Set fill color
+    ctx.fillStyle = mergedTextOptions.color;
+
+    // Draw the text
+    ctx.fillText(
+      mergedTextOptions.text,
+      mergedTextOptions.x,
+      mergedTextOptions.y,
+    );
+
+    // Draw the text stroke if provided
+    if (
+      mergedTextOptions.stroke &&
+      mergedTextOptions.stroke.color &&
+      mergedTextOptions.stroke.width
+    ) {
+      ctx.strokeStyle = mergedTextOptions.stroke.color;
+      ctx.lineWidth = mergedTextOptions.stroke.width;
+
+      // Draw the text stroke
+      ctx.strokeText(
+        mergedTextOptions.text,
+        mergedTextOptions.x,
+        mergedTextOptions.y,
+      );
+    }
+    ctx.restore();
+  }
+
+  mergeOptions(defaultOptions, userOptions) {
+    const mergedOptions = { ...defaultOptions };
+
+    for (const key in userOptions) {
+      if (userOptions[key] !== null && userOptions[key] !== undefined) {
+        if (
+          typeof userOptions[key] === "object" &&
+          defaultOptions[key] !== null &&
+          defaultOptions[key] !== undefined
+        ) {
+          mergedOptions[key] = this.mergeOptions(
+            defaultOptions[key],
+            userOptions[key],
+          );
+        } else {
+          mergedOptions[key] = userOptions[key];
         }
-        if (canvasOptions.width <= 0 || canvasOptions.height <= 0) {
-            throw new Error("Canvas width and height must be positive values.");
+      }
+    }
+
+    return mergedOptions;
+  }
+
+  createGradient(ctx, gradientOptions, startX, startY, endX, endY) {
+    if (!gradientOptions || !gradientOptions.type) {
+      throw new Error(
+        "Invalid gradient options. Provide a valid object with a type property.",
+      );
+    }
+
+    if (gradientOptions.type === "linear") {
+      if (
+        typeof startX !== "number" ||
+        typeof startY !== "number" ||
+        typeof endX !== "number" ||
+        typeof endY !== "number"
+      ) {
+        throw new Error(
+          "Invalid gradient options for linear gradient. Numeric values are required for startX, startY, endX, and endY.",
+        );
+      }
+    } else if (gradientOptions.type === "radial") {
+      if (
+        typeof gradientOptions.startX !== "number" ||
+        typeof gradientOptions.startY !== "number" ||
+        typeof gradientOptions.startRadius !== "number" ||
+        typeof gradientOptions.endX !== "number" ||
+        typeof gradientOptions.endY !== "number" ||
+        typeof gradientOptions.endRadius !== "number"
+      ) {
+        throw new Error(
+          "Invalid gradient options for radial gradient. Numeric values are required for startX, startY, startRadius, endX, endY, and endRadius.",
+        );
+      }
+    } else {
+      throw new Error('Unsupported gradient type. Use "linear" or "radial".');
+    }
+
+    const gradient =
+      gradientOptions.type === "linear"
+        ? ctx.createLinearGradient(startX, startY, endX, endY)
+        : ctx.createRadialGradient(
+            gradientOptions.startX,
+            gradientOptions.startY,
+            gradientOptions.startRadius,
+            gradientOptions.endX,
+            gradientOptions.endY,
+            gradientOptions.endRadius,
+          );
+
+    for (const colorStop of gradientOptions.colors) {
+      gradient.addColorStop(colorStop.stop, colorStop.color);
+    }
+
+    return gradient;
+  }
+
+  drawRoundedImage(ctx, image, x, y, width, height, borderRadius) {
+    ctx.save();
+    ctx.beginPath();
+
+    if (borderRadius === "circular") {
+      const circleRadius = Math.min(width, height) / 2;
+      ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
+    } else {
+      ctx.moveTo(x + borderRadius, y);
+      ctx.lineTo(x + width - borderRadius, y);
+      ctx.quadraticCurveTo(x + width, y, x + width, y + borderRadius);
+      ctx.lineTo(x + width, y + height - borderRadius);
+      ctx.quadraticCurveTo(
+        x + width,
+        y + height,
+        x + width - borderRadius,
+        y + height,
+      );
+      ctx.lineTo(x + borderRadius, y + height);
+      ctx.quadraticCurveTo(x, y + height, x, y + height - borderRadius);
+      ctx.lineTo(x, y + borderRadius);
+      ctx.quadraticCurveTo(x, y, x + borderRadius, y);
+    }
+
+    ctx.closePath();
+    ctx.clip();
+    ctx.drawImage(image, x, y, width, height);
+    ctx.restore();
+  }
+
+  drawRoundedRect(ctx, x, y, width, height, borderRadius) {
+    if (borderRadius === "circular") {
+      const circleRadius = Math.min(width, height) / 2;
+      ctx.beginPath();
+      ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
+      ctx.closePath();
+    } else if (borderRadius) {
+      ctx.beginPath();
+      ctx.moveTo(x + borderRadius, y);
+      ctx.lineTo(x + width - borderRadius, y);
+      ctx.quadraticCurveTo(x + width, y, x + width, y + borderRadius);
+      ctx.lineTo(x + width, y + height - borderRadius);
+      ctx.quadraticCurveTo(
+        x + width,
+        y + height,
+        x + width - borderRadius,
+        y + height,
+      );
+      ctx.lineTo(x + borderRadius, y + height);
+      ctx.quadraticCurveTo(x, y + height, x, y + height - borderRadius);
+      ctx.lineTo(x, y + borderRadius);
+      ctx.quadraticCurveTo(x, y, x + borderRadius, y);
+      ctx.closePath();
+    } else {
+      ctx.rect(x, y, width, height);
+    }
+  }
+
+  ////other options for image manipulations
+  async loadImageFromPathOrURL(imagePath, baseDir) {
+    try {
+      if (!imagePath) {
+        throw new Error("Image path is required.");
+      }
+
+      if (imagePath.startsWith("http")) {
+        if (baseDir) {
+          throw new Error("No need for baseDir when using an image URL.");
         }
-        return true;
-    };
-    ApexPainter.prototype.drawImages = function (imagesOptions, canvasOptions, baseDir) {
-        return __awaiter(this, void 0, void 0, function () {
-            var mergedCanvasOptions, canvas, ctx, customBgImage, gradient, _i, imagesOptions_1, imageOptions;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        mergedCanvasOptions = this.mergeOptions(this.defaultCanvasOptions, canvasOptions);
-                        this.validateCanvasOptions(mergedCanvasOptions);
-                        if (!mergedCanvasOptions.customBg) return [3 /*break*/, 2];
-                        if (typeof mergedCanvasOptions.customBg !== "string" ||
-                            !mergedCanvasOptions.customBg.startsWith("http")) {
-                            throw new Error("Invalid customBg URL");
-                        }
-                        return [4 /*yield*/, (0, canvas_1.loadImage)(mergedCanvasOptions.customBg)];
-                    case 1:
-                        customBgImage = _a.sent();
-                        canvas = (0, canvas_1.createCanvas)(customBgImage.width, customBgImage.height);
-                        ctx = canvas.getContext("2d");
-                        this.drawRoundedRect(ctx, mergedCanvasOptions.x, mergedCanvasOptions.y, mergedCanvasOptions.width, mergedCanvasOptions.height, mergedCanvasOptions.borderRadius);
-                        ctx.clip();
-                        ctx.drawImage(customBgImage, 0, 0);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        canvas = (0, canvas_1.createCanvas)(mergedCanvasOptions.width, mergedCanvasOptions.height);
-                        ctx = canvas.getContext("2d");
-                        if (mergedCanvasOptions.backgroundGradient) {
-                            gradient = this.createGradient(ctx, mergedCanvasOptions.backgroundGradient, mergedCanvasOptions.x, mergedCanvasOptions.y, mergedCanvasOptions.width, mergedCanvasOptions.height);
-                            ctx.fillStyle = gradient;
-                            this.drawRoundedRect(ctx, mergedCanvasOptions.x, mergedCanvasOptions.y, mergedCanvasOptions.width, mergedCanvasOptions.height, mergedCanvasOptions.borderRadius);
-                            ctx.fill();
-                        }
-                        else if (mergedCanvasOptions.backgroundColor) {
-                            if (mergedCanvasOptions.borderRadius) {
-                                this.drawRoundedRect(ctx, mergedCanvasOptions.x, mergedCanvasOptions.y, mergedCanvasOptions.width, mergedCanvasOptions.height, mergedCanvasOptions.borderRadius);
-                                ctx.fillStyle = mergedCanvasOptions.backgroundColor;
-                                ctx.fill();
-                            }
-                            else {
-                                ctx.fillStyle = mergedCanvasOptions.backgroundColor;
-                                ctx.fillRect(mergedCanvasOptions.x, mergedCanvasOptions.y, mergedCanvasOptions.width, mergedCanvasOptions.height);
-                            }
-                        }
-                        _a.label = 3;
-                    case 3:
-                        if (!(imagesOptions && imagesOptions.length > 0)) return [3 /*break*/, 7];
-                        _i = 0, imagesOptions_1 = imagesOptions;
-                        _a.label = 4;
-                    case 4:
-                        if (!(_i < imagesOptions_1.length)) return [3 /*break*/, 7];
-                        imageOptions = imagesOptions_1[_i];
-                        return [4 /*yield*/, this.drawSingleImage(ctx, imageOptions, baseDir)];
-                    case 5:
-                        _a.sent();
-                        _a.label = 6;
-                    case 6:
-                        _i++;
-                        return [3 /*break*/, 4];
-                    case 7: return [2 /*return*/, canvas.toBuffer("image/png")];
-                }
-            });
-        });
-    };
-    ///////Drawing single images
-    ApexPainter.prototype.drawSingleImage = function (ctx, imageOptions, baseDir) {
-        return __awaiter(this, void 0, void 0, function () {
-            var mergedImageOptions, image, imagePath, shadowX, shadowY;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        mergedImageOptions = this.mergeOptions(this.defaultImageOptions, imageOptions);
-                        this.validateImageOptions(imageOptions);
-                        // Check if the source is a shape name
-                        if (mergedImageOptions.source &&
-                            this.isShapeName(mergedImageOptions.source)) {
-                            this.drawShape(ctx, mergedImageOptions);
-                            return [2 /*return*/];
-                        }
-                        if (!mergedImageOptions.source) return [3 /*break*/, 10];
-                        image = void 0;
-                        if (!baseDir) return [3 /*break*/, 5];
-                        imagePath = path_1.join(baseDir, mergedImageOptions.source);
-                        if (!(mergedImageOptions.source.startsWith("http") ||
-                            mergedImageOptions.source.startsWith("https"))) return [3 /*break*/, 2];
-                        return [4 /*yield*/, (0, canvas_1.loadImage)(mergedImageOptions.source)];
-                    case 1:
-                        image = _a.sent();
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, (0, canvas_1.loadImage)(imagePath)];
-                    case 3:
-                        image = _a.sent();
-                        _a.label = 4;
-                    case 4: return [3 /*break*/, 9];
-                    case 5:
-                        if (!(mergedImageOptions.source.startsWith("http") ||
-                            mergedImageOptions.source.startsWith("https"))) return [3 /*break*/, 7];
-                        return [4 /*yield*/, (0, canvas_1.loadImage)(mergedImageOptions.source)];
-                    case 6:
-                        image = _a.sent();
-                        return [3 /*break*/, 9];
-                    case 7: return [4 /*yield*/, (0, canvas_1.loadImage)(mergedImageOptions.source)];
-                    case 8:
-                        image = _a.sent();
-                        _a.label = 9;
-                    case 9:
-                        // Save the initial context state
-                        ctx.save();
-                        // Apply shadow if provided
-                        if (mergedImageOptions.shadow &&
-                            mergedImageOptions.shadow.offsetX &&
-                            mergedImageOptions.shadow.offsetY) {
-                            ctx.globalAlpha = mergedImageOptions.shadow.opacity || null;
-                            ctx.filter = "blur(".concat(mergedImageOptions.shadow.blur || null, "px)");
-                            shadowX = mergedImageOptions.x + (mergedImageOptions.shadow.offsetX || 0);
-                            shadowY = mergedImageOptions.y + (mergedImageOptions.shadow.offsetY || 0);
-                            this.drawRoundedRect(ctx, shadowX, shadowY, mergedImageOptions.width, mergedImageOptions.height, mergedImageOptions.shadow.borderRadius || 0);
-                            ctx.fillStyle = mergedImageOptions.shadow.color || "transparent";
-                            ctx.fill();
-                        }
-                        // Reset filter and opacity properties
-                        ctx.filter = "none";
-                        ctx.globalAlpha = 1;
-                        // Draw the actual image
-                        this.drawRoundedImage(ctx, image, mergedImageOptions.x, mergedImageOptions.y, mergedImageOptions.width, mergedImageOptions.height, mergedImageOptions.borderRadius || 0);
-                        // Restore the context state
-                        ctx.restore();
-                        // Apply stroke if provided
-                        if (mergedImageOptions.stroke &&
-                            mergedImageOptions.stroke.color &&
-                            mergedImageOptions.stroke.width) {
-                            ctx.strokeStyle = mergedImageOptions.stroke.color || "transparent"; // Change color as needed
-                            ctx.lineWidth = mergedImageOptions.stroke.width || 1;
-                            // Draw the rounded rectangle for stroke
-                            this.drawRoundedRect(ctx, mergedImageOptions.x, mergedImageOptions.y, mergedImageOptions.width, mergedImageOptions.height, mergedImageOptions.stroke.borderRadius || 0);
-                            ctx.stroke();
-                        }
-                        ctx.restore();
-                        _a.label = 10;
-                    case 10: return [2 /*return*/];
-                }
-            });
+
+        const response = await axios.get(imagePath, {
+          responseType: "arraybuffer",
         });
-    };
-    ApexPainter.prototype.isShapeName = function (source) {
-        var validShapes = ["square", "circle", "triangle", "rectangle", "pentagon"];
-        return validShapes.includes(source.toLowerCase());
-    };
-    ApexPainter.prototype.drawShape = function (ctx, shapeOptions) {
-        var source = shapeOptions.source, x = shapeOptions.x, y = shapeOptions.y, width = shapeOptions.width, height = shapeOptions.height, borderRadius = shapeOptions.borderRadius, stroke = shapeOptions.stroke, color = shapeOptions.color, rotate = shapeOptions.rotate, filled = shapeOptions.filled, gradient = shapeOptions.gradient, shadow = shapeOptions.shadow;
-        var isFilled = filled !== undefined ? filled : true;
-        // Save the initial context state
-        ctx.save();
-        // Apply shadow if provided
-        if (shadow && shadow.offsetX && shadow.offsetY) {
-            ctx.globalAlpha = shadow.opacity || null;
-            ctx.filter = "blur(".concat(shadow.blur || null, "px)");
-            var shadowX = x + (shadow.offsetX || 0);
-            var shadowY = y + (shadow.offsetY || 0);
-            this.drawRoundedRect(ctx, shadowX, shadowY, width, height, shadow.borderRadius || 0);
-            ctx.fillStyle = shadow.color || "transparent";
-            ctx.fill();
-        }
-        // Reset filter property
-        ctx.filter = "none";
-        ctx.globalAlpha = 1;
-        if (rotate) {
-            var centerX = x + width / 2;
-            var centerY = y + height / 2;
-            ctx.translate(centerX, centerY);
-            ctx.rotate((rotate * Math.PI) / 180);
-            ctx.translate(-centerX, -centerY);
-        }
-        if (gradient) {
-            var gradientFill = typeof gradient === 'string'
-                ? gradient
-                : this.createGradient(ctx, gradient, x, y, x + width, y + height);
-            ctx.fillStyle = gradientFill;
+        return sharp(response.data);
+      } else {
+        if (!baseDir) {
+          throw new Error("baseDir is required for local file paths.");
         }
-        else {
-            ctx.fillStyle = color || "transparent";
+
+        const absolutePath = path.resolve(baseDir, imagePath);
+        return sharp(absolutePath);
+      }
+    } catch (error) {
+      console.error("Error loading image:", error);
+      throw new Error("Failed to load image");
+    }
+  }
+
+  /// Resizing an image
+  async resize(resizeOptions, baseDir) {
+    try {
+      if (!resizeOptions.imagePath) {
+        throw new Error("Image path is required for resizing.");
+      }
+
+      let imagePath;
+
+      if (Buffer.isBuffer(resizeOptions.imagePath)) {
+        const resizedBuffer = await sharp(resizeOptions.imagePath)
+          .resize(resizeOptions.size.width, resizeOptions.size.height)
+          .toBuffer();
+
+        return resizedBuffer;
+      }
+      
+      if (resizeOptions.imagePath.startsWith("http")) {
+        if (baseDir) {
+          throw new Error("No need for baseDir when using an image URL.");
         }
-        ctx.beginPath();
-        switch (source.toLowerCase()) {
-            case "square":
-                this.drawRoundedRect(ctx, x, y, width, height, borderRadius || 0);
-                break;
-            case "circle":
-                var circleRadius = Math.min(width, height) / 2;
-                ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
-                break;
-            case "triangle":
-                ctx.moveTo(x + width / 2, y);
-                ctx.lineTo(x + width, y + height);
-                ctx.lineTo(x, y + height);
-                ctx.closePath();
-                break;
-            case "pentagon":
-                var sideLength = Math.min(width, height);
-                for (var i = 0; i < 5; i++) {
-                    var angle = (i * 2 * Math.PI) / 5;
-                    var px = x + width / 2 + sideLength * Math.cos(angle);
-                    var py = y + height / 2 + sideLength * Math.sin(angle);
-                    if (i === 0) {
-                        ctx.moveTo(px, py);
-                    }
-                    else {
-                        ctx.lineTo(px, py);
-                    }
-                }
-                ctx.closePath();
-                break;
-            // Add cases for other shapes
-            default:
-                console.error("Unsupported shape: ".concat(source));
+
+        imagePath = resizeOptions.imagePath;
+      } else {
+        if (!baseDir) {
+          throw new Error("baseDir is required for local file paths.");
         }
-        if (isFilled) {
-            ctx.fill();
+
+        imagePath = path.resolve(baseDir, resizeOptions.imagePath);
+      }
+
+      const image = await this.loadImageFromPathOrURL(imagePath);
+
+      const resizedBuffer = await image.resize(resizeOptions.size).toBuffer();
+
+      return resizedBuffer;
+    } catch (error) {
+      console.error("Error resizing image:", error);
+      throw new Error("Failed to resize image");
+    }
+  }
+
+
+  /////converter
+  async imageConverter(imagePath, newExtension, baseDir) {
+    try {
+      let image;
+
+      if (imagePath.startsWith("http")) {
+        const response = await axios.get(imagePath, {
+          responseType: "arraybuffer",
+        });
+        image = sharp(Buffer.from(response.data));
+      } else {
+        if (!imagePath) {
+          throw new Error("Image path is required.");
         }
-        else {
-            ctx.stroke();
+
+        if (!baseDir) {
+          throw new Error("baseDir is required for local file paths.");
         }
-        ctx.restore();
-        if (stroke && stroke.color !== undefined && stroke.width !== undefined) {
-            ctx.strokeStyle = stroke.color || "transparent";
-            ctx.lineWidth = stroke.width || 1;
-            ctx.save();
-            if (rotate) {
-                var centerX = x + width / 2;
-                var centerY = y + height / 2;
-                ctx.translate(centerX, centerY);
-                ctx.rotate((rotate * Math.PI) / 180);
-                ctx.translate(-centerX, -centerY);
-            }
-            ctx.fillStyle = "transparent";
-            this.drawRoundedRect(ctx, x, y, width, height, stroke.borderRadius || 0);
-            ctx.stroke();
-            ctx.restore();
+
+        const absolutePath = path.resolve(baseDir, imagePath);
+        image = sharp(absolutePath);
+      }
+
+      const convertedBuffer = await image.toFormat(newExtension).toBuffer();
+      return convertedBuffer;
+    } catch (error) {
+      console.error("Error changing image extension:", error);
+      throw new Error("Failed to change image extension");
+    }
+  }
+
+  /////image filters
+  async processImage(imagePath, filters, baseDir = null) {
+    try {
+      let jimpImage;
+
+      if (imagePath.startsWith("http")) {
+        const pngBuffer = await this.imageConverter(imagePath, "png", baseDir);
+        jimpImage = await Jimp.read(pngBuffer);
+      } else {
+        if (!baseDir) {
+          return console.log(`You need to provide __dirname in options.`);
         }
-        ctx.restore();
-    };
-    ApexPainter.prototype.addText = function (textOptionsArray, buffer, baseDir) {
-        return __awaiter(this, void 0, void 0, function () {
-            var existingImage, canvas, ctx, _i, textOptionsArray_1, textOptions, mergedTextOptions, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, (0, canvas_1.loadImage)(buffer)];
-                    case 1:
-                        existingImage = _a.sent();
-                        canvas = (0, canvas_1.createCanvas)(existingImage.width, existingImage.height);
-                        ctx = canvas.getContext("2d");
-                        ctx.drawImage(existingImage, 0, 0);
-                        for (_i = 0, textOptionsArray_1 = textOptionsArray; _i < textOptionsArray_1.length; _i++) {
-                            textOptions = textOptionsArray_1[_i];
-                            this.validateTextOptions(textOptions);
-                            mergedTextOptions = this.mergeOptions(this.defaultTextOptions, textOptions);
-                            if (mergedTextOptions.fontPath) {
-                                if (!baseDir) {
-                                    throw new Error("You need to mention __dirname in the textOptions");
-                                }
-                                canvas_1.GlobalFonts.registerFromPath(path_1.join(baseDir, mergedTextOptions.fontPath), mergedTextOptions.fontName);
-                                ctx.font = "".concat(mergedTextOptions.fontSize, "px ").concat(mergedTextOptions.fontName || "Arial");
-                            }
-                            else {
-                                ctx.font = "".concat(mergedTextOptions.fontSize, "px ").concat(mergedTextOptions.fontName || "Arial");
-                            }
-                            this.drawText(ctx, mergedTextOptions);
-                        }
-                        return [2 /*return*/, canvas.toBuffer("image/png")];
-                    case 2:
-                        error_1 = _a.sent();
-                        // Handle the case where the buffer is not a valid image
-                        console.error("Error loading existing image:", error_1);
-                        throw new Error("Invalid image buffer");
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ApexPainter.prototype.drawText = function (ctx, textOptions) {
-        var mergedTextOptions = this.mergeOptions(this.defaultTextOptions, textOptions);
-        // Save the initial context state
-        ctx.save();
-        ctx.font = "".concat(mergedTextOptions.fontSize, "px ").concat(mergedTextOptions.fontName);
-        ctx.textAlign = mergedTextOptions.textAlign;
-        ctx.textBaseline = mergedTextOptions.textBaseline;
-        // Apply shadow if provided
-        if (mergedTextOptions.shadow &&
-            mergedTextOptions.shadow.offsetX !== undefined &&
-            mergedTextOptions.shadow.offsetY !== undefined) {
-            ctx.shadowColor = mergedTextOptions.shadow.color || "transparent";
-            ctx.shadowOffsetX = mergedTextOptions.shadow.offsetX;
-            ctx.shadowOffsetY = mergedTextOptions.shadow.offsetY;
-            ctx.shadowBlur = mergedTextOptions.shadow.blur || 0;
+        const imagePathResolved = baseDir
+          ? path.resolve(baseDir, imagePath)
+          : imagePath;
+        jimpImage = await Jimp.read(imagePathResolved);
+      }
+
+      for (const filter of filters) {
+        switch (filter.type) {
+          case "flip":
+            jimpImage.flip(filter.horizontal, filter.vertical);
+            break;
+          case "mirror":
+            jimpImage.mirror(filter.horizontal, filter.vertical);
+            break;
+          case "rotate":
+            jimpImage.rotate(filter.deg, filter.mode);
+            break;
+          case "brightness":
+            jimpImage.brightness(filter.value);
+            break;
+          case "contrast":
+            jimpImage.contrast(filter.value);
+            break;
+          case "dither565":
+            jimpImage.dither565();
+            break;
+          case "greyscale":
+            jimpImage.greyscale();
+            break;
+          case "invert":
+            jimpImage.invert();
+            break;
+          case "normalize":
+            jimpImage.normalize();
+            break;
+          case "autocrop":
+            jimpImage.autocrop(filter.tolerance || 0);
+            break;
+          case "crop":
+            jimpImage.crop(filter.x, filter.y, filter.w, filter.h);
+            break;
+          case "fade":
+            jimpImage.fade(filter.factor);
+            break;
+          case "opacity":
+            jimpImage.opacity(filter.factor);
+            break;
+          case "opaque":
+            jimpImage.opaque();
+            break;
+          case "gaussian":
+            jimpImage.gaussian(filter.radius);
+            break;
+          case "blur":
+            jimpImage.blur(filter.radius);
+            break;
+          case "posterize":
+            jimpImage.posterize(filter.levels);
+            break;
+          case "sepia":
+            jimpImage.sepia();
+            break;
+          case "pixelate":
+            jimpImage.pixelate(
+              filter.size,
+              filter.x,
+              filter.y,
+              filter.w,
+              filter.h,
+            );
+            break;
+          default:
+            console.error(`Unsupported filter type: ${filter.type}`);
         }
-        // Set fill color
-        ctx.fillStyle = mergedTextOptions.color;
-        // Draw the text
-        ctx.fillText(mergedTextOptions.text, mergedTextOptions.x, mergedTextOptions.y);
-        // Draw the text stroke if provided
-        if (mergedTextOptions.stroke &&
-            mergedTextOptions.stroke.color &&
-            mergedTextOptions.stroke.width) {
-            ctx.strokeStyle = mergedTextOptions.stroke.color;
-            ctx.lineWidth = mergedTextOptions.stroke.width;
-            // Draw the text stroke
-            ctx.strokeText(mergedTextOptions.text, mergedTextOptions.x, mergedTextOptions.y);
+      }
+
+      const outputMimeType = jimpImage._originalMime || Jimp.MIME_PNG;
+
+      return await jimpImage.getBufferAsync(outputMimeType);
+    } catch (error) {
+      console.error("Error processing image:", error.message);
+      console.error(error.stack);
+      throw new Error("Failed to process image");
+    }
+  }
+
+  validateColor(filterColor) {
+    const hexColorRegex = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+    const isHexColor = hexColorRegex.test(filterColor);
+
+    if (!isHexColor) {
+      throw new Error("Invalid color format. Only hex colors are supported.");
+    }
+
+    return true;
+  }
+
+  async colorFilters(imagePath, filterColor, baseDir = null) {
+    try {
+      this.validateColor(filterColor);
+
+      let jimpImage;
+
+      if (imagePath.startsWith("http")) {
+        const pngBuffer = await this.imageConverter(imagePath, "png", baseDir);
+        jimpImage = await Jimp.read(pngBuffer);
+      } else {
+        if (!baseDir) {
+          return console.log(`You need to provide __dirname in options.`);
         }
-        ctx.restore();
-    };
-    ApexPainter.prototype.mergeOptions = function (defaultOptions, userOptions) {
-        var mergedOptions = __assign({}, defaultOptions);
-        for (var key in userOptions) {
-            if (userOptions[key] !== null && userOptions[key] !== undefined) {
-                if (typeof userOptions[key] === 'object' &&
-                    defaultOptions[key] !== null &&
-                    defaultOptions[key] !== undefined) {
-                    mergedOptions[key] = this.mergeOptions(defaultOptions[key], userOptions[key]);
-                }
-                else {
-                    mergedOptions[key] = userOptions[key];
-                }
-            }
+        const imagePathResolved = baseDir
+          ? path.resolve(baseDir, imagePath)
+          : imagePath;
+        jimpImage = await Jimp.read(imagePathResolved);
+      }
+
+      jimpImage.color([{ apply: "mix", params: [filterColor, 100] }]);
+
+      return await jimpImage.getBufferAsync(Jimp.MIME_PNG);
+    } catch (error) {
+      console.error("Error applying color filter:", error.message);
+      console.error(error.stack);
+      throw new Error("Failed to apply color filter");
+    }
+  }
+
+  ////background removal
+  async bgRemoval(options) {
+    const apiKey = options.apiKey;
+    const formData = new FormData();
+
+    if (!apiKey) {
+      throw new Error(
+        "Error: No Api_Key was provided. We don't provide a default one.",
+      );
+    }
+
+    if (!options.imageUrl) {
+      throw new Error(
+        "Error: Please provide a valid image source (image_url).",
+      );
+    }
+
+    if (
+      options.imageUrl.startsWith("https://media.discordapp.net/attachments/")
+    ) {
+      throw new Error(
+        "Error: Discord image URL isn't suppported at the moment.",
+      );
+    }
+
+ const lowerCaseImageUrl = options.imageUrl.toLowerCase();
+if (!lowerCaseImageUrl.endsWith(".png") && !lowerCaseImageUrl.endsWith(".jpg")) {
+  throw new Error("Error: Unsupported image format. Please provide a valid URL ending with .png or .jpg.");
+}
+
+    formData.append("size", options.size || "auto");
+    formData.append("image_url", options.imageUrl);
+    formData.append("type_level", options.type_level || "latest");
+    formData.append("format", options.format || "auto");
+    formData.append("roi", options.roi || "0% 0% 100% 100%");
+    formData.append("crop", options.crop || false);
+    formData.append("crop_margin", options.crop_margin || "0");
+    formData.append("scale", options.scale || "original");
+    formData.append("position", options.position || "original");
+    formData.append("channels", options.channels || "rgba");
+    formData.append("add_shadow", options.add_shadow || false);
+    formData.append("semitransparency", options.semitransparency || true);
+
+    formData.append("bg_color", options.bg_color || null);
+    formData.append("bg_image_url", options.bg_image_url || null);
+    
+    try {
+      const response = await axios({
+        method: "post",
+        url: "https://api.remove.bg/v1.0/removebg",
+        data: formData,
+        responseType: "arraybuffer",
+        headers: {
+          ...formData.getHeaders(),
+          "X-Api-Key": apiKey,
+        },
+        encoding: null,
+      });
+
+      if (response.status !== 200) {
+        const errorCode = response.status;
+        switch (errorCode) {
+          case 400:
+            console.error(
+              "Error 400: Invalid parameters or input file unprocessable (no credits charged)",
+            );
+            break;
+          case 402:
+            console.error(
+              "Error 402: Insufficient credits (no credits charged)",
+            );
+            break;
+          case 403:
+            console.error(
+              "Error 403: Authentication failed (no credits charged)",
+            );
+            break;
+          case 429:
+            console.error(
+              "Error 429: Rate limit exceeded (no credits charged)",
+            );
+            break;
+          default:
+            console.error("Error:", errorCode, response.statusText);
+            break;
         }
-        return mergedOptions;
-    };
-    ApexPainter.prototype.createGradient = function (ctx, gradientOptions, startX, startY, endX, endY) {
-        if (!gradientOptions || !gradientOptions.type) {
-            throw new Error("Invalid gradient options. Provide a valid object with a type property.");
+      } else {
+        return response.data;
+      }
+    } catch (error) {
+      console.error("Request failed:", error.message);
+    }
+  }
+
+  /////Draw gif
+  async createGIF(images, options = {}) {
+    async function resizeImage(image, targetWidth, targetHeight) {
+      const canvas = createCanvas(targetWidth, targetHeight);
+      const ctx = canvas.getContext("2d");
+      ctx.drawImage(image, 0, 0, targetWidth, targetHeight);
+      return canvas;
+    }
+
+    function createOutputStream(outputFile) {
+      return fs.createWriteStream(outputFile);
+    }
+
+    function createBufferStream() {
+      const bufferStream = new stream.Writable();
+      bufferStream.buffer = Buffer.alloc(0);
+
+      bufferStream._write = function (chunk, encoding, next) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        next();
+      };
+
+      bufferStream.getBuffer = function () {
+        return this.buffer;
+      };
+
+      return bufferStream;
+    }
+
+    function validateOptions(options) {
+      if (options.outputFormat === "file" && !options.outputFile) {
+        throw new Error(
+          "Output file path is required when using file output format.",
+        );
+      }
+
+      if (
+        options.repeat !== undefined &&
+        (typeof options.repeat !== "number" || options.repeat < 0)
+      ) {
+        throw new Error("Repeat must be a non-negative number or undefined.");
+      }
+
+      if (
+        options.quality !== undefined &&
+        (typeof options.quality !== "number" ||
+          options.quality < 1 ||
+          options.quality > 20)
+      ) {
+        throw new Error(
+          "Quality must be a number between 1 and 20 or undefined.",
+        );
+      }
+
+      if (options.canvasSize) {
+        if (
+          options.canvasSize.width !== undefined &&
+          (!Number.isInteger(options.canvasSize.width) ||
+            options.canvasSize.width <= 0)
+        ) {
+          throw new Error(
+            "Canvas width must be a positive integer or undefined.",
+          );
         }
-        if (gradientOptions.type === "linear") {
-            if (typeof startX !== "number" ||
-                typeof startY !== "number" ||
-                typeof endX !== "number" ||
-                typeof endY !== "number") {
-                throw new Error("Invalid gradient options for linear gradient. Numeric values are required for startX, startY, endX, and endY.");
-            }
+
+        if (
+          options.canvasSize.height !== undefined &&
+          (!Number.isInteger(options.canvasSize.height) ||
+            options.canvasSize.height <= 0)
+        ) {
+          throw new Error(
+            "Canvas height must be a positive integer or undefined.",
+          );
         }
-        else if (gradientOptions.type === "radial") {
-            if (typeof gradientOptions.startX !== "number" ||
-                typeof gradientOptions.startY !== "number" ||
-                typeof gradientOptions.startRadius !== "number" ||
-                typeof gradientOptions.endX !== "number" ||
-                typeof gradientOptions.endY !== "number" ||
-                typeof gradientOptions.endRadius !== "number") {
-                throw new Error("Invalid gradient options for radial gradient. Numeric values are required for startX, startY, startRadius, endX, endY, and endRadius.");
-            }
+      }
+
+      if (
+        options.delay !== undefined &&
+        (!Number.isInteger(options.delay) || options.delay <= 0)
+      ) {
+        throw new Error("Delay must be a positive integer or undefined.");
+      }
+
+      if (
+        options.watermark !== undefined &&
+        typeof options.watermark !== "boolean"
+      ) {
+        throw new Error("Watermark must be a boolean or undefined.");
+      }
+
+      if (options.textOverlay !== undefined) {
+        if (
+          !options.textOverlay.text ||
+          typeof options.textOverlay.text !== "string"
+        ) {
+          throw new Error(
+            "Text overlay text is required and must be a string.",
+          );
         }
-        else {
-            throw new Error('Unsupported gradient type. Use "linear" or "radial".');
+
+        if (
+          options.textOverlay.fontName !== undefined &&
+          typeof options.textOverlay.fontName !== "string"
+        ) {
+          throw new Error(
+            "Text overlay fontName must be a string or undefined.",
+          );
         }
-        var gradient = gradientOptions.type === "linear"
-            ? ctx.createLinearGradient(startX, startY, endX, endY)
-            : ctx.createRadialGradient(gradientOptions.startX, gradientOptions.startY, gradientOptions.startRadius, gradientOptions.endX, gradientOptions.endY, gradientOptions.endRadius);
-        for (var _i = 0, _a = gradientOptions.colors; _i < _a.length; _i++) {
-            var colorStop = _a[_i];
-            gradient.addColorStop(colorStop.stop, colorStop.color);
+
+        if (
+          options.textOverlay.fontPath !== undefined &&
+          typeof options.textOverlay.fontPath !== "string"
+        ) {
+          throw new Error(
+            "Text overlay fontPath must be a string or undefined.",
+          );
         }
-        return gradient;
-    };
-    ApexPainter.prototype.drawRoundedImage = function (ctx, image, x, y, width, height, borderRadius) {
-        ctx.save();
-        ctx.beginPath();
-        if (borderRadius === "circular") {
-            var circleRadius = Math.min(width, height) / 2;
-            ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
+
+        if (
+          options.textOverlay.fontSize !== undefined &&
+          (!Number.isInteger(options.textOverlay.fontSize) ||
+            options.textOverlay.fontSize <= 0)
+        ) {
+          throw new Error(
+            "Text overlay fontSize must be a positive integer or undefined.",
+          );
         }
-        else {
-            ctx.moveTo(x + borderRadius, y);
-            ctx.lineTo(x + width - borderRadius, y);
-            ctx.quadraticCurveTo(x + width, y, x + width, y + borderRadius);
-            ctx.lineTo(x + width, y + height - borderRadius);
-            ctx.quadraticCurveTo(x + width, y + height, x + width - borderRadius, y + height);
-            ctx.lineTo(x + borderRadius, y + height);
-            ctx.quadraticCurveTo(x, y + height, x, y + height - borderRadius);
-            ctx.lineTo(x, y + borderRadius);
-            ctx.quadraticCurveTo(x, y, x + borderRadius, y);
+
+        if (
+          options.textOverlay.fontColor !== undefined &&
+          typeof options.textOverlay.fontColor !== "string"
+        ) {
+          throw new Error(
+            "Text overlay fontColor must be a string or undefined.",
+          );
         }
-        ctx.closePath();
-        ctx.clip();
-        ctx.drawImage(image, x, y, width, height);
-        ctx.restore();
-    };
-    ApexPainter.prototype.drawRoundedRect = function (ctx, x, y, width, height, borderRadius) {
-        if (borderRadius === "circular") {
-            var circleRadius = Math.min(width, height) / 2;
-            ctx.beginPath();
-            ctx.arc(x + width / 2, y + height / 2, circleRadius, 0, 2 * Math.PI);
-            ctx.closePath();
+      }
+    }
+    function validateImageObject(imageObject) {
+      return (
+        imageObject &&
+        typeof imageObject === "object" &&
+        "source" in imageObject &&
+        "isRemote" in imageObject
+      );
+    }
+
+    function validateImages(images) {
+      if (!Array.isArray(images)) {
+        throw new Error('The "images" parameter must be an array.');
+      }
+
+      if (images.length === 0) {
+        throw new Error(
+          'The "images" array must contain at least one image object.',
+        );
+      }
+
+      for (const imageObject of images) {
+        if (!validateImageObject(imageObject)) {
+          throw new Error(
+            'Each image object must have "source" and "isRemote" properties.',
+          );
         }
-        else if (borderRadius) {
-            ctx.beginPath();
-            ctx.moveTo(x + borderRadius, y);
-            ctx.lineTo(x + width - borderRadius, y);
-            ctx.quadraticCurveTo(x + width, y, x + width, y + borderRadius);
-            ctx.lineTo(x + width, y + height - borderRadius);
-            ctx.quadraticCurveTo(x + width, y + height, x + width - borderRadius, y + height);
-            ctx.lineTo(x + borderRadius, y + height);
-            ctx.quadraticCurveTo(x, y + height, x, y + height - borderRadius);
-            ctx.lineTo(x, y + borderRadius);
-            ctx.quadraticCurveTo(x, y, x + borderRadius, y);
-            ctx.closePath();
+      }
+    }
+
+    try {
+      validateOptions(options);
+      validateImages(images);
+
+      const canvasWidth = options.canvasSize?.width || 1200;
+      const canvasHeight = options.canvasSize?.height || 1200;
+
+      const encoder = new GIFEncoder(canvasWidth, canvasHeight);
+      const outputStream = options.outputFile
+        ? createOutputStream(options.outputFile)
+        : createBufferStream();
+
+      encoder.createReadStream().pipe(outputStream);
+
+      encoder.start();
+      encoder.setRepeat(options.repeat || 0);
+      encoder.setQuality(options.quality || 10);
+      encoder.setDelay(options.delay || 3000);
+
+      const canvas = createCanvas(canvasWidth, canvasHeight);
+      const ctx = canvas.getContext("2d");
+
+      for (const imageInfo of images) {
+        const image = imageInfo.isRemote
+          ? await loadImage(imageInfo.source)
+          : await loadImage(imageInfo.source);
+
+        const resizedImage = await resizeImage(
+          image,
+          canvasWidth,
+          canvasHeight,
+        );
+
+        ctx.clearRect(0, 0, canvas.width, canvas.height);
+        ctx.drawImage(resizedImage, 0, 0);
+
+        if (options.watermark) {
+          const watermark = await loadImage("");
+          ctx.drawImage(watermark, 10, canvasHeight - watermark.height - 10);
         }
-        else {
-            ctx.rect(x, y, width, height);
+
+        if (options.textOverlay) {
+          const textOptions = options.textOverlay;
+          const fontPath = textOptions.fontPath;
+          const fontName = textOptions.fontName || "Arial";
+          const fontSize = textOptions.fontSize || 20;
+          const fontColor = textOptions.fontColor || "white";
+          const x = textOptions.x || 10;
+          const y = textOptions.y || 30;
+
+          if (fontPath) {
+            GlobalFonts.registerFromPath(
+              path.join(options.basDir, fontPath),
+              fontName,
+            );
+          }
+
+          ctx.font = `${fontSize}px ${fontName}`;
+          ctx.fillStyle = fontColor;
+          ctx.fillText(textOptions.text, x, y);
         }
-    };
-    ApexPainter.prototype.loadImageFromPathOrURL = function (imagePath, baseDir) {
-        return __awaiter(this, void 0, void 0, function () {
-            var response, absolutePath, error_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 4, , 5]);
-                        if (!imagePath) {
-                            throw new Error("Image path is required.");
-                        }
-                        if (!imagePath.startsWith("http")) return [3 /*break*/, 2];
-                        if (baseDir) {
-                            throw new Error("No need for baseDir when using an image URL.");
-                        }
-                        return [4 /*yield*/, axios_1.get(imagePath, {
-                                responseType: "arraybuffer",
-                            })];
-                    case 1:
-                        response = _a.sent();
-                        return [2 /*return*/, (0, sharp_1.default)(Buffer.from(response.data))];
-                    case 2:
-                        if (!baseDir) {
-                            throw new Error("baseDir is required for local file paths.");
-                        }
-                        absolutePath = path_1.resolve(baseDir, imagePath);
-                        return [2 /*return*/, (0, sharp_1.default)(absolutePath)];
-                    case 3: return [3 /*break*/, 5];
-                    case 4:
-                        error_2 = _a.sent();
-                        console.error("Error loading image:", error_2);
-                        throw new Error("Failed to load image");
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ApexPainter.prototype.resize = function (resizeOptions, baseDir) {
-        return __awaiter(this, void 0, void 0, function () {
-            var imagePath, resizedBuffer_1, image, resizedBuffer, error_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        if (!resizeOptions.imagePath) {
-                            throw new Error("Image path is required for resizing.");
-                        }
-                        imagePath = void 0;
-                        if (!Buffer.isBuffer(resizeOptions.imagePath)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, (0, sharp_1.default)(resizeOptions.imagePath)
-                                .resize(resizeOptions.size.width, resizeOptions.size.height)
-                                .toBuffer()];
-                    case 1:
-                        resizedBuffer_1 = _a.sent();
-                        return [2 /*return*/, resizedBuffer_1];
-                    case 2:
-                        if (resizeOptions.imagePath.startsWith("http")) {
-                            if (baseDir) {
-                                throw new Error("No need for baseDir when using an image URL.");
-                            }
-                            imagePath = resizeOptions.imagePath;
-                        }
-                        else {
-                            if (!baseDir) {
-                                throw new Error("baseDir is required for local file paths.");
-                            }
-                            imagePath = path_1.resolve(baseDir, resizeOptions.imagePath);
-                        }
-                        return [4 /*yield*/, this.loadImageFromPathOrURL(imagePath)];
-                    case 3:
-                        image = _a.sent();
-                        return [4 /*yield*/, image.resize(resizeOptions.size).toBuffer()];
-                    case 4:
-                        resizedBuffer = _a.sent();
-                        return [2 /*return*/, resizedBuffer];
-                    case 5:
-                        error_3 = _a.sent();
-                        console.error("Error resizing image:", error_3);
-                        throw new Error("Failed to resize image");
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ApexPainter.prototype.imageConverter = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var image, response, absolutePath, convertedBuffer, error_4;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        image = void 0;
-                        if (!options.imagePath.startsWith("http")) return [3 /*break*/, 2];
-                        return [4 /*yield*/, axios_1.get(options.imagePath, {
-                                responseType: "arraybuffer",
-                            })];
-                    case 1:
-                        response = _a.sent();
-                        image = (0, sharp_1.default)(Buffer.from(response.data));
-                        return [3 /*break*/, 3];
-                    case 2:
-                        if (!options.imagePath) {
-                            throw new Error("Image path is required.");
-                        }
-                        if (!options.baseDir) {
-                            throw new Error("baseDir is required for local file paths.");
-                        }
-                        absolutePath = path_1.resolve(options.baseDir, options.imagePath);
-                        image = (0, sharp_1.default)(absolutePath);
-                        _a.label = 3;
-                    case 3: return [4 /*yield*/, image.toFormat(options.newExtension).toBuffer()];
-                    case 4:
-                        convertedBuffer = _a.sent();
-                        return [2 /*return*/, convertedBuffer];
-                    case 5:
-                        error_4 = _a.sent();
-                        console.error("Error changing image extension:", error_4);
-                        throw new Error("Failed to change image extension");
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ApexPainter.prototype.processImage = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var jimpImage, pngBuffer, imagePathResolved, _i, _a, filter, outputMimeType, error_5;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 7, , 8]);
-                        jimpImage = void 0;
-                        if (!options.imagePath.startsWith("http")) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.imageConverter({
-                                imagePath: options.imagePath,
-                                newExtension: "png",
-                                baseDir: options.baseDir !== null ? options.baseDir : undefined,
-                            })];
-                    case 1:
-                        pngBuffer = _b.sent();
-                        return [4 /*yield*/, jimp_1.read(pngBuffer)];
-                    case 2:
-                        jimpImage = _b.sent();
-                        return [3 /*break*/, 5];
-                    case 3:
-                        if (!options.baseDir) {
-                            throw new Error("You need to provide __dirname in options.");
-                        }
-                        imagePathResolved = options.baseDir
-                            ? path_1.resolve(options.baseDir, options.imagePath)
-                            : options.imagePath;
-                        return [4 /*yield*/, jimp_1.read(imagePathResolved)];
-                    case 4:
-                        jimpImage = _b.sent();
-                        _b.label = 5;
-                    case 5:
-                        for (_i = 0, _a = options.filters; _i < _a.length; _i++) {
-                            filter = _a[_i];
-                            switch (filter.type) {
-                                case "flip":
-                                    jimpImage.flip(filter.horizontal, filter.vertical);
-                                    break;
-                                case "mirror":
-                                    jimpImage.mirror(filter.horizontal, filter.vertical);
-                                    break;
-                                case "rotate":
-                                    jimpImage.rotate(filter.deg, filter.mode);
-                                    break;
-                                case "brightness":
-                                    jimpImage.brightness(filter.value);
-                                    break;
-                                case "contrast":
-                                    jimpImage.contrast(filter.value);
-                                    break;
-                                case "dither565":
-                                    jimpImage.dither565();
-                                    break;
-                                case "greyscale":
-                                    jimpImage.greyscale();
-                                    break;
-                                case "invert":
-                                    jimpImage.invert();
-                                    break;
-                                case "normalize":
-                                    jimpImage.normalize();
-                                    break;
-                                case "autocrop":
-                                    jimpImage.autocrop(filter.tolerance || 0);
-                                    break;
-                                case "crop":
-                                    jimpImage.crop(filter.x, filter.y, filter.w, filter.h);
-                                    break;
-                                case "fade":
-                                    jimpImage.fade(filter.factor);
-                                    break;
-                                case "opacity":
-                                    jimpImage.opacity(filter.factor);
-                                    break;
-                                case "opaque":
-                                    jimpImage.opaque();
-                                    break;
-                                case "gaussian":
-                                    jimpImage.gaussian(filter.radius);
-                                    break;
-                                case "blur":
-                                    jimpImage.blur(filter.radius);
-                                    break;
-                                case "posterize":
-                                    jimpImage.posterize(filter.levels);
-                                    break;
-                                case "sepia":
-                                    jimpImage.sepia();
-                                    break;
-                                case "pixelate":
-                                    jimpImage.pixelate(filter.size, filter.x, filter.y, filter.w, filter.h);
-                                    break;
-                                default:
-                                    console.error("Unsupported filter type: ".concat(filter.type));
-                            }
-                        }
-                        outputMimeType = jimpImage._originalMime || jimp_1.MIME_PNG;
-                        return [4 /*yield*/, jimpImage.getBufferAsync(outputMimeType)];
-                    case 6: return [2 /*return*/, _b.sent()];
-                    case 7:
-                        error_5 = _b.sent();
-                        console.error("Error processing image:", error_5.message);
-                        console.error(error_5.stack);
-                        throw new Error("Failed to process image");
-                    case 8: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ApexPainter.prototype.validateColor = function (filterColor) {
-        var hexColorRegex = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
-        var isHexColor = hexColorRegex.test(filterColor);
-        if (!isHexColor) {
-            throw new Error("Invalid color format. Only hex colors are supported.");
+
+        encoder.addFrame(ctx);
+      }
+
+      encoder.finish();
+      outputStream.end();
+
+      if (options.outputFormat === "file") {
+        if (!options.outputFile) {
+          throw new Error("Please provide a valid file path");
         }
-        return true;
-    };
-    ApexPainter.prototype.colorFilters = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var jimpImage, pngBuffer, imagePathResolved, resultBuffer, error_6;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 7, , 8]);
-                        this.validateColor(options.filterColor);
-                        jimpImage = void 0;
-                        if (!options.imagePath.startsWith("http")) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.imageConverter({
-                                imagePath: options.imagePath,
-                                newExtension: "png",
-                                baseDir: options.baseDir !== null ? options.baseDir : undefined,
-                            })];
-                    case 1:
-                        pngBuffer = _a.sent();
-                        return [4 /*yield*/, jimp_1.read(pngBuffer)];
-                    case 2:
-                        jimpImage = _a.sent();
-                        return [3 /*break*/, 5];
-                    case 3:
-                        if (!options.baseDir) {
-                            throw new Error("You need to provide __dirname in options.");
-                        }
-                        imagePathResolved = options.baseDir
-                            ? path_1.resolve(options.baseDir, options.imagePath)
-                            : options.imagePath;
-                        return [4 /*yield*/, jimp_1.read(imagePathResolved)];
-                    case 4:
-                        jimpImage = _a.sent();
-                        _a.label = 5;
-                    case 5:
-                        jimpImage.color([{ apply: "mix", params: [options.filterColor, 100] }]);
-                        return [4 /*yield*/, jimpImage.getBufferAsync(jimp_1.MIME_PNG)];
-                    case 6:
-                        resultBuffer = _a.sent();
-                        if (!Buffer.isBuffer(resultBuffer)) {
-                            throw new Error("Unexpected result. Failed to apply color filter.");
-                        }
-                        return [2 /*return*/, resultBuffer];
-                    case 7:
-                        error_6 = _a.sent();
-                        console.error("Error applying color filter:", error_6.message);
-                        console.error(error_6.stack);
-                        throw new Error("Failed to apply color filter");
-                    case 8: return [2 /*return*/];
-                }
-            });
+        await new Promise((resolve) => outputStream.on("finish", resolve));
+        console.log(`GIF created successfully at ${options.outputFile}`);
+      } else if (options.outputFormat === "base64") {
+        outputStream.on("finish", () => {
+          console.log("GIF created successfully");
         });
-    };
-    ApexPainter.prototype.bgRemoval = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var apiKey, formData, lowerCaseImageUrl, response, errorCode, error_7;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        apiKey = options.apiKey;
-                        formData = new form_data_1.default();
-                        if (!apiKey) {
-                            throw new Error("Error: No Api_Key was provided. We don't provide a default one.");
-                        }
-                        if (!options.imageUrl) {
-                            throw new Error("Error: Please provide a valid image source (image_url).");
-                        }
-                        if (options.imageUrl.startsWith("https://media.discordapp.net/attachments/")) {
-                            throw new Error("Error: Discord image URL isn't suppported at the moment.");
-                        }
-                        lowerCaseImageUrl = options.imageUrl.toLowerCase();
-                        if (!lowerCaseImageUrl.endsWith(".png") &&
-                            !lowerCaseImageUrl.endsWith(".jpg")) {
-                            throw new Error("Error: Unsupported image format. Please provide a valid URL ending with .png or .jpg.");
-                        }
-                        formData.append("size", options.size || "auto");
-                        formData.append("image_url", options.imageUrl);
-                        formData.append("type_level", options.type_level || "latest");
-                        formData.append("format", options.format || "auto");
-                        formData.append("roi", options.roi || "0% 0% 100% 100%");
-                        formData.append("crop", options.crop || false);
-                        formData.append("crop_margin", options.crop_margin || "0");
-                        formData.append("scale", options.scale || "original");
-                        formData.append("position", options.position || "original");
-                        formData.append("channels", options.channels || "rgba");
-                        formData.append("add_shadow", options.add_shadow || false);
-                        formData.append("semitransparency", options.semitransparency || true);
-                        formData.append("bg_color", options.bg_color || null);
-                        formData.append("bg_image_url", options.bg_image_url || null);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, axios_1.default({
-                                method: "post",
-                                url: "https://api.remove.bg/v1.0/removebg",
-                                data: formData,
-                                responseType: "arraybuffer",
-                                headers: __assign(__assign({}, formData.getHeaders()), { "X-Api-Key": apiKey }),
-                                encoding: null,
-                            })];
-                    case 2:
-                        response = _a.sent();
-                        if (response.status !== 200) {
-                            errorCode = response.status;
-                            switch (errorCode) {
-                                case 400:
-                                    console.error("Error 400: Invalid parameters or input file unprocessable (no credits charged)");
-                                    break;
-                                case 402:
-                                    console.error("Error 402: Insufficient credits (no credits charged)");
-                                    break;
-                                case 403:
-                                    console.error("Error 403: Authentication failed (no credits charged)");
-                                    break;
-                                case 429:
-                                    console.error("Error 429: Rate limit exceeded (no credits charged)");
-                                    break;
-                                default:
-                                    console.error("Error:", errorCode, response.statusText);
-                                    break;
-                            }
-                        }
-                        else {
-                            return [2 /*return*/, response.data];
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        error_7 = _a.sent();
-                        console.error("Request failed:", error_7.message);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
+
+        return outputStream.buffer.toString("base64");
+      } else if (options.outputFormat === "attachment") {
+        outputStream.on("finish", () => {
+          console.log("GIF created successfully");
         });
-    };
-    ApexPainter.prototype.createGIF = function (options) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function () {
-            function resizeImage(image, targetWidth, targetHeight) {
-                return __awaiter(this, void 0, void 0, function () {
-                    var canvas, ctx;
-                    return __generator(this, function (_a) {
-                        canvas = (0, canvas_1.createCanvas)(targetWidth, targetHeight);
-                        ctx = canvas.getContext("2d");
-                        ctx.drawImage(image, 0, 0, targetWidth, targetHeight);
-                        return [2 /*return*/, canvas];
-                    });
-                });
-            }
-            function createOutputStream(outputFile) {
-                return fs_1.createWriteStream(outputFile);
-            }
-            function createBufferStream() {
-                var buffer = [];
-                var bufferStream = new stream_1.Writable({
-                    write: function (chunk, encoding, next) {
-                        buffer.push(chunk);
-                        next();
-                    },
-                });
-                bufferStream.getBuffer = function () {
-                    return Buffer.concat(buffer);
-                };
-                return bufferStream;
-            }
-            function validateOptions(options) {
-                if (options.outputFormat === "file" && !options.outputFile) {
-                    throw new Error("Output file path is required when using file output format.");
-                }
-                if (options.repeat !== undefined &&
-                    (typeof options.repeat !== "number" || options.repeat < 0)) {
-                    throw new Error("Repeat must be a non-negative number or undefined.");
-                }
-                if (options.quality !== undefined &&
-                    (typeof options.quality !== "number" ||
-                        options.quality < 1 ||
-                        options.quality > 20)) {
-                    throw new Error("Quality must be a number between 1 and 20 or undefined.");
-                }
-                if (options.canvasSize) {
-                    if (options.canvasSize.width !== undefined &&
-                        (!Number.isInteger(options.canvasSize.width) ||
-                            options.canvasSize.width <= 0)) {
-                        throw new Error("Canvas width must be a positive integer or undefined.");
-                    }
-                    if (options.canvasSize.height !== undefined &&
-                        (!Number.isInteger(options.canvasSize.height) ||
-                            options.canvasSize.height <= 0)) {
-                        throw new Error("Canvas height must be a positive integer or undefined.");
-                    }
-                }
-                if (options.delay !== undefined &&
-                    (!Number.isInteger(options.delay) || options.delay <= 0)) {
-                    throw new Error("Delay must be a positive integer or undefined.");
-                }
-                if (options.watermark !== undefined &&
-                    typeof options.watermark !== "boolean") {
-                    throw new Error("Watermark must be a boolean or undefined.");
-                }
-                if (options.textOverlay !== undefined) {
-                    if (!options.textOverlay.text ||
-                        typeof options.textOverlay.text !== "string") {
-                        throw new Error("Text overlay text is required and must be a string.");
-                    }
-                    if (options.textOverlay.fontName !== undefined &&
-                        typeof options.textOverlay.fontName !== "string") {
-                        throw new Error("Text overlay fontName must be a string or undefined.");
-                    }
-                    if (options.textOverlay.fontPath !== undefined &&
-                        typeof options.textOverlay.fontPath !== "string") {
-                        throw new Error("Text overlay fontPath must be a string or undefined.");
-                    }
-                    if (options.textOverlay.fontSize !== undefined &&
-                        (!Number.isInteger(options.textOverlay.fontSize) ||
-                            options.textOverlay.fontSize <= 0)) {
-                        throw new Error("Text overlay fontSize must be a positive integer or undefined.");
-                    }
-                    if (options.textOverlay.fontColor !== undefined &&
-                        typeof options.textOverlay.fontColor !== "string") {
-                        throw new Error("Text overlay fontColor must be a string or undefined.");
-                    }
-                }
-            }
-            function validateImageObject(imageObject) {
-                return (imageObject &&
-                    typeof imageObject === "object" &&
-                    "source" in imageObject &&
-                    "isRemote" in imageObject);
-            }
-            function validateImages(images) {
-                if (!Array.isArray(images)) {
-                    throw new Error('The "images" parameter must be an array.');
-                }
-                if (images.length === 0) {
-                    throw new Error('The "images" array must contain at least one image object.');
-                }
-                for (var _i = 0, images_1 = images; _i < images_1.length; _i++) {
-                    var imageObject = images_1[_i];
-                    if (!validateImageObject(imageObject)) {
-                        throw new Error('Each image object must have "source" and "isRemote" properties.');
-                    }
-                }
-            }
-            var canvasWidth, canvasHeight, encoder, outputStream_1, canvas, ctx, _i, _c, imageInfo, image, _d, resizedImage, watermark, textOptions, fontPath, fontName, fontSize, fontColor, x, y, gifStream, e_1;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _e.trys.push([0, 14, , 15]);
-                        validateOptions(options);
-                        validateImages(options.images);
-                        canvasWidth = ((_a = options.canvasSize) === null || _a === void 0 ? void 0 : _a.width) || 1200;
-                        canvasHeight = ((_b = options.canvasSize) === null || _b === void 0 ? void 0 : _b.height) || 1200;
-                        encoder = new gifencoder_1.default(canvasWidth, canvasHeight);
-                        outputStream_1 = options.outputFile
-                            ? createOutputStream(options.outputFile)
-                            : createBufferStream();
-                        encoder.createReadStream().pipe(outputStream_1);
-                        encoder.start();
-                        encoder.setRepeat(options.repeat || 0);
-                        encoder.setQuality(options.quality || 10);
-                        encoder.setDelay(options.delay || 3000);
-                        canvas = (0, canvas_1.createCanvas)(canvasWidth, canvasHeight);
-                        ctx = canvas.getContext("2d");
-                        _i = 0, _c = options.images;
-                        _e.label = 1;
-                    case 1:
-                        if (!(_i < _c.length)) return [3 /*break*/, 10];
-                        imageInfo = _c[_i];
-                        if (!imageInfo.isRemote) return [3 /*break*/, 3];
-                        return [4 /*yield*/, (0, canvas_1.loadImage)(imageInfo.source)];
-                    case 2:
-                        _d = _e.sent();
-                        return [3 /*break*/, 5];
-                    case 3: return [4 /*yield*/, (0, canvas_1.loadImage)(imageInfo.source)];
-                    case 4:
-                        _d = _e.sent();
-                        _e.label = 5;
-                    case 5:
-                        image = _d;
-                        return [4 /*yield*/, resizeImage(image, canvasWidth, canvasHeight)];
-                    case 6:
-                        resizedImage = _e.sent();
-                        ctx.clearRect(0, 0, canvas.width, canvas.height);
-                        ctx.drawImage(resizedImage, 0, 0);
-                        if (!options.watermark) return [3 /*break*/, 8];
-                        return [4 /*yield*/, (0, canvas_1.loadImage)("")];
-                    case 7:
-                        watermark = _e.sent();
-                        ctx.drawImage(watermark, 10, canvasHeight - watermark.height - 10);
-                        _e.label = 8;
-                    case 8:
-                        if (options.textOverlay) {
-                            textOptions = options.textOverlay;
-                            fontPath = textOptions.fontPath;
-                            fontName = textOptions.fontName || "Arial";
-                            fontSize = textOptions.fontSize || 20;
-                            fontColor = textOptions.fontColor || "white";
-                            x = textOptions.x || 10;
-                            y = textOptions.y || 30;
-                            if (fontPath) {
-                                canvas_1.GlobalFonts.registerFromPath(path_1.join(options.basDir || "", fontPath), fontName);
-                            }
-                            ctx.font = "".concat(fontSize, "px ").concat(fontName);
-                            ctx.fillStyle = fontColor;
-                            ctx.fillText(textOptions.text, x, y);
-                        }
-                        encoder.addFrame(ctx);
-                        _e.label = 9;
-                    case 9:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 10:
-                        encoder.finish();
-                        outputStream_1.end();
-                        if (!(options.outputFormat === "file")) return [3 /*break*/, 12];
-                        if (!options.outputFile) {
-                            throw new Error("Please provide a valid file path");
-                        }
-                        return [4 /*yield*/, new Promise(function (resolve) { return outputStream_1.on("finish", resolve); })];
-                    case 11:
-                        _e.sent();
-                        console.log("GIF created successfully at ".concat(options.outputFile));
-                        return [3 /*break*/, 13];
-                    case 12:
-                        if (options.outputFormat === "base64") {
-                            outputStream_1.on("finish", function () {
-                                console.log("GIF created successfully");
-                            });
-                            return [2 /*return*/, outputStream_1.buffer.toString("base64")];
-                        }
-                        else if (options.outputFormat === "attachment") {
-                            outputStream_1.on("finish", function () {
-                                console.log("GIF created successfully");
-                            });
-                            gifStream = encoder.createReadStream();
-                            return [2 /*return*/, [{ attachment: gifStream, name: "gif.js" }]];
-                        }
-                        else if (options.outputFormat === "buffer") {
-                            outputStream_1.on("finish", function () {
-                                console.log("GIF created successfully");
-                            });
-                            return [2 /*return*/, outputStream_1.buffer];
-                        }
-                        else {
-                            throw new Error("Error: Please provide a valid format: 'buffer', 'base64', 'attachment',or 'output/file/path'.");
-                        }
-                        _e.label = 13;
-                    case 13: return [3 /*break*/, 15];
-                    case 14:
-                        e_1 = _e.sent();
-                        console.error(e_1);
-                        return [3 /*break*/, 15];
-                    case 15: return [2 /*return*/];
-                }
-            });
+
+        const gifStream = encoder.createReadStream();
+        return [{ attachment: gifStream, name: "gif.js" }];
+      } else if (options.outputFormat === "buffer") {
+        outputStream.on("finish", () => {
+          console.log("GIF created successfully");
         });
-    };
-    return ApexPainter;
-}());
 
-exports.ApexPainter = ApexPainter;
+        return outputStream.buffer;
+      } else {
+        throw new Error(
+          "Error: Please provide a valid format: 'buffer', 'base64', 'attachment',or 'output/file/path'.",
+        );
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+
+module.exports = { ApexPainter };