apexify.js 1.2.1

package/lib/canvas/ApexPainter.js

@@ -0,0 +1,1194 @@
+"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;
+    };
+    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 };
+    }
+};
+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,
+        };
+    }
+    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.");
+        }
+        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.");
+        }
+        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;
+    };
+    ApexPainter.prototype.validateCanvasOptions = function (canvasOptions) {
+        if (!canvasOptions || typeof canvasOptions !== "object") {
+            throw new Error("Invalid canvas options. Provide a valid object for canvas configuration.");
+        }
+        if (typeof canvasOptions.width !== "number" ||
+            typeof canvasOptions.height !== "number") {
+            throw new Error("Canvas width and height must be numbers.");
+        }
+        if (canvasOptions.width <= 0 || canvasOptions.height <= 0) {
+            throw new Error("Canvas width and height must be positive values.");
+        }
+        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*/];
+                }
+            });
+        });
+    };
+    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;
+        }
+        else {
+            ctx.fillStyle = color || "transparent";
+        }
+        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));
+        }
+        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) {
+                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();
+        }
+        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;
+        }
+        // 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();
+    };
+    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];
+                }
+            }
+        }
+        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.");
+        }
+        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".');
+        }
+        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);
+        }
+        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);
+        }
+        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();
+    };
+    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();
+        }
+        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);
+        }
+    };
+    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.");
+        }
+        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*/];
+                }
+            });
+        });
+    };
+    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*/];
+                }
+            });
+        });
+    };
+    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*/];
+                }
+            });
+        });
+    };
+    return ApexPainter;
+}());
+
+exports.ApexPainter = ApexPainter;