feat(README.md): enhance README with detailed project info and quick start guide

- Updated project title, emoji, and color scheme
- Added project description, features, and configuration links
- Included quick start guide for Docker deployment

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2

.env

@@ -0,0 +1,3 @@
+PORT="7860"
+BOT_TOKEN="7409167350:AAEfeq81FFYg_XYm7RGUROWDKJiPzaivc00"
+EMOJI_DOMAIN="https://emojipedia.org/"

.env.example

@@ -0,0 +1,3 @@
+PORT="7860"
+BOT_TOKEN="" #your telegram bot token
+EMOJI_DOMAIN="https://emojipedia.org/"

.eslintrc.json

@@ -0,0 +1,17 @@
+{
+    "env": {
+        "es6": true,
+        "node": true
+    },
+    "extends": "standard",
+    "globals": {
+        "Atomics": "readonly",
+        "SharedArrayBuffer": "readonly"
+    },
+    "parserOptions": {
+        "ecmaVersion": 2018,
+        "sourceType": "module"
+    },
+    "rules": {
+    }
+}

.gitignore

@@ -0,0 +1,63 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript v1 declaration files
+typings/
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# next.js build output
+.next
+
+assets/fonts/*
+assets/emojis/*
+
+!.gitkeep

Dockerfile

@@ -0,0 +1,34 @@
+FROM node:20-alpine3.16
+
+WORKDIR /app
+ADD . /app
+
+# install dependency sistem
+RUN apk add --no-cache \
+    font-noto font-noto-cjk font-noto-extra gcompat libstdc++ libuuid \
+    vips-dev build-base jpeg-dev pango-dev cairo-dev imagemagick libssl1.1 \
+    curl
+
+# buat folder assets
+RUN mkdir -p assets
+
+# download file PNG
+RUN curl -o assets/pattern_02.png https://raw.githubusercontent.com/LyoSU/quote-api/master/assets/pattern_02.png \
+ && curl -o assets/pattern_ny.png https://raw.githubusercontent.com/LyoSU/quote-api/master/assets/pattern_ny.png \
+ && curl -o assets/pattern_ny_old.png https://raw.githubusercontent.com/LyoSU/quote-api/master/assets/pattern_ny_old.png
+
+# download emoji JSON (sesuai sebelumnya)
+RUN mkdir -p assets/emoji \
+ && curl -o assets/emoji/emoji-apple-image.json https://raw.githubusercontent.com/LyoSU/quote-api/master/assets/emoji/emoji-apple-image.json \
+ && curl -o assets/emoji/emoji-google-image.json https://raw.githubusercontent.com/LyoSU/quote-api/master/assets/emoji/emoji-google-image.json \
+ && curl -o assets/emoji/emoji-joypixels-image.json https://raw.githubusercontent.com/LyoSU/quote-api/master/assets/emoji/emoji-joypixels-image.json \
+ && curl -o assets/emoji/emoji-twitter-image.json https://raw.githubusercontent.com/LyoSU/quote-api/master/assets/emoji/emoji-twitter-image.json
+
+# buat symlink resolv
+RUN ln -s /lib/libresolv.so.2 /usr/lib/libresolv.so.2
+
+# install node modules
+RUN npm install
+
+EXPOSE 7860
+CMD ["node", "index.js"]

README.md

@@ -1,10 +1,55 @@
 ---
 title: Quotely
-emoji: 🌍
-colorFrom: red
-colorTo: blue
+emoji: 🌖
+colorFrom: purple
+colorTo: indigo
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<h1 align="center">🌖 Quotely</h1>
+<p align="center">
+  <b>Minimalist Quote Generator</b><br>
+  <a href="https://www.docker.com/"><img src="https://img.shields.io/badge/Docker-Ready-blue?logo=docker" alt="Docker"></a>
+  <a href="https://huggingface.co/docs/hub/spaces-config-reference"><img src="https://img.shields.io/badge/Hugging%20Face-Docs-purple?logo=huggingface" alt="Hugging Face Docs"></a>
+</p>
+
+---
+
+<p align="center">
+  <i>Generate beautiful, shareable quotes in seconds.<br>
+  Deploy anywhere with Docker.</i>
+</p>
+
+---
+
+## ✨ Features
+
+- 🎨 Customizable backgrounds & avatars  
+- 🖼️ High-quality `webp` image output  
+- 🚀 One-command Docker deployment  
+- ⚡ Fast, lightweight, and scalable  
+
+---
+
+## 🚀 Quick Start
+
+```bash
+# Clone the repo
+git clone https://huggingface.co/spaces/cv3inx/quotely
+cd quotely
+
+# Build & run with Docker
+docker build -t quotely .
+docker run -p 7860:7860 quotely
+```
+
+Open [http://localhost:7860](http://localhost:7860) in your browser.
+
+---
+
+## ⚙️ Configuration
+
+See [Hugging Face Spaces Config Reference](https://huggingface.co/docs/hub/spaces-config-reference) for advanced options.
+
+---

app.js

@@ -0,0 +1,80 @@
+const logger = require('koa-logger')
+const responseTime = require('koa-response-time')
+const bodyParser = require('koa-bodyparser')
+const Router = require('koa-router')
+const Koa = require('koa')
+const os = require('os')
+
+const app = new Koa()
+
+app.use(logger())
+app.use(responseTime())
+app.use(bodyParser())
+
+app.use(require('./helpers').helpersApi)
+
+const route = new Router()
+const routes = require('./routes')
+
+// helper untuk format memory
+function formatBytes(bytes) {
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
+  if (bytes === 0) return '0 B'
+  const i = Math.floor(Math.log(bytes) / Math.log(1024))
+  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${sizes[i]}`
+}
+function formatUptime(seconds) {
+  const days = Math.floor(seconds / (24 * 3600));
+  seconds %= 24 * 3600;
+  const hours = Math.floor(seconds / 3600);
+  seconds %= 3600;
+  const minutes = Math.floor(seconds / 60);
+  seconds = Math.floor(seconds % 60);
+
+  const parts = [];
+  if (days) parts.push(`${days} day${days > 1 ? 's' : ''}`);
+  if (hours) parts.push(`${hours} hour${hours > 1 ? 's' : ''}`);
+  if (minutes) parts.push(`${minutes} minute${minutes > 1 ? 's' : ''}`);
+  if (seconds || parts.length === 0) parts.push(`${seconds} second${seconds > 1 ? 's' : ''}`);
+
+  return parts.join(' ');
+}
+
+
+route.get(['/', '/ping'], async (ctx) => {
+  const totalMem = os.totalmem()
+  const freeMem = os.freemem()
+  const usedMem = totalMem - freeMem
+  const usagePercent = ((usedMem / totalMem) * 100).toFixed(2)
+
+  const info = {
+    hostname: os.hostname(),
+    platform: os.platform(),
+    arch: os.arch(),
+    uptime: formatUptime(os.uptime()),
+    cpu: {
+      model: os.cpus()[0].model,
+      cores: os.cpus().length
+    },
+    memory: {
+      total: formatBytes(totalMem),
+      used: formatBytes(usedMem),
+      free: formatBytes(freeMem),
+      usage: `${usagePercent}%`
+    }
+  }
+
+  ctx.type = 'application/json'
+  ctx.body = JSON.stringify(info, null, 2) // JSON formatted with 2 spaces
+})
+
+
+route.use('/*', routes.routeApi.routes())
+app.use(route.routes())
+
+const port = process.env.PORT || 7860
+app.listen(port, () => {
+  console.log('Listening on localhost, port', port)
+})
+
+

docker-compose.yml

@@ -0,0 +1,23 @@
+version: '3'
+
+services:
+    api:
+        build:
+            context: .
+        env_file: .env
+        restart: always
+        logging:
+            driver: "json-file"
+            options:
+                max-size: "10m"
+                max-file: "3"
+        networks:
+            - quotly
+        command: node index.js
+        ports:
+            - 127.0.0.1:4888:4888
+
+
+networks:
+    quotly:
+        external: true

ecosystem.config.js

@@ -0,0 +1,17 @@
+module.exports = {
+  apps: [{
+    name: 'quote-api',
+    script: './index.js',
+    max_memory_restart: '2500M',
+    instances: 3,
+    exec_mode: 'cluster',
+    watch: true,
+    ignore_watch: ['node_modules', 'assets'],
+    env: {
+      NODE_ENV: 'development'
+    },
+    env_production: {
+      NODE_ENV: 'production'
+    }
+  }]
+}

helpers/api.js

@@ -0,0 +1,47 @@
+module.exports = async (ctx, next) => {
+  ctx.props = Object.assign(ctx.query || {}, ctx.request.body || {})
+
+  try {
+    await next()
+
+    if (!ctx.body) {
+      ctx.assert(ctx.result, 404, 'Not Found')
+
+      if (ctx.result.error) {
+        ctx.status = 400
+        ctx.body = {
+          ok: false,
+          error: {
+            code: 400,
+            message: ctx.result.error
+          }
+        }
+      } else {
+        if (ctx.result.ext) {
+          if (ctx.result.ext === 'webp') ctx.response.set('content-type', 'image/webp')
+          if (ctx.result.ext === 'png') ctx.response.set('content-type', 'image/png')
+          ctx.response.set('quote-type', ctx.result.type)
+          ctx.response.set('quote-width', ctx.result.width)
+          ctx.response.set('quote-height', ctx.result.height)
+          ctx.body = ctx.result.image
+        } else {
+          ctx.body = {
+            ok: true,
+            result: ctx.result
+          }
+        }
+      }
+    }
+  } catch (error) {
+    console.error(error)
+    ctx.status = error.statusCode || error.status || 500
+    ctx.body = {
+      ok: false,
+      error: {
+        code: ctx.status,
+        message: error.message,
+        description: error.description
+      }
+    }
+  }
+}

helpers/index.js

@@ -0,0 +1,5 @@
+const helpersApi = require('./api')
+
+module.exports = {
+  helpersApi
+}

index.js

@@ -0,0 +1,2 @@
+require('dotenv').config({ path: './.env' })
+require('./app')

methods/generate.js

@@ -0,0 +1,359 @@
+const {
+  QuoteGenerate
+} = require('../utils')
+const { createCanvas, loadImage } = require('canvas')
+const sharp = require('sharp')
+
+const normalizeColor = (color) => {
+  const canvas = createCanvas(0, 0)
+  const canvasCtx = canvas.getContext('2d')
+
+  canvasCtx.fillStyle = color
+  color = canvasCtx.fillStyle
+
+  return color
+}
+
+const colorLuminance = (hex, lum) => {
+  hex = String(hex).replace(/[^0-9a-f]/gi, '')
+  if (hex.length < 6) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2]
+  }
+  lum = lum || 0
+
+  // convert to decimal and change luminosity
+  let rgb = '#'
+  let c
+  let i
+  for (i = 0; i < 3; i++) {
+    c = parseInt(hex.substr(i * 2, 2), 16)
+    c = Math.round(Math.min(Math.max(0, c + (c * lum)), 255)).toString(16)
+    rgb += ('00' + c).substr(c.length)
+  }
+
+  return rgb
+}
+
+const imageAlpha = (image, alpha) => {
+  const canvas = createCanvas(image.width, image.height)
+
+  const canvasCtx = canvas.getContext('2d')
+
+  canvasCtx.globalAlpha = alpha
+
+  canvasCtx.drawImage(image, 0, 0)
+
+  return canvas
+}
+
+module.exports = async (parm) => {
+  // console.log(JSON.stringify(parm, null, 2))
+  if (!parm) return { error: 'query_empty' }
+  if (!parm.messages || parm.messages.length < 1) return { error: 'messages_empty' }
+
+  let botToken = parm.botToken || process.env.BOT_TOKEN
+
+  const quoteGenerate = new QuoteGenerate(botToken)
+
+  const quoteImages = []
+
+  let backgroundColor = parm.backgroundColor || '//#292232'
+  let backgroundColorOne
+  let backgroundColorTwo
+
+  const backgroundColorSplit = backgroundColor.split('/')
+
+  if (backgroundColorSplit && backgroundColorSplit.length > 1 && backgroundColorSplit[0] !== '') {
+    backgroundColorOne = normalizeColor(backgroundColorSplit[0])
+    backgroundColorTwo = normalizeColor(backgroundColorSplit[1])
+  } else if (backgroundColor.startsWith('//')) {
+    backgroundColor = normalizeColor(backgroundColor.replace('//', ''))
+    backgroundColorOne = colorLuminance(backgroundColor, 0.35)
+    backgroundColorTwo = colorLuminance(backgroundColor, -0.15)
+  } else {
+    backgroundColor = normalizeColor(backgroundColor)
+    backgroundColorOne = backgroundColor
+    backgroundColorTwo = backgroundColor
+  }
+
+  for (const key in parm.messages) {
+    const message = parm.messages[key]
+
+    if (message) {
+      // Ensure message has the required structure to prevent errors
+      if (!message.from) {
+        message.from = { id: 0 }
+      }
+
+      // Ensure from object has photo property
+      if (!message.from.photo) {
+        message.from.photo = {}
+      }
+
+      // Make sure name exists in from object
+      if (!message.from.name && (message.from.first_name || message.from.last_name)) {
+        message.from.name = [message.from.first_name, message.from.last_name]
+          .filter(Boolean)
+          .join(' ')
+      }
+
+      // Ensure reply message has required structure to prevent errors
+      if (message.replyMessage) {
+        // Initialize chatId if missing - required for replyNameIndex calculation
+        if (!message.replyMessage.chatId) {
+          message.replyMessage.chatId = message.from?.id || 0
+        }
+
+        // Ensure entities array exists
+        if (!message.replyMessage.entities) {
+          message.replyMessage.entities = []
+        }
+
+        // Ensure the reply message has a from property if needed
+        if (!message.replyMessage.from) {
+          message.replyMessage.from = {
+            name: message.replyMessage.name,
+            photo: {}
+          }
+        } else if (!message.replyMessage.from.photo) {
+          message.replyMessage.from.photo = {}
+        }
+      }
+
+      try {
+        const canvasQuote = await quoteGenerate.generate(
+          backgroundColorOne,
+          backgroundColorTwo,
+          message,
+          parm.width,
+          parm.height,
+          parseFloat(parm.scale) || 2, // Default scale to 2 if not provided
+          parm.emojiBrand || 'apple'   // Default emoji brand to apple if not provided
+        )
+
+        if (canvasQuote) {
+          quoteImages.push(canvasQuote)
+        } else {
+          console.warn('Failed to generate quote for message, skipping')
+        }
+      } catch (error) {
+        console.error('Error generating quote for message:', error.message)
+        // Continue with next message instead of crashing
+      }
+    }
+  }
+
+  if (quoteImages.length === 0) {
+    return {
+      error: 'empty_messages'
+    }
+  }
+
+  let canvasQuote
+
+  if (quoteImages.length > 1) {
+    let width = 0
+    let height = 0
+
+    for (let index = 0; index < quoteImages.length; index++) {
+      if (quoteImages[index].width > width) width = quoteImages[index].width
+      height += quoteImages[index].height
+    }
+
+    const quoteMargin = 5 * parm.scale
+
+    const canvas = createCanvas(width, height + (quoteMargin * quoteImages.length))
+    const canvasCtx = canvas.getContext('2d')
+
+    let imageY = 0
+
+    for (let index = 0; index < quoteImages.length; index++) {
+      canvasCtx.drawImage(quoteImages[index], 0, imageY)
+      imageY += quoteImages[index].height + quoteMargin
+    }
+    canvasQuote = canvas
+  } else {
+    canvasQuote = quoteImages[0]
+  }
+
+  let quoteImage
+
+  let { type, format, ext } = parm
+
+  if (!type && ext) type = 'png'
+  if (type !== 'image' && type !== 'stories' && canvasQuote.height > 1024 * 2) type = 'png'
+
+  if (type === 'quote') {
+    const downPadding = 75
+    const maxWidth = 512
+    const maxHeight = 512
+
+    const imageQuoteSharp = sharp(canvasQuote.toBuffer())
+
+    if (canvasQuote.height > canvasQuote.width) imageQuoteSharp.resize({ height: maxHeight })
+    else imageQuoteSharp.resize({ width: maxWidth })
+
+    const canvasImage = await loadImage(await imageQuoteSharp.toBuffer())
+
+    const canvasPadding = createCanvas(canvasImage.width, canvasImage.height + downPadding)
+    const canvasPaddingCtx = canvasPadding.getContext('2d')
+
+    canvasPaddingCtx.drawImage(canvasImage, 0, 0)
+
+    const imageSharp = sharp(canvasPadding.toBuffer())
+
+    if (canvasPadding.height >= canvasPadding.width) imageSharp.resize({ height: maxHeight })
+    else imageSharp.resize({ width: maxWidth })
+
+    if (format === 'png') quoteImage = await imageSharp.png().toBuffer()
+    else quoteImage = await imageSharp.webp({ lossless: true, force: true }).toBuffer()
+  } else if (type === 'image') {
+    const heightPadding = 75 * parm.scale
+    const widthPadding = 95 * parm.scale
+
+    const canvasImage = await loadImage(canvasQuote.toBuffer())
+
+    const canvasPic = createCanvas(canvasImage.width + widthPadding, canvasImage.height + heightPadding)
+    const canvasPicCtx = canvasPic.getContext('2d')
+
+    // radial gradient background (top left)
+    const gradient = canvasPicCtx.createRadialGradient(
+      canvasPic.width / 2,
+      canvasPic.height / 2,
+      0,
+      canvasPic.width / 2,
+      canvasPic.height / 2,
+      canvasPic.width / 2
+    )
+
+    const patternColorOne = colorLuminance(backgroundColorTwo, 0.15)
+    const patternColorTwo = colorLuminance(backgroundColorOne, 0.15)
+
+    gradient.addColorStop(0, patternColorOne)
+    gradient.addColorStop(1, patternColorTwo)
+
+    canvasPicCtx.fillStyle = gradient
+    canvasPicCtx.fillRect(0, 0, canvasPic.width, canvasPic.height)
+
+    const canvasPatternImage = await loadImage('./assets/pattern_02.png')
+    // const canvasPatternImage = await loadImage('./assets/pattern_ny.png');
+
+    const pattern = canvasPicCtx.createPattern(imageAlpha(canvasPatternImage, 0.3), 'repeat')
+
+    canvasPicCtx.fillStyle = pattern
+    canvasPicCtx.fillRect(0, 0, canvasPic.width, canvasPic.height)
+
+    // Add shadow effect to the canvas image
+    canvasPicCtx.shadowOffsetX = 8
+    canvasPicCtx.shadowOffsetY = 8
+    canvasPicCtx.shadowBlur = 13
+    canvasPicCtx.shadowColor = 'rgba(0, 0, 0, 0.5)'
+
+    // Draw the image to the canvas with padding centered
+    canvasPicCtx.drawImage(canvasImage, widthPadding / 2, heightPadding / 2)
+
+    canvasPicCtx.shadowOffsetX = 0
+    canvasPicCtx.shadowOffsetY = 0
+    canvasPicCtx.shadowBlur = 0
+    canvasPicCtx.shadowColor = 'rgba(0, 0, 0, 0)'
+
+    // write text button right
+    canvasPicCtx.fillStyle = `rgba(0, 0, 0, 0.3)`
+    canvasPicCtx.font = `${8 * parm.scale}px Noto Sans`
+    canvasPicCtx.textAlign = 'right'
+    canvasPicCtx.fillText('@QuotLyBot', canvasPic.width - 25, canvasPic.height - 25)
+
+    quoteImage = await sharp(canvasPic.toBuffer()).png({ lossless: true, force: true }).toBuffer()
+  } else if (type === 'stories') {
+    const canvasPic = createCanvas(720, 1280)
+    const canvasPicCtx = canvasPic.getContext('2d')
+
+    // radial gradient background (top left)
+    const gradient = canvasPicCtx.createRadialGradient(
+      canvasPic.width / 2,
+      canvasPic.height / 2,
+      0,
+      canvasPic.width / 2,
+      canvasPic.height / 2,
+      canvasPic.width / 2
+    )
+
+    const patternColorOne = colorLuminance(backgroundColorTwo, 0.25)
+    const patternColorTwo = colorLuminance(backgroundColorOne, 0.15)
+
+    gradient.addColorStop(0, patternColorOne)
+    gradient.addColorStop(1, patternColorTwo)
+
+    canvasPicCtx.fillStyle = gradient
+    canvasPicCtx.fillRect(0, 0, canvasPic.width, canvasPic.height)
+
+    const canvasPatternImage = await loadImage('./assets/pattern_02.png')
+
+    const pattern = canvasPicCtx.createPattern(imageAlpha(canvasPatternImage, 0.3), 'repeat')
+
+    canvasPicCtx.fillStyle = pattern
+    canvasPicCtx.fillRect(0, 0, canvasPic.width, canvasPic.height)
+
+    // Add shadow effect to the canvas image
+    canvasPicCtx.shadowOffsetX = 8
+    canvasPicCtx.shadowOffsetY = 8
+    canvasPicCtx.shadowBlur = 13
+    canvasPicCtx.shadowColor = 'rgba(0, 0, 0, 0.5)'
+
+    let canvasImage = await loadImage(canvasQuote.toBuffer())
+
+    // мінімальний відступ від країв картинки
+    const minPadding = 110
+
+    // resize canvasImage if it is larger than canvasPic + minPadding
+    if (canvasImage.width > canvasPic.width - minPadding * 2 || canvasImage.height > canvasPic.height - minPadding * 2) {
+      canvasImage = await sharp(canvasQuote.toBuffer()).resize({
+        width: canvasPic.width - minPadding * 2,
+        height: canvasPic.height - minPadding * 2,
+        fit: 'contain',
+        background: { r: 0, g: 0, b: 0, alpha: 0 }
+      }).toBuffer()
+
+      canvasImage = await loadImage(canvasImage)
+    }
+
+    // розмістити canvasImage в центрі по горизонталі і вертикалі
+    const imageX = (canvasPic.width - canvasImage.width) / 2
+    const imageY = (canvasPic.height - canvasImage.height) / 2
+
+    canvasPicCtx.drawImage(canvasImage, imageX, imageY)
+
+    canvasPicCtx.shadowOffsetX = 0
+    canvasPicCtx.shadowOffsetY = 0
+    canvasPicCtx.shadowBlur = 0
+
+    // write text vertical left center text
+    canvasPicCtx.fillStyle = `rgba(0, 0, 0, 0.4)`
+    canvasPicCtx.font = `${16 * parm.scale}px Noto Sans`
+    canvasPicCtx.textAlign = 'center'
+    canvasPicCtx.translate(70, canvasPic.height / 2)
+    canvasPicCtx.rotate(-Math.PI / 2)
+    canvasPicCtx.fillText('@QuotLyBot', 0, 0)
+
+    quoteImage = await sharp(canvasPic.toBuffer()).png({ lossless: true, force: true }).toBuffer()
+  } else {
+    quoteImage = canvasQuote.toBuffer()
+  }
+
+  const imageMetadata = await sharp(quoteImage).metadata()
+
+  const width = imageMetadata.width
+  const height = imageMetadata.height
+
+  let image
+  if (ext) image = quoteImage
+  else image = quoteImage.toString('base64')
+
+  return {
+    image,
+    type,
+    width,
+    height,
+    ext
+  }
+}

methods/index.js

@@ -0,0 +1,38 @@
+const crypto = require('crypto')
+const LRU = require('lru-cache')
+const sizeof = require('object-sizeof')
+
+const generate = require('./generate')
+
+const methods = {
+  generate
+}
+
+const cache = new LRU({
+  max: 1000 * 1000 * 1000,
+  length: (n) => { return sizeof(n) },
+  maxAge: 1000 * 60 * 45
+})
+
+module.exports = async (method, parm) => {
+  if (methods[method]) {
+    let methodResult = {}
+
+    let cacheString = crypto.createHash('md5').update(JSON.stringify({ method, parm })).digest('hex')
+    const methodResultCache = cache.get(cacheString)
+
+    if (!methodResultCache) {
+      methodResult = await methods[method](parm)
+
+      if (!methodResult.error) cache.set(cacheString, methodResult)
+    } else {
+      methodResult = methodResultCache
+    }
+
+    return methodResult
+  } else {
+    return {
+      error: 'method not found'
+    }
+  }
+}

package.json

@@ -0,0 +1,48 @@
+{
+  "name": "quote-api",
+  "version": "0.14.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "lint": "node_modules/.bin/eslint --ext js .",
+    "lint:fix": "node_modules/.bin/eslint --fix --ext js ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LyoSU/quote-api.git"
+  },
+  "author": "LyoSU",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/LyoSU/quote-api/issues"
+  },
+  "homepage": "https://github.com/LyoSU/quote-api#readme",
+  "dependencies": {
+    "canvas": "^2.8.0",
+    "dotenv": "^7.0.0",
+    "emoji-db": "^15.1.2",
+    "jimp": "^1.6.0",
+    "jsdom": "^16.5.3",
+    "koa": "^2.11.0",
+    "koa-bodyparser": "^4.2.1",
+    "koa-logger": "^3.2.1",
+    "koa-ratelimit": "^4.2.1",
+    "koa-response-time": "^2.1.0",
+    "koa-router": "^7.4.0",
+    "lru-cache": "^5.1.1",
+    "object-sizeof": "^1.6.0",
+    "runes": "^0.4.3",
+    "sharp": "^0.32.5",
+    "smartcrop-sharp": "^2.0.7",
+    "telegraf": "^3.38.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.6.0",
+    "eslint-config-standard": "^12.0.0",
+    "eslint-plugin-import": "^2.17.3",
+    "eslint-plugin-node": "^9.1.0",
+    "eslint-plugin-promise": "^4.1.1",
+    "eslint-plugin-standard": "^4.0.0"
+  }
+}

routes/api.js

@@ -0,0 +1,14 @@
+const Router = require('koa-router')
+const api = new Router()
+
+const method = require('../methods')
+
+const apiHandle = async (ctx) => {
+  const methodWithExt = ctx.params[0].match(/(.*).(png|webp)/)
+  if (methodWithExt) ctx.props.ext = methodWithExt[2]
+  ctx.result = await method(methodWithExt ? methodWithExt[1] : ctx.params[0], ctx.props)
+}
+
+api.post('/', apiHandle)
+
+module.exports = api

routes/index.js

@@ -0,0 +1,5 @@
+const routeApi = require('./api')
+
+module.exports = {
+  routeApi
+}

utils/emoji-image.js

@@ -0,0 +1,106 @@
+const path = require('path')
+const fs = require('fs')
+const loadImageFromUrl = require('./image-load-url')
+const EmojiDbLib = require('emoji-db')
+const promiseAllStepN = require('./promise-concurrent')
+
+const emojiDb = new EmojiDbLib({ useDefaultDb: true })
+
+const emojiJFilesDir = '../assets/emoji/'
+
+const brandFoledIds = {
+  apple: 325,
+  google: 313,
+  twitter: 322,
+  joypixels: 340,
+  blob: 56
+}
+
+const emojiJsonByBrand = {
+  apple: 'emoji-apple-image.json',
+  google: 'emoji-google-image.json',
+  twitter: 'emoji-twitter-image.json',
+  joypixels: 'emoji-joypixels-image.json',
+  blob: 'emoji-blob-image.json'
+}
+
+let emojiImageByBrand = {
+  apple: [],
+  google: [],
+  twitter: [],
+  joypixels: [],
+  blob: []
+}
+
+async function downloadEmoji (brand) {
+  console.log('emoji image load start')
+
+  const emojiImage = emojiImageByBrand[brand]
+
+  const emojiJsonFile = path.resolve(
+    __dirname,
+    emojiJFilesDir + emojiJsonByBrand[brand]
+  )
+
+  const dbData = emojiDb.dbData
+  const dbArray = Object.keys(dbData)
+  const emojiPromiseArray = []
+
+  for (const key of dbArray) {
+    const emoji = dbData[key]
+
+    if (!emoji.qualified && !emojiImage[key]) {
+      emojiPromiseArray.push(async () => {
+        let brandFolderName = brand
+        if (brand === 'blob') brandFolderName = 'google'
+
+        const fileUrl = `${process.env.EMOJI_DOMAIN}/thumbs/60/${brandFolderName}/${brandFoledIds[brand]}/${emoji.image.file_name}`
+
+        const img = await loadImageFromUrl(fileUrl, (headers) => {
+          return !headers['content-type'].match(/image/)
+        })
+
+        const base64 = img.toString('base64')
+
+        if (base64) {
+          return {
+            key,
+            base64
+          }
+        }
+      })
+    }
+  }
+
+  const donwloadResult = await promiseAllStepN(200)(emojiPromiseArray)
+
+  for (const emojiData of donwloadResult) {
+    if (emojiData) emojiImage[emojiData.key] = emojiData.base64
+  }
+
+  if (Object.keys(emojiImage).length > 0) {
+    const emojiJson = JSON.stringify(emojiImage, null, 2)
+
+    fs.writeFile(emojiJsonFile, emojiJson, (err) => {
+      if (err) return console.log(err)
+    })
+  }
+
+  console.log('emoji image load end')
+}
+
+for (const brand in emojiJsonByBrand) {
+  const emojiJsonFile = path.resolve(
+    __dirname,
+    emojiJFilesDir + emojiJsonByBrand[brand]
+  )
+
+  try {
+    if (fs.existsSync(emojiJsonFile)) emojiImageByBrand[brand] = require(emojiJsonFile)
+  } catch (error) {
+    console.log(error)
+  }
+  // downloadEmoji(brand)
+}
+
+module.exports = emojiImageByBrand

utils/image-load-path.js

@@ -0,0 +1,9 @@
+const fs = require('fs')
+
+module.exports = (path) => {
+  return new Promise((resolve, reject) => {
+    fs.readFile(path, (_error, data) => {
+      resolve(data)
+    })
+  })
+}

utils/image-load-url.js

@@ -0,0 +1,28 @@
+const https = require('https')
+
+module.exports = (url, filter = false) => {
+  return new Promise((resolve, reject) => {
+    const options = new URL(url)
+    options.headers = {
+      'User-Agent': 'curl/8.4.0'
+    }
+
+    https.get(options, (res) => {
+      if (filter && filter(res.headers)) {
+        resolve(Buffer.concat([]))
+      }
+
+      const chunks = []
+
+      res.on('error', (err) => {
+        reject(err)
+      })
+      res.on('data', (chunk) => {
+        chunks.push(chunk)
+      })
+      res.on('end', () => {
+        resolve(Buffer.concat(chunks))
+      })
+    })
+  })
+}

utils/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  QuoteGenerate: require('./quote-generate'),
+  loadImageFromUrl: require('./image-load-url'),
+  loadImageFromPath: require('./image-load-path'),
+  promiseAllStepN: require('./promise-concurrent'),
+  userName: require('./user-name')
+}

utils/promise-concurrent.js

@@ -0,0 +1,29 @@
+function promiseAllStepN (n, list) {
+  let tail = list.splice(n)
+  let head = list
+  let resolved = []
+  let processed = 0
+  return new Promise(resolve => {
+    head.forEach(x => {
+      let res = x()
+      resolved.push(res)
+      res.then(y => {
+        runNext()
+        return y
+      })
+    })
+    function runNext () {
+      if (processed == tail.length) {
+        resolve(Promise.all(resolved))
+      } else {
+        resolved.push(tail[processed]().then(x => {
+          runNext()
+          return x
+        }))
+        processed++
+      }
+    }
+  })
+}
+
+module.exports = n => list => promiseAllStepN(n, list)

utils/quote-generate.js

@@ -0,0 +1,1308 @@
+const fs = require('fs')
+const { createCanvas, registerFont } = require('canvas')
+const EmojiDbLib = require('emoji-db')
+const { loadImage } = require('canvas')
+const loadImageFromUrl = require('./image-load-url')
+const sharp = require('sharp')
+const { Jimp, JimpMime } = require('jimp')
+const smartcrop = require('smartcrop-sharp')
+const runes = require('runes')
+const zlib = require('zlib')
+const { Telegram } = require('telegraf')
+
+const emojiDb = new EmojiDbLib({ useDefaultDb: true })
+
+function loadFont () {
+  console.log('font load start')
+  const fontsDir = 'assets/fonts/'
+
+  fs.readdir(fontsDir, (_err, files) => {
+    files.forEach((file) => {
+      try {
+        registerFont(`${fontsDir}${file}`, { family: file.replace(/\.[^/.]+$/, '') })
+      } catch (error) {
+        console.error(`${fontsDir}${file} not font file`)
+      }
+    })
+  })
+
+  console.log('font load end')
+}
+
+loadFont()
+
+const emojiImageByBrand = require('./emoji-image')
+
+const LRU = require('lru-cache')
+
+const avatarCache = new LRU({
+  max: 20,
+  maxAge: 1000 * 60 * 5
+})
+
+// write a nodejs function that accepts 2 colors. the first is the background color and the second is the text color. as a result, the first color should come out brighter or darker depending on the contrast. for example, if the first text is dark, then make the second brighter and return it. you need to change not the background color, but the text color
+
+// here are all the possible colors that will be passed as the second argument. the first color can be any
+class ColorContrast {
+  constructor () {
+    this.brightnessThreshold = 175 // A threshold to determine when a color is considered bright or dark
+  }
+
+  getBrightness (color) {
+    // Calculates the brightness of a color using the formula from the WCAG 2.0
+    // See: https://www.w3.org/TR/WCAG20-TECHS/G18.html#G18-tests
+    const [r, g, b] = this.hexToRgb(color)
+    return (r * 299 + g * 587 + b * 114) / 1000
+  }
+
+  hexToRgb (hex) {
+    // Converts a hex color string to an RGB array
+    const r = parseInt(hex.substring(1, 3), 16)
+    const g = parseInt(hex.substring(3, 5), 16)
+    const b = parseInt(hex.substring(5, 7), 16)
+    return [r, g, b]
+  }
+
+  rgbToHex ([r, g, b]) {
+    // Converts an RGB array to a hex color string
+    return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`
+  }
+
+  adjustBrightness (color, amount) {
+    // Adjusts the brightness of a color by a specified amount
+    const [r, g, b] = this.hexToRgb(color)
+    const newR = Math.max(0, Math.min(255, r + amount))
+    const newG = Math.max(0, Math.min(255, g + amount))
+    const newB = Math.max(0, Math.min(255, b + amount))
+    return this.rgbToHex([newR, newG, newB])
+  }
+
+  getContrastRatio (background, foreground) {
+    // Calculates the contrast ratio between two colors using the formula from the WCAG 2.0
+    // See: https://www.w3.org/TR/WCAG20-TECHS/G18.html#G18-tests
+    const brightness1 = this.getBrightness(background)
+    const brightness2 = this.getBrightness(foreground)
+    const lightest = Math.max(brightness1, brightness2)
+    const darkest = Math.min(brightness1, brightness2)
+    return (lightest + 0.05) / (darkest + 0.05)
+  }
+
+  adjustContrast (background, foreground) {
+    // Adjusts the brightness of the foreground color to meet the minimum contrast ratio
+    // with the background color
+    const contrastRatio = this.getContrastRatio(background, foreground)
+    const brightnessDiff = this.getBrightness(background) - this.getBrightness(foreground)
+    if (contrastRatio >= 4.5) {
+      return foreground // The contrast ratio is already sufficient
+    } else if (brightnessDiff >= 0) {
+      // The background is brighter than the foreground
+      const amount = Math.ceil((this.brightnessThreshold - this.getBrightness(foreground)) / 2)
+      return this.adjustBrightness(foreground, amount)
+    } else {
+      // The background is darker than the foreground
+      const amount = Math.ceil((this.getBrightness(foreground) - this.brightnessThreshold) / 2)
+      return this.adjustBrightness(foreground, -amount)
+    }
+  }
+}
+
+class QuoteGenerate {
+  constructor (botToken) {
+    this.telegram = new Telegram(botToken)
+  }
+
+  async avatarImageLatters (letters, color) {
+    const size = 500
+    const canvas = createCanvas(size, size)
+    const context = canvas.getContext('2d')
+
+    const gradient = context.createLinearGradient(0, 0, canvas.width, canvas.height)
+
+    gradient.addColorStop(0, color[0])
+    gradient.addColorStop(1, color[1])
+
+    context.fillStyle = gradient
+    context.fillRect(0, 0, canvas.width, canvas.height)
+
+    const drawLetters = await this.drawMultilineText(
+      letters,
+      null,
+      size / 2,
+      '#FFF',
+      0,
+      size,
+      size * 5,
+      size * 5
+    )
+
+    context.drawImage(drawLetters, (canvas.width - drawLetters.width) / 2, (canvas.height - drawLetters.height) / 1.5)
+
+    return canvas.toBuffer()
+  }
+
+  async downloadAvatarImage (user) {
+    let avatarImage
+
+    let nameLatters
+    if (user.first_name && user.last_name) nameLatters = runes(user.first_name)[0] + (runes(user.last_name || '')[0])
+    else {
+      let name = user.first_name || user.name || user.title
+      name = name.toUpperCase()
+      const nameWord = name.split(' ')
+
+      if (nameWord.length > 1) nameLatters = runes(nameWord[0])[0] + runes(nameWord.splice(-1)[0])[0]
+      else nameLatters = runes(nameWord[0])[0]
+    }
+
+    const cacheKey = user.id
+
+    const avatarImageCache = avatarCache.get(cacheKey)
+
+    const avatarColorArray = [
+      [ '#FF885E', '#FF516A' ], // red
+      [ '#FFCD6A', '#FFA85C' ], // orange
+      [ '#E0A2F3', '#D669ED' ], // purple
+      [ '#A0DE7E', '#54CB68' ], // green
+      [ '#53EDD6', '#28C9B7' ], // sea
+      [ '#72D5FD', '#2A9EF1' ], // blue
+      [ '#FFA8A8', '#FF719A' ] // pink
+    ]
+
+    const nameIndex = Math.abs(user.id) % 7
+
+    const avatarColor = avatarColorArray[nameIndex]
+
+    if (avatarImageCache) {
+      avatarImage = avatarImageCache
+    } else if (user.photo && user.photo.url) {
+      avatarImage = await loadImage(user.photo.url)
+    } else {
+      try {
+        let userPhoto, userPhotoUrl
+
+        if (user.photo && user.photo.big_file_id) userPhotoUrl = await this.telegram.getFileLink(user.photo.big_file_id).catch(() => {})
+
+        if (!userPhotoUrl) {
+          const getChat = await this.telegram.getChat(user.id).catch(() => {})
+
+          if (getChat && getChat.photo && getChat.photo.big_file_id) userPhoto = getChat.photo.big_file_id
+
+          if (userPhoto) userPhotoUrl = await this.telegram.getFileLink(userPhoto).catch(() => {})
+
+          else if (user.username) userPhotoUrl = `https://telega.one/i/userpic/320/${user.username}.jpg`
+
+          else avatarImage = await loadImage(await this.avatarImageLatters(nameLatters, avatarColor)).catch(() => {})
+        }
+
+        if (userPhotoUrl) {
+          const imageBuffer = await loadImageFromUrl(userPhotoUrl).catch((error) => {
+            console.warn('Failed to load user photo from URL:', error.message)
+            return null
+          })
+
+          if (imageBuffer) {
+            avatarImage = await loadImage(imageBuffer).catch((error) => {
+              console.warn('Failed to process user photo buffer:', error.message)
+              return null
+            })
+          }
+        }
+
+        if (avatarImage) {
+          avatarCache.set(cacheKey, avatarImage)
+        }
+      } catch (error) {
+        console.warn('Error getting user photo:', error.message)
+        avatarImage = null
+      }
+
+      // Fallback to letters avatar if no image was loaded
+      if (!avatarImage) {
+        try {
+          avatarImage = await loadImage(await this.avatarImageLatters(nameLatters, avatarColor))
+          avatarCache.set(cacheKey, avatarImage)
+        } catch (error) {
+          console.warn('Failed to create letters avatar:', error.message)
+          avatarImage = null
+        }
+      }
+    }
+
+    return avatarImage
+  }
+
+  ungzip (input, options) {
+    return new Promise((resolve, reject) => {
+      zlib.gunzip(input, options, (error, result) => {
+        if (!error) resolve(result)
+        else reject(Error(error))
+      })
+    })
+  }
+
+  async downloadMediaImage (media, mediaSize, type = 'id', crop = true) {
+    try {
+      let mediaUrl
+      if (type === 'id') mediaUrl = await this.telegram.getFileLink(media).catch(console.error)
+      else mediaUrl = media
+
+      if (!mediaUrl) {
+        console.warn('Failed to get media URL, skipping media')
+        return null
+      }
+
+      const load = await loadImageFromUrl(mediaUrl).catch((error) => {
+        console.warn('Failed to load image from URL:', error.message)
+        return null
+      })
+
+      if (!load) {
+        console.warn('Failed to load media, skipping')
+        return null
+      }
+
+      if (crop || (mediaUrl && mediaUrl.match(/.webp/))) {
+        try {
+          const imageSharp = sharp(load)
+          const imageMetadata = await imageSharp.metadata()
+          const sharpPng = await imageSharp.png({ lossless: true, force: true }).toBuffer()
+
+          if (!imageMetadata || !imageMetadata.width || !imageMetadata.height || !sharpPng) {
+            // Fallback to original image without processing
+            try {
+              return await loadImage(load)
+            } catch (fallbackError) {
+              console.warn('Failed to load original image as fallback:', fallbackError.message)
+              return null
+            }
+          }
+
+          let croppedImage
+
+          if (imageMetadata.format === 'webp') {
+            try {
+              const jimpImage = await Jimp.read(sharpPng)
+              croppedImage = await jimpImage.autocrop().getBuffer(JimpMime.png)
+            } catch (jimpError) {
+              console.warn('Failed to process webp with Jimp, using original:', jimpError.message)
+              croppedImage = sharpPng
+            }
+          } else {
+            try {
+              const smartcropResult = await smartcrop.crop(sharpPng, { width: mediaSize, height: imageMetadata.height })
+              const crop = smartcropResult.topCrop
+
+              croppedImage = await imageSharp.extract({ width: crop.width, height: crop.height, left: crop.x, top: crop.y }).png({ lossless: true, force: true }).toBuffer()
+            } catch (cropError) {
+              console.warn('Failed to crop image, using original:', cropError.message)
+              croppedImage = sharpPng
+            }
+          }
+
+          try {
+            return await loadImage(croppedImage)
+          } catch (loadError) {
+            console.warn('Failed to load processed image, trying original:', loadError.message)
+            try {
+              return await loadImage(load)
+            } catch (originalError) {
+              console.warn('Failed to load original image as final fallback:', originalError.message)
+              return null
+            }
+          }
+        } catch (sharpError) {
+          console.warn('Failed to process image with Sharp, trying original:', sharpError.message)
+          try {
+            return await loadImage(load)
+          } catch (originalError) {
+            console.warn('Failed to load original image:', originalError.message)
+            return null
+          }
+        }
+      } else {
+        try {
+          return await loadImage(load)
+        } catch (loadError) {
+          console.warn('Failed to load image:', loadError.message)
+          return null
+        }
+      }
+    } catch (error) {
+      console.error('Critical error in downloadMediaImage:', error.message)
+      return null
+    }
+  }
+
+  hexToRgb (hex) {
+    return hex.replace(/^#?([a-f\d])([a-f\d])([a-f\d])$/i
+      , (m, r, g, b) => '#' + r + r + g + g + b + b)
+      .substring(1).match(/.{2}/g)
+      .map(x => parseInt(x, 16))
+  }
+
+  // https://codepen.io/andreaswik/pen/YjJqpK
+  lightOrDark (color) {
+    let r, g, b
+
+    // Check the format of the color, HEX or RGB?
+    if (color.match(/^rgb/)) {
+      // If HEX --> store the red, green, blue values in separate variables
+      color = color.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(?:\.\d+)?))?\)$/)
+
+      r = color[1]
+      g = color[2]
+      b = color[3]
+    } else {
+      // If RGB --> Convert it to HEX: http://gist.github.com/983661
+      color = +('0x' + color.slice(1).replace(
+        color.length < 5 && /./g, '$&$&'
+      )
+      )
+
+      r = color >> 16
+      g = color >> 8 & 255
+      b = color & 255
+    }
+
+    // HSP (Highly Sensitive Poo) equation from http://alienryderflex.com/hsp.html
+    const hsp = Math.sqrt(
+      0.299 * (r * r) +
+      0.587 * (g * g) +
+      0.114 * (b * b)
+    )
+
+    // Using the HSP value, determine whether the color is light or dark
+    if (hsp > 127.5) {
+      return 'light'
+    } else {
+      return 'dark'
+    }
+  }
+
+  async drawMultilineText (text, entities, fontSize, fontColor, textX, textY, maxWidth, maxHeight, emojiBrand = 'apple') {
+    if (maxWidth > 10000) maxWidth = 10000
+    if (maxHeight > 10000) maxHeight = 10000
+
+    const emojiImageJson = emojiImageByBrand[emojiBrand]
+
+    let fallbackEmojiBrand = 'apple'
+    if (emojiBrand === 'blob') fallbackEmojiBrand = 'google'
+
+    const fallbackEmojiImageJson = emojiImageByBrand[fallbackEmojiBrand]
+
+    // Pre-calculate text dimensions to avoid creating oversized canvas
+    const canvas = createCanvas(maxWidth + fontSize, maxHeight + fontSize)
+    const canvasCtx = canvas.getContext('2d')
+
+    // text = text.slice(0, 4096)
+    text = text.replace(/і/g, 'i') // замена украинской буквы і на английскую, так как она отсутствует в шрифтах Noto
+    const chars = text.split('')
+
+    const lineHeight = 4 * (fontSize * 0.3)
+
+    const styledChar = []
+
+    const emojis = emojiDb.searchFromText({ input: text, fixCodePoints: true })
+
+    // Pre-load all emojis for better performance
+    const emojiCache = new Map()
+    const emojiLoadPromises = []
+
+    for (let emojiIndex = 0; emojiIndex < emojis.length; emojiIndex++) {
+      const emoji = emojis[emojiIndex]
+      if (!emojiCache.has(emoji.found)) {
+        emojiLoadPromises.push(
+          (async () => {
+            const emojiImageBase = emojiImageJson[emoji.found]
+            if (emojiImageBase) {
+              try {
+                const image = await loadImage(Buffer.from(emojiImageBase, 'base64'))
+                emojiCache.set(emoji.found, image)
+              } catch (error) {
+                try {
+                  const fallbackImage = await loadImage(Buffer.from(fallbackEmojiImageJson[emoji.found], 'base64'))
+                  emojiCache.set(emoji.found, fallbackImage)
+                } catch (fallbackError) {
+                  // Skip if both fail
+                }
+              }
+            } else {
+              try {
+                const fallbackImage = await loadImage(Buffer.from(fallbackEmojiImageJson[emoji.found], 'base64'))
+                emojiCache.set(emoji.found, fallbackImage)
+              } catch (error) {
+                // Skip if fails
+              }
+            }
+          })()
+        )
+      }
+    }
+
+    // Wait for all emojis to load
+    await Promise.all(emojiLoadPromises)
+
+    for (let charIndex = 0; charIndex < chars.length; charIndex++) {
+      const char = chars[charIndex]
+
+      styledChar[charIndex] = {
+        char,
+        style: []
+      }
+
+      if (entities && typeof entities === 'string') styledChar[charIndex].style.push(entities)
+    }
+
+    if (entities && typeof entities === 'object') {
+      for (let entityIndex = 0; entityIndex < entities.length; entityIndex++) {
+        const entity = entities[entityIndex]
+        const style = []
+
+        if (['pre', 'code', 'pre_code'].includes(entity.type)) {
+          style.push('monospace')
+        } else if (
+          ['mention', 'text_mention', 'hashtag', 'email', 'phone_number', 'bot_command', 'url', 'text_link']
+            .includes(entity.type)
+        ) {
+          style.push('mention')
+        } else {
+          style.push(entity.type)
+        }
+
+        if (entity.type === 'custom_emoji') {
+          styledChar[entity.offset].customEmojiId = entity.custom_emoji_id
+        }
+
+        for (let charIndex = entity.offset; charIndex < entity.offset + entity.length; charIndex++) {
+          styledChar[charIndex].style = styledChar[charIndex].style.concat(style)
+        }
+      }
+    }
+
+    for (let emojiIndex = 0; emojiIndex < emojis.length; emojiIndex++) {
+      const emoji = emojis[emojiIndex]
+
+      for (let charIndex = emoji.offset; charIndex < emoji.offset + emoji.length; charIndex++) {
+        styledChar[charIndex].emoji = {
+          index: emojiIndex,
+          code: emoji.found
+        }
+      }
+    }
+
+    const styledWords = []
+
+    let stringNum = 0
+
+    const breakMatch = /<br>|\n|\r/
+    const spaceMatch = /[\f\n\r\t\v\u0020\u1680\u2000-\u200a\u2028\u2029\u205f\u3000]/
+    const CJKMatch = /[\u1100-\u11ff\u2e80-\u2eff\u3000-\u303f\u3040-\u309f\u30a0-\u30ff\u3100-\u312f\u3130-\u318f\u3190-\u319f\u31a0-\u31bf\u31c0-\u31ef\u31f0-\u31ff\u3200-\u32ff\u3300-\u33ff\u3400-\u4dbf\u4e00-\u9fff\uac00-\ud7af\uf900-\ufaff]/
+
+    for (let index = 0; index < styledChar.length; index++) {
+      const charStyle = styledChar[index]
+      const lastChar = styledChar[index - 1]
+
+      if (
+        lastChar && (
+          (
+            (charStyle.emoji && !lastChar.emoji) ||
+              (!charStyle.emoji && lastChar.emoji) ||
+              (charStyle.emoji && lastChar.emoji && charStyle.emoji.index !== lastChar.emoji.index)
+          ) ||
+            (
+              (charStyle.char.match(breakMatch)) ||
+              (charStyle.char.match(spaceMatch) && !lastChar.char.match(spaceMatch)) ||
+              (lastChar.char.match(spaceMatch) && !charStyle.char.match(spaceMatch)) ||
+              (charStyle.style && lastChar.style && charStyle.style.toString() !== lastChar.style.toString())
+            ) || (
+            charStyle.char.match(CJKMatch) ||
+                lastChar.char.match(CJKMatch)
+          )
+        )
+      ) {
+        stringNum++
+      }
+
+      if (!styledWords[stringNum]) {
+        styledWords[stringNum] = {
+          word: charStyle.char
+        }
+
+        if (charStyle.style) styledWords[stringNum].style = charStyle.style
+        if (charStyle.emoji) styledWords[stringNum].emoji = charStyle.emoji
+        if (charStyle.customEmojiId) styledWords[stringNum].customEmojiId = charStyle.customEmojiId
+      } else styledWords[stringNum].word += charStyle.char
+    }
+
+    let lineX = textX
+    let lineY = textY
+
+    let textWidth = 0
+
+    // load custom emoji
+    const customEmojiIds = []
+
+    for (let index = 0; index < styledWords.length; index++) {
+      const word = styledWords[index]
+
+      if (word.customEmojiId) {
+        customEmojiIds.push(word.customEmojiId)
+      }
+    }
+
+    const getCustomEmojiStickers = await this.telegram.callApi('getCustomEmojiStickers', {
+      custom_emoji_ids: customEmojiIds
+    }).catch(() => {})
+
+    const customEmojiStickers = {}
+
+    const loadCustomEmojiStickerPromises = []
+
+    if (getCustomEmojiStickers) {
+      for (let index = 0; index < getCustomEmojiStickers.length; index++) {
+        const sticker = getCustomEmojiStickers[index]
+
+        loadCustomEmojiStickerPromises.push((async () => {
+          const getFileLink = await this.telegram.getFileLink(sticker.thumb.file_id).catch(() => {})
+
+          if (getFileLink) {
+            const load = await loadImageFromUrl(getFileLink).catch(() => {})
+            const imageSharp = sharp(load)
+            const sharpPng = await imageSharp.png({ lossless: true, force: true }).toBuffer()
+
+            customEmojiStickers[sticker.custom_emoji_id] = await loadImage(sharpPng).catch(() => {})
+          }
+        })())
+      }
+
+      await Promise.all(loadCustomEmojiStickerPromises).catch(() => {})
+    }
+
+    let breakWrite = false
+    let lineDirection = this.getLineDirection(styledWords, 0)
+
+    // Pre-set font to avoid repeated font changes
+    let currentFont = null
+    let currentFillStyle = null
+
+    for (let index = 0; index < styledWords.length; index++) {
+      const styledWord = styledWords[index]
+
+      let emojiImage
+
+      if (styledWord.emoji) {
+        if (styledWord.customEmojiId && customEmojiStickers[styledWord.customEmojiId]) {
+          emojiImage = customEmojiStickers[styledWord.customEmojiId]
+        } else {
+          // Use pre-loaded emoji from cache
+          emojiImage = emojiCache.get(styledWord.emoji.code)
+        }
+      }
+
+      let fontType = ''
+      let fontName = 'NotoSans'
+      let fillStyle = fontColor
+
+      if (styledWord.style.includes('bold')) {
+        fontType += 'bold '
+      }
+      if (styledWord.style.includes('italic')) {
+        fontType += 'italic '
+      }
+      if (styledWord.style.includes('monospace')) {
+        fontName = 'NotoSansMono'
+        fillStyle = '#5887a7'
+      }
+      if (styledWord.style.includes('mention')) {
+        fillStyle = '#6ab7ec'
+      }
+      if (styledWord.style.includes('spoiler')) {
+        const rbaColor = this.hexToRgb(this.normalizeColor(fontColor))
+        fillStyle = `rgba(${rbaColor[0]}, ${rbaColor[1]}, ${rbaColor[2]}, 0.15)`
+      }
+
+      const newFont = `${fontType} ${fontSize}px ${fontName}`
+
+      // Only change font if different from current
+      if (currentFont !== newFont) {
+        canvasCtx.font = newFont
+        currentFont = newFont
+      }
+
+      // Only change fill style if different from current
+      if (currentFillStyle !== fillStyle) {
+        canvasCtx.fillStyle = fillStyle
+        currentFillStyle = fillStyle
+      }
+
+      // Pre-truncate long words before measurement
+      let wordToMeasure = styledWord.word
+      const maxWordWidth = maxWidth - fontSize * 3
+
+      if (wordToMeasure.length > 50) { // Quick length check before expensive measurement
+        while (canvasCtx.measureText(wordToMeasure).width > maxWordWidth && wordToMeasure.length > 0) {
+          wordToMeasure = wordToMeasure.substr(0, wordToMeasure.length - 1)
+        }
+        if (wordToMeasure.length < styledWord.word.length) {
+          styledWord.word = wordToMeasure + '…'
+        }
+      } else if (canvasCtx.measureText(wordToMeasure).width > maxWordWidth) {
+        while (canvasCtx.measureText(wordToMeasure).width > maxWordWidth && wordToMeasure.length > 0) {
+          wordToMeasure = wordToMeasure.substr(0, wordToMeasure.length - 1)
+        }
+        styledWord.word = wordToMeasure + '…'
+      }
+
+      let lineWidth
+      const wordlWidth = canvasCtx.measureText(styledWord.word).width
+
+      if (styledWord.emoji) lineWidth = lineX + fontSize
+      else lineWidth = lineX + wordlWidth
+
+      if (styledWord.word.match(breakMatch) || (lineWidth > maxWidth - fontSize * 2 && wordlWidth < maxWidth)) {
+        if (styledWord.word.match(spaceMatch) && !styledWord.word.match(breakMatch)) styledWord.word = ''
+        if ((styledWord.word.match(spaceMatch) || !styledWord.word.match(breakMatch)) && lineY + lineHeight > maxHeight) {
+          while (lineWidth > maxWidth - fontSize * 2) {
+            styledWord.word = styledWord.word.substr(0, styledWord.word.length - 1)
+            lineWidth = lineX + canvasCtx.measureText(styledWord.word).width
+            if (styledWord.word.length <= 0) break
+          }
+
+          styledWord.word += '…'
+          lineWidth = lineX + canvasCtx.measureText(styledWord.word).width
+          breakWrite = true
+        } else {
+          if (styledWord.emoji) lineWidth = textX + fontSize + (fontSize * 0.2)
+          else lineWidth = textX + canvasCtx.measureText(styledWord.word).width
+
+          lineX = textX
+          lineY += lineHeight
+          if (index < styledWords.length - 1) {
+            let nextLineDirection = this.getLineDirection(styledWords, index + 1)
+            if (lineDirection !== nextLineDirection) textWidth = maxWidth - fontSize * 2
+            lineDirection = nextLineDirection
+          }
+        }
+      }
+
+      if (styledWord.emoji) lineWidth += (fontSize * 0.2)
+
+      if (lineWidth > textWidth) textWidth = lineWidth
+      if (textWidth > maxWidth) textWidth = maxWidth
+
+      let wordX = (lineDirection === 'rtl') ? maxWidth - lineX - wordlWidth - fontSize * 2 : lineX
+
+      if (emojiImage) {
+        canvasCtx.drawImage(emojiImage, wordX, lineY - fontSize + (fontSize * 0.15), fontSize + (fontSize * 0.22), fontSize + (fontSize * 0.22))
+      } else {
+        canvasCtx.fillText(styledWord.word, wordX, lineY)
+
+        if (styledWord.style.includes('strikethrough')) canvasCtx.fillRect(wordX, lineY - fontSize / 2.8, canvasCtx.measureText(styledWord.word).width, fontSize * 0.1)
+        if (styledWord.style.includes('underline')) canvasCtx.fillRect(wordX, lineY + 2, canvasCtx.measureText(styledWord.word).width, fontSize * 0.1)
+      }
+
+      lineX = lineWidth
+
+      if (breakWrite) break
+    }
+
+    const canvasResize = createCanvas(textWidth, lineY + fontSize)
+    const canvasResizeCtx = canvasResize.getContext('2d')
+
+    let dx = (lineDirection === 'rtl') ? textWidth - maxWidth + fontSize * 2 : 0
+    canvasResizeCtx.drawImage(canvas, dx, 0)
+
+    return canvasResize
+  }
+
+  // https://stackoverflow.com/a/3368118
+  drawRoundRect (color, w, h, r) {
+    const x = 0
+    const y = 0
+
+    const canvas = createCanvas(w, h)
+    const canvasCtx = canvas.getContext('2d')
+
+    canvasCtx.fillStyle = color
+
+    if (w < 2 * r) r = w / 2
+    if (h < 2 * r) r = h / 2
+    canvasCtx.beginPath()
+    canvasCtx.moveTo(x + r, y)
+    canvasCtx.arcTo(x + w, y, x + w, y + h, r)
+    canvasCtx.arcTo(x + w, y + h, x, y + h, r)
+    canvasCtx.arcTo(x, y + h, x, y, r)
+    canvasCtx.arcTo(x, y, x + w, y, r)
+    canvasCtx.closePath()
+
+    canvasCtx.fill()
+
+    return canvas
+  }
+
+  drawGradientRoundRect (colorOne, colorTwo, w, h, r) {
+    const x = 0
+    const y = 0
+
+    const canvas = createCanvas(w, h)
+    const canvasCtx = canvas.getContext('2d')
+
+    const gradient = canvasCtx.createLinearGradient(0, 0, w, h)
+    gradient.addColorStop(0, colorOne)
+    gradient.addColorStop(1, colorTwo)
+
+    canvasCtx.fillStyle = gradient
+
+    if (w < 2 * r) r = w / 2
+    if (h < 2 * r) r = h / 2
+    canvasCtx.beginPath()
+    canvasCtx.moveTo(x + r, y)
+    canvasCtx.arcTo(x + w, y, x + w, y + h, r)
+    canvasCtx.arcTo(x + w, y + h, x, y + h, r)
+    canvasCtx.arcTo(x, y + h, x, y, r)
+    canvasCtx.arcTo(x, y, x + w, y, r)
+    canvasCtx.closePath()
+
+    canvasCtx.fill()
+
+    return canvas
+  }
+
+  colorLuminance (hex, lum) {
+    hex = String(hex).replace(/[^0-9a-f]/gi, '')
+    if (hex.length < 6) {
+      hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2]
+    }
+    lum = lum || 0
+
+    // convert to decimal and change luminosity
+    let rgb = '#'
+    let c
+    let i
+    for (i = 0; i < 3; i++) {
+      c = parseInt(hex.substr(i * 2, 2), 16)
+      c = Math.round(Math.min(Math.max(0, c + (c * lum)), 255)).toString(16)
+      rgb += ('00' + c).substr(c.length)
+    }
+
+    return rgb
+  }
+
+  roundImage (image, r) {
+    const w = image.width
+    const h = image.height
+
+    const canvas = createCanvas(w, h)
+    const canvasCtx = canvas.getContext('2d')
+
+    const x = 0
+    const y = 0
+
+    if (w < 2 * r) r = w / 2
+    if (h < 2 * r) r = h / 2
+    canvasCtx.beginPath()
+    canvasCtx.moveTo(x + r, y)
+    canvasCtx.arcTo(x + w, y, x + w, y + h, r)
+    canvasCtx.arcTo(x + w, y + h, x, y + h, r)
+    canvasCtx.arcTo(x, y + h, x, y, r)
+    canvasCtx.arcTo(x, y, x + w, y, r)
+    canvasCtx.save()
+    canvasCtx.clip()
+    canvasCtx.closePath()
+    canvasCtx.drawImage(image, x, y)
+    canvasCtx.restore()
+
+    return canvas
+  }
+
+  drawReplyLine (lineWidth, height, color) {
+    const canvas = createCanvas(20, height)
+    const context = canvas.getContext('2d')
+    context.beginPath()
+    context.moveTo(10, 0)
+    context.lineTo(10, height)
+    context.lineWidth = lineWidth
+    context.strokeStyle = color
+    context.stroke()
+    context.closePath()
+
+    return canvas
+  }
+
+  async drawAvatar (user) {
+    try {
+      const avatarImage = await this.downloadAvatarImage(user)
+
+      if (avatarImage) {
+        const avatarSize = avatarImage.naturalHeight || avatarImage.height
+
+        const canvas = createCanvas(avatarSize, avatarSize)
+        const canvasCtx = canvas.getContext('2d')
+
+        const avatarX = 0
+        const avatarY = 0
+
+        canvasCtx.beginPath()
+        canvasCtx.arc(avatarX + avatarSize / 2, avatarY + avatarSize / 2, avatarSize / 2, 0, Math.PI * 2, true)
+        canvasCtx.clip()
+        canvasCtx.closePath()
+        canvasCtx.restore()
+        canvasCtx.drawImage(avatarImage, avatarX, avatarY, avatarSize, avatarSize)
+
+        return canvas
+      } else {
+        console.warn('No avatar image available for user')
+        return null
+      }
+    } catch (error) {
+      console.warn('Error drawing avatar:', error.message)
+      return null
+    }
+  }
+
+  drawLineSegment (ctx, x, y, width, isEven) {
+    ctx.lineWidth = 35 // how thick the line is
+    ctx.strokeStyle = '#aec6cf' // what color our line is
+    ctx.beginPath()
+    y = isEven ? y : -y
+    ctx.moveTo(x, 0)
+    ctx.lineTo(x, y)
+    ctx.arc(x + width / 2, y, width / 2, Math.PI, 0, isEven)
+    ctx.lineTo(x + width, 0)
+    ctx.stroke()
+  }
+
+  drawWaveform (data) {
+    const normalizedData = data.map(i => i / 32)
+
+    const canvas = createCanvas(4500, 500)
+    const padding = 50
+    canvas.height = (canvas.height + padding * 2)
+    const ctx = canvas.getContext('2d')
+    ctx.translate(0, canvas.height / 2 + padding)
+
+    // draw the line segments
+    const width = canvas.width / normalizedData.length
+    for (let i = 0; i < normalizedData.length; i++) {
+      const x = width * i
+      let height = normalizedData[i] * canvas.height - padding
+      if (height < 0) {
+        height = 0
+      } else if (height > canvas.height / 2) {
+        height = height > canvas.height / 2
+      }
+      this.drawLineSegment(ctx, x, height, width, (i + 1) % 2)
+    }
+    return canvas
+  }
+
+  async drawQuote (scale = 1, backgroundColorOne, backgroundColorTwo, avatar, replyName, replyNameColor, replyText, name, text, media, mediaType, maxMediaSize) {
+    const avatarPosX = 0 * scale
+    const avatarPosY = 5 * scale
+    const avatarSize = 50 * scale
+
+    const blockPosX = avatarSize + 10 * scale
+    const blockPosY = 0
+
+    const indent = 14 * scale
+
+    if (mediaType === 'sticker') name = undefined
+
+    let width = 0
+    if (name) width = name.width
+    if (text && width < text.width + indent) width = text.width + indent
+    if (name && width < name.width + indent) width = name.width + indent
+    if (replyName) {
+      if (width < replyName.width) width = replyName.width + indent * 2
+      if (replyText && width < replyText.width) width = replyText.width + indent * 2
+    }
+
+    let height = indent
+    if (text) height += text.height
+    else height += indent
+
+    if (name) {
+      height = name.height
+      if (text) height = text.height + name.height
+      else height += indent
+    }
+
+    width += blockPosX + indent
+    height += blockPosY
+
+    let namePosX = blockPosX + indent
+    let namePosY = indent
+
+    if (!name) {
+      namePosX = 0
+      namePosY = -indent
+    }
+
+    const textPosX = blockPosX + indent
+    let textPosY = indent
+    if (name) {
+      textPosY = name.height + indent * 0.25
+      height += indent * 0.25
+    }
+
+    let replyPosX = 0
+    let replyNamePosY = 0
+    let replyTextPosY = 0
+
+    if (replyName && replyText) {
+      replyPosX = textPosX + indent
+
+      const replyNameHeight = replyName.height
+      const replyTextHeight = replyText.height * 0.5
+
+      replyNamePosY = namePosY + replyNameHeight
+      replyTextPosY = replyNamePosY + replyTextHeight
+
+      textPosY += replyNameHeight + replyTextHeight + (indent / 4)
+      height += replyNameHeight + replyTextHeight + (indent / 4)
+    }
+
+    let mediaPosX = 0
+    let mediaPosY = 0
+
+    let mediaWidth, mediaHeight
+
+    if (media) {
+      mediaWidth = media.width * (maxMediaSize / media.height)
+      mediaHeight = maxMediaSize
+
+      if (mediaWidth >= maxMediaSize) {
+        mediaWidth = maxMediaSize
+        mediaHeight = media.height * (maxMediaSize / media.width)
+      }
+
+      if (!text || text.width <= mediaWidth || mediaWidth > (width - blockPosX)) {
+        width = mediaWidth + indent * 6
+      }
+
+      height += mediaHeight
+      if (!text) height += indent
+
+      if (name) {
+        mediaPosX = namePosX
+        mediaPosY = name.height + 5 * scale
+      } else {
+        mediaPosX = blockPosX + indent
+        mediaPosY = indent
+      }
+      if (replyName) mediaPosY += replyNamePosY + indent / 2
+      textPosY = mediaPosY + mediaHeight + 5 * scale
+    }
+
+    // Declare rectWidth and rectHeight variables before using them
+    let rectWidth = width - blockPosX
+    let rectHeight = height
+
+    if (mediaType === 'sticker' && (name || replyName)) {
+      rectHeight = replyName && replyText ? (replyName.height + replyText.height * 0.5) + indent * 2 : indent * 2
+      backgroundColorOne = backgroundColorTwo = 'rgba(0, 0, 0, 0.5)'
+    }
+
+    const canvas = createCanvas(width, height)
+    const canvasCtx = canvas.getContext('2d')
+
+    const rectPosX = blockPosX
+    const rectPosY = blockPosY
+    const rectRoundRadius = 25 * scale
+
+    let rect
+    if (mediaType === 'sticker' && (name || replyName)) {
+      rectHeight = (replyName.height + replyText.height * 0.5) + indent * 2
+      backgroundColorOne = backgroundColorTwo = 'rgba(0, 0, 0, 0.5)'
+    }
+
+    if (mediaType !== 'sticker' || name || replyName) {
+      if (backgroundColorOne === backgroundColorTwo) {
+        rect = this.drawRoundRect(backgroundColorOne, rectWidth, rectHeight, rectRoundRadius)
+      } else {
+        rect = this.drawGradientRoundRect(backgroundColorOne, backgroundColorTwo, rectWidth, rectHeight, rectRoundRadius)
+      }
+    }
+
+    if (avatar) canvasCtx.drawImage(avatar, avatarPosX, avatarPosY, avatarSize, avatarSize)
+    if (rect) canvasCtx.drawImage(rect, rectPosX, rectPosY)
+    if (name) canvasCtx.drawImage(name, namePosX, namePosY)
+    if (text) canvasCtx.drawImage(text, textPosX, textPosY)
+    if (media) canvasCtx.drawImage(this.roundImage(media, 5 * scale), mediaPosX, mediaPosY, mediaWidth, mediaHeight)
+
+    if (replyName && replyText) {
+      canvasCtx.drawImage(this.drawReplyLine(3 * scale, replyName.height + replyText.height * 0.4, replyNameColor), textPosX - 3, replyNamePosY)
+
+      canvasCtx.drawImage(replyName, replyPosX, replyNamePosY)
+      canvasCtx.drawImage(replyText, replyPosX, replyTextPosY)
+    }
+
+    return canvas
+  }
+
+  normalizeColor (color) {
+    const canvas = createCanvas(0, 0)
+    const canvasCtx = canvas.getContext('2d')
+
+    canvasCtx.fillStyle = color
+    color = canvasCtx.fillStyle
+
+    return color
+  }
+
+  getLineDirection (words, startIndex) {
+    const RTLMatch = /[\u0591-\u07FF\u200F\u202B\u202E\uFB1D-\uFDFD\uFE70-\uFEFC]/
+    const neutralMatch = /[\u0001-\u0040\u005B-\u0060\u007B-\u00BF\u00D7\u00F7\u02B9-\u02FF\u2000-\u2BFF\u2010-\u2029\u202C\u202F-\u2BFF\u1F300-\u1F5FF\u1F600-\u1F64F]/
+
+    for (let index = startIndex; index < words.length; index++) {
+      if (words[index].word.match(RTLMatch)) {
+        return 'rtl'
+      } else {
+        if (!words[index].word.match(neutralMatch)) { return 'ltr' }
+      }
+    }
+    return 'ltr'
+  }
+
+  async generate (backgroundColorOne, backgroundColorTwo, message, width = 512, height = 512, scale = 2, emojiBrand = 'apple') {
+    if (!scale) scale = 2
+    if (scale > 20) scale = 20
+    width = width || 512 // Ensure width has a default value
+    height = height || 512 // Ensure height has a default value
+    width *= scale
+    height *= scale
+
+    // check background style color black/light
+    const backStyle = this.lightOrDark(backgroundColorOne)
+
+    // historyPeer1NameFg: #c03d33; // red
+    // historyPeer2NameFg: #4fad2d; // green
+    // historyPeer3NameFg: #d09306; // yellow
+    // historyPeer4NameFg: #168acd; // blue
+    // historyPeer5NameFg: #8544d6; // purple
+    // historyPeer6NameFg: #cd4073; // pink
+    // historyPeer7NameFg: #2996ad; // sea
+    // historyPeer8NameFg: #ce671b; // orange
+
+    // { 0, 7, 4, 1, 6, 3, 5 }
+    // const nameColor = [
+    //   '#c03d33', // red
+    //   '#ce671b', // orange
+    //   '#8544d6', // purple
+    //   '#4fad2d', // green
+    //   '#2996ad', // sea
+    //   '#168acd', // blue
+    //   '#cd4073' // pink
+    // ]
+
+    const nameColorLight = [
+      '#FC5C51', // red
+      '#FA790F', // orange
+      '#895DD5', // purple
+      '#0FB297', // green
+      '#0FC9D6', // sea
+      '#3CA5EC', // blue
+      '#D54FAF' // pink
+    ]
+
+    const nameColorDark = [
+      '#FF8E86', // red
+      '#FFA357', // orange
+      '#B18FFF', // purple
+      '#4DD6BF', // green
+      '#45E8D1', // sea
+      '#7AC9FF', // blue
+      '#FF7FD5' // pink
+    ]
+
+    // user name  color
+    let nameIndex = 1
+    if (message.from && message.from.id) nameIndex = Math.abs(message.from.id) % 7
+
+    const nameColorArray = backStyle === 'light' ? nameColorLight : nameColorDark
+
+    let nameColor = nameColorArray[nameIndex]
+
+    const colorContrast = new ColorContrast()
+
+    // change name color based on background color by contrast
+    const contrast = colorContrast.getContrastRatio(this.colorLuminance(backgroundColorOne, 0.55), nameColor)
+    if (contrast > 90 || contrast < 30) {
+      nameColor = colorContrast.adjustContrast(this.colorLuminance(backgroundColorTwo, 0.55), nameColor)
+    }
+
+    const nameSize = 22 * scale
+
+    let nameCanvas
+    if ((message.from && message.from.name) || (message.from && (message.from.first_name || message.from.last_name))) {
+      let name = message.from.name || `${message.from.first_name || ''} ${message.from.last_name || ''}`.trim()
+
+      if (!name) name = 'User' // Default name if none provided
+
+      const nameEntities = [
+        {
+          type: 'bold',
+          offset: 0,
+          length: name.length
+        }
+      ]
+
+      if (message.from.emoji_status) {
+        name += ' 🤡'
+
+        nameEntities.push({
+          type: 'custom_emoji',
+          offset: name.length - 2,
+          length: 2,
+          custom_emoji_id: message.from.emoji_status
+        })
+      }
+
+      nameCanvas = await this.drawMultilineText(
+        name,
+        nameEntities,
+        nameSize,
+        nameColor,
+        0,
+        nameSize,
+        width,
+        nameSize,
+        emojiBrand
+      )
+    }
+
+    let fontSize = 24 * scale
+
+    let textColor = '#fff'
+    if (backStyle === 'light') textColor = '#000'
+
+    let textCanvas
+    if (message.text) {
+      textCanvas = await this.drawMultilineText(
+        message.text,
+        message.entities,
+        fontSize,
+        textColor,
+        0,
+        fontSize,
+        width,
+        height - fontSize,
+        emojiBrand
+      )
+    }
+
+    let avatarCanvas
+    if (message.avatar && message.from) {
+      try {
+        avatarCanvas = await this.drawAvatar(message.from)
+      } catch (error) {
+        console.warn('Error drawing avatar:', error.message)
+        avatarCanvas = null
+      }
+    }
+
+    let replyName, replyNameColor, replyText
+    if (message.replyMessage && message.replyMessage.name && message.replyMessage.text) {
+      try {
+        // Ensure chatId exists to prevent NaN in calculations
+        const chatId = message.replyMessage.chatId || 0
+        const replyNameIndex = Math.abs(chatId) % 7
+        replyNameColor = nameColorArray[replyNameIndex]
+
+        const replyNameFontSize = 16 * scale
+        replyName = await this.drawMultilineText(
+          message.replyMessage.name,
+          'bold',
+          replyNameFontSize,
+          replyNameColor,
+          0,
+          replyNameFontSize,
+          width * 0.9,
+          replyNameFontSize,
+          emojiBrand
+        )
+
+        let textColor = '#fff'
+        if (backStyle === 'light') textColor = '#000'
+
+        const replyTextFontSize = 21 * scale
+        replyText = await this.drawMultilineText(
+          message.replyMessage.text,
+          message.replyMessage.entities || [],
+          replyTextFontSize,
+          textColor,
+          0,
+          replyTextFontSize,
+          width * 0.9,
+          replyTextFontSize,
+          emojiBrand
+        )
+      } catch (error) {
+        console.error('Error generating reply message:', error)
+        // If reply message generation fails, continue without it
+        replyName = null
+        replyText = null
+      }
+    }
+
+    let mediaCanvas, mediaType, maxMediaSize
+    if (message.media) {
+      let media, type
+
+      let crop = false
+      if (message.mediaCrop) crop = true
+
+      if (message.media.url) {
+        type = 'url'
+        media = message.media.url
+      } else {
+        type = 'id'
+        if (message.media.length > 1) {
+          if (crop) media = message.media[1]
+          else media = message.media.pop()
+        } else media = message.media[0]
+      }
+
+      maxMediaSize = width / 3 * scale
+      if (message.text && textCanvas && maxMediaSize < textCanvas.width) maxMediaSize = textCanvas.width
+
+      if (media && media.is_animated) {
+        media = media.thumb
+        maxMediaSize = maxMediaSize / 2
+      }
+
+      try {
+        mediaCanvas = await this.downloadMediaImage(media, maxMediaSize, type, crop)
+        if (mediaCanvas) {
+          mediaType = message.mediaType
+        } else {
+          console.warn('Failed to download media image, skipping media for this message')
+          mediaCanvas = null
+          mediaType = null
+        }
+      } catch (error) {
+        console.warn('Error downloading media image:', error.message)
+        mediaCanvas = null
+        mediaType = null
+      }
+    }
+
+    if (message.voice) {
+      mediaCanvas = this.drawWaveform(message.voice.waveform)
+      maxMediaSize = width / 3 * scale
+    }
+
+    const quote = this.drawQuote(
+      scale,
+      backgroundColorOne, backgroundColorTwo,
+      avatarCanvas,
+      replyName, replyNameColor, replyText,
+      nameCanvas, textCanvas,
+      mediaCanvas, mediaType, maxMediaSize
+    )
+
+    return quote
+  }
+}
+
+module.exports = QuoteGenerate

utils/user-name.js

@@ -0,0 +1,9 @@
+module.exports = (user, url = false) => {
+  let name = user.first_name
+
+  if (user.last_name) name += ` ${user.last_name}`
+  name = name.replace(/</g, '&lt;').replace(/>/g, '&gt;')
+
+  if (url) return `<a href="tg://user?id=${user.id}">${name}</a>`
+  return name
+}