@danonino/moon 1.0.0

package/README.md

@@ -0,0 +1 @@
+

package/index.js

@@ -0,0 +1,25 @@
+const fs = require('fs')
+const path = require('path')
+
+const srcPath = path.join(__dirname, 'src')
+const modules = {}
+const listScraper = []
+
+fs.readdirSync(srcPath).forEach(file => {
+  if (file.endsWith('.js')) {
+    const name = file.replace('.js', '')
+    modules[name] = require(`./src/${file}`)
+    listScraper.push(name)
+  }
+})
+
+modules.docs = async () => {
+  return {
+    success: true,
+    total: listScraper.length,
+    scrapers: listScraper,
+    message: "Gunakan nama scraper sebagai function. Contoh pemakaian: await nama_scraper('url')"
+  }
+}
+
+module.exports = modules

package/index.mjs

@@ -0,0 +1,16 @@
+import scraper from './index.js';
+
+export const applemusicdl = scraper.applemusicdl;
+export const geniusdetail = scraper.geniusdetail;
+export const geniussearch = scraper.geniussearch;
+export const igdl = scraper.igdl;
+export const igstalk = scraper.igstalk;
+export const novaai = scraper.novaai;
+export const pinterestdownload = scraper.pinterestdownload;
+export const pixaremovebg = scraper.pixaremovebg;
+export const sharpify = scraper.sharpify;
+export const threadsdownload = scraper.threadsdownload;
+export const twetterdownload = scraper.twetterdownload;
+export const docs = scraper.docs;
+
+export default scraper;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@danonino/moon",
+  "version": "1.0.0",
+  "description": "femboys",
+  "keywords": [
+    "test",
+    "moon",
+    "scraping"
+  ],
+  "main": "index.js",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js"
+    }
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "moon",
+  "license": "ISC",
+  "dependencies": {
+    "@fontsource/plus-jakarta-sans": "^5.2.8",
+    "@napi-rs/canvas": "^1.0.2",
+    "@zenaveline/scraper": "^1.2.2",
+    "axios": "^1.6.0",
+    "cheerio": "^1.0.0",
+    "crypto": "^1.0.1",
+    "form-data": "^4.0.0",
+    "sharp": "^0.33.2"
+  }
+}

package/src/allinonedownloader.js

@@ -0,0 +1,66 @@
+/*
+Base : https://wowdownloader.com
+Author : Neo
+WhatsApp Channel: https://whatsapp.com/channel/0029Vb6hVYK8V0tkiz4bKs0N
+Support:
+Tiktok
+Twitter 
+Facebook 
+Instagram 
+Pinterest 
+LinkedIn 
+Douyin
+Likee
+SoundCloud
+Spotify
+Apple Music
+YouTube
+*/
+const axios = require('axios');
+
+const tools = [
+    'apple-music-downloader', 'douyin-downloader', 'facebook-video-downloader', 
+    'instagram-reels-downloader', 'instagram-story-downloader', 'instagram-video-downloader', 
+    'likee-downloader', 'linkedin-video-downloader', 'pinterest-video-downloader', 
+    'soundcloud-downloader', 'spotify-downloader', 'tiktok-photo-downloader', 
+    'tiktok-story-downloader', 'tiktok-video-downloader', 'twitter-gif-downloader', 
+    'twitter-video-downloader', 'youtube-monetization-checker', 'youtube-money-calculator', 
+    'youtube-tags-extractor', 'youtube-thumbnail-downloader', 'youtube-transcript', 
+    'youtube-video-downloader'
+];
+
+async function wowdownloader(url, tool) {
+    try {
+        if (!url.includes('https://')) throw new Error('Invalid url.');
+        if (!tools.includes(tool)) throw new Error('Invalid tool.');
+        
+        const { data: html, headers } = await axios.get(`https://wowdownloader.com/tool/${tool}`, {
+            headers: {
+                'user-agent': 'Neo/1.0'
+            }
+        });
+        
+        const csrfToken = html.match(/<meta name="csrf-token" content="([^"]+)">/)?.[1];
+        if (!csrfToken) throw new Error('Failed to get token.');
+        
+        const { data } = await axios.post('https://wowdownloader.com/api/download', {
+            url: url,
+            tool: tool
+        }, {
+            headers: {
+                origin: 'https://wowdownloader.com',
+                referer: `https://wowdownloader.com/tool/${tool}`,
+                'x-csrf-token': csrfToken,
+                cookie: headers['set-cookie']?.map(c => c.split(';')[0]).join('; '),
+                'content-type': 'application/json',
+                'user-agent': 'Neo/1.0'
+            }
+        });
+        
+        return data;
+    } catch (error) {
+        throw new Error(error.response?.data?.error || error.message);
+    }
+}
+
+module.exports = wowdownloader;

package/src/applemusicdl.js

@@ -0,0 +1,63 @@
+/*
+Base : https://aaplmusicdownloader.com/
+By : ZennzXD
+Created : Kamis 2 April 2026
+*/
+
+const axios = require('axios')
+
+const headers = {
+  'User-Agent': 'Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Mobile Safari/537.36',
+  'Accept': 'application/json, text/javascript, */*; q=0.01',
+  'origin': 'https://aaplmusicdownloader.com',
+  'referer': 'https://aaplmusicdownloader.com/',
+  'sec-fetch-site': 'same-origin',
+  'sec-fetch-mode': 'cors',
+  'accept-language': 'id-ID,id;q=0.9,en-AU;q=0.8,en;q=0.7,en-US;q=0.6'
+}
+
+async function aapldown(url) {
+  const init = await axios.get('https://aaplmusicdownloader.com/', { headers })
+  const cookies = init.headers['set-cookie']
+  const cookieStr = cookies ? cookies.map(c => c.split(';')[0]).join('; ') : ''
+
+  const reqheaders = { ...headers, 'Cookie': cookieStr, 'x-requested-with': 'XMLHttpRequest' }
+
+  const metadata = await axios.get(`https://aaplmusicdownloader.com/api/song_url.php?url=${encodeURIComponent(url)}`, { headers: reqheaders })
+  const meta = metadata.data
+
+  const swdData = new URLSearchParams()
+  swdData.append('song_name', meta.name.replace(/['"]/g, ''))
+  swdData.append('artist_name', meta.artist.replace(/['"]/g, ''))
+  swdData.append('url', meta.url)
+  swdData.append('token', 'none')
+  swdData.append('zip_download', 'false')
+  swdData.append('quality', '320')
+
+  const swdRes = await axios.post('https://aaplmusicdownloader.com/api/composer/swd.php', swdData, {
+    headers: { ...reqheaders, 'Content-Type': 'application/x-www-form-urlencoded' }
+  })
+
+  const id3Data = new URLSearchParams()
+  id3Data.append('url', swdRes.data.dlink)
+  id3Data.append('name', meta.name)
+  id3Data.append('artist', meta.artist)
+  id3Data.append('album', meta.albumname)
+  id3Data.append('thumb', meta.thumb)
+
+  const id3Res = await axios.post('https://aaplmusicdownloader.com/api/composer/ffmpeg/saveid3.php', id3Data, {
+    headers: { ...reqheaders, 'Content-Type': 'application/x-www-form-urlencoded' },
+    responseType: 'text'
+  })
+
+  return {
+    title: meta.name,
+    album: meta.albumname,
+    artist: meta.artist,
+    thumb: meta.thumb,
+    duration: meta.duration,
+    url_dl: `https://aaplmusicdownloader.com/api/composer/ffmpeg/saved/${id3Res.data}`
+  }
+}
+
+module.exports = aapldown

package/src/brat.js

@@ -0,0 +1,192 @@
+/*
+Source : https://whatsapp.com/channel/0029VbCHRSDAzNboLatr0W0o/471
+Creator : Ditzzx
+*/
+
+const { createCanvas, loadImage, GlobalFonts } = require('@napi-rs/canvas')
+const { writeFileSync, existsSync, readFileSync } = require('fs')
+const path = require('path')
+
+const THEMES = {
+  black: { bg: '#000000', text: '#ffffff' },
+  white: { bg: '#ffffff', text: '#000000' },
+  green: { bg: '#8ace00', text: '#000000' }
+}
+
+const FONT_URL = 'https://raw.githubusercontent.com/Ditzzx-vibecoder/Assets/main/Font/ARIALN.ttf'
+const EMOJI_JSON_URL = 'https://media.githubusercontent.com/media/Ditzzx-vibecoder/entahlah/main/emoji-apple.json'
+const FONT_PATH = path.join(__dirname, 'ARIALN.ttf')
+const EMOJI_JSON_PATH = path.join(__dirname, 'emoji-apple.json')
+
+async function downloadFile(url, dest) {
+  const res = await fetch(url)
+  const buf = Buffer.from(await res.arrayBuffer())
+  writeFileSync(dest, buf)
+  return buf
+}
+
+async function ensureFont() {
+  if (!existsSync(FONT_PATH)) await downloadFile(FONT_URL, FONT_PATH)
+  GlobalFonts.registerFromPath(FONT_PATH, 'ArialNarrow')
+}
+
+let emojiMap = null
+const emojiImageCache = new Map()
+
+function emojiToUnicode(emoji) {
+  return [...emoji].map(c => c.codePointAt(0).toString(16).padStart(4, '0')).join('-')
+}
+
+async function loadEmojiMap() {
+  if (emojiMap) return emojiMap
+  if (!existsSync(EMOJI_JSON_PATH)) await downloadFile(EMOJI_JSON_URL, EMOJI_JSON_PATH)
+  emojiMap = JSON.parse(readFileSync(EMOJI_JSON_PATH, 'utf-8'))
+  return emojiMap
+}
+
+async function getEmojiImage(emoji) {
+  if (emojiImageCache.has(emoji)) return emojiImageCache.get(emoji)
+  const map = await loadEmojiMap()
+  const base = emojiToUnicode(emoji)
+  const variants = [
+    base,
+    base.replace(/-fe0f/gi, ''),
+    `${base.replace(/-fe0f/gi, '')}-fe0f`,
+    base.toUpperCase(),
+    base.replace(/-fe0f/gi, '').toUpperCase(),
+    base.replace(/-fe0f/gi, '').toUpperCase() + '-FE0F'
+  ]
+  let b64 = null
+  for (const v of variants) {
+    if (map[v]) { b64 = map[v]; break }
+  }
+  if (!b64) return null
+  const img = await loadImage(Buffer.from(b64, 'base64'))
+  emojiImageCache.set(emoji, img)
+  return img
+}
+
+async function drawAppleEmoji(ctx, emoji, x, y, size) {
+  const img = await getEmojiImage(emoji)
+  if (!img) { ctx.fillText(emoji, x, y); return }
+  ctx.drawImage(img, x, y, size, size)
+}
+
+const EMOJI_REGEX = /(\p{Emoji_Modifier_Base}\p{Emoji_Modifier}|\p{Emoji_Presentation}\uFE0F?|\p{Emoji}\uFE0F|[\u{1F1E0}-\u{1F1FF}]{2}|\p{Extended_Pictographic}\uFE0F?)/gu
+
+function measureTextCustom(ctx, text, fontSize) {
+  const parts = text.split(EMOJI_REGEX)
+  let w = 0
+  for (const part of parts) {
+    if (!part) continue
+    EMOJI_REGEX.lastIndex = 0
+    if (EMOJI_REGEX.test(part)) w += fontSize
+    else w += ctx.measureText(part).width
+    EMOJI_REGEX.lastIndex = 0
+  }
+  return w
+}
+
+async function drawTextWithEmojis(ctx, text, x, y, fontSize) {
+  const parts = text.split(EMOJI_REGEX)
+  let curX = x
+  for (const part of parts) {
+    if (!part) continue
+    EMOJI_REGEX.lastIndex = 0
+    if (EMOJI_REGEX.test(part)) {
+      await drawAppleEmoji(ctx, part, curX, y, fontSize)
+      curX += fontSize
+    } else {
+      ctx.fillText(part, curX, y)
+      curX += ctx.measureText(part).width
+    }
+    EMOJI_REGEX.lastIndex = 0
+  }
+}
+
+function wrapText(ctx, text, maxWidth, fontSize) {
+  ctx.font = `${fontSize}px ArialNarrow`
+  const words = text.split(' ')
+  const lines = []
+  let cur = ''
+  for (const word of words) {
+    const test = cur ? cur + ' ' + word : word
+    if (measureTextCustom(ctx, test, fontSize) > maxWidth && cur) {
+      lines.push(cur)
+      cur = word
+    } else {
+      cur = test
+    }
+  }
+  if (cur) lines.push(cur)
+  return lines
+}
+
+function fitsAt(ctx, text, fontSize, maxWidth, maxHeight, lineGap) {
+  const lines = wrapText(ctx, text, maxWidth, fontSize)
+  const longestWord = Math.max(...text.split(' ').map(w => measureTextCustom(ctx, w, fontSize)))
+  const totalHeight = lines.length * (fontSize + lineGap) - lineGap
+  return longestWord <= maxWidth && totalHeight <= maxHeight
+}
+
+function findBestFontSize(ctx, text, maxWidth, maxHeight, lineGap) {
+  let lo = 10
+  let hi = 700
+  let best = lo
+
+  while (lo <= hi) {
+    const mid = Math.floor((lo + hi) / 2)
+    if (fitsAt(ctx, text, mid, maxWidth, maxHeight, lineGap)) {
+      best = mid
+      lo = mid + 1
+    } else {
+      hi = mid - 1
+    }
+  }
+  return best
+}
+
+async function generateBrat({ text = 'Halo Guys Nama Saya', theme = 'white', blur = 0 } = {}) {
+  const selectedTheme = THEMES[theme] || THEMES.white
+  const blurAmount = [0, 1, 2, 3].includes(blur) ? blur : 0
+
+  const size = 1000
+  const padding = 80
+  const lineGap = 20
+  const maxWidth = size - padding * 2
+  const maxHeight = size - padding * 2
+
+  await ensureFont()
+  await loadEmojiMap()
+
+  const canvas = createCanvas(size, size)
+  const ctx = canvas.getContext('2d')
+
+  const fontSize = findBestFontSize(ctx, text, maxWidth, maxHeight, lineGap)
+  const lines = wrapText(ctx, text, maxWidth, fontSize)
+
+  ctx.fillStyle = selectedTheme.bg
+  ctx.fillRect(0, 0, size, size)
+
+  ctx.fillStyle = selectedTheme.text
+  ctx.font = `${fontSize}px ArialNarrow`
+  ctx.textAlign = 'left'
+  ctx.textBaseline = 'top'
+
+  ctx.save()
+  if (blurAmount > 0) ctx.filter = `blur(${blurAmount}px)`
+
+  const totalTextHeight = lines.length * (fontSize + lineGap) - lineGap
+  let y = (size - totalTextHeight) / 2
+  for (const line of lines) {
+    await drawTextWithEmojis(ctx, line, padding, y, fontSize)
+    y += fontSize + lineGap
+  }
+
+  ctx.restore()
+
+  const buffer = await canvas.encode('png')
+  return buffer
+}
+
+module.exports = generateBrat

package/src/bypasstools.js

@@ -0,0 +1,35 @@
+//credit by nazir
+//support sf.gl, sub2unlock, tinyurl, linkvertise dll
+
+const crypto = require("crypto");
+
+async function bypass(url, androidId = crypto.randomBytes(16).toString("hex")) {
+  const deviceId = crypto.createHash("sha256").update(`bypasstools:${androidId}`).digest("hex");
+  const { sessionToken } = await fetch("https://bypass.tools/api/mobile/init", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      deviceId,
+      platform: "android",
+      appVersion: "1.0.0"
+    })
+  }).then(r => r.json());
+  return fetch("https://bypass.tools/api/mobile/bypass", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${sessionToken}`,
+      "X-Device-ID": deviceId
+    },
+    body: JSON.stringify({
+      url,
+      forceRefresh: false
+    })
+  }).then(async r => {
+    const d = await r.json();
+    if (!r.ok) throw new Error(d.message || "Bypass failed");
+    return d.result;
+  });
+}
+
+module.exports = bypass;

package/src/douyindl.js

@@ -0,0 +1,69 @@
+//© Nazir 
+
+async function getAwemeId(input) {
+  if (/^\d+$/.test(input)) return input;
+  if (input.includes('v.douyin.com')) {
+    const res = await fetch(input, { redirect: 'follow' });
+    input = res.url;
+  }
+
+  const match = input.match(/\/video\/(\d+)/);
+  if (match) return match[1];
+
+  throw new Error("Gagal mengekstrak ID dari URL.");
+}
+
+async function douyin(input) {
+  try {
+    const awemeId = await getAwemeId(input);
+    const url = "https://so.douyin.com/aweme/v1/web/aweme/detail/";
+    
+    const headers = {
+      "content-type": "application/x-www-form-urlencoded",
+      "accept": "application/json",
+      "user-agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36"
+    };
+    const body = `aweme_id=${awemeId}&request_source=280`;
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: headers,
+      body: body
+    });
+
+    if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+
+    const data = await response.json();
+    
+    if (!data.aweme_detail) {
+      throw new Error("Metadata tidak ditemukan.");
+    }
+
+    const videoData = data.aweme_detail.video;
+    const desc = data.aweme_detail.desc || "no_description";
+    const author = data.aweme_detail.author ? data.aweme_detail.author.nickname : "unknown";
+    const videoUrl = videoData.play_addr.url_list[0];
+
+    return {
+      status: "success",
+      video_id: awemeId,
+      metadata: {
+        description: desc,
+        author: author,
+        author_id: data.aweme_detail.author ? data.aweme_detail.author.unique_id : null,
+        statistics: data.aweme_detail.statistics,
+        cover: videoData.cover.url_list[0],
+        duration: Math.round(videoData.duration / 1000) + "s",
+        video_url: videoUrl
+      }
+    };
+
+  } catch (error) {
+    return {
+      status: "error",
+      message: error.message
+    };
+  }
+}
+
+module.exports = douyin;

package/src/fake-ovo.js

@@ -0,0 +1,106 @@
+/*
+Source : https://whatsapp.com/channel/0029VbCHRSDAzNboLatr0W0o/471
+*/
+
+const { createCanvas, loadImage, GlobalFonts } = require("@napi-rs/canvas");
+const fs = require("fs");
+const fsp = require("fs/promises");
+const path = require("path");
+
+const ROOT = process.cwd();
+const OUTPUT_DIR = path.join(ROOT, "tmp");
+
+const IMAGE_URL =
+  "https://raw.githubusercontent.com/Ditzzx-vibecoder/Assets/main/Image/file_0000000078bc71fa87da5cf26dc6c008.jpeg";
+
+const WIDTH = 841;
+const HEIGHT = 1870;
+
+const FONT_PATHS = [
+  path.join(
+    ROOT,
+    "node_modules/@fontsource/plus-jakarta-sans/files/plus-jakarta-sans-latin-600-normal.woff2"
+  ),
+  path.join(
+    ROOT,
+    "node_modules/@fontsource/plus-jakarta-sans/files/plus-jakarta-sans-latin-ext-600-normal.woff2"
+  ),
+];
+
+const FIXED_RP = Object.freeze({
+  text: "Rp",
+  x: 61,
+  y: 368,
+  size: 20,
+  weight: 800,
+});
+
+const AMOUNT_STYLE = {
+  x: 94,
+  y: 371,
+  size: 28,
+  weight: 800,
+  color: "#FFFFFF",
+};
+
+function formatAmount(input) {
+  const digits = String(input).replace(/[^\d]/g, "") || "0";
+  const normalized = digits.replace(/^0+(?=\d)/, "");
+
+  return normalized.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+}
+
+function registerFont() {
+  for (const fontPath of FONT_PATHS) {
+    if (fs.existsSync(fontPath)) {
+      GlobalFonts.registerFromPath(fontPath, "Plus Jakarta Sans");
+      return;
+    }
+  }
+  
+  throw new Error("Font Plus Jakarta Sans tidak ketemu. Pastikan package @fontsource/plus-jakarta-sans terinstal.");
+}
+
+async function loadImageFromUrl(url) {
+  const res = await fetch(url);
+
+  if (!res.ok) {
+    throw new Error(`Gagal download image: HTTP ${res.status}`);
+  }
+
+  const arrayBuffer = await res.arrayBuffer();
+  return loadImage(Buffer.from(arrayBuffer));
+}
+
+async function fakeOvo(amountInput = "5000002828") {
+  fs.mkdirSync(OUTPUT_DIR, {
+    recursive: true,
+  });
+
+  registerFont();
+
+  const image = await loadImageFromUrl(IMAGE_URL);
+
+  const canvas = createCanvas(WIDTH, HEIGHT);
+  const ctx = canvas.getContext("2d");
+
+  ctx.imageSmoothingEnabled = true;
+  ctx.drawImage(image, 0, 0, WIDTH, HEIGHT);
+
+  ctx.fillStyle = AMOUNT_STYLE.color;
+  ctx.textAlign = "left";
+  ctx.textBaseline = "alphabetic";
+
+  ctx.font = `${FIXED_RP.weight} ${FIXED_RP.size}px "Plus Jakarta Sans"`;
+  ctx.fillText(FIXED_RP.text, FIXED_RP.x, FIXED_RP.y);
+
+  const AMOUNT_TEXT = formatAmount(amountInput);
+
+  ctx.font = `${AMOUNT_STYLE.weight} ${AMOUNT_STYLE.size}px "Plus Jakarta Sans"`;
+  ctx.fillText(AMOUNT_TEXT, AMOUNT_STYLE.x, AMOUNT_STYLE.y);
+
+  const buffer = await canvas.encode("png");
+  return buffer;
+}
+
+module.exports = fakeOvo;

package/src/geniusdetail.js

@@ -0,0 +1,44 @@
+/*
+Genius
+Base : https://play.google.com/store/apps/details?id=com.genius.android
+Author : ZennzXD
+Created : Sabtu 2 mei 2026
+*/
+
+const headers = {
+  'Accept-Encoding': 'gzip',
+  'x-genius-app-background-request': '0',
+  'x-genius-logged-out': 'true',
+  'x-genius-android-version': '8.1.1',
+  'user-agent': 'Genius/8.1.1 (Android; Android 13; ZN/Android)'
+}
+
+function parselirik(node) {
+  if (typeof node === 'string') return node
+  if (!node || !node.children) return ''
+  if (node.tag === 'br') return '\n'
+  return node.children.map(parselirik).join('')
+}
+
+async function detail(id) {
+  const res = await fetch(`https://api.genius.com/songs/${id}`, { headers })
+  const data = await res.json()
+  const song = data.response.song
+  
+  return {
+    id: song.id,
+    title: song.title,
+    artist: song.artist_names,
+    header_image_url: song.header_image_url,
+    song_art_image_url: song.song_art_image_url,
+    instrumental: song.instrumental,
+    is_music: song.is_music,
+    hidden: song.hidden,
+    explicit: song.explicit,
+    release_date: song.release_date_for_display,
+    url: song.url,
+    lyrics: song.lyrics ? parselirik(song.lyrics.dom).trim() : null
+  }
+}
+
+module.exports = detail