From e1e51ddf036a2accc9eb685d9e26f09ea8b01e64 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Tue, 2 Jun 2020 13:11:12 +0200
Subject: [PATCH 01/50] :recycle: Rewrite all JSDoc documentation

---
 src/Player.js | 398 ++++++++++++++++++++++++++------------------------
 src/Queue.js  |  56 ++++---
 src/Song.js   |  58 --------
 src/Track.js  |  71 +++++++++
 src/Util.js   |  82 ++++++-----
 5 files changed, 356 insertions(+), 309 deletions(-)
 delete mode 100644 src/Song.js
 create mode 100644 src/Track.js

diff --git a/src/Player.js b/src/Player.js
index 8ec0679..8098a79 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -1,22 +1,24 @@
 const ytdl = require('ytdl-core');
-const SYA = require('simple-youtube-api');
-const mergeOptions = require('merge-options');
+const SimpleYouTubeAPI = require('simple-youtube-api');
+const Discord = require('discord.js');
 
-const { VoiceChannel, version } = require("discord.js");
-if(version.split('.')[0] !== '12') throw new Error("Only the master branch of discord.js library is supported for now. Install it using 'npm install discordjs/discord.js'.");
 const Queue = require('./Queue');
+const Track = require('./Track');
 const Util = require('./Util');
-const Song = require('./Song');
 
 /**
- * Player options.
- * @typedef {PlayerOptions}
- * 
- * @property {Boolean} leaveOnEnd Whether the bot should leave the current voice channel when the queue ends.
- * @property {Boolean} leaveOnStop Whether the bot should leave the current voice channel when the stop() function is used.
- * @property {Boolean} leaveOnEmpty Whether the bot should leave the voice channel if there is no more member in it.
- */ 
-const PlayerOptions = {
+ * @typedef PlayerOptions
+ * @property {boolean} [leaveOnEnd=true] Whether the bot should leave the current voice channel when the queue ends.
+ * @property {boolean} [leaveOnStop=true] Whether the bot should leave the current voice channel when the stop() function is used.
+ * @property {boolean} [leaveOnEmpty=true] Whether the bot should leave the voice channel if there is no more member in it.
+ */
+
+/**
+ * Default options for the player
+ * @ignore
+ * @type {PlayerOptions}
+ */
+const defaultPlayerOptions = {
     leaveOnEnd: true,
     leaveOnStop: true,
     leaveOnEmpty: true
@@ -25,158 +27,153 @@ const PlayerOptions = {
 class Player {
 
     /**
-     * @param {Client} client Your Discord Client instance.
-     * @param {string} youtubeToken Your Youtube Data v3 API key.
-     * @param {PlayerOptions} options The PlayerOptions object.
+     * @param {Discord.Client} client Discord.js client
+     * @param {string} youtubeToken Youtube Data v3 API Key
+     * @param {PlayerOptions} options Player options
      */
     constructor(client, youtubeToken, options = {}){
         if(!client) throw new SyntaxError('Invalid Discord client');
         if(!youtubeToken) throw new SyntaxError('Invalid Token: Token must be a String');
+
         /**
-         * Your Discord Client instance.
-         * @type {Client}
+         * Discord.js client instance
+         * @type {Discord.Client}
          */
         this.client = client;
         /**
-         * Your Youtube Data v3 API key.
+         * YouTube API Key
          * @type {string}
          */
         this.youtubeToken = youtubeToken;
         /**
-         * The Simple Youtube API Client.
-         * @type {Youtube}
+         * Simple YouTube API client instance
+         * @type {SimpleYouTubeAPI.YouTube}
          */
-        this.SYA = new SYA(this.youtubeToken);
+        this.youtube = new SimpleYouTubeAPI.YouTube(this.youtubeToken);
         /**
-         * The guilds data.
+         * Player queues
          * @type {Queue[]}
          */
         this.queues = [];
         /**
-         * Player options.
+         * Player options
          * @type {PlayerOptions}
          */
-        this.options = mergeOptions(PlayerOptions, options);
+        this.options = defaultPlayerOptions;
+        for(const prop in options){
+            this.options[prop] = options[prop];
+        }
+        /**
+         * Utilities methods for the player
+         * @type {Util}
+         */
+        this.util = new Util(this.youtube)
 
         // Listener to check if the channel is empty
-        client.on('voiceStateUpdate', (oldState, newState) => {
-            if(!this.options.leaveOnEmpty) return;
-            // If the member leaves a voice channel
-            if(!oldState.channelID || newState.channelID) return;
-            // Search for a queue for this channel
-            let queue = this.queues.find((g) => g.connection.channel.id === oldState.channelID);
-            if(queue){
-                // If the channel is not empty
-                if(queue.connection.channel.members.size > 1) return;
-                // Disconnect from the voice channel
-                queue.connection.channel.leave();
-                // Delete the queue
-                this.queues = this.queues.filter((g) => g.guildID !== queue.guildID);
-                // Emit end event
-                queue.emit('channelEmpty');
-            }
-        });
+        client.on('voiceStateUpdate', (oldState, newState) => this._handleVoiceStateUpdate.call(this, oldState, newState));
     }
 
     /**
-     * Whether a guild is currently playing songs
-     * @param {string} guildID The guild ID to check
-     * @returns {Boolean} Whether the guild is currently playing songs
+     * Whether a guild is currently playing something
+     * @param {Discord.Snowflake} guildID The guild ID to check
+     * @returns {boolean} Whether the guild is currently playing tracks
      */
     isPlaying(guildID) {
         return this.queues.some((g) => g.guildID === guildID);
     }
 
     /**
-     * Plays a song in a voice channel.
-     * @param {voiceChannel} voiceChannel The voice channel in which the song will be played.
-     * @param {string} songName The name of the song to play.
-     * @param {User} requestedBy The user who requested the song.
-     * @returns {Promise<Song>}
+     * Play a track in a voice channel
+     * @param {Discord.VoiceChannel} voiceChannel The voice channel in which the track will be played
+     * @param {Track|string} track The name of the track to play
+     * @param {Discord.User?} user The user who requested the track
+     * @returns {Promise<Track>} The played track
      */
-    play(voiceChannel, songName, requestedBy) {
+    play(voiceChannel, track, user) {
         this.queues = this.queues.filter((g) => g.guildID !== voiceChannel.id);
         return new Promise(async (resolve, reject) => {
-            if(!voiceChannel || typeof voiceChannel !== "object") return reject("voiceChannel must be type of VoiceChannel. value="+voiceChannel);
-            if(typeof songName !== "string") return reject("songName must be type of string. value="+songName);
-            // Searches the song
-            let video = await Util.getFirstYoutubeResult(songName, this.SYA);
-            if(!video) return reject('Song not found');
-            // Joins the voice channel
-            let connection = await voiceChannel.join();
-            // Creates a new guild with data
+            if(!voiceChannel || typeof voiceChannel !== "object"){
+                return reject(`voiceChannel must be type of VoiceChannel. value=${voiceChannel}`);
+            }
+            const connection = voiceChannel.client.voice.connections.find((c) => c.channel.id === voiceChannel.id) || await voiceChannel.join();
+            if(typeof track !== "object"){
+                const results = await this.util.search(track, user);
+                track = results[0];
+            }
+            // Create a new guild with data
             let queue = new Queue(voiceChannel.guild.id);
-            queue.connection = connection;
-            let song = new Song(video, queue, requestedBy);
-            queue.songs.push(song);
+            queue.voiceConnection = connection;
+            // Add the track to the queue
+            track.requestedBy = user;
+            queue.tracks.push(track);
             // Add the queue to the list
             this.queues.push(queue);
-            // Plays the song
-            this._playSong(queue.guildID, true);
-            // Resolves the song.
-            resolve(song);
+            // Play the track
+            this._playTrack(queue.guildID, true);
+            // Resolve the track
+            resolve(track);
         });
     }
 
     /**
-     * Pauses the current song.
-     * @param {string} guildID
-     * @returns {Promise<Song>}
+     * Pause the current track
+     * @param {Discord.Snowflake} guildID The ID of the guild where the current track should be paused
+     * @returns {Promise<Track>} The paused track
      */
-    pause(guildID){
+    pause (guildID) {
         return new Promise(async(resolve, reject) => {
             // Gets guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
             // Pauses the dispatcher
-            queue.dispatcher.pause();
+            queue.voiceConnection.dispatcher.pause();
             queue.playing = false;
             // Resolves the guild queue
-            resolve(queue.songs[0]);
+            resolve(queue.tracks[0]);
         });
     }
 
     /**
-     * Resumes the current song.
-     * @param {string} guildID
-     * @returns {Promise<Song>}
+     * Resume the current track
+     * @param {Discord.Snowflake} guildID The ID of the guild where the current track should be resumed
+     * @returns {Promise<Track>} The resumed track
      */
-    resume(guildID){
+    resume (guildID) {
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            // Pauses the dispatcher
-            queue.dispatcher.resume();
+            // Pause the dispatcher
+            queue.voiceConnection.dispatcher.resume();
             queue.playing = true;
-            // Resolves the guild queue
-            resolve(queue.songs[0]);
+            // Resolve the guild queue
+            resolve(queue.tracks[0]);
         });
     }
 
     /**
      * Stops playing music.
-     * @param {string} guildID
+     * @param {Discord.Snowflake} guildID The ID of the guild where the music should be stopped
      * @returns {Promise<void>}
      */
     stop(guildID){
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            // Stops the dispatcher
+            // Stop the dispatcher
             queue.stopped = true;
-            queue.songs = [];
-            queue.dispatcher.end();
-            // Resolves
+            queue.tracks = [];
+            queue.voiceConnection.dispatcher.end();
+            // Resolve
             resolve();
         });
     }
 
     /**
-     * Updates the volume.
-     * @param {string} guildID 
-     * @param {number} percent 
+     * Update the volume
+     * @param {Discord.Snowflake} guildID The ID of the guild where the music should be modified 
+     * @param {number} percent The new volume (0-100)
      * @returns {Promise<void>}
      */
     setVolume(guildID, percent) {
@@ -185,15 +182,16 @@ class Player {
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
             // Updates volume
-            queue.dispatcher.setVolumeLogarithmic(percent / 200);
+            queue.voiceConnection.dispatcher.setVolumeLogarithmic(percent / 200);
+            queue.volume = percent;
             // Resolves guild queue
-            resolve(queue);
+            resolve();
         });
     }
 
     /**
-     * Gets the guild queue.
-     * @param {string} guildID
+     * Get a guild queue
+     * @param {Discord.Snowflake} guildID
      * @returns {?Queue}
      */
     getQueue(guildID) {
@@ -203,108 +201,107 @@ class Player {
     }
 
     /**
-     * Adds a song to the guild queue.
-     * @param {string} guildID
-     * @param {string} songName The name of the song to add to the queue.
-     * @param {User} requestedBy The user who requested the song.
-     * @returns {Promise<Song>}
+     * Add a track to the guild queue
+     * @param {Discord.Snowflake} guildID The ID of the guild where the track should be added
+     * @param {string} trackName The name of the track to add to the queue
+     * @param {Discord.User?} requestedBy The user who requested the track
+     * @returns {Promise<Track>} The added track
      */
-    addToQueue(guildID, songName, requestedBy){
+    addToQueue(guildID, trackName, requestedBy){
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            // Searches the song
-            let video = await Util.getFirstYoutubeResult(songName, this.SYA).catch(() => {});
-            if(!video) return reject('Song not found');
-            let song = new Song(video, queue, requestedBy);
-            // Updates queue
-            queue.songs.push(song);
-            // Resolves the song
-            resolve(song);
+            // Search the track
+            let track = await this.util.search(trackName, requestedBy).catch(() => {});
+            if(!track[0]) return reject('Track not found');
+            // Update queue
+            queue.tracks.push(track[0]);
+            // Resolve the track
+            resolve(track[0]);
         });
     }
 
     /**
-     * Sets the queue for a guild.
-     * @param {string} guildID
-     * @param {Array<Song>} songs The songs list
-     * @returns {Promise<Queue>}
+     * Set the queue for a guild.
+     * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be set
+     * @param {Track[]} tracks The tracks list
+     * @returns {Promise<Queue>} The new queue
      */
-    setQueue(guildID, songs){
+    setQueue(guildID, tracks){
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            // Updates queue
-            queue.songs = songs;
-            // Resolves the queue
+            // Update queue
+            queue.tracks = tracks;
+            // Resolve the queue
             resolve(queue);
         });
     }
 
     /**
-     * Clears the guild queue, but not the current song.
-     * @param {string} guildID
-     * @returns {Promise<Queue>}
+     * Clear the guild queue, but not the current track
+     * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be cleared
+     * @returns {Promise<Queue>} The updated queue
      */
     clearQueue(guildID){
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            // Clears queue
-            let currentlyPlaying = queue.songs.shift();
-            queue.songs = [ currentlyPlaying ];
-            // Resolves guild queue
+            // Clear queue
+            let currentlyPlaying = queue.tracks.shift();
+            queue.tracks = [ currentlyPlaying ];
+            // Resolve guild queue
             resolve(queue);
         });
     }
 
     /**
-     * Skips a song.
-     * @param {string} guildID
-     * @returns {Promise<Song>}
+     * Skip a track
+     * @param {Discord.Snowflake} guildID The ID of the guild where the track should be skipped
+     * @returns {Promise<Track>}
      */
     skip(guildID){
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            let currentSong = queue.songs[0];
-            // Ends the dispatcher
-            queue.dispatcher.end();
-            queue.skipped = true;
-            // Resolves the current song
-            resolve(currentSong);
+            let currentTrack = queue.tracks[0];
+            // End the dispatcher
+            queue.voiceConnection.dispatcher.end();
+            queue.lastSkipped = true;
+            // Resolve the current track
+            resolve(currentTrack);
         });
     }
 
     /**
-     * Gets the currently playing song.
-     * @param {string} guildID
-     * @returns {Promise<Song>}
+     * Get the currently playing track
+     * @param {Discord.Snowflake} guildID
+     * @returns {Promise<Track>} The track which is currently played
      */
     nowPlaying(guildID){
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            let currentSong = queue.songs[0];
-            // Resolves the current song
-            resolve(currentSong);
+            let currentTrack = queue.tracks[0];
+            // Resolve the current track
+            resolve(currentTrack);
         });
     }
 
     /**
      * Enable or disable the repeat mode
-     * @param {string} guildID
+     * @param {Discord.Snowflake} guildID
      * @param {Boolean} enabled Whether the repeat mode should be enabled
      * @returns {Promise<Void>}
      */
     setRepeatMode(guildID, enabled) {
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
             // Enable/Disable repeat mode
@@ -315,89 +312,116 @@ class Player {
     }
 
     /**
-     * Shuffles the guild queue.
-     * @param {string} guildID 
-     * @returns {Promise<Void>}
+     * Shuffle the guild queue (except the first track)
+     * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be shuffled
+     * @returns {Promise<Queue>} The updated queue
      */
     shuffle(guildID){
         return new Promise(async(resolve, reject) => {
-            // Gets guild queue
+            // Get guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            // Shuffle the queue (except the first song)
-            let currentSong = queue.songs.shift();
-            queue.songs = queue.songs.sort(() => Math.random() - 0.5);
-            queue.songs.unshift(currentSong);
+            // Shuffle the queue (except the first track)
+            let currentTrack = queue.tracks.shift();
+            queue.tracks = queue.tracks.sort(() => Math.random() - 0.5);
+            queue.tracks.unshift(currentTrack);
             // Resolve
-            resolve();
+            resolve(queue);
         });
     }
 
     /**
-     * Removes a song from the queue
-     * @param {string} guildID 
-     * @param {number|Song} song The index of the song to remove or the song to remove object.
-     * @returns {Promise<Song|null>}
+     * Remove a track from the queue
+     * @param {Discord.Snowflake} guildID The ID of the guild where the track should be removed
+     * @param {number|Track} track The index of the track to remove or the track to remove object
+     * @returns {Promise<Track|null>}
      */
-    remove(guildID, song){
+    remove(guildID, track){
         return new Promise(async(resolve, reject) => {
             // Gets guild queue
             let queue = this.queues.find((g) => g.guildID === guildID);
             if(!queue) return reject('Not playing');
-            // Remove the song from the queue
-            let songFound = null;
-            if(typeof song === "number"){
-                songFound = queue.songs[song];
-                if(songFound){
-                    queue.songs = queue.songs.filter((s) => s !== songFound);
+            // Remove the track from the queue
+            let trackFound = null;
+            if(typeof track === "number"){
+                trackFound = queue.tracks[track];
+                if(trackFound){
+                    queue.tracks = queue.tracks.filter((s) => s !== trackFound);
                 }
             } else {
-                songFound = queue.songs.find((s) => s === song);
-                if(songFound){
-                    queue.songs = queue.songs.filter((s) => s !== songFound);
+                trackFound = queue.tracks.find((s) => s === track);
+                if(trackFound){
+                    queue.tracks = queue.tracks.filter((s) => s !== trackFound);
                 }
             }
             // Resolve
-            resolve(songFound);
+            resolve(trackFound);
         });
     }
 
     /**
-     * Start playing songs in a guild.
+     * Handle the voice state update event
      * @ignore
-     * @param {string} guildID
+     * @private
+     * @param {Discord.VoiceState} oldState
+     * @param {Discord.VoiceState} newState
+     */
+    _handleVoiceStateUpdate(oldState, newState) {
+        if(!this.options.leaveOnEmpty) return;
+        // If the member leaves a voice channel
+        if(!oldState.channelID || newState.channelID) return;
+        // Search for a queue for this channel
+        let queue = this.queues.find((g) => g.voiceConnection.channel.id === oldState.channelID);
+        if(queue){
+            // If the channel is not empty
+            if(queue.voiceConnection.channel.members.size > 1) return;
+            // Disconnect from the voice channel
+            queue.voiceConnection.channel.leave();
+            // Delete the queue
+            this.queues = this.queues.filter((g) => g.guildID !== queue.guildID);
+            // Emit end event
+            queue.emit('channelEmpty');
+        }
+    }
+
+    /**
+     * Start playing a track in a guild
+     * @ignore
+     * @private
+     * @param {Discord.Snowflake} guildID
      * @param {Boolean} firstPlay Whether the function was called from the play() one
      */
-    async _playSong(guildID, firstPlay) {
+    async _playTrack(guildID, firstPlay) {
         // Gets guild queue
         let queue = this.queues.find((g) => g.guildID === guildID);
         // If there isn't any music in the queue
-        if(queue.songs.length < 2 && !firstPlay && !queue.repeatMode){
+        if(queue.tracks.length < 2 && !firstPlay && !queue.repeatMode){
             // Leaves the voice channel
-            if(this.options.leaveOnEnd && !queue.stopped) queue.connection.channel.leave();
+            if(this.options.leaveOnEnd && !queue.stopped) queue.voiceConnection.channel.leave();
             // Remoces the guild from the guilds list
             this.queues = this.queues.filter((g) => g.guildID !== guildID);
             // Emits stop event
             if(queue.stopped){
-                if(this.options.leaveOnStop) queue.connection.channel.leave();
+                if(this.options.leaveOnStop) queue.voiceConnection.channel.leave();
                 return queue.emit('stop');
             }
             // Emits end event 
             return queue.emit('end');
         }
-        // Emit songChanged event
-        if(!firstPlay) queue.emit('songChanged', (!queue.repeatMode ? queue.songs.shift() : queue.songs[0]), queue.songs[0], queue.skipped, queue.repeatMode);
-        queue.skipped = false;
-        let song = queue.songs[0];
-        // Download the song
-        let dispatcher = queue.connection.play(ytdl(song.url, { filter: "audioonly" }));
-        queue.dispatcher = dispatcher;
+        // Emit trackChanged event
+        if(!firstPlay) queue.emit('trackChanged', (!queue.repeatMode ? queue.tracks.shift() : queue.tracks[0]), queue.tracks[0], queue.lastSkipped, queue.repeatMode);
+        queue.lastSkipped = false;
+        let track = queue.tracks[0];
+        // Download the track
+        queue.voiceConnection.play(ytdl(track.url, {
+            filter: "audioonly"
+        }));
         // Set volume
-        dispatcher.setVolumeLogarithmic(queue.volume / 200);
-        // When the song ends
-        dispatcher.on('finish', () => {
-            // Play the next song
-            return this._playSong(guildID, false);
+        queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200);
+        // When the track ends
+        queue.voiceConnection.dispatcher.on('finish', () => {
+            // Play the next track
+            return this._playTrack(guildID, false);
         });
     }
 
diff --git a/src/Queue.js b/src/Queue.js
index dea9924..e42c727 100644
--- a/src/Queue.js
+++ b/src/Queue.js
@@ -1,4 +1,6 @@
-const { EventEmitter } = require('events');
+const Discord = require('discord.js')
+const { EventEmitter } = require('events')
+const Track = require('./Track')
 
 /**
  * Represents a guild queue.
@@ -6,60 +8,56 @@ const { EventEmitter } = require('events');
 class Queue extends EventEmitter {
 
     /**
-     * Represents a guild queue.
-     * @param {string} guildID 
+     * @param {Discord.Snowflake} guildID ID of the guild this queue is for.
      */
     constructor(guildID){
         super();
         /**
-         * The guild ID.
-         * @type {Snowflake}
+         * ID of the guild this queue is for.
+         * @type {Discord.Snowflake}
          */
         this.guildID = guildID;
         /**
-         * The stream dispatcher.
-         * @type {StreamDispatcher}
+         * The voice connection of this queue.
+         * @type {Discord.VoiceConnection}
          */
-        this.dispatcher = null;
+        this.voiceConnection = null;
         /**
-         * The voice connection.
-         * @type {VoiceConnection}
+         * The tracks of this queue. The first one is currenlty playing and the others are going to be played.
+         * @type {Track[]}
          */
-        this.connection = null;
-        /**
-         * Songs. The first one is currently playing and the rest is going to be played.
-         * @type {Song[]}
-         */
-        this.songs = [];
+        this.tracks = [];
         /**
          * Whether the stream is currently stopped.
-         * @type {Boolean}
+         * @type {boolean}
          */
         this.stopped = false;
         /**
-         * Whether the last song was skipped.
-         * @type {Boolean}
+         * Whether the last track was skipped.
+         * @type {boolean}
          */
-        this.skipped = false;
+        this.lastSkipped = false;
         /**
-         * The stream volume.
-         * @type {Number}
+         * The stream volume of this queue. (0-100)
+         * @type {number}
          */
         this.volume = 100;
         /**
          * Whether the stream is currently playing.
-         * @type {Boolean}
+         * @type {boolean}
          */
         this.playing = true;
         /**
          * Whether the repeat mode is enabled.
-         * @type {Boolean}
+         * @type {boolean}
          */
         this.repeatMode = false;
     }
 
 };
 
+module.exports = Queue;
+
 /**
  * Emitted when the queue is empty.
  * @event Queue#end
@@ -71,11 +69,9 @@ class Queue extends EventEmitter {
  */
 
 /**
- * Emitted when the song changes.
- * @event Queue#songChanged
- * @param {Song} oldSong The old song (playing before)
- * @param {Song} newSong The new song (currently playing)
+ * Emitted when the track changes.
+ * @event Queue#trackChanged
+ * @param {Track} oldTrack The old track (playing before)
+ * @param {Track} newTrack The new track (currently playing)
  * @param {Boolean} skipped Whether the change is due to the skip() function
  */
-
-module.exports = Queue;
\ No newline at end of file
diff --git a/src/Song.js b/src/Song.js
deleted file mode 100644
index d2794ed..0000000
--- a/src/Song.js
+++ /dev/null
@@ -1,58 +0,0 @@
-/**
- * Represents a song.
- */
-class Song {
-    /**
-     * @param {Video} video The Youtube video
-     * @param {Queue} queue The queue in which the song is
-     */
-    constructor(video, queue, requestedBy) {
-        /**
-         * Song name.
-         * @type {string}
-         */
-        this.name = video.title;
-        /**
-         * Song duration.
-         * @type {Number}
-         */
-        this.duration = ((video.duration.hours*3600)+(video.duration.minutes*60)+(video.duration.seconds)) * 100;
-        /**
-         * Raw video object from Simple Youtube API
-         * @type {Video}
-         */
-        this.rawVideo = video;
-        /**
-         * Raw informations about the song.
-         * @type {Object}
-         */
-        this.raw = video.raw;
-        /**
-         * Author channel of the song.
-         * @type {string}
-         */
-        this.author = video.raw.snippet.channelTitle;
-        /**
-         * Youtube video URL.
-         * @type {string}
-         */
-        this.url = `https://www.youtube.com/watch?v=${video.id}`;
-        /**
-         * Youtube video thumbnail.
-         * @type {string}
-         */
-        this.thumbnail = video.raw.snippet.thumbnails.default.url;
-        /**
-         * The queue in which the song is.
-         * @type {Queue}
-         */
-        this.queue = queue;
-        /**
-         * The user who requested that song.
-         * @type {User}
-         */
-        this.requestedBy = requestedBy;
-    }
-};
-
-module.exports = Song;
\ No newline at end of file
diff --git a/src/Track.js b/src/Track.js
new file mode 100644
index 0000000..b3f0133
--- /dev/null
+++ b/src/Track.js
@@ -0,0 +1,71 @@
+const Discord = require('discord.js')
+const Queue = require('./Queue')
+const SimpleYouTubeAPI = require('simple-youtube-api')
+
+/**
+ * Represents a track.
+ */
+class Track {
+
+    /**
+     * @param {SimpleYouTubeAPI.Video} video The video for this track
+     * @param {Discord.User?} user The user who requested the track
+     * @param {Queue?} queue The queue in which is the track is
+     */
+    constructor(video, user, queue) {
+        /**
+         * The track name
+         * @type {string}
+         */
+        this.name = video.title;
+        /**
+         * The full video object
+         * @type {SimpleYouTubeAPI.Video}
+         */
+        this.data = video;
+        /**
+         * The Youtube URL of the track
+         * @type {string}
+         */
+        this.url = `https://www.youtube.com/watch?v=${video.id}`;
+        /**
+         * The user who requested the track
+         * @type {Discord.User?}
+         */
+        this.requestedBy = user;
+        /**
+         * The queue in which the track is
+         * @type {Queue}
+         */
+        this.queue = queue;
+    }
+
+    /**
+     * The name of the channel which is the author of the video on Youtube
+     * @type {string}
+     */
+    get author() {
+        return this.data.raw.snippet.channelTitle;
+    }
+
+    /**
+     * The Youtube video thumbnail
+     * @type {string}
+     */
+    get thumbnail() {
+        return this.data.raw.snippet.thumbnails.default.url;
+    }
+
+    /**
+     * The track duration
+     * @type {number}
+     */
+    get duration() {
+        return typeof this.data.duration === "object"
+            ? ((this.data.duration.hours*3600)+(this.data.duration.minutes*60)+(this.data.duration.seconds)) * 1000
+            : parseInt(this.data.duration)
+    }
+
+};
+
+module.exports = Track;
diff --git a/src/Util.js b/src/Util.js
index 683c198..0a92906 100644
--- a/src/Util.js
+++ b/src/Util.js
@@ -1,49 +1,63 @@
-const fetch = require('node-fetch');
+const fetch = require('node-fetch')
+const Discord = require('discord.js')
+const Track = require('./Track')
+const SimpleYouTubeAPI = require('simple-youtube-api')
 
 /**
- * Utilities.
- * @ignore
+ * Utilities
  */
 class Util {
 
-    constructor(){}
-    
     /**
-     * Gets the first youtube results for your search.
-     * @param {string} search The name of the video or the video URL.
-     * @param {Youtube} SYA The Simple Youtube API Client.
-     * @returns {Promise<Video>}
+     * @param {SimpleYouTubeAPI.YouTube} youtube The SimpleYouTubeAPI client instance
      */
-    static getFirstYoutubeResult(search, SYA){
+    constructor(youtube){
+        /**
+         * The SimpleYouTubeAPI client instance
+         * @type {SimpleYouTubeAPI.YouTube}
+         */
+        this.youtube = youtube;
+    }
+
+    /**
+     * Get the first youtube results for your search
+     * @param {string} query The name of the video or the video URL
+     * @param {Discord.User?} user The user who requested the track
+     * @returns {Promise<Track[]>}
+     */
+    search(query, user) {
         return new Promise(async (resolve, reject) => {
-            search = search.replace(/<(.+)>/g, "$1");
-            // Try with URL
-            SYA.getVideo(search).then(async (video) => {
-                video = await video.fetch();
-                resolve(video);
-            }).catch(async (err) => {
-                if(err.message === "Bad Request"){
-                    reject('Invalid Youtube Data v3 API key.');
-                } else {
-                    try {
-                        // Try with song name
-                        let results = await SYA.searchVideos(search, 1);
-                        if(results.length < 1) return reject('Not found');
-                        let fetched = await results.shift().fetch();
-                        results.push(fetched);
-                        resolve(results.pop());
-                    } catch(err){
-                        if(err.message === "Bad Request"){
-                            reject('Invalid Youtube Data v3 API key.');
-                        } else {
-                            reject(err);
-                        }
+            query = query.replace(/<(.+)>/g, "$1");
+            try {
+                const videoData = SimpleYouTubeAPI.parseURL(query);
+                if(videoData.video){
+                    const video = await this.youtube.getVideoById(videoData.video);
+                    if(video){
+                        await video.fetch();
+                        const track = new Track(video, user, null);
+                        return resolve([ track ]);
                     }
                 }
-            });
+                const results = await this.youtube.searchVideos(query, 1);
+                const tracks = [];
+                for(let result of (results.filter((r) => r.type === "video"))){
+                    // @ts-ignore
+                    await result.fetch();
+                    // @ts-ignore
+                    const track = new Track(result, user, null);
+                    tracks.push(track);
+                }
+                return resolve(tracks);
+            } catch(e) {
+                if(e.message && e.message === "Bad Request"){
+                    reject("Looks like your YouTube Data v3 API key is not valid...");
+                } else {
+                    reject(e);
+                }
+            }
         });
     }
 
 };
 
-module.exports = Util;
\ No newline at end of file
+module.exports = Util;

From 48a4ddb037e76f87e2d82a8ae5803bc8b512c47e Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Tue, 2 Jun 2020 13:20:05 +0200
Subject: [PATCH 02/50] :pencil: Use track instead of song

---
 README.md | 132 +++++++++++++++++++++++++++---------------------------
 1 file changed, 66 insertions(+), 66 deletions(-)

diff --git a/README.md b/README.md
index 04b96c5..a39714e 100644
--- a/README.md
+++ b/README.md
@@ -46,7 +46,7 @@ client.login(settings.token);
 ```
 
 You can pass a third parameter when instantiating the class Player: the **options** object:  
-**options.leaveOnEnd**: whether the bot should leave the voice channel when there is no more song in the queue.  
+**options.leaveOnEnd**: whether the bot should leave the voice channel when there is no more track in the queue.  
 **options.leaveOnStop**: whether the bot should leave the voice channel when the `stop()` function is used.  
 **options.leaveOnEmpty**: whether the bot should leave the voice channel if there is no more member in it.
 
@@ -55,19 +55,19 @@ You can pass a third parameter when instantiating the class Player: the **option
 You need to **init the guild queue using the play() function**, then you are able to manage the queue using the following functions:
 
 ```js
-// Play a song in the voice channel and init the guild queue
-client.player.play(voiceChannel, songName);
+// Play a track in the voice channel and init the guild queue
+client.player.play(voiceChannel, trackName);
 
-// Add a song to the queue
-client.player.addToQueue(guildID, songName);
+// Add a track to the queue
+client.player.addToQueue(guildID, trackName);
 // Clear the queue
 client.player.clearQueue(guildID);
 // Get the queue
 client.player.getQueue(guildID);
-// Skip the current song
+// Skip the current track
 client.player.skip(guildID);
-// Remove a song from the queue using the index number
-client.player.remove(guildID, song);
+// Remove a track from the queue using the index number
+client.player.remove(guildID, track);
 
 
 // Pause
@@ -79,13 +79,13 @@ client.player.stop(guildID);
 
 // Check if music is playing in a guild
 client.player.isPlaying(guildID);
-// Get the currently playing song
+// Get the currently playing trac
 client.player.nowPlaying(guildID);
 
 
-// Current song will be repeated indefinitely
+// Current track will be repeated indefinitely
 client.player.setRepeatMode(guildID, true);
-// Current song will no longer be repeated indefinitely
+// Current track will no longer be repeated indefinitely
 client.player.setRepeatMode(guildID, false);
 ```
 
@@ -96,8 +96,8 @@ client.player.getQueue(guildID)
 .on('end', () => {
     message.channel.send('There is no more music in the queue!');
 })
-.on('songChanged', (oldSong, newSong) => {
-    message.channel.send(`Now playing ${newSong.name}...`);
+.on('trackChanged', (oldTrack, newTrack) => {
+    message.channel.send(`Now playing ${newTrack.name}...`);
 })
 .on('channelEmpty', () => {
     message.channel.send('Stop playing, there is no more member in the voice channel...');
@@ -108,12 +108,12 @@ client.player.getQueue(guildID)
 
 ### Play
 
-To play a song, use the `client.player.play()` function.  
+To play a track, use the `client.player.play()` function.  
 
 **Usage:**
 
 ```js
-client.player.play(voiceChannel, songName, requestedBy);
+client.player.play(voiceChannel, trackName, requestedBy);
 ```
 
 **Example**:
@@ -128,15 +128,15 @@ client.on('message', async (message) => {
     // will play "Despacito" in the member voice channel
 
     if(command === 'play'){
-        let song = await client.player.play(message.member.voice.channel, args[0], message.member.user.tag);
-        message.channel.send(`Currently playing ${song.name}! - Requested by ${song.requestedBy}`);
+        let track = await client.player.play(message.member.voice.channel, args[0], message.member.user.tag);
+        message.channel.send(`Currently playing ${track.name}! - Requested by ${track.requestedBy}`);
     }
 
 ```
 
 ### Pause
 
-To pause the current song, use the `client.player.pause()` function.  
+To pause the current track, use the `client.player.pause()` function.  
 
 **Usage:**
 
@@ -153,8 +153,8 @@ client.on('message', async (message) => {
     const command = args.shift().toLowerCase();
 
     if(command === 'pause'){
-        let song = await client.player.pause(message.guild.id);
-        message.channel.send(`${song.name} paused!`);
+        let track = await client.player.pause(message.guild.id);
+        message.channel.send(`${track.name} paused!`);
     }
 
 });
@@ -162,7 +162,7 @@ client.on('message', async (message) => {
 
 ### Resume
 
-To resume the current song, use the `client.player.resume()` function.  
+To resume the current track, use the `client.player.resume()` function.  
 
 **Usage:**
 
@@ -179,8 +179,8 @@ client.on('message', async (message) => {
     const command = args.shift().toLowerCase();
 
     if(command === 'resume'){
-        let song = await client.player.resume(message.guild.id);
-        message.channel.send(`${song.name} resumed!`);
+        let track = await client.player.resume(message.guild.id);
+        message.channel.send(`${track.name} resumed!`);
     }
 
 });
@@ -240,17 +240,17 @@ client.on('message', (message) => {
 
 ### AddToQueue
 
-To add a song to the queue, use the `client.player.addToQueue()` function.
+To add a track to the queue, use the `client.player.addToQueue()` function.
 
 **Usage:**
 
 ```js
-client.player.addToQueue(guildID, songName);
+client.player.addToQueue(guildID, trackName);
 ```
 
 **Example:**
 
-In this example, you will see how to add a song to the queue if one is already playing.
+In this example, you will see how to add a track to the queue if one is already playing.
 
 ```js
 client.on('message', async (message) => {
@@ -259,16 +259,16 @@ client.on('message', async (message) => {
     const command = args.shift().toLowerCase();
 
     if(command === 'play'){
-        let aSongIsAlreadyPlaying = client.player.isPlaying(message.guild.id);
-        // If there's already a song playing
-        if(aSongIsAlreadyPlaying){
-            // Add the song to the queue
-            let song = await client.player.addToQueue(message.guild.id, args[0]);
-            message.channel.send(`${song.name} added to queue!`);
+        let aTrackIsAlreadyPlaying = client.player.isPlaying(message.guild.id);
+        // If there's already a track playing
+        if(aTrackIsAlreadyPlaying){
+            // Add the track to the queue
+            let track = await client.player.addToQueue(message.guild.id, args[0]);
+            message.channel.send(`${track.name} added to queue!`);
         } else {
-            // Else, play the song
-            let song = await client.player.play(message.member.voice.channel, args[0]);
-            message.channel.send(`Currently playing ${song.name}!`);
+            // Else, play the track
+            let track = await client.player.play(message.member.voice.channel, args[0]);
+            message.channel.send(`Currently playing ${track.name}!`);
         }
     }
 
@@ -321,8 +321,8 @@ client.on('message', (message) => {
 
     if(command === 'queue'){
         let queue = await client.player.getQueue(message.guild.id);
-        message.channel.send('Server queue:\n'+(queue.songs.map((song, i) => {
-            return `${i === 0 ? 'Current' : `#${i+1}`} - ${song.name} | ${song.author}`
+        message.channel.send('Server queue:\n'+(queue.tracks.map((track, i) => {
+            return `${i === 0 ? 'Current' : `#${i+1}`} - ${track.name} | ${track.author}`
         }).join('\n')));
     }
 
@@ -341,7 +341,7 @@ client.on('message', (message) => {
 
 ### Skip
 
-To skip the current song, use the `client.player.skip()` function.  
+To skip the current track, use the `client.player.skip()` function.  
 
 **Usage:**
 
@@ -358,8 +358,8 @@ client.on('message', async (message) => {
     const command = args.shift().toLowerCase();
 
     if(command === 'skip'){
-        let song = await client.player.skip(message.guild.id);
-        message.channel.send(`${song.name} skipped!`);
+        let track = await client.player.skip(message.guild.id);
+        message.channel.send(`${track.name} skipped!`);
     }
 
 });
@@ -367,7 +367,7 @@ client.on('message', async (message) => {
 
 ### Now Playing
 
-To get the currently playing song, use the `client.player.nowPlaying()` function.  
+To get the currently playing track, use the `client.player.nowPlaying()` function.  
 
 **Usage:**
 
@@ -384,8 +384,8 @@ client.on('message', async (message) => {
     const command = args.shift().toLowerCase();
 
     if(command === 'now-playing'){
-        let song = await client.player.nowPlaying(message.guild.id);
-        message.channel.send(`Currently playing ${song.name}...`);
+        let track = await client.player.nowPlaying(message.guild.id);
+        message.channel.send(`Currently playing ${track.name}...`);
     }
 
 });
@@ -393,7 +393,7 @@ client.on('message', async (message) => {
 
 ### Repeat
 
-To repeat the current song, use the `client.player.setRepeatMode()` function.  
+To repeat the current track, use the `client.player.setRepeatMode()` function.  
 
 **Usage:**
 
@@ -412,17 +412,17 @@ client.on('message', async (message) => {
     if(command === 'enable-repeat'){
         // Enable repeat mode
         client.player.setRepeatMode(message.guild.id, true);
-        // Get the current song
-        let song = await client.player.nowPlaying(message.guild.id);
-        message.channel.send(`${song.name} will be repeated indefinitely!`);
+        // Get the current track
+        let track = await client.player.nowPlaying(message.guild.id);
+        message.channel.send(`${track.name} will be repeated indefinitely!`);
     }
 
     if(command === 'disable-repeat'){
         // Disable repeat mode
         client.player.setRepeatMode(message.guild.id, false);
-        // Get the current song
-        let song = await client.player.nowPlaying(message.guild.id);
-        message.channel.send(`${song.name}  will no longer be repeated indefinitely!`);
+        // Get the current track
+        let track = await client.player.nowPlaying(message.guild.id);
+        message.channel.send(`${track.name}  will no longer be repeated indefinitely!`);
     }
 
 });
@@ -430,12 +430,12 @@ client.on('message', async (message) => {
 
 ### Remove
 
-To remove a song from the queue, use the `client.player.remove()` function.
+To remove a track from the queue, use the `client.player.remove()` function.
 
 **Usage:**
 
 ```js
-client.player.remove(guildID, song);
+client.player.remove(guildID, track);
 ```
 
 **Example:**
@@ -447,9 +447,9 @@ client.on('message', async (message) => {
     const command = args.shift().toLowerCase();
 
     if(command === 'remove'){
-        // Removes a song from the queue
+        // Removes a track from the queue
         client.player.remove(message.guild.id, args[0]).then(() => {
-            message.channel.send('Removed song!');
+            message.channel.send('Removed track!');
         });
     }
 });
@@ -457,7 +457,7 @@ client.on('message', async (message) => {
 
 ## Info Messages
 
-You can send a message when the queue ends or when the song changes:
+You can send a message when the queue ends or when the track changes:
 
 ```js
 client.on('message', (message) => {
@@ -466,15 +466,15 @@ client.on('message', (message) => {
     const command = args.shift().toLowerCase();
 
     if(command === 'play'){
-        let song = await client.player.play(message.member.voice.channel, args[0]);
-        song.queue.on('end', () => {
-            message.channel.send('The queue is empty, please add new songs!');
+        let track = await client.player.play(message.member.voice.channel, args[0]);
+        track.queue.on('end', () => {
+            message.channel.send('The queue is empty, please add new tracks!');
         });
-        song.queue.on('songChanged', (oldSong, newSong, skipped, repeatMode) => {
+        track.queue.on('trackChanged', (oldTrack, newTrack, skipped, repeatMode) => {
             if(repeatMode){
-                message.channel.send(`Playing ${newSong} again...`);
+                message.channel.send(`Playing ${newTrack} again...`);
             } else {
-                message.channel.send(`Now playing ${newSong}...`);
+                message.channel.send(`Now playing ${newTrack}...`);
             }
         });
     }
@@ -492,12 +492,12 @@ client.on('message', (message) => {
     const command = args.shift().toLowerCase();
 
     // Error 1:
-    // Song not found
+    // Track not found
     if(command === 'play'){
-        client.player.play(message.member.voice.channel, args[0]).then((song) => {
-            message.channel.send(`Currently playing ${song.name}!`);
+        client.player.play(message.member.voice.channel, args[0]).then((track) => {
+            message.channel.send(`Currently playing ${track.name}!`);
         }).catch(() => {
-            message.channel.send(`No song found for ${args[0]}`);
+            message.channel.send(`No track found for ${args[0]}`);
         });
     }
 
@@ -505,7 +505,7 @@ client.on('message', (message) => {
     // Not playing
     if(command === 'queue'){
         let playing = client.player.isPlaying(message.guild.id);
-        if(!playing) return message.channel.send(':x: No songs currently playing!');
+        if(!playing) return message.channel.send(':x: No tracks currently playing!');
         // you are sure it works:
         client.player.getQueue(message.guild.id);
     }

From 73001169cd3d6a2c918cbbf6dc58e9ad8628845a Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 15:36:16 +0200
Subject: [PATCH 03/50] :recycle: Rewrite everything with eslint and
 discord-ytdl-core

---
 .eslintrc.js  |  22 +++
 package.json  |  12 +-
 src/Player.js | 470 +++++++++++++++++++++++++++++---------------------
 src/Queue.js  |  38 ++--
 src/Track.js  |  80 +++++----
 src/Util.js   |  63 -------
 6 files changed, 370 insertions(+), 315 deletions(-)
 create mode 100644 .eslintrc.js
 delete mode 100644 src/Util.js

diff --git a/.eslintrc.js b/.eslintrc.js
new file mode 100644
index 0000000..43b6d49
--- /dev/null
+++ b/.eslintrc.js
@@ -0,0 +1,22 @@
+module.exports = {
+    env: {
+        commonjs: true,
+        es6: true,
+        node: true
+    },
+    extends: [
+        'standard'
+    ],
+    globals: {
+        Atomics: 'readonly',
+        SharedArrayBuffer: 'readonly'
+    },
+    parserOptions: {
+        ecmaVersion: 11
+    },
+    rules: {
+        indent: ['error', 4],
+        'no-async-promise-executor': 'off',
+        'no-unused-vars': 'off'
+    }
+}
diff --git a/package.json b/package.json
index 5f7085c..9d0bc7f 100644
--- a/package.json
+++ b/package.json
@@ -28,13 +28,21 @@
   },
   "homepage": "https://github.com/Androz2091/discord-player#readme",
   "dependencies": {
-    "ffmpeg-static": "^4.1.1",
+    "@discordjs/opus": "^0.3.2",
+    "discord-ytdl-core": "^4.0.0",
     "merge-options": "^2.0.0",
+    "node-fetch": "^2.6.0",
     "simple-youtube-api": "^5.2.1",
-    "ytdl-core": "^3.0.0"
+    "ytsr": "^0.1.15"
   },
   "devDependencies": {
     "discord.js": "discordjs/discord.js",
+    "eslint": "^7.1.0",
+    "eslint-config-standard": "^14.1.1",
+    "eslint-plugin-import": "^2.20.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-standard": "^4.0.1",
     "jsdoc": "^3.6.3",
     "minami": "Androz2091/minami"
   }
diff --git a/src/Player.js b/src/Player.js
index 8098a79..7e97a99 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -1,10 +1,24 @@
-const ytdl = require('ytdl-core');
-const SimpleYouTubeAPI = require('simple-youtube-api');
-const Discord = require('discord.js');
+const ytdl = require('discord-ytdl-core')
+const Discord = require('discord.js')
+const ytsr = require('ytsr')
 
-const Queue = require('./Queue');
-const Track = require('./Track');
-const Util = require('./Util');
+const Queue = require('./Queue')
+const Track = require('./Track')
+
+const filters = {
+    bassboost: 'bass=g=20,dynaudnorm=f=200',
+    '8D': 'apulsator=hz=0.128',
+    vaporwave: 'asetrate=441000*.8,aresample=44100,atempo=1.1',
+    nightcore: 'asetrate=441001*.25',
+    phaser: 'aphaser=in_gain=0.4',
+    tremolo: 'tremolo=f=6.5',
+    reverse: 'areverse',
+    treble: 'treble=g={GAIN}',
+    normalizer: 'dynaudnorm=f=150',
+    surrounding: 'surround',
+    pulsator: 'apulsator=hz=1',
+    subboost: 'asubboost'
+}
 
 /**
  * @typedef PlayerOptions
@@ -22,55 +36,111 @@ const defaultPlayerOptions = {
     leaveOnEnd: true,
     leaveOnStop: true,
     leaveOnEmpty: true
-};
+}
 
 class Player {
-
     /**
      * @param {Discord.Client} client Discord.js client
-     * @param {string} youtubeToken Youtube Data v3 API Key
      * @param {PlayerOptions} options Player options
      */
-    constructor(client, youtubeToken, options = {}){
-        if(!client) throw new SyntaxError('Invalid Discord client');
-        if(!youtubeToken) throw new SyntaxError('Invalid Token: Token must be a String');
+    constructor (client, options = {}) {
+        if (!client) throw new SyntaxError('Invalid Discord client')
 
         /**
          * Discord.js client instance
          * @type {Discord.Client}
          */
-        this.client = client;
-        /**
-         * YouTube API Key
-         * @type {string}
-         */
-        this.youtubeToken = youtubeToken;
-        /**
-         * Simple YouTube API client instance
-         * @type {SimpleYouTubeAPI.YouTube}
-         */
-        this.youtube = new SimpleYouTubeAPI.YouTube(this.youtubeToken);
+        this.client = client
         /**
          * Player queues
          * @type {Queue[]}
          */
-        this.queues = [];
+        this.queues = []
         /**
          * Player options
          * @type {PlayerOptions}
          */
-        this.options = defaultPlayerOptions;
-        for(const prop in options){
-            this.options[prop] = options[prop];
+        this.options = defaultPlayerOptions
+        for (const prop in options) {
+            this.options[prop] = options[prop]
         }
-        /**
-         * Utilities methods for the player
-         * @type {Util}
-         */
-        this.util = new Util(this.youtube)
 
         // Listener to check if the channel is empty
-        client.on('voiceStateUpdate', (oldState, newState) => this._handleVoiceStateUpdate.call(this, oldState, newState));
+        client.on('voiceStateUpdate', (oldState, newState) => this._handleVoiceStateUpdate(oldState, newState))
+    }
+
+    _playYTDLStream (queue, updateFilter) {
+        return new Promise((resolve) => {
+            const currentStreamTime = updateFilter ? queue.voiceConnection.dispatcher.streamTime / 1000 : undefined
+            const encoderArgsFilters = []
+            Object.keys(queue.filters).forEach((filterName) => {
+                if (queue.filters[filterName]) {
+                    encoderArgsFilters.push(filters[filterName])
+                }
+            })
+            let encoderArgs
+            if (encoderArgsFilters.length < 1) {
+                encoderArgs = []
+            } else {
+                encoderArgs = ['-af', encoderArgsFilters.join(',')]
+            }
+            const newStream = ytdl(queue.playing.url, {
+                filter: 'audioonly',
+                opusEncoded: true,
+                encoderArgs,
+                seek: currentStreamTime
+            })
+            setTimeout(() => {
+                queue.voiceConnection.play(newStream, {
+                    type: 'opus'
+                })
+                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200)
+                // When the track starts
+                queue.voiceConnection.dispatcher.on('start', () => {
+                    resolve()
+                })
+                // When the track ends
+                queue.voiceConnection.dispatcher.on('finish', () => {
+                    // Play the next track
+                    return this._playTrack(queue.guildID, false)
+                })
+            }, 1000)
+        })
+    }
+
+    /**
+     * Update the filters for the guild
+     * @param {Discord.Snowflake} guildID
+     * @param {Object} newFilters
+     */
+    updateFilters (guildID, newFilters) {
+        return new Promise((resolve, reject) => {
+            // Gets guild queue
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
+            Object.keys(newFilters).forEach((filterName) => {
+                queue.filters[filterName] = newFilters[filterName]
+            })
+            this._playYTDLStream(queue, true, false)
+        })
+    }
+
+    /**
+     * Searchs tracks on YouTube
+     * @param {string} query The query
+     * @returns {Promise<Track[]>}
+     */
+    searchTracks (query) {
+        return new Promise(async (resolve, reject) => {
+            if (query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)) {
+                query = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)[1]
+            }
+            ytsr(query, (err, results) => {
+                if (err) return []
+                const resultsVideo = results.items.filter((i) => i.type === 'video')
+                resolve(resultsVideo.map((r) => new Track(r, null, null)))
+            })
+        })
     }
 
     /**
@@ -78,8 +148,8 @@ class Player {
      * @param {Discord.Snowflake} guildID The guild ID to check
      * @returns {boolean} Whether the guild is currently playing tracks
      */
-    isPlaying(guildID) {
-        return this.queues.some((g) => g.guildID === guildID);
+    isPlaying (guildID) {
+        return this.queues.some((g) => g.guildID === guildID)
     }
 
     /**
@@ -89,30 +159,34 @@ class Player {
      * @param {Discord.User?} user The user who requested the track
      * @returns {Promise<Track>} The played track
      */
-    play(voiceChannel, track, user) {
-        this.queues = this.queues.filter((g) => g.guildID !== voiceChannel.id);
+    play (voiceChannel, track, user) {
+        this.queues = this.queues.filter((g) => g.guildID !== voiceChannel.id)
         return new Promise(async (resolve, reject) => {
-            if(!voiceChannel || typeof voiceChannel !== "object"){
-                return reject(`voiceChannel must be type of VoiceChannel. value=${voiceChannel}`);
+            if (!voiceChannel || typeof voiceChannel !== 'object') {
+                return reject(new Error(`voiceChannel must be type of VoiceChannel. value=${voiceChannel}`))
             }
-            const connection = voiceChannel.client.voice.connections.find((c) => c.channel.id === voiceChannel.id) || await voiceChannel.join();
-            if(typeof track !== "object"){
-                const results = await this.util.search(track, user);
-                track = results[0];
+            const connection = voiceChannel.client.voice.connections.find((c) => c.channel.id === voiceChannel.id) || await voiceChannel.join()
+            if (typeof track !== 'object') {
+                const results = await this.searchTracks(track)
+                track = results[0]
             }
             // Create a new guild with data
-            let queue = new Queue(voiceChannel.guild.id);
-            queue.voiceConnection = connection;
+            const queue = new Queue(voiceChannel.guild.id)
+            queue.voiceConnection = connection
+            queue.filters = {}
+            Object.keys(filters).forEach((f) => {
+                queue.filters[f] = false
+            })
             // Add the track to the queue
-            track.requestedBy = user;
-            queue.tracks.push(track);
+            track.requestedBy = user
+            queue.tracks.push(track)
             // Add the queue to the list
-            this.queues.push(queue);
+            this.queues.push(queue)
             // Play the track
-            this._playTrack(queue.guildID, true);
+            this._playTrack(queue.guildID, true)
             // Resolve the track
-            resolve(track);
-        });
+            resolve(track)
+        })
     }
 
     /**
@@ -121,16 +195,16 @@ class Player {
      * @returns {Promise<Track>} The paused track
      */
     pause (guildID) {
-        return new Promise(async(resolve, reject) => {
+        return new Promise((resolve, reject) => {
             // Gets guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Pauses the dispatcher
-            queue.voiceConnection.dispatcher.pause();
-            queue.playing = false;
+            queue.voiceConnection.dispatcher.pause()
+            queue.paused = true
             // Resolves the guild queue
-            resolve(queue.tracks[0]);
-        });
+            resolve(queue.tracks[0])
+        })
     }
 
     /**
@@ -139,16 +213,16 @@ class Player {
      * @returns {Promise<Track>} The resumed track
      */
     resume (guildID) {
-        return new Promise(async(resolve, reject) => {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Pause the dispatcher
-            queue.voiceConnection.dispatcher.resume();
-            queue.playing = true;
+            queue.voiceConnection.dispatcher.resume()
+            queue.paused = false
             // Resolve the guild queue
-            resolve(queue.tracks[0]);
-        });
+            resolve(queue.tracks[0])
+        })
     }
 
     /**
@@ -156,37 +230,37 @@ class Player {
      * @param {Discord.Snowflake} guildID The ID of the guild where the music should be stopped
      * @returns {Promise<void>}
      */
-    stop(guildID){
-        return new Promise(async(resolve, reject) => {
+    stop (guildID) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Stop the dispatcher
-            queue.stopped = true;
-            queue.tracks = [];
-            queue.voiceConnection.dispatcher.end();
+            queue.stopped = true
+            queue.tracks = []
+            queue.voiceConnection.dispatcher.end()
             // Resolve
-            resolve();
-        });
+            resolve()
+        })
     }
 
     /**
      * Update the volume
-     * @param {Discord.Snowflake} guildID The ID of the guild where the music should be modified 
+     * @param {Discord.Snowflake} guildID The ID of the guild where the music should be modified
      * @param {number} percent The new volume (0-100)
      * @returns {Promise<void>}
      */
-    setVolume(guildID, percent) {
-        return new Promise(async(resolve, reject) => {
-            // Gets guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+    setVolume (guildID, percent) {
+        return new Promise((resolve, reject) => {
+            // Get guild queue
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Updates volume
-            queue.voiceConnection.dispatcher.setVolumeLogarithmic(percent / 200);
-            queue.volume = percent;
+            queue.voiceConnection.dispatcher.setVolumeLogarithmic(percent / 200)
+            queue.volume = percent
             // Resolves guild queue
-            resolve();
-        });
+            resolve()
+        })
     }
 
     /**
@@ -194,10 +268,10 @@ class Player {
      * @param {Discord.Snowflake} guildID
      * @returns {?Queue}
      */
-    getQueue(guildID) {
+    getQueue (guildID) {
         // Gets guild queue
-        let queue = this.queues.find((g) => g.guildID === guildID);
-        return queue;
+        const queue = this.queues.find((g) => g.guildID === guildID)
+        return queue
     }
 
     /**
@@ -207,19 +281,23 @@ class Player {
      * @param {Discord.User?} requestedBy The user who requested the track
      * @returns {Promise<Track>} The added track
      */
-    addToQueue(guildID, trackName, requestedBy){
-        return new Promise(async(resolve, reject) => {
+    addToQueue (guildID, trackName, requestedBy) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Search the track
-            let track = await this.util.search(trackName, requestedBy).catch(() => {});
-            if(!track[0]) return reject('Track not found');
-            // Update queue
-            queue.tracks.push(track[0]);
-            // Resolve the track
-            resolve(track[0]);
-        });
+            this.search(trackName).then((track) => {
+                if (!track[0]) return reject(new Error('Track not found'))
+                track[0].requestedBy = requestedBy
+                // Update queue
+                queue.tracks.push(track[0])
+                // Resolve the track
+                resolve(track[0])
+            }).catch(() => {
+                return reject(new Error('Track not found'))
+            })
+        })
     }
 
     /**
@@ -228,16 +306,16 @@ class Player {
      * @param {Track[]} tracks The tracks list
      * @returns {Promise<Queue>} The new queue
      */
-    setQueue(guildID, tracks){
-        return new Promise(async(resolve, reject) => {
+    setQueue (guildID, tracks) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Update queue
-            queue.tracks = tracks;
+            queue.tracks = tracks
             // Resolve the queue
-            resolve(queue);
-        });
+            resolve(queue)
+        })
     }
 
     /**
@@ -245,17 +323,17 @@ class Player {
      * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be cleared
      * @returns {Promise<Queue>} The updated queue
      */
-    clearQueue(guildID){
-        return new Promise(async(resolve, reject) => {
+    clearQueue (guildID) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Clear queue
-            let currentlyPlaying = queue.tracks.shift();
-            queue.tracks = [ currentlyPlaying ];
+            const currentlyPlaying = queue.tracks.shift()
+            queue.tracks = [currentlyPlaying]
             // Resolve guild queue
-            resolve(queue);
-        });
+            resolve(queue)
+        })
     }
 
     /**
@@ -263,18 +341,18 @@ class Player {
      * @param {Discord.Snowflake} guildID The ID of the guild where the track should be skipped
      * @returns {Promise<Track>}
      */
-    skip(guildID){
-        return new Promise(async(resolve, reject) => {
+    skip (guildID) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
-            let currentTrack = queue.tracks[0];
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
+            const currentTrack = queue.tracks[0]
             // End the dispatcher
-            queue.voiceConnection.dispatcher.end();
-            queue.lastSkipped = true;
+            queue.voiceConnection.dispatcher.end()
+            queue.lastSkipped = true
             // Resolve the current track
-            resolve(currentTrack);
-        });
+            resolve(currentTrack)
+        })
     }
 
     /**
@@ -282,15 +360,15 @@ class Player {
      * @param {Discord.Snowflake} guildID
      * @returns {Promise<Track>} The track which is currently played
      */
-    nowPlaying(guildID){
-        return new Promise(async(resolve, reject) => {
+    nowPlaying (guildID) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
-            let currentTrack = queue.tracks[0];
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
+            const currentTrack = queue.tracks[0]
             // Resolve the current track
-            resolve(currentTrack);
-        });
+            resolve(currentTrack)
+        })
     }
 
     /**
@@ -299,16 +377,16 @@ class Player {
      * @param {Boolean} enabled Whether the repeat mode should be enabled
      * @returns {Promise<Void>}
      */
-    setRepeatMode(guildID, enabled) {
-        return new Promise(async(resolve, reject) => {
+    setRepeatMode (guildID, enabled) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Enable/Disable repeat mode
-            queue.repeatMode = enabled;
+            queue.repeatMode = enabled
             // Resolve
-            resolve();
-        });
+            resolve()
+        })
     }
 
     /**
@@ -316,18 +394,18 @@ class Player {
      * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be shuffled
      * @returns {Promise<Queue>} The updated queue
      */
-    shuffle(guildID){
-        return new Promise(async(resolve, reject) => {
+    shuffle (guildID) {
+        return new Promise((resolve, reject) => {
             // Get guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Shuffle the queue (except the first track)
-            let currentTrack = queue.tracks.shift();
-            queue.tracks = queue.tracks.sort(() => Math.random() - 0.5);
-            queue.tracks.unshift(currentTrack);
+            const currentTrack = queue.tracks.shift()
+            queue.tracks = queue.tracks.sort(() => Math.random() - 0.5)
+            queue.tracks.unshift(currentTrack)
             // Resolve
-            resolve(queue);
-        });
+            resolve(queue)
+        })
     }
 
     /**
@@ -336,27 +414,27 @@ class Player {
      * @param {number|Track} track The index of the track to remove or the track to remove object
      * @returns {Promise<Track|null>}
      */
-    remove(guildID, track){
-        return new Promise(async(resolve, reject) => {
+    remove (guildID, track) {
+        return new Promise((resolve, reject) => {
             // Gets guild queue
-            let queue = this.queues.find((g) => g.guildID === guildID);
-            if(!queue) return reject('Not playing');
+            const queue = this.queues.find((g) => g.guildID === guildID)
+            if (!queue) return reject(new Error('Not playing'))
             // Remove the track from the queue
-            let trackFound = null;
-            if(typeof track === "number"){
-                trackFound = queue.tracks[track];
-                if(trackFound){
-                    queue.tracks = queue.tracks.filter((s) => s !== trackFound);
+            let trackFound = null
+            if (typeof track === 'number') {
+                trackFound = queue.tracks[track]
+                if (trackFound) {
+                    queue.tracks = queue.tracks.filter((t) => t !== trackFound)
                 }
             } else {
-                trackFound = queue.tracks.find((s) => s === track);
-                if(trackFound){
-                    queue.tracks = queue.tracks.filter((s) => s !== trackFound);
+                trackFound = queue.tracks.find((s) => s === track)
+                if (trackFound) {
+                    queue.tracks = queue.tracks.filter((s) => s !== trackFound)
                 }
             }
             // Resolve
-            resolve(trackFound);
-        });
+            resolve(trackFound)
+        })
     }
 
     /**
@@ -366,21 +444,21 @@ class Player {
      * @param {Discord.VoiceState} oldState
      * @param {Discord.VoiceState} newState
      */
-    _handleVoiceStateUpdate(oldState, newState) {
-        if(!this.options.leaveOnEmpty) return;
+    _handleVoiceStateUpdate (oldState, newState) {
+        if (!this.options.leaveOnEmpty) return
         // If the member leaves a voice channel
-        if(!oldState.channelID || newState.channelID) return;
+        if (!oldState.channelID || newState.channelID) return
         // Search for a queue for this channel
-        let queue = this.queues.find((g) => g.voiceConnection.channel.id === oldState.channelID);
-        if(queue){
+        const queue = this.queues.find((g) => g.voiceConnection.channel.id === oldState.channelID)
+        if (queue) {
             // If the channel is not empty
-            if(queue.voiceConnection.channel.members.size > 1) return;
+            if (queue.voiceConnection.channel.members.size > 1) return
             // Disconnect from the voice channel
-            queue.voiceConnection.channel.leave();
+            queue.voiceConnection.channel.leave()
             // Delete the queue
-            this.queues = this.queues.filter((g) => g.guildID !== queue.guildID);
+            this.queues = this.queues.filter((g) => g.guildID !== queue.guildID)
             // Emit end event
-            queue.emit('channelEmpty');
+            queue.emit('channelEmpty')
         }
     }
 
@@ -391,40 +469,34 @@ class Player {
      * @param {Discord.Snowflake} guildID
      * @param {Boolean} firstPlay Whether the function was called from the play() one
      */
-    async _playTrack(guildID, firstPlay) {
-        // Gets guild queue
-        let queue = this.queues.find((g) => g.guildID === guildID);
+    async _playTrack (guildID, firstPlay) {
+        // Get guild queue
+        const queue = this.queues.find((g) => g.guildID === guildID)
         // If there isn't any music in the queue
-        if(queue.tracks.length < 2 && !firstPlay && !queue.repeatMode){
-            // Leaves the voice channel
-            if(this.options.leaveOnEnd && !queue.stopped) queue.voiceConnection.channel.leave();
-            // Remoces the guild from the guilds list
-            this.queues = this.queues.filter((g) => g.guildID !== guildID);
-            // Emits stop event
-            if(queue.stopped){
-                if(this.options.leaveOnStop) queue.voiceConnection.channel.leave();
-                return queue.emit('stop');
+        if (queue.tracks.length < 2 && !firstPlay && !queue.repeatMode) {
+            // Leave the voice channel
+            if (this.options.leaveOnEnd && !queue.stopped) queue.voiceConnection.channel.leave()
+            // Remove the guild from the guilds list
+            this.queues = this.queues.filter((g) => g.guildID !== guildID)
+            // Emit stop event
+            if (queue.stopped) {
+                if (this.options.leaveOnStop) queue.voiceConnection.channel.leave()
+                return queue.emit('stop')
             }
-            // Emits end event 
-            return queue.emit('end');
+            // Emit end event
+            return queue.emit('end')
         }
-        // Emit trackChanged event
-        if(!firstPlay) queue.emit('trackChanged', (!queue.repeatMode ? queue.tracks.shift() : queue.tracks[0]), queue.tracks[0], queue.lastSkipped, queue.repeatMode);
-        queue.lastSkipped = false;
-        let track = queue.tracks[0];
-        // Download the track
-        queue.voiceConnection.play(ytdl(track.url, {
-            filter: "audioonly"
-        }));
-        // Set volume
-        queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200);
-        // When the track ends
-        queue.voiceConnection.dispatcher.on('finish', () => {
-            // Play the next track
-            return this._playTrack(guildID, false);
-        });
+        const wasPlaying = queue.playing
+        const nowPlaying = queue.playing = queue.repeatMode ? wasPlaying : queue.tracks.shift()
+        // Reset lastSkipped state
+        queue.lastSkipped = false
+        this._playYTDLStream(queue, false).then(() => {
+            // Emit trackChanged event
+            if (!firstPlay) {
+                queue.emit('trackChanged', nowPlaying, wasPlaying, queue.lastSkipped, queue.repeatMode)
+            }
+        })
     }
-
 };
 
-module.exports = Player;
\ No newline at end of file
+module.exports = Player
diff --git a/src/Queue.js b/src/Queue.js
index e42c727..0637842 100644
--- a/src/Queue.js
+++ b/src/Queue.js
@@ -6,57 +6,65 @@ const Track = require('./Track')
  * Represents a guild queue.
  */
 class Queue extends EventEmitter {
-
     /**
      * @param {Discord.Snowflake} guildID ID of the guild this queue is for.
      */
-    constructor(guildID){
-        super();
+    constructor (guildID) {
+        super()
         /**
          * ID of the guild this queue is for.
          * @type {Discord.Snowflake}
          */
-        this.guildID = guildID;
+        this.guildID = guildID
         /**
          * The voice connection of this queue.
          * @type {Discord.VoiceConnection}
          */
-        this.voiceConnection = null;
+        this.voiceConnection = null
+        /**
+         * The song currently played.
+         * @type {Track}
+         */
+        this.playing = null
         /**
          * The tracks of this queue. The first one is currenlty playing and the others are going to be played.
          * @type {Track[]}
          */
-        this.tracks = [];
+        this.tracks = []
         /**
          * Whether the stream is currently stopped.
          * @type {boolean}
          */
-        this.stopped = false;
+        this.stopped = false
         /**
          * Whether the last track was skipped.
          * @type {boolean}
          */
-        this.lastSkipped = false;
+        this.lastSkipped = false
         /**
          * The stream volume of this queue. (0-100)
          * @type {number}
          */
-        this.volume = 100;
+        this.volume = 100
         /**
-         * Whether the stream is currently playing.
+         * Whether the stream is currently paused.
          * @type {boolean}
          */
-        this.playing = true;
+        this.paused = true
         /**
          * Whether the repeat mode is enabled.
          * @type {boolean}
          */
-        this.repeatMode = false;
+        this.repeatMode = false
+        /**
+         * Filters status
+         * @type {Object}
+         */
+        this.filters = {}
     }
+}
 
-};
-
-module.exports = Queue;
+module.exports = Queue
 
 /**
  * Emitted when the queue is empty.
diff --git a/src/Track.js b/src/Track.js
index b3f0133..3dd6efa 100644
--- a/src/Track.js
+++ b/src/Track.js
@@ -1,71 +1,79 @@
 const Discord = require('discord.js')
 const Queue = require('./Queue')
-const SimpleYouTubeAPI = require('simple-youtube-api')
 
 /**
  * Represents a track.
  */
 class Track {
-
     /**
-     * @param {SimpleYouTubeAPI.Video} video The video for this track
+     * @param {Object} videoData The video data for this track
      * @param {Discord.User?} user The user who requested the track
      * @param {Queue?} queue The queue in which is the track is
      */
-    constructor(video, user, queue) {
+    constructor (videoData, user, queue) {
         /**
          * The track name
          * @type {string}
          */
-        this.name = video.title;
-        /**
-         * The full video object
-         * @type {SimpleYouTubeAPI.Video}
-         */
-        this.data = video;
+        this.name = videoData.title
         /**
          * The Youtube URL of the track
          * @type {string}
          */
-        this.url = `https://www.youtube.com/watch?v=${video.id}`;
+        this.url = videoData.link
+        /**
+         * The video duration (formatted).
+         * @type {string}
+         */
+        this.duration = videoData.duration
+        /**
+         * The video description
+         * @type {string}
+         */
+        this.description = videoData.description
+        /**
+         * The video thumbnail
+         * @type {string}
+         */
+        this.thumbnail = videoData.thumbnail
+        /**
+         * The video views
+         */
+        this.views = videoData.views
+        /**
+         * The video channel
+         * @type {string}
+         */
+        this.author = videoData.author.name
         /**
          * The user who requested the track
          * @type {Discord.User?}
          */
-        this.requestedBy = user;
+        this.requestedBy = user
         /**
          * The queue in which the track is
          * @type {Queue}
          */
-        this.queue = queue;
-    }
-
-    /**
-     * The name of the channel which is the author of the video on Youtube
-     * @type {string}
-     */
-    get author() {
-        return this.data.raw.snippet.channelTitle;
-    }
-
-    /**
-     * The Youtube video thumbnail
-     * @type {string}
-     */
-    get thumbnail() {
-        return this.data.raw.snippet.thumbnails.default.url;
+        this.queue = queue
     }
 
     /**
      * The track duration
      * @type {number}
      */
-    get duration() {
-        return typeof this.data.duration === "object"
-            ? ((this.data.duration.hours*3600)+(this.data.duration.minutes*60)+(this.data.duration.seconds)) * 1000
-            : parseInt(this.data.duration)
+    get durationMS () {
+        const args = this.duration.split(':')
+        if (args.length === 3) {
+            return  parseInt(args[0]) * 60 * 60 * 1000
+                    + parseInt(args[1]) * 60 * 1000
+                    + parseInt(args[2]) * 1000
+        } else if(args.length === 2) {
+            return  parseInt(args[0]) * 60 * 1000
+                    + parseInt(args[1]) * 1000
+        } else {
+            return  parseInt(args[0]) * 1000
+        }
     }
+}
 
-};
-
-module.exports = Track;
+module.exports = Track
diff --git a/src/Util.js b/src/Util.js
deleted file mode 100644
index 0a92906..0000000
--- a/src/Util.js
+++ /dev/null
@@ -1,63 +0,0 @@
-const fetch = require('node-fetch')
-const Discord = require('discord.js')
-const Track = require('./Track')
-const SimpleYouTubeAPI = require('simple-youtube-api')
-
-/**
- * Utilities
- */
-class Util {
-
-    /**
-     * @param {SimpleYouTubeAPI.YouTube} youtube The SimpleYouTubeAPI client instance
-     */
-    constructor(youtube){
-        /**
-         * The SimpleYouTubeAPI client instance
-         * @type {SimpleYouTubeAPI.YouTube}
-         */
-        this.youtube = youtube;
-    }
-
-    /**
-     * Get the first youtube results for your search
-     * @param {string} query The name of the video or the video URL
-     * @param {Discord.User?} user The user who requested the track
-     * @returns {Promise<Track[]>}
-     */
-    search(query, user) {
-        return new Promise(async (resolve, reject) => {
-            query = query.replace(/<(.+)>/g, "$1");
-            try {
-                const videoData = SimpleYouTubeAPI.parseURL(query);
-                if(videoData.video){
-                    const video = await this.youtube.getVideoById(videoData.video);
-                    if(video){
-                        await video.fetch();
-                        const track = new Track(video, user, null);
-                        return resolve([ track ]);
-                    }
-                }
-                const results = await this.youtube.searchVideos(query, 1);
-                const tracks = [];
-                for(let result of (results.filter((r) => r.type === "video"))){
-                    // @ts-ignore
-                    await result.fetch();
-                    // @ts-ignore
-                    const track = new Track(result, user, null);
-                    tracks.push(track);
-                }
-                return resolve(tracks);
-            } catch(e) {
-                if(e.message && e.message === "Bad Request"){
-                    reject("Looks like your YouTube Data v3 API key is not valid...");
-                } else {
-                    reject(e);
-                }
-            }
-        });
-    }
-
-};
-
-module.exports = Util;

From 737687e1374e4dcc635a860a36d0fbf58234ab1a Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 15:47:37 +0200
Subject: [PATCH 04/50] :pencil: Update README

---
 README.md | 69 +++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 64 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index a39714e..3f80463 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@
 
 **Note**: this module uses recent discordjs features and requires discord.js version 12.
 
-Discord Player is a powerful [Node.js](https://nodejs.org) module that allows you to easily implement music commands. **Everything** is customizable, and everything is done to simplify your work **without limiting you**!
+Discord Player is a powerful [Node.js](https://nodejs.org) module that allows you to easily implement music commands. **Everything** is customizable, and everything is done to simplify your work **without limiting you**! It doesn't require any api key, as it uses **scraping**.
 
 ## Installation
 
@@ -14,10 +14,10 @@ Discord Player is a powerful [Node.js](https://nodejs.org) module that allows yo
 npm install --save discord-player
 ```
 
-Install **opusscript** or **@discordjs/opus**:
+Install **@discordjs/opus**:
 
 ```sh
-npm install --save opusscript
+npm install --save @discordjs/opus
 ```
 
 Install [FFMPEG](https://www.ffmpeg.org/download.html) and you're done!
@@ -33,8 +33,8 @@ settings = {
 };
 
 const { Player } = require("discord-player");
-// Create a new Player (Youtube API key is your Youtube Data v3 key)
-const player = new Player(client, "YOUTUBE API KEY");
+// Create a new Player (you don't need any API Key)
+const player = new Player(client);
 // To easily access the player
 client.player = player;
 
@@ -69,6 +69,11 @@ client.player.skip(guildID);
 // Remove a track from the queue using the index number
 client.player.remove(guildID, track);
 
+// Filters!
+client.player.updateFilters(guildID, {
+    bassboost: true,
+    vaporwave: true
+})
 
 // Pause
 client.player.pause(guildID);
@@ -92,6 +97,10 @@ client.player.setRepeatMode(guildID, false);
 ### Event messages
 
 ```js
+// Play the music
+await client.player.play(message.member.voice.channel, "Despacito")
+
+// Then add some messages that will be sent when the events will be triggered
 client.player.getQueue(guildID)
 .on('end', () => {
     message.channel.send('There is no more music in the queue!');
@@ -455,6 +464,56 @@ client.on('message', async (message) => {
 });
 ```
 
+### Filters
+
+You can apply some cool filters to your music!
+
+**Usage:**
+
+```js
+client.player.updateFilters(guildID, {
+    bassboost: true,
+    '8D': true,
+    vaporwave: true,
+    nightcore: true,
+    phaser: true,
+    tremolo: true,
+    reverse: true,
+    treble: true,
+    normalizer: true,
+    surrounding: true
+    pulsator: true,
+    subboost: true
+});
+```
+
+**Example:**
+
+```js
+client.on('message', async (message) => {
+
+    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+    const command = args.shift().toLowerCase();
+
+    if(command === 'bassboost'){
+        const bassboostEnabled = client.player.getQueue(message.guild.id);
+        if(!bassboostEnabled){
+            client.player.updateFilters(message.guild.id, {
+                bassboost: true
+            });
+            message.channel.send("Bassboost effect has been enabled!");
+        } else {
+            client.player.updateFilters(message.guild.id, {
+                bassboost: false
+            });
+            message.channel.send("Bassboost effect has been disabled!");
+        }
+    }
+
+    // You can do the same for each filter!
+});
+```
+
 ## Info Messages
 
 You can send a message when the queue ends or when the track changes:

From 08a8d0ff20e36373d6d11fafc478c19d1273e594 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:17:00 +0200
Subject: [PATCH 05/50] :art: Move _playYTDLStream function

---
 src/Player.js | 86 ++++++++++++++++++++++++++++-----------------------
 1 file changed, 47 insertions(+), 39 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 7e97a99..5dc3d79 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -69,45 +69,6 @@ class Player {
         client.on('voiceStateUpdate', (oldState, newState) => this._handleVoiceStateUpdate(oldState, newState))
     }
 
-    _playYTDLStream (queue, updateFilter) {
-        return new Promise((resolve) => {
-            const currentStreamTime = updateFilter ? queue.voiceConnection.dispatcher.streamTime / 1000 : undefined
-            const encoderArgsFilters = []
-            Object.keys(queue.filters).forEach((filterName) => {
-                if (queue.filters[filterName]) {
-                    encoderArgsFilters.push(filters[filterName])
-                }
-            })
-            let encoderArgs
-            if (encoderArgsFilters.length < 1) {
-                encoderArgs = []
-            } else {
-                encoderArgs = ['-af', encoderArgsFilters.join(',')]
-            }
-            const newStream = ytdl(queue.playing.url, {
-                filter: 'audioonly',
-                opusEncoded: true,
-                encoderArgs,
-                seek: currentStreamTime
-            })
-            setTimeout(() => {
-                queue.voiceConnection.play(newStream, {
-                    type: 'opus'
-                })
-                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200)
-                // When the track starts
-                queue.voiceConnection.dispatcher.on('start', () => {
-                    resolve()
-                })
-                // When the track ends
-                queue.voiceConnection.dispatcher.on('finish', () => {
-                    // Play the next track
-                    return this._playTrack(queue.guildID, false)
-                })
-            }, 1000)
-        })
-    }
-
     /**
      * Update the filters for the guild
      * @param {Discord.Snowflake} guildID
@@ -462,6 +423,53 @@ class Player {
         }
     }
 
+    /**
+     * Play a stream in a channel
+     * @ignore
+     * @private
+     * @param {Queue} queue The queue to play
+     * @param {*} updateFilter Whether this method is called to update some ffmpeg filters
+     * @returns {Promise<void>}
+     */
+    _playYTDLStream (queue, updateFilter) {
+        return new Promise((resolve) => {
+            const currentStreamTime = updateFilter ? queue.voiceConnection.dispatcher.streamTime / 1000 : undefined
+            const encoderArgsFilters = []
+            Object.keys(queue.filters).forEach((filterName) => {
+                if (queue.filters[filterName]) {
+                    encoderArgsFilters.push(filters[filterName])
+                }
+            })
+            let encoderArgs
+            if (encoderArgsFilters.length < 1) {
+                encoderArgs = []
+            } else {
+                encoderArgs = ['-af', encoderArgsFilters.join(',')]
+            }
+            const newStream = ytdl(queue.playing.url, {
+                filter: 'audioonly',
+                opusEncoded: true,
+                encoderArgs,
+                seek: currentStreamTime
+            })
+            setTimeout(() => {
+                queue.voiceConnection.play(newStream, {
+                    type: 'opus'
+                })
+                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200)
+                // When the track starts
+                queue.voiceConnection.dispatcher.on('start', () => {
+                    resolve()
+                })
+                // When the track ends
+                queue.voiceConnection.dispatcher.on('finish', () => {
+                    // Play the next track
+                    return this._playTrack(queue.guildID, false)
+                })
+            }, 1000)
+        })
+    }
+
     /**
      * Start playing a track in a guild
      * @ignore

From 8243539f3f6c3ebbbd1e8587a4170964ce5f0a31 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:17:24 +0200
Subject: [PATCH 06/50] :bug: Disable eslint for youtube regex

---
 src/Player.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 5dc3d79..0f67e17 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -93,8 +93,10 @@ class Player {
      */
     searchTracks (query) {
         return new Promise(async (resolve, reject) => {
-            if (query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)) {
-                query = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)[1]
+            // eslint-disable-next-line no-useless-escape
+            const matchURL = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)
+            if (matchURL) {
+                query = matchURL[1]
             }
             ytsr(query, (err, results) => {
                 if (err) return []

From bbfe529177bb664462ea497e58a297e49027c30d Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:17:36 +0200
Subject: [PATCH 07/50] :pencil: Add shuffle example

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 0f67e17..f9af26c 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -376,6 +376,19 @@ class Player {
      * @param {Discord.Snowflake} guildID The ID of the guild where the track should be removed
      * @param {number|Track} track The index of the track to remove or the track to remove object
      * @returns {Promise<Track|null>}
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *     const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *     const command = args.shift().toLowerCase();
+     *
+     *     if(command === 'remove'){
+     *         // Removes a track from the queue
+     *         client.player.remove(message.guild.id, args[0]).then(() => {
+     *              message.channel.send('Removed track!');
+     *         });
+     *      }
+     * });
      */
     remove (guildID, track) {
         return new Promise((resolve, reject) => {

From 872c335b5533c5f64741ad478009c40590e9f1cb Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:17:43 +0200
Subject: [PATCH 08/50] :art: Some eslint fixes

---
 src/Track.js | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/Track.js b/src/Track.js
index 3dd6efa..d357230 100644
--- a/src/Track.js
+++ b/src/Track.js
@@ -64,14 +64,14 @@ class Track {
     get durationMS () {
         const args = this.duration.split(':')
         if (args.length === 3) {
-            return  parseInt(args[0]) * 60 * 60 * 1000
-                    + parseInt(args[1]) * 60 * 1000
-                    + parseInt(args[2]) * 1000
-        } else if(args.length === 2) {
-            return  parseInt(args[0]) * 60 * 1000
-                    + parseInt(args[1]) * 1000
+            return parseInt(args[0]) * 60 * 60 * 1000 +
+            parseInt(args[1]) * 60 * 1000 +
+            parseInt(args[2]) * 1000
+        } else if (args.length === 2) {
+            return parseInt(args[0]) * 60 * 1000 +
+            parseInt(args[1]) * 1000
         } else {
-            return  parseInt(args[0]) * 1000
+            return parseInt(args[0]) * 1000
         }
     }
 }

From 9e329c8aa6a6ba7d2374fd8327db41820a985e65 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:19:14 +0200
Subject: [PATCH 09/50] :pencil: Add example for shuffle method

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index f9af26c..92dc9e3 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -356,6 +356,19 @@ class Player {
      * Shuffle the guild queue (except the first track)
      * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be shuffled
      * @returns {Promise<Queue>} The updated queue
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *     const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *     const command = args.shift().toLowerCase();
+     *
+     *     if(command === 'shuffle'){
+     *         // Shuffle the server queue
+     *         client.player.shuffle(message.guild.id).then(() => {
+     *              message.channel.send('Queue shuffled!');
+     *         });
+     *      }
+     * });
      */
     shuffle (guildID) {
         return new Promise((resolve, reject) => {

From fd5f312f5ff8aab13a44d60b1ebd3120409bae05 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:24:18 +0200
Subject: [PATCH 10/50] :pencil: Add example for setRepeatMode method

---
 src/Player.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 92dc9e3..6491fd9 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -339,6 +339,26 @@ class Player {
      * @param {Discord.Snowflake} guildID
      * @param {Boolean} enabled Whether the repeat mode should be enabled
      * @returns {Promise<Void>}
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *     const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *     const command = args.shift().toLowerCase();
+     *
+     *     if(command === 'repeat-mode'){
+     *         const repeatModeEnabled = client.player.getQueue(message.guild.id).repeatMode;
+     *         if(repeatModeEnabled){
+     *              // if the repeat mode is currently enabled, disable it
+     *              client.player.setRepeatMode(message.guild.id, false);
+     *              message.channel.send("Repeat mode disabled! The current song will no longer be played again and again...");
+     *         } else {
+     *              // if the repeat mode is currently disabled, enable it
+     *              client.player.setRepeatMode(message.guild.id, true);
+     *              message.channel.send("Repeat mode enabled! The current song will be played again and again until you run the command again!");
+     *         }
+     *     }
+     *
+     * });
      */
     setRepeatMode (guildID, enabled) {
         return new Promise((resolve, reject) => {

From a3b32d30c5502de4fe9c7193232290cfb3a422ef Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:26:36 +0200
Subject: [PATCH 11/50] :lipstick: Pad block with blank lines

---
 src/Player.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 6491fd9..0bbf577 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -342,6 +342,7 @@ class Player {
      *
      * @example
      * client.on('message', async (message) => {
+     *
      *     const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
      *     const command = args.shift().toLowerCase();
      *
@@ -379,6 +380,7 @@ class Player {
      *
      * @example
      * client.on('message', async (message) => {
+     *
      *     const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
      *     const command = args.shift().toLowerCase();
      *
@@ -388,6 +390,7 @@ class Player {
      *              message.channel.send('Queue shuffled!');
      *         });
      *      }
+     *
      * });
      */
     shuffle (guildID) {
@@ -412,6 +415,7 @@ class Player {
      *
      * @example
      * client.on('message', async (message) => {
+     *
      *     const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
      *     const command = args.shift().toLowerCase();
      *
@@ -421,6 +425,7 @@ class Player {
      *              message.channel.send('Removed track!');
      *         });
      *      }
+     *
      * });
      */
     remove (guildID, track) {

From 7fa041bb22879a96e3ce9ad0db3ab9a23888b283 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:26:55 +0200
Subject: [PATCH 12/50] :pencil: Add example for the nowPlaying method

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 0bbf577..7ca6956 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -322,6 +322,19 @@ class Player {
      * Get the currently playing track
      * @param {Discord.Snowflake} guildID
      * @returns {Promise<Track>} The track which is currently played
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'now-playing'){
+     *          let track = await client.player.nowPlaying(message.guild.id);
+     *          message.channel.send(`Currently playing ${track.name}...`);
+     *      }
+     *
+     * });
      */
     nowPlaying (guildID) {
         return new Promise((resolve, reject) => {

From 4e55e66b3d2cc82119c18af973b84be4ee84572a Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:28:04 +0200
Subject: [PATCH 13/50] :pencil: Add example for skip command

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 7ca6956..54150bf 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -303,6 +303,19 @@ class Player {
      * Skip a track
      * @param {Discord.Snowflake} guildID The ID of the guild where the track should be skipped
      * @returns {Promise<Track>}
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'skip'){
+     *          let track = await client.player.skip(message.guild.id);
+     *          message.channel.send(`${track.name} skipped!`);
+     *      }
+     *
+     * });
      */
     skip (guildID) {
         return new Promise((resolve, reject) => {

From 8f9e6ca9d17535138fccda158534bb6a908f4563 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:29:20 +0200
Subject: [PATCH 14/50] :pencil: Add example for clearQueue method

---
 src/Player.js | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/Player.js b/src/Player.js
index 54150bf..1bf1769 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -282,9 +282,22 @@ class Player {
     }
 
     /**
-     * Clear the guild queue, but not the current track
+     * Clear the guild queue, except the current track
      * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be cleared
      * @returns {Promise<Queue>} The updated queue
+     *
+     * @example
+     * client.on('message', (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'clear-queue'){
+     *          client.player.clearQueue(message.guild.id);
+     *          message.channel.send('Queue cleared!');
+     *      }
+     *
+     * });
      */
     clearQueue (guildID) {
         return new Promise((resolve, reject) => {

From 88e9419350b0d6c53d5b818a3f2ef5254b081102 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:31:36 +0200
Subject: [PATCH 15/50] :pencil: Add example for addToQueue method

---
 src/Player.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 1bf1769..538e9ce 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -243,6 +243,28 @@ class Player {
      * @param {string} trackName The name of the track to add to the queue
      * @param {Discord.User?} requestedBy The user who requested the track
      * @returns {Promise<Track>} The added track
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'play'){
+     *          let trackPlaying = client.player.isPlaying(message.guild.id);
+     *          // If there's already a track being played
+     *          if(trackPlaying){
+     *              // Add the track to the queue
+     *              let track = await client.player.addToQueue(message.guild.id, args[0]);
+     *              message.channel.send(`${track.name} added to queue!`);
+     *          } else {
+     *              // Else, play the track
+     *              let track = await client.player.play(message.member.voice.channel, args[0]);
+     *              message.channel.send(`Currently playing ${track.name}!`);
+     *          }
+     *      }
+     *
+     * });
      */
     addToQueue (guildID, trackName, requestedBy) {
         return new Promise((resolve, reject) => {

From 07e07f0d63ca38cd40abd96084786a1dae07945d Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:32:50 +0200
Subject: [PATCH 16/50] :fire: :warning: Remove setQueue method

---
 src/Player.js | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 538e9ce..976cfaa 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -285,24 +285,6 @@ class Player {
         })
     }
 
-    /**
-     * Set the queue for a guild.
-     * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be set
-     * @param {Track[]} tracks The tracks list
-     * @returns {Promise<Queue>} The new queue
-     */
-    setQueue (guildID, tracks) {
-        return new Promise((resolve, reject) => {
-            // Get guild queue
-            const queue = this.queues.find((g) => g.guildID === guildID)
-            if (!queue) return reject(new Error('Not playing'))
-            // Update queue
-            queue.tracks = tracks
-            // Resolve the queue
-            resolve(queue)
-        })
-    }
-
     /**
      * Clear the guild queue, except the current track
      * @param {Discord.Snowflake} guildID The ID of the guild where the queue should be cleared

From 248042de33779601c3c86290a1a885d2b94cd6d1 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:33:56 +0200
Subject: [PATCH 17/50] :pencil: Add example for pause method

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 976cfaa..e4d1570 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -156,6 +156,19 @@ class Player {
      * Pause the current track
      * @param {Discord.Snowflake} guildID The ID of the guild where the current track should be paused
      * @returns {Promise<Track>} The paused track
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'pause'){
+     *          let track = await client.player.pause(message.guild.id);
+     *          message.channel.send(`${track.name} paused!`);
+     *      }
+     *
+     * });
      */
     pause (guildID) {
         return new Promise((resolve, reject) => {

From 4334aafb34050a6a9133eb588aee874f4a4f72d6 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:34:52 +0200
Subject: [PATCH 18/50] :pencil: Add example for resume method

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index e4d1570..a5bb247 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -187,6 +187,19 @@ class Player {
      * Resume the current track
      * @param {Discord.Snowflake} guildID The ID of the guild where the current track should be resumed
      * @returns {Promise<Track>} The resumed track
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'resume'){
+     *          let track = await client.player.resume(message.guild.id);
+     *          message.channel.send(`${track.name} resumed!`);
+     *      }
+     *
+     * });
      */
     resume (guildID) {
         return new Promise((resolve, reject) => {

From b8dee7bce2963997f0bd6f33de9ba5d8f793b74d Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:36:04 +0200
Subject: [PATCH 19/50] :pencil: Add example for stop command

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index a5bb247..4dfe88d 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -218,6 +218,19 @@ class Player {
      * Stops playing music.
      * @param {Discord.Snowflake} guildID The ID of the guild where the music should be stopped
      * @returns {Promise<void>}
+     *
+     * @example
+     * client.on('message', (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'stop'){
+     *          client.player.stop(message.guild.id);
+     *          message.channel.send('Music stopped!');
+     *      }
+     *
+     * });
      */
     stop (guildID) {
         return new Promise((resolve, reject) => {

From 535d8a43e440fa4306875651f98dd926d404e4de Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:37:07 +0200
Subject: [PATCH 20/50] :pencil: Add example for setVolume method

---
 src/Player.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 4dfe88d..1f73ca0 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -251,6 +251,19 @@ class Player {
      * @param {Discord.Snowflake} guildID The ID of the guild where the music should be modified
      * @param {number} percent The new volume (0-100)
      * @returns {Promise<void>}
+     *
+     * @example
+     * client.on('message', (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'setvolume'){
+     *          client.player.setVolume(message.guild.id, parseInt(args[0]));
+     *          message.channel.send(`Volume set to ${args[0]} !`);
+     *      }
+     *
+     * });
      */
     setVolume (guildID, percent) {
         return new Promise((resolve, reject) => {

From d1099b3551509cfc99a1af998abb29e84628aec9 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:49:57 +0200
Subject: [PATCH 21/50] :bug: :pencil: Some fixes and some documentation
 examples

---
 src/Player.js | 89 +++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 76 insertions(+), 13 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 1f73ca0..ec3edc4 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -90,6 +90,32 @@ class Player {
      * Searchs tracks on YouTube
      * @param {string} query The query
      * @returns {Promise<Track[]>}
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'play'){
+     *          // Search for tracks
+     *          let tracks = await client.player.searchTracks(args[0]);
+     *          // Sends an embed with the 10 first songs
+     *          if(tracks.length > 10) tracks = tracks.substr(0, 10);
+     *          const embed = new Discord.MessageEmbed()
+     *          .setDescription(tracks.map((t, i) => `**${i+1} -** ${t.name}`).join("\n"))
+     *          .setFooter("Send the number of the track you want to play!");
+     *          message.channel.send(embed);
+     *          // Wait for user answer
+     *          await message.channel.awaitMessages((m) => m.content > 0 && m.content < 10, { max: 1, time: 20000, errors: ["time"] }).then(async (answers) => {
+     *              let index = parseInt(answers.first().content, 10);
+     *              track = track[index-1];
+     *              // Then play the song
+     *              client.player.play(message.member.voice.channel, track);
+     *          });
+     *      }
+     *
+     * });
      */
     searchTracks (query) {
         return new Promise(async (resolve, reject) => {
@@ -121,6 +147,22 @@ class Player {
      * @param {Track|string} track The name of the track to play
      * @param {Discord.User?} user The user who requested the track
      * @returns {Promise<Track>} The played track
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      // !play Despacito
+     *      // will play "Despacito" in the member voice channel
+     *
+     *      if(command === 'play'){
+     *          let track = await client.player.play(message.member.voice.channel, args[0], message.member.user.tag);
+     *          message.channel.send(`Currently playing ${track.name}! - Requested by ${track.requestedBy}`);
+     *      }
+     *
+     * });
      */
     play (voiceChannel, track, user) {
         this.queues = this.queues.filter((g) => g.guildID !== voiceChannel.id)
@@ -282,6 +324,28 @@ class Player {
      * Get a guild queue
      * @param {Discord.Snowflake} guildID
      * @returns {?Queue}
+     *
+     * @example
+     * client.on('message', (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'queue'){
+     *          let queue = await client.player.getQueue(message.guild.id);
+     *          message.channel.send('Server queue:\n'+(queue.tracks.map((track, i) => {
+     *              return `${i === 0 ? 'Current' : `#${i+1}`} - ${track.name} | ${track.author}`;
+     *          }).join('\n')));
+     *      }
+     *
+     *      // Output:
+     *
+     *      // Server queue:
+     *      // Current - Despacito | Luis Fonsi
+     *      // #2 - Memories | Maroon 5
+     *      // #3 - Dance Monkey | Tones And I
+     *      // #4 - Circles | Post Malone
+     * });
      */
     getQueue (guildID) {
         // Gets guild queue
@@ -292,7 +356,7 @@ class Player {
     /**
      * Add a track to the guild queue
      * @param {Discord.Snowflake} guildID The ID of the guild where the track should be added
-     * @param {string} trackName The name of the track to add to the queue
+     * @param {Track|string} trackName The name of the track to add to the queue
      * @param {Discord.User?} requestedBy The user who requested the track
      * @returns {Promise<Track>} The added track
      *
@@ -318,22 +382,21 @@ class Player {
      *
      * });
      */
-    addToQueue (guildID, trackName, requestedBy) {
-        return new Promise((resolve, reject) => {
+    addToQueue (guildID, track, requestedBy) {
+        return new Promise(async (resolve, reject) => {
             // Get guild queue
             const queue = this.queues.find((g) => g.guildID === guildID)
             if (!queue) return reject(new Error('Not playing'))
             // Search the track
-            this.search(trackName).then((track) => {
-                if (!track[0]) return reject(new Error('Track not found'))
-                track[0].requestedBy = requestedBy
-                // Update queue
-                queue.tracks.push(track[0])
-                // Resolve the track
-                resolve(track[0])
-            }).catch(() => {
-                return reject(new Error('Track not found'))
-            })
+            if (typeof track !== 'object') {
+                const results = await this.searchTracks(track)
+                track = results[0]
+            }
+            track.requestedBy = requestedBy
+            // Update queue
+            queue.tracks.push(track)
+            // Resolve the track
+            resolve(track)
         })
     }
 

From 52c70eb2812034bd791883d7286a0ff4e0deef77 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 17:56:33 +0200
Subject: [PATCH 22/50] :pencil: Document setFilters method

---
 src/Player.js | 45 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 42 insertions(+), 3 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index ec3edc4..a476f00 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -5,6 +5,22 @@ const ytsr = require('ytsr')
 const Queue = require('./Queue')
 const Track = require('./Track')
 
+/**
+ * @typedef Filters
+ * @property {boolean} [bassboost=false] Whether the bassboost filter is enabled.
+ * @property {boolean} [8D=false] Whether the 8D filter is enabled.
+ * @property {boolean} [vaporwave=false] Whether the vaporwave filter is enabled.
+ * @property {boolean} [nightcore=false] Whether the nightcore filter is enabled.
+ * @property {boolean} [phaser=false] Whether the phaser filter is enabled.
+ * @property {boolean} [tremolo=false] Whether the tremolo filter is enabled.
+ * @property {boolean} [reverse=false] Whether the reverse filter is enabled.
+ * @property {boolean} [treble=false] Whether the treble filter is enabled.
+ * @property {boolean} [normalizer=false] Whether the normalizer filter is enabled.
+ * @property {boolean} [surrounding=false] Whether the surrounding filter is enabled.
+ * @property {boolean} [pulsator=false] Whether the pulsator filter is enabled.
+ * @property {boolean} [subboost=false] Whether the subboost filter is enabled.
+ */
+
 const filters = {
     bassboost: 'bass=g=20,dynaudnorm=f=200',
     '8D': 'apulsator=hz=0.128',
@@ -70,11 +86,34 @@ class Player {
     }
 
     /**
-     * Update the filters for the guild
+     * Set the filters enabled for the guild. [Full list of the filters](https://discord-player.js.org/global.html#Filters)
      * @param {Discord.Snowflake} guildID
-     * @param {Object} newFilters
+     * @param {Filters} newFilters
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *      const command = args.shift().toLowerCase();
+     *
+     *      if(command === 'bassboost'){
+     *          const bassboostEnabled = client.player.getQueue(message.guild.id);
+     *          if(!bassboostEnabled){
+     *              client.player.updateFilters(message.guild.id, {
+     *                  bassboost: true
+     *              });
+     *              message.channel.send("Bassboost effect has been enabled!");
+     *          } else {
+     *              client.player.updateFilters(message.guild.id, {
+     *                  bassboost: false
+     *              });
+     *              message.channel.send("Bassboost effect has been disabled!");
+     *          }
+     *      }
+     *
+     * });
      */
-    updateFilters (guildID, newFilters) {
+    setFilters (guildID, newFilters) {
         return new Promise((resolve, reject) => {
             // Gets guild queue
             const queue = this.queues.find((g) => g.guildID === guildID)

From c16c730c4dc77f04f6f21fb90572f4f175497a63 Mon Sep 17 00:00:00 2001
From: Snowflake <46562212+Snowflake107@users.noreply.github.com>
Date: Mon, 22 Jun 2020 00:24:27 +0545
Subject: [PATCH 23/50] Add and fix filters (#32)

Co-authored-by: Androz <androz2091@gmail.com>
---
 src/Player.js | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index a476f00..23661d5 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -13,6 +13,7 @@ const Track = require('./Track')
  * @property {boolean} [nightcore=false] Whether the nightcore filter is enabled.
  * @property {boolean} [phaser=false] Whether the phaser filter is enabled.
  * @property {boolean} [tremolo=false] Whether the tremolo filter is enabled.
+ * @property {boolean} [vibrato=false] Whether the vibrato filter is enabled.
  * @property {boolean} [reverse=false] Whether the reverse filter is enabled.
  * @property {boolean} [treble=false] Whether the treble filter is enabled.
  * @property {boolean} [normalizer=false] Whether the normalizer filter is enabled.
@@ -24,12 +25,13 @@ const Track = require('./Track')
 const filters = {
     bassboost: 'bass=g=20,dynaudnorm=f=200',
     '8D': 'apulsator=hz=0.128',
-    vaporwave: 'asetrate=441000*.8,aresample=44100,atempo=1.1',
-    nightcore: 'asetrate=441001*.25',
+    vaporwave: 'asetrate=44100*0.8,aresample=44100,atempo=1.1',
+    nightcore: 'asetrate=44100*1.25',
     phaser: 'aphaser=in_gain=0.4',
-    tremolo: 'tremolo=f=6.5',
+    tremolo: 'tremolo',
+    vibrato: 'vibrato=f=6.5',
     reverse: 'areverse',
-    treble: 'treble=g={GAIN}',
+    treble: 'treble=g=5',
     normalizer: 'dynaudnorm=f=150',
     surrounding: 'surround',
     pulsator: 'apulsator=hz=1',

From a90532fee008141bef719a79dbc26f86068303be Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sun, 21 Jun 2020 21:06:54 +0200
Subject: [PATCH 24/50] :pencil: Rewrite README doc and add some examples

---
 README.md    | 547 +++++----------------------------------------------
 src/Queue.js |  40 ++++
 2 files changed, 88 insertions(+), 499 deletions(-)

diff --git a/README.md b/README.md
index 3f80463..2470b7a 100644
--- a/README.md
+++ b/README.md
@@ -22,7 +22,16 @@ npm install --save @discordjs/opus
 
 Install [FFMPEG](https://www.ffmpeg.org/download.html) and you're done!
 
-## Player
+## Features
+
+🤘 Easy to use!  
+🎸 You can apply some cool filters (bassboost, reverse, 8D, etc...)  
+🎼 Manage your server queues with simple functions (add songs, skip the current song, pause the music, resume it, etc...)!
+🌐 Multi-servers support
+
+## Getting Started
+
+Here is the code you will need to get started with discord-player. Then, you will be able to use `client.player` everywhere in your code!
 
 ```js
 const Discord = require("discord.js"),
@@ -42,57 +51,56 @@ client.on("ready", () => {
     console.log("I'm ready !");
 });
 
+client.on("message", async (message) => {
+
+    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+    const command = args.shift().toLowerCase();
+
+    // !play Despacito
+    // will play "Despacito" in the member voice channel
+
+    if(command === "play"){
+        let track = await client.player.play(message.member.voice.channel, args[0], message.member.user.tag);
+        message.channel.send(`Currently playing ${track.name}! - Requested by ${track.requestedBy}`);
+    }
+
+});
+
 client.login(settings.token);
 ```
 
-You can pass a third parameter when instantiating the class Player: the **options** object:  
-**options.leaveOnEnd**: whether the bot should leave the voice channel when there is no more track in the queue.  
-**options.leaveOnStop**: whether the bot should leave the voice channel when the `stop()` function is used.  
-**options.leaveOnEmpty**: whether the bot should leave the voice channel if there is no more member in it.
+## [Documentation](https://discord-player.js.org)
 
-### Features Overview
+You will find many examples in the documentation to understand how the package works!
 
-You need to **init the guild queue using the play() function**, then you are able to manage the queue using the following functions:
+### Methods overview
 
-```js
-// Play a track in the voice channel and init the guild queue
-client.player.play(voiceChannel, trackName);
+You need to **init the guild queue using the play() function**, then you are able to manage the queue and the music using the following functions. Click on a function name to get an example code and explanations.
 
-// Add a track to the queue
-client.player.addToQueue(guildID, trackName);
-// Clear the queue
-client.player.clearQueue(guildID);
-// Get the queue
-client.player.getQueue(guildID);
-// Skip the current track
-client.player.skip(guildID);
-// Remove a track from the queue using the index number
-client.player.remove(guildID, track);
+#### Queue initialization
 
-// Filters!
-client.player.updateFilters(guildID, {
-    bassboost: true,
-    vaporwave: true
-})
+* [play(voiceChannel, track, requestedBy)](https://discord-player.js.org/Player.html#play) - play a track in a server
 
-// Pause
-client.player.pause(guildID);
-// Resume
-client.player.resume(guildID);
-// Stop
-client.player.stop(guildID);
+#### Queue management
 
-// Check if music is playing in a guild
-client.player.isPlaying(guildID);
-// Get the currently playing trac
-client.player.nowPlaying(guildID);
+* [isPlaying(guildID)](https://discord-player.js.org/Player.html#isPlaying) - check if there is a queue for a specific server
 
+#### Manage tracks in your queue
 
-// Current track will be repeated indefinitely
-client.player.setRepeatMode(guildID, true);
-// Current track will no longer be repeated indefinitely
-client.player.setRepeatMode(guildID, false);
-```
+* [getQueue(guildID)](https://discord-player.js.org/Player.html#getQueue) - get the server queue
+* [addToQueue(guildID, track, requestedBy)](https://discord-player.js.org/Player.html#addToQueue) - add a track to the server queue
+* [clearQueue(guildID)](https://discord-player.js.org/Player.html#clearQueue) - clear the server queue
+* [remove(guildID, track)](https://discord-player.js.org/Player.html#remove) - remove a track from the server queue
+* [nowPlaying(guildID)](https://discord-player.js.org/Player.html#nowPlaying) - get the current track
+
+#### Manage music stream
+
+* [skip(guildID)](https://discord-player.js.org/Player.html#skip) - skip the current track
+* [pause(guildID)](https://discord-player.js.org/Player.html#pause) - pause the current track
+* [resume(guildID)](https://discord-player.js.org/Player.html#resume) - resume the current track
+* [stop(guildID)](https://discord-player.js.org/Player.html#stop) - stop the current track
+* [setFilters(data)](https://discord-player.js.org/Player.html#setFilters) - update filters (bassboost for example)
+* [setRepeatMode(boolean)](https://discord-player.js.org/Player.html#setRepeatMode) - enable or disable repeat mode for the server
 
 ### Event messages
 
@@ -113,465 +121,6 @@ client.player.getQueue(guildID)
 });
 ```
 
-## Examples
-
-### Play
-
-To play a track, use the `client.player.play()` function.  
-
-**Usage:**
-
-```js
-client.player.play(voiceChannel, trackName, requestedBy);
-```
-
-**Example**:
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    // !play Despacito
-    // will play "Despacito" in the member voice channel
-
-    if(command === 'play'){
-        let track = await client.player.play(message.member.voice.channel, args[0], message.member.user.tag);
-        message.channel.send(`Currently playing ${track.name}! - Requested by ${track.requestedBy}`);
-    }
-
-```
-
-### Pause
-
-To pause the current track, use the `client.player.pause()` function.  
-
-**Usage:**
-
-```js
-client.player.pause(guildID);
-```
-
-**Example**:
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'pause'){
-        let track = await client.player.pause(message.guild.id);
-        message.channel.send(`${track.name} paused!`);
-    }
-
-});
-```
-
-### Resume
-
-To resume the current track, use the `client.player.resume()` function.  
-
-**Usage:**
-
-```js
-client.player.resume(guildID);
-```
-
-**Example**:
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'resume'){
-        let track = await client.player.resume(message.guild.id);
-        message.channel.send(`${track.name} resumed!`);
-    }
-
-});
-```
-
-### Stop
-
-To stop the music, use the `client.player.stop()` function.  
-
-**Usage:**
-
-```js
-client.player.stop(guildID);
-```
-
-**Example**:
-
-```js
-client.on('message', (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'stop'){
-        client.player.stop(message.guild.id);
-        message.channel.send('Music stopped!');
-    }
-
-});
-```
-
-### SetVolume
-
-To update the volume, use the `client.player.setVolume()` function.  
-
-**Usage:**
-
-```js
-client.player.setVolume(guildID, percent);
-```
-
-**Example**:
-
-```js
-client.on('message', (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'setvolume'){
-        client.player.setVolume(message.guild.id, parseInt(args[0]));
-        message.channel.send(`Volume set to ${args[0]} !`);
-    }
-
-});
-```
-
-### AddToQueue
-
-To add a track to the queue, use the `client.player.addToQueue()` function.
-
-**Usage:**
-
-```js
-client.player.addToQueue(guildID, trackName);
-```
-
-**Example:**
-
-In this example, you will see how to add a track to the queue if one is already playing.
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'play'){
-        let aTrackIsAlreadyPlaying = client.player.isPlaying(message.guild.id);
-        // If there's already a track playing
-        if(aTrackIsAlreadyPlaying){
-            // Add the track to the queue
-            let track = await client.player.addToQueue(message.guild.id, args[0]);
-            message.channel.send(`${track.name} added to queue!`);
-        } else {
-            // Else, play the track
-            let track = await client.player.play(message.member.voice.channel, args[0]);
-            message.channel.send(`Currently playing ${track.name}!`);
-        }
-    }
-
-});
-```
-
-### ClearQueue
-
-To clear the queue, use the `client.player.clearQueue()` function.
-
-**Usage:**
-
-```js
-client.player.clearQueue(guildID);
-```
-
-**Example:**
-
-```js
-client.on('message', (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'clear-queue'){
-        client.player.clearQueue(message.guild.id);
-        message.channel.send('Queue cleared!');
-    }
-
-});
-```
-
-### GetQueue
-
-To get the server queue, use the `client.player.getQueue()` function.
-
-**Usage:**
-
-```js
-client.player.getQueue(guildID);
-```
-
-**Example:**
-
-```js
-client.on('message', (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'queue'){
-        let queue = await client.player.getQueue(message.guild.id);
-        message.channel.send('Server queue:\n'+(queue.tracks.map((track, i) => {
-            return `${i === 0 ? 'Current' : `#${i+1}`} - ${track.name} | ${track.author}`
-        }).join('\n')));
-    }
-
-    /**
-     * Output:
-     *
-     * Server queue:
-     * Current - Despacito | Luis Fonsi
-     * #2 - Memories | Maroon 5
-     * #3 - Dance Monkey | Tones And I
-     * #4 - Circles | Post Malone
-     */
-
-});
-```
-
-### Skip
-
-To skip the current track, use the `client.player.skip()` function.  
-
-**Usage:**
-
-```js
-client.player.skip(guildID);
-```
-
-**Example**:
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'skip'){
-        let track = await client.player.skip(message.guild.id);
-        message.channel.send(`${track.name} skipped!`);
-    }
-
-});
-```
-
-### Now Playing
-
-To get the currently playing track, use the `client.player.nowPlaying()` function.  
-
-**Usage:**
-
-```js
-client.player.nowPlaying(guildID);
-```
-
-**Example**:
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'now-playing'){
-        let track = await client.player.nowPlaying(message.guild.id);
-        message.channel.send(`Currently playing ${track.name}...`);
-    }
-
-});
-```
-
-### Repeat
-
-To repeat the current track, use the `client.player.setRepeatMode()` function.  
-
-**Usage:**
-
-```js
-client.player.setRepeatMode(guildID, boolean);
-```
-
-**Example**:
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'enable-repeat'){
-        // Enable repeat mode
-        client.player.setRepeatMode(message.guild.id, true);
-        // Get the current track
-        let track = await client.player.nowPlaying(message.guild.id);
-        message.channel.send(`${track.name} will be repeated indefinitely!`);
-    }
-
-    if(command === 'disable-repeat'){
-        // Disable repeat mode
-        client.player.setRepeatMode(message.guild.id, false);
-        // Get the current track
-        let track = await client.player.nowPlaying(message.guild.id);
-        message.channel.send(`${track.name}  will no longer be repeated indefinitely!`);
-    }
-
-});
-```
-
-### Remove
-
-To remove a track from the queue, use the `client.player.remove()` function.
-
-**Usage:**
-
-```js
-client.player.remove(guildID, track);
-```
-
-**Example:**
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'remove'){
-        // Removes a track from the queue
-        client.player.remove(message.guild.id, args[0]).then(() => {
-            message.channel.send('Removed track!');
-        });
-    }
-});
-```
-
-### Filters
-
-You can apply some cool filters to your music!
-
-**Usage:**
-
-```js
-client.player.updateFilters(guildID, {
-    bassboost: true,
-    '8D': true,
-    vaporwave: true,
-    nightcore: true,
-    phaser: true,
-    tremolo: true,
-    reverse: true,
-    treble: true,
-    normalizer: true,
-    surrounding: true
-    pulsator: true,
-    subboost: true
-});
-```
-
-**Example:**
-
-```js
-client.on('message', async (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'bassboost'){
-        const bassboostEnabled = client.player.getQueue(message.guild.id);
-        if(!bassboostEnabled){
-            client.player.updateFilters(message.guild.id, {
-                bassboost: true
-            });
-            message.channel.send("Bassboost effect has been enabled!");
-        } else {
-            client.player.updateFilters(message.guild.id, {
-                bassboost: false
-            });
-            message.channel.send("Bassboost effect has been disabled!");
-        }
-    }
-
-    // You can do the same for each filter!
-});
-```
-
-## Info Messages
-
-You can send a message when the queue ends or when the track changes:
-
-```js
-client.on('message', (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    if(command === 'play'){
-        let track = await client.player.play(message.member.voice.channel, args[0]);
-        track.queue.on('end', () => {
-            message.channel.send('The queue is empty, please add new tracks!');
-        });
-        track.queue.on('trackChanged', (oldTrack, newTrack, skipped, repeatMode) => {
-            if(repeatMode){
-                message.channel.send(`Playing ${newTrack} again...`);
-            } else {
-                message.channel.send(`Now playing ${newTrack}...`);
-            }
-        });
-    }
-
-```
-
-## Handle errors
-
-There are 2 main errors that you can handle like this:
-
-```js
-client.on('message', (message) => {
-
-    const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
-    const command = args.shift().toLowerCase();
-
-    // Error 1:
-    // Track not found
-    if(command === 'play'){
-        client.player.play(message.member.voice.channel, args[0]).then((track) => {
-            message.channel.send(`Currently playing ${track.name}!`);
-        }).catch(() => {
-            message.channel.send(`No track found for ${args[0]}`);
-        });
-    }
-
-    // Error 2:
-    // Not playing
-    if(command === 'queue'){
-        let playing = client.player.isPlaying(message.guild.id);
-        if(!playing) return message.channel.send(':x: No tracks currently playing!');
-        // you are sure it works:
-        client.player.getQueue(message.guild.id);
-    }
-
-});
-```
-
 ## Examples of bots made with discord-player
 
 These bots are made by the community, they can help you build your own!
diff --git a/src/Queue.js b/src/Queue.js
index 0637842..f102c50 100644
--- a/src/Queue.js
+++ b/src/Queue.js
@@ -69,6 +69,24 @@ module.exports = Queue
 /**
  * Emitted when the queue is empty.
  * @event Queue#end
+ *
+ * @example
+ * client.on('message', (message) => {
+ *
+ *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+ *      const command = args.shift().toLowerCase();
+ *
+ *      if(command === 'play'){
+ *
+ *          let track = await client.player.play(message.member.voice.channel, args[0]);
+ *
+ *          track.queue.on('end', () => {
+ *              message.channel.send('The queue is empty, please add new tracks!');
+ *          });
+ *
+ *      }
+ *
+ * });
  */
 
 /**
@@ -82,4 +100,26 @@ module.exports = Queue
  * @param {Track} oldTrack The old track (playing before)
  * @param {Track} newTrack The new track (currently playing)
  * @param {Boolean} skipped Whether the change is due to the skip() function
+ *
+ * @example
+ * client.on('message', (message) => {
+ *
+ *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+ *      const command = args.shift().toLowerCase();
+ *
+ *      if(command === 'play'){
+ *
+ *          let track = await client.player.play(message.member.voice.channel, args[0]);
+ *
+ *          track.queue.on('trackChanged', (oldTrack, newTrack, skipped, repeatMode) => {
+ *              if(repeatMode){
+ *                  message.channel.send(`Playing ${newTrack} again...`);
+ *              } else {
+ *                  message.channel.send(`Now playing ${newTrack}...`);
+ *              }
+ *          });
+ *
+ *      }
+ *
+ * });
  */

From 347750ec06b910a8c8a30b4df37e075d4728a8d4 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 10:23:20 +0200
Subject: [PATCH 25/50] :bug: Resolve currently playing song

---
 src/Player.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 23661d5..b5cc4a3 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -262,7 +262,7 @@ class Player {
             queue.voiceConnection.dispatcher.pause()
             queue.paused = true
             // Resolves the guild queue
-            resolve(queue.tracks[0])
+            resolve(queue.playing)
         })
     }
 
@@ -293,7 +293,7 @@ class Player {
             queue.voiceConnection.dispatcher.resume()
             queue.paused = false
             // Resolve the guild queue
-            resolve(queue.tracks[0])
+            resolve(queue.playing)
         })
     }
 

From f98a8d73abeec91cf280c43ebe85ca431fdc04ae Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 11:12:57 +0200
Subject: [PATCH 26/50] :bug: Use queue#playing for nowPlaying() function

---
 src/Player.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Player.js b/src/Player.js
index b5cc4a3..5eb388b 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -527,7 +527,7 @@ class Player {
             // Get guild queue
             const queue = this.queues.find((g) => g.guildID === guildID)
             if (!queue) return reject(new Error('Not playing'))
-            const currentTrack = queue.tracks[0]
+            const currentTrack = queue.playing
             // Resolve the current track
             resolve(currentTrack)
         })

From c6625a02d8c17057c251cd3f5f5b66c0c13a7cbc Mon Sep 17 00:00:00 2001
From: Snowflake <46562212+Snowflake107@users.noreply.github.com>
Date: Wed, 24 Jun 2020 14:59:33 +0545
Subject: [PATCH 27/50] feat: add createProgressBar (#33)

---
 src/Player.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index b5cc4a3..bddec56 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -674,6 +674,27 @@ class Player {
             queue.emit('channelEmpty')
         }
     }
+    
+    /**
+      * Creates progress bar of the current song
+      * @param {Queue} queue Queue of the current server
+      * @returns {String}
+      */
+    createProgressBar(queue) {
+        // stream time of the dispatcher
+        const currentStreamTime = queue.voiceConnection.dispatcher.streamTime
+        // total stream length
+        const totalLength = queue.tracks[0].durationMS
+        // stream progress
+        let index = Math.round((currentStreamTime / totalLength) * 15)
+        // conditions
+        if ((index >= 1) && (index <= 15)) {
+            let bar = `▬▬▬▬▬▬▬▬▬▬▬▬▬▬`.split("")
+            return bar.splice(index, 0, "🔘").join("")
+        } else {
+            return `🔘▬▬▬▬▬▬▬▬▬▬▬▬▬▬`
+        }
+    }
 
     /**
      * Play a stream in a channel

From 09eddf27c717a958824efc1f8414eb5da3845ac8 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 11:28:38 +0200
Subject: [PATCH 28/50] :sparkles: Fix createProgressBar method

---
 src/Player.js | 46 +++++++++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 21 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 242ecd6..c4d1d68 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -650,6 +650,31 @@ class Player {
         })
     }
 
+    /**
+      * Creates progress bar of the current song
+      * @param {Discord.Snowflake} guildID
+      * @returns {String}
+      */
+    createProgressBar (guildID) {
+        // Gets guild queue
+        const queue = this.queues.find((g) => g.guildID === guildID)
+        if (!queue) return
+        // Stream time of the dispatcher
+        const currentStreamTime = queue.voiceConnection.dispatcher.streamTime
+        // Total stream time
+        const totalTime = queue.playing.durationMS
+        // Stream progress
+        const index = Math.round((currentStreamTime / totalTime) * 15)
+        // conditions
+        if ((index >= 1) && (index <= 15)) {
+            const bar = '▬▬▬▬▬▬▬▬▬▬▬▬▬▬'.split('')
+            bar.splice(index, 0, '🔘')
+            return bar.join('')
+        } else {
+            return '🔘▬▬▬▬▬▬▬▬▬▬▬▬▬▬'
+        }
+    }
+
     /**
      * Handle the voice state update event
      * @ignore
@@ -674,27 +699,6 @@ class Player {
             queue.emit('channelEmpty')
         }
     }
-    
-    /**
-      * Creates progress bar of the current song
-      * @param {Queue} queue Queue of the current server
-      * @returns {String}
-      */
-    createProgressBar(queue) {
-        // stream time of the dispatcher
-        const currentStreamTime = queue.voiceConnection.dispatcher.streamTime
-        // total stream length
-        const totalLength = queue.tracks[0].durationMS
-        // stream progress
-        let index = Math.round((currentStreamTime / totalLength) * 15)
-        // conditions
-        if ((index >= 1) && (index <= 15)) {
-            let bar = `▬▬▬▬▬▬▬▬▬▬▬▬▬▬`.split("")
-            return bar.splice(index, 0, "🔘").join("")
-        } else {
-            return `🔘▬▬▬▬▬▬▬▬▬▬▬▬▬▬`
-        }
-    }
 
     /**
      * Play a stream in a channel

From 86cedbafad2a1c84ce79fa07b6af6dc4ada8e978 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 11:31:19 +0200
Subject: [PATCH 29/50] :pencil: Add an example for createProgessBar method

---
 src/Player.js | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index c4d1d68..3a2341d 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -651,10 +651,25 @@ class Player {
     }
 
     /**
-      * Creates progress bar of the current song
-      * @param {Discord.Snowflake} guildID
-      * @returns {String}
-      */
+     * Creates progress bar of the current song
+     * @param {Discord.Snowflake} guildID
+     * @returns {String}
+     *
+     * @example
+     * client.on('message', async (message) => {
+     *
+     *     const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+     *     const command = args.shift().toLowerCase();
+     *
+     *     if(command === 'now-playing'){
+     *         // Shuffle the server queue
+     *         client.player.nowPlaying(message.guild.id).then((song) => {
+     *              message.channel.send('Currently playing ' + song.name + '\n\n'+ client.player.createProgressBar(message.guild.id));
+     *         });
+     *      }
+     *
+     * });
+     */
     createProgressBar (guildID) {
         // Gets guild queue
         const queue = this.queues.find((g) => g.guildID === guildID)

From 334dacd8807562b7021e6d5562cd811cdef1d0cb Mon Sep 17 00:00:00 2001
From: Zack Radisic <56137411+zackradisic@users.noreply.github.com>
Date: Wed, 24 Jun 2020 07:57:24 -0400
Subject: [PATCH 30/50] feat: play soundcloud tracks (#35)

---
 package.json  |  1 +
 src/Player.js | 75 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 75 insertions(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9d0bc7f..08fd8ad 100644
--- a/package.json
+++ b/package.json
@@ -33,6 +33,7 @@
     "merge-options": "^2.0.0",
     "node-fetch": "^2.6.0",
     "simple-youtube-api": "^5.2.1",
+    "soundcloud-downloader": "0.0.9",
     "ytsr": "^0.1.15"
   },
   "devDependencies": {
diff --git a/src/Player.js b/src/Player.js
index 3a2341d..adaabaa 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -1,6 +1,7 @@
 const ytdl = require('discord-ytdl-core')
 const Discord = require('discord.js')
 const ytsr = require('ytsr')
+const scdl = require('soundcloud-downloader')
 
 const Queue = require('./Queue')
 const Track = require('./Track')
@@ -43,6 +44,7 @@ const filters = {
  * @property {boolean} [leaveOnEnd=true] Whether the bot should leave the current voice channel when the queue ends.
  * @property {boolean} [leaveOnStop=true] Whether the bot should leave the current voice channel when the stop() function is used.
  * @property {boolean} [leaveOnEmpty=true] Whether the bot should leave the voice channel if there is no more member in it.
+ * @property {string} [soundcloudClientID=""] The client ID for Soundcloud, optional
  */
 
 /**
@@ -53,7 +55,8 @@ const filters = {
 const defaultPlayerOptions = {
     leaveOnEnd: true,
     leaveOnStop: true,
-    leaveOnEmpty: true
+    leaveOnEmpty: true,
+    soundcloudClientID: ''
 }
 
 class Player {
@@ -164,6 +167,21 @@ class Player {
             const matchURL = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)
             if (matchURL) {
                 query = matchURL[1]
+            } else if (this.options.soundcloudClientID) {
+                const scRegex = /^https?:\/\/(soundcloud\.com)\/(.*)$/
+                if (query.match(scRegex) && query.match(scRegex)[2]) {
+                    const info = await scdl.getInfo(query, this.options.soundcloudClientID)
+                    const details = {
+                        title: info.title,
+                        link: info.uri,
+                        duration: info.duration,
+                        description: info.description,
+                        thumbnail: info.artwork_url,
+                        views: info.playback_count,
+                        author: { name: info.user.username }
+                    }
+                    return resolve([new Track(details, null, null)])
+                }
             }
             ytsr(query, (err, results) => {
                 if (err) return []
@@ -762,6 +780,51 @@ class Player {
         })
     }
 
+    /**
+     * Play a Soundcloud stream in a channel
+     * @ignore
+     * @private
+     * @param {Queue} queue The queue to play
+     * @param {*} updateFilter Whether this method is called to update some ffmpeg filters
+     * @returns {Promise<void>}
+     */
+    _playSouncloudStream (queue, updateFilter) {
+        return new Promise(async (resolve) => {
+            const currentStreamTime = updateFilter ? queue.voiceConnection.dispatcher.streamTime / 1000 : undefined
+            const encoderArgsFilters = []
+            Object.keys(queue.filters).forEach((filterName) => {
+                if (queue.filters[filterName]) {
+                    encoderArgsFilters.push(filters[filterName])
+                }
+            })
+            let encoderArgs
+            if (encoderArgsFilters.length < 1) {
+                encoderArgs = []
+            } else {
+                encoderArgs = ['-af', encoderArgsFilters.join(',')]
+            }
+
+            const info = await scdl.getInfo(queue.playing.url, this.options.soundcloudClientID)
+            const opus = scdl.filterMedia(info.media.transcodings, { format: scdl.FORMATS.OPUS })
+            const newStream = await scdl.downloadFromURL(opus[0].url, this.options.soundcloudClientID)
+            setTimeout(() => {
+                queue.voiceConnection.play(newStream, {
+                    type: 'ogg/opus'
+                })
+                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200)
+                // When the track starts
+                queue.voiceConnection.dispatcher.on('start', () => {
+                    resolve()
+                })
+                // When the track ends
+                queue.voiceConnection.dispatcher.on('finish', () => {
+                    // Play the next track
+                    return this._playTrack(queue.guildID, false)
+                })
+            }, 1000)
+        })
+    }
+
     /**
      * Start playing a track in a guild
      * @ignore
@@ -790,6 +853,16 @@ class Player {
         const nowPlaying = queue.playing = queue.repeatMode ? wasPlaying : queue.tracks.shift()
         // Reset lastSkipped state
         queue.lastSkipped = false
+
+        if (queue.playing.url.includes('soundcloud.com')) {
+            this._playSouncloudStream(queue, false).then(() => {
+                // Emit trackChanged event
+                if (!firstPlay) {
+                    queue.emit('trackChanged', nowPlaying, wasPlaying, queue.lastSkipped, queue.repeatMode)
+                }
+            })
+            return
+        }
         this._playYTDLStream(queue, false).then(() => {
             // Emit trackChanged event
             if (!firstPlay) {

From ed13b2c40a344acd2e35c7f46cc99a264d5905d5 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 13:59:03 +0200
Subject: [PATCH 31/50] :arrow_up: Bump some dependencies

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 08fd8ad..eedcbb1 100644
--- a/package.json
+++ b/package.json
@@ -29,11 +29,11 @@
   "homepage": "https://github.com/Androz2091/discord-player#readme",
   "dependencies": {
     "@discordjs/opus": "^0.3.2",
-    "discord-ytdl-core": "^4.0.0",
+    "discord-ytdl-core": "^4.0.2",
     "merge-options": "^2.0.0",
     "node-fetch": "^2.6.0",
     "simple-youtube-api": "^5.2.1",
-    "soundcloud-downloader": "0.0.9",
+    "soundcloud-downloader": "^0.0.9",
     "ytsr": "^0.1.15"
   },
   "devDependencies": {

From df6be94fb32f58065b325d31f7afe7a8651168f5 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 16:51:00 +0200
Subject: [PATCH 32/50] :bug: Fix skip method

---
 src/Player.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index adaabaa..96d4512 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -513,7 +513,7 @@ class Player {
             // Get guild queue
             const queue = this.queues.find((g) => g.guildID === guildID)
             if (!queue) return reject(new Error('Not playing'))
-            const currentTrack = queue.tracks[0]
+            const currentTrack = queue.playing
             // End the dispatcher
             queue.voiceConnection.dispatcher.end()
             queue.lastSkipped = true
@@ -836,7 +836,7 @@ class Player {
         // Get guild queue
         const queue = this.queues.find((g) => g.guildID === guildID)
         // If there isn't any music in the queue
-        if (queue.tracks.length < 2 && !firstPlay && !queue.repeatMode) {
+        if (queue.tracks.length < 1 && !firstPlay && !queue.repeatMode) {
             // Leave the voice channel
             if (this.options.leaveOnEnd && !queue.stopped) queue.voiceConnection.channel.leave()
             // Remove the guild from the guilds list

From ec83e01cde51952fbc2cb62a7bdf34857cd5224b Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 17:41:16 +0200
Subject: [PATCH 33/50] :sparkles: Support playlists

---
 package.json  |  1 +
 src/Player.js | 60 ++++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 48 insertions(+), 13 deletions(-)

diff --git a/package.json b/package.json
index eedcbb1..51d2d43 100644
--- a/package.json
+++ b/package.json
@@ -34,6 +34,7 @@
     "node-fetch": "^2.6.0",
     "simple-youtube-api": "^5.2.1",
     "soundcloud-downloader": "^0.0.9",
+    "ytpl": "^0.1.21",
     "ytsr": "^0.1.15"
   },
   "devDependencies": {
diff --git a/src/Player.js b/src/Player.js
index 96d4512..83b703b 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -1,6 +1,7 @@
 const ytdl = require('discord-ytdl-core')
 const Discord = require('discord.js')
 const ytsr = require('ytsr')
+const ytpl = require('ytpl')
 const scdl = require('soundcloud-downloader')
 
 const Queue = require('./Queue')
@@ -163,6 +164,21 @@ class Player {
      */
     searchTracks (query) {
         return new Promise(async (resolve, reject) => {
+            if (ytpl.validateURL(query)) {
+                const playlistID = await ytpl.getPlaylistID(query).catch(() => {})
+                if (playlistID) {
+                    const playlist = await ytpl(playlistID).catch(() => {})
+                    if (playlist) {
+                        return resolve(playlist.items.map((i) => new Track({
+                            title: i.title,
+                            duration: i.duration,
+                            thumbnail: i.thumbnail,
+                            author: i.author,
+                            link: i.url
+                        }, null, null)))
+                    }
+                }
+            }
             // eslint-disable-next-line no-useless-escape
             const matchURL = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)
             if (matchURL) {
@@ -184,9 +200,9 @@ class Player {
                 }
             }
             ytsr(query, (err, results) => {
-                if (err) return []
+                if (err) return resolve([])
                 const resultsVideo = results.items.filter((i) => i.type === 'video')
-                resolve(resultsVideo.map((r) => new Track(r, null, null)))
+                resolve([new Track(resultsVideo[0], null, null)])
             })
         })
     }
@@ -205,7 +221,7 @@ class Player {
      * @param {Discord.VoiceChannel} voiceChannel The voice channel in which the track will be played
      * @param {Track|string} track The name of the track to play
      * @param {Discord.User?} user The user who requested the track
-     * @returns {Promise<Track>} The played track
+     * @returns {any} The played track
      *
      * @example
      * client.on('message', async (message) => {
@@ -217,8 +233,12 @@ class Player {
      *      // will play "Despacito" in the member voice channel
      *
      *      if(command === 'play'){
-     *          let track = await client.player.play(message.member.voice.channel, args[0], message.member.user.tag);
-     *          message.channel.send(`Currently playing ${track.name}! - Requested by ${track.requestedBy}`);
+     *          const result = await client.player.play(message.member.voice.channel, args.join(" "));
+     *          if(result.type === 'playlist'){
+     *              message.channel.send(`${result.tracks.length} songs added to the queue ${emotes.music}\nCurrently playing **${result.tracks[0].name}**!`);
+     *          } else {
+     *              message.channel.send(`Currently playing ${result.name} ${emotes.music}`);
+     *          }
      *      }
      *
      * });
@@ -230,10 +250,6 @@ class Player {
                 return reject(new Error(`voiceChannel must be type of VoiceChannel. value=${voiceChannel}`))
             }
             const connection = voiceChannel.client.voice.connections.find((c) => c.channel.id === voiceChannel.id) || await voiceChannel.join()
-            if (typeof track !== 'object') {
-                const results = await this.searchTracks(track)
-                track = results[0]
-            }
             // Create a new guild with data
             const queue = new Queue(voiceChannel.guild.id)
             queue.voiceConnection = connection
@@ -241,15 +257,33 @@ class Player {
             Object.keys(filters).forEach((f) => {
                 queue.filters[f] = false
             })
-            // Add the track to the queue
-            track.requestedBy = user
-            queue.tracks.push(track)
+            let result = null
+            if (typeof track === 'object') {
+                track.requestedBy = user
+                result = track
+                // Add the track to the queue
+                queue.tracks.push(track)
+            } else if (typeof track === 'string') {
+                const results = await this.searchTracks(track)
+                if (results.length > 1) {
+                    result = {
+                        type: 'playlist',
+                        tracks: results
+                    }
+                } else {
+                    result = results[0]
+                }
+                results.forEach((i) => {
+                    i.requestedBy = user
+                    queue.tracks.push(i)
+                })
+            }
             // Add the queue to the list
             this.queues.push(queue)
             // Play the track
             this._playTrack(queue.guildID, true)
             // Resolve the track
-            resolve(track)
+            resolve(result)
         })
     }
 

From 5a4714772bebce33caa141d6b5d37b09fc5914ea Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 17:48:25 +0200
Subject: [PATCH 34/50] :sparkles: Add calculatedVolume property

---
 src/Player.js | 6 +++---
 src/Queue.js  | 4 ++++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 83b703b..9d041be 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -406,8 +406,8 @@ class Player {
             const queue = this.queues.find((g) => g.guildID === guildID)
             if (!queue) return reject(new Error('Not playing'))
             // Updates volume
-            queue.voiceConnection.dispatcher.setVolumeLogarithmic(percent / 200)
             queue.volume = percent
+            queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.calculatedVolume / 200)
             // Resolves guild queue
             resolve()
         })
@@ -800,7 +800,7 @@ class Player {
                 queue.voiceConnection.play(newStream, {
                     type: 'opus'
                 })
-                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200)
+                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.calculatedVolume / 200)
                 // When the track starts
                 queue.voiceConnection.dispatcher.on('start', () => {
                     resolve()
@@ -845,7 +845,7 @@ class Player {
                 queue.voiceConnection.play(newStream, {
                     type: 'ogg/opus'
                 })
-                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.volume / 200)
+                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.calculatedVolume / 200)
                 // When the track starts
                 queue.voiceConnection.dispatcher.on('start', () => {
                     resolve()
diff --git a/src/Queue.js b/src/Queue.js
index f102c50..d337d58 100644
--- a/src/Queue.js
+++ b/src/Queue.js
@@ -62,6 +62,10 @@ class Queue extends EventEmitter {
          */
         this.filters = {}
     }
+
+    get calculatedVolume () {
+        return this.filters.bassboost ? this.volume + 40 : this.volume
+    }
 }
 
 module.exports = Queue

From c1dae09be6b58132a6540062a476e869e8c70fc0 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 17:48:38 +0200
Subject: [PATCH 35/50] :bug: Fix updateFilter param

---
 src/Player.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Player.js b/src/Player.js
index 9d041be..a5d0f35 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -772,7 +772,7 @@ class Player {
      * @ignore
      * @private
      * @param {Queue} queue The queue to play
-     * @param {*} updateFilter Whether this method is called to update some ffmpeg filters
+     * @param {Boolean} updateFilter Whether this method is called to update some ffmpeg filters
      * @returns {Promise<void>}
      */
     _playYTDLStream (queue, updateFilter) {

From ef27a34a3097cd14e2dea1cdeb65fc6bf060d9fe Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Wed, 24 Jun 2020 18:07:17 +0200
Subject: [PATCH 36/50] :sparkles: Update documentation and update addToQueue

---
 src/Player.js | 55 +++++++++++++++++++++++++++++++++++----------------
 1 file changed, 38 insertions(+), 17 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index a5d0f35..c8a4165 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -221,7 +221,7 @@ class Player {
      * @param {Discord.VoiceChannel} voiceChannel The voice channel in which the track will be played
      * @param {Track|string} track The name of the track to play
      * @param {Discord.User?} user The user who requested the track
-     * @returns {any} The played track
+     * @returns {any} The played content
      *
      * @example
      * client.on('message', async (message) => {
@@ -450,8 +450,8 @@ class Player {
      * Add a track to the guild queue
      * @param {Discord.Snowflake} guildID The ID of the guild where the track should be added
      * @param {Track|string} trackName The name of the track to add to the queue
-     * @param {Discord.User?} requestedBy The user who requested the track
-     * @returns {Promise<Track>} The added track
+     * @param {Discord.User?} user The user who requested the track
+     * @returns {any} The content added to the queue
      *
      * @example
      * client.on('message', async (message) => {
@@ -463,33 +463,54 @@ class Player {
      *          let trackPlaying = client.player.isPlaying(message.guild.id);
      *          // If there's already a track being played
      *          if(trackPlaying){
-     *              // Add the track to the queue
-     *              let track = await client.player.addToQueue(message.guild.id, args[0]);
-     *              message.channel.send(`${track.name} added to queue!`);
+     *              const result = await client.player.addToQueue(message.guild.id, args.join(" "));
+     *              if(result.type === 'playlist'){
+     *                  message.channel.send(`${result.tracks.length} songs added to the queue ${emotes.music}`);
+     *              } else {
+     *                  message.channel.send(`${result.name} added to the queue ${emotes.music}`);
+     *              }
      *          } else {
      *              // Else, play the track
-     *              let track = await client.player.play(message.member.voice.channel, args[0]);
-     *              message.channel.send(`Currently playing ${track.name}!`);
+     *              const result = await client.player.addToQueue(message.member.voice.channel, args[0]);
+     *              if(result.type === 'playlist'){
+     *                  message.channel.send(`${result.tracks.length} songs added to the queue ${emotes.music}\nCurrently playing **${result.tracks[0].name}**!`);
+     *              } else {
+     *                  message.channel.send(`Currently playing ${result.name} ${emotes.music}`);
+     *              }
      *          }
      *      }
      *
      * });
      */
-    addToQueue (guildID, track, requestedBy) {
+    addToQueue (guildID, track, user) {
         return new Promise(async (resolve, reject) => {
             // Get guild queue
             const queue = this.queues.find((g) => g.guildID === guildID)
             if (!queue) return reject(new Error('Not playing'))
             // Search the track
-            if (typeof track !== 'object') {
+            let result = null
+            if (typeof track === 'object') {
+                track.requestedBy = user
+                result = track
+                // Add the track to the queue
+                queue.tracks.push(track)
+            } else if (typeof track === 'string') {
                 const results = await this.searchTracks(track)
-                track = results[0]
+                if (results.length > 1) {
+                    result = {
+                        type: 'playlist',
+                        tracks: results
+                    }
+                } else {
+                    result = results[0]
+                }
+                results.forEach((i) => {
+                    i.requestedBy = user
+                    queue.tracks.push(i)
+                })
             }
-            track.requestedBy = requestedBy
-            // Update queue
-            queue.tracks.push(track)
-            // Resolve the track
-            resolve(track)
+            // Resolve the result
+            resolve(result)
         })
     }
 
@@ -819,7 +840,7 @@ class Player {
      * @ignore
      * @private
      * @param {Queue} queue The queue to play
-     * @param {*} updateFilter Whether this method is called to update some ffmpeg filters
+     * @param {Boolean} updateFilter Whether this method is called to update some ffmpeg filters
      * @returns {Promise<void>}
      */
     _playSouncloudStream (queue, updateFilter) {

From d47be162d7ccdb722a0bbf727504de9f99bad904 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Thu, 25 Jun 2020 18:03:37 +0200
Subject: [PATCH 37/50] :bug: Fix trackChanged event

---
 src/Player.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Player.js b/src/Player.js
index c8a4165..a50aee2 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -921,7 +921,7 @@ class Player {
         this._playYTDLStream(queue, false).then(() => {
             // Emit trackChanged event
             if (!firstPlay) {
-                queue.emit('trackChanged', nowPlaying, wasPlaying, queue.lastSkipped, queue.repeatMode)
+                queue.emit('trackChanged', wasPlaying, nowPlaying, queue.lastSkipped, queue.repeatMode)
             }
         })
     }

From 7783e423e9f97fd82dd0c993ca80d9a84aa54adb Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Thu, 25 Jun 2020 18:06:01 +0200
Subject: [PATCH 38/50] :fire: Temporarily remove support for soundcloud

---
 package.json  |  1 -
 src/Player.js | 74 +--------------------------------------------------
 2 files changed, 1 insertion(+), 74 deletions(-)

diff --git a/package.json b/package.json
index 51d2d43..fb8d35f 100644
--- a/package.json
+++ b/package.json
@@ -33,7 +33,6 @@
     "merge-options": "^2.0.0",
     "node-fetch": "^2.6.0",
     "simple-youtube-api": "^5.2.1",
-    "soundcloud-downloader": "^0.0.9",
     "ytpl": "^0.1.21",
     "ytsr": "^0.1.15"
   },
diff --git a/src/Player.js b/src/Player.js
index a50aee2..3941297 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -2,7 +2,6 @@ const ytdl = require('discord-ytdl-core')
 const Discord = require('discord.js')
 const ytsr = require('ytsr')
 const ytpl = require('ytpl')
-const scdl = require('soundcloud-downloader')
 
 const Queue = require('./Queue')
 const Track = require('./Track')
@@ -45,7 +44,6 @@ const filters = {
  * @property {boolean} [leaveOnEnd=true] Whether the bot should leave the current voice channel when the queue ends.
  * @property {boolean} [leaveOnStop=true] Whether the bot should leave the current voice channel when the stop() function is used.
  * @property {boolean} [leaveOnEmpty=true] Whether the bot should leave the voice channel if there is no more member in it.
- * @property {string} [soundcloudClientID=""] The client ID for Soundcloud, optional
  */
 
 /**
@@ -56,8 +54,7 @@ const filters = {
 const defaultPlayerOptions = {
     leaveOnEnd: true,
     leaveOnStop: true,
-    leaveOnEmpty: true,
-    soundcloudClientID: ''
+    leaveOnEmpty: true
 }
 
 class Player {
@@ -183,21 +180,6 @@ class Player {
             const matchURL = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)
             if (matchURL) {
                 query = matchURL[1]
-            } else if (this.options.soundcloudClientID) {
-                const scRegex = /^https?:\/\/(soundcloud\.com)\/(.*)$/
-                if (query.match(scRegex) && query.match(scRegex)[2]) {
-                    const info = await scdl.getInfo(query, this.options.soundcloudClientID)
-                    const details = {
-                        title: info.title,
-                        link: info.uri,
-                        duration: info.duration,
-                        description: info.description,
-                        thumbnail: info.artwork_url,
-                        views: info.playback_count,
-                        author: { name: info.user.username }
-                    }
-                    return resolve([new Track(details, null, null)])
-                }
             }
             ytsr(query, (err, results) => {
                 if (err) return resolve([])
@@ -835,51 +817,6 @@ class Player {
         })
     }
 
-    /**
-     * Play a Soundcloud stream in a channel
-     * @ignore
-     * @private
-     * @param {Queue} queue The queue to play
-     * @param {Boolean} updateFilter Whether this method is called to update some ffmpeg filters
-     * @returns {Promise<void>}
-     */
-    _playSouncloudStream (queue, updateFilter) {
-        return new Promise(async (resolve) => {
-            const currentStreamTime = updateFilter ? queue.voiceConnection.dispatcher.streamTime / 1000 : undefined
-            const encoderArgsFilters = []
-            Object.keys(queue.filters).forEach((filterName) => {
-                if (queue.filters[filterName]) {
-                    encoderArgsFilters.push(filters[filterName])
-                }
-            })
-            let encoderArgs
-            if (encoderArgsFilters.length < 1) {
-                encoderArgs = []
-            } else {
-                encoderArgs = ['-af', encoderArgsFilters.join(',')]
-            }
-
-            const info = await scdl.getInfo(queue.playing.url, this.options.soundcloudClientID)
-            const opus = scdl.filterMedia(info.media.transcodings, { format: scdl.FORMATS.OPUS })
-            const newStream = await scdl.downloadFromURL(opus[0].url, this.options.soundcloudClientID)
-            setTimeout(() => {
-                queue.voiceConnection.play(newStream, {
-                    type: 'ogg/opus'
-                })
-                queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.calculatedVolume / 200)
-                // When the track starts
-                queue.voiceConnection.dispatcher.on('start', () => {
-                    resolve()
-                })
-                // When the track ends
-                queue.voiceConnection.dispatcher.on('finish', () => {
-                    // Play the next track
-                    return this._playTrack(queue.guildID, false)
-                })
-            }, 1000)
-        })
-    }
-
     /**
      * Start playing a track in a guild
      * @ignore
@@ -909,15 +846,6 @@ class Player {
         // Reset lastSkipped state
         queue.lastSkipped = false
 
-        if (queue.playing.url.includes('soundcloud.com')) {
-            this._playSouncloudStream(queue, false).then(() => {
-                // Emit trackChanged event
-                if (!firstPlay) {
-                    queue.emit('trackChanged', nowPlaying, wasPlaying, queue.lastSkipped, queue.repeatMode)
-                }
-            })
-            return
-        }
         this._playYTDLStream(queue, false).then(() => {
             // Emit trackChanged event
             if (!firstPlay) {

From 3b78249c769d00b0c03d50ee27020e7075334fbf Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Thu, 25 Jun 2020 18:34:41 +0200
Subject: [PATCH 39/50] :bug: Add some errors for track not found

---
 src/Player.js | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index 3941297..87e74c0 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -182,6 +182,7 @@ class Player {
                 query = matchURL[1]
             }
             ytsr(query, (err, results) => {
+                if (results.items.length < 1) return resolve([])
                 if (err) return resolve([])
                 const resultsVideo = results.items.filter((i) => i.type === 'video')
                 resolve([new Track(resultsVideo[0], null, null)])
@@ -246,14 +247,19 @@ class Player {
                 // Add the track to the queue
                 queue.tracks.push(track)
             } else if (typeof track === 'string') {
-                const results = await this.searchTracks(track)
+                const results = await this.searchTracks(track).catch(() => {
+                    return reject(new Error('Not found'))
+                })
+                if (!results) return
                 if (results.length > 1) {
                     result = {
                         type: 'playlist',
                         tracks: results
                     }
-                } else {
+                } else if (results[0]) {
                     result = results[0]
+                } else {
+                    return reject(new Error('Not found'))
                 }
                 results.forEach((i) => {
                     i.requestedBy = user
@@ -477,14 +483,19 @@ class Player {
                 // Add the track to the queue
                 queue.tracks.push(track)
             } else if (typeof track === 'string') {
-                const results = await this.searchTracks(track)
+                const results = await this.searchTracks(track).catch(() => {
+                    return reject(new Error('Not found'))
+                })
+                if (!results) return
                 if (results.length > 1) {
                     result = {
                         type: 'playlist',
                         tracks: results
                     }
-                } else {
+                } else if (results[0]) {
                     result = results[0]
+                } else {
+                    return reject(new Error('Not found'))
                 }
                 results.forEach((i) => {
                     i.requestedBy = user

From aa1b364a2e01b206c7ff9100b1564a3ad5bbc23f Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Thu, 25 Jun 2020 18:46:24 +0200
Subject: [PATCH 40/50] Merge

---
 src/Player.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Player.js b/src/Player.js
index 87e74c0..1d378a7 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -811,6 +811,8 @@ class Player {
                 seek: currentStreamTime
             })
             setTimeout(() => {
+                if (queue.stream) queue.stream.destroy()
+                queue.stream = newStream
                 queue.voiceConnection.play(newStream, {
                     type: 'opus'
                 })
@@ -856,7 +858,6 @@ class Player {
         const nowPlaying = queue.playing = queue.repeatMode ? wasPlaying : queue.tracks.shift()
         // Reset lastSkipped state
         queue.lastSkipped = false
-
         this._playYTDLStream(queue, false).then(() => {
             // Emit trackChanged event
             if (!firstPlay) {

From e1d1c86c63cb7439537a04159c6bbe5070279128 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Thu, 25 Jun 2020 18:49:12 +0200
Subject: [PATCH 41/50] :bug: Fix views type on track class

---
 src/Track.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Track.js b/src/Track.js
index d357230..91cf172 100644
--- a/src/Track.js
+++ b/src/Track.js
@@ -38,6 +38,7 @@ class Track {
         this.thumbnail = videoData.thumbnail
         /**
          * The video views
+         * @type {?number}
          */
         this.views = videoData.views
         /**

From 53c58f3140ec3d11a69290babf414eefa03cdfc9 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Thu, 25 Jun 2020 18:56:05 +0200
Subject: [PATCH 42/50] :see_no_evil: Add docs and vscode folder to gitignore

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index dc10c68..a74d490 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@ node_modules
 poc.js
 package-lock.json
 yarn.lock
+docs
+.vscode

From 5b6d1c496b6a7328813a810aebff4761cfb64cec Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Thu, 25 Jun 2020 19:04:59 +0200
Subject: [PATCH 43/50] :bug: Add currentStreamTime to dispatcher time

---
 src/Player.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Player.js b/src/Player.js
index 1d378a7..9235da6 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -816,6 +816,9 @@ class Player {
                 queue.voiceConnection.play(newStream, {
                     type: 'opus'
                 })
+                if (currentStreamTime) {
+                    queue.voiceConnection.dispatcher.streamTime += currentStreamTime
+                }
                 queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.calculatedVolume / 200)
                 // When the track starts
                 queue.voiceConnection.dispatcher.on('start', () => {

From a0cdcbc46184386d1bc08c82d026d2db3f1a5819 Mon Sep 17 00:00:00 2001
From: Snowflake <46562212+Snowflake107@users.noreply.github.com>
Date: Sat, 4 Jul 2020 17:08:49 +0545
Subject: [PATCH 44/50] Spotify support & bug fixes (#40)

Co-authored-by: Androz2091 <androz2091@gmail.com>
---
 package.json  |   8 +-
 src/Player.js |  20 ++--
 src/Queue.js  | 258 +++++++++++++++++++++++++-------------------------
 src/Track.js  |   5 +
 4 files changed, 152 insertions(+), 139 deletions(-)

diff --git a/package.json b/package.json
index fb8d35f..e8e8e04 100644
--- a/package.json
+++ b/package.json
@@ -28,16 +28,16 @@
   },
   "homepage": "https://github.com/Androz2091/discord-player#readme",
   "dependencies": {
-    "@discordjs/opus": "^0.3.2",
     "discord-ytdl-core": "^4.0.2",
     "merge-options": "^2.0.0",
     "node-fetch": "^2.6.0",
-    "simple-youtube-api": "^5.2.1",
-    "ytpl": "^0.1.21",
+    "spotify-url-info": "^1.3.1",
+    "ytpl": "^0.1.22",
     "ytsr": "^0.1.15"
   },
   "devDependencies": {
-    "discord.js": "discordjs/discord.js",
+    "@discordjs/opus": "^0.3.2",
+    "discord.js": "^12.2.0",
     "eslint": "^7.1.0",
     "eslint-config-standard": "^14.1.1",
     "eslint-plugin-import": "^2.20.2",
diff --git a/src/Player.js b/src/Player.js
index 9235da6..db3743b 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -2,7 +2,7 @@ const ytdl = require('discord-ytdl-core')
 const Discord = require('discord.js')
 const ytsr = require('ytsr')
 const ytpl = require('ytpl')
-
+const spotify = require('spotify-url-info')
 const Queue = require('./Queue')
 const Track = require('./Track')
 
@@ -176,10 +176,15 @@ class Player {
                     }
                 }
             }
+            const matchSpotifyURL = query.match(/https?:\/\/(?:embed\.|open\.)(?:spotify\.com\/)(?:track\/|\?uri=spotify:track:)((\w|-){22})/)
+            if (matchSpotifyURL) {
+                const spotifyData = await spotify.getPreview(query).catch(e => resolve([]))
+                query = `${spotifyData.artist} - ${spotifyData.track}`
+            }
             // eslint-disable-next-line no-useless-escape
-            const matchURL = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)
-            if (matchURL) {
-                query = matchURL[1]
+            const matchYoutubeURL = query.match(/(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/)
+            if (matchYoutubeURL) {
+                query = matchYoutubeURL[1]
             }
             ytsr(query, (err, results) => {
                 if (results.items.length < 1) return resolve([])
@@ -814,10 +819,11 @@ class Player {
                 if (queue.stream) queue.stream.destroy()
                 queue.stream = newStream
                 queue.voiceConnection.play(newStream, {
-                    type: 'opus'
+                    type: 'opus',
+                    bitrate: 'auto'
                 })
                 if (currentStreamTime) {
-                    queue.voiceConnection.dispatcher.streamTime += currentStreamTime
+                    queue.playing.streamTime += currentStreamTime
                 }
                 queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.calculatedVolume / 200)
                 // When the track starts
@@ -826,6 +832,8 @@ class Player {
                 })
                 // When the track ends
                 queue.voiceConnection.dispatcher.on('finish', () => {
+                    // reset streamTime
+                    if (queue.repeatMode) queue.playing.streamTime = 0
                     // Play the next track
                     return this._playTrack(queue.guildID, false)
                 })
diff --git a/src/Queue.js b/src/Queue.js
index d337d58..86a4f94 100644
--- a/src/Queue.js
+++ b/src/Queue.js
@@ -1,129 +1,129 @@
-const Discord = require('discord.js')
-const { EventEmitter } = require('events')
-const Track = require('./Track')
-
-/**
- * Represents a guild queue.
- */
-class Queue extends EventEmitter {
-    /**
-     * @param {Discord.Snowflake} guildID ID of the guild this queue is for.
-     */
-    constructor (guildID) {
-        super()
-        /**
-         * ID of the guild this queue is for.
-         * @type {Discord.Snowflake}
-         */
-        this.guildID = guildID
-        /**
-         * The voice connection of this queue.
-         * @type {Discord.VoiceConnection}
-         */
-        this.voiceConnection = null
-        /**
-         * The song currently played.
-         * @type {Track}
-         */
-        this.playing = null
-        /**
-         * The tracks of this queue. The first one is currenlty playing and the others are going to be played.
-         * @type {Track[]}
-         */
-        this.tracks = []
-        /**
-         * Whether the stream is currently stopped.
-         * @type {boolean}
-         */
-        this.stopped = false
-        /**
-         * Whether the last track was skipped.
-         * @type {boolean}
-         */
-        this.lastSkipped = false
-        /**
-         * The stream volume of this queue. (0-100)
-         * @type {number}
-         */
-        this.volume = 100
-        /**
-         * Whether the stream is currently paused.
-         * @type {boolean}
-         */
-        this.paused = true
-        /**
-         * Whether the repeat mode is enabled.
-         * @type {boolean}
-         */
-        this.repeatMode = false
-        /**
-         * Filters status
-         * @type {Object}
-         */
-        this.filters = {}
-    }
-
-    get calculatedVolume () {
-        return this.filters.bassboost ? this.volume + 40 : this.volume
-    }
-}
-
-module.exports = Queue
-
-/**
- * Emitted when the queue is empty.
- * @event Queue#end
- *
- * @example
- * client.on('message', (message) => {
- *
- *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
- *      const command = args.shift().toLowerCase();
- *
- *      if(command === 'play'){
- *
- *          let track = await client.player.play(message.member.voice.channel, args[0]);
- *
- *          track.queue.on('end', () => {
- *              message.channel.send('The queue is empty, please add new tracks!');
- *          });
- *
- *      }
- *
- * });
- */
-
-/**
- * Emitted when the voice channel is empty.
- * @event Queue#channelEmpty
- */
-
-/**
- * Emitted when the track changes.
- * @event Queue#trackChanged
- * @param {Track} oldTrack The old track (playing before)
- * @param {Track} newTrack The new track (currently playing)
- * @param {Boolean} skipped Whether the change is due to the skip() function
- *
- * @example
- * client.on('message', (message) => {
- *
- *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
- *      const command = args.shift().toLowerCase();
- *
- *      if(command === 'play'){
- *
- *          let track = await client.player.play(message.member.voice.channel, args[0]);
- *
- *          track.queue.on('trackChanged', (oldTrack, newTrack, skipped, repeatMode) => {
- *              if(repeatMode){
- *                  message.channel.send(`Playing ${newTrack} again...`);
- *              } else {
- *                  message.channel.send(`Now playing ${newTrack}...`);
- *              }
- *          });
- *
- *      }
- *
- * });
- */
+const Discord = require('discord.js')
+const { EventEmitter } = require('events')
+const Track = require('./Track')
+
+/**
+ * Represents a guild queue.
+ */
+class Queue extends EventEmitter {
+    /**
+     * @param {Discord.Snowflake} guildID ID of the guild this queue is for.
+     */
+    constructor (guildID) {
+        super()
+        /**
+         * ID of the guild this queue is for.
+         * @type {Discord.Snowflake}
+         */
+        this.guildID = guildID
+        /**
+         * The voice connection of this queue.
+         * @type {Discord.VoiceConnection}
+         */
+        this.voiceConnection = null
+        /**
+         * The song currently played.
+         * @type {Track}
+         */
+        this.playing = null
+        /**
+         * The tracks of this queue. The first one is currenlty playing and the others are going to be played.
+         * @type {Track[]}
+         */
+        this.tracks = []
+        /**
+         * Whether the stream is currently stopped.
+         * @type {boolean}
+         */
+        this.stopped = false
+        /**
+         * Whether the last track was skipped.
+         * @type {boolean}
+         */
+        this.lastSkipped = false
+        /**
+         * The stream volume of this queue. (0-100)
+         * @type {number}
+         */
+        this.volume = 100
+        /**
+         * Whether the stream is currently paused.
+         * @type {boolean}
+         */
+        this.paused = true
+        /**
+         * Whether the repeat mode is enabled.
+         * @type {boolean}
+         */
+        this.repeatMode = false
+        /**
+         * Filters status
+         * @type {Object}
+         */
+        this.filters = {}
+    }
+
+    get calculatedVolume () {
+        return this.filters.bassboost ? this.volume + 50 : this.volume
+    }
+}
+
+module.exports = Queue
+
+/**
+ * Emitted when the queue is empty.
+ * @event Queue#end
+ *
+ * @example
+ * client.on('message', (message) => {
+ *
+ *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+ *      const command = args.shift().toLowerCase();
+ *
+ *      if(command === 'play'){
+ *
+ *          let track = await client.player.play(message.member.voice.channel, args[0]);
+ *
+ *          track.queue.on('end', () => {
+ *              message.channel.send('The queue is empty, please add new tracks!');
+ *          });
+ *
+ *      }
+ *
+ * });
+ */
+
+/**
+ * Emitted when the voice channel is empty.
+ * @event Queue#channelEmpty
+ */
+
+/**
+ * Emitted when the track changes.
+ * @event Queue#trackChanged
+ * @param {Track} oldTrack The old track (playing before)
+ * @param {Track} newTrack The new track (currently playing)
+ * @param {Boolean} skipped Whether the change is due to the skip() function
+ *
+ * @example
+ * client.on('message', (message) => {
+ *
+ *      const args = message.content.slice(settings.prefix.length).trim().split(/ +/g);
+ *      const command = args.shift().toLowerCase();
+ *
+ *      if(command === 'play'){
+ *
+ *          let track = await client.player.play(message.member.voice.channel, args[0]);
+ *
+ *          track.queue.on('trackChanged', (oldTrack, newTrack, skipped, repeatMode) => {
+ *              if(repeatMode){
+ *                  message.channel.send(`Playing ${newTrack} again...`);
+ *              } else {
+ *                  message.channel.send(`Now playing ${newTrack}...`);
+ *              }
+ *          });
+ *
+ *      }
+ *
+ * });
+ */
diff --git a/src/Track.js b/src/Track.js
index 91cf172..ce5e218 100644
--- a/src/Track.js
+++ b/src/Track.js
@@ -56,6 +56,11 @@ class Track {
          * @type {Queue}
          */
         this.queue = queue
+
+        /**
+         * Stream time of the track (available on applying filters)
+         */
+        this.streamTime = 0
     }
 
     /**

From 27e28ef41f6d6917f209b3e90acd1886f43d4024 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sat, 4 Jul 2020 14:34:00 +0200
Subject: [PATCH 45/50] :zap: Improve stream time calculation

---
 src/Player.js | 10 +++++-----
 src/Queue.js  |  5 +++++
 src/Track.js  |  5 -----
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/Player.js b/src/Player.js
index db3743b..0aa0762 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -746,7 +746,7 @@ class Player {
         const queue = this.queues.find((g) => g.guildID === guildID)
         if (!queue) return
         // Stream time of the dispatcher
-        const currentStreamTime = queue.voiceConnection.dispatcher.streamTime
+        const currentStreamTime = queue.calculatedStreamTime
         // Total stream time
         const totalTime = queue.playing.durationMS
         // Stream progress
@@ -813,7 +813,7 @@ class Player {
                 filter: 'audioonly',
                 opusEncoded: true,
                 encoderArgs,
-                seek: currentStreamTime
+                seek: currentStreamTime + queue.additionalStreamTime
             })
             setTimeout(() => {
                 if (queue.stream) queue.stream.destroy()
@@ -823,7 +823,7 @@ class Player {
                     bitrate: 'auto'
                 })
                 if (currentStreamTime) {
-                    queue.playing.streamTime += currentStreamTime
+                    queue.additionalStreamTime += currentStreamTime
                 }
                 queue.voiceConnection.dispatcher.setVolumeLogarithmic(queue.calculatedVolume / 200)
                 // When the track starts
@@ -832,8 +832,8 @@ class Player {
                 })
                 // When the track ends
                 queue.voiceConnection.dispatcher.on('finish', () => {
-                    // reset streamTime
-                    if (queue.repeatMode) queue.playing.streamTime = 0
+                    // Reset streamTime
+                    queue.additionalStreamTime = 0
                     // Play the next track
                     return this._playTrack(queue.guildID, false)
                 })
diff --git a/src/Queue.js b/src/Queue.js
index 86a4f94..8f50d22 100644
--- a/src/Queue.js
+++ b/src/Queue.js
@@ -61,6 +61,11 @@ class Queue extends EventEmitter {
          * @type {Object}
          */
         this.filters = {}
+        /**
+         * Additional stream time
+         * @type {Number}
+         */
+        this.additionalStreamTime = 0
     }
 
     get calculatedVolume () {
diff --git a/src/Track.js b/src/Track.js
index ce5e218..91cf172 100644
--- a/src/Track.js
+++ b/src/Track.js
@@ -56,11 +56,6 @@ class Track {
          * @type {Queue}
          */
         this.queue = queue
-
-        /**
-         * Stream time of the track (available on applying filters)
-         */
-        this.streamTime = 0
     }
 
     /**

From 6b609719e17f313a425cf65cc85ebf221689e593 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sat, 4 Jul 2020 15:11:18 +0200
Subject: [PATCH 46/50] :construction_worker: Add cname and remove source dir

---
 .github/workflows/main.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index bd1818b..b3beb3d 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -15,14 +15,14 @@ jobs:
       - name: Build
         uses: andstor/jsdoc-action@v1
         with:
-          source_dir: ./src
           output_dir: ./docs
           config_file: .jsdoc.json
-          template_name: Androz2091/minami
+          template: Androz2091/minami
           front_page: README.md
 
       - name: Deploy
         uses: peaceiris/actions-gh-pages@v3
         with:
           personal_token: ${{ secrets.ACTIONS_DEPLOY_KEY }}
-          publish_dir: ./docs
\ No newline at end of file
+          publish_dir: ./docs
+          cname: discord-player.js.org
\ No newline at end of file

From a4865ed4c4cdf8990bccdcd5793a42e5bc4333d0 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sat, 4 Jul 2020 15:11:50 +0200
Subject: [PATCH 47/50] :construction_worker: Rename workflow to jsdoc-deploy

---
 .github/workflows/{main.yml => jsdoc-deploy.yml} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename .github/workflows/{main.yml => jsdoc-deploy.yml} (93%)

diff --git a/.github/workflows/main.yml b/.github/workflows/jsdoc-deploy.yml
similarity index 93%
rename from .github/workflows/main.yml
rename to .github/workflows/jsdoc-deploy.yml
index b3beb3d..1610ebd 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/jsdoc-deploy.yml
@@ -25,4 +25,4 @@ jobs:
         with:
           personal_token: ${{ secrets.ACTIONS_DEPLOY_KEY }}
           publish_dir: ./docs
-          cname: discord-player.js.org
\ No newline at end of file
+          cname: discord-player.js.org

From f3b8342603e89fc41d1fd8ed9fd92b89e486b230 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sat, 4 Jul 2020 15:22:10 +0200
Subject: [PATCH 48/50] :sparkles: Add Player#filters property

---
 src/Player.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/Player.js b/src/Player.js
index 0aa0762..c1610d1 100644
--- a/src/Player.js
+++ b/src/Player.js
@@ -83,6 +83,11 @@ class Player {
         for (const prop in options) {
             this.options[prop] = options[prop]
         }
+        /**
+         * Default filters for the queues created with this player.
+         * @type {Filters}
+         */
+        this.filters = filters
 
         // Listener to check if the channel is empty
         client.on('voiceStateUpdate', (oldState, newState) => this._handleVoiceStateUpdate(oldState, newState))
@@ -242,7 +247,7 @@ class Player {
             const queue = new Queue(voiceChannel.guild.id)
             queue.voiceConnection = connection
             queue.filters = {}
-            Object.keys(filters).forEach((f) => {
+            Object.keys(this.filters).forEach((f) => {
                 queue.filters[f] = false
             })
             let result = null

From bb527cc2e1ed599843329fa880f43f6b8f55080d Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sat, 4 Jul 2020 15:22:19 +0200
Subject: [PATCH 49/50] :bug: Fix Queue#filters type

---
 src/Queue.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Queue.js b/src/Queue.js
index 8f50d22..d28ef42 100644
--- a/src/Queue.js
+++ b/src/Queue.js
@@ -58,7 +58,7 @@ class Queue extends EventEmitter {
         this.repeatMode = false
         /**
          * Filters status
-         * @type {Object}
+         * @type {Filters}
          */
         this.filters = {}
         /**

From ffc10091fd1818b33d2b661b54e8acf51ebd9ab4 Mon Sep 17 00:00:00 2001
From: Androz2091 <androz2091@gmail.com>
Date: Sat, 4 Jul 2020 15:24:05 +0200
Subject: [PATCH 50/50] :pencil: Add missing line break

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2470b7a..0b488e0 100644
--- a/README.md
+++ b/README.md
@@ -26,7 +26,7 @@ Install [FFMPEG](https://www.ffmpeg.org/download.html) and you're done!
 
 🤘 Easy to use!  
 🎸 You can apply some cool filters (bassboost, reverse, 8D, etc...)  
-🎼 Manage your server queues with simple functions (add songs, skip the current song, pause the music, resume it, etc...)!
+🎼 Manage your server queues with simple functions (add songs, skip the current song, pause the music, resume it, etc...)!  
 🌐 Multi-servers support
 
 ## Getting Started