apexify.js 4.5.58 → 4.5.591

package/lib/ai/ApexModules.ts

@@ -2,7 +2,6 @@ import { Hercai } from 'hercai';
 import { validateModels } from "./functions/validOptions";
 import { whisper } from './modals-chat/groq/whisper';
 import { connect } from 'verse.db';
-import { otherChatModels } from './modals-chat/others/otherModels';
 import { chatGroq } from './modals-chat/groq/chatgroq';
 import { groqAnalyzer } from './utils';
 import { electronImagine } from './modals-chat/electronHub/imageModels';
@@ -52,7 +51,7 @@ async function ApexImagine(model: string, prompt: string, options?: ApexImagineO
   if ((width || height) <= 0) throw new Error("Inavlid usage. Image width/height can't be less than 0 or more than 1024.");
 
   for (let i = 0; i < count; i++) {
-     if (imageType.validHercaiModels.includes(model)) {
+     if (imageType.validHercImageModels.includes(model)) {
         if (model === 'prodia-v2') {
            imageURL = (await hercai.betaDrawImage({ 
               prompt: translatedText, 
@@ -643,6 +642,45 @@ async function ApexChat(model: string, prompt: string, { userId, memory, limit,
   }
 }
 
+async function resetHistory({ id, last }: { id: string; last: number | string }): Promise<boolean> {
+  if (!id) return false;
+
+  try {
+
+    const getUserData = (await db.findCollection(`${id}`, 'normal')).results;
+
+    if (!getUserData) return false;
+
+    const userRecord = (await db.find(`${id}`, { userId: id })).results;
+    if (!userRecord || !userRecord.history) return false;
+
+    const countHistory = userRecord.history.length;
+
+    let updateQuery: any = {};
+
+    if (typeof last === "string" && last.toLowerCase() === "all") {
+      updateQuery = { $set: { history: [] } };
+    } else if (typeof last === "number" && last > 0) {
+      const keep = Math.max(countHistory - last, 0);
+      if (keep === 0) {
+        updateQuery = { $set: { history: [] } };
+      } else {
+        updateQuery = { $slice: { history: keep } };
+      }
+    } else {
+      console.log("Invalid value for 'last'. Must be a positive number or 'all'.");
+      return false;
+    }
+
+    await db.update(`${id}`, { userId: id }, updateQuery);
+    return true
+  } catch (error) {
+    console.error("Error resetting history:", error);
+    return false
+  }
+}
+
+
 async function processChunk(
   model: string,
   prompt: string,
@@ -660,12 +698,7 @@ async function processChunk(
         })
       ).reply;
       break;
-
-    case validOptions.validotherChatModels.includes(model):
-      response = await otherChatModels({ modelName: model as any, prompt });
-      break;
-
-    case validOptions.validgroqChatModels.includes(model):
+    case validOptions.validGroqChatModels.includes(model):
       response = await chatGroq({
         API_KEY: ApiKey,
         apiName: model,
@@ -693,7 +726,7 @@ async function processChunk(
 
 async function ApexListener(options: { filepath: string, model: string, prompt?: string, lang?: string, apiKey?: string }) {
 
-  const { filepath, model = 'gemini', prompt = '', lang = 'en', apiKey = undefined } = options;
+  const { filepath, model = 'v3', prompt = '', lang = 'en', apiKey = undefined } = options;
 
   const validatedLang = validateLanguageInput(lang);
 
@@ -765,9 +798,9 @@ function validateLanguageInput(lang: string): string | null {
 async function  ApexText2Speech({ ApiKey, inputText, modelName, personality }: {
   ApiKey?: string;
   inputText: string;
-  modelName?: "elevenlabs" | "myshell-tts" | "deepinfra-tts";
+  modelName?: "elevenlabs" | "myshell-tts" | "deepinfra-tts" | "whisper-large-v3" | "distil-large-v3" | string;
   personality?: string;
-}): Promise<any> {
+}): Promise<Buffer> {
   return await electronSpeech({ ApiKey, inputText, modelName, personality })
 }
 
@@ -779,4 +812,4 @@ async function ApexVideo({ ApiKey, prompt, modelName }: {
   return await electronVideo({ ApiKey, prompt, modelName })
 }
 
-export { ApexImagine, ApexChat, ApexListener, ApexText2Speech, ApexVideo };
+export { ApexImagine, ApexChat, ApexListener, ApexText2Speech, ApexVideo, resetHistory };

package/lib/ai/buttons/tools.ts

@@ -34,6 +34,7 @@ async function filters(Apex: any) {
           const resizedBuffer = await apexPainter.resize({
             imagePath: imageURL,
             size: { width: parseInt(width, 10), height: parseInt(height, 10) },
+            quality: 90
           });
           await a.editReply({
             content: "Resized Image:",

package/lib/ai/functions/readFiles.ts

@@ -1,11 +1,9 @@
 import pdf from "pdf-parse";
 import * as fs from "fs";
 import * as https from "https";
-import { createWriteStream, createReadStream } from "fs";
+import { createWriteStream } from "fs";
 import { promisify } from "util";
-import { parse as parseCSV } from "csv-parse/sync";
-import Tesseract from 'tesseract.js';
-import path from 'path';
+import path from "path";
 
 const readFileAsync = promisify(fs.readFile);
 
@@ -14,17 +12,15 @@ export async function readFile(pathOrUrl: string, type?: string): Promise<string
     const ext = type || getFileExtension(pathOrUrl);
 
     switch (ext) {
-        case 'pdf':
+        case "pdf":
             return readPdf(buffer);
-        case 'csv':
-            return readCSV(buffer);
         default:
             return buffer.toString();
     }
 }
 
 function getFileExtension(pathOrUrl: string): string | undefined {
-    const parsedPath = new URL(pathOrUrl, 'file://');
+    const parsedPath = new URL(pathOrUrl, "file://");
     const pathname = parsedPath.pathname || pathOrUrl;
     const ext = path.extname(pathname).toLowerCase();
 
@@ -32,11 +28,7 @@ function getFileExtension(pathOrUrl: string): string | undefined {
 }
 
 async function loadFile(pathOrUrl: string): Promise<Buffer> {
-    if (isUrl(pathOrUrl)) {
-        return downloadFile(pathOrUrl);
-    } else {
-        return readFileAsync(pathOrUrl);
-    }
+    return isUrl(pathOrUrl) ? downloadFile(pathOrUrl) : readFileAsync(pathOrUrl);
 }
 
 function isUrl(pathOrUrl: string): boolean {
@@ -44,16 +36,16 @@ function isUrl(pathOrUrl: string): boolean {
 }
 
 async function downloadFile(url: string): Promise<Buffer> {
-    const tempFilePath = 'temp';
+    const tempFilePath = "temp";
     const file = createWriteStream(tempFilePath);
 
     await new Promise<void>((resolve, reject) => {
         https.get(url, (response) => {
             // @ts-ignore
             response.pipe(file);
-            file.on('finish', resolve);
-            file.on('error', reject);
-        }).on('error', reject);
+            file.on("finish", resolve);
+            file.on("error", reject);
+        }).on("error", reject);
     });
 
     const buffer = await readFileAsync(tempFilePath);
@@ -64,20 +56,11 @@ async function downloadFile(url: string): Promise<Buffer> {
 async function readPdf(buffer: Buffer): Promise<string> {
     try {
         const data = await pdf(buffer);
-        console.log('PDF Metadata:', data.metadata);
-        console.log('PDF Text:', data.text);
-        return data.text;
+        console.log("PDF Metadata:", data.metadata);
+        console.log("PDF Text:", data.text);
+        return data.text || "No readable text found in PDF.";
     } catch (err) {
-        console.error('PDF parse failed, attempting OCR...', err);
-        const { data: { text } } = await Tesseract.recognize(buffer, 'eng');
-        return text;
+        console.error("Error parsing PDF:", err);
+        return "Failed to extract text from PDF.";
     }
 }
-
-
-function readCSV(buffer: Buffer): string {
-    const csvData = buffer.toString();
-    const records = parseCSV(csvData, { columns: true });
-    return JSON.stringify(records, null, 2);
-}
-

package/lib/ai/functions/validOptions.ts

@@ -1,69 +1,116 @@
-import Groq from 'groq-sdk';
+import Groq from "groq-sdk";
 import OpenAI from "openai";
 
-export const hercChatModels = [
+// Define static models as readonly to prevent accidental modifications
+export const HERC_CHAT_MODELS = Object.freeze([
   "v3", "v3-32k", "turbo", "turbo-16k", "gemini",
-  "llama3-70b", "llama3-8b", "mixtral-8x7b", 
-  "gemma-7b", "gemma2-9b"
-];
-
-export const otherChatModel = ["apexai", "facebook_ai", "yi_34b", "starChat"];
-
-const initializeGroqInstance = () => {
-  return new Groq({ apiKey: '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' });
-};
-export async function electronHubModels(apiKey?: string): Promise<string[]> {
-  const key = apiKey || "ek-3gmOPmvuljmrl4NQrohpnp1ryNXQG5bNn08zNuzhX6bcxBrndR";
-  const openai = new OpenAI({
-    apiKey: key,
-    baseURL: "https://api.electronhub.top/v1",
-  });
-  
-  const models = await openai.models.list();
-  return models.data.map((model: any) => model.id);
+  "llama3-70b", "llama3-8b", "mixtral-8x7b",
+  "gemma-7b", "gemma2-9b",
+]);
+
+export const HERC_IMAGE_MODELS = Object.freeze([
+  "v3", "lexica", "prodia", "prodia-v2", "simurg",
+  "animefy", "raava", "shonin",
+]);
+
+// API Keys (ensure they are securely stored, do not hardcode in production)
+const GROQ_API_KEY = "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";
+const ELECTRON_HUB_API_KEY = "ek-3gmOPmvuljmrl4NQrohpnp1ryNXQG5bNn08zNuzhX6bcxBrndR";
+
+/**
+ * Initializes the Groq SDK instance.
+ */
+const initializeGroqInstance = (): Groq => new Groq({ apiKey: GROQ_API_KEY });
+
+/**
+ * Fetches available models from ElectronHub API.
+ */
+export async function getElectronHubModels(apiKey?: string): Promise<string[]> {
+  try {
+    const openai = new OpenAI({
+      apiKey: apiKey ?? ELECTRON_HUB_API_KEY,
+      baseURL: "https://api.electronhub.top/v1",
+    });
+
+    const models = await openai.models.list();
+
+    // Ensure models are valid and correctly formatted
+    if (!models?.data || !Array.isArray(models.data)) {
+      console.warn("Warning: Unexpected ElectronHub models response", models);
+      return [];
+    }
+
+    return models.data.map((model) => model.id).filter(Boolean); // Filter out any undefined/null values
+  } catch (error) {
+    console.error("Error fetching ElectronHub models:", error);
+    return [];
+  }
 }
 
-export const groqChatModels = async (groqInstance: any) => {
-  const allModels = await groqInstance.models.list();
+/**
+ * Fetches available chat models from Groq API.
+ */
+export async function getGroqChatModels(groqInstance: Groq): Promise<string[]> {
+  try {
+    const response = await groqInstance.models.list();
 
-  const filteredModels = allModels.data.filter((model: any) => 
-    !model.id.startsWith("whisper") &&
-    !model.id.startsWith("llava") &&
-    !model.id.startsWith("distil-whisper")
-  );
+    // Ensure response is valid
+    if (!response?.data || !Array.isArray(response.data)) {
+      console.warn("Warning: Unexpected Groq models response", response);
+      return [];
+    }
 
-  return filteredModels.map((model: any) => model.id);
-};
+    return response.data
+      .map((model) => model.id)
+      .filter(
+        (id) =>
+          id &&
+          !id.startsWith("whisper") &&
+          !id.startsWith("llava") &&
+          !id.startsWith("distil-whisper")
+      ); // Remove unwanted prefixes
+  } catch (error) {
+    console.error("Error fetching Groq models:", error);
+    return [];
+  }
+}
 
-async function initializeValidOptions() {
+/**
+ * Fetches and compiles all valid model options.
+ */
+async function initializeValidOptions(): Promise<{
+  validHercChatModels: readonly string[];
+  validGroqChatModels: string[];
+  validElectronModels: string[];
+  validHercImageModels: readonly string[];
+  allModels: string[];
+}> {
   const groq = initializeGroqInstance();
 
+  // Fetch models in parallel for better performance
   const [groqModels, electronModels] = await Promise.all([
-    groqChatModels(groq),
-    electronHubModels()
+    getGroqChatModels(groq),
+    getElectronHubModels(),
   ]);
 
-  const HercImageModels = [
-    "v3", "lexica", "prodia", "prodia-v2", "simurg", 
-    "animefy", "raava", "shonin"
-  ];
+  // Use Set to prevent duplicate entries in `allModels`
+  const allModelsSet = new Set([
+    ...HERC_IMAGE_MODELS,
+    ...HERC_CHAT_MODELS,
+    ...groqModels,
+    ...electronModels,
+  ]);
 
   return {
-    validHercChatModels: hercChatModels,
-    validgroqChatModels: groqModels,
+    validHercChatModels: HERC_CHAT_MODELS,
+    validGroqChatModels: groqModels,
     validElectronModels: electronModels,
-    validHercaiModels: HercImageModels,
-    validotherChatModels: otherChatModel,
-    validEnhancers: [
-      "ESRGAN_4x", "Lanczos", "Nearest", "LDSR", 
-      "R-ESRGAN 4x+", "R-ESRGAN 4x+ Anime6B", 
-      "ScuNET GAN", "ScuNET PSNR", "SwinIR 4x"
-    ],
-    allModels: [
-       ...HercImageModels,
-      ...hercChatModels, ...otherChatModel, ...groqModels, ...electronModels
-    ]
+    validHercImageModels: HERC_IMAGE_MODELS,
+    allModels: Array.from(allModelsSet), // Convert Set to array for uniqueness
   };
 }
 
+/**
+ * Returns all valid model lists asynchronously.
+ */
 export const validateModels = async () => await initializeValidOptions();

package/lib/ai/modals-chat/electronHub/speechModels.ts

@@ -9,9 +9,9 @@ export async function electronSpeech({
 }: {
   ApiKey?: string;
   inputText: string;
-  modelName?: 'elevenlabs' | 'myshell-tts' | 'deepinfra-tts';
+  modelName?: "elevenlabs" | "myshell-tts" | "deepinfra-tts" | "whisper-large-v3" | "distil-large-v3" | string;
   personality?: string;
-}) {
+}): Promise<Buffer> {
   try {
     const apiKey = ApiKey || "ek-3gmOPmvuljmrl4NQrohpnp1ryNXQG5bNn08zNuzhX6bcxBrndR";
     

package/lib/ai/modals-chat/groq/whisper.ts

@@ -3,12 +3,19 @@ import fs from 'fs';
 import path from 'path';
 import { URL } from 'url';
 import https from 'https';
+import { Uploadable } from 'groq-sdk/uploads.mjs';
 
+/**
+ * Gets the file size of a given path.
+ */
 function getFileSize(filePath: string): number {
   const stats = fs.statSync(filePath);
   return stats.size;
 }
 
+/**
+ * Creates a readable stream from a local file or a remote URL.
+ */
 async function createReadableStream(filepathOrUrl: string): Promise<NodeJS.ReadableStream | string> {
   const maxFileSizeBytes = 25 * 1024 * 1024;
 
@@ -19,17 +26,18 @@ async function createReadableStream(filepathOrUrl: string): Promise<NodeJS.Reada
 
     return new Promise((resolve, reject) => {
       const file = fs.createWriteStream(tempFilePath);
-
-      https.get(filepathOrUrl, (response) => {
+      const request = https.get(filepathOrUrl, (response) => {
         let fileSize = 0;
 
         response.on('data', (chunk) => {
           fileSize += chunk.length;
           if (fileSize > maxFileSizeBytes) {
+            request.destroy(); // Stop downloading
             file.close();
             fs.unlink(tempFilePath, () => {
               resolve('File size exceeds the limit (25MB)');
             });
+            return; // Ensure function stops here
           }
         });
 
@@ -42,37 +50,45 @@ async function createReadableStream(filepathOrUrl: string): Promise<NodeJS.Reada
             }
           });
         });
-      }).on('error', (err) => {
+      });
+
+      request.on('error', (err) => {
         fs.unlink(tempFilePath, () => {
           reject(err);
         });
       });
     });
   } else {
-    const fileSize = getFileSize(filepathOrUrl);
-    if (fileSize > maxFileSizeBytes) {
+    if (getFileSize(filepathOrUrl) > maxFileSizeBytes) {
       return 'File size exceeds the limit (25MB)';
     }
     return fs.createReadStream(filepathOrUrl);
   }
 }
 
+/**
+ * Transcribes audio using Groq Whisper API.
+ */
 export async function whisper(prompt: string, filepath: string, lang?: string, API_KEY?: string) {
   try {
     const groq = new Groq({
       apiKey: API_KEY || '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',
     });
 
-    const fileStream = await createReadableStream(path.join(process.cwd(), filepath));
+    // Ensure filepath is properly resolved
+    const resolvedFilePath = filepath.startsWith('http') || path.isAbsolute(filepath)
+      ? filepath
+      : path.join(process.cwd(), filepath);
+
+    const fileStream = await createReadableStream(resolvedFilePath);
 
     if (typeof fileStream === 'string') {
       return fileStream; 
     }
 
     const transcription = await groq.audio.transcriptions.create({
-      // @ts-ignore: Ignore type checking for this line
-      file: fileStream,
-      model: "whisper-large-v3",
+      file: fileStream as Uploadable,
+      model: "whisper-large-v3-turbo",
       prompt: prompt,
       temperature: 1,
       language: lang || 'eng',
@@ -81,19 +97,17 @@ export async function whisper(prompt: string, filepath: string, lang?: string, A
 
     return transcription.text;
   } catch (err: any) {
-    if (err instanceof Groq.APIError) {
-      if (err.status === 400) {
-        return 'Bad request, try again after a minute please.';
-      } else if (err.status === 429) {
-        return 'Rate limit, try again after one minute or provide your own api-key.';
-      } else if (err.status === 401 || !err.status) {
-        return 'Invalid Api-Key provided.';
-      } else {
-        console.error(err);
-        return "Unknown error occurred.";
+    if (err?.status) {
+      switch (err.status) {
+        case 400: return 'Bad request, try again after a minute please.';
+        case 429: return 'Rate limit exceeded, try again later or provide your own API key.';
+        case 401: return 'Invalid API key provided.';
+        default: 
+          console.error(err);
+          return "An unknown error occurred.";
       }
     }
     console.error(err);
-    return 'Unknown error occurred.';
+    return 'An unknown error occurred.';
   }
 }

package/lib/ai/utils.ts

@@ -1,18 +1,10 @@
-import { imageReader } from "./functions/imageReader";
-import { chunkString } from "./functions/chunkString";
-import { toDraw } from "./functions/shouldDrawImage";
-import { aiImagine } from "./functions/draw";
 import { readFile } from "./functions/readFiles";
-import { ApexChat, ApexImagine, ApexListener, ApexVideo, ApexText2Speech } from "./ApexModules";
+import { ApexChat, ApexImagine, ApexListener, ApexVideo, ApexText2Speech, resetHistory } from "./ApexModules";
 import { typeWriter } from "./functions/typeWriter" ;
 import { groqAnalyzer } from "./modals-chat/groq/imageAnalyzer";
 
 
 export {
-  chunkString,
-  imageReader,
-  toDraw,
-  aiImagine,
   readFile,
   ApexChat,
   ApexImagine,
@@ -20,5 +12,6 @@ export {
   typeWriter,
   groqAnalyzer,
   ApexVideo,
-  ApexText2Speech
+  ApexText2Speech,
+  resetHistory
 };

package/lib/canvas/utils/Image/imageProperties.ts

@@ -89,120 +89,34 @@ export function applyZoom(
     height: number
   ): void {
     if (!stroke) return;
-    
+  
     ctx.save();
+    ctx.beginPath();
+  
+    const gradient = createGradient(ctx, stroke.gradient, x, y, x + width, y + height);
+    ctx.strokeStyle = gradient;
     
-    ctx.strokeStyle = stroke.gradient
-      ? createGradient(ctx, stroke.gradient, x, y, x + width, y + height)
-      : stroke.color || "transparent";
-    
-    ctx.lineWidth = stroke.width ?? 0;
-    
+    ctx.lineWidth = stroke.width && stroke.width > 0 ? stroke.width : 2; 
+  
     const positionOffset = stroke.position ?? 0;
     const halfStroke = ctx.lineWidth / 2;
-    const totalOffset = positionOffset + halfStroke;
-
-    const adjustedX = Math.max(0, x - totalOffset);
-    const adjustedY = Math.max(0, y - totalOffset);
+    const totalOffset = positionOffset > 0 ? positionOffset + halfStroke : 0;
+  
+    const adjustedBorderRadius = stroke.borderRadius === "circular"
+      ? "circular"
+      : (stroke.borderRadius ?? 2) + halfStroke;
+  
+    const adjustedX = x - totalOffset;
+    const adjustedY = y - totalOffset;
     const adjustedWidth = width + totalOffset * 2;
     const adjustedHeight = height + totalOffset * 2;
-    
-    if (!stroke.borderPosition || stroke.borderPosition.trim().toLowerCase() === "all") {
-      objectRadius(
-        ctx,
-        adjustedX,
-        adjustedY,
-        adjustedWidth,
-        adjustedHeight,
-        stroke.borderRadius ?? 2,
-        "all"
-      );
-      ctx.stroke();
-      ctx.restore();
-      return;
-    }
-    
-    const bp = stroke.borderPosition.toLowerCase();
-    const positions = bp.split(',').map(s => s.trim());
-    
-    ctx.beginPath();
-    
-    if (
-      positions.includes("top") ||
-      positions.includes("top-left") ||
-      positions.includes("top-right")
-    ) {
-      const tl = positions.includes("top-left") || positions.includes("top")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      const tr = positions.includes("top-right") || positions.includes("top")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      ctx.moveTo(adjustedX + tl, adjustedY);
-      ctx.lineTo(adjustedX + adjustedWidth - tr, adjustedY);
-      if (tr > 0) {
-        ctx.quadraticCurveTo(adjustedX + adjustedWidth, adjustedY, adjustedX + adjustedWidth, adjustedY + tr);
-      }
-    }
-    
-    if (
-      positions.includes("right") ||
-      positions.includes("top-right") ||
-      positions.includes("bottom-right")
-    ) {
-      const tr = positions.includes("top-right") || positions.includes("right")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      const br = positions.includes("bottom-right") || positions.includes("right")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      ctx.moveTo(adjustedX + adjustedWidth, adjustedY + tr);
-      ctx.lineTo(adjustedX + adjustedWidth, adjustedY + adjustedHeight - br);
-      if (br > 0) {
-        ctx.quadraticCurveTo(adjustedX + adjustedWidth, adjustedY + adjustedHeight, adjustedX + adjustedWidth - br, adjustedY + adjustedHeight);
-      }
-    }
-    
-    if (
-      positions.includes("bottom") ||
-      positions.includes("bottom-left") ||
-      positions.includes("bottom-right")
-    ) {
-      const bl = positions.includes("bottom-left") || positions.includes("bottom")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      const br = positions.includes("bottom-right") || positions.includes("bottom")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      ctx.moveTo(adjustedX + bl, adjustedY + adjustedHeight);
-      ctx.lineTo(adjustedX + adjustedWidth - br, adjustedY + adjustedHeight);
-      if (br > 0) {
-        ctx.quadraticCurveTo(adjustedX + adjustedWidth, adjustedY + adjustedHeight, adjustedX + adjustedWidth, adjustedY + adjustedHeight - br);
-      }
-    }
-    
-    if (
-      positions.includes("left") ||
-      positions.includes("top-left") ||
-      positions.includes("bottom-left")
-    ) {
-      const tl = positions.includes("top-left") || positions.includes("left")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      const bl = positions.includes("bottom-left") || positions.includes("left")
-        ? (stroke.borderRadius ? +stroke.borderRadius : 0)
-        : 0;
-      ctx.moveTo(adjustedX, adjustedY + tl);
-      ctx.lineTo(adjustedX, adjustedY + adjustedHeight - bl);
-      if (bl > 0) {
-        ctx.quadraticCurveTo(adjustedX, adjustedY + adjustedHeight, adjustedX + bl, adjustedY + adjustedHeight);
-      }
-    }
+  
+    objectRadius(ctx, adjustedX, adjustedY, adjustedWidth, adjustedHeight, adjustedBorderRadius, "all");
     
     ctx.stroke();
     ctx.restore();
   }
-  
+      
 /**
  * Draws a shape on the canvas context based on the provided settings.
  * Supports built‑in shapes as well as a custom polygon.