medias-fakerator 1.0.0-dra.0 → 1.0.0-dra.2

package/index.js

@@ -15,8 +15,12 @@ const {
   generateGoogleLyrics,
   bratGenerator,
   bratVidGenerator,
+  bratHdGenerator,
+  bratVidHdGenerator,
   generateAnimatedBratVid,
+  generateAnimatedBratVidHd,
 } = require("./lib/generators.js");
+const generateCard = require("./lib/ktpGenerator.js");
 
 module.exports = {
   generateQuote,
@@ -34,6 +38,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/quote-generator.js

@@ -2,31 +2,12 @@ const fs = require("fs");
 const path = require("path");
 const runes = require("runes");
 const sharp = require("sharp");
+const EmojiDbLib = require("emoji-db");
 const { LRUCache } = require("lru-cache");
+const emojiDb = new EmojiDbLib({ useDefaultDb: true });
 const emojiImageByBrandPromise = require("emoji-cache");
 const ALLOWED_MEDIA_DIRECTORY = path.resolve(__dirname, "../");
 const { createCanvas, loadImage, registerFont } = require("canvas");
-const emoji = require("node-emoji");
-const emojiRegex =
-  /(\p{Extended_Pictographic}(?:\u200d\p{Extended_Pictographic})*)/gu;
-
-function searchEmojiFromText(text) {
-  const results = [];
-  let match;
-
-  while ((match = emojiRegex.exec(text)) !== null) {
-    const emojiChar = match[0];
-
-    results.push({
-      emoji: emojiChar, // emoji unicode
-      found: emojiChar, // key untuk emoji-cache
-      offset: match.index,
-      length: emojiChar.length,
-    });
-  }
-
-  return results;
-}
 
 async function loadFont() {
   const fontsDir = path.join(__dirname, "../assets/fonts");
@@ -357,8 +338,10 @@ class QuoteGenerate {
       for (let i = 0; i < charStyles.length; i++) charStyles[i].push(entities);
     }
     const styledWords = [];
-    const emojiData = searchEmojiFromText(text);
-
+    const emojiData = emojiDb.searchFromText({
+      input: text,
+      fixCodePoints: true,
+    });
     let currentIndex = 0;
     const processPlainText = (plainText, startOffset) => {
       if (!plainText) return;
@@ -557,8 +540,10 @@ class QuoteGenerate {
       }
     }
     const styledWords = [];
-    const emojiData = searchEmojiFromText(text);
-
+    const emojiData = emojiDb.searchFromText({
+      input: text,
+      fixCodePoints: true,
+    });
     let currentIndex = 0;
     const processPlainText = (plainText, startOffset) => {
       if (!plainText) return;

package/lib/utils.js

@@ -1,21 +1,13 @@
-const emojiRegex =
-  /(\p{Extended_Pictographic}(?:\u200d\p{Extended_Pictographic})*)/gu;
+const EmojiDbLib = require("emoji-db");
 
-function searchEmojiFromText(text) {
-  const results = [];
-  let match;
-
-  while ((match = emojiRegex.exec(text)) !== null) {
-    const emojiChar = match[0];
-    results.push({
-      found: emojiChar,
-      emoji: emojiChar,
-      offset: match.index,
-      length: emojiChar.length,
-    });
-  }
-
-  return results;
+let emojiDb;
+try {
+  emojiDb = new EmojiDbLib({ useDefaultDb: true });
+  if (!emojiDb || typeof emojiDb.searchFromText !== "function")
+    throw new Error("Gagal menginisialisasi database emoji");
+} catch (error) {
+  console.error("Error saat inisialisasi database emoji:", error);
+  throw error;
 }
 
 function parseTextToSegments(text, ctx, fontSize) {
@@ -29,8 +21,10 @@ function parseTextToSegments(text, ctx, fontSize) {
       if (line === "") {
       } else {
         const segmentsInLine = [];
-        const emojiMatches = searchEmojiFromText(line);
-
+        const emojiMatches = emojiDb.searchFromText({
+          input: line,
+          fixCodePoints: true,
+        });
         let lastIndex = 0;
         const processChunk = (chunk) => {
           if (!chunk) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "medias-fakerator",
-  "version": "1.0.0-dra.0",
+  "version": "1.0.0-dra.2",
   "description": "AIO Faker generator by Iruka Devs",
   "main": "index.js",
   "author": "Iruka Devs",
@@ -11,10 +11,10 @@
     "@ffmpeg-installer/ffmpeg": "1.1.0",
     "canvas": "^3.2.0",
     "emoji-cache": "^2.0.1",
+    "emoji-db": "^16.0.1",
     "fluent-ffmpeg": "^2.1.3",
     "fs-extra": "11.3.2",
     "lru-cache": "^11.1.0",
-    "node-emoji": "^2.2.0",
     "runes": "^0.4.3",
     "sharp": "^0.34.3"
   },