@danonino/moon 1.0.0

package/src/iqc-pinkmode.js

@@ -0,0 +1,390 @@
+/*
+Source : https://whatsapp.com/channel/0029VbCHRSDAzNboLatr0W0o/471
+*/
+
+const { createCanvas, loadImage, GlobalFonts } = require('@napi-rs/canvas');
+const { writeFile, readFile, mkdir } = require('node:fs/promises');
+const { existsSync } = require('node:fs');
+const { join } = require('node:path');
+
+const BG_URL   = "https://raw.githubusercontent.com/ryyntwx/allimagerin/refs/heads/main/Iqcbyrin.png";
+const BG_LOCAL = join(__dirname, 'Iqcbyrin.png');
+
+const INTER_FONTS = [
+    { url: 'https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuLyfAZ9hiJ-Ek-_EeA.woff2', file: 'Inter-Regular.ttf' },
+    { url: 'https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuI6fAZ9hiJ-Ek-_EeA.woff2', file: 'Inter-Medium.ttf'  },
+    { url: 'https://fonts.gstatic.com/s/inter/v18/UcCO3FwrK3iLTeHuS_nVMrMxCp50SjIw2boKoduKmMEVuFuYAZ9hiJ-Ek-_EeA.woff2', file: 'Inter-SemiBold.ttf' },
+];
+
+const APPLE_EMOJI_JSON_URL   = 'https://media.githubusercontent.com/media/Ditzzx-vibecoder/entahlah/main/emoji-apple.json';
+const APPLE_EMOJI_JSON_LOCAL = join(__dirname, 'fonts', 'emoji-apple-image.json');
+
+const BG_W = 906;
+const BG_H = 1736;
+const SX = BG_W / 1080;
+const SY = BG_H / 2280;
+
+const state = {
+    text: "Kesendirian adalah teman terbaik ku😂😂",
+    time: "22.54",
+    bubbleColor:  "#ffc5d5", 
+    textColor:    "#111111",
+    timeColor:    "#5e4146", 
+    tickColor:    "#8c1d2c",
+    fontSize:     Math.round(45  * SX), 
+    bubbleWidth:  Math.round(746 * SX),
+    showReaction: true,
+    emojiSize:    Math.round(90  * SX),
+    emojiSpacing: Math.round(110 * SX),
+    emojiXOffset: Math.round(15  * SX),
+    emojiYOffset: -15,
+    reactionScale: 1.0,
+    emojis: ["👍", "❤️", "😂", "😮", "😢", "🙏"],
+    offsetX: 20,
+    offsetY: 0,
+};
+
+let appleEmojiMap = null;
+
+async function downloadFile(url) {
+    const axios = require('axios');
+    const res = await axios.get(url, {
+        responseType: 'arraybuffer',
+        headers: { 'User-Agent': 'Mozilla/5.0' },
+        maxRedirects: 5,
+    });
+    return Buffer.from(res.data);
+}
+
+function emojiToUnicode(emoji) {
+    return [...emoji].map(c => c.codePointAt(0).toString(16)).join('-');
+}
+
+async function loadAppleEmojiMap() {
+    if (appleEmojiMap) return appleEmojiMap;
+    if (!existsSync(APPLE_EMOJI_JSON_LOCAL)) {
+        const buf = await downloadFile(APPLE_EMOJI_JSON_URL);
+        await writeFile(APPLE_EMOJI_JSON_LOCAL, buf);
+    }
+    const raw = await readFile(APPLE_EMOJI_JSON_LOCAL, 'utf-8');
+    appleEmojiMap = JSON.parse(raw);
+    return appleEmojiMap;
+}
+
+async function drawAppleEmoji(ctx, emoji, x, y, size) {
+    const map = await loadAppleEmojiMap();
+    const base = emojiToUnicode(emoji);
+    const variants = [
+        base,
+        base.replace(/-fe0f/g, ''),
+        base.toUpperCase(),
+        base.replace(/-fe0f/g, '').toUpperCase(),
+    ];
+    let b64 = null;
+    for (const v of variants) {
+        if (map[v]) { b64 = map[v]; break; }
+    }
+    if (!b64) {
+        ctx.fillText(emoji, x, y);
+        return;
+    }
+    const buf = Buffer.from(b64, 'base64');
+    const img = await loadImage(buf);
+    ctx.drawImage(img, x - size / 2, y - size / 2, size, size);
+}
+
+async function ensureAssets() {
+    await mkdir(join(__dirname, 'fonts'), { recursive: true });
+
+    for (const f of INTER_FONTS) {
+        const dest = join(__dirname, 'fonts', f.file);
+        if (!existsSync(dest)) {
+            const buf = await downloadFile(f.url);
+            await writeFile(dest, buf);
+        }
+        GlobalFonts.registerFromPath(dest, 'Inter');
+    }
+
+    await loadAppleEmojiMap();
+
+    if (!existsSync(BG_LOCAL)) {
+        const buf = await downloadFile(BG_URL);
+        await writeFile(BG_LOCAL, buf);
+    }
+}
+
+function drawRoundedRect(ctx, x, y, w, h, r) {
+    ctx.beginPath();
+    ctx.moveTo(x + r, y);
+    ctx.lineTo(x + w - r, y);
+    ctx.quadraticCurveTo(x + w, y, x + w, y + r);
+    ctx.lineTo(x + w, y + h - r);
+    ctx.quadraticCurveTo(x + w, y + h, x + w - r, y + h);
+    ctx.lineTo(x + r, y + h);
+    ctx.quadraticCurveTo(x, y + h, x, y + h - r);
+    ctx.lineTo(x, y + r);
+    ctx.quadraticCurveTo(x, y, x + r, y);
+    ctx.closePath();
+}
+
+function measureTextCustom(ctx, text, fontSize) {
+    const parts = text.split(/(\p{Extended_Pictographic})/gu);
+    let totalWidth = 0;
+    for (const part of parts) {
+        if (!part) continue;
+        if (/\p{Extended_Pictographic}/u.test(part)) {
+            totalWidth += fontSize * 1.05; 
+        } else {
+            totalWidth += ctx.measureText(part).width;
+        }
+    }
+    return totalWidth;
+}
+
+async function drawTextWithEmojis(ctx, text, x, y, fontSize) {
+    const parts = text.split(/(\p{Extended_Pictographic})/gu);
+    let currentX = x;
+    
+    for (const part of parts) {
+        if (!part) continue;
+        if (/\p{Extended_Pictographic}/u.test(part)) {
+            const emojiSize = fontSize * 1.05;
+            const emojiCX = currentX + emojiSize / 2;
+            const emojiCY = y; 
+            await drawAppleEmoji(ctx, part, emojiCX, emojiCY, emojiSize);
+            currentX += emojiSize;
+        } else {
+            ctx.fillText(part, currentX, y);
+            currentX += ctx.measureText(part).width;
+        }
+    }
+}
+
+function wrapText(ctx, text, maxWidth, fontSize) {
+    ctx.font = `500 ${fontSize}px Inter`;
+    const words = text.split(" ");
+    const lines = [];
+    let cur = "";
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        if (word.includes('\n')) {
+            const parts = word.split('\n');
+            for (let j = 0; j < parts.length; j++) {
+                const test = cur + (cur ? " " : "") + parts[j];
+                if (measureTextCustom(ctx, test, fontSize) > maxWidth && cur) {
+                    lines.push(cur); cur = parts[j];
+                } else { cur = test; }
+                if (j < parts.length - 1) { lines.push(cur); cur = ""; }
+            }
+            continue;
+        }
+        const test = cur + (cur ? " " : "") + word;
+        if (measureTextCustom(ctx, test, fontSize) > maxWidth && i > 0) {
+            lines.push(cur); cur = word;
+        } else { cur = test; }
+    }
+    if (cur) lines.push(cur);
+    return lines;
+}
+
+async function render(text, time, outputPath) {
+    await ensureAssets();
+
+    const s = { ...state, text: text ?? state.text, time: time ?? state.time };
+
+    const canvas = createCanvas(BG_W, BG_H);
+    const ctx    = canvas.getContext('2d');
+
+    const bgImg = await loadImage(BG_LOCAL);
+    ctx.drawImage(bgImg, 0, 0, BG_W, BG_H);
+
+    const rightPadding   = Math.round(80  * SX);
+    const textPaddingX   = Math.round(36  * SX);
+    const paddingTop     = Math.round(28  * SY);
+    const paddingBottom  = Math.round(28  * SY);
+    const bRadius        = Math.round(32  * SX);
+    const menuTopBorderY = Math.round(1276 * SY);
+    const timeFontSize   = Math.round(23  * SX);
+
+    ctx.font = `600 ${timeFontSize}px Inter`;
+    const timeMetrics    = ctx.measureText(s.time);
+    const ticksWidth     = Math.round(34 * SX);
+    const timestampWidth = timeMetrics.width + ticksWidth + Math.round(12 * SX);
+    const timestampHeight = timeFontSize;
+
+    const textLimitW = s.bubbleWidth - (textPaddingX * 2);
+    ctx.font = `500 ${s.fontSize}px Inter`;
+    const textLines  = wrapText(ctx, s.text, textLimitW, s.fontSize);
+
+    const lineWidths = textLines.map(line => measureTextCustom(ctx, line, s.fontSize));
+    const maxLineWidth = Math.max(...lineWidths, 0);
+
+    let bubbleActualW = 0;
+    let timestampOnNewRow = false;
+    const minBubbleW = Math.round(280 * SX);
+
+    if (textLines.length === 1) {
+        bubbleActualW = maxLineWidth + (textPaddingX * 2) + timestampWidth + Math.round(35 * SX);
+    } else {
+        const lastLineWidth = lineWidths[textLines.length - 1] || 0;
+        
+        if (lastLineWidth + timestampWidth + Math.round(35 * SX) <= maxLineWidth) {
+            bubbleActualW = maxLineWidth + (textPaddingX * 2);
+        } else if (lastLineWidth + timestampWidth + Math.round(35 * SX) <= textLimitW) {
+            bubbleActualW = lastLineWidth + timestampWidth + Math.round(35 * SX) + (textPaddingX * 2);
+        } else {
+            bubbleActualW = maxLineWidth + (textPaddingX * 2);
+            timestampOnNewRow = true;
+        }
+    }
+
+    if (bubbleActualW < minBubbleW) bubbleActualW = minBubbleW;
+    if (bubbleActualW > s.bubbleWidth) bubbleActualW = s.bubbleWidth;
+
+    const bubbleX = BG_W - bubbleActualW - rightPadding;
+
+    const lineGap = Math.round(12 * SY);
+    const textTotalHeight = (textLines.length * s.fontSize) + ((textLines.length - 1) * lineGap);
+
+    let bubbleHeight = 0;
+    if (timestampOnNewRow) {
+        bubbleHeight = paddingTop + textTotalHeight + Math.round(16 * SY) + timestampHeight + paddingBottom;
+    } else {
+        bubbleHeight = paddingTop + textTotalHeight + paddingBottom;
+    }
+
+    const currentBubbleY = menuTopBorderY - bubbleHeight - Math.round(28 * SY);
+
+    ctx.save();
+    ctx.translate(s.offsetX, s.offsetY);
+
+    ctx.save();
+    ctx.shadowColor   = "rgba(0,0,0,0.05)";
+    ctx.shadowBlur    = 20;
+    ctx.shadowOffsetY = 6;
+    ctx.fillStyle     = s.bubbleColor;
+    drawRoundedRect(ctx, bubbleX, currentBubbleY, bubbleActualW, bubbleHeight, bRadius);
+    ctx.fill();
+    ctx.restore();
+
+    ctx.save();
+    ctx.beginPath();
+    ctx.moveTo(bubbleX + bubbleActualW - Math.round(15 * SX), currentBubbleY + bubbleHeight - 5);
+    ctx.lineTo(bubbleX + bubbleActualW + Math.round(10 * SX), currentBubbleY + bubbleHeight - 5);
+    ctx.quadraticCurveTo(
+        bubbleX + bubbleActualW + Math.round(2 * SX),
+        currentBubbleY + bubbleHeight - Math.round(20 * SY),
+        bubbleX + bubbleActualW - Math.round(1 * SX),
+        currentBubbleY + bubbleHeight - Math.round(32 * SY)
+    );
+    ctx.closePath();
+    ctx.fillStyle = s.bubbleColor;
+    ctx.fill();
+    ctx.restore();
+
+    ctx.save();
+    ctx.fillStyle    = s.textColor;
+    ctx.font         = `400 ${s.fontSize}px Inter`;
+    ctx.textAlign    = "left";
+    ctx.textBaseline = "middle";
+    for (let i = 0; i < textLines.length; i++) {
+        const lineY = currentBubbleY + paddingTop + (i * (s.fontSize + lineGap)) + (s.fontSize / 2);
+        await drawTextWithEmojis(ctx, textLines[i], bubbleX + textPaddingX, lineY, s.fontSize);
+    }
+    ctx.restore();
+
+    ctx.save();
+    let timeX = bubbleX + bubbleActualW - textPaddingX - timestampWidth;
+    let timeY = 0;
+
+    if (timestampOnNewRow) {
+        timeY = currentBubbleY + bubbleHeight - paddingBottom - timestampHeight + Math.round(4 * SY);
+    } else {
+        const lastLineTop = currentBubbleY + paddingTop + ((textLines.length - 1) * (s.fontSize + lineGap));
+        timeY = lastLineTop + s.fontSize - timestampHeight + Math.round(2 * SY);
+    }
+
+    ctx.fillStyle    = s.timeColor;
+    ctx.font         = `600 ${timeFontSize}px Inter`;
+    ctx.textBaseline = "top";
+    ctx.fillText(s.time, timeX, timeY);
+
+    const tickX = timeX + timeMetrics.width + Math.round(10 * SX);
+    const t     = (n) => Math.round(n * SX);
+    const tickY = timeY + (timeFontSize / 2) - t(8); 
+
+    ctx.strokeStyle = s.tickColor;
+    ctx.lineWidth   = 3.6 * SX;
+    ctx.lineCap     = "round";
+    ctx.lineJoin    = "round";
+    
+    ctx.beginPath();
+    ctx.moveTo(tickX,         tickY + t(8));
+    ctx.lineTo(tickX + t(6),  tickY + t(14));
+    ctx.lineTo(tickX + t(16), tickY + t(2));
+    ctx.stroke();
+    
+    ctx.beginPath();
+    ctx.moveTo(tickX + t(7),         tickY + t(8));
+    ctx.lineTo(tickX + t(7) + t(6),  tickY + t(14));
+    ctx.lineTo(tickX + t(7) + t(16), tickY + t(2));
+    ctx.stroke();
+    ctx.restore();
+
+    if (s.showReaction) {
+        ctx.save();
+        const emojiNum  = s.emojis.length;
+        const startPad  = Math.round(52  * SX);
+        const plusBtnW  = Math.round(80  * SX);
+        const rxHeight  = Math.round(160 * SX);
+        const rxWidth   = startPad + ((emojiNum - 1) * s.emojiSpacing) + s.emojiSpacing * 0.5 + plusBtnW + startPad * 0.5;
+
+        const rxX       = bubbleX + bubbleActualW - rxWidth + s.emojiXOffset;
+        const rxY       = currentBubbleY - rxHeight + s.emojiYOffset;
+        const rxRadius  = rxHeight / 2;
+
+        const rxPivotX = rxX + rxWidth - Math.round(80 * SX);
+        const rxPivotY = rxY + rxHeight / 2;
+        ctx.translate(rxPivotX, rxPivotY);
+        ctx.scale(s.reactionScale, s.reactionScale);
+        ctx.translate(-rxPivotX, -rxPivotY);
+
+        ctx.save();
+        ctx.shadowColor   = "rgba(0,0,0,0.10)";
+        ctx.shadowBlur    = 36;
+        ctx.shadowOffsetY = 16;
+        ctx.fillStyle     = "#FFFFFF";
+        drawRoundedRect(ctx, rxX, rxY, rxWidth, rxHeight, rxRadius);
+        ctx.fill();
+        ctx.restore();
+
+        const emojiCY = rxY + rxHeight / 2;
+        for (let i = 0; i < emojiNum; i++) {
+            await drawAppleEmoji(ctx, s.emojis[i], rxX + startPad + (i * s.emojiSpacing), emojiCY, s.emojiSize);
+        }
+
+        const plusX = rxX + startPad + (emojiNum - 1) * s.emojiSpacing + Math.round(90 * SX);
+        const plusY = emojiCY;
+        const plusR = Math.round(38 * SX);
+        const arm   = Math.round(13 * SX);
+        ctx.beginPath();
+        ctx.arc(plusX, plusY, plusR, 0, Math.PI * 2);
+        ctx.fillStyle = "#E5E5EA";
+        ctx.fill();
+        ctx.strokeStyle = "#8E8E93";
+        ctx.lineWidth   = 4.5 * SX;
+        ctx.lineCap     = "round";
+        ctx.beginPath();
+        ctx.moveTo(plusX - arm, plusY); ctx.lineTo(plusX + arm, plusY);
+        ctx.moveTo(plusX, plusY - arm); ctx.lineTo(plusX, plusY + arm);
+        ctx.stroke();
+        ctx.restore();
+    }
+
+    ctx.restore();
+
+    const pngData = await canvas.encode('png');
+    return pngData;
+}
+
+module.exports = render;

package/src/mediafiredl.js

@@ -0,0 +1,144 @@
+const cheerio = require('cheerio')
+const axios = require("axios")
+
+const regex_ = {
+  folder: /\.com\/folder\/([^\/]+)\/?/,
+  file: /\.com\/(view|file)\/([a-zA-Z0-9]+)/
+}
+
+async function extractFromWeb(is, link) {
+  try {
+    const lnk = link.replace('.com/view', '.com/file');
+    const f = await is.get(lnk)
+    const $ = cheerio.load(f.data)
+    const url = $('.input.popsok').attr('href')
+    
+    if (!url || !/\/\/download\d+\.mediafire\.com\//.test(url)) throw Error ('Failed to find download url on the web')
+    
+    const [name, date, size, type] = [
+      $('.intro .filename').text(),
+      $('.details li:nth-child(2) span').text(),
+      $('.details li:nth-child(1) span').text(),
+      $('.intro .filetype').text()
+    ]
+    
+    const cont = {
+      'af': 'Africa',
+      'an': 'Antarctica',
+      'as': 'Asia',
+      'eu': 'Europe',
+      'na': 'North America',
+      'oc': 'Oceania',
+      'sa': 'South America'
+    }
+    
+    const $lo = $('.DLExtraInfo-uploadLocation')
+    
+    const [continent, location, flag] = [
+      $lo.find('.DLExtraInfo-uploadLocationRegion').attr('data-lazyclass')?.replace('continent-', ''),
+      $lo.find('.DLExtraInfo-sectionDetails p').text().match(/from (.*?) on/)?.[1],
+      $lo.find('div.lazyload.flag').attr('data-lazyclass')?.replace('flag-', '')
+    ];
+    
+    return {
+      size_format: size,
+      continent: cont[continent] || 'Unkown',
+      flag,
+      location,
+      url,
+    }
+  } catch (e) {
+    throw e
+  }
+}
+
+async function mediafire(link) {
+  try {
+    const is = axios.create({
+      baseURL: "https://www.mediafire.com",
+      headers: {
+        'accept-encoding' : 'gzip, deflate, br, zstd',
+        'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36',
+      }
+    });
+    
+    if (regex_.folder.test(link)) {
+      const ab = link.match(regex_.folder)
+      const getId = ab ? ab[1] : null;
+      
+      const { data: info } = await is.get('/api/1.4/folder/get_info.php', {
+        params: {
+          recursive: 'yes',
+          folder_key: getId,
+          response_format: 'json'
+        }
+      })
+      
+      let files_ = [], chunk = 1;
+      
+      while (true) {
+        const { data: files } = await is.get('/api/1.4/folder/get_content.php', {
+          params: {
+            r: 'hrdd',
+            content_type: 'files',
+            filter: 'all',
+            order_by: 'name',
+            order_direction: 'asc',
+            chunk: chunk,
+            version: '1.5',
+            folder_key: getId,
+            response_format: 'json'
+          },
+        })
+        files.response.folder_content.files.map(p => files_.push({
+          ...p,
+          links: p.links.normal_download,
+        }));
+        if (files.response.folder_content.more_chunks === 'no') break;
+        chunk++;
+        await new Promise(r => setTimeout(r, 2e3));
+      }
+      
+      return {
+        status: true,
+        type: 'folder',
+        ...info.response.folder_info,
+        files: files_
+      } 
+    };
+    
+    const match = link.match(regex_.file);
+    const ab = match ? match[2] : null;
+    
+    let { data: info } = await is.get('/api/1.5/file/get_info.php', {
+      params: {
+        quick_key: ab,
+        response_format: 'json'
+      }
+    })
+    
+    let inf = info.response.file_info, wb = await extractFromWeb(is, link);
+    if (!wb.type) wb = await extractFromWeb(is, link);
+    
+    return {
+      status: true,
+      type: 'file',
+      ...inf,
+      links: inf.links.normal_download,
+      ...wb,
+      ...(!!inf.links.view ? {
+        preview: is.defaults.baseURL + '/convkey/' + inf.hash.substr(0, 4) + '/' + inf.quickkey + '9g.' + inf.filename.split('.').pop()
+      } : {}),
+    }
+  } catch(e) {
+    if (e.status === 404) {
+      return {
+        status: false,
+        msg: "Page not found or invalid link"
+      }
+    }
+    throw e.response ? e.response.data : e.message
+  }
+}
+
+module.exports = mediafire;

package/src/nanobanana.js

@@ -0,0 +1,115 @@
+const axios = require('axios');
+const crypto = require('crypto');
+const FormData = require('form-data');
+
+async function live3d(buffer, prompt) {
+  const config = {
+    pkey: "LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlHZk1BMEdDU3FHU0liM0RRRUJBUVVBQTRHTkFEQ0JpUUtCZ1FDd2xPK2JvQzZjd1JvM1VmWFZCYWRhWXdjWDB6S1MyZnVWTlkycVowZGd3YjFOSisvUTlGZUFvc0w0T05pb3NENzFvbjNQVllxUlVsTDUwNDVtdkgySzlpOGJBRlZNRWlwN0U2Uk1LNnRLQUFpZjd4elpyWG5QMUdaNVJpanRxZGd3aCtZbXpUbzM5Y3VCQ3NacUs5b0VvZVEzci9teUc5Uys5Y1I1aHVUdUZRSURBUUFCCi0tLS0tRU5EIFBVQkxJQyBLRVktLS0tLQ==",
+    aid: "aifaceswap",
+    uid: "1H5tRtzsBkqXcaJ",
+    origin: "8f3f0c7387123ae0",
+    theme_version: '83EmcUoQTUv50LhNx0VrdcK8rcGexcP35FcZDcpgWsAXEyO4xqL5shCY6sFIWB2Q',
+    model: 'nano_banana_2',
+  }
+  
+  let currentFp = crypto.randomBytes(16).toString('hex');
+  
+  const crypt = {
+    aes: (data, key) => {
+      const cipher = crypto.createCipheriv('aes-128-cbc', key, key);
+      return Buffer.concat([cipher.update(data, 'utf8'), cipher.final()]).toString('base64')
+    },
+    rsa: (data) => {
+      return crypto.publicEncrypt({
+        key: Buffer.from(config.pkey, "base64").toString(),
+        padding: crypto.constants.RSA_PKCS1_PADDING,
+      }, Buffer.from(data, 'utf8')).toString('base64');
+    }
+  };
+
+  const api = axios.create({
+    baseURL: 'https://app-v1.live3d.io',
+    headers: {
+      'User-Agent': 'Mozilla/5.0 (Linux; Android 16; NX729J) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.7499.34 Mobile Safari/537.36',
+      'origin': 'https://live3d.io',
+      'referer': 'https://live3d.io/',
+      'theme-version': config.theme_version
+    }
+  });
+
+  api.interceptors.request.use((cfg) => {
+    const [i, d, n] = [
+      crypto.randomBytes(8).toString('hex'),
+      crypto.randomUUID(),
+      Math.floor(Date.now() / 1000)
+    ]
+    
+    const s = crypt.rsa(i);
+    const signStr = cfg.url.includes('upload-img') ? `${config.aid}:${d}:${s}` : `${config.aid}:${config.uid}:${n}:${d}:${s}`;
+    
+    Object.assign(cfg.headers, {
+      'fp': currentFp,
+      'fp1': crypt.aes(`${config.aid}:${currentFp}`, i),
+      'x-guide': s,
+      'x-sign': crypt.aes(signStr, i),
+      'x-code': Date.now().toString()
+    });
+    
+    return cfg;
+  });
+
+  try {
+    const form = new FormData();
+    form.append('file', buffer, { filename: 'input.jpg', contentType: 'image/jpeg' });
+    form.append('fn_name', 'demo-image-editor');
+    form.append('request_from', '9');
+    form.append('origin_from', config.origin);
+    
+    const { data: upRes } = await api.post('/aitools/upload-img', form, {
+      headers: form.getHeaders()
+    });
+    
+    const { data: job } = await api.post('/aitools/of/create', {
+      fn_name: 'demo-image-editor',
+      call_type: 3,
+      input: {
+        model: config.model,
+        source_images: [upRes.data.path],
+        prompt: prompt,
+        aspect_radio: 'auto',
+        request_from: 9
+      },
+      data: '',
+      request_from: 9,
+      origin_from: config.origin
+    });
+    
+    
+    const taskId = job.data.task_id;
+    if (!taskId) throw new Error("TaskId cannot be found")
+    
+    while (true) {
+      const { data: status } = await api.post('/aitools/of/check-status', {
+        task_id: taskId,
+        fn_name: 'demo-image-editor',
+        call_type: 3,
+        request_from: 9,
+        origin_from: config.origin
+      });
+      
+      if (status.data.status === 2) {
+        return {
+          status: 'success',
+          image_url: 'https://temp.live3d.io/' + status.data.result_image
+        };
+      } else if (status.data.status === 3) {
+        return status.data
+      }
+      await new Promise(r => setTimeout(r, 3000));
+    }
+  } catch (error) {
+    throw new Error(`Process failed: ${error.message}`);
+  }
+}
+
+module.exports = live3d;

package/src/novaai.js

@@ -0,0 +1,34 @@
+/*
+Base : https://play.google.com/store/apps/details?id=com.apporigins.NovaAI
+By : ZennzXD
+Created : 1 Mei 2026
+*/
+
+const headers = {
+  'User-Agent': 'okhttp/4.10.0',
+  'Accept-Encoding': 'gzip',
+  'platform': 'Android',
+  'version': '1.4.0',
+  'language': 'in',
+  'content-type': 'application/json; charset=utf-8'
+}
+
+async function novaAi(text) {
+  const payload = {
+    question_text: text,
+    conversation: {
+      conversation_items: []
+    }
+  }
+
+  const res = await fetch('https://us-central1-nova-ai---android.cloudfunctions.net/app/ai-response/v2', {
+    method: 'POST',
+    headers: headers,
+    body: JSON.stringify(payload)
+  })
+
+  const data = await res.json()
+  return data
+}
+
+module.exports = novaAi