Upload 25 files

Dockerfile

@@ -0,0 +1,13 @@
+FROM node:20
+
+WORKDIR /
+
+EXPOSE 7680
+
+COPY package*.json ./
+
+RUN npm install
+
+COPY . .
+
+CMD ["npm", "start"]

LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, The PerformanC Organization
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

config.js

@@ -0,0 +1,155 @@
+export default {
+  version: {
+    major: '2',
+    minor: '0',
+    patch: '1',
+    preRelease: null
+  },
+  server: {
+    port: 7680,
+    password: 'youshallnotpass'
+  },
+  options: {
+    threshold: false,
+    playerUpdateInterval: false,
+    statsInterval: false,
+    maxResultsLength: 200,
+    maxAlbumPlaylistLength: 200,
+    maxCaptionsLength: 3,
+    bypassAgeRestriction: false // Bypasses age-restricted videos. Enable at your own risk.
+  },
+  debug: {
+    youtube: {
+      success: true,
+      error: true
+    },
+    pandora: {
+      success: true,
+      error: true
+    },
+    deezer: {
+      success: true,
+      error: true
+    },
+    spotify: {
+      success: true,
+      error: true
+    },
+    soundcloud: {
+      success: true,
+      error: true
+    },
+    musixmatch: true,
+    websocket: {
+      connect: true,
+      disconnect: true,
+      resume: true,
+      failedResume: true,
+      resumeTimeout: true,
+      error: true,
+      connectCD: true,
+      disconnectCD: true,
+      sentDataCD: true
+    },
+    request: {
+      all: false, // Only enable for debugging purposes.
+      enabled: true,
+      error: true,
+      showBody: true,
+      showHeaders: true,
+      showParams: true
+    },
+    track: {
+      start: true,
+      end: true,
+      exception: true,
+      stuck: true
+    },
+    sources: {
+      retrieveStream: true,
+      loadtrack: {
+        request: true,
+        results: true,
+        exception: true
+      },
+      search: {
+        request: true,
+        results: true,
+        exception: true
+      },
+      loadlyrics: {
+        request: true,
+        results: true,
+        exception: true
+      }
+    }
+  },
+  search: {
+    defaultSearchSource: 'youtube',
+    fallbackSearchSource: 'bandcamp',
+    lyricsFallbackSource: 'genius',
+    sources: {
+      youtube: {
+        enabled: true,
+        authentication: {
+          enabled: false, // Authentication using accounts outside EU helps bypass 403 errors. Enable at your own risk.
+          cookies: { // Available in YouTube website cookies.
+            SID: 'DISABLED',
+            LOGIN_INFO: 'DISABLED'
+          },
+          authorization: 'DISABLED' // Available in YouTube website in Authorization header.
+        }
+      },
+      bandcamp: true,
+      http: true,
+      local: true,
+      pandora: false,
+      spotify: {
+        enabled: true,
+        market: 'BR',
+        sp_dc: 'DISABLED' // Necessary for direct Spotify loadLyrics. Available in Spotify website cookies in sp_dc parameter.
+      },
+      deezer: {
+        enabled: false,
+        decryptionKey: 'DISABLED', // For legal reasons, this key is not provided.
+        arl: 'DISABLED' // Necessary for direct Deezer Lyrics. Available in Deezer website cookies in arl parameter.
+      },
+      soundcloud: {
+        enabled: true,
+        clientId: 'AUTOMATIC', // Available in SoundCloud website API requests in client_id parameter.
+        fallbackIfSnipped: true
+      },
+      musixmatch: {
+        enabled: false,
+        signatureSecret: 'DISABLED' // For legal reasons, this key is not provided.
+      },
+      genius: {
+        enabled: true
+      }
+    }
+  },
+  filters: {
+    enabled: true,
+    threads: 4,
+    list: {
+      volume: true,
+      equalizer: true,
+      karaoke: true,
+      timescale: true,
+      tremolo: true,
+      vibrato: true,
+      rotation: true,
+      distortion: true,
+      channelMix: true,
+      lowPass: true
+    }
+  },
+  audio: {
+    quality: 'high',
+    encryption: 'xsalsa20_poly1305_lite'
+  },
+  voiceReceive: {
+    type: 'pcm', // pcm, opus
+    timeout: 1000 // 1s of silence to consider as it stopped speaking.
+  }
+}

constants.js

@@ -0,0 +1,107 @@
+export default {
+  YouTube: {
+    video: 1,
+    playlist: 2,
+    shorts: 3,
+  },
+  VoiceWSCloseCodes: {
+    4001: 'Unknown opcode',
+    4002: 'Failed to decode payload',
+    4003: 'Not authenticated',
+    4004: 'Authentication failed',
+    4005: 'Already authenticated',
+    4006: 'Session no longer valid',
+    4009: 'Session timeout',
+    4011: 'Server not found',
+    4012: 'Unknown protocol',
+    4014: 'Disconnected',
+    4015: 'Voice server crashed',
+    4016: 'Unknown encryption mode'
+  },
+  opus: {
+    samplingRate: 48000,
+    frameSize: 960,
+    channels: 2
+  },
+  sampleRate: {
+    coefficients: [{
+      beta: 0.99847546664,
+      alpha: 76226668143e-14,
+      gamma: 1.9984647656
+    }, {
+      beta: 0.99756184654,
+      alpha: 0.0012190767289,
+      gamma: 1.9975344645
+    }, {
+      beta: 0.99616261379,
+      alpha: 0.0019186931041,
+      gamma: 1.9960947369
+    }, {
+      beta: 0.99391578543,
+      alpha: 0.0030421072865,
+      gamma: 1.9937449618
+    }, {
+      beta: 0.99028307215,
+      alpha: 0.0048584639242,
+      gamma: 1.9898465702
+    }, {
+      beta: 0.98485897264,
+      alpha: 0.0075705136795,
+      gamma: 1.9837962543
+    }, {
+      beta: 0.97588512657,
+      alpha: 0.012057436715,
+      gamma: 1.9731772447
+    }, {
+      beta: 0.96228521814,
+      alpha: 0.018857390928,
+      gamma: 1.9556164694
+    }, {
+      beta: 0.94080933132,
+      alpha: 0.029595334338,
+      gamma: 1.9242054384
+    }, {
+      beta: 0.90702059196,
+      alpha: 0.046489704022,
+      gamma: 1.8653476166
+    }, {
+      beta: 0.85868004289,
+      alpha: 0.070659978553,
+      gamma: 1.7600401337
+    }, {
+      beta: 0.78409610788,
+      alpha: 0.10795194606,
+      gamma: 1.5450725522
+    }, {
+      beta: 0.68332861002,
+      alpha: 0.15833569499,
+      gamma: 1.1426447155
+    }, {
+      beta: 0.55267518228,
+      alpha: 0.22366240886,
+      gamma: 0.40186190803
+    }, {
+      beta: 0.41811888447,
+      alpha: 0.29094055777,
+      gamma: -0.70905944223
+    }]
+  },
+  pcm: {
+    maximumRate: 32767,
+    minimumRate: -32768,
+    bits: 16,
+    bytes: 2,
+    channels: 2
+  },
+  filtering: {
+    equalizerBands: 15,
+    types: {
+      equalizer: 1,
+      tremolo: 2,
+      rotationHz: 3,
+    }
+  },
+  circunferece: {
+    diameter: 2 * Math.PI
+  }
+}

package.json

@@ -0,0 +1,12 @@
+{
+  "type": "module",
+  "scripts": {
+    "start": "node --dns-result-order=ipv4first --openssl-legacy-provider src/connection/index.js"
+  },
+  "dependencies": {
+    "@performanc/voice": "^1.0.5",
+    "opusscript": "^0.0.8",
+    "prism-media": "^1.3.5",
+    "sodium-native": "^4.0.4"
+  }
+}

src/connection/handler.js

@@ -0,0 +1,829 @@
+import os from 'node:os'
+import { URL } from 'node:url'
+
+import { randomLetters, debugLog, sendResponse, sendResponseNonNull, verifyMethod, encodeTrack, decodeTrack, tryParseBody } from '../utils.js'
+import config from '../../config.js'
+import sources from '../sources.js'
+import VoiceConnection from './voiceHandler.js'
+
+const clients = {}
+let statsInterval = null
+let playerUpdateInterval = null
+
+function startStats() {
+  statsInterval = setInterval(() => {
+    let memoryUsage = process.memoryUsage()
+
+    const statistics = {
+      sent: 0,
+      nulled: 0,
+      expected: 0,
+      deficit: 0
+    }
+
+    Object.keys(clients).forEach((key) => {
+      const client = clients[key]
+
+      client.players.forEach((player) => {
+        if (!player.connection) return;
+
+        statistics.sent += player.connection.statistics.packetsSent
+        statistics.nulled += player.connection.statistics.packetsLost
+        statistics.expected += player.connection.statistics.packetsExpected
+      })
+    })
+
+    statistics.deficit = statistics.sent - statistics.expected
+
+    const statisticsResponse = JSON.stringify({
+      op: 'stats',
+      players: nodelinkPlayingPlayersCount,
+      playingPlayers: nodelinkPlayingPlayersCount,
+      uptime: Math.floor(process.uptime() * 1000),
+      memory: {
+        free: memoryUsage.heapTotal - memoryUsage.heapUsed,
+        used: memoryUsage.heapUsed,
+        allocated: 0,
+        reservable: memoryUsage.rss
+      },
+      cpu: {
+        cores: os.cpus().length,
+        systemLoad: os.loadavg()[0],
+        lavalinkLoad: 0
+      },
+      frameStats: statistics
+    })
+
+    Object.keys(clients).forEach((key) => clients[key].ws.send(statisticsResponse, 200))
+  }, config.options.statsInterval)
+}
+
+function startPlayerUpdate() {
+  playerUpdateInterval = setInterval(() => {
+    if (Object.keys(clients).length === 0) return;
+
+    Object.keys(clients).forEach((key) => {
+      const client = clients[key]
+
+      client.players.forEach((player) => {
+        if (!player.connection) return;
+
+        player.config.state = {
+          time: Date.now(),
+          position: player.connection.playerState.status === 'playing' ? player._getRealTime() : 0,
+          connected: player.connection.state.status === 'connected',
+          ping: player.connection.ping || -1
+        }
+
+        client.ws.send(JSON.stringify({
+          op: 'playerUpdate',
+          guildId: player.guildId,
+          state: player.config.state
+        }))
+      })
+    })
+  }, config.options.playerUpdateInterval)
+}
+
+async function configureConnection(ws, req, parsedClientName) {
+  let sessionId = null
+  let client = null
+
+  ws.on('close', (code, reason) => {
+    debugLog('disconnect', 3, { ...parsedClientName, code, reason })
+
+    if (!client) return;
+
+    if (clients.length === 1) {
+      clearInterval(statsInterval)
+      statsInterval = null
+
+      clearInterval(playerUpdateInterval)
+      playerUpdateInterval = null
+
+      if (config.search.sources.youtube && config.options.bypassAgeRestriction)
+        sources.youtube.free()
+    }
+
+    client.players.forEach((player) => player.destroy())
+    delete clients[sessionId]
+  })
+
+  sessionId = randomLetters(16)
+  client = {
+    userId: req.headers['user-id'],
+    ws,
+    players: new Map()
+  }
+
+  clients[sessionId] = client
+
+  await startSourceAPIs()
+
+  ws.send(
+    JSON.stringify({
+      op: 'ready',
+      resumed: false,
+      sessionId
+    })
+  )
+}
+
+async function requestHandler(req, res) {
+  const parsedUrl = new URL(req.url, `http://${req.headers.host}`)
+
+  if (config.debug.request.all) {
+    const body = []
+    req.on('data', (chunk) => body.push(chunk))
+    req.on('end', () => {
+      debugLog('all', 6, { method: req.method, path: parsedUrl.pathname, headers: req.headers, body: Buffer.concat(body).toString() })
+
+      req.removeAllListeners()
+
+      req.push(Buffer.concat(body))
+    })
+  }
+
+  if (!req.headers || req.headers.authorization !== config.server.password) {
+    res.writeHead(401, { 'Content-Type': 'text/plain' })
+
+    res.end('Unauthorized')
+  }
+
+  else if (parsedUrl.pathname === '/version') {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    debugLog('version', 1, { headers: req.headers })
+
+    res.writeHead(200, { 'Content-Type': 'text/plain' })
+    res.end(`${config.version.major}.${config.version.minor}.${config.version.patch}${config.version.preRelease ? `-${config.version.preRelease}` : ''}`)
+  }
+
+  else if (parsedUrl.pathname === '/v4/info') {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    debugLog('info', 1, { headers: req.headers })
+
+    sendResponse(req, res, {
+      version: {
+        semver: `${config.version.major}.${config.version.minor}.${config.version.patch}${config.version.preRelease ? `-${config.version.preRelease}` : ''}`,
+        ...config.version
+      },
+      buildTime: -1,
+      git: {
+        branch: 'main',
+        commit: 'unknown',
+        commitTime: -1
+      },
+      nodejs: process.version,
+      isNodeLink: true,
+      jvm: '0.0.0',
+      lavaplayer: '0.0.0',
+      sourceManagers: Object.keys(config.search.sources).filter((source) => {
+        if (typeof config.search.sources[source] === 'boolean') return source
+        return config.search.sources[source].enabled
+      }),
+      filters: Object.keys(config.filters.list).filter((filter) => config.filters.list[filter]),
+      plugins: []
+    }, 200)
+  }
+
+  else if (parsedUrl.pathname === '/v4/decodetrack') {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    let encodedTrack = parsedUrl.searchParams.get('encodedTrack')
+    
+    if (!encodedTrack) {
+      debugLog('decodetrack', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'The provided track is invalid.' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 400,
+        error: 'Bad Request',
+        trace: new Error().stack,
+        message: 'The provided track is invalid.',
+        path: parsedUrl.pathname
+      }, 400)
+    }
+    
+    encodedTrack = encodedTrack.replace(/ /, '+')
+
+    let decodedTrack = null
+
+    if (!encodedTrack || !(decodedTrack = decodeTrack(encodedTrack))) {
+      debugLog('decodetrack', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'The provided track is invalid.' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 400,
+        error: 'Bad Request',
+        trace: new Error().stack,
+        message: 'The provided track is invalid.',
+        path: parsedUrl.pathname
+      }, 400)
+    }
+
+    debugLog('decodetrack', 1, { params: parsedUrl.pathname, headers: req.headers })
+
+    sendResponse(req, res, { encoded: encodedTrack, info: decodedTrack }, 200)
+  }
+
+  else if (parsedUrl.pathname === '/v4/decodetracks') {
+    if (verifyMethod(parsedUrl, req, res, 'POST')) return;
+
+    let buffer = ''
+    if (!(buffer = await tryParseBody(req, res))) return;
+
+    if (typeof buffer !== 'object' || !Array.isArray(buffer)) {
+      debugLog('decodetracks', 1, { headers: req.headers, body: buffer, error: 'The provided body is invalid.' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 400,
+        error: 'Bad request',
+        trace: new Error().stack,
+        message: 'The provided body is invalid.',
+        path: parsedUrl.pathname
+      }, 400)
+    }
+
+    const tracks = []
+    let failed = false
+
+    buffer.nForEach((encodedTrack) => {
+      const decodedTrack = decodeTrack(encodedTrack)
+
+      if (!decodedTrack) {
+        failed = true
+
+        debugLog('decodetracks', 1, { headers: req.headers, body: encodedTrack, error: 'The provided track is invalid.' })
+
+        sendResponse(req, res, {
+          timestamp: Date.now(),
+          status: 400,
+          error: 'Bad request',
+          trace: new Error().stack,
+          message: 'The provided track is invalid.',
+          path: parsedUrl.pathname
+        }, 400)
+
+        return true
+      }
+
+      tracks.push({ encoded: encodedTrack, info: decodedTrack })
+    })
+
+    if (failed) return;
+
+    debugLog('decodetracks', 1, { headers: req.headers, body: buffer })
+
+    sendResponse(req, res, tracks, 200)
+  }
+
+  else if (parsedUrl.pathname === '/v4/encodetrack') {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    let buffer = ''
+    if (!(buffer = await tryParseBody(req, res))) return;
+
+    let encodedTrack = null
+
+    if (!(encodedTrack = encodeTrack(buffer))) {
+      debugLog('encodetrack', 1, { headers: req.headers, body: buffer, error: 'Invalid track object' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 400,
+        error: 'Bad Request',
+        trace: new Error().stack,
+        message: 'Invalid track object',
+        path: '/v4/encodetrack'
+      }, 400)
+    }
+
+    debugLog('encodetrack', 1, { headers: req.headers, body: buffer })
+
+    sendResponse(req, res, encodedTrack, 200)
+  }
+
+  else if (parsedUrl.pathname === '/v4/encodetracks') {
+    if (verifyMethod(parsedUrl, req, res, 'POST')) return;
+
+    let buffer = ''
+    if (!(buffer = await tryParseBody(req, res))) return;
+
+    if (typeof buffer !== 'object' || !Array.isArray(buffer)) {
+      debugLog('decodetracks', 1, { headers: req.headers, body: buffer, error: 'The provided body is invalid.' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 400,
+        error: 'Bad request',
+        trace: new Error().stack,
+        message: 'The provided body is invalid.',
+        path: parsedUrl.pathname
+      }, 400)
+    }
+
+    const tracks = []
+
+    buffer.forEach((track) => {
+      let encodedTrack = null
+
+      if (!(encodedTrack = encodeTrack(track))) {
+        debugLog('encodetracks', 1, { headers: req.headers, body: buffer, error: 'Invalid track object' })
+
+        return sendResponse(req, res, {
+          timestamp: Date.now(),
+          status: 400,
+          error: 'Bad Request',
+          trace: new Error().stack,
+          message: 'Invalid track object',
+          path: '/v4/encodetracks'
+        }, 400)
+      }
+
+      tracks.push(encodedTrack)
+    })
+
+    debugLog('encodetracks', 1, { headers: req.headers, body: buffer })
+
+    sendResponse(req, res, tracks, 200)
+  }
+
+  else if (parsedUrl.pathname === '/v4/stats') {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    debugLog('stats', 1, { headers: req.headers })
+
+    const statistics = {
+      sent: 0,
+      nulled: 0,
+      expected: 0,
+      deficit: 0
+    }
+
+    Object.keys(clients).forEach((key) => {
+      const client = clients[key]
+
+      client.players.forEach((player) => {
+        if (!player.connection) return;
+
+        statistics.sent += player.connection.statistics.packetsSent
+        statistics.nulled += player.connection.statistics.packetsLost
+        statistics.expected += player.connection.statistics.packetsExpected
+      })
+    })
+
+    statistics.deficit = statistics.sent - statistics.expected
+
+    sendResponse(req, res, {
+      players: nodelinkPlayersCount,
+      playingPlayers: nodelinkPlayingPlayersCount,
+      uptime: Math.floor(process.uptime() * 1000),
+      memory: {
+        free: process.memoryUsage().heapTotal - process.memoryUsage().heapUsed,
+        used: process.memoryUsage().heapUsed,
+        allocated: 0,
+        reservable: process.memoryUsage().rss
+      },
+      cpu: {
+        cores: os.cpus().length,
+        systemLoad: os.loadavg()[0],
+        lavalinkLoad: 0
+      },
+      frameStats: statistics
+    }, 200)
+  }
+
+  else if (parsedUrl.pathname === '/v4/loadtracks') {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    debugLog('loadtracks', 1, { params: parsedUrl.pathname, headers: req.headers })
+
+    const search = await sources.loadTracks(parsedUrl.searchParams.get('identifier'))
+
+    sendResponse(req, res, search, 200)
+
+    return;
+  }
+
+  else if (parsedUrl.pathname === '/v4/loadlyrics') {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    const encodedTrack = parsedUrl.searchParams.get('encodedTrack')
+    let decodedTrack = null
+
+    if (!encodedTrack || !(decodedTrack = decodeTrack(encodedTrack))) {
+      debugLog('loadlyrics', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'The provided track is invalid.' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 400,
+        error: 'Bad Request',
+        trace: new Error().stack,
+        message: 'The provided track is invalid.',
+        path: '/v4/loadlyrics'
+      }, 400)
+    }
+
+    const language = parsedUrl.searchParams.get('language')
+    const captions = await sources.loadLyrics(parsedUrl, req, decodedTrack, language)
+
+    debugLog('loadlyrics', 1, { params: parsedUrl.pathname, headers: req.headers })
+
+    sendResponse(req, res, captions, 200)
+  }
+
+  else if (/^\/v4\/sessions\/[A-Za-z0-9]+\/players$(?!\/)/.test(parsedUrl.pathname)) {
+    if (verifyMethod(parsedUrl, req, res, 'GET')) return;
+
+    const client = clients[/^\/v4\/sessions\/([A-Za-z0-9]+)\/players$/.exec(parsedUrl.pathname)[1]]
+
+    if (!client) {
+      debugLog('getPlayers', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'The provided session Id doesn\'t exist.' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 404,
+        trace: new Error().stack,
+        message: 'The provided session Id doesn\'t exist.',
+        path: parsedUrl.pathname
+      }, 404)
+    }
+
+    const players = []
+
+    client.players.forEach((player) => {
+      player.config.state = {
+        time: Date.now(),
+        position: player.connection ? player.connection.playerState.status === 'playing' ? player._getRealTime() : 0 : 0,
+        connected: player.connection ? player.connection.state.status === 'ready' : false,
+        ping: player.connection?.ping || -1
+      }
+
+      players.push(player.config)
+    })
+
+    debugLog('getPlayers', 1, { headers: req.headers })
+
+    sendResponse(req, res, players, 200)
+  }
+
+  else if (/^\/v4\/sessions\/\w+\/players\/\w+./.test(parsedUrl.pathname)) {
+    if (![ 'DELETE', 'PATCH', 'GET' ].includes(req.method)) {
+      sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 405,
+        error: 'Method Not Allowed',
+        message: `Request method must be DELETE, PATCH or GET`,
+        path: parsedUrl.pathname
+      }, 405)
+
+      return;
+    }
+
+    const client = clients[/^\/v4\/sessions\/([A-Za-z0-9]+)\/players\/\d+$/.exec(parsedUrl.pathname)[1]]
+
+    if (!client) {
+      debugLog('updatePlayer', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'The provided session Id doesn\'t exist.' })
+
+      return sendResponse(req, res, {
+        timestamp: Date.now(),
+        status: 404,
+        trace: new Error().stack,
+        message: 'The provided session Id doesn\'t exist.',
+        path: parsedUrl.pathname
+      }, 404)
+    }
+
+    const guildId = /\/players\/(\d+)$/.exec(parsedUrl.pathname)[1]
+    let player = client.players.get(guildId)
+
+    if (req.method === 'DELETE') {
+      if (!player) {
+        debugLog('deletePlayer', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'The provided guildId doesn\'t exist.' })
+
+        return sendResponse(req, res, {
+          timestamp: Date.now(),
+          status: 404,
+          trace: new Error().stack,
+          message: 'The provided guildId doesn\'t exist.',
+          path: parsedUrl.pathname
+        }, 404)
+      }
+
+      player.destroy()
+      client.players.delete(guildId)
+
+      debugLog('deletePlayer', 1, { params: parsedUrl.pathname, headers: req.headers })
+
+      return sendResponse(req, res, null, 204)
+    }
+
+    if (req.method === 'GET') {
+      if (!guildId) {
+        debugLog('getPlayer', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'Missing guildId parameter.' })
+
+        return sendResponse(req, res, {
+          timestamp: Date.now(),
+          status: 400,
+          trace: new Error().stack,
+          message: 'Missing guildId parameter.',
+          path: parsedUrl.pathname
+        }, 400)
+      }
+
+      let player = client.players.get(guildId)
+
+      if (!player) {
+        player = new VoiceConnection(guildId, client)
+
+        client.players.set(guildId, player)
+      }
+
+      player.config.state = {
+        time: Date.now(),
+        position: player.connection ? player.connection.playerState.status === 'playing' ? player._getRealTime() : 0 : 0,
+        connected: player.connection ? player.connection.state.status === 'ready' : false,
+        ping: player.connection?.ping || -1
+      }
+
+      debugLog('getPlayer', 1, { params: parsedUrl.pathname, headers: req.headers })
+
+      return sendResponse(req, res, player.config, 200)
+    }
+
+    let buffer = ''
+    if (!(buffer = await tryParseBody(req, res))) return;
+    
+    if (req.method === 'PATCH') {
+      if (!player) player = new VoiceConnection(guildId, client)
+
+      if (buffer.voice !== undefined) {
+        if (!buffer.voice.endpoint || !buffer.voice.token || !buffer.voice.sessionId) {
+          debugLog('voice', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: `Invalid voice object.` })
+
+          return sendResponse(req, res, {
+            timestamp: Date.now(),
+            status: 400,
+            trace: new Error().stack,
+            message: 'Invalid voice object.',
+            path: parsedUrl.pathname
+          }, 400)
+        }
+
+        player.updateVoice(buffer.voice)
+
+        if (player.cache.track) {
+          player.play(player.cache.track, decodeTrack(player.cache.track), false)
+
+          player.cache.track = null
+        }
+
+        client.players.set(guildId, player)
+
+        debugLog('voice', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer })
+      }
+
+                                                                   /* Deprecated */
+      const encodedTrack = buffer.track?.encoded === undefined ? buffer.encodedTrack : buffer.track?.encoded
+
+      if (encodedTrack !== undefined) {
+        if (buffer.encodedTrack !== undefined) /* Deprecated */
+          debugLog('encodedTrack', 2, { params: parsedUrl.pathname, headers: req.headers, body: buffer, warning: 'The client is using a deprecated method of play (encodedTrack), deprecated by LavaLink. Report to the client GitHub.' })
+
+        if (encodedTrack === null) {
+          if (!player.config.track) {
+            debugLog('stop', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: 'The player is not playing.' })
+
+            return sendResponse(req, res, {
+              timestamp: Date.now(),
+              status: 400,
+              trace: new Error().stack,
+              message: 'The player is not playing.',
+              path: parsedUrl.pathname
+            }, 400)
+          }
+
+          player.stop()
+
+          debugLog('stop', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer })
+        } else {
+          const noReplace = parsedUrl.searchParams.get('noReplace')
+          const decodedTrack = decodeTrack(encodedTrack)
+
+          if (!decodedTrack) {
+            debugLog('play', 1, { track: encodedTrack, exception: { message: 'The provided track is invalid.', severity: 'common', cause: 'Invalid track' } })
+
+            return sendResponse(req, res, {
+              timestamp: Date.now(),
+              status: 400,
+              trace: new Error().stack,
+              message: 'The provided track is invalid.',
+              path: parsedUrl.pathname
+            }, 400)
+          }
+
+          if (!player.connection.voiceServer) player.cache.track = encodedTrack
+          else player.play(encodedTrack, decodedTrack, noReplace === true)
+
+          debugLog('play', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer })
+        }
+
+        client.players.set(guildId, player)
+      }
+
+      if (buffer.track?.userData !== undefined) {
+        player.config.track = {
+          ...(player.config.track ? player.config.track : {}),
+          userData: buffer.userData
+        }
+
+        debugLog('userData', 1, { params: parsedUrl.pathname, params: parsedUrl.pathname, body: buffer })
+      }
+
+      if (buffer.volume !== undefined) {
+        if (buffer.volume < 0 || buffer.volume > 1000) {
+          debugLog('volume', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: 'The volume must be between 0 and 1000.' })
+
+          return sendResponse(req, res, {
+            timestamp: Date.now(),
+            status: 400,
+            trace: new Error().stack,
+            message: 'The volume must be between 0 and 1000.',
+            path: parsedUrl.pathname
+          }, 400)
+        }
+
+        player.volume(buffer.volume)
+
+        client.players.set(guildId, player)
+
+        debugLog('volume', 1, { params: parsedUrl.pathname, params: parsedUrl.pathname, body: buffer })
+      }
+
+      if (buffer.paused !== undefined) {
+        if (typeof buffer.paused !== 'boolean') {
+          debugLog('pause', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: 'The paused value must be a boolean.' })
+
+          return sendResponse(req, res, {
+            timestamp: Date.now(),
+            status: 400,
+            trace: new Error().stack,
+            message: 'The paused value must be a boolean.',
+            path: parsedUrl.pathname
+          }, 400)
+        }
+
+        if (!player.connection?.ws) {
+          debugLog('pause', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: 'The player is not connected to a voice server.' })
+
+          return sendResponse(req, res, {
+            timestamp: Date.now(),
+            status: 400,
+            trace: new Error().stack,
+            message: 'The player is not connected to a voice server.',
+            path: parsedUrl.pathname
+          }, 400)
+        }
+
+        player.pause(buffer.paused)
+
+        client.players.set(guildId, player)
+
+        debugLog('pause', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer })
+      }
+
+      let filters = {}
+
+      if (buffer.filters !== undefined) {
+        if (typeof buffer.filters !== 'object') {
+          debugLog('filters', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: 'The filters value must be an object.' })
+
+          return sendResponse(req, res, {
+            timestamp: Date.now(),
+            status: 400,
+            trace: new Error().stack,
+            message: 'The filters value must be an object.',
+            path: parsedUrl.pathname
+          }, 400)
+        }
+
+        filters = buffer.filters
+
+        debugLog('filters', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer })
+      }
+
+      if (buffer.position !== undefined) {
+        if (typeof buffer.position !== 'number' && buffer.endTime !== null) {
+          debugLog('seek', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: 'The position value must be a number.' })
+
+          return sendResponse(req, res, {
+            timestamp: Date.now(),
+            status: 400,
+            trace: new Error().stack,
+            message: 'The position value must be a number.',
+            path: parsedUrl.pathname
+          }, 400)
+        }
+
+        filters.seek = buffer.position
+
+        debugLog('seek', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer })
+      }
+
+      if (buffer.endTime !== undefined) {
+        if (typeof buffer.endTime !== 'number' && buffer.endTime !== null) {
+          debugLog('endTime', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer, error: 'The endTime value must be a number.' })
+
+          return sendResponse(req, res, {
+            timestamp: Date.now(),
+            status: 400,
+            trace: new Error().stack,
+            message: 'The endTime value must be a number.',
+            path: parsedUrl.pathname
+          }, 400)
+        }
+
+        filters.endTime = buffer.endTime
+
+        debugLog('endTime', 1, { params: parsedUrl.pathname, headers: req.headers, body: buffer })
+      }
+
+      if (Object.keys(filters).length != 0 || JSON.stringify(buffer.filters) === '{}') {
+        player.filters(filters)
+
+        client.players.set(guildId, player)
+      }
+
+      /* Updating player state to ensure it's sending up-to-date data */
+      player.config.state = {
+        time: Date.now(),
+        position: player.connection ? player.connection.playerState.status === 'playing' ? player._getRealTime() : 0 : 0,
+        connected: player.connection ? player.connection.state.status === 'ready' : false,
+        ping: player.connection?.ping || -1 
+      }
+
+      sendResponse(req, res, player.config, 200)
+    }
+  }
+
+  else {
+    sendResponse(req, res, {
+      timestamp: Date.now(),
+      status: 404,
+      error: 'Not Found',
+      trace: new Error().stack,
+      message: 'The requested route was not found.',
+      path: parsedUrl.pathname
+    }, 404)
+  }
+}
+
+function startSourceAPIs() {
+  if (Object.keys(clients).length !== 1) return;
+
+  return new Promise((resolve) => {
+    const sourcesToInitialize = []
+
+    if (config.search.sources.youtube && config.options.bypassAgeRestriction)
+      sourcesToInitialize.push(sources.youtube)
+
+    if (config.search.sources.spotify.enabled)
+      sourcesToInitialize.push(sources.spotify)
+
+    if (config.search.sources.pandora)
+      sourcesToInitialize.push(sources.pandora)
+
+    if (config.search.sources.deezer.enabled)
+      sourcesToInitialize.push(sources.deezer)
+
+    if (config.search.sources.soundcloud.enabled)
+      sourcesToInitialize.push(sources.soundcloud)
+
+    if (config.options.statsInterval)
+      startStats()
+
+    if (config.options.playerUpdateInterval)
+      startPlayerUpdate()
+
+    if (config.search.sources.musixmatch.enabled)
+      sources.musixmatch.init()
+
+    if (sourcesToInitialize.length === 0) resolve()
+
+    let i = 0
+    sourcesToInitialize.forEach(async (source) => {
+      await source.init()
+
+      if (++i === sourcesToInitialize.length) resolve()
+    })
+  })
+}
+
+export default {
+  configureConnection,
+  requestHandler,
+  startSourceAPIs
+}

src/connection/index.js

@@ -0,0 +1,125 @@
+import http from 'node:http'
+import { URL } from 'node:url'
+
+import connectionHandler from './handler.js'
+import inputHandler from './inputHandler.js'
+import config from '../../config.js'
+import { debugLog, parseClientName } from '../utils.js'
+import { WebSocketServer } from '../ws.js'
+
+if (typeof config.server.port !== 'number')
+  throw new Error('Port must be a number.')
+
+if (typeof config.server.password !== 'string')
+  throw new Error('Password must be a string.')
+
+if (typeof config.options.threshold !== 'boolean' && typeof config.options.threshold !== 'number')
+  throw new Error('Threshold must be a boolean or a number.')
+
+if (typeof config.options.playerUpdateInterval !== 'boolean' && typeof config.options.playerUpdateInterval !== 'number')
+  throw new Error('Player update interval must be a boolean or a number.')
+
+if (typeof config.options.statsInterval !== 'boolean' && typeof config.options.statsInterval !== 'number')
+  throw new Error('Stats interval must be a boolean or a number.')
+
+if (typeof config.options.maxResultsLength !== 'number')
+  throw new Error('Max results length must be a number.')
+
+if (typeof config.options.maxAlbumPlaylistLength !== 'number')
+  throw new Error('Max album playlist length must be a number.')
+
+if (typeof config.options.maxCaptionsLength !== 'number')
+  throw new Error('Max captions length must be a number.')
+
+if (typeof config.options.bypassAgeRestriction !== 'boolean')
+  throw new Error('Bypass age restriction must be a boolean.')
+
+if (!['bandcamp', 'deezer', 'soundcloud', 'youtube', 'ytmusic'].includes(config.search.defaultSearchSource))
+  throw new Error('Default search source must be either "bandcamp", "deezer", "soundcloud", "youtube" or "ytmusic".')
+
+if (config.search.fallbackSearchSource === 'soundcloud')
+  throw new Error('SoundCloud is not supported as a fallback source.')
+
+if (config.search.sources.spotify.enabled && !config.search.sources.spotify.market)
+  throw new Error('Spotify is enabled but no market was provided.')
+
+if (config.search.sources.deezer.enabled && config.search.sources.deezer.decryptionKey === 'DISABLED')
+  throw new Error('Deezer is enabled but no decryption key or API key was provided.')
+
+if (config.search.sources.soundcloud.enabled && config.search.sources.soundcloud.clientId === 'DISABLED')
+  throw new Error('SoundCloud is enabled but no client ID was provided.')
+
+if (![ 'high', 'medium', 'low', 'lowest' ].includes(config.audio.quality))
+  throw new Error('Audio quality must be either "high", "medium", "low" or "lowest".')
+
+if (![ 'xsalsa20_poly1305', 'xsalsa20_poly1305_suffix', 'xsalsa20_poly1305_lite' ].includes(config.audio.encryption))
+  throw new Error('Encryption must be either "xsalsa20_poly1305", "xsalsa20_poly1305_suffix" or "xsalsa20_poly1305_lite".')
+
+if (typeof config.voiceReceive.timeout !== 'number')
+  throw new Error('Voice receive timeout must be a number.')
+
+if (![ 'opus', 'pcm' ].includes(config.voiceReceive.type))
+  throw new Error('Voice receive type must be either "opus" or "pcm".')
+
+const server = http.createServer(connectionHandler.requestHandler)
+const v4 = new WebSocketServer()
+
+v4.on('/v4/websocket', connectionHandler.configureConnection)
+
+v4.on('/connection/data', inputHandler.setupConnection)
+
+server.on('upgrade', (req, socket, head) => {
+  const { pathname } = new URL(req.url, `http://${req.headers.host}`)
+
+  if (req.headers.authorization !== config.server.password) {
+    debugLog('disconnect', 3, { name: 'Unknown', version: '0.0.0', code: 401, reason: 'Invalid password' })
+
+    req.socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n')
+
+    return req.socket.destroy()
+  }
+
+  const parsedClientName = parseClientName(req.headers['client-name'])
+
+  if (!parsedClientName) {
+    debugLog('connect', 1, { name: req.headers['client-name'], error: 'Client-name doesn\'t conform to NAME/VERSION format.' })
+
+    req.socket.write('HTTP/1.1 400 Bad Request\r\n\r\n')
+
+    return req.socket.destroy()
+  }
+
+  req.clientInfo = parsedClientName
+
+  if (pathname === '/v4/websocket') {
+    debugLog('connect', 3, parsedClientName)
+
+    v4.handleUpgrade(req, socket, head, { 'isNodeLink': true }, (ws) => v4.emit('/v4/websocket', ws, req, parsedClientName))
+  }
+
+  if (pathname === '/connection/data') {
+    if (!req.headers['guild-id'] || !req.headers['user-id']) {
+      debugLog('connectCD', 1, { ...parsedClientName, error: `"${!req.headers['guild-id'] ? 'guild-id' : 'user-id'}" header not provided.` })
+
+      req.socket.write('HTTP/1.1 400 Bad Request\r\n\r\n')
+  
+      return req.socket.destroy()
+    }
+
+    debugLog('connectCD', 3, { ...parsedClientName, guildId: req.headers['guild-id'] })
+
+    v4.handleUpgrade(req, socket, head, {}, (ws) => v4.emit('/connection/data', ws, req, parsedClientName))
+  }
+})
+
+v4.on('error', (err) => {
+  debugLog('error', 3, { error: err.message })
+})
+
+server.on('error', (err) => {
+  debugLog('http', 1, { error: err.message })
+})
+
+server.listen(config.server.port || 2333, () => {
+  console.log(`[\u001b[32mwebsocket\u001b[37m]: Listening on port \u001b[94m${config.server.port || 2333}\u001b[37m.`)
+})

src/connection/inputHandler.js

@@ -0,0 +1,110 @@
+import { debugLog } from '../utils.js'
+import config from '../../config.js'
+
+import voiceUtils from '../voice/utils.js'
+import discordVoice from '@performanc/voice'
+import prism from 'prism-media'
+
+const Connections = {}
+
+function setupConnection(ws, req, parsedClientName) {
+  const userId = req.headers['user-id']
+  const guildId = req.headers['guild-id']
+
+  ws.on('close', (code, reason) => {
+    debugLog('disconnectCD', 3, { ...parsedClientName, code, reason, guildId })
+
+    delete Connections[userId]
+  })
+
+  ws.on('error', (err) => {
+    debugLog('disconnectCD', 3, { ...parsedClientName, error: `Error: ${err.message}`, guildId })
+
+    delete Connections[userId]
+  })
+
+  Connections[userId] = {
+    ws,
+    guildId
+  }
+}
+
+function handleStartSpeaking(ssrc, userId, guildId) {
+  const opusStream = discordVoice.getSpeakStream(ssrc)
+  const stream = new voiceUtils.NodeLinkStream(opusStream, config.voiceReceive.type === 'pcm' ? [ new prism.opus.Decoder({ rate: 48000, channels: 2, frameSize: 960 }) ] : [])
+  let timeout = null
+
+  const startSpeakingResponse = JSON.stringify({
+    op: 'speak',
+    type: 'startSpeakingEvent',
+    data: {
+      userId,
+      guildId
+    }
+  })
+
+  Object.keys(Connections).forEach((botId) => {
+    if (Connections[botId].guildId !== guildId) return;
+
+    Connections[botId].ws.send(startSpeakingResponse)
+  })
+
+  let buffer = []
+  stream.on('data', (chunk) => {
+    if (timeout) {
+      clearTimeout(timeout)
+      timeout = null
+    }
+
+    if (Object.keys(Connections).length === 0) {
+      stream.destroy()
+      buffer = null
+
+      return;
+    }
+
+    buffer.push(chunk)
+  })
+
+  stream.on('end', () => {
+    let i = 0
+
+    const connectionsArray = Object.keys(Connections)
+
+    if (connectionsArray.length === 0) {
+      buffer = []
+
+      return;
+    }
+
+    timeout = setTimeout(() => {
+      const endSpeakingResponse = JSON.stringify({
+        op: 'speak',
+        type: 'endSpeakingEvent',
+        data: {
+          userId,
+          guildId,
+          data: Buffer.concat(buffer).toString('base64'),
+          type: config.voiceReceive.type
+        }
+      })
+
+      connectionsArray.forEach((botId) => {
+        if (Connections[botId].guildId !== guildId) return;
+
+        Connections[botId].ws.send(endSpeakingResponse)
+
+        i++
+      })
+
+      buffer = []
+
+      debugLog('sentDataCD', 3, { clientsAmount: i, guildId })
+    }, config.voiceReceive.timeout)
+  })
+}
+
+export default {
+  setupConnection,
+  handleStartSpeaking
+}

src/connection/voiceHandler.js

@@ -0,0 +1,383 @@
+import { debugLog, waitForEvent } from '../utils.js'
+import config from '../../config.js'
+import constants from '../../constants.js'
+import sources from '../sources.js'
+import Filters from '../filters.js'
+
+import inputHandler from './inputHandler.js'
+
+import voiceUtils from '../voice/utils.js'
+
+import discordVoice from '@performanc/voice'
+
+globalThis.nodelinkPlayersCount = 0
+globalThis.nodelinkPlayingPlayersCount = 0
+ 
+class VoiceConnection {
+  constructor(guildId, client) {
+    nodelinkPlayersCount++
+
+    this.client = {
+      userId: client.userId,
+      ws: client.ws
+    }
+
+    this.cache = {
+      url: null,
+      protocol: null,
+      track: null
+    }
+  
+    this.config = {
+      guildId,
+      track: null,
+      volume: 100,
+      paused: false,
+      filters: {},
+      voice: {
+        token: null,
+        endpoint: null,
+        sessionId: null
+      }
+    }
+
+    this._setupVoice()
+  }
+
+  _setupVoice() {
+    this.connection = discordVoice.joinVoiceChannel({ guildId: this.config.guildId, userId: this.client.userId, encryption: config.audio.encryption })
+
+    this.connection.on('speakStart', (userId, ssrc) => inputHandler.handleStartSpeaking(ssrc, userId, this.config.guildId))
+
+    this.connection.on('stateChange', async (oldState, newState) => {
+      switch (newState.status) {
+        case 'disconnected': {
+          debugLog('websocketClosed', 2, { track: this.config.track?.info, exception: constants.VoiceWSCloseCodes[newState.closeCode] })
+
+          this.connection.destroy()
+          this.connection = null
+          this._stopTrack()
+
+          this.client.ws.send(JSON.stringify({
+            op: 'event',
+            type: 'WebSocketClosedEvent',
+            guildId: this.config.guildId,
+            code: newState.code,
+            reason: constants.VoiceWSCloseCodes[newState.code],
+            byRemote: true
+          }))
+
+          break
+        }
+      }
+    })
+
+    this.connection.on('playerStateChange', (_oldState, newState) => {
+      if (newState.status === 'idle' && [ 'stopped', 'finished' ].includes(newState.reason)) {
+        nodelinkPlayingPlayersCount--
+
+        debugLog('trackEnd', 2, { track: this.config.track.info, reason: newState.reason })
+
+        this.client.ws.send(JSON.stringify({
+          op: 'event',
+          type: 'TrackEndEvent',
+          guildId: this.config.guildId,
+          track: this.config.track,
+          reason: newState.reason
+        }))
+
+        this._stopTrack()
+      }
+
+      if (newState.status === 'playing' && newState.reason === 'requested') {
+        nodelinkPlayingPlayersCount++
+
+        debugLog('trackStart', 2, { track: this.config.track.info })
+
+        this.client.ws.send(JSON.stringify({
+          op: 'event',
+          type: 'TrackStartEvent',
+          guildId: this.config.guildId,
+          track: this.config.track
+        }))
+      }
+    })
+
+    this.connection.on('error', (error) => {
+      debugLog('trackException', 2, { track: this.config.track?.info, exception: error.message })
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackExceptionEvent',
+        guildId: this.config.guildId,
+        track: this.config.track,
+        exception: {
+          message: error.message,
+          severity: 'fault',
+          cause: `${error.name}: ${error.message}`
+        }
+      }))
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackEndEvent',
+        guildId: this.config.guildId,
+        track: this.config.track,
+        reason: 'loadFailed'
+      }))
+
+      this._stopTrack()
+    })
+  }
+
+  _stopTrack() {
+    this.cache = {
+      url: null,
+      protocol: null,
+      track: null
+    }
+
+    this.config = {
+      ...this.config,
+      track: null,
+      paused: false
+    }
+  }
+
+  _getRealTime() {
+    return this.connection.statistics.packetsExpected * 20
+  }
+
+  updateVoice(buffer) {
+    this.config.voice = buffer
+
+    if (!this.connection) this._setupVoice()
+
+    this.connection.voiceStateUpdate({
+      session_id: buffer.sessionId
+    })
+    this.connection.voiceServerUpdate({
+      token: buffer.token,
+      endpoint: buffer.endpoint
+    })
+
+    if (!this.connection.ws) this.connection.connect()
+  }
+
+  destroy() {
+    if (this.connection) {
+      this.connection.destroy()
+      this.connection = null
+    }
+
+    this._stopTrack()
+  }
+
+  async getResource(decodedTrack, urlInfo) {
+    const streamInfo = await sources.getTrackStream(decodedTrack, urlInfo.url, urlInfo.protocol, urlInfo.additionalData)
+
+    if (streamInfo.exception) return streamInfo
+
+    return { stream: voiceUtils.createAudioResource(streamInfo.stream, urlInfo.format) }
+  }
+
+  async play(track, decodedTrack, noReplace) {
+    if (noReplace && this.config.track) return this.config
+
+    const urlInfo = await sources.getTrackURL(decodedTrack)
+
+    if (urlInfo.exception) {
+      this._stopTrack()
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackExceptionEvent',
+        guildId: this.config.guildId,
+        track: {
+          encoded: track,
+          info: decodedTrack
+        },
+        exception: urlInfo.exception
+      }))
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackEndEvent',
+        guildId: this.config.guildId,
+        track: {
+          encoded: track,
+          info: decodedTrack,
+          userData: this.config.track?.userData
+        },
+        reason: 'loadFailed'
+      }))
+
+      return this.config
+    }
+
+    if (this.config.track?.encoded) {
+      debugLog('trackEnd', 2, { track: this.config.track.info, reason: 'replaced' })
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackEndEvent',
+        guildId: this.config.guildId,
+        track: this.config.track,
+        reason: 'replaced'
+      }))
+
+      debugLog('trackStart', 2, { track: decodedTrack })
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackStartEvent',
+        guildId: this.config.guildId,
+        track: {
+          encoded: track,
+          info: decodedTrack,
+          userData: this.config.track?.userData
+        }
+      }))
+    }
+
+    let resource = null
+    if (Object.keys(this.config.filters).length > 0) {
+      const filter = new Filters()
+      this.config.filters = filter.configure(this.config.filters)
+
+      resource = await filter.getResource(decodedTrack, urlInfo.protocol, urlInfo.url, null, null, this.cache.ffmpeg, urlInfo.additionalData)  
+    } else {
+      resource = await this.getResource(decodedTrack, urlInfo)
+    }
+  
+    if (resource.exception) {
+      this._stopTrack()
+
+      debugLog('trackException', 2, { track: decodedTrack, exception: resource.exception.message })
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackExceptionEvent',
+        guildId: this.config.guildId,
+        track: {
+          encoded: track,
+          info: decodedTrack,
+          userData: this.config.track?.userData
+        },
+        exception: resource.exception
+      }))
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackEndEvent',
+        guildId: this.config.guildId,
+        track: {
+          encoded: track,
+          info: decodedTrack,
+          userData: this.config.track?.userData
+        },
+        reason: 'loadFailed'
+      }))
+
+      return this.config
+    }
+
+    this.cache.url = urlInfo.url
+    this.cache.protocol = urlInfo.protocol
+    this.config.track = { encoded: track, info: decodedTrack }
+    this.config.paused = false
+
+    if (this.config.volume !== 100) 
+      resource.stream.setVolume(this.config.volume / 100)
+
+    if (!this.connection)
+      return this.config
+  
+    if (!this.connection.udpInfo?.secretKey)
+      await waitForEvent(this.connection, 'stateChange', (_oldState, newState) => newState.status === 'connected', config.options.threshold || undefined)
+
+    const oldResource = this.connection.audioStream
+    
+    this.connection.play(resource.stream)
+
+    if (oldResource)
+      resource.stream.once('readable', () => oldResource.destroy())
+
+    return this.config
+  }
+
+  stop() {
+    if (!this.config.track) return this.config
+
+    if (this.connection.audioStream) this.connection.stop()
+    else this._stopTrack()
+  }
+
+  volume(volume) {
+    if (this.connection.audioStream)
+      this.connection.audioStream.setVolume(volume / 100)
+
+    this.config.volume = volume
+
+    return this.config
+  }
+
+  pause(pause) {
+    if (this.connection.audioStream) {
+      if (pause) this.connection.pause()
+      else this.connection.unpause()
+    }
+
+    this.config.paused = pause
+    
+    return this.config
+  }
+
+  async filters(filters) {
+    if (!this.config.track?.encoded || !config.filters.enabled) return this.config
+
+    const filter = new Filters()
+    this.config.filters = filter.configure(filters, this.config.track.info)
+
+    if (!this.config.track) return this.config
+
+    const resource = await filter.getResource(this.config.track.info, this.cache.protocol, this.cache.url, this._getRealTime(), filters.endTime, null, null)
+
+    if (resource.exception) {
+      this._stopTrack()
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackExceptionEvent',
+        guildId: this.config.guildId,
+        track: this.config.track,
+        exception: resource.exception
+      }))
+
+      this.client.ws.send(JSON.stringify({
+        op: 'event',
+        type: 'TrackEndEvent',
+        guildId: this.config.guildId,
+        track: this.config.track,
+        reason: 'loadFailed'
+      }))
+
+      return this.config
+    }
+
+    resource.stream.setVolume(filters.volume || (this.config.volume / 100))
+    this.config.volume = (filters.volume * 100) || this.config.volume
+
+    if (!this.connection)
+      return this.config
+
+    if (!this.connection.udpInfo?.secretKey)
+      await waitForEvent(this.connection, 'stateChange', (_oldState, newState) => newState.status === 'connected', config.options.threshold || undefined)
+    
+    this.connection.play(resource.stream)
+
+    return this.config
+  }
+}
+
+export default VoiceConnection

src/filters.js

@@ -0,0 +1,345 @@
+import { PassThrough, Transform } from 'node:stream'
+
+import config from '../config.js'
+import { debugLog, clamp16Bit, isEmpty } from './utils.js'
+import soundcloud from './sources/soundcloud.js'
+import voiceUtils from './voice/utils.js'
+import constants from '../constants.js'
+
+import prism from 'prism-media'
+
+class ChannelProcessor {
+  constructor(data, type) {
+    this.type = type
+
+    switch (type) {
+      case constants.filtering.types.equalizer: {
+        this.history = new Array(constants.filtering.equalizerBands * 6).fill(0)
+        this.bandMultipliers = data
+        this.current = 0
+        this.minus1 = 2
+        this.minus2 = 1
+
+        break
+      }
+      case constants.filtering.types.tremolo: {
+        this.frequency = data.frequency
+        this.depth = data.depth
+        this.phase = 0
+        this.offset = 1 - this.depth / 2
+
+        break
+      }
+      case constants.filtering.types.rotationHz: {
+        this.phase = 0
+        this.rotationStep = (constants.circunferece.diameter * data.rotationHz) / constants.opus.samplingRate
+
+        break
+      }
+    }
+  }
+
+  processEqualizer(band) {
+    let processedBand = band * 0.25
+
+    for (let bandIndex = 0; bandIndex < constants.filtering.equalizerBands; bandIndex++) {
+      const coefficient = constants.sampleRate.coefficients[bandIndex]
+
+      const x = bandIndex * 6
+      const y = x + 3
+
+      const bandResult = coefficient.alpha * (band - this.history[x + this.minus2]) + coefficient.gamma * this.history[y + this.minus1] - coefficient.beta * this.history[y + this.minus2]
+
+      this.history[x + this.current] = band
+      this.history[y + this.current] = bandResult
+
+      processedBand += bandResult * this.bandMultipliers[bandIndex]
+    }
+
+    return processedBand * 4
+  }
+
+  getTremoloMultiplier() {
+    let env = this.frequency * this.phase / constants.opus.samplingRate
+    env = Math.sin(2 * Math.PI * ((env + 0.25) % 1.0))
+
+    this.phase++
+
+    return env * (1 - Math.abs(this.offset)) + this.offset
+  }
+
+  processRotationHz(leftSample, rightSample) {
+    const panning = Math.sin(this.phase)
+  
+    const leftMultiplier = panning <= 0 ? 1 : 1 - panning
+    const rightMultiplier = panning >= 0 ? 1 : 1 + panning
+  
+    this.phase += this.rotationStep
+    if (this.phase > constants.circunferece.diameter)
+      this.phase -= constants.circunferece.diameter
+  
+    return {
+      left: leftSample * leftMultiplier,
+      right: rightSample * rightMultiplier
+    }
+  }
+
+  process(samples) {
+    let bytes = constants.pcm.bytes
+    if ([ constants.filtering.types.rotationHz, constants.filtering.types.tremolo ].includes(this.type)) bytes *= 2
+
+    for (let i = 0; i < samples.length - constants.pcm.bytes; i += bytes) {
+      const sample = samples.readInt16LE(i)
+      let result = null
+      
+      switch (this.type) {
+        case constants.filtering.types.equalizer: {
+          result = this.processEqualizer(sample)
+
+          if (++this.current === 3) this.current = 0
+          if (++this.minus1 === 3) this.minus1 = 0
+          if (++this.minus2 === 3) this.minus2 = 0
+
+          samples.writeInt16LE(clamp16Bit(result), i)
+
+          break
+        }
+        case constants.filtering.types.tremolo: {
+          const multiplier = this.getTremoloMultiplier()
+
+          const rightSample = samples.readInt16LE(i + 2)
+
+          samples.writeInt16LE(clamp16Bit(sample * multiplier), i)
+          samples.writeInt16LE(clamp16Bit(rightSample * multiplier), i + 2)
+
+          break
+        }
+        case constants.filtering.types.rotationHz: {
+          const { left, right } = this.processRotationHz(sample, samples.readInt16LE(i + 2))
+
+          samples.writeInt16LE(clamp16Bit(left), i)
+          samples.writeInt16LE(clamp16Bit(right), i + 2)
+
+          break
+        }
+      }
+    }
+
+    return samples
+  }
+}
+
+class Filtering extends Transform {
+  constructor(data, type) {
+    super()
+
+    this.type = type
+    this.channel = new ChannelProcessor(data, type)
+  }
+
+  process(input) {
+    this.channel.process(input)
+  }
+
+  _transform(data, _encoding, callback) {
+    this.process(data)
+
+    return callback(null, data)
+  }
+}
+
+class Filters {
+  constructor() {
+    this.command = []
+    this.equalizer = Array(constants.filtering.equalizerBands).fill(0).map((_, i) => ({ band: i, gain: 0 }))
+    this.result = {}
+  }
+
+  configure(filters, decodedTrack) {
+    const result = {}
+
+    if (filters.equalizer && Array.isArray(filters.equalizer) && filters.equalizer.length && config.filters.list.equalizer) {
+      filters.equalizer.forEach((equalizedBand) => {
+        const band = this.equalizer.find((i) => i.band === equalizedBand.band)
+        if (band) band.gain = Math.min(Math.max(equalizedBand.gain, -0.25), 1.0)
+      })
+
+      result.equalizer = this.equalizer
+    }
+
+    if (!isEmpty(filters.karaoke) && config.filters.list.karaoke) {
+      result.karaoke = {
+        level: Math.min(Math.max(filters.karaoke.level, 0.0), 1.0),
+        monoLevel: Math.min(Math.max(filters.karaoke.monoLevel, 0.0), 1.0),
+        filterBand: filters.karaoke.filterBand,
+        filterWidth: filters.karaoke.filterWidth
+      }
+
+      this.command.push(`stereotools=mlev=${result.karaoke.monoLevel}:mwid=${result.karaoke.filterWidth}:k=${result.karaoke.level}:kc=${result.karaoke.filterBand}`)
+    }
+
+    if (!isEmpty(filters.timescale) && config.filters.list.timescale) {
+      result.timescale = {
+        speed: Math.max(filters.timescale.speed, 0.0),
+        pitch: Math.max(filters.timescale.pitch, 0.0),
+        rate: Math.max(filters.timescale.rate, 0.0)
+      }
+
+      const finalspeed = result.timescale.speed + (1.0 - result.timescale.pitch)
+      const ratedif = 1.0 - result.timescale.rate
+
+      this.command.push(`asetrate=${constants.opus.samplingRate}*${result.timescale.pitch + ratedif},atempo=${finalspeed},aresample=${constants.opus.samplingRate}`)
+    }
+
+    if (!isEmpty(filters.tremolo) && config.filters.list.tremolo) {
+      result.tremolo = {
+        frequency: Math.min(Math.max(filters.tremolo.frequency, 0.0), 14.0),
+        depth: Math.min(Math.max(filters.tremolo.depth, 0.0), 1.0)
+      }
+    }
+
+    if (!isEmpty(filters.vibrato) && config.filters.list.vibrato) {
+      result.vibrato = {
+        frequency: Math.min(Math.max(filters.vibrato.frequency, 0.0), 14.0),
+        depth: Math.min(Math.max(filters.vibrato.depth, 0.0), 1.0)
+      }
+
+      this.command.push(`vibrato=f=${result.vibrato.frequency}:d=${result.vibrato.depth}`)
+    }
+
+    if (!isEmpty(filters.rotation?.rotationHz) && config.filters.list.rotation) {
+      result.rotation = { 
+        rotationHz: filters.rotation.rotationHz
+      }
+    }
+
+    if (!isEmpty(filters.distortion) && config.filters.list.distortion) {
+      result.distortion = {
+        sinOffset: filters.distortion.sinOffset,
+        sinScale: filters.distortion.sinScale,
+        cosOffset: filters.distortion.cosOffset,
+        cosScale: filters.distortion.cosScale,
+        tanOffset: filters.distortion.tanOffset,
+        tanScale: filters.distortion.tanScale,
+        offset: filters.distortion.offset,
+        scale: filters.distortion.scale
+      }
+
+      this.command.push(`afftfilt=real='hypot(re,im)*sin(0.1*${filters.distortion.sinOffset}*PI*t)*${filters.distortion.sinScale}+hypot(re,im)*cos(0.1*${filters.distortion.cosOffset}*PI*t)*${filters.distortion.cosScale}+hypot(re,im)*tan(0.1*${filters.distortion.tanOffset}*PI*t)*${filters.distortion.tanScale}+${filters.distortion.offset}':imag='hypot(re,im)*sin(0.1*${filters.distortion.sinOffset}*PI*t)*${filters.distortion.sinScale}+hypot(re,im)*cos(0.1*${filters.distortion.cosOffset}*PI*t)*${filters.distortion.cosScale}+hypot(re,im)*tan(0.1*${filters.distortion.tanOffset}*PI*t)*${filters.distortion.tanScale}+${filters.distortion.offset}':win_size=512:overlap=0.75:scale=${filters.distortion.scale}`)
+    }
+
+    if (filters.channelMix && filters.channelMix.leftToLeft !== undefined && filters.channelMix.leftToRight !== undefined && filters.channelMix.rightToLeft !== undefined && filters.channelMix.rightToRight !== undefined && config.filters.list.channelMix) {
+      result.channelMix = {
+        leftToLeft: Math.min(Math.max(filters.channelMix.leftToLeft, 0.0), 1.0),
+        leftToRight: Math.min(Math.max(filters.channelMix.leftToRight, 0.0), 1.0),
+        rightToLeft: Math.min(Math.max(filters.channelMix.rightToLeft, 0.0), 1.0),
+        rightToRight: Math.min(Math.max(filters.channelMix.rightToRight, 0.0), 1.0)
+      }
+
+      this.command.push(`pan=stereo|c0<c0*${result.channelMix.leftToLeft}+c1*${result.channelMix.rightToLeft}|c1<c0*${result.channelMix.leftToRight}+c1*${result.channelMix.rightToRight}`)
+    }
+
+    if (filters.lowPass?.smoothing !== undefined && config.filters.list.lowPass) {
+      result.lowPass = {
+        smoothing: Math.max(filters.lowPass.smoothing, 1.0)
+      }
+
+      this.command.push(`lowpass=f=${filters.lowPass.smoothing / 500}`)
+    }
+
+    if (filters.seek !== undefined) {
+      result.startTime = Math.min(filters.seek, decodedTrack.length)
+    }
+
+    this.result = result
+
+    return result
+  }
+
+  getResource(decodedTrack, protocol, url, startTime, endTime, oldFFmpeg, additionalData) {
+    return new Promise(async (resolve) => {
+      if (decodedTrack.sourceName === 'deezer') {
+        debugLog('retrieveStream', 4, { type: 2, sourceName: decodedTrack.sourceName, query: decodedTrack.title, message: 'Filtering does not support Deezer platform.' })
+
+        return resolve({ status: 1, exception: { message: 'Filtering does not support Deezer platform', severity: 'fault', cause: 'Unimplemented feature.' } })
+      }
+
+      if (decodedTrack.sourceName === 'soundcloud')
+        url = await soundcloud.loadFilters(url, protocol)
+
+      const ffmpeg = new prism.FFmpeg({
+        args: [
+          '-loglevel', '0',
+          '-analyzeduration', '0',
+          '-hwaccel', 'auto',
+          '-threads', config.filters.threads,
+          '-filter_threads', config.filters.threads,
+          '-filter_complex_threads', config.filters.threads,
+          ...(this.result.startTime !== undefined || startTime ? ['-ss', `${this.result.startTime !== undefined ? this.result.startTime : startTime}ms`] : []),
+          '-i', url,
+          ...(this.command.length !== 0 ? [ '-af', this.command.join(',') ] : [] ),
+          ...(endTime ? ['-t', `${endTime}ms`] : []),
+          '-f', 's16le',
+          '-ar', constants.opus.samplingRate,
+          '-ac', '2',
+          '-crf', '0'
+        ]
+      })
+
+      const stream = PassThrough()
+
+      ffmpeg.process.stdout.on('data', (data) => stream.write(data))
+      ffmpeg.process.stdout.on('end', () => stream.end())
+      ffmpeg.on('error', (err) => {
+        debugLog('retrieveStream', 4, { type: 2, sourceName: decodedTrack.sourceName, query: decodedTrack.title, message: err.message })
+
+        resolve({ status: 1, exception: { message: err.message, severity: 'fault', cause: 'Unknown' } })
+      })
+
+      ffmpeg.process.stdout.once('readable', () => {
+        const pipelines = [
+          new prism.VolumeTransformer({ type: 's16le' })
+        ]
+
+        if (this.equalizer.some((band) => band.gain !== 0)) {
+          pipelines.push(
+            new Filtering(
+              this.equalizer.map((band) => band.gain),
+              constants.filtering.types.equalizer
+            )
+          )
+        }
+
+        if (this.result.tremolo) {
+          pipelines.push(
+            new Filtering({
+              frequency: this.result.tremolo.frequency,
+              depth: this.result.tremolo.depth
+            },
+            constants.filtering.types.tremolo)
+          )
+        }
+
+        if (this.result.rotation) {
+          pipelines.push(
+            new Filtering({
+              rotationHz: this.result.rotation.rotationHz / 2
+            }, constants.filtering.types.rotationHz)
+          )
+        }
+
+        pipelines.push(
+          new prism.opus.Encoder({
+            rate: constants.opus.samplingRate,
+            channels: constants.opus.channels,
+            frameSize: constants.opus.frameSize
+          })
+        )
+
+        resolve({ stream: new voiceUtils.NodeLinkStream(stream, pipelines) })
+      })
+    })
+  }
+}
+
+export default Filters

src/sources.js

@@ -0,0 +1,322 @@
+import fs from 'node:fs'
+import { PassThrough } from 'node:stream'
+
+import config from '../config.js'
+import bandcamp from './sources/bandcamp.js'
+import deezer from './sources/deezer.js'
+import httpSource from './sources/http.js'
+import local from './sources/local.js'
+import pandora from './sources/pandora.js'
+import soundcloud from './sources/soundcloud.js'
+import spotify from './sources/spotify.js'
+import youtube from './sources/youtube.js'
+import genius from './sources/genius.js'
+import musixmatch from './sources/musixmatch.js'
+import searchWithDefault from './sources/default.js'
+
+import { debugLog, http1makeRequest, makeRequest } from './utils.js'
+
+async function getTrackURL(track, toDefault) {
+  switch (track.sourceName === 'pandora' || toDefault ? config.search.defaultSearchSource : track.sourceName) {
+    case 'spotify': {
+      const result = await searchWithDefault(`${track.title} - ${track.author}`, false)
+
+      if (result.loadType === 'error') {
+        return {
+          exception: result.data
+        }
+      }
+
+      if (result.loadType === 'empty') {
+        return {
+          exception: {
+            message: 'Failed to retrieve stream from source. (Spotify track not found)',
+            severity: 'common',
+            cause: 'Spotify track not found'
+          }
+        }
+      }
+
+      const trackInfo = result.data[0].info
+
+      return getTrackURL(trackInfo, true)
+    }
+    case 'ytmusic':
+    case 'youtube': {
+      return youtube.retrieveStream(track.identifier, track.sourceName, track.title)
+    }
+    case 'local': {
+      return { url: track.uri, protocol: 'file', format: 'arbitrary' }
+    }
+
+    case 'http':
+    case 'https': {
+      return { url: track.uri, protocol: track.sourceName, format: 'arbitrary' }
+    }
+    case 'soundcloud': {
+      return soundcloud.retrieveStream(track.identifier, track.title)
+    }
+    case 'bandcamp': {
+      return bandcamp.retrieveStream(track.uri, track.title)
+    }
+    case 'deezer': {
+      return deezer.retrieveStream(track.identifier, track.title)
+    }
+    default: {
+      return {
+        exception: {
+          message: 'Unknown source',
+          severity: 'common',
+          cause: 'Not supported source.'
+        }
+      }
+    }
+  }
+}
+
+function getTrackStream(decodedTrack, url, protocol, additionalData) {
+  return new Promise(async (resolve) => {
+    if (protocol === 'file') {
+      const file = fs.createReadStream(url)
+
+      file.on('error', () => {
+        debugLog('retrieveStream', 4, { type: 2, sourceName: decodedTrack.sourceName, query: decodedTrack.title, message: 'Failed to retrieve stream from source. (File not found or not accessible)' })
+
+        return resolve({
+          status: 1,
+          exception: {
+            message: 'Failed to retrieve stream from source. (File not found or not accessible)',
+            severity: 'common',
+            cause: 'No permission to access file or doesn\'t exist'
+          }
+        })
+      })
+
+      file.on('open', () => {
+        resolve({
+          stream: file,
+          type: 'arbitrary'
+        })
+      })
+    } else {
+      let trueSource = [ 'pandora', 'spotify' ].includes(decodedTrack.sourceName) ? config.search.defaultSearchSource : decodedTrack.sourceName
+
+      if (trueSource === 'youtube' && protocol === 'hls') {
+        return resolve({
+          stream: await youtube.loadStream(url)
+        })
+      }
+
+      if (trueSource === 'deezer') {
+        return resolve({
+          stream: await deezer.loadTrack(decodedTrack.title, url, additionalData)
+        })
+      }
+
+      if (trueSource === 'soundcloud') {
+        if (additionalData === true) {
+          trueSource = config.search.fallbackSearchSource
+        } else if (protocol === 'hls') {
+          const stream = await soundcloud.loadHLSStream(url)
+
+          return resolve({
+            stream
+          })
+        }
+      }
+
+      const res = await ((trueSource === 'youtube' || trueSource === 'ytmusic') ? http1makeRequest : makeRequest)(url, {
+        headers: {
+          'User-Agent': 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)'
+        },
+        method: 'GET',
+        streamOnly: true
+      })
+
+      if (res.statusCode !== 200) {
+        res.stream.emit('end') /* (http1)makeRequest will handle this automatically */
+
+        debugLog('retrieveStream', 4, { type: 2, sourceName: decodedTrack.sourceName, query: decodedTrack.title, message: `Expected 200, received ${res.statusCode}.` })
+
+        return resolve({
+          status: 1,
+          exception: {
+            message: `Failed to retrieve stream from source. Expected 200, received ${res.statusCode}.`,
+            severity: 'suspicious',
+            cause: 'Wrong status code'
+          }
+        })
+      }
+
+      const stream = new PassThrough()
+
+      res.stream.on('data', (chunk) => stream.write(chunk))
+      res.stream.on('end', () => stream.end())
+      res.stream.on('error', (error) => {
+        debugLog('retrieveStream', 4, { type: 2, sourceName: decodedTrack.sourceName, query: decodedTrack.title, message: error.message })
+
+        resolve({
+          status: 1,
+          exception: {
+            message: error.message,
+            severity: 'fault',
+            cause: 'Unknown'
+          }
+        })
+      })
+
+      resolve({
+        stream
+      })
+    }
+  })
+}
+
+async function loadTracks(identifier) {
+  const ytSearch = config.search.sources.youtube ? identifier.startsWith('ytsearch:') : null
+  const ytRegex = config.search.sources.youtube && !ytSearch ? /^(?:(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/(?:shorts\/(?:\?v=)?[a-zA-Z0-9_-]{11}|playlist\?list=[a-zA-Z0-9_-]+|watch\?(?=.*v=[a-zA-Z0-9_-]{11})[^\s]+))|(?:https?:\/\/)?(?:www\.)?youtu\.be\/[a-zA-Z0-9_-]{11})/.test(identifier) : null
+  if (config.search.sources.youtube && (ytSearch || ytRegex))
+    return ytSearch ? youtube.search(identifier.replace('ytsearch:', ''), 'youtube', true) : youtube.loadFrom(identifier, 'youtube')
+
+  const ytMusicSearch = config.search.sources.youtube ? identifier.startsWith('ytmsearch:') : null
+  const ytMusicRegex = config.search.sources.youtube && !ytMusicSearch ? /^(https?:\/\/)?(music\.)?youtube\.com\/(?:shorts\/(?:\?v=)?[a-zA-Z0-9_-]{11}|playlist\?list=[a-zA-Z0-9_-]+|watch\?(?=.*v=[a-zA-Z0-9_-]{11})[^\s]+)$/.test(identifier) : null
+  if (config.search.sources.youtube && (ytMusicSearch || ytMusicRegex))
+    return ytMusicSearch ? youtube.search(identifier.replace('ytmsearch:', ''), 'ytmusic', true) : youtube.loadFrom(identifier, 'ytmusic')
+
+  const spSearch = config.search.sources.spotify.enabled ? identifier.startsWith('spsearch:') : null
+  const spRegex = config.search.sources.spotify.enabled && !spSearch ? /^https?:\/\/(?:open\.spotify\.com\/|spotify:)(?:[^?]+)?(track|playlist|artist|episode|show|album)[/:]([A-Za-z0-9]+)/.exec(identifier) : null
+  if (config.search.sources[config.search.defaultSearchSource] && (spSearch || spRegex))
+    return spSearch ? spotify.search(identifier.replace('spsearch:', '')) : spotify.loadFrom(identifier, spRegex)
+
+  const dzSearch = config.search.sources.deezer.enabled ? identifier.startsWith('dzsearch:') : null
+  const dzRegex = config.search.sources.deezer.enabled && !dzSearch ? /^https?:\/\/(?:www\.)?deezer\.com\/(?:[a-z]{2}\/)?(track|album|playlist)\/(\d+)/.exec(identifier) : null
+  if (config.search.sources.deezer.enabled && (dzSearch || dzRegex))
+    return dzSearch ? deezer.search(identifier.replace('dzsearch:', ''), true) : deezer.loadFrom(identifier, dzRegex)
+
+  const scSearch = config.search.sources.soundcloud.enabled ? identifier.startsWith('scsearch:') : null
+  const scRegex = config.search.sources.soundcloud.enabled && !scSearch ? /^(https?:\/\/)?(www.)?(m\.)?soundcloud\.com\/[\w\-\.]+(\/)+[\w\-\.]+?$/.test(identifier) : null
+  if (config.search.sources.soundcloud.enabled && (scSearch || scRegex))
+    return scSearch ? soundcloud.search(identifier.replace('scsearch:', ''), true) : soundcloud.loadFrom(identifier)
+
+  const bcSearch = config.search.sources.bandcamp ? identifier.startsWith('bcsearch:') : null
+  const bcRegex = config.search.sources.bandcamp && !bcSearch ? /^https?:\/\/[\w-]+\.bandcamp\.com(\/(track|album)\/[\w-]+)?/.test(identifier) : null
+  if (config.search.sources.bandcamp && (bcSearch || bcRegex))
+    return bcSearch ? bandcamp.search(identifier.replace('bcsearch:', ''), true) : bandcamp.loadFrom(identifier)
+
+  const pdSearch = config.search.sources.pandora ? identifier.startsWith('pdsearch:') : null
+  const pdRegex = config.search.sources.pandora && !pdSearch ? /^https:\/\/www\.pandora\.com\/(?:playlist|station|podcast|artist)\/.+/.exec(identifier) : null
+  if (config.search.sources.pandora && (pdSearch || pdRegex))
+    return pdSearch ? pandora.search(identifier.replace('pdsearch:', '')) : pandora.loadFrom(identifier)
+
+  if (config.search.sources.http && (identifier.startsWith('http://') || identifier.startsWith('https://')))
+    return httpSource.loadFrom(identifier)
+
+  if (config.search.sources.local && identifier.startsWith('local:'))
+    return local.loadFrom(identifier.replace('local:', ''))
+
+  debugLog('loadTracks', 1, { params: identifier, error: 'No possible search source found.' })
+
+  return { loadType: 'empty', data: {} }
+}
+
+function loadLyrics(parsedUrl, req, decodedTrack, language, fallback) {
+  return new Promise(async (resolve) => {
+    let captions = { loadType: 'empty', data: {} }
+
+    switch (fallback ? config.search.lyricsFallbackSource : decodedTrack.sourceName) {
+      case 'ytmusic':
+      case 'youtube': {
+        if (!config.search.sources.youtube) {
+          debugLog('loadlyrics', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'No possible search source found.' })
+
+          break
+        }
+
+        captions = await youtube.loadLyrics(decodedTrack, language) || captions
+
+        if (captions.loadType === 'error')
+          captions = await loadLyrics(parsedUrl, req, decodedTrack, language, true)
+
+        break
+      }
+      case 'spotify': {
+        if (!config.search.sources[config.search.defaultSearchSource] || !config.search.sources.spotify.enabled) {
+          debugLog('loadlyrics', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'No possible search source found.' })
+
+          break
+        }
+
+        if (config.search.sources.spotify.sp_dc === 'DISABLED')
+          return resolve(loadLyrics(parsedUrl, decodedTrack, language, true))
+
+        captions = await spotify.loadLyrics(decodedTrack, language) || captions
+
+        if (captions.loadType === 'error')
+          captions = await loadLyrics(parsedUrl, req, decodedTrack, language, true)
+
+        break
+      }
+      case 'deezer': {
+        if (!config.search.sources.deezer.enabled) {
+          debugLog('loadlyrics', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'No possible search source found.' })
+
+          break
+        }
+
+        if (config.search.sources.deezer.arl === 'DISABLED')
+          return resolve(loadLyrics(parsedUrl, decodedTrack, language, true))
+
+        captions = await deezer.loadLyrics(decodedTrack, language) || captions
+
+        if (captions.loadType === 'error')
+          captions = await loadLyrics(parsedUrl, req, decodedTrack, language, true)
+
+        break
+      }
+      case 'genius': {
+        if (!config.search.sources.genius.enabled) {
+          debugLog('loadlyrics', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'No possible search source found.' })
+
+          break
+        }
+
+        captions = await genius.loadLyrics(decodedTrack, language) || captions
+
+        break
+      }
+      case 'musixmatch': {
+        if (!config.search.sources.musixmatch.enabled) {
+          debugLog('loadlyrics', 1, { params: parsedUrl.pathname, headers: req.headers, error: 'No possible search source found.' })
+
+          break
+        }
+
+        captions = await musixmatch.loadLyrics(decodedTrack, language) || captions
+
+        break
+      }
+      default: {
+        captions = await loadLyrics(parsedUrl, req, decodedTrack, language, true)
+      }
+    }
+
+    resolve(captions)
+  })
+}
+
+export default {
+  getTrackURL,
+  getTrackStream,
+  loadTracks,
+  loadLyrics,
+  bandcamp,
+  deezer,
+  http: httpSource,
+  local,
+  pandora,
+  soundcloud,
+  spotify,
+  youtube,
+  genius,
+  musixmatch
+}

src/sources/bandcamp.js

@@ -0,0 +1,203 @@
+import config from '../../config.js'
+import { debugLog, makeRequest, encodeTrack } from '../utils.js'
+
+async function loadFrom(url) {
+  const { body: data } = await makeRequest(url, { method: 'GET' })
+  const matches = /<script type="application\/ld\+json">([\s\S]*?)<\/script>/.exec(data)
+
+  if (!matches.length) {
+    debugLog('loadtracks', 4, { type: 2, loadType: 'empty', sourceName: 'BandCamp', query: url, message: 'No matches found.' })
+
+    return {
+      loadType: 'empty',
+      data: {}
+    }
+  }
+
+  const trackInfo = JSON.parse(matches[1])
+
+  debugLog('loadtracks', 4, { type: 1, loadType: trackInfo['@type'] === 'MusicRecording' ? 'track' : 'album', sourceName: 'BandCamp', query: url })
+
+  switch (trackInfo['@type']) {
+    case 'MusicRecording': {
+      const identifier = trackInfo['@id'].match(/^https?:\/\/([^/]+)\/track\/([^/?]+)/)
+  
+      const track = {
+        identifier: `${identifier[1]}:${identifier[2]}`,
+        isSeekable: true,
+        author: trackInfo.byArtist.name,
+        length: (trackInfo.duration.split('P')[1].split('H')[0] * 3600000) + (trackInfo.duration.split('H')[1].split('M')[0] * 60000) + (trackInfo.duration.split('M')[1].split('S')[0] * 1000),
+        isStream: false,
+        position: 0,
+        title: trackInfo.name,
+        uri: trackInfo['@id'],
+        artworkUrl: trackInfo.image,
+        isrc: null,
+        sourceName: 'bandcamp'
+      }
+  
+      debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'BandCamp', track, query: url })
+  
+      return {
+        loadType: 'track',
+        data: {
+          encoded: encodeTrack(track),
+          info: track,
+          pluginInfo: {}
+        }
+      }
+    }
+    case 'MusicAlbum': {
+      const tracks = []
+
+      trackInfo.track.itemListElement.forEach((item) => {
+        const identifier = item.item['@id'].match(/^https?:\/\/([^/]+)\/track\/([^/?]+)/)
+
+        const track = {
+          identifier: `${identifier[1]}:${identifier[2]}`,
+          isSeekable: true,
+          author: trackInfo.byArtist.name,
+          length: (item.item.duration.split('P')[1].split('H')[0] * 3600000) + (item.item.duration.split('H')[1].split('M')[0] * 60000) + (item.item.duration.split('M')[1].split('S')[0] * 1000),
+          isStream: false,
+          position: 0,
+          title: item.item.name,
+          uri: item.item['@id'],
+          artworkUrl: trackInfo.image,
+          isrc: null,
+          sourceName: 'bandcamp'
+        }
+
+        tracks.push({
+          encoded: encodeTrack(track),
+          info: track,
+          pluginInfo: {}
+        })
+      })
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'album', sourceName: 'BandCamp', playlistName: trackInfo.name })
+
+      return {
+        loadType: 'album',
+        data: {
+          info: {
+            name: trackInfo.name,
+            selectedTrack: 0
+          },
+          tracks
+        }
+      }
+    }
+  }
+}
+
+async function search(query, shouldLog) {
+  if (shouldLog) debugLog('search', 4, { type: 1, sourceName: 'BandCamp', query })
+
+  const { body: data } = await makeRequest(`https://bandcamp.com/search?q=${encodeURI(query)}&item_type=t&from=results`, { method: 'GET' })
+
+  const names = data.match(/<div class="heading">\s+<a.*?>(.*?)<\/a>/gs)
+
+  if (!names) {
+    if (shouldLog) debugLog('search', 4, { type: 2, sourceName: 'BandCamp', query, message: 'No matches found.' })
+
+    return {
+      loadType: 'empty',
+      data: {}
+    }
+  }
+
+  const tracks = []
+
+  if (names.length > config.options.maxResultsLength)
+    names = names.slice(0, config.options.maxResultsLength)
+  
+  names.forEach((name) => {
+    tracks.push({
+      encoded: null,
+      info: {
+        identifier: null,
+        isSeekable: true,
+        author: null,
+        length: -1,
+        isStream: false,
+        position: 0,
+        title: name[1].trim(),
+        uri: null,
+        artworkUrl: null,
+        isrc: null,
+        sourceName: 'bandcamp'
+      },
+      pluginInfo: {}
+    })
+  })
+
+  if (!tracks.length) {
+    if (shouldLog) debugLog('search', 4, { type: 2, sourceName: 'BandCamp', query, message: 'No matches found.' })
+
+    return {
+      loadType: 'empty',
+      data: {}
+    }
+  }
+
+  const authors = data.match(/<div class="subhead">\s+(?:from\s+)?[\s\S]*?by (.*?)\s+<\/div>/gs)
+
+  authors.forEach((author, i) => {
+    tracks[i].info.author = author.split('by')[1].split('</div>')[0].trim()
+  })
+
+  const artworkUrls = data.match(/<div class="art">\s*<img src="(.+?)"/gs)
+
+  artworkUrls.forEach((artworkUrl, i) => {
+    tracks[i].info.artworkUrl = artworkUrl.split('"')[3].split('"')[0]
+  })
+
+  const urls = data.match(/<div class="itemurl">\s+<a.*?>(.*?)<\/a>/gs)
+
+  urls.forEach((url, i) => {
+    tracks[i].info.uri = url.split('">')[2].split('</a>')[0]
+    
+    const identifier = tracks[i].info.uri.match(/^https?:\/\/([^/]+)\/track\/([^/?]+)/)
+    tracks[i].info.identifier = `${identifier[1]}:${identifier[2]}`
+
+    tracks[i].encoded = encodeTrack(tracks[i].info)
+    tracks[i].pluginInfo = {}
+  })
+
+  if (shouldLog) debugLog('search', 4, { type: 2, sourceName: 'BandCamp', tracksLen: tracks.length, query })
+
+  return {
+    loadType: 'search',
+    data: tracks
+  }
+}
+
+async function retrieveStream(uri, title) {
+  const { body: data } = await makeRequest(uri, { method: 'GET' })
+
+  const streamURL = data.match(/https?:\/\/t4\.bcbits\.com\/stream\/[a-zA-Z0-9]+\/mp3-128\/\d+\?p=\d+&amp;ts=\d+&amp;t=[a-zA-Z0-9]+&amp;token=\d+_[a-zA-Z0-9]+/)
+
+  if (!streamURL) {
+    debugLog('retrieveStream', 4, { type: 2, sourceName: 'BandCamp', query: title, message: 'No stream URL was found.' })
+
+    return {
+      exception: {
+        message: 'Failed to get the stream from source.',
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  return {
+    url: streamURL[0],
+    protocol: 'https',
+    format: 'arbitrary'
+  }
+}
+
+export default {
+  loadFrom,
+  search,
+  retrieveStream
+}

src/sources/deezer.js

@@ -0,0 +1,428 @@
+import crypto from 'node:crypto'
+import { Buffer } from 'node:buffer'
+import { PassThrough } from 'node:stream'
+
+import config from '../../config.js'
+import { debugLog, makeRequest, encodeTrack } from '../utils.js'
+
+let sourceInfo = {
+  licenseToken: null,
+  csrfToken: null,
+  mediaUrl: null,
+  Cookie: null,
+  jwtToken: null
+}
+
+const bufferSize = 2048
+const IV = Buffer.from(Array.from({ length: 8 }, (_i, x) => x))
+
+async function init() {
+  if (sourceInfo.licenseToken) return;
+  // TODO: Need to reset when timestamp is expired
+
+  debugLog('deezer', 5, { type: 1, message: 'Fetching user data...' })
+
+  const res = await makeRequest(`https://www.deezer.com/ajax/gw-light.php?method=deezer.getUserData&input=3&api_version=1.0&api_token=${config.search.sources.deezer.apiToken}`, {
+    method: 'GET',
+    getCookies: true
+  })
+
+  sourceInfo.Cookie = res.headers['set-cookie'].join('; ')
+  
+  if (config.search.sources.deezer.arl !== 'DISABLED') {
+    sourceInfo.Cookie += `; arl=${config.search.sources.deezer.arl}`
+
+    const { body: jwtInfo } = await makeRequest('https://auth.deezer.com/login/arl?jo=p&rto=c&i=c', {
+      headers: {
+        Cookie: sourceInfo.Cookie
+      },
+      method: 'POST'
+    })
+
+    sourceInfo.jwtToken = JSON.parse(jwtInfo).jwt
+  } 
+
+  sourceInfo.licenseToken = res.body.results.USER.OPTIONS.license_token
+  sourceInfo.csrfToken = res.body.results.checkForm
+  sourceInfo.mediaUrl = res.body.results.URL_MEDIA
+
+  debugLog('deezer', 5, { type: 1, message: 'Successfully fetched user data.' })
+}
+
+async function loadFrom(query, type) {
+  let endpoint
+
+  switch (type[1]) {
+    case 'track':
+      endpoint = `track/${type[2]}`
+      break
+    case 'playlist':
+      endpoint = `playlist/${type[2]}`
+      break
+    case 'album':
+      endpoint = `album/${type[2]}`
+      break
+    default: {
+      return {
+        loadType: 'empty',
+        data: {}
+      }
+    }
+  }
+
+  debugLog('loadtracks', 4, { type: 1, loadType: type[1], sourceName: 'Deezer', query })
+
+  const { body: data } = await makeRequest(`https://api.deezer.com/2.0/${endpoint}`, { method: 'GET' })
+
+  if (data.error) {
+    if (data.error.code === 800) {
+      return {
+        loadType: 'empty',
+        data: {}
+      }
+    }
+
+    return {
+      loadType: 'error',
+      data: {
+        message: data.error.message,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  switch (type[1]) {
+    case 'track': {
+      const track = {
+        identifier: data.id.toString(),
+        isSeekable: true,
+        author: data.artist.name,
+        length: data.duration * 1000,
+        isStream: false,
+        position: 0,
+        title: data.title,
+        uri: data.link,
+        artworkUrl: data.album.cover_xl,
+        isrc: data.isrc,
+        sourceName: 'deezer'
+      }
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'Deezer', track, query })
+
+      return {
+        loadType: 'track',
+        data: {
+          encoded: encodeTrack(track),
+          info: track,
+          pluginInfo: {}
+        }
+      }
+    }
+    case 'album':
+    case 'playlist': {
+      const tracks = []
+
+      if (data.tracks.data.length > config.options.maxAlbumPlaylistLength)
+        data.tracks.data = data.tracks.data.slice(0, config.options.maxAlbumPlaylistLength)
+
+      data.tracks.data.forEach(async (item, i) => {
+        const track = {
+          identifier: item.id.toString(),
+          isSeekable: true,
+          author: item.artist.name,
+          length: item.duration * 1000,
+          isStream: false,
+          position: 0,
+          title: item.title,
+          uri: item.link,
+          artworkUrl: type[1] === 'album' ? data.cover_xl : data.picture_xl,
+          isrc: null,
+          sourceName: 'deezer'
+        }
+
+        tracks.push({
+          encoded: encodeTrack(track),
+          info: track,
+          pluginInfo: {}
+        })
+      })
+
+      debugLog('loadtracks', 4, { type: 2, loadType: type[1], sourceName: 'Deezer', playlistName: data.title })
+
+      return {
+        loadType: type[1],
+        data: {
+          info: {
+            name: data.title,
+            selectedTrack: 0
+          },
+          pluginInfo: {},
+          tracks
+        }
+      }
+    }
+  }
+}
+
+async function search(query, shouldLog) {
+  if (shouldLog) debugLog('search', 4, { type: 1, sourceName: 'Deezer', query })
+
+  const { body: data } = await makeRequest(`https://api.deezer.com/2.0/search?q=${encodeURI(query)}`, { method: 'GET' })
+
+  // This API doesn't give ISRC, must change to internal API
+
+  if (data.error) {
+    return {
+      loadType: 'error',
+      data: {
+        message: data.error.message,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  if (data.total === 0) {
+    if (shouldLog) debugLog('search', 4, { type: 3, sourceName: 'Deezer', query, message: 'No matches found.' })
+
+    return {
+      loadType: 'empty',
+      data: {}
+    }
+  }
+
+  const tracks = []
+
+  if (data.data.length > config.options.maxResultsLength)
+    data.data = data.data.filter((item, i) => i < config.options.maxResultsLength || item.type === 'track')
+
+  data.data.forEach(async (item) => {
+    const track = {
+      identifier: item.id.toString(),
+      isSeekable: true,
+      author: item.artist.name,
+      length: item.duration * 1000,
+      isStream: false,
+      position: 0,
+      title: item.title,
+      uri: item.link,
+      artworkUrl: item.album.cover_xl,
+      isrc: item.isrc,
+      sourceName: 'deezer'
+    }
+
+    tracks.push({
+      encoded: encodeTrack(track),
+      info: track,
+      pluginInfo: {}
+    })
+  })
+
+  if (shouldLog)
+    debugLog('search', 4, { type: 2, sourceName: 'Deezer', tracksLen: tracks.length, query })
+
+  return {
+    loadType: 'search',
+    data: tracks
+  }
+}
+
+async function retrieveStream(identifier, title) {
+  const { body: data } = await makeRequest(`https://www.deezer.com/ajax/gw-light.php?method=song.getListData&input=3&api_version=1.0&api_token=${sourceInfo.csrfToken}`, {
+    body: {
+      sng_ids: [ identifier ]
+    },
+    headers: {
+      Cookie: sourceInfo.Cookie
+    },
+    method: 'POST',
+    disableBodyCompression: true
+  })
+
+  if (data.error.length !== 0) {
+    const errorMessage = Object.keys(data.error).map((err) => data.error[err]).join('; ')
+
+    debugLog('retrieveStream', 4, { type: 2, sourceName: 'Deezer', query: title, message: errorMessage })
+
+    return {
+      exception: {
+        message: errorMessage,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  const trackInfo = data.results.data[0]
+
+  const { body: streamData } = await makeRequest('https://media.deezer.com/v1/get_url', {
+    body: {
+      license_token: sourceInfo.licenseToken,
+      media: [{
+        type: 'FULL',
+        formats: [{
+          cipher: 'BF_CBC_STRIPE',
+          format: 'FLAC'
+        }, {
+          cipher: 'BF_CBC_STRIPE',
+          format: 'MP3_256'
+        }, {
+          cipher: 'BF_CBC_STRIPE',
+          format: 'MP3_128'
+        }, {
+          cipher: 'BF_CBC_STRIPE',
+          format: 'MP3_MISC'
+        }]
+      }],
+      track_tokens: [ trackInfo.TRACK_TOKEN ]
+    },
+    method: 'POST',
+    disableBodyCompression: true
+  })
+
+  return {
+    url: streamData.data[0].media[0].sources[0].url,
+    protocol: 'https',
+    format: 'arbitrary',
+    additionalData: trackInfo
+  }
+}
+
+async function loadLyrics(decodedTrack, _language) {
+  const { body: video } = await makeRequest('https://pipe.deezer.com/api', {
+    headers: {
+      Cookie: sourceInfo.Cookie,
+      Authorization: `Bearer ${sourceInfo.jwtToken}`
+    },
+    body: {
+      operationName: 'SynchronizedTrackLyrics',
+      query: 'query SynchronizedTrackLyrics($trackId: String!) {\n  track(trackId: $trackId) {\n    ...SynchronizedTrackLyrics\n    __typename\n  }\n}\n\nfragment SynchronizedTrackLyrics on Track {\n  id\n  lyrics {\n    ...Lyrics\n    __typename\n  }\n  album {\n    cover {\n      small: urls(pictureRequest: {width: 100, height: 100})\n      medium: urls(pictureRequest: {width: 264, height: 264})\n      large: urls(pictureRequest: {width: 800, height: 800})\n      explicitStatus\n      __typename\n    }\n    __typename\n  }\n  __typename\n}\n\nfragment Lyrics on Lyrics {\n  id\n  copyright\n  text\n  writers\n  synchronizedLines {\n    ...LyricsSynchronizedLines\n    __typename\n  }\n  __typename\n}\n\nfragment LyricsSynchronizedLines on LyricsSynchronizedLine {\n  lrcTimestamp\n  line\n  lineTranslated\n  milliseconds\n  duration\n  __typename\n}',
+      variables: {
+        trackId: decodedTrack.identifier
+      }
+    },
+    method: 'POST',
+    disableBodyCompression: true
+  })
+
+  if (video.errors) {
+    const errorMessage = video.errors.map((err) => `${err.message} (${err.type})`).join('; ')
+
+    debugLog('loadlyrics', 4, { type: 3, track: decodedTrack, sourceName: 'Deezer', message: errorMessage })
+        
+    return {
+      loadType: 'error',
+      data: {
+        message: errorMessage,
+        severity: 'common',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  const lyricsEvents = video.data.track.lyrics.synchronizedLines.map((event) => {
+    return {
+      startTime: event.milliseconds,
+      endTime: event.milliseconds + event.duration,
+      text: event.line
+    }
+  })
+
+  return {
+    loadType: 'lyricsSingle',
+    data: {
+      name: 'original',
+      synced: true,
+      data: lyricsEvents,
+      rtl: false
+    }
+  }
+}
+
+function _calculateKey(songId) {
+  const key = config.search.sources.deezer.decryptionKey
+  const songIdHash = crypto.createHash('md5').update(songId, 'ascii').digest('hex')
+  const trackKey = Buffer.alloc(16)
+
+  for (let i = 0; i < 16; i++) {
+    trackKey.writeInt8(songIdHash[i].charCodeAt(0) ^ songIdHash[i + 16].charCodeAt(0) ^ key[i].charCodeAt(0), i)
+  }
+
+  return trackKey
+}
+
+function loadTrack(title, url, trackInfos) {
+  return new Promise(async (resolve) => {
+    const stream = new PassThrough()
+
+    const trackKey = _calculateKey(trackInfos.SNG_ID)
+    let buf = Buffer.alloc(0)
+    let i = 0
+
+    const res = await makeRequest(url, {
+      method: 'GET',
+      streamOnly: true
+    })
+
+    res.stream.on('end', () => stream.end())
+    res.stream.on('error', (error) => {
+      debugLog('retrieveStream', 4, { type: 2, sourceName: 'Deezer', query: title, message: error.message })
+
+      resolve({
+        status: 1,
+        exception: {
+          message: error.message,
+          severity: 'fault',
+          cause: 'Unknown'
+        }
+      })
+    })
+
+    res.stream.on('readable', () => {
+      let chunk = null
+      while (1) {
+        chunk = res.stream.read(bufferSize)
+
+        if (!chunk) {
+          if (res.stream.readableLength) {
+            chunk = res.stream.read(res.stream.readableLength)
+            buf = Buffer.concat([ buf, chunk ])
+          }
+
+          break
+        } else {
+          buf = Buffer.concat([ buf, chunk ])
+        }
+
+        while (buf.length >= bufferSize) {
+          const bufferSized = buf.subarray(0, bufferSize)
+
+          if (i % 3 === 0) {
+            const decipher = crypto.createDecipheriv('bf-cbc', trackKey, IV).setAutoPadding(false)
+    
+            stream.push(decipher.update(bufferSized))
+            stream.push(decipher.final())
+          } else {
+            stream.push(bufferSized)
+          }
+
+          i++
+      
+          buf = buf.subarray(bufferSize)
+        }
+      }
+
+      resolve(stream)
+    })
+  })
+}
+
+export default {
+  init,
+  loadFrom,
+  search,
+  retrieveStream,
+  loadLyrics,
+  loadTrack
+}

src/sources/default.js

@@ -0,0 +1,32 @@
+import config from '../../config.js'
+import youtube from './youtube.js'
+import soundcloud from './soundcloud.js'
+import bandcamp from './bandcamp.js'
+import deezer from './deezer.js'
+
+async function searchWithDefault(query, fallback) {
+  const searchSource = fallback ? config.search.fallbackSearchSource : config.search.defaultSearchSource
+
+  switch (searchSource) {
+    case 'ytmusic':
+    case 'youtube': {
+      return youtube.search(query, searchSource, false)
+    }
+    case 'soundcloud': {
+      return soundcloud.search(query, false)
+    }
+    case 'bandcamp': {
+      return bandcamp.search(query, false)
+    }
+    case 'deezer': {
+      return deezer.search(query, false)
+    }
+    default: {
+      console.warn(`[\u001b[33msources\u001b[37m]: Default search source: unknown, falling back to: ${config.search.fallbackSearchSource}`)
+
+      return searchWithDefault(query, true)
+    }
+  }
+}
+
+export default searchWithDefault

src/sources/genius.js

@@ -0,0 +1,58 @@
+import { makeRequest } from '../utils.js'
+
+async function search(query) {
+  const { body: data } = await makeRequest(`https://genius.com/api/search/multi?q=${encodeURIComponent(query)}`, {
+    method: 'GET'
+  })
+
+  if (data.response.sections[1].hits.length === 0) return null
+
+  return data.response.sections[1].hits[0].result.path
+}
+
+async function loadLyrics(decodedTrack, language) {
+  const searchResult = await search(`${decodedTrack.title} ${decodedTrack.author}`)
+
+  if (!searchResult) return null
+
+  const { body: data } = await makeRequest(`https://genius.com${searchResult}`, {
+    method: 'GET'
+  })
+
+  const trackInfo = JSON.parse(data.match(/JSON.parse\('(.*)'\);/)[1].replace(/\\(.)/g, '$1'))
+
+  const lyricsEvents = []
+  trackInfo.songPage.lyricsData.body.children[0].children.forEach((text) => {
+    if (typeof text === 'object') {
+      if (!text.children) return;
+
+      text.children.forEach((child) => {
+        if (typeof child !== 'string') return;
+
+        lyricsEvents.push({
+          text: child
+        })
+      })
+
+      return;
+    }
+
+    lyricsEvents.push({
+      text
+    })
+  })
+
+  return {
+    loadType: 'lyricsSingle',
+    data: {
+      name: 'original',
+      synced: false,
+      data: lyricsEvents,
+      rtl: false
+    }
+  }
+}
+
+export default {
+  loadLyrics
+}

src/sources/http.js

@@ -0,0 +1,61 @@
+import { debugLog, makeRequest, encodeTrack } from '../utils.js'
+
+async function loadFrom(uri) {
+  const type = uri.startsWith('http://') ? 'http' : 'https'
+  debugLog('loadtracks', 4, { type: 1, loadType: 'track', sourceName: type, query: uri })
+
+  const data = await makeRequest(uri, { method: 'HEAD' })
+  
+  if (data.error) {
+    debugLog('loadtracks', 4, { type: 3, loadType: 'track', sourceName: type, query: uri, message: 'Not possible to connect to the URL.', })
+
+    return {
+      message: 'Not possible to connect to the URL.',
+      severity: 'fault',
+      cause: 'Unknown'
+    }
+  }
+
+
+  if (!data.headers || !data.headers['content-type']?.startsWith('audio/')) {
+    debugLog('loadtracks', 4, { type: 2, loadType: 'error', sourceName: type, query: uri, message: 'Url is not a playable stream.' })
+
+    return {
+      loadType: 'error',
+      data: {
+        message: 'URL is not a playable stream.',
+        severity: 'common',
+        cause: 'Invalid URL'
+      }
+    }
+  }
+
+  const track = {
+    identifier: 'unknown',
+    isSeekable: false,
+    author: 'unknown',
+    length: -1,
+    isStream: false,
+    position: 0,
+    title: 'unknown',
+    uri,
+    artworkUrl: null,
+    isrc: null,
+    sourceName: type
+  }
+
+  debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: type, track, query: uri })
+
+  return {
+    loadType: 'track',
+    data: {
+      encoded: encodeTrack(track),
+      info: track,
+      pluginInfo: {}
+    }
+  }
+}
+
+export default {
+  loadFrom
+}

src/sources/local.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs'
+
+import { debugLog, encodeTrack } from '../utils.js'
+
+function loadFrom(path) {
+  return new Promise((resolve) => {
+    debugLog('loadtracks', 4, { type: 1, loadType: 'track', sourceName: 'local', query: path })
+
+    fs.open(path, (err) => {
+      if (err) {
+        debugLog('loadtracks', 4, { type: 2, loadType: 'error', sourceName: 'local', query: path, message: 'Failed to retrieve stream from source. (File not found or not accessible)' })
+
+        return resolve({
+          loadType: 'error',
+          data: {
+            message: 'Failed to retrieve stream from source. (File not found or not accessible)',
+            severity: 'common',
+            cause: 'No permission to access file or doesn\'t exist'
+          }
+        })
+      }
+    
+      const track = {
+        identifier: 'unknown',
+        isSeekable: false,
+        author: 'unknown',
+        length: -1,
+        isStream: false,
+        position: 0,
+        title: 'unknown',
+        uri: path,
+        artworkUrl: null,
+        isrc: null,
+        sourceName: 'local'
+      }
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'local', track, query: path })
+
+      resolve({
+        loadType: 'track',
+        data: {
+          encoded: encodeTrack(track),
+          info: track,
+          pluginInfo: {}
+        }
+      })
+    })
+  })
+}
+
+export default {
+  loadFrom
+}

src/sources/musixmatch.js

@@ -0,0 +1,164 @@
+import crypto from 'node:crypto'
+
+import config from '../../config.js'
+import { debugLog, makeRequest } from '../utils.js'
+
+function _getGuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (character) => {
+    const random = 16 * Math.random() | 0
+    const value = character === 'x' ? random : 3 & random | 8
+
+    return value.toString(16)
+  })
+}
+
+let sourceInfo = {
+  guid: null
+}
+
+function init() {
+  sourceInfo.guid = _getGuid()
+
+  debugLog('musixmatch', 5, { message: `New guid: ${sourceInfo.guid}` })
+}
+
+function _signUrl(url) {
+  const time = new Date
+  const year = time.getUTCFullYear()
+  let month = time.getUTCMonth() + 1
+  month < 10 && (month = '0' + month)
+  let day = time.getUTCDate()
+  day < 10 && (day = '0' + day)
+
+  let superKey = crypto.createHmac('sha1', config.search.sources.musixmatch.signatureSecret)
+  superKey = superKey.update(url + year + month + day)
+  superKey = superKey.digest('base64')
+
+  return url + `&signature=${encodeURIComponent(superKey)}&signature_protocol=sha1`
+}
+
+function _normalizeLanguage(language) {
+  switch (language) {
+    case 'ara': return 'ar'
+    case 'afr': return 'af'
+    case 'ind': return 'id'
+    case 'kan': return 'kn'
+    case 'kor': return 'ko'
+    case 'rkr': return 'rk'
+    case 'zho': return 'zh'
+    case 'rz0': return 'rz'
+    case 'zht': return 'z1'
+    case 'ces': return 'cs'
+    case 'deu': return 'de'
+    case 'nld': return 'nl'
+    case 'spa': return 'es'
+    case 'dan': return 'da'
+    case 'ell': return 'el'
+    case 'eng': return 'en'
+    case 'fas': return 'fa'
+    case 'fin': return 'fi'
+    case 'fra': return 'fr'
+    case 'heb': return 'he'
+    case 'hin': return 'hi'
+    case 'ita': return 'it'
+    case 'jpn': return 'ja'
+    case 'hun': return 'hu'
+    case 'rja': return 'rj'
+    case 'nor': return 'no'
+    case 'pol': return 'pl'
+    case 'por': return 'pt'
+    case 'pt-br': return 'pt-br'
+    case 'rus': return 'ru'
+    case 'ron': return 'ro'
+    case 'tur': return 'tr'
+    case 'lit': return 'lt'
+    case 'mas': return 'ms'
+    case 'mkd': return 'mk'
+    case 'sqi': return 'sq'
+    case 'hye': return 'hy'
+    case 'aze': return 'az'
+    case 'ben': return 'bn'
+    case 'bos': return 'bs'
+    case 'bul': return 'bg'
+    case 'hrv': return 'hr'
+    case 'est': return 'et'
+    case 'fil': return 'f1'
+    case 'kat': return 'ka'
+    case 'hat': return 'ht'
+    case 'isl': return 'is'
+    case 'kaz': return 'kk'
+    case 'kir': return 'ky'
+    case 'lao': return 'lo'
+    case 'lav': return 'lv'
+    case 'mon': return 'mn'
+    case 'msa': return 'ms'
+    case 'nep': return 'ne'
+    case 'pan': return 'pa'
+    case 'srp': return 'sr'
+    case 'slk': return 'sk'
+    case 'slv': return 'sl'
+    case 'swe': return 'se'
+    case 'tha': return 'th'
+    case 'ukr': return 'uk'
+    case 'uzb': return 'uz'
+    case 'vie': return 'vi'
+  }
+}
+
+async function search(query) {
+  init()
+  const { body: data } = await makeRequest(_signUrl(`https://www.musixmatch.com/ws/1.1/macro.search?app_id=community-app-v1.0&part=track_artist,track_lyrics_translation_status&guid=${sourceInfo.guid}&format=json&q=${encodeURIComponent(query)}&page_size=1`), {
+    method: 'GET'
+  })
+
+  return data.message.body.macro_result_list.track_list[0].track
+}
+
+async function loadLyrics(decodedTrack, language) {
+  const searchResults = await search(`${decodedTrack.title} ${decodedTrack.artist}`)
+
+  if (!searchResults) return null
+
+  const { body: data } = await makeRequest(_signUrl(`https://www.musixmatch.com/ws/1.1/track.lyrics.get?page_size=100&page=1&commontrack_id=${searchResults.commontrack_id}&format=json&app_id=community-app-v1.0&guid=${sourceInfo.guid}`), {
+    method: 'GET'
+  })
+
+  const lyricsEvents = data.message.body.lyrics.lyrics_body.split('\n').map((text) => {
+    return {
+      text
+    }
+  })
+
+  if (language && language !== searchResults.lyrics_language && searchResults.track_lyrics_translation_status.find((status) => _normalizeLanguage(status.to) === language)) {
+    const { body: data } = await makeRequest(_signUrl(`https://www.musixmatch.com/ws/1.1/crowd.track.translations.get?page_size=1&selected_language=${language}&track_id=${searchResults.track_id}&format=json&app_id=community-app-v1.0&guid=${sourceInfo.guid}`), {
+      method: 'GET'
+    })
+
+    lyricsEvents.forEach((text, i) => {
+      if (text.text === '') return;
+
+      data.message.body.translations_list.forEach((translation) => {
+        if (text.text && text.text.replace(/′/, '\'') === translation.translation.matched_line) {
+          lyricsEvents[i].text = translation.translation.description
+        }
+      })
+    })
+  } else {
+    language = searchResults.lyrics_language
+  }
+
+  return {
+    loadType: 'lyricsSingle',
+    data: {
+      name: language,
+      synced: false,
+      data: lyricsEvents,
+      rtl: false
+    }
+  }
+}
+
+export default {
+  init,
+  loadLyrics
+}

src/sources/pandora.js

@@ -0,0 +1,919 @@
+import config from '../../config.js'
+import { debugLog, makeRequest, encodeTrack, http1makeRequest } from '../utils.js'
+import searchWithDefault from './default.js'
+
+let csrfToken = null
+let authToken = null
+
+async function init() {
+  debugLog('pandora', 5, { type: 1, message: 'Setting Pandora auth and CSRF token.' })
+
+  const { headers: headers } = await makeRequest('https://www.pandora.com', { method: 'HEAD' })
+  const csfr = headers['set-cookie']
+
+  if (!csfr[1]) return debugLog('pandora', 5, { type: 2, message: 'Failed to set CSRF token from Pandora.' })
+
+  csrfToken = { raw: csfr[1], parsed: /csrftoken=([a-f0-9]{16});/.exec(csfr[1])[1] }
+
+  const { body: token } = await makeRequest('https://www.pandora.com/api/v1/auth/anonymousLogin', {
+    headers: {
+      'Cookie': csrfToken.raw,
+      'Content-Type': 'application/json',
+      'Accept': '*/*',
+      'X-CsrfToken': csrfToken.parsed
+    },
+    method: 'POST'
+  })
+
+  if (token.errorCode === 0) return debugLog('pandora', 5, { type: 2, message: 'Failed to set auth token from Pandora.' })
+
+  authToken = token.authToken
+
+  debugLog('pandora', 5, { type: 1, message: 'Successfully set Pandora auth and CSRF token.' })
+}
+
+async function search(query) {
+  return new Promise(async (resolve) => {
+    debugLog('search', 4, { type: 1, sourceName: 'Pandora', query })
+
+    const body = {
+      query,
+      types: ['TR'],
+      listener: null,
+      start: 0,
+      count: config.options.maxResultsLength,
+      annotate: true,
+      searchTime: 0,
+      annotationRecipe: 'CLASS_OF_2019'
+    }
+   
+    const { body: data } = await makeRequest('https://www.pandora.com/api/v3/sod/search', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': '*/*',
+        'Content-Length': JSON.stringify(body).length
+      },
+      body,
+      disableBodyCompression: true
+    })
+
+    if (data.results.length === 0) {
+      return {
+        loadType: 'empty',
+        data: {}
+      }
+    }
+
+    const tracks = []
+    let index = 0
+
+    let annotationKeys = Object.keys(data.annotations)
+
+    if (annotationKeys.length > config.options.maxResultsLength)
+      annotationKeys = annotationKeys.slice(0, config.options.maxResultsLength)
+
+    annotationKeys.forEach(async (key) => {
+      if (data.annotations[key].type === 'TR') {
+        const search = await searchWithDefault(`${data.annotations[key].name} ${data.annotations[key].artistName}`)
+
+        if (search.loadType === 'search') {
+          const track = {
+            identifier: search.data[0].info.identifier,
+            isSeekable: true,
+            author: data.annotations[key].artistName,
+            length: search.data[0].info.length,
+            isStream: false,
+            position: 0,
+            title: data.annotations[key].name,
+            uri: `https://www.pandora.com${data.annotations[key].shareableUrlPath}`,
+            artworkUrl: `https://content-images.p-cdn.com/${data.annotations[key].icon.artUrl}`,
+            isrc: data.annotations[key].isrc,
+            sourceName: 'pandora'
+          }
+
+          tracks.push({
+            encoded: encodeTrack(track),
+            info: track,
+            playlistInfo: {}
+          })
+        }
+      }
+
+      if (index !== data.results.length - 1) return index++
+
+      const new_tracks = []
+      annotationKeys.nForEach(async (key2) => {
+        await tracks.nForEach((track) => {
+          if (track.info.title !== data.annotations[key2].name || track.info.author !== data.annotations[key2].artistName) return false
+
+          new_tracks.push(track)
+
+          return true
+        })
+
+        if (new_tracks.length !== tracks.length) return false
+
+        debugLog('search', 4, { type: 2, sourceName: 'Pandora', tracksLen: new_tracks.length, query })
+
+        resolve({
+          loadType: 'search',
+          data: new_tracks
+        })
+
+        return true
+      })
+    })
+  })
+}
+
+async function loadFrom(query) {
+  return new Promise(async (resolve) => {
+    const type = /^(https:\/\/www\.pandora\.com\/)((playlist)|(station)|(podcast)|(artist))\/.+/.exec(query)
+
+    debugLog('loadtracks', 4, { type: 1, loadType: type[2], sourceName: 'Pandora', query })
+
+    if (!type) {
+      return resolve({
+        loadType: 'empty',
+        data: {}
+      })
+    }
+
+    if (!csrfToken) {
+      return resolve({
+        loadType: 'error',
+        data: {
+          message: 'Pandora not available in current country.',
+          severity: 'common',
+          cause: 'Pandora availability'
+        }
+      })
+    }
+
+    let lastPart = query.split('/')
+    lastPart = lastPart[lastPart.length - 1]
+
+    switch (type[2]) {
+      case 'artist': {
+        const { body: trackData } = await http1makeRequest('https://www.pandora.com/api/v4/catalog/annotateObjectsSimple', {
+          body: {
+            pandoraIds: [ lastPart ],
+          },
+          headers: {
+            'Cookie': csrfToken.raw,
+            'X-CsrfToken': csrfToken.parsed,
+            'X-AuthToken': authToken,
+            'Content-Type': 'application/json',
+          },
+          method: 'POST',
+          disableBodyCompression: true
+        })
+
+        const keysTrackData = Object.keys(trackData)
+
+        let trackType = null
+        switch (trackData[keysTrackData[0]] ? trackData[keysTrackData[0]].type : 'unknown') {
+          case 'TR': trackType = 'track'; break
+          case 'AL': trackType = 'album'; break
+          case 'AR': trackType = 'artist'; break
+          default: trackType = 'unknown'; break
+        }
+
+        if (keysTrackData.length === 0) {
+          debugLog('loadtracks', 4, { type: 3, loadType: trackType, sourceName: 'Pandora', query, message: 'No matches found.' })
+
+          return resolve({
+            loadType: 'empty',
+            data: {}
+          })
+        }
+
+        if (trackData.message) {
+          debugLog('loadtracks', 4, { type: 3, loadType: trackType, sourceName: 'Pandora', query, message: trackData.message })
+      
+          return resolve({
+            loadType: 'error',
+            data: {
+              message: trackData.message,
+              severity: 'common',
+              cause: 'Unknown'
+            }
+          })
+        }
+
+        const trackId = trackData[keysTrackData[0]].pandoraId
+
+        switch (trackData[keysTrackData].type) {
+          case 'TR': {
+            const item = trackData[keysTrackData]
+
+            const search = await searchWithDefault(`${item.name} ${item.artistName}`)
+
+            if (search.loadType !== 'search')
+              return resolve(search)
+    
+            const track = {
+              identifier: search.data[0].info.identifier,
+              isSeekable: true,
+              author: item.artistName,
+              length: search.data[0].info.length,
+              isStream: false,
+              position: 0,
+              title: item.name,
+              uri: `https://www.pandora.com${item.shareableUrlPath}`,
+              artworkUrl: `https://content-images.p-cdn.com/${item.icon.artUrl}`,
+              isrc: item.isrc,
+              sourceName: 'pandora'
+            }
+
+            debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'Pandora', track, query })
+    
+            resolve({
+              loadType: 'track',
+              data: {
+                encoded: encodeTrack(track),
+                info: track,
+                playlistInfo: {}
+              }
+            })
+
+            break
+          }
+          case 'AL': {
+            const { body: data } = await http1makeRequest('https://www.pandora.com/api/v4/catalog/getDetails', {
+              body: {
+                pandoraId: trackId
+              },
+              headers: {
+                'Cookie': csrfToken.raw,
+                'X-CsrfToken': csrfToken.parsed,
+                'X-AuthToken': authToken
+              },
+              method: 'POST',
+              disableBodyCompression: true
+            })
+  
+            if (data.errors || typeof data !== 'object') {
+              const errorMessage = typeof data !== 'object' ? 'Unknown error' : data.errors.map((err) => `${err.message} (${err.extensions.code})`).join('; ')
+  
+              debugLog('loadtracks', 4, { type: 3, loadType: 'album', sourceName: 'Pandora', query, message: errorMessage })
+          
+              return resolve({
+                loadType: 'error',
+                data: {
+                  message: errorMessage,
+                  severity: 'common',
+                  cause: 'Unknown'
+                }
+              })
+            }
+  
+            const tracks = []
+            let index = 0
+
+            let trackKeys = Object.keys(data.annotations)
+  
+            if (trackKeys.length > config.options.maxAlbumPlaylistLength)
+              trackKeys = trackKeys.slice(0, config.options.maxAlbumPlaylistLength)
+  
+            trackKeys.forEach(async (key) => {
+              const search = await searchWithDefault(`${data.annotations[key].name} ${data.annotations[key].artistName}`)
+        
+              if (search.loadType === 'search') {
+                const track = {
+                  identifier: search.data[0].info.identifier,
+                  isSeekable: true,
+                  author: data.annotations[key].artistName,
+                  length: search.data[0].info.length,
+                  isStream: false,
+                  position: 0,
+                  title: data.annotations[key].name,
+                  uri: `https://www.pandora.com${data.annotations[key].shareableUrlPath}`,
+                  artworkUrl: `https://content-images.p-cdn.com/${data.annotations[key].icon.artUrl}`,
+                  isrc: data.annotations[key].isrc,
+                  sourceName: 'pandora'
+                }
+            
+                tracks.push({
+                  encoded: encodeTrack(track),
+                  info: track,
+                  playlistInfo: {}
+                })
+              }
+        
+              if (index !== trackKeys.length - 1) return index++
+
+              if (tracks.length === 0) {
+                debugLog('loadtracks', 4, { type: 3, loadType: 'album', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+                return resolve({
+                  loadType: 'empty',
+                  data: {}
+                })
+              }
+
+              const new_tracks = []
+              trackKeys.nForEach(async (key2) => {
+                await tracks.nForEach((track) => {
+                  if (track.info.title !== data.annotations[key2].name || track.info.author !== data.annotations[key2].artistName) return false
+
+                  new_tracks.push(track)
+
+                  return true
+                })
+      
+                if (new_tracks.length !== tracks.length) return false
+
+                debugLog('loadtracks', 4, { type: 2, loadType: 'album', sourceName: 'Pandora', playlistName: trackData[trackId].name })
+
+                resolve({
+                  loadType: 'album',
+                  data: {
+                    info: {
+                      name: trackData[trackId].name,
+                      selectedTrack: 0,
+                    },
+                    pluginInfo: {},
+                    tracks: new_tracks,
+                  }
+                })
+
+                return true
+              })
+            })
+
+            break
+          }
+          case 'AR': {
+            const { body: data } = await http1makeRequest('https://www.pandora.com/api/v1/graphql/graphql', {
+              body: {
+                operationName: 'GetArtistDetailsWithCuratorsWeb',
+                query: 'query GetArtistDetailsWithCuratorsWeb($pandoraId: String!) {\n  entity(id: $pandoraId) {\n    ... on Artist {\n      id\n      type\n      urlPath\n      name\n      trackCount\n      albumCount\n      bio\n      canSeedStation\n      stationListenerCount\n      albumCount\n      artistTracksId\n      art {\n        ...ArtFragment\n        __typename\n      }\n      isMegastar\n      headerArt {\n        ...ArtFragment\n        __typename\n      }\n      topTracksWithCollaborations {\n        ...TrackFragment\n        __typename\n      }\n      artistPlay {\n        id\n        __typename\n      }\n      events {\n        externalId\n        __typename\n      }\n      latestReleaseWithCollaborations {\n        ...AlbumFragment\n        __typename\n      }\n      topAlbumsWithCollaborations {\n        ...AlbumFragment\n        __typename\n      }\n      similarArtists {\n        id\n        name\n        art {\n          ...ArtFragment\n          __typename\n        }\n        urlPath\n        __typename\n      }\n      twitterHandle\n      twitterUrl\n      allArtistAlbums {\n        totalItems\n        __typename\n      }\n      curator {\n        ...CurationFragment\n        __typename\n      }\n      featured(types: [PL, AR, AL, TR, SF, PC, PE]) {\n        ... on Playlist {\n          ...PlaylistFragment\n          __typename\n        }\n        ... on StationFactory {\n          ...StationFactoryFragment\n          __typename\n        }\n        ... on Artist {\n          ...ArtistFragment\n          __typename\n        }\n        ... on Album {\n          ...AlbumFragment\n          __typename\n        }\n        ... on Track {\n          ...TrackFragment\n          __typename\n        }\n        ... on Podcast {\n          ...PodcastFragment\n          __typename\n        }\n        ... on PodcastEpisode {\n          ...PodcastEpisodeFragment\n          __typename\n        }\n        __typename\n      }\n      __typename\n    }\n    __typename\n  }\n}\n\nfragment ArtFragment on Art {\n  artId\n  dominantColor\n  artUrl: url(size: WIDTH_500)\n}\n\nfragment TrackFragment on Track {\n  pandoraId: id\n  type\n  name\n  sortableName\n  duration\n  trackNumber\n  explicitness\n  hasRadio: canSeedStation\n  shareableUrlPath: urlPath\n  modificationtime: dateModified\n  slugPlusPandoraId: slugPlusId\n  artistId: artist {\n    pandoraId: id\n    __typename\n  }\n  artistName: artist {\n    name\n    __typename\n  }\n  albumId: album {\n    pandoraId: id\n    __typename\n  }\n  albumName: album {\n    name\n    __typename\n  }\n  album {\n    urlPath\n    __typename\n  }\n  icon: art {\n    ...ArtFragment\n    __typename\n  }\n  rightsInfo: rights {\n    ...RightsFragment\n    __typename\n  }\n}\n\nfragment AlbumFragment on Album {\n  pandoraId: id\n  type\n  name\n  sortableName\n  duration\n  trackCount\n  releaseDate\n  explicitness\n  isCompilation\n  shareableUrlPath: urlPath\n  modificationTime: dateModified\n  slugPlusPandoraId: slugPlusId\n  artistId: artist {\n    pandoraId: id\n    __typename\n  }\n  artistName: artist {\n    name\n    __typename\n  }\n  icon: art {\n    ...ArtFragment\n    __typename\n  }\n  artist {\n    url\n    __typename\n  }\n  rightsInfo: rights {\n    ...RightsFragment\n    __typename\n  }\n}\n\nfragment CurationFragment on Curator {\n  curatedStations {\n    items {\n      ...StationFactoryFragment\n      __typename\n    }\n    __typename\n  }\n  playlists {\n    items {\n      ...PlaylistFragment\n      __typename\n    }\n    __typename\n  }\n}\n\nfragment PlaylistFragment on Playlist {\n  pandoraId: id\n  type\n  name\n  sortableName\n  description\n  duration\n  totalTracks\n  version\n  isEditable\n  linkedId\n  linkedType: origin\n  shareableUrlPath: urlPath\n  modificationTime: dateModified\n  unlocked: isUnlocked\n  autogenForListener: isOfAnyOrigin(origins: [PERSONALIZED, SHARED])\n  hasVoiceTrack: includesAny(types: [AM])\n  listenerIdInfo: owner {\n    listenerPandoraId: id\n    displayName\n    isMe\n    __typename\n  }\n  icon: art {\n    ...ArtFragment\n    __typename\n  }\n}\n\nfragment StationFactoryFragment on StationFactory {\n  pandoraId: id\n  type\n  name\n  sortableName\n  hasTakeoverModes\n  isHosted\n  shareableUrlPath: urlPath\n  modificationTime: dateModified\n  seedId: seed {\n    pandoraId: id\n    __typename\n  }\n  seedType: seed {\n    type\n    __typename\n  }\n  icon: art {\n    ...ArtFragment\n    __typename\n  }\n  listenerCount\n}\n\nfragment ArtistFragment on Artist {\n  pandoraId: id\n  type\n  name\n  sortableName\n  trackCount\n  collaboration: isCollaboration\n  megastar: isMegastar\n  shareableUrlPath: urlPath\n  modificationTime: dateModified\n  hasRadio: canSeedStation\n  icon: art {\n    ...ArtFragment\n    __typename\n  }\n}\n\nfragment PodcastFragment on Podcast {\n  pandoraId: id\n  type\n  name\n  sortableName\n  publisherName\n  ordering: releaseType\n  episodeCount: totalEpisodeCount\n  shareableUrlPath: urlPath\n  modificationTime: dateModified\n  icon: art {\n    ...ArtFragment\n    __typename\n  }\n  rightsInfo: rights {\n    ...RightsFragment\n    __typename\n  }\n}\n\nfragment PodcastEpisodeFragment on PodcastEpisode {\n  pandoraId: id\n  type\n  name\n  sortableName\n  duration\n  releaseDate\n  explicitness\n  shareableUrlPath: urlPath\n  modificationTime: dateModified\n  podcastId: podcast {\n    pandoraId: id\n    __typename\n  }\n  programName: podcast {\n    name\n    __typename\n  }\n  elapsedTime: playbackProgress {\n    elapsedTime\n    __typename\n  }\n  icon: art {\n    ...ArtFragment\n    __typename\n  }\n  rightsInfo: rights {\n    ...RightsFragment\n    __typename\n  }\n}\n\nfragment RightsFragment on Rights {\n  expirationTime\n  hasInteractive\n  hasRadioRights\n  hasOffline\n}\n',
+                variables: {
+                  pandoraId: trackId
+                }
+              },
+              headers: {
+                'Cookie': csrfToken.raw,
+                'X-CsrfToken': csrfToken.parsed,
+                'X-AuthToken': authToken
+              },
+              method: 'POST',
+              disableBodyCompression: true
+            })
+  
+            if (data.errors || typeof data !== 'object') {
+              const errorMessage = typeof data !== 'object' ? 'Unknown error' : data.errors.map((err) => `${err.message} (${err.extensions.code})`).join('; ')
+  
+              debugLog('loadtracks', 4, { type: 3, loadType: 'artist', sourceName: 'Pandora', query, message: errorMessage })
+          
+              return resolve({
+                loadType: 'error',
+                data: {
+                  message: errorMessage,
+                  severity: 'common',
+                  cause: 'Unknown'
+                }
+              })
+            }
+  
+            const tracks = []
+            let index = 0
+
+            let topTracks = data.data.entity.topTracksWithCollaborations
+  
+            if (topTracks.length > config.options.maxAlbumPlaylistLength)
+              topTracks = topTracks.slice(0, config.options.maxAlbumPlaylistLength)
+            
+            topTracks.forEach(async (pTrack) => {
+              const search = await searchWithDefault(`${pTrack.name} ${pTrack.artistName.name}`)
+        
+              if (search.loadType === 'search') {
+                const track = {
+                  identifier: search.data[0].info.identifier,
+                  isSeekable: true,
+                  author: pTrack.artistName.name,
+                  length: search.data[0].info.length,
+                  isStream: false,
+                  position: 0,
+                  title: pTrack.name,
+                  uri: `https://www.pandora.com${pTrack.shareableUrlPath}`,
+                  artworkUrl: pTrack.icon.artUrl,
+                  isrc: null,
+                  sourceName: 'pandora'
+                }
+          
+                tracks.push({
+                  encoded: encodeTrack(track),
+                  info: track,
+                  playlistInfo: {}
+                })
+              }
+        
+              if (index !== topTracks.length - 1) return index++
+
+              if (tracks.length === 0) {
+                debugLog('loadtracks', 4, { type: 3, loadType: 'artist', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+                return resolve({
+                  loadType: 'empty',
+                  data: {}
+                })
+              }
+
+              const new_tracks = []
+              topTracks.nForEach(async (pTrack2) => {
+                await tracks.nForEach((track) => {
+                  if (track.info.title !== pTrack2.name || track.info.author !== pTrack2.artistName.name) return false
+
+                  track.push(track)
+
+                  return true
+                })
+      
+                if (new_tracks.length !== tracks.length) return false
+
+                debugLog('loadtracks', 4, { type: 2, loadType: 'playlist', sourceName: 'Pandora', playlistName: data.data.entity.name })
+
+                resolve({
+                  loadType: 'artist',
+                  data: {
+                    info: {
+                      name: trackData[trackId].name,
+                      artworkUrl: `https://content-images.p-cdn.com/${trackData[trackId].icon.artUrl}`,
+                    },
+                    pluginInfo: {},
+                    tracks: new_tracks,
+                  }
+                })
+
+                return true
+              })
+            })
+
+            break
+          }
+        }
+
+        break
+      }
+      case 'playlist': {
+        const body = {
+          request: {
+            pandoraId: lastPart,
+            playlistVersion: 0,
+            offset: 0,
+            limit: config.options.maxAlbumPlaylistLength,
+            annotationLimit: config.options.maxAlbumPlaylistLength,
+            allowedTypes: ['TR', 'AM'],
+            bypassPrivacyRules: true
+          }
+        }
+
+        const { body: data } = await makeRequest('https://www.pandora.com/api/v7/playlists/getTracks', {
+          method: 'POST',
+          headers: {
+            'Cookie': csrfToken.raw,
+            'Content-Type': 'application/json',
+            'Accept': '*/*',
+            'Content-Length': JSON.stringify(body).length,
+            'X-CsrfToken': csrfToken.parsed,
+            'X-AuthToken': authToken
+          },
+          body,
+          disableBodyCompression: true
+        })
+    
+        const tracks = []
+        let index = 0
+
+        let keys = Object.keys(data.annotations).filter((key) => key.indexOf('TR:') !== -1)
+
+        if (keys.length > config.options.maxAlbumPlaylistLength)
+          keys = keys.slice(0, config.options.maxAlbumPlaylistLength)
+
+        keys.forEach(async (key) => {
+          const search = await searchWithDefault(`${data.annotations[key].name} ${data.annotations[key].artistName}`)
+    
+          if (search.loadType === 'search') {
+            const track = {
+              identifier: search.data[0].info.identifier,
+              isSeekable: data.annotations[key].visible,
+              author: data.annotations[key].artistName,
+              length: search.data[0].info.length,
+              isStream: false,
+              position: 0,
+              title: data.annotations[key].name,
+              uri: search.data[0].info.uri,
+              artworkUrl: `https://content-images.p-cdn.com/${data.annotations[key].icon.artUrl}`,
+              isrc: data.annotations[key].isrc,
+              sourceName: 'pandora'
+            }
+      
+            tracks.push({
+              encoded: encodeTrack(track),
+              info: track,
+              playlistInfo: {}
+            })
+          }
+    
+          if (index !== keys.length - 1) return index++
+
+          if (tracks.length === 0) {
+            debugLog('loadtracks', 4, { type: 3, loadType: 'playlist', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+            return resolve({
+              loadType: 'empty',
+              data: {}
+            })
+          }
+
+          const new_tracks = []
+          keys.nForEach(async (key2) => {
+            await tracks.nForEach((track) => {
+              if (track.info.title !== data.annotations[key2].name || track.info.author !== data.annotations[key2].artistName) return false
+
+              new_tracks.push(track)
+            
+              return true
+            })
+  
+            if (new_tracks.length !== tracks.length) return false
+
+            debugLog('loadtracks', 4, { type: 2, loadType: 'playlist', sourceName: 'Pandora', playlistName: data.name })
+
+            resolve({
+              loadType: 'playlist',
+              data: {
+                info: {
+                  name: data.name,
+                  selectedTrack: 0,
+                },
+                pluginInfo: {},
+                tracks: new_tracks,
+              }
+            })
+
+            return true
+          })
+        })
+
+        break
+      }
+      case 'station': {
+        const { body: stationData } = await http1makeRequest('https://www.pandora.com/api/v1/station/getStationDetails', {
+          body: {
+            stationId: lastPart
+          },
+          headers: {
+            'Cookie': csrfToken.raw,
+            'X-CsrfToken': csrfToken.parsed,
+            'X-AuthToken': authToken
+          },
+          method: 'POST',
+          disableBodyCompression: true
+        })
+
+        if (stationData.length === 0) {
+          debugLog('loadtracks', 4, { type: 3, loadType: 'station', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+          return resolve({
+            loadType: 'empty',
+            data: {}
+          })
+        }
+
+        if (stationData.message) {
+          debugLog('loadtracks', 4, { type: 3, loadType: 'station', sourceName: 'Pandora', query, message: stationData.message })
+      
+          return resolve({
+            loadType: 'error',
+            data: {
+              message: stationData.message,
+              severity: 'common',
+              cause: 'Unknown'
+            }
+          })
+        }
+
+        const tracks = []
+        let index = 0
+
+        let seeds = stationData.seeds
+
+        if (seeds.length > config.options.maxAlbumPlaylistLength)
+          seeds = seeds.slice(0, config.options.maxAlbumPlaylistLength)
+
+        seeds.forEach(async (seed) => {
+          const search = await searchWithDefault(`${seed.song.songTitle} ${seed.song.artistSummary}`)
+
+          if (search.loadType === 'search') {
+            const track = {
+              identifier: search.data[0].info.identifier,
+              isSeekable: true,
+              author: seed.song.artistSummary,
+              length: search.data[0].info.length,
+              isStream: false,
+              position: 0,
+              title: seed.song.songTitle,
+              uri: seed.song.songDetailUrl,
+              artworkUrl: seed.art[seed.art.length - 1].url,
+              isrc: null,
+              sourceName: 'pandora'
+            }
+
+            tracks.push({
+              encoded: encodeTrack(track),
+              info: track,
+              playlistInfo: {}
+            })
+          }
+
+          if (index !== seeds.length - 1) return index++
+
+          if (tracks.length === 0) {
+            debugLog('loadtracks', 4, { type: 3, loadType: 'station', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+            return resolve({
+              loadType: 'empty',
+              data: {}
+            })
+          }
+
+          const new_tracks = []
+          seeds.nForEach(async (seed2) => {
+            await tracks.nForEach((track) => {
+              if (track.info.title !== seed2.song.songTitle || track.info.author !== seed2.song.artistSummary) return false
+
+              new_tracks.push(track)
+
+              return true
+            })
+
+            if (new_tracks.length !== tracks.length) return false
+
+            debugLog('loadtracks', 4, { type: 2, loadType: 'station', sourceName: 'Pandora', playlistName: stationData.name })
+
+            resolve({
+              loadType: 'station',
+              data: {
+                info: {
+                  name: stationData.name,
+                  selectedTrack: 0,
+                },
+                pluginInfo: {},
+                tracks: new_tracks,
+              }
+            })
+
+            return true
+          })
+        })
+
+        break
+      }
+      case 'podcast': {
+        const { body: podcastData } = await http1makeRequest('https://www.pandora.com/api/v1/aesop/getDetails', {
+          body: {
+            catalogVersion: 4,
+            pandoraId: lastPart
+          },
+          headers: {
+            'Cookie': csrfToken.raw,
+            'X-CsrfToken': csrfToken.parsed,
+            'X-AuthToken': authToken
+          },
+          method: 'POST',
+          disableBodyCompression: true
+        })
+
+        if (podcastData.length === 0) {
+          debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+          return resolve({
+            loadType: 'empty',
+            data: {}
+          })
+        }
+
+        if (podcastData.message) {
+          debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: podcastData.message })
+      
+          return resolve({
+            loadType: 'error',
+            data: {
+              message: podcastData.message,
+              severity: 'common',
+              cause: 'Unknown'
+            }
+          })
+        }
+
+        const tracks = []
+        let index = 0
+
+        switch (podcastData.details.podcastProgramDetails ? podcastData.details.podcastProgramDetails.type : podcastData.details.podcastEpisodeDetails.type) {
+          case 'PE': {
+            const podcastEpisode = podcastData.details.annotations[Object.keys(podcastData.details.annotations).find((key) => key === podcastData.details.podcastEpisodeDetails.pandoraId)]
+
+            const search = await searchWithDefault(`${podcastEpisode.name} ${podcastEpisode.programName}`)
+
+            if (search.loadType !== 'search')
+              return resolve(search)
+
+            const track = {
+              identifier: search.data[0].info.identifier,
+              isSeekable: true,
+              author: podcastEpisode.programName,
+              length: search.data[0].info.length,
+              isStream: false,
+              position: 0,
+              title: podcastEpisode.name,
+              uri: `https://www.pandora.com${podcastEpisode.shareableUrlPath}`,
+              artworkUrl: `https://content-images.p-cdn.com/${podcastEpisode.icon.artUrl}`,
+              isrc: null,
+              sourceName: 'pandora'
+            }
+
+            debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'Pandora', track, query })
+
+            resolve({
+              loadType: 'track',
+              data: {
+                encoded: encodeTrack(track),
+                info: track,
+                playlistInfo: {}
+              }
+            })
+
+            break
+          }
+          case 'PC': {
+            const { body: allEpisodesIdsData } = await http1makeRequest('https://www.pandora.com/api/v1/aesop/getAllEpisodesByPodcastProgram', {
+              body: {
+                catalogVersion: 4,
+                pandoraId: lastPart
+              },
+              headers: {
+                'Cookie': csrfToken.raw,
+                'X-CsrfToken': csrfToken.parsed,
+                'X-AuthToken': authToken
+              },
+              method: 'POST',
+              disableBodyCompression: true
+            })
+
+            if (allEpisodesIdsData.length === 0) {
+              debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+              return resolve({
+                loadType: 'empty',
+                data: {}
+              })
+            }
+
+            if (allEpisodesIdsData.message) {
+              debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: allEpisodesIdsData.message })
+
+              return resolve({
+                loadType: 'error',
+                data: {
+                  message: allEpisodesIdsData.message,
+                  severity: 'common',
+                  cause: 'Unknown'
+                }
+              })
+            }
+
+            let allEpisodesIds = []
+            allEpisodesIdsData.episodes.episodesWithLabel.forEach((yearInfo) => {
+              allEpisodesIds.push(...yearInfo.episodes)
+            })
+
+            if (allEpisodesIds.length > config.options.maxAlbumPlaylistLength)
+              allEpisodesIds = allEpisodesIds.slice(0, config.options.maxAlbumPlaylistLength)
+
+            const { body: allEpisodesData } = await http1makeRequest('https://www.pandora.com/api/v1/aesop/annotateObjects', {
+              body: {
+                catalogVersion: 4,
+                pandoraIds: allEpisodesIds
+              },
+              headers: {
+                'Cookie': csrfToken.raw,
+                'X-CsrfToken': csrfToken.parsed,
+                'X-AuthToken': authToken
+              },
+              method: 'POST',
+              disableBodyCompression: true
+            })
+
+            if (allEpisodesData.length === 0) {
+              debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+              return resolve({
+                loadType: 'empty',
+                data: {}
+              })
+            }
+
+            if (allEpisodesData.message) {
+              debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: allEpisodesData.message })
+
+              return resolve({
+                loadType: 'error',
+                data: {
+                  message: allEpisodesData.message,
+                  severity: 'common',
+                  cause: 'Unknown'
+                }
+              })
+            }
+
+            let episodes = Object.keys(allEpisodesData.annotations)
+
+            episodes.forEach(async (episode) => {
+              episode = allEpisodesData.annotations[episode]
+
+              const search = await searchWithDefault(`${episode.name} ${episode.programName}`)
+
+              if (search.loadType === 'search') {
+                const track = {
+                  identifier: search.data[0].info.identifier,
+                  isSeekable: true,
+                  author: episode.programName,
+                  length: search.data[0].info.length,
+                  isStream: false,
+                  position: 0,
+                  title: episode.name,
+                  uri: `https://www.pandora.com${episode.shareableUrlPath}`,
+                  artworkUrl: `https://content-images.p-cdn.com/${episode.icon.artUrl}`,
+                  isrc: null,
+                  sourceName: 'pandora'
+                }
+
+                tracks.push({
+                  encoded: encodeTrack(track),
+                  info: track,
+                  playlistInfo: {}
+                })
+              }
+
+              if (index !== episodes.length - 1) return index++
+
+              if (tracks.length === 0) {
+                debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' })
+
+                return resolve({
+                  loadType: 'empty',
+                  data: {}
+                })
+              }
+
+              const new_tracks = []
+              episodes.nForEach(async (episode2) => {
+                if (typeof episode2 !== 'object') episode2 = allEpisodesData.annotations[episode2]
+
+                await tracks.nForEach((track) => {
+                  if (track.info.title !== episode2.name || track.info.author !== episode2.programName) return false
+
+                  new_tracks.push(track)
+
+                  return true
+                })
+      
+                if (new_tracks.length !== tracks.length) return false
+
+                const podcastName = podcastData.details.annotations[Object.keys(podcastData.details.annotations).find((key) => key === podcastData.details.podcastProgramDetails.pandoraId)].name
+
+                debugLog('loadtracks', 4, { type: 2, loadType: 'podcast', sourceName: 'Pandora', playlistName: podcastName })
+
+                resolve({
+                  loadType: 'podcast',
+                  data: {
+                    info: {
+                      name: podcastName,
+                      selectedTrack: 0,
+                    },
+                    pluginInfo: {},
+                    tracks: new_tracks,
+                  }
+                })
+
+                return true
+              })
+            })
+
+            break
+          }
+        }
+      }
+    }
+  })
+}
+
+export default {
+  init,
+  search,
+  loadFrom
+}

src/sources/soundcloud.js

@@ -0,0 +1,366 @@
+import { PassThrough } from 'node:stream'
+
+import config from '../../config.js'
+import { debugLog, encodeTrack, http1makeRequest, loadHLS } from '../utils.js'
+import searchWithDefault from './default.js'
+import sources from '../sources.js'
+
+const sourceInfo = {
+  clientId: null
+}
+
+async function init() {
+  if (config.search.sources.soundcloud.clientId !== 'AUTOMATIC') {
+    sourceInfo.clientId = config.search.sources.soundcloud.clientId
+
+    return;
+  }
+
+  debugLog('soundcloud', 5, { type: 1, message: 'clientId not provided. Fetching clientId...' })
+
+  const { body: mainpage } = await http1makeRequest('https://soundcloud.com', {
+    method: 'GET'
+  }).catch(() => {
+    debugLog('soundcloud', 5, { type: 2, message: 'Failed to fetch clientId.' })
+  })
+
+  const assetId = mainpage.match(/https:\/\/a-v2.sndcdn.com\/assets\/([a-zA-Z0-9-]+).js/gs)[5]
+
+  const { body: data } = await http1makeRequest(assetId, {
+    method: 'GET'
+  }).catch(() => {
+    debugLog('soundcloud', 5, { type: 2, message: 'Failed to fetch clientId.' })
+  })
+
+  const clientId = data.match(/client_id=([a-zA-Z0-9]{32})/)[1]
+
+  if (!clientId) {
+    debugLog('soundcloud', 5, { type: 2, message: 'Failed to fetch clientId.' })
+
+    return;
+  }
+
+  sourceInfo.clientId = clientId
+
+  debugLog('soundcloud', 5, { type: 1, message: 'Successfully fetched clientId.' })
+}
+
+async function loadFrom(url) {
+  let req = await http1makeRequest(`https://api-v2.soundcloud.com/resolve?url=${encodeURI(url)}&client_id=${sourceInfo.clientId}`, { method: 'GET' })
+
+  if (req.error || req.statusCode !== 200) {
+    const errorMessage = req.error ? req.error.message : `SoundCloud returned invalid status code: ${req.statusCode}`
+
+    debugLog('loadtracks', 4, { type: 2, loadType: 'unknown', sourceName: 'Soundcloud', query: url, message: errorMessage })
+
+    return {
+      loadType: 'error',
+      data: {
+        message: errorMessage,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  const body = req.body
+
+  if (typeof body !== 'object') {
+    debugLog('loadtracks', 4, { type: 3, loadType: 'unknown', sourceName: 'Soundcloud', query: url, message: 'Invalid response from SoundCloud.' })
+
+    return {
+      loadType: 'error',
+      data: {
+        message: 'Invalid response from SoundCloud.',
+        severity: 'common',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  debugLog('loadtracks', 4, { type: 1, loadType: body.kind || 'unknown', sourceName: 'SoundCloud', query: url })
+
+  if (Object.keys(body).length === 0) {
+    debugLog('loadtracks', 4, { type: 3, loadType: body.kind || 'unknown', sourceName: 'Soundcloud', query: url, message: 'No matches found.' })
+
+    return {
+      loadType: 'empty',
+      data: {}
+    }
+  }
+
+  switch (body.kind) {
+    case 'track': {
+      const track = {
+        identifier: body.id.toString(),
+        isSeekable: true,
+        author: body.user.username,
+        length: body.duration,
+        isStream: false,
+        position: 0,
+        title: body.title,
+        uri: body.permalink_url,
+        artworkUrl: body.artwork_url,
+        isrc: body.publisher_metadata ? body.publisher_metadata.isrc : null,
+        sourceName: 'soundcloud'
+      }
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'SoundCloud', track, query: url })
+
+      return {
+        loadType: 'track',
+        data: {
+          encoded: encodeTrack(track),
+          info: track,
+          playlistInfo: {}
+        }
+      }
+    }
+    case 'playlist': {
+      const tracks = []
+      const notLoaded = []
+
+      if (body.tracks.length > config.options.maxAlbumPlaylistLength)
+        data.tracks = body.tracks.slice(0, config.options.maxAlbumPlaylistLength)
+
+      body.tracks.forEach((item) => {
+        if (!item.title) {
+          notLoaded.push(item.id.toString())
+
+          return;
+        }
+
+        const track = {
+          identifier: item.id.toString(),
+          isSeekable: true,
+          author: item.user.username,
+          length: item.duration,
+          isStream: false,
+          position: 0,
+          title: item.title,
+          uri: item.permalink_url,
+          artworkUrl: item.artwork_url,
+          isrc: item.publisher_metadata?.isrc,
+          sourceName: 'soundcloud'
+        }
+
+        tracks.push({
+          encoded: encodeTrack(track),
+          info: track,
+          playlistInfo: {}
+        })
+      })
+
+      if (notLoaded.length) {
+        let stop = false
+
+        while ((notLoaded.length && !stop) && (tracks.length > config.options.maxAlbumPlaylistLength)) {
+          const notLoadedLimited = notLoaded.slice(0, 50)
+          data = await http1makeRequest(`https://api-v2.soundcloud.com/tracks?ids=${notLoadedLimited.join('%2C')}&client_id=${sourceInfo.clientId}`, { method: 'GET' })
+          data = data.body
+
+          data.forEach((item) => {
+            const track = {
+              identifier: item.id.toString(),
+              isSeekable: true,
+              author: item.user.username,
+              length: item.duration,
+              isStream: false,
+              position: 0,
+              title: item.title,
+              uri: item.permalink_url,
+              artworkUrl: item.artwork_url,
+              isrc: item.publisher_metadata ? item.publisher_metadata.isrc : null,
+              sourceName: 'soundcloud'
+            }
+
+            tracks.push({
+              encoded: encodeTrack(track),
+              info: track,
+              playlistInfo: {}
+            })
+          })
+
+          notLoaded.splice(0, 50)
+
+          if (notLoaded.length === 0)
+            stop = true
+        }
+      }
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'playlist', sourceName: 'SoundCloud', playlistName: data.title })
+
+      return {
+        loadType: 'playlist',
+        data: {
+          info: {
+            name: data.title,
+            selectedTrack: 0,
+          },
+          pluginInfo: {},
+          tracks,
+        }
+      }
+    }
+    case 'user': {
+      debugLog('loadtracks', 4, { type: 2, loadType: 'artist', sourceName: 'SoundCloud', playlistName: data.full_name })
+
+      return {
+        loadType: 'empty',
+        data: {}
+      }
+    }
+  }
+}
+
+async function search(query, shouldLog) {
+  if (shouldLog) debugLog('search', 4, { type: 1, sourceName: 'SoundCloud', query })
+
+  const req = await http1makeRequest(`https://api-v2.soundcloud.com/search?q=${encodeURI(query)}&variant_ids=&facet=model&user_id=992000-167630-994991-450103&client_id=${sourceInfo.clientId}&limit=${config.options.maxResultsLength}&offset=0&linked_partitioning=1&app_version=1679652891&app_locale=en`, { method: 'GET' })
+  const body = req.body
+
+  if (req.error || req.statusCode !== 200) {
+    const errorMessage = req.error ? req.error.message : `SoundCloud returned invalid status code: ${req.statusCode}`
+
+    debugLog('search', 4, { type: 2, sourceName: 'SoundCloud', query, message: errorMessage })
+
+    return {
+      exception: {
+        message: errorMessage,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  if (body.total_results === 0) {
+    debugLog('search', 4, { type: 2, sourceName: 'SoundCloud', query, message: 'No matches found.' })
+
+    return {
+      loadType: 'empty',
+      data: {}
+    }
+  }
+
+  const tracks = []
+
+  if (body.collection.length > config.options.maxSearchResults)
+    body.collection = body.collection.filter((item, i) => i < config.options.maxSearchResults || item.kind === 'track')
+
+  body.collection.forEach((item) => {
+    if (item.kind !== 'track') return;
+    
+    const track = {
+      identifier: item.id.toString(),
+      isSeekable: true,
+      author: item.user.username,
+      length: item.duration,
+      isStream: false,
+      position: 0,
+      title: item.title,
+      uri: item.uri,
+      artworkUrl: item.artwork_url,
+      isrc: null,
+      sourceName: 'soundcloud'
+    }
+
+    tracks.push({
+      encoded: encodeTrack(track),
+      info: track,
+      pluginInfo: {}
+    })
+  })
+
+  if (shouldLog)
+    debugLog('search', 4, { type: 2, sourceName: 'SoundCloud', tracksLen: tracks.length, query })
+
+  return {
+    loadType: 'search',
+    data: tracks
+  }
+}
+
+async function retrieveStream(identifier, title) {
+  const req = await http1makeRequest(`https://api-v2.soundcloud.com/resolve?url=https://api.soundcloud.com/tracks/${identifier}&client_id=${sourceInfo.clientId}`, { method: 'GET' })
+  const body = req.body
+
+  if (req.error || req.statusCode !== 200) {
+    const errorMessage = req.error ? req.error.message : `SoundCloud returned invalid status code: ${req.statusCode}`
+
+    debugLog('retrieveStream', 4, { type: 2, sourceName: 'SoundCloud', query: title, message: errorMessage })
+
+    return {
+      exception: {
+        message: errorMessage,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  if (body.errors) {
+    debugLog('retrieveStream', 4, { type: 2, sourceName: 'SoundCloud', query: title, message: body.errors[0].error_message })
+
+    return {
+      exception: {
+        message: body.errors[0].error_message,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  const oggOpus = body.media.transcodings.find((transcoding) => transcoding.format.mime_type === 'audio/ogg; codecs="opus"')
+  const transcoding = oggOpus || body.media.transcodings[0]
+
+  if (transcoding.snipped && config.search.sources.soundcloud.fallbackIfSnipped) {
+    debugLog('retrieveStream', 4, { type: 2, sourceName: 'SoundCloud', query: title, message: `Track is snipped, falling back to: ${config.search.fallbackSearchSource}.` })
+
+    const search = await searchWithDefault(title, true)
+
+    if (search.loadType === 'search') {
+      const urlInfo = await sources.getTrackURL(search.data[0].info)
+
+      return {
+        url: urlInfo.url,
+        protocol: urlInfo.protocol,
+        format: urlInfo.format,
+        additionalData: true
+      }
+    }
+  }
+
+  return {
+    url: `${transcoding.url}?client_id=${sourceInfo.clientId}`,
+    protocol: transcoding.format.protocol,
+    format: oggOpus ? 'ogg/opus' : 'arbitrary'
+  }
+}
+
+async function loadHLSStream(url) {
+  const streamHlsRedirect = await http1makeRequest(url, { method: 'GET' })
+
+  const stream = new PassThrough()
+  await loadHLS(streamHlsRedirect.body.url, stream)
+
+  return stream
+}
+
+async function loadFilters(url, protocol) {
+  if (protocol === 'hls') {
+    const streamHlsRedirect = await http1makeRequest(url, { method: 'GET' })
+
+    return streamHlsRedirect.body.url
+  } else {
+    return url
+  }
+}
+
+export default {
+  init,
+  loadFrom,
+  search,
+  retrieveStream,
+  loadHLSStream,
+  loadFilters
+}

src/sources/spotify.js

@@ -0,0 +1,472 @@
+import crypto from 'node:crypto'
+
+import config from '../../config.js'
+import { debugLog, makeRequest, encodeTrack, http1makeRequest } from '../utils.js'
+import searchWithDefault from './default.js'
+
+let playerInfo = {}
+
+async function init() {
+  debugLog('spotify', 5, { type: 1, message: 'Fetching token...' })
+
+  const { body: token } = await makeRequest('https://open.spotify.com/get_access_token', {
+    headers: {
+      ...(config.search.sources.spotify.sp_dc !== 'DISABLED' ? { Cookie: `sp_dc=${config.search.sources.spotify.sp_dc}` } : {})
+    },
+    method: 'GET'
+  })
+
+  if (typeof token !== 'object') {
+    debugLog('spotify', 5, { type: 2, message: 'Failed to fetch Spotify token.' })
+
+    return;
+  }
+
+  const { body: data } = await http1makeRequest(`https://clienttoken.spotify.com/v1/clienttoken`, {
+    body: {
+      client_data: {
+        client_version: '1.2.9.2269.g2fe25d39',
+        client_id: token.clientId,
+        js_sdk_data: {
+          device_brand: 'unknown',
+          device_model: 'unknown',
+          os: 'linux',
+          os_version: 'unknown',
+          device_id: crypto.randomUUID(),
+          device_type: 'computer'
+        }
+      }
+    },
+    headers: {
+      'Accept': 'application/json'
+    },
+    method: 'POST',
+    disableBodyCompression: true
+  })
+
+  if (typeof data !== 'object') {
+    debugLog('spotify', 5, { type: 2, message: 'Failed to fetch client token.' })
+
+    return;
+  }
+
+  if (data.response_type !== 'RESPONSE_GRANTED_TOKEN_RESPONSE') {
+    debugLog('spotify', 5, { type: 2, message: 'Failed to fetch client token.' })
+
+    return;
+  }
+
+  playerInfo = {
+    accessToken: token.accessToken,
+    clientToken: data.granted_token.token
+  }
+
+  debugLog('spotify', 5, { type: 1, message: 'Successfully fetched token.' })
+}
+
+async function search(query) {
+  return new Promise(async (resolve) => {
+    debugLog('search', 4, { type: 1, sourceName: 'Spotify', query })
+
+    const limit = config.options.maxResultsLength >= 50 ? 50 : config.options.maxResultsLength
+
+    const { body: data } = await makeRequest(`https://api.spotify.com/v1/search?q=${encodeURI(query)}&type=track&limit=${limit}&market=${config.search.sources.spotify.market}`, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${playerInfo.accessToken}`,
+        'client-token': playerInfo.clientToken,
+        'accept': 'application/json'
+      }
+    })
+
+    if (data.tracks.total === 0) {
+      debugLog('search', 4, { type: 3, sourceName: 'Spotify', query, message: 'No matches found.' })
+
+      return resolve({
+        loadType: 'empty',
+        data: {}
+      })
+    }
+      
+    const tracks = []
+
+    data.tracks.items.forEach(async (items) => {
+      const track = {
+        identifier: items.id,
+        isSeekable: true,
+        author: items.artists.map((artist) => artist.name).join(', '),
+        length: items.duration_ms,
+        isStream: false,
+        position: 0,
+        title: items.name,
+        uri: items.href,
+        artworkUrl: items.album.images[0].url,
+        isrc: items.external_ids.isrc,
+        sourceName: 'spotify'
+      }
+
+      tracks.push({
+        encoded: encodeTrack(track),
+        info: track,
+        pluginInfo: {}
+      })
+    })
+
+    if (tracks.length === 0) {
+      debugLog('search', 4, { type: 3, sourceName: 'Spotify', query, message: 'No matches found.' })
+
+      return resolve({
+        loadType: 'empty',
+        data: {}
+      })
+    }
+
+    debugLog('search', 4, { type: 2, loadType: 'track', sourceName: 'Spotify', tracksLen: tracks.length, query })
+
+    return resolve({
+      loadType: 'search',
+      data: tracks
+    })
+  })   
+}
+
+async function loadFrom(query, type) {
+  return new Promise(async (resolve) => {
+    let endpoint
+
+    switch (type[1]) {
+      case 'track': {
+        endpoint = `/tracks/${type[2]}?limit=${config.options.maxResultsLength}`
+
+        break
+      }
+      case 'playlist': {
+        endpoint = `/playlists/${type[2]}`
+
+        break
+      }
+      case 'album': {
+        endpoint = `/albums/${type[2]}?limit=${config.options.maxAlbumPlaylistLength < 100 ? config.options.maxAlbumPlaylistLength : 100}`
+
+        break
+      }
+      case 'episode': {
+        endpoint = `/episodes/${type[2]}?market=${config.search.sources.spotify.market}&limit=${config.options.maxAlbumPlaylistLength < 100 ? config.options.maxAlbumPlaylistLength : 100}`
+
+        break
+      }
+      case 'show': {
+        endpoint = `/shows/${type[2]}?market=${config.search.sources.spotify.market}&limit=${config.options.maxAlbumPlaylistLength < 100 ? config.options.maxAlbumPlaylistLength : 100}`
+
+        break
+      }
+      default: {
+        debugLog('loadtracks', 4, { type: 3, loadType: type[1], sourceName: 'Spotify', query, message: 'No matches found.' })
+
+        return resolve({
+          loadType: 'empty',
+          data: {}
+        })
+      }
+    }
+
+    debugLog('loadtracks', 4, { type: 1, loadType: type[1], sourceName: 'Spotify', query })
+
+    let { body: data } = await makeRequest(`https://api.spotify.com/v1${endpoint}`, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${playerInfo.accessToken}`
+      }
+    })
+
+    if (data.error) {
+      if (data.error.status === 401) {
+        await init()
+
+        data = await makeRequest(`https://api.spotify.com/v1${endpoint}`, {
+          method: 'GET',
+          headers: {
+            Authorization: `Bearer ${playerInfo.accessToken}`
+          }
+        })
+        data = data.body
+      }
+
+      if (data.error?.status === 400) {
+        debugLog('loadtracks', 4, { type: 3, loadType: type[1], sourceName: 'Spotify', query, message: 'No matches found.' })
+
+        return resolve({
+          loadType: 'empty',
+          data: {}
+        })
+      }
+
+      if (data.error?.message === 'Invalid playlist Id') {
+        debugLog('loadtracks', 4, { type: 3, loadType: type[1], sourceName: 'Spotify', query, message: 'No matches found.' })
+
+        return resolve({
+          loadType: 'empty',
+          data: {}
+        })
+      }
+    
+      if (data.error) {
+        debugLog('loadtracks', 4, { type: 3, loadType: type[1], sourceName: 'Spotify', query, message: data.error.message })
+
+        return resolve({
+          loadType: 'error',
+          data: {
+            message: data.error.message,
+            severity: 'fault',
+            cause: 'Unknown'
+          }
+        })
+      }
+    }
+
+    switch (type[1]) {
+      case 'track': {
+        const track = {
+          identifier: data.id,
+          isSeekable: true,
+          author: data.artists[0].name,
+          length: data.duration_ms,
+          isStream: false,
+          position: 0,
+          title: data.name,
+          uri: data.external_urls.spotify,
+          artworkUrl: data.album.images[0].url,
+          isrc: data.external_ids?.isrc || null,
+          sourceName: 'spotify'
+        }
+
+        debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'Spotify', track, query })
+
+        return resolve({
+          loadType: 'track',
+          data: {
+            encoded: encodeTrack(track),
+            info: track,
+            pluginInfo: {}
+          }
+        })
+      }
+      case 'episode': {
+        const track = {
+          identifier: data.id,
+          isSeekable: true,
+          author: data.show.publisher,
+          length: data.duration_ms,
+          isStream: false,
+          position: 0,
+          title: data.name,
+          uri: data.external_urls.spotify,
+          artworkUrl: data.images[0].url,
+          isrc: data.external_ids?.isrc || null,
+          sourceName: 'spotify'
+        }
+
+        debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'Spotify', track, query })
+
+        return resolve({
+          loadType: 'track',
+          data: {
+            encoded: encodeTrack(track),
+            info: track,
+            pluginInfo: {}
+          }
+        })
+      }
+      case 'playlist':
+      case 'album': {
+        const tracks = []
+        let index = 0
+
+        if (data.tracks.total > config.options.maxAlbumPlaylistLength)
+          data.tracks.total = config.options.maxAlbumPlaylistLength
+
+        const fragments = []
+        const fragmentLengths = []
+
+        for (let i = data.tracks.items.length; i != data.tracks.total;) {
+          const requestLimit = data.tracks.total - i > 100 ? 100 : data.tracks.total - i
+
+          fragmentLengths.push(requestLimit)
+          i += requestLimit
+        }
+
+        fragmentLengths.forEach(async (limit, i) => {
+          if (fragmentLengths.length !== 0) {
+            let url = `https://api.spotify.com/v1${endpoint}/tracks?offset=${(i + 1) * 100}&limit=${limit}`
+
+            const { body: data2 } = await makeRequest(url, {
+              method: 'GET',
+              headers: {
+                Authorization: `Bearer ${playerInfo.accessToken}`
+              }
+            })
+
+            fragments[i] = data2.items
+
+            if (index === fragmentLengths.length - 1)
+              data.tracks.items = data.tracks.items.concat(...fragments)
+          }
+
+          if (index === fragmentLengths.length - 1) {
+            data.tracks.items.forEach(async (item) => {
+              item = type[1] === 'playlist' ? item.track : item
+    
+              const track = {
+                identifier: item.id || 'unknown',
+                isSeekable: true,
+                author: item.artists[0].name,
+                length: item.duration_ms,
+                isStream: false,
+                position: 0,
+                title: item.name,
+                uri: item.external_urls.spotify,
+                artworkUrl: item.album ? item.album.images[0]?.url : null,
+                isrc: item.external_ids?.isrc || null,
+                sourceName: 'spotify'
+              }
+    
+              tracks.push({
+                encoded: encodeTrack(track),
+                info: track,
+                pluginInfo: {}
+              })
+            })
+    
+            if (tracks.length === 0) {
+              debugLog('loadtracks', 4, { type: 3, sourceName: 'Spotify', query, message: 'No matches found.' })
+    
+              return resolve({
+                loadType: 'empty',
+                data: {}
+              })
+            }
+    
+            debugLog('loadtracks', 4, { type: 2, loadType: 'playlist', sourceName: 'Spotify', playlistName: data.name })
+    
+            return resolve({
+              loadType: type[1],
+              data: {
+                info: {
+                  name: data.name,
+                  selectedTrack: 0
+                },
+                pluginInfo: {},
+                tracks
+              }
+            })
+          }
+
+          index++
+        })
+
+        break
+      }
+      case 'show': {
+        const tracks = []
+
+        data.episodes.items.forEach(async (episode) => {
+          const track = {
+            identifier: episode.id,
+            isSeekable: true,
+            author: data.publisher,
+            length: episode.duration_ms,
+            isStream: false,
+            position: 0,
+            title: episode.name,
+            uri: episode.external_urls.spotify,
+            artworkUrl: episode.images[0].url,
+            isrc: episode.external_ids?.isrc || null,
+            sourceName: 'spotify'
+          }
+
+          tracks.push({
+            encoded: encodeTrack(track),
+            info: track,
+            pluginInfo: {}
+          })
+        })
+
+        if (tracks.length === 0) {
+          debugLog('loadtracks', 4, { type: 3, sourceName: 'Spotify', query, message: 'No matches found.' })
+
+          return resolve({
+            loadType: 'empty',
+            data: {}
+          })
+        }
+
+        debugLog('loadtracks', 4, { type: 2, loadType: 'show', sourceName: 'Spotify', playlistName: data.name })
+
+        return resolve({
+          loadType: 'show',
+          data: {
+            info: {
+              name: data.name,
+              selectedTrack: 0
+            },
+            pluginInfo: {},
+            tracks
+          }
+        })
+      }
+    }
+  })
+}
+
+async function loadLyrics(decodedTrack, _language) {
+  const identifier = /^https?:\/\/(?:open\.spotify\.com\/|spotify:)(?:[^?]+)?(track|playlist|artist|episode|show|album)[/:]([A-Za-z0-9]+)/.exec(decodedTrack.uri)
+
+  if (config.search.sources.spotify.sp_dc === 'DISABLED') {
+    debugLog('loadlyrics', 4, { type: 3, sourceName: 'Spotify', message: 'Spotify lyrics are disabled.' })
+
+    return null
+  }
+
+  const { body: data, statusCode } = await makeRequest(`https://spclient.wg.spotify.com/color-lyrics/v2/track/${identifier[2]}?format=json&vocalRemoval=false&market=from_token`, {
+    headers: {
+      'authorization': `Bearer ${playerInfo.accessToken}`,
+      'client-token': playerInfo.clientToken,
+      'app-platform': 'WebPlayer'
+    },
+    method: 'GET'
+  })
+
+  if (statusCode === 404) {
+    debugLog('loadlyrics', 4, { type: 3, sourceName: 'Spotify', message: 'No lyrics found.' })
+
+    return null
+  }
+
+  const lyricsEvents = []
+  data.lyrics.lines.forEach((event, index) => {
+    if (index === data.lyrics.lines.length - 1) return;
+
+    lyricsEvents.push({
+      startTime: Number(event.startTimeMs),
+      endTime: Number(data.lyrics.lines[index + 1] ? data.lyrics.lines[index + 1].startTimeMs : data.lyrics.durationMs),
+      text: event.words
+    })
+  })
+
+  return {
+    loadType: 'lyricsSingle',
+    data: {
+      name: data.lyrics.language,
+      synced: data.lyrics.syncType === 'LINE_SYNCED',
+      data: lyricsEvents,
+      rtl: false
+    }
+  }
+}
+
+export default {
+  init,
+  search,
+  loadFrom,
+  loadLyrics
+}

src/sources/youtube.js

@@ -0,0 +1,715 @@
+import { PassThrough } from 'node:stream'
+
+import config from '../../config.js'
+import constants from '../../constants.js'
+import { debugLog, makeRequest, encodeTrack, randomLetters, loadHLSPlaylist } from '../utils.js'
+
+const ytContext = {
+  ...(config.options.bypassAgeRestriction ? {
+    thirdParty: {
+      embedUrl: 'https://www.youtube.com'
+    },
+  } : {}),
+  client: {
+    ...(!config.options.bypassAgeRestriction ? {
+      userAgent: 'com.google.android.youtube/19.13.34 (Linux; U; Android 14 gzip)',
+      clientName: 'ANDROID',
+      clientVersion: '19.13.34',
+    } : {
+      clientName: 'TVHTML5_SIMPLY_EMBEDDED_PLAYER',
+      clientVersion: '2.0',
+      userAgent: 'Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/111.0'
+    }),
+    screenDensityFloat: 1,
+    screenHeightPoints: 1080,
+    screenPixelDensity: 1,
+    screenWidthPoints: 1920,
+  }
+}
+
+const sourceInfo = {
+  innertubeInterval: null,
+  signatureTimestamp: null,
+  functions: []
+}
+
+function _getBaseHostRequest(type) {
+  if (ytContext.client.clientName.startsWith('ANDROID'))
+    return 'youtubei.googleapis.com'
+
+  return `${type === 'ytmusic' ? 'music' : 'www'}.youtube.com`
+}
+
+function _getBaseHost(type) {
+  return `${type === 'ytmusic' ? 'music' : 'www'}.youtube.com`
+}
+
+function _switchClient(newClient) {
+  if (newClient === 'ANDROID') {
+    ytContext.client.clientName = 'ANDROID'
+    ytContext.client.clientVersion = '19.04.33'
+    ytContext.client.userAgent = 'com.google.android.youtube/19.04.33 (Linux; U; Android 14 gzip)'
+  } else if (newClient === 'ANDROID_MUSIC') {
+    ytContext.client.clientName = 'ANDROID_MUSIC'
+    ytContext.client.clientVersion = '6.37.50'
+    ytContext.client.userAgent = 'com.google.android.apps.youtube.music/6.37.50 (Linux; U; Android 14 gzip)'
+  }
+}
+
+function _getSourceName(type) {
+  return type === 'ytmusic' ? 'YouTube Music' : 'YouTube'
+}
+
+async function _init() {
+  debugLog('youtube', 5, { type: 1, message: 'Fetching deciphering functions...' })
+ 
+  const { body: data } = await makeRequest('https://www.youtube.com/embed', { method: 'GET' }).catch((err) => {
+    debugLog('youtube', 5, { type: 2, message: `Failed to access YouTube website: ${err.message}` })
+  })
+
+  const { body: player } = await makeRequest(`https://www.youtube.com${/(?<=jsUrl":")[^"]+/.exec(data)[0]}`, { method: 'GET' }).catch((err) => {
+    debugLog('youtube', 5, { type: 2, message: `Failed to fetch player.js: ${err.message}` })
+  })
+
+  sourceInfo.signatureTimestamp = /(?<=signatureTimestamp:)[0-9]+/.exec(player)[0]
+
+  let functionName = player.match(/a.set\("alr","yes"\);c&&\(c=(.*?)\(/)[1]
+  const decipherFunctionName = functionName
+
+  const sigFunction = player.match(new RegExp(`${functionName.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')}=function\\(a\\){(.*)\\)};`, 'g'))[0]
+
+  functionName = player.match(/a=a\.split\(""\);(.*?)\./)[1]
+  const sigWrapper = player.match(new RegExp(`var ${functionName}={(.*?)};`, 's'))[1]
+
+  sourceInfo.functions[0] = `const ${functionName}={${sigWrapper}};const ${sigFunction}${decipherFunctionName}(sig);`
+
+  functionName = player.match(/&&\(b=a\.get\("n"\)\)&&\(b=(.*?)\(/)[1]
+
+  if (functionName && functionName.includes('['))
+    functionName = player.match(new RegExp(`${functionName.match(/([^[]*)\[/)[1]}=\\[(.*?)]`))[1]
+  
+  const ncodeFunction = player.match(new RegExp(`${functionName}=function(.*?)};`, 's'))[1]
+  sourceInfo.functions[1] = `const ${functionName} = function${ncodeFunction}};${functionName}(ncode)`
+
+  debugLog('youtube', 5, { type: 1, message: 'Successfully fetched deciphering functions.' })
+}
+
+async function init() {
+  debugLog('youtube', 5, { type: 1, message: 'Unrecommended option "bypass age-restricted" is enabled.' })
+
+  await _init()
+
+  sourceInfo.innertubeInterval = setInterval(async () => _init(), 3600000)
+}
+
+function free() {
+  clearInterval(sourceInfo.innertubeInterval)
+  sourceInfo.innertubeInterval = null
+
+  sourceInfo.signatureTimestamp = null
+  sourceInfo.functions = []
+}
+
+function checkURLType(url, type) {
+  if (type === 'ytmusic') {
+    const videoRegex = /^https?:\/\/music\.youtube\.com\/watch\?v=[\w-]+/
+    const playlistRegex = /^https?:\/\/music\.youtube\.com\/playlist\?list=[\w-]+/
+    const selectedVideoRegex = /^https?:\/\/music\.youtube\.com\/watch\?v=[\w-]+&list=[\w-]+/
+    
+    if (selectedVideoRegex.test(url) || playlistRegex.test(url)) return constants.YouTube.playlist
+    else if (videoRegex.test(url)) return constants.YouTube.video
+    else return -1
+  } else {
+    const videoRegex = /^https?:\/\/(?:www\.)?(?:youtube\.com\/(?:watch\?v=[\w-]+)|youtu\.be\/[\w-]+)/
+    const playlistRegex = /^https?:\/\/(?:www\.)?youtube\.com\/playlist\?list=[\w-]+/
+    const selectedVideoRegex = /^https?:\/\/(?:www\.)?youtube\.com\/watch\?v=[\w-]+&list=[\w-]+/
+    const shortsRegex = /^https?:\/\/(?:www\.)?youtube\.com\/shorts\/[\w-]+/
+  
+    if (selectedVideoRegex.test(url) || playlistRegex.test(url)) return constants.YouTube.playlist
+    else if (shortsRegex.test(url)) return constants.YouTube.shorts
+    else if (videoRegex.test(url)) return constants.YouTube.video
+    else return -1
+  }
+}
+
+async function search(query, type, shouldLog) {
+  if (shouldLog) debugLog('search', 4, { type: 1, sourceName: _getSourceName(type), query })
+
+  if (!config.options.bypassAgeRestriction)
+    _switchClient(type === 'ytmusic' ? 'ANDROID_MUSIC' : 'ANDROID')
+
+  const { body: search } = await makeRequest(`https://${_getBaseHostRequest(type)}/youtubei/v1/search`, {
+    headers: {
+      'User-Agent': ytContext.client.userAgent,
+      ...(config.search.sources.youtube.authentication.enabled ? {
+        Authorization: config.search.sources.youtube.authentication.authorization,
+        Cookie: `SID=${config.search.sources.youtube.authentication.cookies.SID}; LOGIN_INFO=${config.search.sources.youtube.authentication.cookies.LOGIN_INFO}`
+      } : {})
+    },
+    body: {
+      context: ytContext,
+      query,
+      params: type === 'ytmusic' ? 'EgWKAQIIAWoQEAMQBBAJEAoQBRAREBAQFQ%3D%3D' : 'EgIQAQ%3D%3D'
+    },
+    method: 'POST',
+    disableBodyCompression: true
+  })
+
+  if (typeof search !== 'object') {
+    debugLog('search', 4, { type: 3, sourceName: _getSourceName(type), query, message: 'Failed to load results.' })
+
+    return {
+      loadType: 'error',
+      data: {
+        message: 'Failed to load results.',
+        severity: 'common',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  if (search.error) {
+    debugLog('search', 4, { type: 3, sourceName: _getSourceName(type), query, message: search.error.message })
+
+    return {
+      loadType: 'error',
+      data: {
+        message: search.error.message,
+        severity: 'fault',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  const tracks = []
+
+  let videos = null
+  if (config.options.bypassAgeRestriction) videos = type == 'ytmusic' ? search.contents.sectionListRenderer.contents[0].itemSectionRenderer.contents : search.contents.sectionListRenderer.contents[search.contents.sectionListRenderer.contents.length - 1].itemSectionRenderer.contents
+  else videos = type == 'ytmusic' ? search.contents.tabbedSearchResultsRenderer.tabs[0].tabRenderer.content.musicSplitViewRenderer.mainContent.sectionListRenderer.contents[0].musicShelfRenderer.contents : search.contents.sectionListRenderer.contents[search.contents.sectionListRenderer.contents.length - 1].itemSectionRenderer.contents
+
+  if (videos.length > config.options.maxSearchResults)
+    videos = videos.slice(0, config.options.maxSearchResults)
+
+  videos.forEach((video) => {
+    video = video.compactVideoRenderer || video.musicTwoColumnItemRenderer
+
+    if (video) {
+      const identifier = type === 'ytmusic' ? video.navigationEndpoint.watchEndpoint.videoId : video.videoId
+      const length = type === 'ytmusic' && !config.options.bypassAgeRestriction ? video.subtitle.runs[2].text : video.lengthText?.runs[0]?.text
+      const thumbnails = type === 'ytmusic' && !config.options.bypassAgeRestriction ? video.thumbnail.musicThumbnailRenderer.thumbnail.thumbnails : video.thumbnail.thumbnails
+
+      const track = {
+        identifier,
+        isSeekable: true,
+        author: video.longBylineText ? video.longBylineText.runs[0].text : video.subtitle.runs[0].text,
+        length: length ? (parseInt(length.split(':')[0]) * 60 + parseInt(length.split(':')[1])) * 1000 : 0,
+        isStream: !length,
+        position: 0,
+        title: video.title.runs[0].text,
+        uri: `https://${_getBaseHost(type)}/watch?v=${identifier}`,
+        artworkUrl: thumbnails[thumbnails.length - 1].url.split('?')[0],
+        isrc: null,
+        sourceName: type
+      }
+
+      tracks.push({
+        encoded: encodeTrack(track),
+        info: track,
+        pluginInfo: {}
+      })
+    }
+  })
+
+  if (tracks.length === 0) {
+    debugLog('search', 4, { type: 3, sourceName: _getSourceName(type), query, message: 'No matches found.' })
+
+    return {
+      loadType: 'empty',
+      data: {}
+    }
+  }
+
+  if (shouldLog)
+    debugLog('search', 4, { type: 2, sourceName: _getSourceName(type), tracksLen: tracks.length, query })
+
+  return {
+    loadType: 'search',
+    data: tracks
+  }
+}
+
+async function loadFrom(query, type) {
+  if (!config.options.bypassAgeRestriction)
+    _switchClient(type === 'ytmusic' ? 'ANDROID_MUSIC' : 'ANDROID')
+
+  switch (checkURLType(query, type)) {
+    case constants.YouTube.video: {
+      debugLog('loadtracks', 4, { type: 1, loadType: 'track', sourceName: _getSourceName(type), query })
+      
+      const identifier = (/v=([^&]+)/.exec(query) || /youtu\.be\/([^?]+)/.exec(query))[1]
+
+      const { body: video } = await makeRequest(`https://${_getBaseHostRequest(type)}/youtubei/v1/player?key=AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8&prettyPrint=false`, {
+        headers: {
+          'User-Agent': ytContext.client.userAgent,
+          ...(config.search.sources.youtube.authentication.enabled ? {
+            Authorization: config.search.sources.youtube.authentication.authorization,
+            Cookie: `SID=${config.search.sources.youtube.authentication.cookies.SID}; LOGIN_INFO=${config.search.sources.youtube.authentication.cookies.LOGIN_INFO}`
+          } : {})
+        },
+        body: {
+          context: ytContext,
+          videoId: identifier,
+          contentCheckOk: true,
+          racyCheckOk: true,
+          params: 'CgIQBg'
+        },
+        method: 'POST'
+      })
+
+      if (video.playabilityStatus.status !== 'OK') {
+        const errorMessage = video.playabilityStatus.reason || video.playabilityStatus.messages[0]
+
+        debugLog('loadtracks', 4, { type: 3, loadType: 'track', sourceName: _getSourceName(type), query, message: errorMessage })
+        
+        return {
+          loadType: 'error',
+          data: {
+            message: errorMessage,
+            severity: 'common',
+            cause: 'Unknown'
+          }
+        }
+      }
+
+      const track = {
+        identifier: video.videoDetails.videoId,
+        isSeekable: true,
+        author: video.videoDetails.author,
+        length: parseInt(video.videoDetails.lengthSeconds) * 1000,
+        isStream: video.videoDetails.isLiveContent,
+        position: 0,
+        title: video.videoDetails.title,
+        uri: `https://${_getBaseHost(type)}/watch?v=${video.videoDetails.videoId}`,
+        artworkUrl: video.videoDetails.thumbnail.thumbnails[video.videoDetails.thumbnail.thumbnails.length - 1].url,
+        isrc: null,
+        sourceName: type
+      }
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: _getSourceName(type), track, query })
+
+      return {
+        loadType: 'track',
+        data: {
+          encoded: encodeTrack(track),
+          info: track,
+          pluginInfo: {}
+        }
+      }
+    }
+    case constants.YouTube.playlist: {
+      debugLog('loadtracks', 4, { type: 1, loadType: 'playlist', sourceName: _getSourceName(type), query })
+
+      let identifier = /v=([^&]+)/.exec(query)
+      if (identifier) identifier = identifier[1]
+
+      const { body: playlist } = await makeRequest(`https://${_getBaseHostRequest(type)}/youtubei/v1/next?key=AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8&prettyPrint=false`, {
+        headers: {
+          'User-Agent': ytContext.client.userAgent,
+          ...(config.search.sources.youtube.authentication.enabled ? {
+            Authorization: config.search.sources.youtube.authentication.authorization,
+            Cookie: `SID=${config.search.sources.youtube.authentication.cookies.SID}; LOGIN_INFO=${config.search.sources.youtube.authentication.cookies.LOGIN_INFO}`
+          } : {})
+        },
+        body: {
+          context: ytContext,
+          playlistId: /(?<=list=)[\w-]+/.exec(query)[0],
+          contentCheckOk: true,
+          racyCheckOk: true,
+          params: 'CgIQBg'
+        },
+        method: 'POST'
+      })
+
+      let contentsRoot = null
+      
+      if (config.options.bypassAgeRestriction) contentsRoot = playlist.contents.singleColumnWatchNextResults.playlist
+      else contentsRoot = type === 'ytmusic' ? playlist.contents.singleColumnMusicWatchNextResultsRenderer.tabbedRenderer.watchNextTabbedResultsRenderer.tabs[0].tabRenderer.content.musicQueueRenderer : playlist.contents.singleColumnWatchNextResults
+
+      if (!(type === 'ytmusic' && !config.options.bypassAgeRestriction ? contentsRoot.content : contentsRoot)) {
+        debugLog('loadtracks', 4, { type: 3, loadType: 'playlist', sourceName: _getSourceName(type), query, message: 'No matches found.' })
+      
+        return {
+          loadType: 'empty',
+          data: {}
+        }
+      }
+    
+      const tracks = []
+      let selectedTrack = 0
+
+      let playlistContent = null
+      
+      if (config.options.bypassAgeRestriction) playlistContent = contentsRoot.playlist.contents
+      else playlistContent = type === 'ytmusic' ? contentsRoot.content.playlistPanelRenderer.contents : contentsRoot.playlist?.playlist?.contents
+
+      if (!playlistContent) {
+        debugLog('loadtracks', 4, { type: 3, loadType: 'playlist', sourceName: _getSourceName(type), query, message: 'No matches found.' })
+
+        return {
+          loadType: 'empty',
+          data: {}
+        }
+      }
+
+      if (playlistContent.length > config.options.maxAlbumPlaylistLength)
+        playlistContent = playlistContent.slice(0, config.options.maxAlbumPlaylistLength)
+
+      playlistContent.forEach((video, i) => {
+        video = video.playlistPanelVideoRenderer || video.gridVideoRenderer
+
+        if (video) {
+          const track = {
+            identifier: video.videoId,
+            isSeekable: true,
+            author: video.shortBylineText.runs ? video.shortBylineText.runs[0].text : 'Unknown author',
+            length: video.lengthText ? (parseInt(video.lengthText.runs[0].text.split(':')[0]) * 60 + parseInt(video.lengthText.runs[0].text.split(':')[1])) * 1000 : 0,
+            isStream: false,
+            position: 0,
+            title: video.title.runs[0].text,
+            uri: `https://${_getBaseHost(type)}/watch?v=${video.videoId}`,
+            artworkUrl: video.thumbnail.thumbnails[video.thumbnail.thumbnails.length - 1].url,
+            isrc: null,
+            sourceName: 'youtube'
+          }
+
+          tracks.push({
+            encoded: encodeTrack(track),
+            info: track,
+            pluginInfo: {}
+          })
+
+          if (identifier && track.identifier === identifier)
+            selectedTrack = i
+        }
+      })
+
+      if (tracks.length === 0) {
+        debugLog('loadtracks', 4, { type: 3, loadType: 'playlist', sourceName: _getSourceName(type), query, message: 'No matches found.' })
+
+        return {
+          loadType: 'empty',
+          data: {}
+        }
+      }
+
+      let playlistName = null
+      
+      if (config.options.bypassAgeRestriction) playlistName = contentsRoot.playlist.title
+      else playlistName = type === 'ytmusic' ? contentsRoot.header.musicQueueHeaderRenderer.subtitle.runs[0].text : contentsRoot.playlist.playlist.title
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'playlist', sourceName: _getSourceName(type), playlistName: playlistName })
+
+      return {
+        loadType: 'playlist',
+        data: {
+          info: {
+            name: playlistName,
+            selectedTrack: selectedTrack
+          },
+          pluginInfo: {},
+          tracks
+        }
+      }
+    }
+    case constants.YouTube.shorts: {
+      debugLog('loadtracks', 4, { type: 1, loadType: 'track', sourceName: 'YouTube Shorts', query })
+
+      const { body: short } = await makeRequest(`https://${_getBaseHostRequest(type)}/youtubei/v1/player?key=AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8&prettyPrint=false`, {
+        headers: {
+          'User-Agent': ytContext.client.userAgent,
+          ...(config.search.sources.youtube.authentication.enabled ? {
+            Authorization: config.search.sources.youtube.authentication.authorization,
+            Cookie: `SID=${config.search.sources.youtube.authentication.cookies.SID}; LOGIN_INFO=${config.search.sources.youtube.authentication.cookies.LOGIN_INFO}`
+          } : {})
+        },
+        body: {
+          context: ytContext,
+          videoId: /shorts\/([a-zA-Z0-9_-]+)/.exec(query)[1],
+          contentCheckOk: true,
+          racyCheckOk: true,
+          params: 'CgIQBg'
+        },
+        method: 'POST'
+      })
+
+      if (short.playabilityStatus.status !== 'OK') {
+        const errorMessage = short.playabilityStatus.reason || short.playabilityStatus.messages[0]
+
+        debugLog('loadtracks', 4, { type: 3, loadType: 'track', sourceName: 'YouTube Shorts', query, message: errorMessage })
+
+        return {
+          loadType: 'error',
+          data: { message: errorMessage,
+            severity: 'common',
+            cause: 'Unknown'
+          }
+        }
+      }
+
+      const track = {
+        identifier: short.videoDetails.videoId,
+        isSeekable: true,
+        author: short.videoDetails.author,
+        length: parseInt(short.videoDetails.lengthSeconds) * 1000,
+        isStream: false,
+        position: 0,
+        title: short.videoDetails.title,
+        uri: `https://${_getBaseHost(type)}/watch?v=${short.videoDetails.videoId}`,
+        artworkUrl: short.videoDetails.thumbnail.thumbnails[short.videoDetails.thumbnail.thumbnails.length - 1].url,
+        isrc: null,
+        sourceName: 'youtube'
+      }
+
+      debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'YouTube Shorts', track, query })
+
+      return {
+        loadType: 'short',
+        data: {
+          encoded: encodeTrack(track),
+          info: track,
+          pluginInfo: {}
+        }
+      }
+    }
+    default: {
+      debugLog('loadtracks', 4, { type: 3, loadType: 'unknown', sourceName: _getSourceName(type), query, message: 'No matches found.' })
+
+      return {
+        loadType: 'empty',
+        data: {}
+      }
+    }
+  }
+}
+
+async function retrieveStream(identifier, type, title) {
+  if (!config.options.bypassAgeRestriction)
+    _switchClient(type === 'ytmusic' ? 'ANDROID_MUSIC' : 'ANDROID')
+
+  const { body: videos } = await makeRequest(`https://${_getBaseHostRequest(type)}/youtubei/v1/player?key=AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8&prettyPrint=false&t=${randomLetters(12)}&id=${identifier}`, {
+    headers: {
+      'User-Agent': ytContext.client.userAgent,
+      ...(config.search.sources.youtube.authentication.enabled ? {
+        Authorization: config.search.sources.youtube.authentication.authorization,
+        Cookie: `SID=${config.search.sources.youtube.authentication.cookies.SID}; LOGIN_INFO=${config.search.sources.youtube.authentication.cookies.LOGIN_INFO}`
+      } : {})
+    },
+    body: {
+      context: ytContext,
+      cpn: randomLetters(16),
+      ...(config.options.bypassAgeRestriction ? {
+        playbackContext: {
+          contentPlaybackContext: {
+            signatureTimestamp: sourceInfo.signatureTimestamp
+          }
+        }
+      } : {}),
+      videoId: identifier,
+      contentCheckOk: true,
+      racyCheckOk: true,
+      params: 'CgIQBg'
+    },
+    method: 'POST',
+    disableBodyCompression: true
+  })
+
+  if (videos.playabilityStatus.status !== 'OK') {
+    debugLog('retrieveStream', 4, { type: 2, sourceName: _getSourceName(type), query: title, message: videos.playabilityStatus.reason })
+
+    return {
+      exception: {
+        message: videos.playabilityStatus.reason,
+        severity: 'common',
+        cause: 'Unknown'
+      }
+    }
+  }
+
+  let itag = null
+  switch (config.audio.quality) {
+    case 'high': itag = 251; break
+    case 'medium': itag = 250; break
+    case 'low': itag = 249; break
+    case 'lowest': itag = 599; break
+    default: itag = 251; break
+  }
+
+  const audio = videos.streamingData.adaptiveFormats.find((format) => format.itag === itag) || videos.streamingData.adaptiveFormats.find((format) => format.mimeType.startsWith('audio/'))
+  let url = audio.url || audio.signatureCipher || audio.cipher
+
+  if ((audio.signatureCipher || audio.cipher) && config.options.bypassAgeRestriction) {
+    const args = new URLSearchParams(url)
+    url = decodeURIComponent(args.get('url'))
+
+    if (audio.signatureCipher || audio.cipher)
+      url += `&${args.get('sp')}=${eval(`const sig = "${args.get('s')}";` + sourceInfo.functions[0])}`
+  } else {
+    url = decodeURIComponent(url)
+  }
+
+  url += `&rn=1&cpn=${randomLetters(16)}&ratebypass=yes&range=0-` /* range query is necessary to bypass throttling */
+
+  return {
+    url: videos.streamingData.hlsManifestUrl ? videos.streamingData.hlsManifestUrl : url,
+    protocol: videos.streamingData.hlsManifestUrl ? 'hls' : 'http',
+    format: audio.mimeType === 'audio/webm; codecs="opus"' ? 'webm/opus' : 'arbitrary'
+  }
+}
+
+function loadLyrics(decodedTrack, language) {
+  return new Promise(async (resolve) => {
+    if (!config.options.bypassAgeRestriction)
+      _switchClient(decodedTrack.sourceName === 'ytmusic' ? 'ANDROID_MUSIC' : 'ANDROID')
+
+    const { body: video } = await makeRequest(`https://${_getBaseHostRequest(decodedTrack.sourceName)}/youtubei/v1/player?key=AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8&prettyPrint=false`, {
+      headers: {
+        'User-Agent': ytContext.client.userAgent,
+        ...(config.search.sources.youtube.authentication.enabled ? {
+          Authorization: config.search.sources.youtube.authentication.authorization,
+          Cookie: `SID=${config.search.sources.youtube.authentication.cookies.SID}; LOGIN_INFO=${config.search.sources.youtube.authentication.cookies.LOGIN_INFO}`
+        } : {})
+      },
+      body: {
+        context: ytContext,
+        videoId: decodedTrack.identifier,
+        contentCheckOk: true,
+        racyCheckOk: true,
+        params: 'CgIQBg'
+      },
+      method: 'POST'
+    })
+
+    if (video.playabilityStatus.status !== 'OK') {
+      debugLog('loadlyrics', 4, { type: 2, sourceName: _getSourceName(decodedTrack.sourceName), track: { title: decodedTrack.title, author: decodedTrack.author }, message: video.playabilityStatus.reason })
+
+      return resolve({
+        loadType: 'error',
+        data: {
+          message: video.playabilityStatus.reason,
+          severity: 'common',
+          cause: 'Unknown'
+        }
+      })
+    }
+
+    if (!video.captions)
+      return resolve(null)
+
+    const selectedCaption = video.captions.playerCaptionsTracklistRenderer.captionTracks.find((caption) => {
+      return caption.languageCode === language
+    })
+
+    if (selectedCaption) {
+      const { body: captionData } = await makeRequest(selectedCaption.baseUrl.replace('&fmt=srv3', '&fmt=json3'), { method: 'GET' }).catch((err) => {
+        debugLog('loadlyrics', 4, { type: 2, sourceName: _getSourceName(decodedTrack.sourceName), track: { title: decodedTrack.title, author: decodedTrack.author }, message: err.message })
+
+        return resolve({
+          loadType: 'error',
+          data: {
+            message: err.message,
+            severity: 'common',
+            cause: 'Unknown'
+          }
+        })
+      })
+
+      const captionEvents = []
+      captionData.events.forEach((event) => {
+        if (!event.segs) return null
+
+        captionEvents.push({
+          startTime: event.tStartMs,
+          endTime: event.tStartMs + (event.dDurationMs || 0),
+          text: event.segs ? event.segs.map((seg) => seg.utf8).join('') : null
+        })
+      })
+
+      return resolve({
+        loadType: 'lyricsSingle',
+        data: {
+          name: selectedCaption.languageCode,
+          synced: true,
+          data: captionEvents,
+          rtl: !!selectedCaption.rtl
+        }
+      })
+    } else {
+      const captions = []
+      let i = 0
+
+      video.captions.playerCaptionsTracklistRenderer.captionTracks.forEach(async (caption) => {
+        const { body: captionData } = await makeRequest(caption.baseUrl.replace('&fmt=srv3', '&fmt=json3'), { method: 'GET' }).catch((err) => {
+          debugLog('loadlyrics', 4, { type: 2, sourceName: _getSourceName(decodedTrack.sourceName), track: { title: decodedTrack.title, author: decodedTrack.author }, message: err.message })
+
+          return resolve({
+            loadType: 'error',
+            data: {
+              message: err.message,
+              severity: 'common',
+              cause: 'Unknown'
+            }
+          })
+        })
+
+        const captionEvents = captionData.events.map((event) => {
+          return {
+            startTime: event.tStartMs,
+            endTime: event.tStartMs + event.dDurationMs,
+            text: event.segs ? event.segs.map((seg) => seg.utf8).join('') : null
+          }
+        })
+
+        captions.push({
+          name: caption.languageCode,
+          synced: true,
+          data: captionEvents,
+          rtl: !!caption.rtl
+        })
+
+        if (++i === video.captions.playerCaptionsTracklistRenderer.captionTracks.length) {
+          if (captions.length === 0) {
+            debugLog('loadlyrics', 4, { type: 3, sourceName: _getSourceName(decodedTrack.sourceName), track: { title: decodedTrack.title, author: decodedTrack.author }, message: 'No captions found.' })
+
+            return resolve(null)
+          }
+
+          debugLog('loadlyrics', 4, { type: 2, sourceName: _getSourceName(decodedTrack.sourceName), track: { title: decodedTrack.title, author: decodedTrack.author } })
+
+          return resolve({
+            loadType: 'lyricsMultiple',
+            data: captions
+          })
+        }
+      })
+    }
+  })
+}
+
+async function loadStream(url) {
+  return new Promise(async (resolve) => {
+    const stream = new PassThrough()
+    await loadHLSPlaylist(url, stream)
+
+    resolve(stream)
+  })
+}
+
+export default {
+  init,
+  free,
+  search,
+  loadFrom,
+  retrieveStream,
+  loadLyrics,
+  loadStream
+}

src/utils.js

@@ -0,0 +1,943 @@
+import http from 'node:http'
+import https from 'node:https'
+import http2 from 'node:http2'
+import zlib from 'node:zlib'
+import process from 'node:process'
+import { Buffer } from 'node:buffer'
+import { URL } from 'node:url'
+import { PassThrough } from 'node:stream'
+
+import config from '../config.js'
+import constants from '../constants.js'
+
+export function randomLetters(size) {
+  let result = ''
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+  
+  let counter = 0
+  while (counter < size) {
+    result += characters.charAt(Math.floor(Math.random() * characters.length))
+    counter++
+  }
+  
+  return result
+}
+
+function _http1Events(request, headers, statusCode) {
+  return new Promise((resolve) => {
+    let data = ''
+
+    request.setEncoding('utf8')
+    request.on('data', (chunk) => data += chunk)
+    request.on('end', () => {
+      resolve({
+        statusCode: statusCode,
+        headers: headers,
+        body: (headers && headers['content-type'] && headers['content-type'].startsWith('application/json')) ? JSON.parse(data) : data
+      })
+    })
+  })
+}
+
+export function http1makeRequest(url, options) { 
+  return new Promise(async (resolve, reject) => {
+    let compression = null
+
+    let req = (url.startsWith('https') ? https : http).request(url, {
+      method: options.method,
+      headers: {
+        'Accept-Encoding': 'br, gzip, deflate',
+        'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/111.0',
+        'DNT': '1',
+        ...(options.headers || {}),
+        ...(options.body ? { 'Content-Type': 'application/json' } : {})
+      }
+    }, async (res) => {
+      const statusCode = res.statusCode
+      const headers = res.headers
+
+      if (headers.location) {
+        resolve(http1makeRequest(headers.location, options))
+
+        return res.destroy()
+      }
+
+      switch (res.headers['content-encoding']) {
+        case 'deflate': {
+          compression = zlib.createInflate()
+          break
+        }
+        case 'br': {
+          compression = zlib.createBrotliDecompress()
+          break
+        }
+        case 'gzip': {
+          compression = zlib.createGunzip()
+          break
+        }
+      }
+
+      if (compression) {
+        res.pipe(compression)
+
+        if (options.streamOnly) {
+          return resolve({
+            statusCode,
+            headers,
+            stream: compression
+          })
+        }
+        
+        resolve(await _http1Events(compression, headers, statusCode))
+      } else {
+        if (options.streamOnly) {
+          return resolve({
+            statusCode,
+            headers,
+            stream: res
+          })
+        }
+
+        resolve(await _http1Events(res, headers, statusCode))
+      }
+    })
+
+    if (options.body) {
+      if (options.disableBodyCompression || process.versions.deno)
+        req.end(JSON.stringify(options.body))
+      else zlib.gzip(JSON.stringify(options.body), (error, data) => {
+        if (error) throw new Error(`\u001b[31mhttp1makeRequest\u001b[37m]: Failed gziping body: ${error}`)
+        req.end(data)
+      })
+    } else req.end()
+
+    req.on('error', (error) => {
+      console.error(`[\u001b[31mhttp1makeRequest\u001b[37m]: Failed sending HTTP request to ${url}: \u001b[31m${error}\u001b[37m`)
+
+      reject(error)
+    })
+  })
+}
+
+function _http2Events(request, headers) {
+  return new Promise((resolve) => {
+    let data = ''
+
+    request.setEncoding('utf8')
+    request.on('data', (chunk) => data += chunk)
+    request.on('end', () => {
+      resolve({
+        statusCode: headers[':status'],
+        headers: headers,
+        body: (headers && headers['content-type'] && headers['content-type'].startsWith('application/json')) ? JSON.parse(data) : data
+      })
+    })
+  })
+}
+
+export function makeRequest(url, options) {
+  if (process.versions.deno) return http1makeRequest(url, options)
+
+  return new Promise(async (resolve) => {
+    const parsedUrl = new URL(url)
+    let compression = null
+
+    const client = http2.connect(parsedUrl.origin)
+
+    let reqOptions = {
+      ':method': options.method,
+      ':path': parsedUrl.pathname + parsedUrl.search,
+      'Accept-Encoding': 'br, gzip, deflate',
+      'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/111.0',
+      'DNT': '1',
+      ...(options.headers || {})
+    }
+
+    if (options.body) {
+      if (!options.disableBodyCompression) reqOptions['Content-Encoding'] = 'gzip'
+
+      reqOptions['Content-Type'] = 'application/json'
+    }
+
+    let req = client.request(reqOptions)
+
+    client.on('error', () => { /* Add listener or else will crash */ })
+
+    req.on('error', (error) => {
+      console.error(`[\u001b[31mmakeRequest\u001b[37m]: Failed sending HTTP request to ${url}: \u001b[31m${error}\u001b[37m`)
+
+      resolve({ error })
+    })
+
+    req.on('response', async (headers) => {
+      if (headers.location) {
+        client.close()
+        req.destroy()
+
+        return resolve(makeRequest(headers.location, options))
+      }
+
+      switch (headers['content-encoding']) {
+        case 'deflate': {
+          compression = zlib.createInflate()
+          break
+        }
+        case 'br': {
+          compression = zlib.createBrotliDecompress()
+          break
+        }
+        case 'gzip': {
+          compression = zlib.createGunzip()
+          break
+        }
+      }
+
+      if (compression) {
+        req.pipe(compression)
+
+        if (options.streamOnly) {
+          req.on('end', () => client.close())
+
+          return resolve({
+            statusCode: headers[':status'],
+            headers: headers,
+            stream: compression
+          })
+        }
+
+        compression.on('error', (error) => {
+          console.error(`[\u001b[31mmakeRequest\u001b[37m]: Failed decompressing HTTP response: \u001b[31m${error}\u001b[37m`)
+
+          resolve({ error })
+        })
+
+        resolve(await _http2Events(compression, headers))
+
+        client.close()
+      } else {
+        if (options.streamOnly) {
+          req.on('end', () => client.close())
+
+          return resolve({
+            statusCode: headers[':status'],
+            headers: headers,
+            stream: req
+          })
+        }
+
+        resolve(await _http2Events(req, headers))
+
+        client.close()
+      }
+    })
+
+    if (options.body) {
+      if (options.disableBodyCompression)
+        req.end(JSON.stringify(options.body))
+      else zlib.gzip(JSON.stringify(options.body), (error, data) => {
+        if (error) throw new Error(`\u001b[31mmakeRequest\u001b[37m]: Failed gziping body: ${error}`)
+        req.end(data)
+      })
+    } else req.end()
+  })
+}
+
+class EncodeClass {
+  constructor() {
+    this.position = 0
+    this.buffer = Buffer.alloc(512)
+  }
+
+  changeBytes(bytes) {
+    if (this.position + bytes > this.buffer.length) {
+      const newBuffer = Buffer.alloc(Math.max(this.buffer.length * 2, this.position + bytes))
+      this.buffer.copy(newBuffer)
+      this.buffer = newBuffer
+    }
+    this.position += bytes
+    return this.position - bytes
+  }
+
+  write(type, value) {
+    switch (type) {
+      case 'byte': {
+        this.buffer[this.changeBytes(1)] = value
+        break
+      }
+      case 'unsignedShort': {
+        this.buffer.writeUInt16BE(value, this.changeBytes(2))
+        break
+      }
+      case 'int': {
+        this.buffer.writeInt32BE(value, this.changeBytes(4))
+        break
+      }
+      case 'long': {
+        const msb = value / BigInt(2 ** 32)
+        const lsb = value % BigInt(2 ** 32)
+
+        this.write('int', Number(msb))
+        this.write('int', Number(lsb))
+        break
+      }
+      case 'utf': {
+        const len = Buffer.byteLength(value, 'utf8')
+        this.write('unsignedShort', len)
+        const start = this.changeBytes(len)
+        this.buffer.write(value, start, len, 'utf8')
+        break
+      }
+    }
+  }
+
+  result() {
+    return this.buffer.subarray(0, this.position)
+  }
+}
+
+export function encodeTrack(obj) {
+  try {
+    const buf = new EncodeClass()
+
+    buf.write('byte', 3)
+    buf.write('utf', obj.title)
+    buf.write('utf', obj.author)
+    buf.write('long', BigInt(obj.length))
+    buf.write('utf', obj.identifier)
+    buf.write('byte', obj.isStream ? 1 : 0)
+    buf.write('byte', obj.uri ? 1 : 0)
+    if (obj.uri) buf.write('utf', obj.uri)
+    buf.write('byte', obj.artworkUrl ? 1 : 0)
+    if (obj.artworkUrl) buf.write('utf', obj.artworkUrl)
+    buf.write('byte', obj.isrc ? 1 : 0)
+    if (obj.isrc) buf.write('utf', obj.isrc)
+    buf.write('utf', obj.sourceName)
+    buf.write('long', BigInt(obj.position))
+
+    const buffer = buf.result()
+    const result = Buffer.alloc(buffer.length + 4)
+
+    result.writeInt32BE(buffer.length | (1 << 30))
+    buffer.copy(result, 4)
+
+    return result.toString('base64')
+  } catch {
+    return null
+  }
+}
+
+class DecodeClass {
+  constructor(buffer) {
+    this.position = 0
+    this.buffer = buffer
+  }
+
+  changeBytes(bytes) {
+    this.position += bytes
+    return this.position - bytes
+  }
+
+  read(type) {
+    switch (type) {
+      case 'byte': {
+        return this.buffer[this.changeBytes(1)]
+      }
+      case 'unsignedShort': {
+        const result = this.buffer.readUInt16BE(this.changeBytes(2))
+        return result
+      }
+      case 'int': {
+        const result = this.buffer.readInt32BE(this.changeBytes(4))
+        return result
+      }
+      case 'long': {
+        const msb = BigInt(this.read('int'))
+        const lsb = BigInt(this.read('int'))
+
+        return msb * BigInt(2 ** 32) + lsb
+      }
+      case 'utf': {
+        const len = this.read('unsignedShort')
+        const start = this.changeBytes(len)
+        const result = this.buffer.toString('utf8', start, start + len)
+        return result
+      }
+    }
+  }
+}
+
+export function decodeTrack(track) {
+  try {
+    const buf = new DecodeClass(Buffer.from(track, 'base64'))
+
+    const version = ((buf.read('int') & 0xC0000000) >> 30 & 1) !== 0 ? buf.read('byte') : 1
+
+    switch (version) {
+      case 1: {
+        return {
+          title: buf.read('utf'),
+          author: buf.read('utf'),
+          length: Number(buf.read('long')),
+          identifier: buf.read('utf'),
+          isStream: buf.read('byte') === 1,
+          uri: null,
+          source: buf.read('utf'),
+          position: Number(buf.read('long'))
+        }
+      }
+      case 2: {
+        return {
+          title: buf.read('utf'),
+          author: buf.read('utf'),
+          length: Number(buf.read('long')),
+          identifier: buf.read('utf'),
+          isStream: buf.read('byte') === 1,
+          uri: buf.read('byte') === 1 ? buf.read('utf') : null,
+          source: buf.read('utf'),
+          position: Number(buf.read('long'))
+        }
+      }
+      case 3: {
+        return {
+          title: buf.read('utf'),
+          author: buf.read('utf'),
+          length: Number(buf.read('long')),
+          identifier: buf.read('utf'),
+          isSeekable: true,
+          isStream: buf.read('byte') === 1,
+          uri: buf.read('byte') === 1 ? buf.read('utf') : null,
+          artworkUrl: buf.read('byte') === 1 ? buf.read('utf') : null,
+          isrc: buf.read('byte') === 1 ? buf.read('utf') : null,
+          sourceName: buf.read('utf'),
+          position: Number(buf.read('long'))
+        }
+      }
+    }
+  } catch {
+    return null
+  }
+}
+
+export function debugLog(name, type, options) {
+  switch (type) {
+    case 1: {
+      if (!config.debug.request.enabled) return;
+
+      if (options.headers) {
+        options.headers.authorization = 'REDACTED'
+        options.headers.host = 'REDACTED'
+      }
+
+      if (options.error)
+        console.error(`[\u001b[32m${name}\u001b[37m]: Detected an error in a request: \u001b[31m${options.error}\u001b[37m${config.debug.request.showParams && options.params ? `\n Params: ${JSON.stringify(options.params)}` : ''}${config.debug.request.showHeaders && options.headers ? `\n Headers: ${JSON.stringify(options.headers)}` : ''}${config.debug.request.showBody && options.body ? `\n Body: ${JSON.stringify(options.body)}` : ''}`)
+      else
+        console.log(`[\u001b[32m${name}\u001b[37m]: Received a request from client.${config.debug.request.showParams && options.params ? `\n Params: ${JSON.stringify(options.params)}` : ''}${config.debug.request.showHeaders && options.headers ? `\n Headers: ${JSON.stringify(options.headers)}` : ''}${config.debug.request.showBody && options.body ? `\n Body: ${JSON.stringify(options.body)}` : ''}`)
+
+      break
+    }
+    case 2: {
+      switch (name) {
+        case 'trackStart': {
+          if (!config.debug.track.start) return;
+
+          console.log(`[\u001b[32mtrackStart\u001b[37m]: \u001b[94m${options.track.title}\u001b[37m by \u001b[94m${options.track.author}\u001b[37m.`)
+
+            break
+        }
+        case 'trackEnd': {
+          if (!config.debug.track.end) return;
+
+          console.log(`[\u001b[32mtrackEnd\u001b[37m]: \u001b[94m${options.track.title}\u001b[37m by \u001b[94m${options.track.author}\u001b[37m because was \u001b[94m${options.reason}\u001b[37m.`)
+
+          break
+        }
+        case 'trackException': {
+          if (!config.debug.track.exception) return;
+
+          console.error(`[\u001b[31mtrackException\u001b[37m]: \u001b[94m${options.track?.title || 'None'}\u001b[37m by \u001b[94m${options.track?.author || 'none'}\u001b[37m: \u001b[31m${options.exception}\u001b[37m`)
+
+          break
+        }
+        case 'trackStuck': {
+          if (!config.debug.track.stuck) return;
+
+          console.warn(`[\u001b[33mtrackStuck\u001b[37m]: \u001b[94m${options.track.title}\u001b[37m by \u001b[94m${options.track.author}\u001b[37m: \u001b[33m${config.options.threshold}ms have passed.\u001b[37m`)
+
+          break
+        }
+      }
+
+      break
+    }
+    case 3: {
+      switch (name) {
+        case 'connect': {
+          if (!config.debug.websocket.connect) return;
+
+          if (options.error)
+            return console.error(`[\u001b[31mwebsocket\u001b[37m]: \u001b[31m${options.error}\u001b[37m\n Name: \u001b[94m${options.name}\u001b[37m`)
+
+          console.log(`[\u001b[32mwebsocket\u001b[37m]: \u001b[94m${options.name}\u001b[37m@\u001b[94m${options.version}\u001b[37m client connected to NodeLink.`)
+
+          break
+        }
+        case 'disconnect': {
+          if (!config.debug.websocket.disconnect) return;
+
+          console.error(`[\u001b[33mwebsocket\u001b[37m]: A connection was closed with a client.\n Code: \u001b[33m${options.code}\u001b[37m\n Reason: \u001b[33m${options.reason === '' ? 'No reason provided' : options.reason}\u001b[37m`)
+        
+          break
+        }
+        case 'error': {
+          if (!config.debug.websocket.error) return;
+
+          console.error(`[\u001b[31mwebsocketError\u001b[37m]: \u001b[94m${options.name}\u001b[37m@\u001b[94m${options.version}\u001b[37m ran into an error: \u001b[31m${options.error}\u001b[37m`)
+
+          break
+        }
+        case 'connectCD': {
+          if (!config.debug.websocket.connectCD) return;
+
+          console.log(`[\u001b[32mwebsocketCD\u001b[37m]: \u001b[94m${options.name}\u001b[37m@\u001b[94m${options.version}\u001b[37m client connected to NodeLink.\n Guild: \u001b[94m${options.guildId}\u001b[37m`)
+
+          break
+        }
+        case 'disconnectCD': {
+          if (!config.debug.websocket.disconnectCD) return;
+
+          console.error(`[\u001b[32mwebsocketCD\u001b[37m]: Connection with \u001b[94m${options.name}\u001b[37m@\u001b[94m${options.version}\u001b[37m was closed.\n Guild: \u001b[94m${options.guildId}\u001b[37m\n Code: \u001b[33m${options.code}\u001b[37m\n Reason: \u001b[33m${options.reason === '' ? 'No reason provided' : options.reason}\u001b[37m`)
+
+          break
+        }
+        case 'sentDataCD': {
+          if (!config.debug.websocket.sentDataCD) return;
+
+          console.log(`[\u001b[32msentData\u001b[37m]: Sent data to \u001b[94m${options.clientsAmount}\u001b[37m clients.\n Guild: \u001b[94m${options.guildId}\u001b[37m`)
+
+          break
+        }
+        default: {
+          if (!config.debug.request.error) return;
+
+          console.error(`[\u001b[31m${name}\u001b[37m]: \u001b[31m${options.error}\u001b[37m${config.debug.request.showParams && options.params ? `\n Params: ${JSON.stringify(options.params)}` : ''}${config.debug.request.showHeaders && options.headers ? `\n Headers: ${JSON.stringify(options.headers)}` : ''}${config.debug.request.showBody && options.body ? `\n Body: ${JSON.stringify(options.body)}` : ''}`)
+
+          break
+        }
+      }
+
+      break
+    }
+    case 4: {
+      switch (name) {
+        case 'loadtracks': {
+          if (options.type === 1 && config.debug.sources.loadtrack.request)
+            console.log(`[\u001b[32mloadTracks\u001b[37m]: Loading \u001b[94m${options.loadType}\u001b[37m from ${options.sourceName}: ${options.query}`)
+
+          if (options.type === 2 && config.debug.sources.loadtrack.results) {
+            if (options.loadType !== 'search' && options.loadType !== 'track')
+              console.log(`[\u001b[32mloadTracks\u001b[37m]: Loaded \u001b[94m${options.playlistName}\u001b[37m from \u001b[94m${options.sourceName}\u001b[37m.`)
+            else
+              console.log(`[\u001b[32mloadTracks\u001b[37m]: Loaded \u001b[94m${options.track.title}\u001b[37m by \u001b[94m${options.track.author}\u001b[37m from \u001b[94m${options.sourceName}\u001b[37m: ${options.query}`)
+          }
+
+          if (options.type === 3 && config.debug.sources.loadtrack.exception)
+            console.error(`[\u001b[31mloadTracks\u001b[37m]: Exception loading \u001b[94m${options.loadType}\u001b[37m from \u001b[94m${options.sourceName}\u001b[37m: \u001b[31m${options.message}\u001b[37m`)
+
+          break
+        }
+        case 'search': {
+          if (options.type === 1 && config.debug.sources.search.request)
+            console.log(`[\u001b[32msearch\u001b[37m]: Searching for \u001b[94m${options.query}\u001b[37m on \u001b[94m${options.sourceName}\u001b[37m`)
+          
+          if (options.type === 2 && config.debug.sources.search.results)
+            console.log(`[\u001b[32msearch\u001b[37m]: Found \u001b[94m${options.tracksLen}\u001b[37m tracks on \u001b[94m${options.sourceName}\u001b[37m for query \u001b[94m${options.query}\u001b[37m`)
+
+          if (options.type === 3 && config.debug.sources.search.exception)
+            console.error(`[\u001b[31msearch\u001b[37m]: Exception from ${options.sourceName} for query \u001b[94m${options.query}\u001b[37m: \u001b[31m${options.message}\u001b[37m`)
+
+          break
+        }
+        case 'retrieveStream': {
+          if (!config.debug.sources.retrieveStream) return;
+
+          if (options.type === 1)
+            console.log(`[\u001b[32mretrieveStream\u001b[37m]: Retrieved from \u001b[94m${options.sourceName}\u001b[37m for query \u001b[94m${options.query}\u001b[37m`)
+
+          if (options.type === 2)
+            console.error(`[\u001b[31mretrieveStream\u001b[37m]: Exception from \u001b[94m${options.sourceName}\u001b[37m for query \u001b[94m${options.query}\u001b[37m: \u001b[31m${options.message}\u001b[37m`)
+
+          break
+        }
+        case 'loadlyrics': {
+          if (options.type === 1 && config.debug.sources.loadlyrics.request)
+            console.log(`[\u001b[32mloadCaptions\u001b[37m]: Loading captions for \u001b[94m${options.track.title}\u001b[37m by \u001b[94m${options.track.author}\u001b[37m from \u001b[94m${options.sourceName}\u001b[37m`)
+
+          if (options.type === 2 && config.debug.sources.loadlyrics.results)
+            console.log(`[\u001b[32mloadCaptions\u001b[37m]: Loaded captions for \u001b[94m${options.track.title}\u001b[37m by \u001b[94m${options.track.author}\u001b[37m from \u001b[94m${options.sourceName}\u001b[37m`)
+
+          if (options.type === 3 && config.debug.sources.loadlyrics.exception)
+            console.error(`[\u001b[31mloadCaptions\u001b[37m]: Exception loading captions for \u001b[94m${options.track.title}\u001b[37m by \u001b[94m${options.track.author}\u001b[37m from \u001b[94m${options.sourceName}\u001b[37m: \u001b[31m${options.message}\u001b[37m`)
+
+          break
+        }
+      }
+
+      break
+    }
+    case 5: {
+      switch (name) {
+        case 'youtube': {
+          if (options.type === 1 && config.debug.youtube.success)
+            console.log(`[\u001b[32myoutube\u001b[37m]: ${options.message}`)
+
+          if (options.type === 2 && config.debug.youtube.error)
+            console.error(`[\u001b[31myoutube\u001b[37m]: ${options.message}`)
+
+          break
+        }
+
+        case 'pandora': {
+          if (options.type === 1 && config.debug.pandora.success)
+            console.log(`[\u001b[32mpandora\u001b[37m]: ${options.message}`)
+
+          if (options.type === 2 && config.debug.pandora.error)
+            console.error(`[\u001b[31mpandora\u001b[37m]: ${options.message}`)
+
+          break
+        }
+        case 'deezer': {
+          if (options.type === 1 && config.debug.deezer.success)
+            console.log(`[\u001b[32mdeezer\u001b[37m]: ${options.message}`)
+
+          if (options.type === 2 && config.debug.deezer.error)
+            console.error(`[\u001b[31mdeezer\u001b[37m]: ${options.message}`)
+
+          break
+        }
+        case 'spotify': {
+          if (options.type === 1 && config.debug.spotify.success)
+            console.log(`[\u001b[32mspotify\u001b[37m]: ${options.message}`)
+
+          if (options.type === 2 && config.debug.spotify.error)
+            console.error(`[\u001b[31mspotify\u001b[37m]: ${options.message}`)
+
+          break
+        }
+        case 'soundcloud': {
+          if (options.type === 1 && config.debug.soundcloud.success)
+            console.log(`[\u001b[32msoundcloud\u001b[37m]: ${options.message}`)
+
+          if (options.type === 2 && config.debug.soundcloud.error)
+            console.error(`[\u001b[31msoundcloud\u001b[37m]: ${options.message}`)
+
+          break
+        }
+        case 'musixmatch': {
+          console.log(`[\u001b[32mmusixmatch\u001b[37m]: ${options.message}`)
+
+          break
+        }
+      }
+
+      break
+    }
+    case 6: {
+      if (!config.debug.request.all) return;
+
+      if (options.headers) {
+        options.headers.authorization = 'REDACTED'
+        options.headers.host = 'REDACTED'
+      }
+
+      console.log(`[\u001b[32mALL\u001b[37m]: Received a request from client.\n Path: ${options.path}${options.params ? `\n Params: ${JSON.stringify(options.params)}` : ''}${options.headers ? `\n Headers: ${JSON.stringify(options.headers)}` : ''}${options.body ? `\n Body: ${JSON.stringify(options.body)}` : ''}`)
+
+      break
+    }
+  }
+}
+
+export function sendResponse(req, res, data, status) {
+  if (!data) {
+    res.writeHead(status)
+    res.end()
+
+    return true
+  }
+
+  if (!req.headers || !req.headers['accept-encoding']) {
+    res.setHeader('Connection', 'close')
+    res.writeHead(status, { 'Content-Type': 'application/json' })
+
+    res.end(JSON.stringify(data))
+  }
+
+  if (req.headers && req.headers['accept-encoding']) {
+    if (req.headers['accept-encoding'].includes('br')) {
+      res.setHeader('Content-Encoding', 'br')
+      res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Encoding': 'br' })
+
+      zlib.brotliCompress(JSON.stringify(data), (err, result) => {
+        if (err) {
+          res.writeHead(500)
+          res.end()
+
+          return;
+        }
+
+        res.end(result)
+      })
+    }
+
+    else if (req.headers['accept-encoding'].includes('gzip')) {
+      res.setHeader('Content-Encoding', 'gzip')
+      res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Encoding': 'gzip' })
+  
+      zlib.gzip(JSON.stringify(data), (err, result) => {
+        if (err) {
+          res.writeHead(500)
+          res.end()
+
+          return;
+        }
+
+        res.end(result)
+      })
+    }
+
+    else if (req.headers['accept-encoding'].includes('deflate')) {
+      res.setHeader('Content-Encoding', 'deflate')
+      res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Encoding': 'deflate' })
+  
+      zlib.deflate(JSON.stringify(data), (err, result) => {
+        if (err) {
+          res.writeHead(500)
+          res.end()
+
+          return;
+        }
+
+        res.end(result)
+      })
+    }
+  }
+
+  return true
+}
+
+export function tryParseBody(req, res) {
+  return new Promise((resolve) => {
+    let buffer = ''
+
+    req.on('data', (chunk) => buffer += chunk)
+    req.on('end', () => {
+      try {
+        resolve(JSON.parse(buffer))
+      } catch {
+        sendResponse(req, res, {
+          timestamp: Date.now(),
+          status: 400,
+          trace: new Error().stack,
+          error: 'Bad Request',
+          message: 'Invalid JSON body',
+          path: req.url
+        }, 400)
+
+        resolve(null)
+      }
+    })
+  })
+}
+
+export function sendResponseNonNull(req, res, data) {
+  if (data === null) return;
+
+  sendResponse(req, res, data, 200)
+
+  return true
+}
+
+export function verifyMethod(parsedUrl, req, res, expected) {
+  if (req.method !== expected) {
+    sendResponse(req, res, {
+      timestamp: Date.now(),
+      status: 405,
+      error: 'Method Not Allowed',
+      message: `Request method must be ${expected}`,
+      path: parsedUrl.pathname
+    }, 405)
+
+    return 1
+  }
+
+  return 0
+}
+
+Array.prototype.nForEach = async function(callback) {
+  return new Promise(async (resolve) => {
+    for (let i = 0; i < this.length - 1; i++) {
+      const res = await callback(this[i], i)
+
+      if (res) return resolve()
+    }
+
+    resolve()
+  })
+}
+
+export function waitForEvent(emitter, eventName, func, timeoutMs) {
+  return new Promise((resolve) => {
+    const timeout = timeoutMs ? setTimeout(() => {
+      throw new Error(`Event ${eventName} timed out after ${timeoutMs}ms`)
+    }, timeoutMs) : null
+
+    const listener = (param, param2) => {
+      if (func(param, param2) === true) {
+        emitter.removeListener(eventName, listener)
+        timeoutMs ? clearTimeout(timeout) : null
+        resolve()
+      }
+    }
+    emitter.on(eventName, listener)
+  })
+}
+
+export function clamp16Bit(sample) {
+  return Math.max(constants.pcm.minimumRate, Math.min(sample, constants.pcm.maximumRate))
+}
+
+export function parseClientName(clientName) {
+  if (!clientName)
+    return null
+
+  let clientInfo = clientName.split('(')
+  if (clientInfo.length > 1) clientInfo = clientInfo[0].slice(0, clientInfo[0].length - 1)
+  else clientInfo = clientInfo[0]
+
+  const split = clientInfo.split('/')
+  const name = split[0]
+  const version = split[1]
+
+  if (!name || !version || split.length != 2) return null
+
+  return { name, version }
+}
+
+export function isEmpty(value) {
+  return value === undefined || value === null || false
+}
+
+export function loadHLS(url, stream, onceEnded) {
+  return new Promise(async (resolve) => {
+    const response = await http1makeRequest(url, { method: 'GET' })
+    const body = response.body.split('\n')
+
+    let segmentMetadata = {
+      duration: 0
+    }
+
+    body.nForEach(async (line, i) => {
+      return new Promise(async (resolveSegment) => {
+        if (stream.ended) {
+          resolveSegment(true)
+
+          return resolve(false)
+        }
+
+        if (line.startsWith('#')) {
+          const tag = line.split(':')[0]
+          let value = line.split(':')[1]
+          if (value) value = value.split(',')[0]
+
+          if (tag === '#EXTINF') {
+            segmentMetadata.duration = parseFloat(value) * 1000
+          } else if (tag === '#EXT-X-ENDLIST') {
+            stream.end()
+
+            return resolveSegment(true)
+          }
+
+          return resolveSegment(false)
+        }
+
+        const now = Date.now()
+
+        const segment = await http1makeRequest(line, { method: 'GET', streamOnly: true })
+
+        segment.stream.on('data', (chunk) => stream.write(chunk))
+        segment.stream.once('readable', () => {
+          if (segmentMetadata.duration) {
+            setTimeout(() => {
+              resolveSegment(false)
+            }, segmentMetadata.duration - (Date.now() - now) * 2)
+  
+            segmentMetadata.duration = 0
+          } else {
+            segment.stream.on('end', () => {
+              resolveSegment(false)
+
+              segment.stream.destroy()
+            })
+          }
+        })
+
+        if (onceEnded && i === body.length - 2) {
+          segment.stream.on('end', () => {
+            resolve(true)
+
+            segment.stream.destroy()
+          })
+        }
+      })
+    })
+
+    if (!onceEnded) resolve(true)
+  })
+}
+
+export function loadHLSPlaylist(url, stream) {
+  return new Promise(async (resolve) => {
+    const response = await http1makeRequest(url, { method: 'GET' })
+    const body = response.body.split('\n')
+
+    body.nForEach(async (line, i) => {
+      return new Promise(async (resolvePlaylist) => {
+        if (line.startsWith('#')) {
+          const tag = line.split(':')[0]
+          let value = line.split(':')[1]
+          if (value) value = value.split(',')[0]
+
+          if (tag === '#EXT-X-ENDLIST') {
+            stream.end()
+
+            resolvePlaylist(true)
+
+            return resolve(stream)
+          }
+
+          resolvePlaylist(false)
+
+          if (i === body.length - 1) {
+            loadHLSPlaylist(value, stream)
+
+            resolve(stream)
+          }
+
+          return;
+        }
+
+        if (await loadHLS(line, stream, true) === false)
+          return resolve(stream)
+
+        resolvePlaylist(false)
+
+        if (i === body.length - 2) {
+          loadHLSPlaylist(url, stream)
+
+          return resolve(stream)
+        }
+      })
+    })
+
+    resolve(stream)
+  })
+}

src/voice/utils.js

@@ -0,0 +1,114 @@
+import config from '../../config.js'
+import constants from '../../constants.js'
+
+import prism from 'prism-media'
+
+class NodeLinkStream {
+  constructor(stream, pipes) {
+    pipes.unshift(stream)
+
+    for (let i = 0; i < pipes.length - 1; i++) {
+      const pipe = pipes[i]
+
+      pipe.pipe(pipes[i + 1])
+    }
+
+    this.stream = pipes[pipes.length - 1]
+
+    this.listeners = []
+    this.pipes = pipes
+  }
+
+  _end() {
+    this.listeners.forEach(({ event, listener }) => this.stream.removeListener(event, listener))
+    this.listeners = []
+
+    if (this.stream) { 
+      this.stream.destroy()
+      this.stream = null
+    }
+  
+    this.pipes.forEach((_, i) => {
+      if (this.pipes[i].destroy) this.pipes[i].destroy()
+      delete this.pipes[i]
+    })
+  }
+
+  on(event, listener) {
+    this.listeners.push({ event, listener })
+
+    this.stream.on(event, listener)
+  }
+
+  once(event, listener) {
+    this.listeners.push({ event, listener })
+
+    this.stream.once(event, listener)
+  }
+
+  emit(event, ...args) {
+    this.stream.emit(event, ...args)
+  }
+
+  read() {
+    return this.stream?.read()
+  }
+
+  resume() {
+    this.stream?.resume()
+  }
+
+  destroy() {
+    this._end()
+  }
+
+  setVolume(volume) {
+    this.pipes.find((pipe) => pipe instanceof prism.VolumeTransformer)?.setVolume(volume)
+  }
+}
+
+function createAudioResource(stream, type) {
+  if ([ 'webm/opus', 'ogg/opus' ].includes(type)) {
+    return new NodeLinkStream(stream, [
+      new prism.opus[type === 'webm/opus' ? 'WebmDemuxer' : 'OggDemuxer'](),
+      new prism.opus.Decoder({ frameSize: 960, channels: 2, rate: 48000 }),
+      new prism.VolumeTransformer({ type: 's16le' }),
+      new prism.opus.Encoder({
+        rate: constants.opus.samplingRate,
+        channels: constants.opus.channels,
+        frameSize: constants.opus.frameSize
+      })
+    ])
+  }
+
+  const ffmpeg = new prism.FFmpeg({
+    args: [
+      '-loglevel', '0',
+      '-analyzeduration', '0',
+      '-hwaccel', 'auto',
+      '-threads', config.filters.threads,
+      '-filter_threads', config.filters.threads,
+      '-filter_complex_threads', config.filters.threads,
+      '-i', '-',
+      '-f', 's16le',
+      '-ar', '48000',
+      '-ac', '2',
+      '-crf', '0'
+    ]
+  })
+
+  return new NodeLinkStream(stream, [
+    ffmpeg, 
+    new prism.VolumeTransformer({ type: 's16le' }),
+    new prism.opus.Encoder({
+      rate: constants.opus.samplingRate,
+      channels: constants.opus.channels,
+      frameSize: constants.opus.frameSize
+    })
+  ])
+}
+
+export default {
+  NodeLinkStream,
+  createAudioResource
+}

src/ws.js

@@ -0,0 +1,257 @@
+import EventEmitter from 'node:events'
+import crypto from 'node:crypto'
+import { Buffer } from 'node:buffer'
+
+const TLS_MAX_SEND_SIZE = 2 ** 14
+const CONTINUE_HEADER_LENGTH = 2
+
+function parseFrameHeader(buffer) {
+  let startIndex = 2
+
+  const opcode = buffer[0] & 0b00001111
+  const fin = (buffer[0] & 0b10000000) === 0b10000000
+  const isMasked = (buffer[1] & 0x80) === 0x80
+  let payloadLength = buffer[1] & 0b01111111
+
+  if (payloadLength === 126) {
+    startIndex += 2
+    payloadLength = buffer.readUInt16BE(2)
+  } else if (payloadLength === 127) {
+    const buf = buffer.subarray(startIndex, startIndex + 8)
+
+    payloadLength = buf.readUInt32BE(0) * Math.pow(2, 32) + buf.readUInt32BE(4)
+    startIndex += 8
+  }
+
+  let mask = null
+
+  if (isMasked) {
+    mask = buffer.subarray(startIndex, startIndex + 4)
+    startIndex += 4
+
+    buffer = buffer.subarray(startIndex, startIndex + payloadLength)
+    
+    for (let i = 0; i < buffer.length; i++) {
+      buffer[i] ^= mask[i & 3]
+    }
+  } else {
+    buffer = buffer.subarray(startIndex, startIndex + payloadLength)
+  }
+
+  return {
+    opcode,
+    fin,
+    buffer,
+    payloadLength
+  }
+}
+
+class WebsocketConnection extends EventEmitter {
+  constructor(req, socket, head, addHeaders) {
+    super()
+
+    this.req = req
+    this.socket = socket
+
+    socket.setNoDelay()
+    socket.setKeepAlive(true)
+
+    if (head.length !== 0) socket.unshift(head)
+
+    const headers = [
+      'HTTP/1.1 101 Switching Protocols',
+      'Upgrade: websocket',
+      'Connection: Upgrade',
+      'Sec-WebSocket-Accept: ' + crypto.createHash('sha1').update(req.headers['sec-websocket-key'] + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest('base64'),
+      'Sec-WebSocket-Version: 13',
+    ]
+
+    if (addHeaders) {
+      for (const [key, value] of Object.entries(addHeaders)) {
+        headers.push(`${key}: ${value}`)
+      }
+    }
+
+    socket.write(headers.join('\r\n') + '\r\n\r\n')
+
+    socket.on('data', (data) => {
+      const headers = parseFrameHeader(data)
+
+      switch (headers.opcode) {
+        case 0x0: {
+          this.cachedData.push(headers.buffer)
+
+          if (headers.fin) {
+            this.emit('message', Buffer.concat(this.cachedData).toString())
+
+            this.cachedData = []
+          }
+
+          break
+        }
+        case 0x1: {
+          this.emit('message', headers.buffer.toString())
+
+          break
+        }
+        case 0x2: {
+          throw new Error('Binary data is not supported.')
+
+          break
+        }
+        case 0x8: {
+          if (headers.buffer.length === 0) {
+            this.emit('close', 1006, '')
+          } else {
+            const code = headers.buffer.readUInt16BE(0)
+            const reason = headers.buffer.subarray(2).toString('utf-8')
+
+            this.emit('close', code, reason)
+          }
+
+          socket.end()
+
+          socket.removeAllListeners()
+
+          break
+        }
+        case 0x9: {
+          const pong = Buffer.allocUnsafe(2)
+          pong[0] = 0x8a
+          pong[1] = 0x00
+
+          this.socket.write(pong)
+
+          break
+        }
+        case 0x10: {
+          this.emit('pong')
+        }
+      }
+
+      if (headers.buffer.length > headers.payloadLength)
+        this.socket.unshift(headers.buffer)
+    })
+
+    req.on('error', (err) => {
+      socket.destroy()
+
+      this.emit('close', 1006, `Error: ${err.message}`)
+
+      socket.removeAllListeners()
+    })
+
+    socket.on('error', (err) => {
+      socket.destroy()
+
+      this.emit('close', 1006, `Error: ${err.message}`)
+
+      socket.removeAllListeners()
+    })
+
+    socket.on('end', () => {
+      socket.end()
+
+      this.emit('close', 1006, '')
+
+      socket.removeAllListeners()
+    })
+  }
+
+  send(data) {
+    const payload = Buffer.from(data, 'utf-8')
+
+    if (payload.length + CONTINUE_HEADER_LENGTH > TLS_MAX_SEND_SIZE) {
+      for (let i = 0; i < payload.length; i += TLS_MAX_SEND_SIZE) {
+        const buffer = payload.subarray(i, i + TLS_MAX_SEND_SIZE)
+        const length = Buffer.byteLength(buffer)
+
+        let header = null
+
+        if (i === 0) {
+          header = this.makeFHeader({ len: length, fin: false, opcode: 0x1 })
+        }
+
+        else if (i + TLS_MAX_SEND_SIZE >= payload.length) {
+          header = this.makeFHeader({ len: length, fin: true, opcode: 0x0 })
+        }
+
+        else {
+          header = this.makeFHeader({ len: length, fin: false, opcode: 0x0 })
+        }
+
+        this.socket.write(Buffer.concat([ header, buffer ]))
+      }
+
+      return true
+    } else {
+      return this.sendFrame(payload, { len: payload.length, fin: true, opcode: 0x01 })
+    }
+  }
+
+  destroy() {
+    this.socket.destroy()
+    this.socket = null
+    this.req = null
+  }
+
+  makeFHeader(options) {
+    let payloadStartIndex = 2
+    let payloadLength = options.len
+
+    if (options.len >= 65536) {
+      payloadStartIndex += 8
+      payloadLength = 127
+    } else if (options.len > 125) {
+      payloadStartIndex += 2
+      payloadLength = 126
+    }
+
+    const header = Buffer.allocUnsafe(payloadStartIndex)
+    header[0] = options.fin ? options.opcode | 0x80 : options.opcode
+    header[1] = payloadLength
+
+    if (payloadLength === 126) {
+      header.writeUInt16BE(options.len, 2)
+    } else if (payloadLength === 127) {
+      header[2] = header[3] = 0
+      header.writeUIntBE(options.len, 4, 6)
+    }
+
+    return header
+  }
+
+  sendFrame(data, options) {
+    const header = this.makeFHeader(options)
+    
+    if (this.socket) this.socket.write(Buffer.concat([ header, data ]))
+
+    return true
+  }
+
+  close(code, reason) {
+    const data = Buffer.allocUnsafe(2 + Buffer.byteLength(reason || 'normal close'))
+    data.writeUInt16BE(code || 1000)
+    data.write(reason || 'normal close', 2)
+
+    this.sendFrame(data, { len: data.length, fin: true, opcode: 0x08 })
+
+    return true
+  }
+}
+
+class WebSocketServer extends EventEmitter {
+  constructor() {
+    super()
+  }
+
+  handleUpgrade(req, socket, head, headers, callback) {
+    const connection = new WebsocketConnection(req, socket, head, headers)
+
+    if (!socket.readable || !socket.writable) return socket.destroy()
+
+    callback(connection)
+  }
+}
+
+export { WebSocketServer }