medias-fakerator 1.0.0-dra → 1.0.0-dra.1

package/index.js

@@ -17,6 +17,7 @@ const {
   bratVidGenerator,
   generateAnimatedBratVid,
 } = require("./lib/generators.js");
+const generateCard = require("./lib/ktpGenerator.js");
 
 module.exports = {
   generateQuote,
@@ -34,6 +35,10 @@ module.exports = {
   generateGoogleLyrics,
   bratGenerator,
   bratVidGenerator,
+  bratHdGenerator,
+  bratVidHdGenerator,
   generateAnimatedBratVid,
+  generateAnimatedBratVidHd,
+  generateCard,
   QuoteGenerator,
 };

package/lib/generators.js

@@ -2799,6 +2799,31 @@ function generateAnimatedBratVid(tempFrameDir, outputPath) {
     }
   });
 }
+function generateAnimatedBratVidHd(tempFrameDir, outputPath) {
+  return new Promise((resolve, reject) => {
+    try {
+      ffmpeg()
+        .input(path.join(tempFrameDir, "frame_%d.png"))
+        .inputOptions("-framerate", "1.5")
+        .videoCodec("libwebp")
+        .outputOptions(
+          "-loop",
+          "0",
+          "-lossless",
+          "1",
+          "-preset",
+          "picture",
+          "-an"
+        )
+        .output(outputPath)
+        .on("end", resolve)
+        .on("error", reject)
+        .run();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
 
 async function bratVidGenerator(
   text,
@@ -3199,6 +3224,403 @@ async function bratGenerator(teks, highlightWords = []) {
     throw error;
   }
 }
+async function bratVidHdGenerator(
+  text,
+  width,
+  height,
+  bgColor = "#FFFFFF",
+  textColor = "#000000",
+  highlightWords = []
+) {
+  try {
+    if (typeof text !== "string" || text.trim().length === 0)
+      throw new Error("Text must be a non-empty string");
+    if (!Array.isArray(highlightWords))
+      throw new TypeError("highlightWords must be an array.");
+    if (
+      !Number.isInteger(width) ||
+      !Number.isInteger(height) ||
+      width <= 0 ||
+      height <= 0
+    )
+      throw new Error("Width and height must be positive integers");
+    if (!/^#[0-9A-F]{6}$/i.test(bgColor) || !/^#[0-9A-F]{6}$/i.test(textColor))
+      throw new Error("Colors must be in hex format (#RRGGBB)");
+    const allEmojiImages = await emojiImageByBrandPromise;
+    const emojiCache = allEmojiImages["apple"] || {};
+    const padding = 20;
+    const availableWidth = width - padding * 2;
+    const tempCanvas = createCanvas(1, 1);
+    const tempCtx = tempCanvas.getContext("2d");
+    if (!tempCtx) throw new Error("Failed to create canvas context");
+    const tokens = text.match(/\S+|\n/g) || [];
+    if (tokens.length === 0)
+      throw new Error("No valid content tokens found in the text");
+    let frames = [];
+    const recalculateSegmentWidths = (segments, fontSize, ctx) => {
+      return segments.map((seg) => {
+        let newWidth = seg.width;
+        switch (seg.type) {
+          case "bold":
+            ctx.font = `bold ${fontSize}px Arial`;
+            newWidth = ctx.measureText(seg.content).width;
+            break;
+          case "italic":
+            ctx.font = `italic ${fontSize}px Arial`;
+            newWidth = ctx.measureText(seg.content).width;
+            break;
+          case "bolditalic":
+            ctx.font = `bold italic ${fontSize}px Arial`;
+            newWidth = ctx.measureText(seg.content).width;
+            break;
+          case "monospace":
+            ctx.font = `${fontSize}px 'Courier New', monospace`;
+            newWidth = ctx.measureText(seg.content).width;
+            break;
+          case "strikethrough":
+          case "text":
+            ctx.font = `${fontSize}px Arial`;
+            newWidth = ctx.measureText(seg.content).width;
+            break;
+          case "emoji":
+            newWidth = fontSize * 1.2;
+            break;
+        }
+        return { ...seg, width: newWidth };
+      });
+    };
+    const renderSegment = async (ctx, segment, x, y, fontSize, lineHeight) => {
+      ctx.fillStyle = highlightWords.includes(segment.content)
+        ? "red"
+        : textColor;
+      switch (segment.type) {
+        case "bold":
+          ctx.font = `bold ${fontSize}px Arial`;
+          break;
+        case "italic":
+          ctx.font = `italic ${fontSize}px Arial`;
+          break;
+        case "bolditalic":
+          ctx.font = `bold italic ${fontSize}px Arial`;
+          break;
+        case "monospace":
+          ctx.font = `${fontSize}px 'Courier New', monospace`;
+          break;
+        default:
+          ctx.font = `${fontSize}px Arial`;
+          break;
+      }
+      if (segment.type === "emoji") {
+        const emojiSize = fontSize * 1.2;
+        const emojiY = y + (lineHeight - emojiSize) / 2;
+        if (!emojiCache[segment.content])
+          throw new Error(`Emoji ${segment.content} tidak ditemukan`);
+        const emojiImg = await loadImage(
+          Buffer.from(emojiCache[segment.content], "base64")
+        );
+        ctx.drawImage(emojiImg, x, emojiY, emojiSize, emojiSize);
+      } else {
+        ctx.fillText(segment.content, x, y);
+        if (segment.type === "strikethrough") {
+          ctx.strokeStyle = ctx.fillStyle;
+          ctx.lineWidth = Math.max(1, fontSize / 15);
+          const lineY = y + lineHeight / 2.1;
+          ctx.beginPath();
+          ctx.moveTo(x, lineY);
+          ctx.lineTo(x + segment.width, lineY);
+          ctx.stroke();
+        }
+      }
+    };
+    for (let i = 1; i <= tokens.length; i++) {
+      const frameTokens = tokens.slice(0, i);
+      const currentText = frameTokens
+        .join(" ")
+        .replace(/ \n /g, "\n")
+        .replace(/\n /g, "\n")
+        .replace(/ \n/g, "\n");
+      if (currentText.trim() === "") continue;
+      let fontSize = 200;
+      let finalLines = [];
+      let lineHeight = 0;
+      const lineHeightMultiplier = 1.3;
+      while (fontSize > 10) {
+        let currentRenderLines = [];
+        const textLines = currentText.split("\n");
+        for (const singleLineText of textLines) {
+          if (singleLineText === "") {
+            currentRenderLines.push([]);
+            continue;
+          }
+          let segments = parseTextToSegments(singleLineText, tempCtx, fontSize);
+          let segmentsForSizing = recalculateSegmentWidths(
+            segments,
+            fontSize,
+            tempCtx
+          );
+          let wrappedLines = rebuildLinesFromSegments(
+            segmentsForSizing,
+            availableWidth,
+            tempCtx,
+            fontSize
+          );
+          currentRenderLines.push(...wrappedLines);
+        }
+        const currentLineHeight = fontSize * lineHeightMultiplier;
+        const totalTextHeight = currentRenderLines.length * currentLineHeight;
+        if (totalTextHeight <= height - padding * 2) {
+          finalLines = currentRenderLines;
+          lineHeight = currentLineHeight;
+          break;
+        }
+        fontSize -= 2;
+      }
+      const canvas = createCanvas(width, height);
+      const ctx = canvas.getContext("2d");
+      if (!ctx) throw new Error("Failed to create canvas context");
+      ctx.fillStyle = bgColor;
+      ctx.fillRect(0, 0, width, height);
+      ctx.textBaseline = "top";
+      const totalTextBlockHeight = finalLines.length * lineHeight;
+      const startY = (height - totalTextBlockHeight) / 2;
+      for (let j = 0; j < finalLines.length; j++) {
+        const line = finalLines[j];
+        const positionY = startY + j * lineHeight;
+        const contentSegments = line.filter((seg) => seg.type !== "whitespace");
+        if (contentSegments.length <= 1) {
+          let positionX = padding;
+          for (const segment of line) {
+            await renderSegment(
+              ctx,
+              segment,
+              positionX,
+              positionY,
+              fontSize,
+              lineHeight
+            );
+            positionX += segment.width;
+          }
+        } else {
+          const totalContentWidth = contentSegments.reduce(
+            (sum, seg) => sum + seg.width,
+            0
+          );
+          const spaceBetween =
+            (availableWidth - totalContentWidth) / (contentSegments.length - 1);
+          let positionX = padding;
+          for (let k = 0; k < contentSegments.length; k++) {
+            const segment = contentSegments[k];
+            await renderSegment(
+              ctx,
+              segment,
+              positionX,
+              positionY,
+              fontSize,
+              lineHeight
+            );
+            positionX += segment.width;
+            if (k < contentSegments.length - 1) {
+              positionX += spaceBetween;
+            }
+          }
+        }
+      }
+      const buffer = canvas.toBuffer("image/png");
+      frames.push(buffer);
+    }
+    return frames;
+  } catch (error) {
+    throw error;
+  }
+}
+async function bratHdGenerator(teks, highlightWords = []) {
+  try {
+    if (typeof teks !== "string" || teks.trim().length === 0)
+      throw new Error("Teks tidak boleh kosong.");
+    if (!Array.isArray(highlightWords))
+      throw new TypeError("highlightWords harus berupa array.");
+    const allEmojiImages = await emojiImageByBrandPromise;
+    const emojiCache = allEmojiImages["apple"] || {};
+    let width = 512,
+      height = 512,
+      margin = 8,
+      verticalPadding = 8;
+    const canvas = createCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (!ctx) throw new Error("Gagal membuat konteks kanvas.");
+    ctx.fillStyle = "white";
+    ctx.fillRect(0, 0, width, height);
+    ctx.textAlign = "left";
+    ctx.textBaseline = "top";
+    let fontSize = 200;
+    let lineHeightMultiplier = 1.3;
+    const availableWidth = width - 2 * margin;
+    let finalLines = [];
+    let finalFontSize = 0;
+    let lineHeight = 0;
+    const wordCount = (
+      teks.trim().match(/(\p{L}|\p{N}|\p{Emoji_Presentation})+/gu) || []
+    ).length;
+    let lastKnownGoodSolution = null;
+    while (fontSize > 10) {
+      let currentRenderLines = [];
+      const textLines = teks.split("\n");
+      for (const singleLineText of textLines) {
+        if (singleLineText === "") {
+          currentRenderLines.push([]);
+          continue;
+        }
+        let segments = parseTextToSegments(singleLineText, ctx, fontSize);
+        let wrappedLines = rebuildLinesFromSegments(
+          segments,
+          availableWidth,
+          ctx,
+          fontSize
+        );
+        currentRenderLines.push(...wrappedLines);
+      }
+      if (
+        currentRenderLines.length === 1 &&
+        currentRenderLines[0].filter((seg) => seg.type !== "whitespace")
+          .length === 2 &&
+        currentRenderLines[0].some((seg) => seg.type === "text") &&
+        currentRenderLines[0].some((seg) => seg.type === "emoji")
+      ) {
+        const textSeg = currentRenderLines[0].find(
+          (seg) => seg.type === "text"
+        );
+        const emojiSeg = currentRenderLines[0].find(
+          (seg) => seg.type === "emoji"
+        );
+        currentRenderLines = [[textSeg], [emojiSeg]];
+      }
+      const currentLineHeight = fontSize * lineHeightMultiplier;
+      const totalTextHeight = currentRenderLines.length * currentLineHeight;
+      if (totalTextHeight <= height - 2 * verticalPadding) {
+        lastKnownGoodSolution = {
+          lines: currentRenderLines,
+          fontSize: fontSize,
+          lineHeight: currentLineHeight,
+        };
+        if (wordCount === 4) {
+          if (currentRenderLines.length === 2) {
+            finalLines = currentRenderLines;
+            finalFontSize = fontSize;
+            lineHeight = currentLineHeight;
+            break;
+          }
+        } else {
+          finalLines = currentRenderLines;
+          finalFontSize = fontSize;
+          lineHeight = currentLineHeight;
+          break;
+        }
+      }
+      fontSize -= 2;
+    }
+    if (finalLines.length === 0 && lastKnownGoodSolution) {
+      finalLines = lastKnownGoodSolution.lines;
+      finalFontSize = lastKnownGoodSolution.fontSize;
+      lineHeight = lastKnownGoodSolution.lineHeight;
+    }
+    if (
+      finalLines.length === 1 &&
+      finalLines[0].length === 1 &&
+      finalLines[0][0].type === "text"
+    ) {
+      const theOnlyWord = finalLines[0][0].content;
+      const heightBasedSize =
+        (height - 2 * verticalPadding) / lineHeightMultiplier;
+      ctx.font = `200px Arial`;
+      const referenceWidth = ctx.measureText(theOnlyWord).width;
+      const widthBasedSize = (availableWidth / referenceWidth) * 200;
+      finalFontSize = Math.floor(Math.min(heightBasedSize, widthBasedSize));
+      lineHeight = finalFontSize * lineHeightMultiplier;
+    }
+    const totalFinalHeight = finalLines.length * lineHeight;
+    let y =
+      finalLines.length === 1
+        ? verticalPadding
+        : (height - totalFinalHeight) / 2;
+    const renderSegment = async (segment, x, y) => {
+      ctx.fillStyle = isHighlighted(highlightWords, segment.content)
+        ? "red"
+        : "black";
+      switch (segment.type) {
+        case "bold":
+          ctx.font = `bold ${finalFontSize}px Arial`;
+          break;
+        case "italic":
+          ctx.font = `italic ${finalFontSize}px Arial`;
+          break;
+        case "bolditalic":
+          ctx.font = `bold italic ${finalFontSize}px Arial`;
+          break;
+        case "monospace":
+          ctx.font = `${finalFontSize}px 'Courier New', monospace`;
+          break;
+        case "strikethrough":
+        case "text":
+        default:
+          ctx.font = `${finalFontSize}px Arial`;
+          break;
+      }
+      if (segment.type === "emoji") {
+        const emojiSize = finalFontSize * 1.2;
+        const emojiY = y + (lineHeight - emojiSize) / 2;
+        if (!emojiCache[segment.content])
+          throw new Error(`Emoji ${segment.content} tidak ditemukan di cache`);
+        const emojiImg = await loadImage(
+          Buffer.from(emojiCache[segment.content], "base64")
+        );
+        ctx.drawImage(emojiImg, x, emojiY, emojiSize, emojiSize);
+      } else {
+        ctx.fillText(segment.content, x, y);
+        if (segment.type === "strikethrough") {
+          ctx.strokeStyle = ctx.fillStyle;
+          ctx.lineWidth = Math.max(1, finalFontSize / 15);
+          const lineY = y + lineHeight / 2.1;
+          ctx.beginPath();
+          ctx.moveTo(x, lineY);
+          ctx.lineTo(x + segment.width, lineY);
+          ctx.stroke();
+        }
+      }
+    };
+    for (const line of finalLines) {
+      const contentSegments = line.filter((seg) => seg.type !== "whitespace");
+      if (contentSegments.length <= 1) {
+        let x = margin;
+        for (const segment of line) {
+          await renderSegment(segment, x, y);
+          x += segment.width;
+        }
+      } else {
+        const totalContentWidth = contentSegments.reduce(
+          (sum, seg) => sum + seg.width,
+          0
+        );
+        const spacePerGap =
+          (availableWidth - totalContentWidth) / (contentSegments.length - 1);
+        let currentX = margin;
+        for (let i = 0; i < contentSegments.length; i++) {
+          const segment = contentSegments[i];
+          await renderSegment(segment, currentX, y);
+          currentX += segment.width;
+          if (i < contentSegments.length - 1) {
+            currentX += spacePerGap;
+          }
+        }
+      }
+      y += lineHeight;
+    }
+    const buffer = canvas.toBuffer("image/png");
+    return buffer;
+  } catch (error) {
+    console.error("Terjadi error di bratGenerator:", error);
+    throw error;
+  }
+}
 
 module.exports = {
   generateQuote,
@@ -3216,5 +3638,8 @@ module.exports = {
   generateGoogleLyrics,
   bratGenerator,
   bratVidGenerator,
+  bratHdGenerator,
+  bratVidHdGenerator,
   generateAnimatedBratVid,
+  generateAnimatedBratVidHd,
 };

package/lib/ktpGenerator.js

@@ -0,0 +1,185 @@
+const fs = require("fs-extra");
+const path = require("path");
+const { createCanvas, loadImage, registerFont } = require("canvas");
+
+/* ================= FONT REGISTRATION ================= */
+try {
+  registerFont(path.join(process.cwd(), "assets/fonts/Ocr.ttf"), {
+    family: "Ocr",
+  });
+  registerFont(path.join(process.cwd(), "assets/fonts/Sign.ttf"), {
+    family: "Sign",
+  });
+  registerFont(path.join(process.cwd(), "assets/fonts/Frutiger.ttf"), {
+    family: "Frutiger",
+  });
+} catch (error) {
+  console.error("⚠️ Gagal mendaftarkan font:", error);
+}
+
+/* ================= FONT CONSTANT ================= */
+const FONT_OCR = "Ocr";
+const FONT_NORMAL = "Frutiger";
+
+/* ================= DEFAULT DATA ================= */
+const defaultUserData = {
+  NIK: "1234567890123456",
+  Nama: "YANTO OLI GARDAN",
+  "Tempat/Tgl Lahir": "Zimbabwe, 69-69-6969",
+  "Jenis Kelamin": "LAKI-LAKI",
+  "Gol. Darah": "O",
+  Alamat: "JL. Kemana Aja",
+  "RT/RW": "001/002",
+  "Kel/Desa": "JOLODONG",
+  Kecamatan: "KECIMITIN",
+  Agama: "KEPO",
+  "Status Perkawinan": "SERING KAWIN",
+  Pekerjaan: "PENGANGGURAN BANYAK ACARA",
+  Kewarganegaraan: "PMO",
+  "Berlaku Hingga": "SAMPE MENINGGOY",
+};
+
+const defaultHeaderFooterData = {
+  Provinsi: "PROVINSI",
+  Kabupaten: "KABUPATEN",
+  LokasiTTD: "KONTOLODON",
+  TanggalTTD: "12-34-5678",
+};
+
+/* ================= COORDINATES ================= */
+const coordinates = {
+  // ✅ HANYA NIK PAKAI OCR
+  NIK: { x: 195, y: 139, fontSize: 34, font: FONT_OCR },
+
+  // ❌ SELAIN NIK → FONT NORMAL
+  Nama: { x: 215, y: 174, fontSize: 19 },
+  "Tempat/Tgl Lahir": { x: 215, y: 200, fontSize: 19 },
+  "Jenis Kelamin": { x: 215, y: 224, fontSize: 19 },
+  "Gol. Darah": { x: 520, y: 224, fontSize: 19 },
+  Alamat: { x: 215, y: 249, fontSize: 19 },
+  "RT/RW": { x: 215, y: 274, fontSize: 19 },
+  "Kel/Desa": { x: 215, y: 298, fontSize: 19 },
+  Kecamatan: { x: 215, y: 322, fontSize: 19 },
+  Agama: { x: 215, y: 348, fontSize: 19 },
+  "Status Perkawinan": { x: 215, y: 372, fontSize: 19 },
+  Pekerjaan: { x: 215, y: 397, fontSize: 19 },
+  Kewarganegaraan: { x: 215, y: 422, fontSize: 19 },
+  "Berlaku Hingga": { x: 215, y: 446, fontSize: 19 },
+};
+
+const headerFooterCoordinates = {
+  Provinsi: { y: 55, fontSize: 34, align: "center" },
+  Kabupaten: { y: 90, fontSize: 30, align: "center" },
+  LokasiTTD: {
+    x: 690,
+    y: 410,
+    fontSize: 19,
+    align: "center",
+  },
+  TanggalTTD: {
+    x: 690,
+    y: 430,
+    fontSize: 16,
+    align: "center",
+  },
+};
+
+/* ================= MAIN FUNCTION ================= */
+async function generateCard(options = {}) {
+  const {
+    userData = {},
+    headerFooterData = {},
+    profilePicPath,
+    signatureText,
+  } = options;
+
+  const finalUserData = { ...defaultUserData, ...userData };
+  const finalHeaderFooterData = {
+    ...defaultHeaderFooterData,
+    ...headerFooterData,
+  };
+
+  /* ===== LOAD PROFILE PICTURE ===== */
+  let profilePic;
+  try {
+    if (Buffer.isBuffer(profilePicPath)) {
+      profilePic = await loadImage(profilePicPath);
+    } else if (
+      typeof profilePicPath === "string" &&
+      (await fs.pathExists(profilePicPath))
+    ) {
+      profilePic = await loadImage(profilePicPath);
+    } else {
+      console.error("⚠️ profilePicPath tidak valid");
+      return null;
+    }
+  } catch (err) {
+    console.error("⚠️ Gagal load foto profil:", err);
+    return null;
+  }
+
+  try {
+    const background = await loadImage(
+      path.join(process.cwd(), "assets/ktp/output.png")
+    );
+
+    const canvas = createCanvas(background.width, background.height);
+    const ctx = canvas.getContext("2d");
+
+    ctx.textBaseline = "alphabetic";
+    ctx.fillStyle = "black";
+
+    ctx.drawImage(background, 0, 0);
+    ctx.drawImage(profilePic, 584, 136, 201, 251);
+
+    /* ===== DRAW USER DATA ===== */
+    for (const [label, value] of Object.entries(finalUserData)) {
+      const style = coordinates[label];
+      if (!style) continue;
+
+      const fontFamily = style.font || FONT_NORMAL;
+
+      ctx.textAlign = "left";
+      ctx.font = `${style.fontWeight || "normal"} ${
+        style.fontSize || 18
+      }px ${fontFamily}`;
+
+      ctx.lineWidth = 0.6;
+      ctx.strokeText(String(value).toUpperCase(), style.x, style.y);
+      ctx.fillText(String(value).toUpperCase(), style.x, style.y);
+    }
+
+    /* ===== HEADER & FOOTER ===== */
+    for (const [label, value] of Object.entries(finalHeaderFooterData)) {
+      const style = headerFooterCoordinates[label];
+      if (!style) continue;
+
+      const xPos = style.x || background.width / 2;
+
+      ctx.textAlign = style.align || "left";
+      ctx.font = `${style.fontWeight || "normal"} ${
+        style.fontSize || 18
+      }px ${FONT_NORMAL}`;
+
+      ctx.lineWidth = 0.8;
+      ctx.strokeText(String(value).toUpperCase(), xPos, style.y);
+      ctx.fillText(String(value).toUpperCase(), xPos, style.y);
+    }
+
+    /* ===== SIGNATURE ===== */
+    const signText = signatureText || finalUserData.Nama.split(" ")[0];
+
+    ctx.textAlign = "center";
+    ctx.font = "23px Sign";
+    ctx.lineWidth = 1;
+    ctx.strokeText(signText.toUpperCase(), 660, 450);
+    ctx.fillText(signText.toUpperCase(), 660, 450);
+
+    return canvas.toBuffer("image/png");
+  } catch (error) {
+    console.error("❌ Terjadi kesalahan saat membuat kartu:", error);
+    return null;
+  }
+}
+
+module.exports = { generateCard };

package/lib/utils.js

@@ -1,66 +1,109 @@
-const EmojiDbLib = require('emoji-db');
+const EmojiDbLib = require("emoji-db");
 
 let emojiDb;
 try {
   emojiDb = new EmojiDbLib({ useDefaultDb: true });
-  if (!emojiDb || typeof emojiDb.searchFromText !== 'function') throw new Error('Gagal menginisialisasi database emoji');
+  if (!emojiDb || typeof emojiDb.searchFromText !== "function")
+    throw new Error("Gagal menginisialisasi database emoji");
 } catch (error) {
-  console.error('Error saat inisialisasi database emoji:', error);
+  console.error("Error saat inisialisasi database emoji:", error);
   throw error;
 }
 
 function parseTextToSegments(text, ctx, fontSize) {
   try {
-    if (typeof text !== 'string') text = String(text);
-    if (!ctx || typeof ctx.measureText !== 'function') throw new TypeError('Invalid canvas context');
+    if (typeof text !== "string") text = String(text);
+    if (!ctx || typeof ctx.measureText !== "function")
+      throw new TypeError("Invalid canvas context");
     const finalSegments = [];
-    const rawLines = text.split('\n');
+    const rawLines = text.split("\n");
     rawLines.forEach((line, index) => {
-      if (line === '') {
+      if (line === "") {
       } else {
         const segmentsInLine = [];
-        const emojiMatches = emojiDb.searchFromText({ input: line, fixCodePoints: true });
+        const emojiMatches = emojiDb.searchFromText({
+          input: line,
+          fixCodePoints: true,
+        });
         let lastIndex = 0;
         const processChunk = (chunk) => {
           if (!chunk) return;
-          const tokenizerRegex = /(\*_.*?_\*|_\*.*?\*_)|(\*.*?\*)|(_.*?_)|(~.*?~)|(```.*?```)|(\s+)|([^\s*~_`]+)/g;
+          const tokenizerRegex =
+            /(\*_.*?_\*|_\*.*?\*_)|(\*.*?\*)|(_.*?_)|(~.*?~)|(```.*?```)|(\s+)|([^\s*~_`]+)/g;
           let match;
           while ((match = tokenizerRegex.exec(chunk)) !== null) {
-            const [fullMatch, boldItalic, bold, italic, strikethrough, monospace, whitespace, textContent] = match;
+            const [
+              fullMatch,
+              boldItalic,
+              bold,
+              italic,
+              strikethrough,
+              monospace,
+              whitespace,
+              textContent,
+            ] = match;
             if (boldItalic) {
               const content = boldItalic.slice(2, -2);
               ctx.font = `italic bold ${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'bolditalic', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "bolditalic",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (bold) {
               const content = bold.slice(1, -1);
               ctx.font = `bold ${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'bold', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "bold",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (italic) {
               const content = italic.slice(1, -1);
               ctx.font = `italic ${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'italic', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "italic",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (strikethrough) {
               const content = strikethrough.slice(1, -1);
               ctx.font = `${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'strikethrough', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "strikethrough",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (monospace) {
               const content = monospace.slice(3, -3);
               ctx.font = `${fontSize}px 'Courier New', monospace`;
-              segmentsInLine.push({ type: 'monospace', content, width: ctx.measureText(content).width });
+              segmentsInLine.push({
+                type: "monospace",
+                content,
+                width: ctx.measureText(content).width,
+              });
             } else if (whitespace) {
               ctx.font = `${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'whitespace', content: whitespace, width: ctx.measureText(whitespace).width });
+              segmentsInLine.push({
+                type: "whitespace",
+                content: whitespace,
+                width: ctx.measureText(whitespace).width,
+              });
             } else if (textContent) {
               ctx.font = `${fontSize}px Arial`;
-              segmentsInLine.push({ type: 'text', content: textContent, width: ctx.measureText(textContent).width });
+              segmentsInLine.push({
+                type: "text",
+                content: textContent,
+                width: ctx.measureText(textContent).width,
+              });
             }
           }
         };
-        emojiMatches.forEach(emojiInfo => {
+        emojiMatches.forEach((emojiInfo) => {
           const plainText = line.substring(lastIndex, emojiInfo.offset);
           processChunk(plainText);
           segmentsInLine.push({
-            type: 'emoji',
+            type: "emoji",
             content: emojiInfo.found,
             width: fontSize * 1.2,
           });
@@ -72,13 +115,13 @@ function parseTextToSegments(text, ctx, fontSize) {
         finalSegments.push(...segmentsInLine);
       }
       if (index < rawLines.length - 1) {
-        finalSegments.push({ type: 'newline', content: '\n', width: 0 });
+        finalSegments.push({ type: "newline", content: "\n", width: 0 });
       }
     });
     ctx.font = `${fontSize}px Arial`;
     return finalSegments;
   } catch (error) {
-    console.error('Error in parseTextToSegments:', error);
+    console.error("Error in parseTextToSegments:", error);
     return [];
   }
 }
@@ -90,50 +133,70 @@ function rebuildLinesFromSegments(segments, maxWidth, ctx, fontSize) {
     let currentLineWidth = 0;
     const getFontString = (type, size) => {
       switch (type) {
-        case 'bold': return `bold ${size}px Arial`;
-        case 'italic': return `italic ${size}px Arial`;
-        case 'bolditalic': return `italic bold ${size}px Arial`;
-        case 'monospace': return `${size}px 'Courier New', monospace`;
-        default: return `${size}px Arial`;
+        case "bold":
+          return `bold ${size}px Arial`;
+        case "italic":
+          return `italic ${size}px Arial`;
+        case "bolditalic":
+          return `italic bold ${size}px Arial`;
+        case "monospace":
+          return `${size}px 'Courier New', monospace`;
+        default:
+          return `${size}px Arial`;
       }
     };
-    segments.forEach(segment => {
-      if (segment.type === 'newline') {
+    segments.forEach((segment) => {
+      if (segment.type === "newline") {
         lines.push(currentLine);
         currentLine = [];
         currentLineWidth = 0;
         return;
       }
-      if (segment.width > maxWidth && segment.type !== 'emoji') {
+      if (segment.width > maxWidth && segment.type !== "emoji") {
         if (currentLine.length > 0) {
           lines.push(currentLine);
           currentLine = [];
           currentLineWidth = 0;
         }
-        let tempStr = '';
+        let tempStr = "";
         const originalFont = getFontString(segment.type, fontSize);
         ctx.font = originalFont;
         for (const char of segment.content) {
           const measuredWidth = ctx.measureText(tempStr + char).width;
           if (measuredWidth > maxWidth) {
-            lines.push([{ type: segment.type, content: tempStr, width: ctx.measureText(tempStr).width }]);
+            lines.push([
+              {
+                type: segment.type,
+                content: tempStr,
+                width: ctx.measureText(tempStr).width,
+              },
+            ]);
             tempStr = char;
           } else {
             tempStr += char;
           }
         }
         if (tempStr) {
-          currentLine = [{ type: segment.type, content: tempStr, width: ctx.measureText(tempStr).width }];
+          currentLine = [
+            {
+              type: segment.type,
+              content: tempStr,
+              width: ctx.measureText(tempStr).width,
+            },
+          ];
           currentLineWidth = currentLine[0].width;
         }
         return;
       }
-      if (currentLineWidth + segment.width > maxWidth && currentLine.length > 0) {
+      if (
+        currentLineWidth + segment.width > maxWidth &&
+        currentLine.length > 0
+      ) {
         lines.push(currentLine);
         currentLine = [segment];
         currentLineWidth = segment.width;
       } else {
-        if (segment.type === 'whitespace' && currentLine.length === 0) return;
+        if (segment.type === "whitespace" && currentLine.length === 0) return;
         currentLine.push(segment);
         currentLineWidth += segment.width;
       }
@@ -143,24 +206,24 @@ function rebuildLinesFromSegments(segments, maxWidth, ctx, fontSize) {
     }
     return lines;
   } catch (error) {
-    console.error('Error in rebuildLinesFromSegments:', error);
+    console.error("Error in rebuildLinesFromSegments:", error);
     return [[]];
   }
 }
 
 function getContrastColor(hexColor) {
-  if (!hexColor || typeof hexColor !== 'string') return '#FFFFFF';
-  const hex = hexColor.replace('#', '');
-  if (hex.length !== 6) return '#FFFFFF';
+  if (!hexColor || typeof hexColor !== "string") return "#FFFFFF";
+  const hex = hexColor.replace("#", "");
+  if (hex.length !== 6) return "#FFFFFF";
   const r = parseInt(hex.substring(0, 2), 16);
   const g = parseInt(hex.substring(2, 4), 16);
   const b = parseInt(hex.substring(4, 6), 16);
-  const luminance = (0.299 * r + 0.587 * g + 0.114 * b);
-  return luminance > 140 ? '#000000' : '#FFFFFF';
-};
+  const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+  return luminance > 140 ? "#000000" : "#FFFFFF";
+}
 
 module.exports = {
   parseTextToSegments,
   rebuildLinesFromSegments,
-  getContrastColor
-};
+  getContrastColor,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "medias-fakerator",
-  "version": "1.0.0-dra",
+  "version": "1.0.0-dra.1",
   "description": "AIO Faker generator by Iruka Devs",
   "main": "index.js",
   "author": "Iruka Devs",
@@ -11,7 +11,7 @@
     "@ffmpeg-installer/ffmpeg": "1.1.0",
     "canvas": "^3.2.0",
     "emoji-cache": "^2.0.1",
-    "emoji-db": "github:Terror-Machine/emoji-db#master",
+    "emoji-db": "^16.0.1",
     "fluent-ffmpeg": "^2.1.3",
     "fs-extra": "11.3.2",
     "lru-cache": "^11.1.0",