indo-scraper 1.0.0

package/src/bmkg/cuaca.js

@@ -0,0 +1,34 @@
+const { fetchJSON, ok, fail } = require('../utils')
+
+/*
+ * Prakiraan cuaca kota populer
+ * @param {string} kota - jakarta | bandung | surabaya | medan | semarang | makassar | yogyakarta | palembang | denpasar | balikpapan
+ */
+const bmkgCuaca = async (kota = 'jakarta') => {
+  return new Promise(async (resolve) => {
+    try {
+      const KOTA = {
+        jakarta: '31.71.05.1001', bandung: '32.73.04.1002', surabaya: '35.78.27.1001',
+        medan: '12.71.01.1001', semarang: '33.74.01.1001', makassar: '73.71.01.1001',
+        yogyakarta: '34.71.01.1001', palembang: '16.71.01.1001',
+        denpasar: '51.71.01.1001', balikpapan: '64.72.01.1001',
+      }
+      const adm4 = KOTA[kota.toLowerCase()]
+      if (!adm4) return resolve(fail(`Kota tidak tersedia. Pilihan: ${Object.keys(KOTA).join(', ')}`))
+      const json   = await fetchJSON(`https://api.bmkg.go.id/publik/prakiraan-cuaca?adm4=${adm4}`)
+      const lokasi = json.data?.[0]?.lokasi || {}
+      const cuaca  = (json.data?.[0]?.cuaca || []).flat().map(i => ({
+        datetime: i.local_datetime, cuaca: i.weather_desc,
+        suhu: i.t, suhu_min: i.tmin, suhu_max: i.tmax,
+        kelembaban: i.hu, angin: i.ws, arah_angin: i.wd, icon: i.image,
+      }))
+      if (!cuaca.length) return resolve(fail('Data cuaca tidak ditemukan'))
+      resolve(ok({
+        lokasi: { kecamatan: lokasi.kecamatan, kotkab: lokasi.kotkab, provinsi: lokasi.provinsi },
+        prakiraan: cuaca,
+      }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+module.exports = { bmkgCuaca }

package/src/bmkg/gempa.js

@@ -0,0 +1,56 @@
+const { fetchJSON, ok, fail } = require('../utils')
+
+/* Gempa terbaru (1 data) */
+const bmkgGempa = async () => {
+  return new Promise(async (resolve) => {
+    try {
+      const json = await fetchJSON('https://data.bmkg.go.id/DataMKG/TEWS/autogempa.json')
+      const g = json.Infogempa.gempa
+      resolve(ok({
+        tanggal: g.Tanggal, jam: g.Jam, datetime: g.DateTime,
+        koordinat: g.Coordinates, lintang: g.Lintang, bujur: g.Bujur,
+        magnitude: g.Magnitude, kedalaman: g.Kedalaman,
+        wilayah: g.Wilayah, potensi: g.Potensi, dirasakan: g.Dirasakan,
+        shakemap: `https://data.bmkg.go.id/DataMKG/TEWS/${g.Shakemap}`,
+      }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+/* 15 gempa terkini */
+const bmkgGempaTerkini = async () => {
+  return new Promise(async (resolve) => {
+    try {
+      const json = await fetchJSON('https://data.bmkg.go.id/DataMKG/TEWS/gempaterkini.json')
+      const list = json.Infogempa.gempa
+      if (!list?.length) return resolve(fail('Data tidak ditemukan'))
+      resolve(ok(list.map(g => ({
+        tanggal: g.Tanggal, jam: g.Jam, datetime: g.DateTime,
+        koordinat: g.Coordinates, lintang: g.Lintang, bujur: g.Bujur,
+        magnitude: g.Magnitude, kedalaman: g.Kedalaman,
+        wilayah: g.Wilayah, potensi: g.Potensi,
+        shakemap: `https://data.bmkg.go.id/DataMKG/TEWS/${g.Shakemap}`,
+      }))))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+/* Gempa yang dirasakan */
+const bmkgGempaDirasakan = async () => {
+  return new Promise(async (resolve) => {
+    try {
+      const json = await fetchJSON('https://data.bmkg.go.id/DataMKG/TEWS/gempadirasakan.json')
+      const list = json.Infogempa.gempa
+      if (!list?.length) return resolve(fail('Data tidak ditemukan'))
+      resolve(ok(list.map(g => ({
+        tanggal: g.Tanggal, jam: g.Jam, datetime: g.DateTime,
+        koordinat: g.Coordinates, lintang: g.Lintang, bujur: g.Bujur,
+        magnitude: g.Magnitude, kedalaman: g.Kedalaman,
+        wilayah: g.Wilayah, dirasakan: g.Dirasakan, potensi: g.Potensi,
+        shakemap: `https://data.bmkg.go.id/DataMKG/TEWS/${g.Shakemap}`,
+      }))))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+module.exports = { bmkgGempa, bmkgGempaTerkini, bmkgGempaDirasakan }

package/src/downloader/facebook.js

@@ -0,0 +1,94 @@
+const { axios, cheerio, ok, fail } = require('../utils')
+
+const _getTitle = async (url) => {
+  try {
+    const res = await axios.get(url, { headers: { 'User-Agent': 'Mozilla/5.0 (Linux; Android 13)', 'Accept-Language': 'id-ID,id;q=0.9' }, timeout: 15000 })
+    const $ = cheerio.load(res.data)
+    return ($('meta[property="og:description"]').attr('content') ||
+            $('meta[name="description"]').attr('content') ||
+            $('meta[property="og:title"]').attr('content') ||
+            $('title').text() || '')
+      .replace(/\| Facebook.*$/i, '').replace(/&/g, '&').replace(/\s+/g, ' ').trim()
+  } catch (_) { return '' }
+}
+
+/*
+ * Facebook Video Downloader
+ * Source: fdown.net
+ * @param {string} url
+ */
+const facebook = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url) return resolve(fail('URL tidak boleh kosong'))
+      if (!url.includes('facebook.com') && !url.includes('fb.watch'))
+        return resolve(fail('URL Facebook tidak valid'))
+
+      const title = await _getTitle(url) || 'Facebook Video'
+
+      const res = await axios.post(
+        'https://fdown.net/download.php',
+        new URLSearchParams({ URLz: url }).toString(),
+        { headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'User-Agent': 'Mozilla/5.0 (Linux; Android 13)', 'Origin': 'https://fdown.net', 'Referer': 'https://fdown.net/' }, timeout: 20000 }
+      )
+
+      const $ = cheerio.load(res.data)
+      const thumbnail = $('.lib-item img').attr('src') || $('img').first().attr('src') || null
+      let sd = null, hd = null
+
+      $('a').each((_, el) => {
+        const href = $(el).attr('href')
+        const text = $(el).text().trim()
+        if (!href) return
+        if (text.includes('Download Video in HD Quality')) hd = href
+        if (text.includes('Download Video in Normal Quality')) sd = href
+      })
+
+      if (!sd) sd = res.data.match(/Download Video in Normal Quality.*?href="(.*?)"/s)?.[1] || null
+      if (!hd) hd = res.data.match(/Download Video in HD Quality.*?href="(.*?)"/s)?.[1] || null
+      if (!sd && !hd) return resolve(fail('Video tidak ditemukan atau private'))
+
+      resolve(ok({ title, thumbnail, sd, hd: hd || sd }))
+    } catch (e) { console.log(e); resolve(fail(e?.response?.status || e.message)) }
+  })
+}
+
+/*
+ * Facebook Photo Downloader
+ * Support: post photo, album, carousel, share link
+ * @param {string} url
+ */
+const facebookPhoto = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url) return resolve(fail('URL tidak boleh kosong'))
+      if (!url.includes('facebook.com') && !url.includes('fb.watch'))
+        return resolve(fail('URL Facebook tidak valid'))
+
+      const res = await axios.get(url, { headers: { 'User-Agent': 'Mozilla/5.0 (Linux; Android 13)', 'Accept-Language': 'id-ID,id;q=0.9' }, timeout: 20000 })
+      const $ = cheerio.load(res.data)
+
+      const title = ($('meta[property="og:description"]').attr('content') ||
+                    $('meta[name="description"]').attr('content') ||
+                    $('meta[property="og:title"]').attr('content') || 'Facebook Photo')
+        .replace(/\| Facebook.*$/i, '').replace(/&/g, '&').replace(/\s+/g, ' ').trim()
+
+      const medias = []
+      const og = $('meta[property="og:image"]').attr('content')
+      if (og) medias.push(og)
+
+      const matches = res.data.match(/https:\/\/scontent.*?\.(jpg|png|jpeg).*?(?=")/g) || []
+      for (let img of matches) {
+        img = img.replace(/\\\//g, '/').replace(/\\u0025/g, '%')
+        medias.push(img)
+      }
+
+      const clean = [...new Set(medias)]
+      if (!clean.length) return resolve(fail('Foto tidak ditemukan'))
+
+      resolve(ok({ title, total: clean.length, medias: clean.map(v => ({ type: 'image', url: v })) }))
+    } catch (e) { console.log(e); resolve(fail(e?.response?.status || e.message)) }
+  })
+}
+
+module.exports = { facebook, facebookPhoto }

package/src/downloader/gdrive.js

@@ -0,0 +1,38 @@
+const { axios, ok, fail } = require('../utils')
+
+const _formatBytes = (bytes) => {
+  if (!bytes) return null
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
+  const i = Math.floor(Math.log(bytes) / Math.log(1024))
+  return (bytes / Math.pow(1024, i)).toFixed(2) + ' ' + sizes[i]
+}
+
+/*
+ * Google Drive Downloader
+ * @param {string} url
+ */
+const gdrive = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url || !url.includes('drive.google.com'))
+        return resolve(fail('URL Google Drive tidak valid'))
+
+      const id = url.match(/\/d\/(.*?)\//)?.[1] || url.match(/[?&]id=([^&]+)/)?.[1] || null
+      if (!id) return resolve(fail('File ID tidak ditemukan'))
+
+      const preview = `https://drive.google.com/file/d/${id}/view`
+      const direct  = `https://drive.google.com/uc?export=download&id=${id}`
+
+      const page = await axios.get(preview, { headers: { 'User-Agent': 'Mozilla/5.0' }, timeout: 15000 })
+      const filename = page.data.match(/<title>(.*?) - Google Drive<\/title>/)?.[1] || 'unknown'
+
+      const head = await axios({ url: direct, method: 'GET', maxRedirects: 5, responseType: 'stream', headers: { 'User-Agent': 'Mozilla/5.0' } })
+      const filesize = _formatBytes(Number(head.headers['content-length']) || 0)
+      const mimetype = head.headers['content-type'] || 'unknown'
+
+      resolve(ok({ id, filename, filesize, mimetype, direct, preview }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+module.exports = { gdrive }

package/src/downloader/instagram.js

@@ -0,0 +1,62 @@
+const { cheerio, ok, fail } = require('../utils')
+const vm = require('vm')
+
+/*
+ * Instagram Downloader — foto, video, reels, carousel
+ * Sumber: snapsave.app
+ * @param {string} url - URL post/reel Instagram
+ */
+const instagram = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url || !url.includes('instagram.com'))
+        return resolve(fail('URL Instagram tidak valid'))
+
+      const axios = require('axios')
+      const res = await axios.post(
+        'https://snapsave.app/action.php?lang=id',
+        'url=' + encodeURIComponent(url),
+        {
+          headers: {
+            'User-Agent': 'Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.6367.82 Mobile Safari/537.36',
+            'Referer': 'https://snapsave.app/id/download-video-instagram',
+            'Origin': 'https://snapsave.app',
+            'Content-Type': 'application/x-www-form-urlencoded',
+          },
+          timeout: 15000,
+        }
+      )
+
+      // Decode obfuscated JS
+      let decoded = ''
+      const sandbox = {
+        decodeURIComponent, escape, unescape, String, Math,
+        window: { location: { hostname: 'snapsave.app' } },
+        document: { getElementById: () => ({ set innerHTML(v) { decoded = v } }) },
+        eval: (s) => { decoded = s; return s },
+      }
+      try { vm.runInNewContext(res.data, sandbox) } catch (_) {}
+
+      if (!decoded) return resolve(fail('Gagal decode response'))
+
+      // Unescape escaped quotes dari dalam JS string
+      decoded = decoded.replace(/\\"/g, '"').replace(/\\'/g, "'")
+
+      const $ = cheerio.load(decoded)
+      const medias = []
+
+      $('.download-items').each((_, el) => {
+        const thumb  = $(el).find('img').attr('src') || null
+        const dlUrl  = $(el).find('a[href*="rapidcdn"]').attr('href') || null
+        const isVideo = $(el).find('i[class*="dlvideo"]').length > 0
+        if (dlUrl) medias.push({ type: isVideo ? 'video' : 'image', url: dlUrl, thumbnail: thumb })
+      })
+
+      if (!medias.length) return resolve(fail('Media tidak ditemukan'))
+
+      resolve(ok({ url, medias }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+module.exports = { instagram }

package/src/downloader/mediafire.js

@@ -0,0 +1,30 @@
+const { fetchHTML, cheerio, ok, fail } = require('../utils')
+
+/*
+ * MediaFire Downloader
+ * @param {string} url - URL MediaFire
+ */
+const mediafire = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url || !url.includes('mediafire.com'))
+        return resolve(fail('URL MediaFire tidak valid'))
+
+      const html = await fetchHTML(url, { Referer: 'https://www.mediafire.com/' })
+      const $ = cheerio.load(html)
+
+      const download = $('#downloadButton').attr('href')
+      if (!download) return resolve(fail('Link download tidak ditemukan'))
+
+      const filename = $('.dl-btn-label').attr('title') ||
+                       $('meta[property="og:title"]').attr('content') ||
+                       download.split('/').pop()
+      const filesize = $('#downloadButton').text().replace(/Download/i, '').replace(/\s+/g, ' ').trim()
+      const filetype = filename.split('.').pop() || 'unknown'
+
+      resolve(ok({ url, filename, filesize, filetype, download }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+module.exports = { mediafire }

package/src/downloader/spotify.js

@@ -0,0 +1,262 @@
+const { axios, fetchHTML, ok, fail } = require('../utils')
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.6367.82 Mobile Safari/537.36',
+  'Accept-Language': 'id-ID,id;q=0.9',
+}
+
+const _id = (url, type) => url.match(new RegExp(`spotify\\.com\\/${type}\\/([a-zA-Z0-9]+)`))?.[1] || null
+
+const _state = (html) => {
+  try {
+    const m = html.match(/<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/)
+    if (m) return JSON.parse(m[1])
+  } catch (_) {}
+  return null
+}
+
+const _cover = (entity) => {
+  const imgs = entity?.visualIdentity?.image || entity?.coverArt?.sources || entity?.images || []
+  if (!imgs.length) return null
+  return imgs.sort((a, b) => (b.maxWidth || b.width || 0) - (a.maxWidth || a.width || 0))[0]?.url || null
+}
+
+const _duration = (ms) => {
+  if (!ms || isNaN(ms)) return null
+  const m = Math.floor(ms / 60000)
+  const s = Math.floor((ms % 60000) / 1000).toString().padStart(2, '0')
+  return `${m}:${s}`
+}
+
+// Ambil anonymous access token dari Spotify web player
+const _getToken = async () => {
+  const res = await axios.get('https://open.spotify.com/get_access_token?reason=transport&productType=web_player', {
+    headers: { ...HEADERS, 'Referer': 'https://open.spotify.com/' },
+    timeout: 10000,
+  })
+  return res.data?.accessToken || null
+}
+
+// Cari video YouTube pertama dari query
+const _ytSearch = async (query) => {
+  const html = await fetchHTML(
+    `https://www.youtube.com/results?search_query=${encodeURIComponent(query)}`,
+    { 'User-Agent': HEADERS['User-Agent'], 'Accept-Language': 'en-US,en;q=0.9' }
+  )
+  const m = html.match(/var ytInitialData\s*=\s*({[\s\S]*?});<\/script>/)
+  if (!m) return null
+  try {
+    const data     = JSON.parse(m[1])
+    const sections = data?.contents?.twoColumnSearchResultsRenderer
+                       ?.primaryContents?.sectionListRenderer?.contents || []
+    for (const sec of sections) {
+      for (const item of sec?.itemSectionRenderer?.contents || []) {
+        if (item?.videoRenderer?.videoId) return item.videoRenderer.videoId
+      }
+    }
+  } catch (_) {}
+  return null
+}
+
+// Download audio via cobalt → fallback yt1s
+const _ytDownload = async (videoId) => {
+  const ytUrl = `https://www.youtube.com/watch?v=${videoId}`
+  // Cobalt
+  try {
+    const res = await axios.post('https://co.wuk.sh/api/json',
+      { url: ytUrl, isAudioOnly: true, aFormat: 'mp3', filenamePattern: 'basic' },
+      { headers: { ...HEADERS, 'Accept': 'application/json', 'Content-Type': 'application/json' }, timeout: 20000 }
+    )
+    if (res.data?.url) return { url: res.data.url, source: 'cobalt' }
+  } catch (_) {}
+  // yt1s fallback
+  try {
+    const page = await axios.post('https://yt1s.com/api/ajaxSearch',
+      new URLSearchParams({ q: ytUrl, vt: 'home' }).toString(),
+      { headers: { ...HEADERS, 'Content-Type': 'application/x-www-form-urlencoded', 'Referer': 'https://yt1s.com/' }, timeout: 15000 }
+    )
+    const kId = page.data?.kId
+    const bid  = Object.keys(page.data?.links?.mp3 || {})[0]
+    if (kId && bid) {
+      const conv = await axios.post('https://yt1s.com/api/ajaxConvert',
+        new URLSearchParams({ vid: videoId, k: bid }).toString(),
+        { headers: { ...HEADERS, 'Content-Type': 'application/x-www-form-urlencoded', 'Referer': 'https://yt1s.com/' }, timeout: 20000 }
+      )
+      if (conv.data?.dlink) return { url: conv.data.dlink, source: 'yt1s' }
+    }
+  } catch (_) {}
+  return null
+}
+
+/*
+ * Spotify Search Track
+ * @param {string} query
+ * @param {number} limit
+ */
+const spotifySearch = async (query, limit = 10) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!query) return resolve(fail('Query tidak boleh kosong'))
+
+      const token = await _getToken()
+      if (!token) return resolve(fail('Gagal mendapatkan token Spotify'))
+
+      const res = await axios.get(`https://api.spotify.com/v1/search?q=${encodeURIComponent(query)}&type=track&limit=${limit}`, {
+        headers: { ...HEADERS, 'Authorization': `Bearer ${token}` },
+        timeout: 15000,
+      })
+
+      const items = res.data?.tracks?.items || []
+      if (!items.length) return resolve(fail('Tidak ada hasil'))
+
+      resolve(ok(items.map(t => ({
+        id:       t.id,
+        title:    t.name,
+        artist:   t.artists?.map(a => a.name).join(', ') || null,
+        album:    t.album?.name || null,
+        release:  t.album?.release_date || null,
+        duration: _duration(t.duration_ms),
+        cover:    t.album?.images?.[0]?.url || null,
+        preview:  t.preview_url || null,
+        url:      t.external_urls?.spotify || `https://open.spotify.com/track/${t.id}`,
+      }))))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+/*
+ * Spotify Track Info + Preview URL (30 detik)
+ * @param {string} url - URL track Spotify
+ */
+const spotifyTrack = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url || !url.includes('spotify.com'))
+        return resolve(fail('URL Spotify tidak valid'))
+
+      const id = _id(url, 'track')
+      if (!id) return resolve(fail('Track ID tidak ditemukan'))
+
+      const html   = await fetchHTML(`https://open.spotify.com/embed/track/${id}`, HEADERS)
+      const entity = _state(html)?.props?.pageProps?.state?.data?.entity
+      if (!entity) return resolve(fail('Data track tidak ditemukan'))
+
+      resolve(ok({
+        id,
+        title:    entity.name || entity.title || null,
+        artist:   (entity.artists || []).map(a => a.name).join(', ') || null,
+        release:  entity.releaseDate?.isoString?.slice(0, 10) || null,
+        duration: _duration(entity.duration),
+        cover:    _cover(entity),
+        preview:  entity.audioPreview?.url || null,
+        url:      `https://open.spotify.com/track/${id}`,
+      }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+/*
+ * Spotify Download — cari di YouTube lalu download audio
+ * @param {string} url - URL track Spotify
+ */
+const spotifyDownload = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      const track = await spotifyTrack(url)
+      if (!track.status) return resolve(track)
+
+      const { title, artist } = track.data
+      const query = `${title} ${artist} audio`
+
+      const ytId = await _ytSearch(query)
+      if (!ytId) return resolve(fail('Video YouTube tidak ditemukan'))
+
+      const dl = await _ytDownload(ytId)
+
+      resolve(ok({
+        ...track.data,
+        youtube_id:  ytId,
+        youtube_url: `https://www.youtube.com/watch?v=${ytId}`,
+        download:    dl?.url    || null,
+        dl_source:   dl?.source || null,
+      }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+/*
+ * Spotify Album Info + list track (ringan)
+ * @param {string} url - URL album Spotify
+ */
+const spotifyAlbum = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url || !url.includes('spotify.com'))
+        return resolve(fail('URL Spotify tidak valid'))
+
+      const id = _id(url, 'album')
+      if (!id) return resolve(fail('Album ID tidak ditemukan'))
+
+      const html   = await fetchHTML(`https://open.spotify.com/embed/album/${id}`, HEADERS)
+      const entity = _state(html)?.props?.pageProps?.state?.data?.entity
+      if (!entity) return resolve(fail('Data album tidak ditemukan'))
+
+      const tracks = (entity.tracks?.items || []).map(t => ({
+        id:       t.track?.id   || t.uid  || null,
+        title:    t.track?.name || t.name || null,
+        artist:   (t.track?.artists || t.artists || []).map(a => a.name).join(', '),
+        duration: _duration(t.track?.duration?.totalMilliseconds || t.track?.duration || t.duration),
+      }))
+
+      resolve(ok({
+        id,
+        title:       entity.name || null,
+        artist:      (entity.artists || []).map(a => a.name).join(', ') || null,
+        release:     entity.date?.isoString?.slice(0, 10) || entity.releaseDate?.isoString?.slice(0, 10) || null,
+        total_track: entity.tracks?.totalCount || tracks.length,
+        cover:       _cover(entity),
+        tracks,
+        url: `https://open.spotify.com/album/${id}`,
+      }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+/*
+ * Spotify Playlist Info + list track (ringan)
+ * @param {string} url - URL playlist Spotify
+ */
+const spotifyPlaylist = async (url) => {
+  return new Promise(async (resolve) => {
+    try {
+      if (!url || !url.includes('spotify.com'))
+        return resolve(fail('URL Spotify tidak valid'))
+
+      const id = _id(url, 'playlist')
+      if (!id) return resolve(fail('Playlist ID tidak ditemukan'))
+
+      const html   = await fetchHTML(`https://open.spotify.com/embed/playlist/${id}`, HEADERS)
+      const entity = _state(html)?.props?.pageProps?.state?.data?.entity
+      if (!entity) return resolve(fail('Data playlist tidak ditemukan'))
+
+      const tracks = (entity.trackList || entity.tracks?.items || []).map(t => ({
+        id:     t.uid || t.track?.id || null,
+        title:  t.track?.name || t.name || null,
+        artist: (t.track?.artists || t.artists || []).map(a => a.name).join(', '),
+      }))
+
+      resolve(ok({
+        id,
+        title:       entity.name || null,
+        owner:       entity.ownerV2?.data?.name || null,
+        description: entity.description || null,
+        total_track: entity.tracks?.totalCount || tracks.length,
+        cover:       _cover(entity),
+        tracks,
+        url: `https://open.spotify.com/playlist/${id}`,
+      }))
+    } catch (e) { console.log(e); resolve(fail(e)) }
+  })
+}
+
+module.exports = { spotifySearch, spotifyTrack, spotifyDownload, spotifyAlbum, spotifyPlaylist }