@zenaveline/scraper 1.1.1 → 1.2.2

package/README.md

@@ -18,7 +18,7 @@
 ## 🚀 Fitur Unggulan
 - **⚡ Super Ringan & Cepat:** Dibuat menggunakan library andalan.
 - **📦 Support Dual Module:** Bisa pakai `import` (ESM) atau `require` (CommonJS).
-- **💡 Developer Friendly:** Sintaks yang sederhana dan to-the-point menggunakan Promise (Async/Await).
+- **💡 Developer Friendly:** Sintaks yang sederhana dan mudah dipahami.
 - **🌐 Beragam Layanan:** Mulai dari Instagram, Threads, Twitter (X), Pinterest, hingga Apple Music & AI dan lain lain.
 
 ## 📦 Instalasi
@@ -33,26 +33,44 @@ yarn add @zenaveline/scraper
 
 ## 📖 Quick Start
 
-Cara panggilnya sangat praktis! Gunakan _destructuring_ untuk mengimpor fungsi yang spesifik kamu butuhkan.
+Cara panggilnya sangat praktis! Kamu bebas menamai *import*-nya sesuai selera (contoh: `scraper` atau nama lain).
 
 ### 🌟 ESM (ECMAScript Modules)
 Untuk project berformat module (atau menggunakan TypeScript):
 
 ```javascript
-import { igdl } from '@zenaveline/scraper';
+import scraper from '@zenaveline/scraper'
 
-const data = await igdl('https://www.instagram.com/p/url-postingan');
-console.log(data); // JSON
+const data = await scraper.igdl('https://www.instagram.com/p/url-postingan')
+console.log(data) // output
 ```
 
 ### 💻 CommonJS (CJS)
 Untuk project standar Node.js (seperti bot WhatsApp pada umumnya):
 
 ```javascript
-const { igdl } = require('@zenaveline/scraper');
+const scraper = require('@zenaveline/scraper')
 
-const data = await igdl('https://www.instagram.com/p/url-postingan');
-console.log(data); // JSON
+const data = await scraper.igstalk('prabowo')
+console.log(data); // output
+```
+
+### 🎶 Khusus Penggunaan Spotify API 
+
+```javascript
+const scraper = require('@zenaveline/scraper')
+
+const spotify = new scraper.spotify()
+
+// Contoh pencarian lagu
+const searchResult = await spotify.search('a thousand years jvke')
+console.log(searchResult)
+
+// Contoh Mengambil data spesifik berdasarkan ID
+const trackData = await spotify.track('23WxsmliKISYaCfam8iPPG')
+const artistData = await spotify.artist('164Uj4eKjl6zTBKfJLFKKK')
+const albumData = await spotify.album('7z2Nuz41dkU9ruY5Qkva2L')
+const playlistData = await spotify.playlist('4IfUIdWEonPys9mYs7zXna')
 ```
 
 ---
@@ -69,6 +87,9 @@ Panggil nama fungsinya sesuai daftar di bawah ini untuk menikmati semua fiturnya
 | `threadsdownload(url)` | Ambil media foto/video dari postingan Threads secara instan. |
 | `twetterdownload(url)` | Unduh postingan video/gambar dari platform X (Twitter). |
 | `pinterestdownload(url)`| Ekstrak media gambar dan video dengan kualitas jernih dari Pinterest. |
+| `douyindl(url)` | Download video Douyin tanpa watermark. |
+| `allinonedownloader(url, tool)` | Downloader all-in-one yang mendukung banyak platform (Tiktok, YouTube, IG, dll). |
+| `tiktokdownload(url)` | Download video/foto Tiktok tanpa watermark. |
 
 ### 🎵 Musik & Audio
 | Fungsi | Deskripsi Singkat |
@@ -76,6 +97,9 @@ Panggil nama fungsinya sesuai daftar di bawah ini untuk menikmati semua fiturnya
 | `applemusicdl(url)` | Unduh audio lagu favoritmu langsung dari Apple Music (hingga 320kbps). |
 | `geniussearch(query)` | Temukan lagu dan metadata sang artis lewat API Genius. |
 | `geniusdetail(id)` | Dapatkan detail lagu beserta lirik utuhnya via Genius ID. |
+| `spotify` | Class API untuk fitur Spotify (search, track, artist, album, playlist). Gunakan dengan `new scraper.spotify()`. |
+| `spotifydl(url)` | Unduh track dari Spotify (mendukung URL Track). |
+| `spotifycard(options)` | Buat gambar kartu keren lagu Spotify menggunakan metadata musik. |
 
 ### 🤖 AI & Image Tools
 | Fungsi | Deskripsi Singkat |
@@ -87,6 +111,7 @@ Panggil nama fungsinya sesuai daftar di bawah ini untuk menikmati semua fiturnya
 ### ℹ️ Utility
 | Fungsi | Deskripsi Singkat |
 | :--- | :--- |
+| `bypasstools(url)` | Bypass shortlink URL (support sf.gl, sub2unlock, tinyurl, linkvertise, dll). |
 | `docs()` | Gunakan fungsi ini untuk melihat *list* lengkap seluruh fungsi scraper yang didukung secara terprogram. |
 
 > **Catatan Penting:**  

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenaveline/scraper",
-  "version": "1.1.1",
+  "version": "1.2.2",
   "description": "Kumpulan scraper yang mudah digunakan!",
   "keywords": [
     "@zenaveline/scraper",
@@ -23,6 +23,7 @@
   "dependencies": {
     "axios": "^1.6.0",
     "cheerio": "^1.0.0",
-    "crypto": "^1.0.1"
+    "crypto": "^1.0.1",
+    "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/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/igstalk.js

@@ -1,67 +1,59 @@
-/*
-Base : https://instagram.com
-Author : ZenzzXD
-Test code nya di masing" ya jangan di website
-*/
-
-const axios = require('axios')
-const cheerio = require('cheerio')
-
-const headers = {
-  'host': 'www.instagram.com',
-  'dpr': '1.962499976158142',
-  'viewport-width': '980',
-  'sec-ch-ua': '"Chromium";v="139", "Not;A=Brand";v="99"',
-  'sec-ch-ua-mobile': '?1',
-  'sec-ch-ua-platform': '"Android"',
-  'sec-ch-ua-platform-version': '"13.0.0"',
-  'sec-ch-ua-model': '"RMX3085"',
-  'sec-ch-ua-full-version-list': '"Chromium";v="139.0.7339.0", "Not;A=Brand";v="99.0.0.0"',
-  'sec-ch-prefers-color-scheme': 'dark',
-  'upgrade-insecure-requests': '1',
-  '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': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
-  'sec-fetch-site': 'same-origin',
-  'sec-fetch-mode': 'navigate',
-  'sec-fetch-user': '?1',
-  'sec-fetch-dest': 'document',
-  'accept-encoding': 'gzip, deflate, br',
-  'accept-language': 'id-ID,id;q=0.9,en-AU;q=0.8,en;q=0.7,en-US;q=0.6',
-  'cookie': 'csrftoken=UhNYfmpbN4zFIUATif4lcT; datr=aisGabstXUMaPhnsc3rGDr3V; ig_did=8961CBBD-2C6B-486E-97C0-61557817C61A; ps_l=1; ps_n=1; mid=aZVbfgABAAHGlIdJc5uThx4NQ4Qv; wd=551x1096; dpr=1.962499976158142',
-  'pragma': 'akamai-x-cache-on, akamai-x-cache-remote-on, akamai-x-check-cacheable, akamai-x-get-cache-key, akamai-x-get-extracted-values, status-id, akamai-x-get-true-cache-key, akamai-x-serial-no, akamai-x-get-request-id,akamai-x-get-nonces,akamai-x-get-client-ip,akamai-x-feo-trace'
-}
-
-async function instagram(username) {
-  const r = await axios.get(`https://www.instagram.com/${username}`, { headers })
-  const $ = cheerio.load(r.data)
-  
-  const title = $('meta[property="og:title"]').attr('content') || ''
-  const description = $('meta[property="og:description"]').attr('content') || ''
-  const image = $('meta[property="og:image"]').attr('content') || ''
-  const url = $('meta[property="og:url"]').attr('content') || ''
-  const nameDescription = $('meta[name="description"]').attr('content') || ''
-
-  const followers = description.match(/([\d.,KMB]+)\s+(Pengikut|Followers)/i)?.[1] || '0'
-  const following = description.match(/([\d.,KMB]+)\s+(Mengikuti|Following)/i)?.[1] || '0'
-  const posts = description.match(/([\d.,KMB]+)\s+(Postingan|Posts)/i)?.[1] || '0'
-
-  const nameUsernameMatch = title.match(/^([^(]+)\s+\(([^)]+)\)/)
-  const name = nameUsernameMatch?.[1]?.trim() || ''
-  const parsedUsername = nameUsernameMatch?.[2]?.replace('@', '').trim() || username
-
-  const bioMatch = nameDescription.match(/(?:di Instagram|on Instagram):\s*["']?([^"']+)["']?$/i)
-  const bio = bioMatch?.[1] || ''
-
-  return {
-    name,
-    username: parsedUsername,
-    followers,
-    following,
-    posts,
-    bio,
-    profilePic: image,
-    url: url || `https://www.instagram.com/${username}`
+const axios  = require('axios');
+const crypto = require('crypto');
+
+async function igStalk(username) {
+  const [ky, tx] = ['2180a186d666f77b2c2af70e0098166d2b43d1e0a7b199776b07b98bf8351f37', 1781788719883]
+
+  try {
+    const client = axios.create({
+      baseURL: 'https://cors.caliph.my.id/https://api-wh.storiesig.info/api/v1/instagram',
+      headers: {
+        'accept': 'application/json, text/plain, */*',
+        'accept-language': 'id,id-ID;q=0.9,en-US;q=0.8,en;q=0.7',
+        'origin': 'https://storiesig.info',
+        'referer': 'https://storiesig.info/',
+        'user-agent': 'Mozilla/5.0 (X11; Linux aarch64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36',
+        'sec-ch-ua': '"Chromium";v="149", "Google Chrome";v="149", "Not/A)Brand";v="99"',
+        'sec-ch-ua-mobile': '?0',
+        'sec-ch-ua-platform': '"Linux"',
+        'sec-fetch-dest': 'empty',
+        'sec-fetch-mode': 'cors',
+        'sec-fetch-site': 'same-site'
+      },
+    });
+
+    client.interceptors.request.use((config) => {
+      const bd = config.data ?? {};
+      const ts = Date.now();
+      const mg = JSON.stringify(Object.keys(bd).sort().reduce((a, k) => { a[k] = bd[k]; return a; }, {})) + ts;
+      const sg = crypto.createHmac('sha256', Buffer.from(ky, 'hex')).update(mg).digest('hex');
+      config.data = { ...bd, ts, _ts: tx, _tsc: 0, _sv: 2, _s: sg };
+      return config;
+    });
+    
+    const { data: usrinf } = await client.post('userInfo', { username });
+    
+    if ((!usrinf.sucess && usrinf?.result <= 0) || !usrinf.result?.find(p => p?.user?.username === username)) {
+      return {
+        status: false,
+        msg: 'User not found'
+      }
+    }
+    
+    const [{ data: stories }, { data: posts }] = await Promise.all([
+      client.post('stories', { username }),
+      client.post('postsV2', { username, maxId: '' })
+    ]);
+
+    return {
+      status: true,
+      ...usrinf.result[0].user,
+      stories: stories.result,
+      posts: posts.result
+    };
+  } catch (error) {
+    throw error
   }
 }
 
-module.exports = instagram
+module.exports = igStalk;

package/src/spotify.js

@@ -0,0 +1,374 @@
+const axios = require("axios");
+const crypto = require("crypto");
+
+class Parser {
+  _getImg(o) {
+    return (o?.sources || []).map(s => ({ 
+      url: s.url,
+      width: s.width || s.maxWidth || null,
+      height: s.height || s.maxHeight || null 
+    }));
+  }
+
+  _getCol(o) {
+    return o?.extractedColors?.colorRaw?.hex || o?.extractedColors?.colorDark?.hex || null;
+  }
+
+  _getVI(v) {
+    return v?.squareCoverImage?.extractedColorSet ? { 
+      text_color: v.squareCoverImage.extractedColorSet.encoreBaseSetTextColor || null, 
+      high_contrast: v.squareCoverImage.extractedColorSet.highContrast || null, 
+      higher_contrast: v.squareCoverImage.extractedColorSet.higherContrast || null, 
+      min_contrast: v.squareCoverImage.extractedColorSet.minContrast || null 
+    } : null;
+  }
+
+  _getLink(uri) {
+    if (!uri) return { id: null, url: null };
+    const p = uri.split(':');
+    return {
+      uri,
+      id: p[2] || null,
+      url: p[2] ? `https://open.spotify.com/${p[1]}/${p[2]}` : null
+    };
+  }
+
+  parseSearch(res) {
+    if (!res) return null;
+    
+    const parse = (arr, mapFn, isTrack = false) => (arr || []).reduce((acc, node) => {
+      const d = isTrack ? node.item?.data : node.data;
+      if (d) acc.push({ ...mapFn(d), ...(node.matchedFields && { matched_fields: node.matchedFields }) });
+      return acc;
+    }, []);
+
+    const trackItems = res.tracksV2?.items?.length ? res.tracksV2.items : res.topResultsV2?.itemsV2?.filter(i => i.item?.__typename === "TrackResponseWrapper");
+
+    return {
+      top_results: (res.topResultsV2?.itemsV2 || []).reduce((acc, node) => {
+        const wrap = node.item;
+        const d = wrap?.data;
+        if (!d) return acc;
+        const type = wrap.__typename?.replace('ResponseWrapper', '') || 'Unknown';
+        acc.push({
+          type: type, ...this._getLink(d.uri),
+          name: d.name || d.profile?.name || d.displayName || null,
+          images: this._getImg(d.coverArt || d.visuals?.avatarImage || d.images?.items?.[0] || d.avatar),
+          matched_fields: node.matchedFields || []
+        });
+        return acc;
+      }, []),
+      tracks: parse(trackItems, t => ({
+        ...this._getLink(t.uri), name: t.name || null, duration_ms: t.duration?.totalMilliseconds || 0,
+        explicit: t.contentRating?.label === "EXPLICIT", media_type: t.trackMediaType || null,
+        playability: { playable: !!t.playability?.playable, reason: t.playability?.reason || null },
+        associations: { audio_count: t.associationsV3?.audioAssociations?.totalCount || 0, video_count: t.associationsV3?.videoAssociations?.totalCount || 0 },
+        artists: (t.artists?.items || []).map(a => ({ ...this._getLink(a.uri), uri: a.uri, name: a.profile?.name })),
+        album: {
+          ...this._getLink(t.albumOfTrack?.uri), name: t.albumOfTrack?.name || null,
+          images: this._getImg(t.albumOfTrack?.coverArt), color_dark: this._getCol(t.albumOfTrack?.coverArt), visual_identity: this._getVI(t.albumOfTrack?.visualIdentity)
+        },
+        sixteen_by_nine_cover: t.visualIdentity?.sixteenByNineCoverImage?.image?.data?.sources || []
+      }), true),
+      albums: parse(res.albumsV2?.items, a => ({
+        ...this._getLink(a.uri), name: a.name || null, type: a.type || null, release_year: a.date?.year || null,
+        playability: { playable: !!a.playability?.playable, reason: a.playability?.reason || null },
+        artists: (a.artists?.items || []).map(art => ({ ...this._getLink(art.uri), uri: art.uri, name: art.profile?.name })),
+        images: this._getImg(a.coverArt), color_dark: this._getCol(a.coverArt), visual_identity: this._getVI(a.visualIdentity)
+      })),
+      artists: parse(res.artists?.items, art => ({
+        ...this._getLink(art.uri), name: art.profile?.name || null, images: this._getImg(art.visuals?.avatarImage), color_dark: this._getCol(art.visuals?.avatarImage), visual_identity: this._getVI(art.visualIdentity)
+      })),
+      episodes: parse(res.episodes?.items, ep => ({
+        ...this._getLink(ep.uri), name: ep.name || null, description: ep.description || null, duration_ms: ep.duration?.totalMilliseconds || 0, explicit: ep.contentRating?.label === "EXPLICIT", media_types: ep.mediaTypes || [], release_date: ep.releaseDate?.isoString || null,
+        playability: { playable: ep.playability?.reason === "PLAYABLE", reason: ep.playability?.reason || null }, played_state: ep.playedState?.state || null, is_paywall: !!ep.restrictions?.paywallContent,
+        images: this._getImg(ep.coverArt), color_dark: this._getCol(ep.coverArt), visual_identity: this._getVI(ep.visualIdentity), video_preview_thumbnail: this._getImg(ep.videoPreviewThumbnail?.imagePreview?.data),
+        podcast: { ...this._getLink(ep.podcastV2?.data?.uri), name: ep.podcastV2?.data?.name || null, publisher: ep.podcastV2?.data?.publisher?.name || null, media_type: ep.podcastV2?.data?.mediaType || null }
+      })),
+      podcasts: parse(res.podcasts?.items, pod => ({
+        ...this._getLink(pod.uri), name: pod.name || null, publisher: pod.publisher?.name || null, media_type: pod.mediaType || null,
+        topics: (pod.topics?.items || []).map(t => ({ ...this._getLink(t.uri), uri: t.uri, title: t.title })),
+        images: this._getImg(pod.coverArt), color_dark: this._getCol(pod.coverArt), visual_identity: this._getVI(pod.visualIdentity)
+      })),
+      playlists: parse(res.playlists?.items, pl => ({
+        ...this._getLink(pl.uri), name: pl.name || null, description: pl.description || null, format: pl.format || null, attributes: pl.attributes || [],
+        images: this._getImg(pl.images?.items?.[0]), color_dark: this._getCol(pl.images?.items?.[0]), visual_identity: this._getVI(pl.visualIdentity),
+        owner: { ...this._getLink(pl.ownerV2?.data?.uri), display_name: pl.ownerV2?.data?.name || null, username: pl.ownerV2?.data?.username || null, images: this._getImg(pl.ownerV2?.data?.avatar) }
+      })),
+      genres: parse(res.genres?.items, g => ({
+        ...this._getLink(g.uri), name: g.name || null, images: this._getImg(g.image), color_dark: this._getCol(g.image)
+      })),
+      users: parse(res.users?.items, u => ({
+        ...this._getLink(u.uri), display_name: u.displayName || null, username: u.username || null, images: this._getImg(u.avatar), color_dark: this._getCol(u.avatar)
+      }))
+    };
+  }
+
+  parseTrack(data) {
+    const t = data?.track || data;
+    if (!t || t.__typename !== 'Track') return null;
+    const allArtists = [...(t.firstArtist?.items || []), ...(t.otherArtists?.items || [])];
+    
+    return {
+      ...this._getLink(t.uri), name: t.name || null, duration_ms: t.duration?.totalMilliseconds || 0,
+      playcount: parseInt(t.playcount) || 0, explicit: t.contentRating?.label === "EXPLICIT", track_number: t.trackNumber || null,
+      album: {
+        ...this._getLink(t.albumOfTrack?.uri), name: t.albumOfTrack?.name || null, type: t.albumOfTrack?.type || null, release_year: t.albumOfTrack?.date?.year || null,
+        images: this._getImg(t.albumOfTrack?.coverArt), color: this._getCol(t.albumOfTrack?.coverArt), visual_identity: this._getVI(t.albumOfTrack?.visualIdentity)
+      },
+      artists: allArtists.map(node => ({ ...this._getLink(node.uri), name: node.profile?.name || null, images: this._getImg(node.visuals?.avatarImage) }))
+    };
+  }
+
+  parseArtist(data) {
+    const a = data?.artist || data;
+    if (!a || a.__typename !== 'Artist') return null;
+    
+    return {
+      ...this._getLink(a.uri || `spotify:artist:${a.id}`), uri: a.uri || `spotify:artist:${a.id}`, name: a.profile?.name || null, verified: !!a.profile?.verified,
+      images: this._getImg(a.visuals?.avatarImage), header_images: this._getImg(a.visuals?.headerImage?.data || a.headerImage?.data), color: this._getCol(a.visuals?.avatarImage),
+      statistics: { followers: a.stats?.followers || 0, monthly_listeners: a.stats?.monthlyListeners || 0 },
+      top_tracks: (a.discography?.topTracks?.items || []).map(node => ({
+        ...this._getLink(node.track?.uri), name: node.track?.name || null, playcount: parseInt(node.track?.playcount) || 0, duration_ms: node.track?.duration?.totalMilliseconds || 0,
+        album: { ...this._getLink(node.track?.albumOfTrack?.uri), name: node.track?.albumOfTrack?.name || null, images: this._getImg(node.track?.albumOfTrack?.coverArt) }
+      }))
+    };
+  }
+
+  parseAlbum(data) {
+    const al = data?.albumUnion || data?.album || data;
+    if (!al || (al.__typename !== 'Album' && al.__typename !== 'AlbumRelease')) return null;
+    
+    return {
+      ...this._getLink(al.uri), name: al.name || null, type: al.type || null, 
+      release_date: al.date?.isoString || al.date?.year || null, label: al.label || null,
+      playability: { playable: !!al.playability?.playable, reason: al.playability?.reason || null },
+      images: this._getImg(al.coverArt), color: this._getCol(al.coverArt), visual_identity: this._getVI(al.visualIdentity),
+      artists: (al.artists?.items || []).map(art => ({ ...this._getLink(art.uri), name: art.profile?.name || null })),
+      copyrights: al.copyrights?.items || [],
+      tracks: (al.tracks?.items || al.tracksV2?.items || []).map(node => {
+        const t = node.track || node;
+        return {
+          ...this._getLink(t.uri), name: t.name || null, duration_ms: t.duration?.totalMilliseconds || 0,
+          playcount: parseInt(t.playcount) || 0, explicit: t.contentRating?.label === "EXPLICIT", track_number: t.trackNumber || null,
+          artists: (t.artists?.items || []).map(a => ({ ...this._getLink(a.uri), uri: a.uri, name: a.profile?.name }))
+        };
+      })
+    };
+  }
+
+  parsePlaylist(data) {
+    const pl = data?.playlistV2 || data?.playlist || data;
+    if (!pl || (pl.__typename !== 'Playlist' && pl.__typename !== 'PlaylistResponseWrapper')) return null;
+    
+    return {
+      ...this._getLink(pl.uri), name: pl.name || null, description: pl.description || null, format: pl.format || null,
+      followers: pl.followers || pl.ownerV2?.data?.followers || 0,
+      images: this._getImg(pl.images?.items?.[0] || pl.image), color: this._getCol(pl.images?.items?.[0] || pl.image), visual_identity: this._getVI(pl.visualIdentity),
+      owner: {
+        ...this._getLink(pl.ownerV2?.data?.uri), display_name: pl.ownerV2?.data?.name || null, username: pl.ownerV2?.data?.username || null,
+        images: this._getImg(pl.ownerV2?.data?.avatar)
+      },
+      tracks: (pl.content?.items || pl.tracks?.items || []).map(node => {
+        const t = node.item?.data || node.track || node; 
+        if (!t || t.__typename !== 'Track') return null;
+        return {
+          ...this._getLink(t.uri), name: t.name || null, duration_ms: t.duration?.totalMilliseconds || 0, explicit: t.contentRating?.label === "EXPLICIT",
+          album: { ...this._getLink(t.albumOfTrack?.uri), name: t.albumOfTrack?.name || null, images: this._getImg(t.albumOfTrack?.coverArt) },
+          artists: (t.artists?.items || []).map(a => ({ ...this._getLink(a.uri), uri: a.uri, name: a.profile?.name }))
+        };
+      }).filter(item => item !== null)
+    };
+  }
+}
+
+
+class Spotify {
+  constructor() {
+    this.cfg = {
+      secret: '376136387538459893883312310911992847112448894410210511297108', 
+      version: 61,
+      client_version: '1.2.88.61.ge172202b',
+      query: {
+        search: {
+          opt: "searchDesktop",
+          sha: "21b3fe49546912ba782db5c47e9ef5a7dbd20329520ba0c7d0fcfadee671d24e"
+        },
+        track: {
+          opt: "getTrack",
+          sha: "612585ae06ba435ad26369870deaae23b5c8800a256cd8a57e08eddc25a37294",
+        },
+        artist: {
+          opt: "queryArtistOverview",
+          sha: "5b9e64f43843fa3a9b6a98543600299b0a2cbbbccfdcdcef2402eb9c1017ca4c"
+        },
+        album: {
+          opt: "getAlbum",
+          sha: "b9bfabef66ed756e5e13f68a942deb60bd4125ec1f1be8cc42769dc0259b4b10"
+        },
+        playlist: {
+          opt: "fetchPlaylist",
+          sha: "32b05e92e438438408674f95d0fdad8082865dc32acd55bd97f5113b8579092b"
+        }
+      }
+    };
+    this.is = axios.create({
+      headers: {
+        'referer': 'https://open.spotify.com/',
+        'origin': 'https://open.spotify.com',
+        'content-type': 'application/json',
+        'accept': 'application/json',
+        'user-agent': 'Mozilla/5.0 (Linux; Android 16; NX729J) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.7499.34 Mobile Safari/537.36',
+      }
+    });
+    this.parser = new Parser();
+  }
+  
+  generateTOTP(tsms) {
+    const counter = Math.floor((tsms / 1000) / 30);
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigInt64BE(BigInt(counter));
+    const hmac = crypto.createHmac('sha1', Buffer.from(this.cfg.secret, "utf8")).update(buffer);
+    const digest = hmac.digest();
+    const offset = digest[digest.length - 1] & 0xf;
+    const code = (digest.readUInt32BE(offset) & 0x7fffffff) % 1000000;
+    return code.toString().padStart(6, '0');
+  }
+  
+  async getToken() {
+    try {
+      if (this.is.defaults.headers.authorization) return true
+      const sts = Math.floor(Date.now() / 1000);
+      const { data: token } = await this.is.get("https://open.spotify.com/api/token", {
+        params: {
+          reason: "init",
+          productType: "web-player",
+          totp: this.generateTOTP(Date.now()),
+          totpServer: this.generateTOTP(sts * 1000),
+          totpVer: String(this.cfg.version)
+        }
+      });
+      const { data: client } = await this.is.post('https://clienttoken.spotify.com/v1/clienttoken', {
+        client_data: {
+          client_version: this.cfg.client_version,
+          client_id: token.clientId,
+          js_sdk_data: {
+            device_brand: "unknown",
+            device_model: "unknown",
+            os: "linux",
+            os_version: "24.04",
+            device_id: crypto.randomUUID(),
+            device_type: "computer"
+          }
+        }
+      });
+      
+      Object.assign(this.is.defaults.headers, {
+        'accept-language': 'en', 
+        'app-platform': 'WebPlayer', 
+        'authorization': `Bearer ${token.accessToken}`, 
+        'client-token': client.granted_token.token,
+        'spotify-app-version': this.cfg.client_version
+      })
+      return true
+    } catch (error) {
+      return false;
+    }
+  }
+  
+  async query(name, vars) {
+    try {
+      if (!(await this.getToken())) return;
+      const sel = this.cfg.query[name]
+      
+      const { data: res } = await this.is.post('https://api-partner.spotify.com/pathfinder/v2/query', {
+        variables: vars,
+        operationName: sel.opt,
+        extensions: {
+          persistedQuery: {
+            version: 1,
+            sha256Hash: sel.sha
+          }
+        }
+      });
+      
+      return res
+    } catch (error) {
+      throw error
+    }
+  }
+  
+  async search(query) {
+    try {
+      const res = await this.query("search", {
+        searchTerm: query,
+        offset: 0,
+        limit: 10,
+        numberOfTopResults: 5,
+        includeAudiobooks: true,
+        includeArtistHasConcertsField: false,
+        includePreReleases: true,
+        includeAuthors: false,
+        includeEpisodeContentRatingsV2: false
+      });
+      return this.parser.parseSearch(res.data.searchV2)
+    } catch (error) {
+      throw error
+    }
+  }
+  
+  async track(ids) {
+    try {
+      const res = await this.query("track", {
+         uri: `spotify:track:${ids}`
+      });
+      return this.parser.parseTrack(res.data.trackUnion)
+    } catch (error) {
+      throw error
+    }
+  }
+  
+  async artist(ids) {
+    try {
+      const res = await this.query("artist", {
+        uri: `spotify:artist:${ids}`,
+        locale: "",
+        preReleaseV2: false
+      });
+      return this.parser.parseArtist(res.data.artistUnion)
+    } catch (error) {
+      throw error
+    }
+  }
+  
+  async album(ids) {
+    try {
+      const res = await this.query("album", {
+        uri: `spotify:album:${ids}`,
+        locale: "",
+        offset: 0,
+        limit: 50
+      });
+      return this.parser.parseAlbum(res.data.albumUnion)
+    } catch (error) {
+      throw error
+    }
+  }
+  
+  async playlist(ids) {
+    try {
+      const res = await this.query("playlist", {
+        uri: `spotify:playlist:${ids}`,
+        offset: 0,
+        limit: 25,
+        enableWatchFeedEntrypoint: false,
+        includeEpisodeContentRatingsV2: false
+      });
+      return this.parser.parsePlaylist(res.data.playlistV2)
+    } catch (error) {
+      throw error
+    }
+  }
+}
+
+module.exports = Spotify;

package/src/spotifycard.js

@@ -0,0 +1,142 @@
+const sharp = require('sharp')
+const axios = require('axios')
+
+async function loadImageFromURL(url) {
+  if (!url) return null;
+  if (Buffer.isBuffer(url)) return url;
+  try {
+    const response = await axios.get(url, { responseType: 'arraybuffer', timeout: 4000 });
+    return Buffer.from(response.data, 'binary');
+  } catch (err) {
+    return null;
+  }
+}
+
+function truncateText(text, maxChars = 20) {
+  if (text.length <= maxChars) return text;
+  return text.slice(0, maxChars - 3).trim() + '...';
+}
+
+function wrapText(text, maxCharsPerLine = 22) {
+  if (!text) return [];
+  const words = text.split(' ');
+  const lines = [];
+  let currentLine = '';
+
+  for (const word of words) {
+    if ((currentLine + word).length > maxCharsPerLine) {
+      if (currentLine) lines.push(currentLine.trim());
+      currentLine = word + ' ';
+    } else {
+      currentLine += word + ' ';
+    }
+  }
+  if (currentLine) lines.push(currentLine.trim());
+  return lines;
+}
+
+const escapeXml = (unsafe) => (unsafe || "").replace(/[<>&'"]/g, c => {
+  switch (c) {
+      case '<': return '&lt;';
+      case '>': return '&gt;';
+      case '&': return '&amp;';
+      case '\'': return '&apos;';
+      case '"': return '&quot;';
+  }
+});
+
+
+async function drawCardSpotify({ bg, cover, title, artist }) {
+  const width = 320;
+  const height = 420;
+  const cardX = 20;
+  const cardY = 20;
+  const cardWidth = 280;
+  const cardHeight = 380;
+  const radius = 20;
+
+  let baseImageBuffer;
+  let bgColor = '#222222';
+
+  const coverBuffer = await loadImageFromURL(cover);
+  let dominantColor = bgColor;
+  if (coverBuffer) {
+     try {
+       const stats = await sharp(coverBuffer).stats();
+       const { r, g, b } = stats.dominant;
+       dominantColor = `rgb(${r}, ${g}, ${b})`;
+     } catch (e) { }
+  }
+
+  if (bg) {
+    const bgBuffer = await loadImageFromURL(bg);
+    if (bgBuffer) {
+      baseImageBuffer = await sharp(bgBuffer).resize(width, height, { fit: 'cover' }).toBuffer();
+    }
+  }
+  
+  if (!baseImageBuffer && coverBuffer) {
+      baseImageBuffer = await sharp({ create: { width, height, channels: 4, background: dominantColor } }).png().toBuffer();
+  }
+  
+  if (!baseImageBuffer) {
+      baseImageBuffer = await sharp({ create: { width, height, channels: 4, background: bgColor } }).png().toBuffer();
+  }
+
+  const composites = [];
+
+  const cardSvg = `<svg width="${width}" height="${height}">
+    <rect x="${cardX}" y="${cardY}" width="${cardWidth}" height="${cardHeight}" rx="${radius}" ry="${radius}" fill="rgba(0, 0, 0, 0.7)" />
+  </svg>`;
+  composites.push({ input: Buffer.from(cardSvg), top: 0, left: 0 });
+
+  if (coverBuffer) {
+    const resizedCover = await sharp(coverBuffer).resize(240, 240, { fit: 'cover' }).toBuffer();
+    composites.push({
+      input: resizedCover,
+      left: cardX + 20,
+      top: cardY + 20
+    });
+  }
+
+  let titleLines = wrapText(truncateText(title || "", 26), 20);
+  let artistLines = wrapText(truncateText(artist || ""), 28);
+  
+  let currentY = cardY + 282;
+  let textSvgStr = `<svg width="${width}" height="${height}">
+    <style> 
+      .t { font-family: sans-serif; font-weight: bold; font-size: 22px; fill: white; } 
+      .a { font-family: sans-serif; font-size: 16px; fill: rgba(255, 255, 255, 0.8); } 
+    </style>
+  `;
+
+  for (const line of titleLines) {
+      textSvgStr += `<text x="${cardX + 20}" y="${currentY}" class="t">${escapeXml(line)}</text>`;
+      currentY += 26;
+  }
+
+  currentY += 2;
+
+  for (const line of artistLines) {
+      textSvgStr += `<text x="${cardX + 20}" y="${currentY}" class="a">${escapeXml(line)}</text>`;
+      currentY += 20;
+  }
+
+  textSvgStr += `<text x="${cardX + 40}" y="${cardY + 370}" font-family="sans-serif" font-weight="bold" font-size="14px" fill="white">Spotify</text>
+  </svg>`;
+
+  composites.push({ input: Buffer.from(textSvgStr), top: 0, left: 0 });
+
+  const logoUrl = "https://storage.googleapis.com/pr-newsroom-wp/1/2023/05/Spotify_Primary_Logo_RGB_White-300x300.png";
+  const logoBuffer = await loadImageFromURL(logoUrl);
+  if (logoBuffer) {
+    const logoResized = await sharp(logoBuffer).resize(20, 20).toBuffer();
+    composites.push({ input: logoResized, top: cardY + 354, left: cardX + 14 });
+  }
+
+  const finalBuffer = await sharp(baseImageBuffer).composite(composites).png().toBuffer();
+
+  return finalBuffer;
+}
+
+module.exports = drawCardSpotify;

package/src/spotifydl.js

@@ -0,0 +1,25 @@
+const axios = require("axios");
+
+async function SpotifyDl(url) {
+  try {
+    const { data: pp } = await axios.post('https://gamepvz.com/api/download/get-url', {
+      url: url
+    }, {
+      'headers': {
+        'content-type': 'application/json',
+        'user-agent': 'Mozilla/5.0 (Linux; Android 16; NX729J) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.7499.34 Mobile Safari/537.36',
+      }
+    })
+    return {
+      status: true,
+      title: pp.title,
+      author: pp.authorName,
+      cover: pp.coverUrl,
+      dl: atob(pp.originalVideoUrl.split('url=')[1])
+    }
+  } catch(e) {
+    return { status: false }
+  }
+}
+
+module.exports = SpotifyDl;

package/src/tiktokdownload.js

@@ -0,0 +1,56 @@
+//credit: by Nazir
+
+async function tt(url) {
+    const html = await fetch(url, {
+        headers: {
+            authority: "www.tiktok.com",
+            "sec-ch-ua-mobile": "?1",
+            "sec-ch-ua-platform": `"Android"`,
+            "user-agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Mobile Safari/537.36"
+        }
+    }).then(a => a.text());
+    const match = html.match(/<script id="__UNIVERSAL_DATA_FOR_REHYDRATION__"[^>]*>([\s\S]*?)<\/script>/);
+    if (!match) return null;
+    const json = JSON.parse(match[1]);
+    const data = json.__DEFAULT_SCOPE__["webapp.reflow.video.detail"].itemInfo.itemStruct;
+    let download = data.imagePost
+        ? data.imagePost.images.reduce((acc, img) => {
+              return acc.concat(img.imageURL.urlList);
+          }, [])
+        : await fetch(`https://www.tiktok.com/player/api/v1/items?item_ids=${data.id}`)
+              .then(a => a.json())
+              .then(b => b.items[0].video_info.url_list[0]);
+    return {
+        id: data.id || data.aweme_id || null,
+        like: data.stats.diggCount || 0,
+        views: data.stats.playCount || data.play || 0,
+        share: data.stats.shareCount || 0,
+        comment: data.stats.commentCount || 0,
+        isVideo: data.imagePost ? false : true,
+        title: data.desc || data.suggestedWords?.[0] || "",
+        region: data.locationCreated || null,
+        duration: `${data.duration || data.music?.duration || 0} second`,
+        download: download,
+        author: {
+            id: data.author.id || "",
+            avatar: data.author?.avatarThumb,
+            nickname: data.author?.nickname || "",
+            username: data.author.uniqueId || "",
+            followers: data.author.followerCount || 0,
+            following: data.author.followingCount || 0,
+            like: data.author.heartCount || 0,
+            verified: data.author.verified,
+            videoCount: data.author.videoCount || 0
+        },
+        music: {
+            id: data.music?.id || null,
+            title: data.music?.title || "",
+            author: data.music?.authorName || "",
+            thumbnail: data.music?.coverLarge || data.music?.coverMedium || data.music?.coverThumb || null,
+            duration: data.music?.duration + " second" || "",
+            url: data.music?.playUrl || null
+        }
+    };
+}
+
+module.exports = tt;