Upload folder using huggingface_hub

.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.example

@@ -0,0 +1,3 @@
+PORT="4888"
+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": {
+    }
+}

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/emoji/emoji-apple-image.json filter=lfs diff=lfs merge=lfs -text
+assets/emoji/emoji-google-image.json filter=lfs diff=lfs merge=lfs -text
+assets/emoji/emoji-joypixels-image.json filter=lfs diff=lfs merge=lfs -text
+assets/emoji/emoji-twitter-image.json filter=lfs diff=lfs merge=lfs -text
+assets/pattern_ny_old.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,66 @@
+# 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
+
+# dotenv environment variables file
+.env
+
+# next.js build output
+.next
+
+assets/fonts/*
+assets/emojis/*
+
+!.gitkeep

.vscode/launch.json

@@ -0,0 +1,18 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "runtimeVersion": "16.5.0",
+            "request": "launch",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/index.js"
+        }
+    ]
+}

Dockerfile

@@ -0,0 +1,11 @@
+FROM nikolaik/python-nodejs:python3.8-nodejs12 AS builder
+
+ENV NODE_WORKDIR /app
+WORKDIR $NODE_WORKDIR
+
+ADD . $NODE_WORKDIR
+
+RUN apt-get update && apt-get install -y build-essential gcc wget git libvips && rm -rf /var/lib/apt/lists/*
+
+
+RUN npm install [email protected] && npm install # TODO: canvas crashes if installed via npm install from package.json

README.md

@@ -1,12 +1,232 @@
----
-title: Quote Api
-emoji: 💻
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 4.13.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# quote-api
+
+[![wakatime](https://wakatime.com/badge/github/LyoSU/quote-api.svg)](https://wakatime.com/badge/github/LyoSU/quote-api)
+
+Апи для генерации Telegram цитат
+
+## Методы
+##### Создание цитаты
+```http
+POST /generate
+```
+
+Пример JSON запроса:
+```json
+{
+  "type": "quote",
+  "format": "png",
+  "backgroundColor": "#1b1429",
+  "width": 512,
+  "height": 768,
+  "scale": 2,
+  "messages": [
+    {
+      "entities": [],
+      "chatId": 66478514,
+      "avatar": true,
+      "from": {
+        "id": 66478514,
+        "first_name": "Yuri 💜",
+        "last_name": "Ly",
+        "username": "LyoSU",
+        "language_code": "ru",
+        "title": "Yuri 💜 Ly",
+        "photo": {
+          "small_file_id": "AQADAgADCKoxG7Jh9gMACBbSEZguAAMCAAOyYfYDAATieVimvJOu7M43BQABHgQ",
+          "small_file_unique_id": "AQADFtIRmC4AA843BQAB",
+          "big_file_id": "AQADAgADCKoxG7Jh9gMACBbSEZguAAMDAAOyYfYDAATieVimvJOu7NA3BQABHgQ",
+          "big_file_unique_id": "AQADFtIRmC4AA9A3BQAB"
+        },
+        "type": "private",
+        "name": "Yuri 💜 Ly"
+      },
+      "text": "I love you 💜",
+      "replyMessage": {}
+    }
+  ]
+}
+```
+
+Медиа:
+```json
+{
+  "type": "quote",
+  "format": "png",
+  "backgroundColor": "#1b1429",
+  "width": 512,
+  "height": 768,
+  "scale": 2,
+  "messages": [
+    {
+      "media": [
+        {
+          "file_id": "CAACAgIAAxkBAAIyH2AAAUcJoPJqv4uOPabtiSR3judSnQACaQEAAiI3jgQe29BUaNTqrx4E",
+          "file_size": 22811,
+          "height": 512,
+          "width": 512
+        }
+      ],
+      "mediaType": "sticker",
+      "chatId": 66478514,
+      "avatar": true,
+      "from": {
+        "id": 66478514,
+        "first_name": "Yuri 💜",
+        "last_name": "Ly",
+        "username": "LyoSU",
+        "language_code": "ru",
+        "title": "Yuri 💜 Ly",
+        "photo": {
+          "small_file_id": "AQADAgADCKoxG7Jh9gMACBbSEZguAAMCAAOyYfYDAATieVimvJOu7M43BQABHgQ",
+          "small_file_unique_id": "AQADFtIRmC4AA843BQAB",
+          "big_file_id": "AQADAgADCKoxG7Jh9gMACBbSEZguAAMDAAOyYfYDAATieVimvJOu7NA3BQABHgQ",
+          "big_file_unique_id": "AQADFtIRmC4AA9A3BQAB"
+        },
+        "type": "private",
+        "name": "Yuri 💜 Ly"
+      },
+      "replyMessage": {}
+    }
+  ]
+}
+```
+
+Без Telegram
+```json
+{
+  "type": "quote",
+  "format": "png",
+  "backgroundColor": "#1b1429",
+  "width": 512,
+  "height": 768,
+  "scale": 2,
+  "messages": [
+    {
+      "entities": [],
+      "media": {
+        "url": "https://via.placeholder.com/1000"
+      },
+      "avatar": true,
+      "from": {
+        "id": 1,
+        "name": "Mike",
+        "photo": {
+          "url": "https://via.placeholder.com/100"
+        }
+      },
+      "text": "Hey",
+      "replyMessage": {}
+    }
+  ]
+}
+```
+
+Параметры:
+|  Поле | Тип |  Описание  |
+| :------------ | :------------ | :------------ |
+|  type | string | Тип выходного изображения. Может быть: quote, image, null |
+|  backgroundColor | string | Цвет фона цитаты. Может быть Hex, название или random для случайного цвета |
+|  messages | array | Массив из сообщений |
+| width | number | Максимальная ширина |
+| height | number | Максимальная высота |
+| scale | number | Маcштаб |
+
+Пример ответа:
+
+```json
+{
+  "ok": true,
+  "result": {
+    "image": "base64 image",
+    "type": "quote",
+    "width": 512,
+    "height": 359
+  }
+}
+
+```
+
+## Примеры запросов:
+> JavaScript
+```js
+const axios = require('axios')
+const fs = require('fs')
+
+const text = "Hello World"
+const username = "Alι_Aryαɴ"
+const avatar = "https://telegra.ph/file/59952c903fdfb10b752b3.jpg"
+
+const json = {
+  "type": "quote",
+  "format": "png",
+  "backgroundColor": "#FFFFFF",
+  "width": 512,
+  "height": 768,
+  "scale": 2,
+  "messages": [
+    {
+      "entities": [],
+      "avatar": true,
+      "from": {
+        "id": 1,
+        "name": username,
+        "photo": {
+          "url": avatar
+        }
+      },
+      "text": text,
+      "replyMessage": {}
+    }
+  ]
+};
+        const response = axios.post('https://bot.lyo.su/quote/generate', json, {
+        headers: {'Content-Type': 'application/json'}
+}).then(res => {
+    const buffer = Buffer.from(res.data.result.image, 'base64')
+       fs.writeFile('Quotly.png', buffer, (err) => {
+      if (err) throw err;
+    })
+});
+```
+
+> Python
+```py
+import requests
+import base64
+
+text = "Hello World"
+username = "Alι_Aryαɴ" 
+avatar = "https://telegra.ph/file/59952c903fdfb10b752b3.jpg"
+
+json = {
+  "type": "quote",
+  "format": "webp",
+  "backgroundColor": "#FFFFFF",
+  "width": 512,
+  "height": 768,
+  "scale": 2,
+  "messages": [
+    {
+      "entities": [],
+      "avatar": True,
+      "from": {
+        "id": 1,
+        "name": username,
+        "photo": {
+          "url": avatar
+        }
+      },
+      "text": text,
+      "replyMessage": {}
+    }
+  ]
+}
+
+response = requests.post('https://bot.lyo.su/quote/generate', json=json).json()
+buffer = base64.b64decode(response['result']['image'].encode('utf-8'))
+open('Quotly.png', 'wb').write(buffer)
+print('Quotly.png')
+```
+### Response
+
+![Quotly.png](assets/Quotly.png)

app.js

@@ -0,0 +1,56 @@
+const logger = require('koa-logger')
+const responseTime = require('koa-response-time')
+const bodyParser = require('koa-bodyparser')
+const ratelimit = require('koa-ratelimit')
+const Router = require('koa-router')
+const Koa = require('koa')
+
+const app = new Koa()
+
+app.use(logger())
+app.use(responseTime())
+app.use(bodyParser())
+
+const ratelimitВb = new Map()
+
+app.use(ratelimit({
+  driver: 'memory',
+  db: ratelimitВb,
+  duration: 1000 * 55,
+  errorMessage: {
+    ok: false,
+    error: {
+      code: 429,
+      message: 'Rate limit exceeded. See "Retry-After"'
+    }
+  },
+  id: (ctx) => ctx.ip,
+  headers: {
+    remaining: 'Rate-Limit-Remaining',
+    reset: 'Rate-Limit-Reset',
+    total: 'Rate-Limit-Total'
+  },
+  max: 20,
+  disableHeader: false,
+  whitelist: (ctx) => {
+    return ctx.query.botToken === process.env.BOT_TOKEN
+  },
+  blacklist: (ctx) => {
+  }
+}))
+
+app.use(require('./helpers').helpersApi)
+
+const route = new Router()
+
+const routes = require('./routes')
+
+route.use('/*', routes.routeApi.routes())
+
+app.use(route.routes())
+
+const port = process.env.PORT || 3000
+
+app.listen(port, () => {
+  console.log('Listening on localhost, port', port)
+})

assets/emoji/emoji-apple-image.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7f6822c2fe7de7e5af4637a812c89ffce5826ec546d0852e772ee117c50ecda
+size 28524906

assets/emoji/emoji-google-image.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2be7165b28cb0346161e94cc0e1813af1c175fab279128851128b09fa8b29ca
+size 18282533

assets/emoji/emoji-joypixels-image.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f9f1323fddae35bd891dfbe5ad218380e78d197834e4a250a073257d487faad
+size 18326902

assets/emoji/emoji-twitter-image.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fec5f05b7a8735b18883eedbef089532b827fc6c970adb0071f550a60b56ea38
+size 13737806

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: '1000M',
+    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,310 @@
+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) {
+      const canvasQuote = await quoteGenerate.generate(
+        backgroundColorOne,
+        backgroundColorTwo,
+        message,
+        parm.width,
+        parm.height,
+        parseFloat(parm.scale),
+        parm.emojiBrand
+      )
+
+      quoteImages.push(canvasQuote)
+    }
+  }
+
+  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,50 @@
+{
+  "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.11.0",
+    "dotenv": "^7.0.0",
+    "emoji-db": "^14.0.1",
+    "jimp": "^0.16.1",
+    "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",
+    "lottie-node": "^2.0.0",
+    "lottie-web": "^5.7.8",
+    "lru-cache": "^5.1.1",
+    "object-sizeof": "^1.6.0",
+    "runes": "^0.4.3",
+    "sharp": "^0.31.3",
+    "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,23 @@
+const https = require('https')
+
+module.exports = (url, filter = false) => {
+  return new Promise((resolve, reject) => {
+    https.get(url, (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,1100 @@
+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 = require('jimp')
+const smartcrop = require('smartcrop-sharp')
+const runes = require('runes')
+const lottie = require('lottie-node')
+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(console.error)
+
+        if (!userPhotoUrl) {
+          const getChat = await this.telegram.getChat(user.id).catch(console.error)
+          if (getChat && getChat.photo && getChat.photo.big_file_id) userPhoto = getChat.photo.big_file_id
+
+          if (userPhoto) userPhotoUrl = await this.telegram.getFileLink(userPhoto)
+          else if (user.username) userPhotoUrl = `https://telega.one/i/userpic/320/${user.username}.jpg`
+          else avatarImage = await loadImage(await this.avatarImageLatters(nameLatters, avatarColor))
+        }
+
+        if (userPhotoUrl) avatarImage = await loadImage(userPhotoUrl)
+
+        avatarCache.set(cacheKey, avatarImage)
+      } catch (error) {
+        avatarImage = await loadImage(await this.avatarImageLatters(nameLatters, avatarColor))
+      }
+    }
+
+    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) {
+    let mediaUrl
+    if (type === 'id') mediaUrl = await this.telegram.getFileLink(media).catch(console.error)
+    else mediaUrl = media
+    const load = await loadImageFromUrl(mediaUrl)
+    if (mediaUrl.match(/.tgs/)) {
+      const jsonLottie = await this.ungzip(load)
+      const canvas = createCanvas(512, 512)
+      const animation = lottie(JSON.parse(jsonLottie.toString()), canvas)
+      const middleFrame = Math.floor(animation.getDuration(true) / 2)
+      animation.goToAndStop(middleFrame, true)
+
+      return canvas
+    } else if (crop || mediaUrl.match(/.webp/)) {
+      const imageSharp = sharp(load)
+      const imageMetadata = await imageSharp.metadata()
+      const sharpPng = await imageSharp.png({ lossless: true, force: true }).toBuffer()
+
+      let croppedImage
+
+      if (imageMetadata.format === 'webp') {
+        const jimpImage = await Jimp.read(sharpPng)
+
+        croppedImage = await jimpImage.autocrop(false).getBufferAsync(Jimp.MIME_PNG)
+      } else {
+        const smartcropResult = await smartcrop.crop(sharpPng, { width: mediaSize, height: imageMetadata.height })
+        const crop = smartcropResult.topCrop
+
+        croppedImage = imageSharp.extract({ width: crop.width, height: crop.height, left: crop.x, top: crop.y })
+        croppedImage = await imageSharp.png({ lossless: true, force: true }).toBuffer()
+      }
+
+      return loadImage(croppedImage)
+    } else {
+      return loadImage(load)
+    }
+  }
+
+  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]
+
+    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 })
+
+    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'].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]/
+
+    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())
+            )
+        )
+      ) {
+        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
+    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 {
+          const emojiImageBase = emojiImageJson[styledWord.emoji.code]
+          if (emojiImageBase) {
+            emojiImage = await loadImage(
+              Buffer.from(emojiImageBase, 'base64')
+            ).catch(() => {})
+          }
+          if (!emojiImage) {
+            emojiImage = await loadImage(
+              Buffer.from(fallbackEmojiImageJson[styledWord.emoji.code], 'base64')
+            ).catch(() => {})
+          }
+        }
+      }
+
+      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)`
+      }
+      // else {
+      //   canvasCtx.font = `${fontSize}px OpenSans`
+      //   canvasCtx.fillStyle = fontColor
+      // }
+
+      canvasCtx.font = `${fontType} ${fontSize}px ${fontName}`
+      canvasCtx.fillStyle = fillStyle
+
+      if (canvasCtx.measureText(styledWord.word).width > maxWidth - fontSize * 3) {
+        while (canvasCtx.measureText(styledWord.word).width > maxWidth - fontSize * 3) {
+          styledWord.word = styledWord.word.substr(0, styledWord.word.length - 1)
+          if (styledWord.word.length <= 0) break
+        }
+        styledWord.word += '…'
+      }
+
+      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 (styledWord.emoji) lineWidth += (fontSize * 0.2)
+
+      if (lineWidth > textWidth) textWidth = lineWidth
+      if (textWidth > maxWidth) textWidth = maxWidth
+
+      if (emojiImage) {
+        canvasCtx.drawImage(emojiImage, lineX, lineY - fontSize + (fontSize * 0.15), fontSize + (fontSize * 0.22), fontSize + (fontSize * 0.22))
+      } else {
+        canvasCtx.fillText(styledWord.word, lineX, lineY)
+
+        if (styledWord.style.includes('strikethrough')) canvasCtx.fillRect(lineX, lineY - fontSize / 2.8, canvasCtx.measureText(styledWord.word).width, fontSize * 0.1)
+        if (styledWord.style.includes('underline')) canvasCtx.fillRect(lineX, 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')
+
+    canvasResizeCtx.drawImage(canvas, 0, 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.clip()
+    canvasCtx.closePath()
+    canvasCtx.restore()
+    canvasCtx.drawImage(image, x, y)
+
+    return canvas
+  }
+
+  deawReplyLine (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()
+
+    return canvas
+  }
+
+  async drawAvatar (user) {
+    const avatarImage = await this.downloadAvatarImage(user)
+
+    if (avatarImage) {
+      const avatarSize = avatarImage.naturalHeight
+
+      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
+    }
+  }
+
+  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 (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) {
+      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
+    }
+
+    if (mediaType === 'sticker' && (name || replyName)) {
+      mediaPosY += indent * 4
+      height += indent * 2
+    }
+
+    const canvas = createCanvas(width, height)
+    const canvasCtx = canvas.getContext('2d')
+
+    let rectWidth = width - blockPosX
+    let rectHeight = height
+    const rectPosX = blockPosX
+    const rectPosY = blockPosY
+    const rectRoundRadius = 25 * scale
+
+    let rect
+    if (mediaType === 'sticker' && (name || replyName)) {
+      rectHeight -= mediaHeight + indent * 2
+    }
+
+    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) {
+      canvasCtx.drawImage(this.deawReplyLine(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
+  }
+
+  async generate (backgroundColorOne, backgroundColorTwo, message, width = 512, height = 512, scale = 2, emojiBrand = 'apple') {
+    if (!scale) scale = 2
+    if (scale > 20) scale = 20
+    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.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?.name) {
+      let name = message.from.name
+
+      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) avatarCanvas = await this.drawAvatar(message.from)
+
+    let replyName, replyNameColor, replyText
+    if (message.replyMessage && message.replyMessage.name && message.replyMessage.text) {
+      const replyNameIndex = Math.abs(message.replyMessage.chatId) % 7
+      replyNameColor = nameColorArray[replyNameIndex]
+
+      const replyNameFontSize = 16 * scale
+      if (message.replyMessage.name) {
+        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
+      )
+    }
+
+    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 && maxMediaSize < textCanvas.width) maxMediaSize = textCanvas.width
+
+      mediaCanvas = await this.downloadMediaImage(media, maxMediaSize, type, crop)
+      mediaType = message.mediaType
+    }
+
+    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
+}