@soyaxell09/zenbot-scraper 1.0.0

package/src/scrapers/youtube.js

@@ -0,0 +1,190 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+import ytdl from '@distube/ytdl-core'
+
+const INNERTUBE_URL = 'https://www.youtube.com/youtubei/v1'
+let _config = null
+
+async function getConfig() {
+  if (_config) return _config
+  const res = await axios.get('https://www.youtube.com/', {
+    headers: {
+      'User-Agent':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Accept':          'text/html,application/xhtml+xml',
+    },
+    timeout: 15000,
+  })
+  const html          = res.data
+  const key           = html.match(/"INNERTUBE_API_KEY"\s*:\s*"([^"]+)"/)?.[1] || 'AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM394'
+  const visitorData   = html.match(/"visitorData"\s*:\s*"([^"]+)"/)?.[1] || ''
+  const clientVersion = html.match(/"clientVersion"\s*:\s*"([^"]+)"/)?.[1] || '2.20240101.00.00'
+  _config = { key, visitorData, clientVersion }
+  return _config
+}
+
+function parseVideoId(url) {
+  const patterns = [
+    /(?:v=|youtu\.be\/|shorts\/)([a-zA-Z0-9_-]{11})/,
+    /^([a-zA-Z0-9_-]{11})$/,
+  ]
+  for (const p of patterns) {
+    const m = url.match(p)
+    if (m) return m[1]
+  }
+  return null
+}
+
+export async function ytInfo(url) {
+  const id = parseVideoId(url)
+  if (!id) throw new Error('URL/ID de YouTube inválido')
+
+  const info = await ytdl.getInfo(`https://www.youtube.com/watch?v=${id}`)
+  const vd   = info.videoDetails
+  const formats = info.formats
+    .filter(f => f.url)
+    .map(f => ({
+      itag:      f.itag,
+      url:       f.url,
+      mimeType:  f.mimeType || '',
+      quality:   f.qualityLabel || f.quality || '',
+      bitrate:   f.bitrate || f.averageBitrate || 0,
+      width:     f.width  || 0,
+      height:    f.height || 0,
+      fps:       f.fps    || 0,
+      hasVideo:  !!f.hasVideo,
+      hasAudio:  !!f.hasAudio,
+      container: f.container || '',
+      codecs:    f.codecs   || '',
+    }))
+
+  return {
+    id,
+    title:       vd.title || '',
+    author:      vd.author?.name || vd.ownerChannelName || '',
+    channelId:   vd.channelId || '',
+    duration:    Number(vd.lengthSeconds || 0),
+    views:       Number(vd.viewCount || 0),
+    thumbnail:   vd.thumbnails?.at(-1)?.url || '',
+    description: vd.description?.slice(0, 300) || '',
+    isLive:      vd.isLiveContent || false,
+    formats,
+  }
+}
+
+export async function ytDownload(url, type = 'video', quality = '360') {
+  const id   = parseVideoId(url)
+  if (!id) throw new Error('URL de YouTube inválida')
+
+  const info    = await ytInfo(id)
+  const formats = info.formats
+
+  if (type === 'mp3' || type === 'audio') {
+    const audioFormats = formats
+      .filter(f => f.hasAudio && !f.hasVideo)
+      .sort((a, b) => b.bitrate - a.bitrate)
+    if (!audioFormats.length) throw new Error('Sin formatos de audio disponibles')
+    const best = audioFormats[0]
+    return {
+      type:      'audio',
+      url:       best.url,
+      mimeType:  best.mimeType,
+      bitrate:   best.bitrate,
+      duration:  info.duration,
+      title:     info.title,
+      author:    info.author,
+      thumbnail: info.thumbnail,
+    }
+  }
+
+  const q            = parseInt(quality)
+  const videoFormats = formats
+    .filter(f => f.hasVideo && f.hasAudio)
+    .sort((a, b) => b.height - a.height)
+
+  if (!videoFormats.length) {
+    const videoOnly = formats
+      .filter(f => f.hasVideo && !f.hasAudio)
+      .sort((a, b) => b.height - a.height)
+    if (!videoOnly.length) throw new Error('Sin formatos de video disponibles')
+    const best = videoOnly.find(f => f.height <= q) || videoOnly[0]
+    return {
+      type: 'video', url: best.url, mimeType: best.mimeType,
+      quality: best.quality, width: best.width, height: best.height,
+      fps: best.fps, title: info.title, author: info.author,
+      thumbnail: info.thumbnail, duration: info.duration,
+      note: 'solo_video_sin_audio',
+    }
+  }
+
+  const best = videoFormats.find(f => f.height <= q) || videoFormats[0]
+  return {
+    type: 'video', url: best.url, mimeType: best.mimeType,
+    quality: best.quality, width: best.width, height: best.height,
+    fps: best.fps, title: info.title, author: info.author,
+    thumbnail: info.thumbnail, duration: info.duration,
+  }
+}
+
+export async function ytSearch(query, limit = 5) {
+  const cfg = await getConfig()
+  const res = await axios.post(
+    `${INNERTUBE_URL}/search?key=${cfg.key}&prettyPrint=false`,
+    {
+      query,
+      context: {
+        client: {
+          clientName:    'WEB',
+          clientVersion: cfg.clientVersion,
+          hl: 'en', gl: 'US',
+          visitorData:   cfg.visitorData,
+        },
+      },
+    },
+    {
+      headers: {
+        'User-Agent':              'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+        'X-YouTube-Client-Name':   '1',
+        'X-YouTube-Client-Version': cfg.clientVersion,
+        'Content-Type':            'application/json',
+        'X-Goog-Visitor-Id':       cfg.visitorData,
+      },
+      timeout: 15000,
+    }
+  )
+
+  const contents =
+    res.data?.contents
+      ?.twoColumnSearchResultsRenderer
+      ?.primaryContents
+      ?.sectionListRenderer
+      ?.contents?.[0]
+      ?.itemSectionRenderer
+      ?.contents || []
+
+  const results = []
+  for (const item of contents) {
+    if (results.length >= limit) break
+    const v = item?.videoRenderer
+    if (!v?.videoId) continue
+    results.push({
+      id:        v.videoId,
+      title:     v.title?.runs?.[0]?.text || '',
+      url:       `https://www.youtube.com/watch?v=${v.videoId}`,
+      thumbnail: v.thumbnail?.thumbnails?.at(-1)?.url || '',
+      duration:  v.lengthText?.simpleText || '',
+      views:     v.viewCountText?.simpleText || '',
+      channel:   v.ownerText?.runs?.[0]?.text || '',
+      published: v.publishedTimeText?.simpleText || '',
+    })
+  }
+
+  if (!results.length) throw new Error('Sin resultados')
+  return results
+}

package/src/scrapers/youtubev2.js

@@ -0,0 +1,131 @@
+// Créditos a FG-error
+import axios from 'axios'
+
+const delay = ms => new Promise(r => setTimeout(r, ms))
+
+function parseFileSize(size) {
+  if (!size) return 0
+  const units = { B: 1, KB: 1024, MB: 1024 ** 2, GB: 1024 ** 3, TB: 1024 ** 4 }
+  const match = size.toString().trim().match(/([\d.]+)\s*(B|KB|MB|GB|TB)/i)
+  if (!match) return 0
+  return Math.round(parseFloat(match[1]) * (units[match[2].toUpperCase()] || 1))
+}
+
+function formatFileSize(bytes) {
+  if (!bytes || isNaN(bytes)) return '0 B'
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  let i = 0
+  while (bytes >= 1024 && i < units.length - 1) { bytes /= 1024; i++ }
+  return `${bytes.toFixed(1).replace(/\.0$/, '')} ${units[i]}`
+}
+
+export async function getFileSizeV2(url) {
+  try {
+    const res   = await axios.head(url, { timeout: 10000 })
+    const bytes = parseInt(res.headers['content-length'] || 0)
+    return formatFileSize(bytes)
+  } catch { return '0 B' }
+}
+
+function normalizeYT(url) {
+  try {
+    const u = new URL(url)
+    if (u.hostname.includes('youtu.be')) return url
+    if (u.hostname.includes('youtube.com')) {
+      if (u.pathname.includes('/watch'))   return `https://youtu.be/${u.searchParams.get('v')}`
+      if (u.pathname.includes('/shorts/')) return `https://youtu.be/${u.pathname.split('/shorts/')[1]}`
+      if (u.pathname.includes('/embed/'))  return `https://youtu.be/${u.pathname.split('/embed/')[1]}`
+    }
+    return url
+  } catch { return url }
+}
+
+async function waitForDownload(mediaUrl) {
+  for (let i = 0; i < 15; i++) {
+    try {
+      const { data } = await axios.get(mediaUrl, { timeout: 15000 })
+      if (data?.percent === 'Completed' && data?.fileUrl && data.fileUrl !== 'In Processing...')
+        return data.fileUrl
+    } catch {}
+    await delay(4000)
+  }
+  throw new Error('No se pudo generar el enlace de descarga')
+}
+
+async function fetchYtdownto(url) {
+  const { data } = await axios.post(
+    'https://app.ytdown.to/proxy.php',
+    new URLSearchParams({ url }).toString(),
+    {
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      timeout: 20000,
+    }
+  )
+  const api = data?.api
+  if (!api)                   throw new Error('No se pudo obtener información del video')
+  if (api.status === 'ERROR') throw new Error(api.message)
+
+  const qualities = (api.mediaItems || []).map((v, i) => {
+    const match = v?.mediaUrl?.match(/(\d+)p|(\d+)k/)
+    const res   = match ? match[0] : v.mediaQuality
+    return {
+      id:       i + 1,
+      type:     v.type,
+      quality:  res,
+      label:    `${v.mediaExtension?.toUpperCase()} - ${v.mediaQuality}`,
+      size:     v.mediaFileSize,
+      sizeB:    parseFileSize(v.mediaFileSize),
+      mediaUrl: v.mediaUrl,
+      duration: v.mediaDuration,
+    }
+  })
+
+  return { api, qualities }
+}
+
+export async function ytDownloadV2(url, type = 'video', quality = '360p') {
+  url = normalizeYT(url)
+
+  const { api, qualities } = await fetchYtdownto(url)
+
+  const isAudio  = type === 'mp3' || type === 'audio'
+  const targetQ  = quality.toLowerCase()
+
+  const filtered = isAudio
+    ? qualities.filter(v => v.type === 'audio' || v.quality?.includes('k'))
+    : qualities.filter(v => v.type === 'video' || v.quality?.includes('p'))
+
+  const selected = filtered.find(v => v.quality?.toLowerCase() === targetQ) || filtered[0]
+
+  if (!selected) {
+    const disponibles = qualities.map(v => v.quality).filter(Boolean).join(', ')
+    throw new Error(`Calidad ${quality} no disponible. Disponibles: ${disponibles}`)
+  }
+
+  const dlUrl = await waitForDownload(selected.mediaUrl)
+
+  return {
+    title:    api.title,
+    uploader: api.userInfo?.name || '',
+    views:    api.mediaStats?.viewsCount || '',
+    thumb:    api.imagePreviewUrl || '',
+    type:     isAudio ? 'audio' : 'video',
+    quality:  selected.quality,
+    size:     selected.size,
+    sizeB:    selected.sizeB,
+    duration: selected.duration,
+    url:      dlUrl,
+  }
+}
+
+export async function ytInfoV2(url) {
+  url = normalizeYT(url)
+  const { api, qualities } = await fetchYtdownto(url)
+  return {
+    title:    api.title,
+    uploader: api.userInfo?.name || '',
+    views:    api.mediaStats?.viewsCount || '',
+    thumb:    api.imagePreviewUrl || '',
+    qualities,
+  }
+}

package/src/search/giphy.js

@@ -0,0 +1,36 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+}
+
+const TENOR_KEY = 'AIzaSyAyimkuYQYF_FXVALexPuGQctUWRURdCYQ'
+
+export async function giphy(query, limit = 5, type = 'search') {
+  const endpoint = type === 'trending'
+    ? `https://tenor.googleapis.com/v2/featured?key=${TENOR_KEY}&limit=${limit}&media_filter=gif`
+    : `https://tenor.googleapis.com/v2/search?q=${encodeURIComponent(query)}&key=${TENOR_KEY}&limit=${limit}&media_filter=gif`
+
+  const res  = await axios.get(endpoint, { headers: HEADERS, timeout: 15000 })
+  const data = res.data?.results || []
+
+  if (!data.length) throw new Error('Sin resultados en Tenor')
+
+  return data.map(g => ({
+    id:      g.id,
+    title:   g.title || g.content_description || '',
+    url:     g.itemurl || '',
+    gif:     g.media_formats?.gif?.url     || g.media_formats?.mediumgif?.url || '',
+    preview: g.media_formats?.nanogif?.url || g.media_formats?.tinygif?.url  || '',
+    mp4:     g.media_formats?.mp4?.url     || g.media_formats?.loopedmp4?.url || '',
+    width:   g.media_formats?.gif?.dims?.[0] || 0,
+    height:  g.media_formats?.gif?.dims?.[1] || 0,
+  }))
+}

package/src/search/google.js

@@ -0,0 +1,55 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+}
+
+export async function googleSearch(query, limit = 5) {
+  const res = await axios.get(
+    `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&skip_disambig=1`,
+    { headers: HEADERS, timeout: 15000 }
+  )
+
+  const data    = res.data
+  const results = []
+
+  if (data?.AbstractText && data?.AbstractURL) {
+    results.push({
+      title:   data.Heading || query,
+      url:     data.AbstractURL,
+      snippet: data.AbstractText,
+    })
+  }
+
+  for (const item of (data?.RelatedTopics || [])) {
+    if (results.length >= limit) break
+    if (item?.Topics) {
+      for (const sub of item.Topics) {
+        if (results.length >= limit) break
+        if (sub?.FirstURL && sub?.Text) {
+          results.push({
+            title:   sub.Text.split(' - ')[0] || sub.Text.slice(0, 60),
+            url:     sub.FirstURL,
+            snippet: sub.Text,
+          })
+        }
+      }
+    } else if (item?.FirstURL && item?.Text) {
+      results.push({
+        title:   item.Text.split(' - ')[0] || item.Text.slice(0, 60),
+        url:     item.FirstURL,
+        snippet: item.Text,
+      })
+    }
+  }
+
+  if (!results.length) throw new Error('Sin resultados')
+  return results.slice(0, limit)
+}

package/src/search/index.js

@@ -0,0 +1,12 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+export { ytSearch }                  from './youtube.js'
+export { googleSearch }              from './google.js'
+export { spotify }                   from './spotify.js'
+export { giphy }                     from './giphy.js'
+export { pinsearch, pinimg, pinvid } from './pinterest.js'

package/src/search/pinterest.js

@@ -0,0 +1,162 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+import * as cheerio from 'cheerio'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Linux; Android 10; SM-G975F) AppleWebKit/537.36 Chrome/120.0.0.0 Mobile Safari/537.36',
+  'Accept-Language': 'en-US,en;q=0.9',
+}
+
+function toOriginal(src) {
+  return src.replace(/\/\d+x\//, '/originals/').replace(/\/\d+x\d+\//, '/originals/')
+}
+
+function isValidPin(src) {
+  return (
+    src.includes('i.pinimg.com') &&
+    /\.(jpg|jpeg|png|webp)/.test(src) &&
+    !src.includes('/60x60/') &&
+    !src.includes('/videos/thumbnails/')
+  )
+}
+
+function extractVidsFromHtml(html, limit) {
+  const seen = new Set()
+  const vids = []
+  const RE   = /https:\/\/v\d+\.pinimg\.com\/videos\/[^\s"'\\]+\.mp4/g
+  for (const m of html.matchAll(RE)) {
+    const original = m[0]
+    if (seen.has(original)) continue
+    seen.add(original)
+    const hd = original.replace(/\/\d+p\//, '/720p/')
+    const sd = original.replace(/\/\d+p\//, '/480p/')
+    vids.push({ video: hd, sd, original })
+    if (vids.length >= limit) break
+  }
+  return vids
+}
+
+export async function pinvid(input, limit = 5) {
+  if (input.includes('pinterest.com/pin/') || input.includes('pin.it/')) {
+    let resolvedUrl = input
+    if (input.includes('pin.it/')) {
+      const r = await axios.get(input, { headers: HEADERS, maxRedirects: 5, timeout: 10000 })
+      resolvedUrl = r.request?.res?.responseUrl || r.config?.url || input
+    }
+    const res  = await axios.get(resolvedUrl, { headers: HEADERS, timeout: 15000 })
+    const vids = extractVidsFromHtml(res.data, limit)
+    if (!vids.length) throw new Error('Este pin no tiene video')
+    return vids.map((v, i) => ({ index: i + 1, ...v }))
+  }
+
+  const res  = await axios.get(
+    `https://www.pinterest.com/search/pins/?q=${encodeURIComponent(input + ' video')}`,
+    { headers: HEADERS, timeout: 15000 }
+  )
+  const vids = extractVidsFromHtml(res.data, limit)
+  if (!vids.length) throw new Error('Sin videos en Pinterest')
+  return vids.map((v, i) => ({ index: i + 1, ...v }))
+}
+
+export async function pinsearch(query, limit = 10) {
+  const res = await axios.get(
+    `https://www.pinterest.com/search/pins/?q=${encodeURIComponent(query)}`,
+    { headers: HEADERS, timeout: 15000 }
+  )
+  const $    = cheerio.load(res.data)
+  const seen = new Set()
+  const imgs = []
+
+  $('img').each((_, el) => {
+    const src    = $(el).attr('src') || ''
+    const srcset = $(el).attr('srcset') || ''
+    const sources = [src, ...srcset.split(',').map(s => s.trim().split(' ')[0])]
+    for (const s of sources) {
+      if (!isValidPin(s)) continue
+      const high = toOriginal(s)
+      if (!seen.has(high)) { seen.add(high); imgs.push(high) }
+    }
+  })
+
+  $('[style]').each((_, el) => {
+    const style = $(el).attr('style') || ''
+    const m     = style.match(/url\(['"]?(https:\/\/i\.pinimg\.com[^'")\s]+)['"]?\)/)
+    if (m && isValidPin(m[1])) {
+      const high = toOriginal(m[1])
+      if (!seen.has(high)) { seen.add(high); imgs.push(high) }
+    }
+  })
+
+  const result = imgs.slice(0, limit)
+  if (!result.length) throw new Error('Sin resultados en Pinterest')
+  return result.map((url, i) => ({ index: i + 1, image: url, url }))
+}
+
+export async function pinimg(input, limit = 5) {
+  if (!input.includes('pinterest.com/pin/') && !input.includes('pin.it/')) {
+    return pinsearch(input, limit)
+  }
+
+  let resolvedUrl = input
+  if (input.includes('pin.it/')) {
+    const r = await axios.get(input, { headers: HEADERS, maxRedirects: 5, timeout: 10000 })
+    resolvedUrl = r.request?.res?.responseUrl || r.config?.url || input
+  }
+  const url = resolvedUrl
+
+  const res  = await axios.get(url, { headers: HEADERS, timeout: 15000 })
+  const html = res.data
+  const $    = cheerio.load(html)
+  const seen = new Set()
+  const imgs = []
+
+  const jsonMatch = html.match(/"orig"\s*:\s*\{"url"\s*:\s*"([^"]+)"/)
+  if (jsonMatch) {
+    const u = jsonMatch[1].replace(/\\u002F/g, '/').replace(/\\\//g, '/')
+    if (u.includes('i.pinimg.com')) { seen.add(u); imgs.push(u) }
+  }
+
+  const PIN_IMG_RE = /"url"\s*:\s*"(https:\\?\/\\?\/i\.pinimg\.com[^"]+)"/g
+  const pinMatches = [...html.matchAll(PIN_IMG_RE)]
+  for (const m of pinMatches) {
+    const u = m[1].replace(/\\u002F/g, '/').replace(/\\\//g, '/').replace(/\\/g, '')
+    if (isValidPin(u)) {
+      const high = toOriginal(u)
+      if (!seen.has(high)) { seen.add(high); imgs.push(high) }
+    }
+  }
+
+  $('img').each((_, el) => {
+    const src    = $(el).attr('src') || ''
+    const srcset = $(el).attr('srcset') || ''
+    const sources = [src, ...srcset.split(',').map(s => s.trim().split(' ')[0])]
+    for (const s of sources) {
+      if (!isValidPin(s)) continue
+      const high = toOriginal(s)
+      if (!seen.has(high)) { seen.add(high); imgs.push(high) }
+    }
+  })
+
+  const ogImg   = $('meta[property="og:image"]').attr('content') || ''
+  const ogTitle = $('meta[property="og:title"]').attr('content') || ''
+  const ogDesc  = $('meta[property="og:description"]').attr('content') || ''
+  if (ogImg && !seen.has(ogImg)) imgs.push(ogImg)
+
+  const unique = [...new Set(imgs)].filter(Boolean)
+  if (!unique.length) throw new Error('No se pudo extraer la imagen del pin')
+
+  return {
+    id:          resolvedUrl.match(/\/pin\/(\d+)/)?.[1] || '',
+    title:       ogTitle,
+    description: ogDesc,
+    image:       unique[0],
+    images:      unique,
+    url:         resolvedUrl,
+  }
+}

package/src/search/spotify.js

@@ -0,0 +1,56 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+import axios from 'axios'
+
+const HEADERS = {
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36',
+}
+
+async function searchTracks(query, limit = 5) {
+  const res = await axios.get(
+    `https://api.deezer.com/search?q=${encodeURIComponent(query)}&limit=${limit}`,
+    { headers: HEADERS, timeout: 15000 }
+  )
+  const tracks = res.data?.data || []
+  if (!tracks.length) throw new Error('Sin resultados')
+  return tracks.map(t => ({
+    type:      'track',
+    title:     t.title,
+    artist:    t.artist?.name || '',
+    album:     t.album?.title || '',
+    duration:  t.duration || 0,
+    thumbnail: t.album?.cover_big || t.album?.cover || '',
+    url:       t.link || '',
+    preview:   t.preview || null,
+    id:        String(t.id),
+  }))
+}
+
+async function searchAlbums(query, limit = 5) {
+  const res = await axios.get(
+    `https://api.deezer.com/search/album?q=${encodeURIComponent(query)}&limit=${limit}`,
+    { headers: HEADERS, timeout: 15000 }
+  )
+  const albums = res.data?.data || []
+  if (!albums.length) throw new Error('Sin resultados')
+  return albums.map(a => ({
+    type:      'album',
+    title:     a.title,
+    artist:    a.artist?.name || '',
+    thumbnail: a.cover_big || a.cover || '',
+    url:       a.link || '',
+    tracks:    a.nb_tracks || 0,
+    year:      a.release_date?.slice(0, 4) || '',
+    id:        String(a.id),
+  }))
+}
+
+export async function spotify(query, type = 'track', limit = 5) {
+  if (type === 'album') return searchAlbums(query, limit)
+  return searchTracks(query, limit)
+}

package/src/tools/index.js

@@ -0,0 +1,15 @@
+/*
+ * © Created by AxelDev09 🔥
+ * GitHub: https://github.com/AxelDev09
+ * Instagram: @axeldev09
+ * Deja los créditos we 🗣️
+ */
+
+export { tiktokStalk }             from './tiktokstalk.js'
+export { lyricsSearch, lyricsGet } from './lyrics.js'
+export { translate, getLangs }     from './translator.js'
+export { weather }                 from './weather.js'
+export { qrGenerate, qrRead }      from './qr.js'
+export { shortenUrl, expandUrl }   from './urlshortener.js'
+export { news, newsCategories }    from './news.js'
+export { upload }                  from './upload.js'