aqualink 1.4.2 → 1.5.1

package/README.md

@@ -25,14 +25,15 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 
 - Example bot: https://github.com/ToddyTheNoobDud/Thorium-Music
 
-# Yay, Version 1.4.2 is released, wow
-
-- Rewrited CONNECTION manager (This fixes Bad request, Fixes sessionId, json responses from lavalink, and other bugfixes)
-- Fixed skip in Player, Fixed Destroy, Fixed desconnection, Fixed stop, And added some optimizations
-- Added clean this.voice on Aqua manager
-- Fixed Destroy sending embeds / text if there is an queue
-- Fixed stop / destroy sending all the texts (songs in queue)
-- Optimized the track handling
+# Yay, Version 1.5.0 || 1.5.1 is released, wow
+
+- Optimized memory usage in `FetchImage` by removing unnecessary code and saving, addressing some memory leaks.
+- Updated `AQUA` with additional cleanup options, faster response arrays, Remade `ConstructResponse` and `resolve`, and improved the `UpdateVoice` handler.
+- Updated `CONNECTION` to fix bugs, improve the cleanup system, and Improve speed.
+- Improved cleanup in the `NODE` manager and fixed issues for VPS.
+- Rewrited the `TRACK` handler for better speed by removing redundant checks and code.
+- REMADE the `PLAYER` system to fix bugs, resolve message sending issues, Fixes `EventEmitter` memory leaks (also Fixes `AQUA`), remove unnecessary JSDoc comments, rewrite some methods, and enhance cleanup.
+- 1.5.1 : Fully fixed destroy and the queue handling for delete, also now it deletes from lavalink...
 
 # How to install
 

package/build/handlers/fetchImage.js

@@ -23,11 +23,10 @@ async function getImageUrl(info) {
 async function fetchThumbnail(url) {
     try {
         const response = await request(url, { method: "GET" });
-        if (response.ok) {
-            const json = await response.json();
-            return json.thumbnail_url || null;
-        }
-        return null;
+        const json = await response.json();
+        response.body.destroy();
+
+        return json.thumbnail_url || null;
     } catch (error) {
         console.error(`Error fetching ${url}:`, error);
         return null;

package/build/structures/Aqua.js

@@ -5,6 +5,16 @@ const { Track } = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 
 class Aqua extends EventEmitter {
+    /**
+     * @param {Object} client - The client instance.
+     * @param {Array<Object>} nodes - An array of node configurations.
+     * @param {Object} options - Configuration options for Aqua.
+     * @param {Function} options.send - Function to send data.
+     * @param {string} [options.defaultSearchPlatform="ytsearch"] - Default search platform.
+     * @param {string} [options.restVersion="v4"] - Version of the REST API.
+     * @param {Array<Object>} [options.plugins=[]] - Plugins to load.
+     * @param {string} [options.shouldDeleteMessage='none'] - Should delete your message? (true, false)
+     */
     constructor(client, nodes, options) {
         super();
         this.validateInputs(client, nodes, options);
@@ -16,21 +26,22 @@ class Aqua extends EventEmitter {
         this.initiated = false;
         this.shouldDeleteMessage = options.shouldDeleteMessage || false;
         this.defaultSearchPlatform = options.defaultSearchPlatform || "ytsearch";
-        this.restVersion = options.restVersion || "v3";
+        this.restVersion = options.restVersion || "v4";
         this.plugins = options.plugins || [];
         this.version = pkgVersion;
         this.options = options;
         this.send = options.send;
+        this.setMaxListeners(0);
     }
 
     validateInputs(client, nodes, options) {
         if (!client) throw new Error("Client is required to initialize Aqua");
         if (!Array.isArray(nodes) || nodes.length === 0) throw new Error(`Nodes must be a non-empty Array (Received ${typeof nodes})`);
-        if (typeof options.send !== "function") throw new Error("Send function is required to initialize Aqua");
+        if (typeof options?.send !== "function") throw new Error("Send function is required to initialize Aqua");
     }
 
     get leastUsedNodes() {
-        return [...this.nodeMap.values()]
+        return Array.from(this.nodeMap.values())
             .filter(node => node.connected)
             .sort((a, b) => a.rest.calls - b.rest.calls);
     }
@@ -63,14 +74,10 @@ class Aqua extends EventEmitter {
 
     updateVoiceState(packet) {
         const player = this.players.get(packet.d.guild_id);
-        if (player) {
-            if (packet.t === "VOICE_SERVER_UPDATE") {
-                player.connection.setServerUpdate(packet.d);
-            } else if (packet.t === "VOICE_STATE_UPDATE" && packet.d.user_id === this.clientId) {
-                player.connection.setStateUpdate(packet.d);
-                if (packet.d.status === "disconnected") {
-                    this.cleanupPlayer(player); // Cleanup when disconnected
-                }
+        if (player && (packet.t === "VOICE_SERVER_UPDATE" || packet.t === "VOICE_STATE_UPDATE" && packet.d.user_id === this.clientId)) {
+            player.connection[packet.t === "VOICE_SERVER_UPDATE" ? "setServerUpdate" : "setStateUpdate"](packet.d);
+            if (packet.d.status === "disconnected") {
+                this.cleanupPlayer(player); // Cleanup when disconnected
             }
         }
     }
@@ -98,6 +105,7 @@ class Aqua extends EventEmitter {
     createPlayer(node, options) {
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
+        player.setMaxListeners(0);
         player.connect(options);
         player.on("destroy", () => this.cleanupPlayer(player)); // Listen for player destruction
         this.emit("playerCreate", player);
@@ -114,20 +122,10 @@ class Aqua extends EventEmitter {
         }
     }
 
-    /**
-     * Resolve a track into an array of {@link Track} objects.
-     *
-     * @param {Object} options - The options for the resolve operation.
-     * @param {string} options.query - The query to search for.
-     * @param {string} [options.source] - The source to use for the search. Defaults to the bot's default search platform.
-     * @param {GuildMember} options.requester - The member who requested the track.
-     * @param {Node[]} [options.nodes] - The nodes to prioritize for the search. Defaults to all nodes.
-     * @returns {Promise<Track[]>} The resolved tracks.
-     */
-    async resolve({ query, source, requester, nodes }) {
+    async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
         this.ensureInitialized();
         const requestNode = this.getRequestNode(nodes);
-        const formattedQuery = this.formatQuery(query, source || this.defaultSearchPlatform);
+        const formattedQuery = this.formatQuery(query, source);
         try {
             let response = await requestNode.rest.makeRequest("GET", `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`);
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
@@ -157,11 +155,11 @@ class Aqua extends EventEmitter {
 
     async handleNoMatches(rest, query) {
         try {
-            const spotifyResponse = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
-            if (["empty", "NO_MATCHES"].includes(spotifyResponse.loadType)) {
-                return await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
+            const youtubeResponse = await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://www.youtube.com/watch?v=${query}`);
+            if (["empty", "NO_MATCHES"].includes(youtubeResponse.loadType)) {
+                return await rest.makeRequest("GET", `/v4/loadtracks?identifier=https://open.spotify.com/track/${query}`);
             }
-            return spotifyResponse;
+            return youtubeResponse;
         } catch (error) {
             console.error("Error handling no matches:", error);
             throw new Error("Failed to handle no matches");
@@ -176,26 +174,28 @@ class Aqua extends EventEmitter {
             pluginInfo: response.pluginInfo || {},
             tracks: [],
         };
-        switch (response.loadType) {
+        const { loadType, data } = response;
+        if (loadType === "error" || loadType === "LOAD_FAILED") {
+            baseResponse.exception = data || response.exception;
+            return baseResponse;
+        }
+        switch (loadType) {
             case "track":
-                if (response.data) {
-                    baseResponse.tracks.push(new Track(response.data, requester, requestNode));
+                if (data) {
+                    baseResponse.tracks.push(new Track(data, requester, requestNode));
                 }
                 break;
             case "playlist":
                 baseResponse.playlistInfo = {
-                    name: response.data?.info?.name || response.data?.info?.title,
-                    ...response.data?.info,
+                    name: data?.info?.name || data?.info?.title,
+                    ...data?.info,
                 };
-                baseResponse.tracks = response.data?.tracks?.map(track => new Track(track, requester, requestNode)) || [];
+                baseResponse.tracks = (data?.tracks || []).map(track => new Track(track, requester, requestNode));
                 break;
             case "search":
-                baseResponse.tracks = response.data?.map(track => new Track(track, requester, requestNode)) || [];
+                baseResponse.tracks = (data || []).map(track => new Track(track, requester, requestNode));
                 break;
         }
-        if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
-            baseResponse.exception = response.loadType.data || response.loadType.exception;
-        }
         return baseResponse;
     }
 
@@ -208,9 +208,7 @@ class Aqua extends EventEmitter {
     cleanupIdle() {
         for (const [guildId, player] of this.players) {
             if (!player.playing && !player.paused && player.queue.isEmpty()) {
-                player.destroy();
-                this.players.delete(guildId);
-                this.emit("playerDestroy", player);
+                this.cleanupPlayer(player);
             }
         }
     }
@@ -219,11 +217,27 @@ class Aqua extends EventEmitter {
         if (player) {
             player.clearData();
             player.destroy();
-            this.voice = null
             this.players.delete(player.guildId);
             this.emit("playerDestroy", player);
         }
     }
+
+    cleanup() {
+        for (const player of this.players.values()) {
+            this.cleanupPlayer(player);
+        }
+        for (const node of this.nodeMap.values()) {
+            this.destroyNode(node.name || node.host);
+        }
+        this.nodeMap.clear();
+        this.players.clear();
+        this.client = null;
+        this.nodes = null;
+        this.plugins = null;
+        this.options = null;
+        this.send = null;
+        this.version = null;
+    }
 }
 
 module.exports = { Aqua };

package/build/structures/Connection.js

@@ -8,11 +8,24 @@ class Connection {
         this.voiceChannel = player.voiceChannel;
         this.lastUpdateTime = 0;
         this.updateThrottle = 1000;
+
+        // Bind event listeners
+        this.onPlayerMove = this.onPlayerMove.bind(this);
+        this.onPlayerLeave = this.onPlayerLeave.bind(this);
+        this.player.aqua.on("playerMove", this.onPlayerMove);
+        this.player.aqua.on("playerLeave", this.onPlayerLeave);
+    }
+
+    onPlayerMove(oldChannel, newChannel) {
+        // Handle player movement
+    }
+
+    onPlayerLeave(channelId) {
+        // Handle player leaving
     }
 
     setServerUpdate({ endpoint, token }) {
         if (!endpoint) throw new Error("Missing 'endpoint' property in VOICE_SERVER_UPDATE");
-
         const newRegion = endpoint.split('.')[0].replace(/[0-9]/g, "");
         if (this.region !== newRegion) {
             this.updateRegion(newRegion, endpoint, token);
@@ -25,52 +38,57 @@ class Connection {
         this.region = newRegion;
         this.voice.endpoint = endpoint;
         this.voice.token = token;
-
         this.player.aqua.emit("debug", `[Player ${this.player.guildId} - CONNECTION] ${previousVoiceRegion ? `Changed Voice Region from ${previousVoiceRegion} to ${this.region}` : `Voice Server: ${this.region}`}`);
-
         if (this.player.paused) {
             this.player.pause(false);
         }
     }
 
-    setStateUpdate({ session_id, channel_id, self_deaf, self_mute }) {
-        if (!channel_id || !session_id) {
+    setStateUpdate(data) {
+        if (!data.channel_id || !data.session_id) {
             this.cleanup();
             return;
         }
-
-        if (this.player.voiceChannel !== channel_id) {
-            this.player.aqua.emit("playerMove", this.player.voiceChannel, channel_id);
-            this.player.voiceChannel = channel_id;
-            this.voiceChannel = channel_id;
+        if (this.player.voiceChannel !== data.channel_id) {
+            this.player.aqua.emit("playerMove", this.player.voiceChannel, data.channel_id);
+            this.player.voiceChannel = data.channel_id;
+            this.voiceChannel = data.channel_id;
         }
-
-        this.selfDeaf = self_deaf;
-        this.selfMute = self_mute;
-        this.voice.sessionId = session_id;
+        this.selfDeaf = data.self_deaf;
+        this.selfMute = data.self_mute;
+        this.voice.sessionId = data.session_id;
     }
 
     updatePlayerVoiceData() {
         const currentTime = Date.now();
         if (currentTime - this.lastUpdateTime >= this.updateThrottle) {
             this.lastUpdateTime = currentTime;
+            const data = ({
+                voice: this.voice,
+                volume: this.player.volume,
+            });
             this.player.nodes.rest.updatePlayer({
                 guildId: this.player.guildId,
-                data: {
-                    voice: this.voice,
-                    volume: this.player.volume
-                }
+                data,
             });
         }
     }
 
     cleanup() {
+        this.player.aqua.off("playerMove", this.onPlayerMove);
+        this.player.aqua.off("playerLeave", this.onPlayerLeave);
         this.player.aqua.emit("playerLeave", this.player.voiceChannel);
         this.player.voiceChannel = null;
         this.voiceChannel = null;
         this.player.destroy();
         this.player.aqua.emit("playerDestroy", this.player);
+        this.player = null;
+        this.voice = null;
+        this.region = null;
+        this.selfDeaf = null;
+        this.selfMute = null;
+        this.voiceChannel = null;
     }
 }
 
-module.exports = { Connection };
+module.exports = { Connection };

package/build/structures/Node.js

@@ -235,6 +235,11 @@ class Node {
         this.aqua.emit("nodeDestroy", this);
         this.aqua.nodeMap.delete(this.name);
         this.connected = false;
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.close();
+            this.ws = null;
+        }
     }
 
     disconnect() {
@@ -259,4 +264,4 @@ class Node {
     }
 }
 
-module.exports = { Node };
+module.exports = { Node };

package/build/structures/Player.js

@@ -4,21 +4,6 @@ const { Queue } = require("./Queue");
 const { Filters } = require("./Filters");
 
 class Player extends EventEmitter {
-    /**
-     * Player constructor
-     * @param {Aqua} aqua the Aqua client instance
-     * @param {Array<Node>} nodes the nodes to connect to
-     * @param {Object} options the options to use
-     * @param {String} options.guildId the guild id to play in
-     * @param {String} options.textChannel the text channel to send messages in
-     * @param {String} options.voiceChannel the voice channel to join
-     * @param {Boolean} options.mute if the player should be muted
-     * @param {Boolean} options.deaf if the player should be deafened
-     * @param {Number} options.defaultVolume the default volume to use
-     * @param {String} options.loop the loop mode to use
-     * @param {Map} options.data the data to use
-     * @param {Boolean} options.shouldDeleteMessage if the player should delete the now playing message
-     */
     constructor(aqua, nodes, options = {}) {
         super();
         this.aqua = aqua;
@@ -32,7 +17,7 @@ class Player extends EventEmitter {
         this.deaf = options.deaf ?? false;
         this.volume = options.defaultVolume ?? 100;
         this.loop = options.loop ?? "none";
-        this.data = new Map()
+        this.data = new Map();
         this.queue = new Queue();
         this.position = 0;
         this.current = null;
@@ -70,67 +55,60 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Plays the next track in the queue.
+     * Play the next track in the queue.
      *
-     * @returns {Promise<Player>} The player instance.
      * @throws {Error} If the player is not connected.
-     * @throws {Error} If the queue is empty.
+     * @returns {Promise<Player>} The player instance.
      */
     async play() {
         if (!this.connected) throw new Error("Player must be connected first.");
         if (!this.queue.length) return;
-
         this.current = this.queue.shift();
         this.current = this.current.track ? this.current : await this.current.resolve(this.aqua);
         this.playing = true;
         this.position = 0;
-
         this.aqua.emit("debug", this.guildId, `Playing track: ${this.current.track}`);
         await this.updatePlayer({ track: { encoded: this.current.track } });
         return this;
     }
 
     /**
-     * Connects the player to a voice channel.
-     * @param {Object} options the options to use
-     * @param {String} options.guildId the guild id to connect to
-     * @param {String} options.voiceChannel the voice channel to connect to
-     * @param {Boolean} [options.deaf=true] if the player should be deafened
-     * @param {Boolean} [options.mute=false] if the player should be muted
-     * @returns {Promise<Player>} The player instance.
+     * Connects the player to a specified voice channel.
+     *
+     * @param {Object} options - Options for connecting the player.
+     * @param {string} options.guildId - The ID of the guild.
+     * @param {string} options.voiceChannel - The ID of the voice channel to connect to.
+     * @param {boolean} [options.deaf=true] - Whether the player should be self-deafened.
+     * @param {boolean} [options.mute=false] - Whether the player should be self-muted.
      * @throws {Error} If the player is already connected.
+     * @returns {Promise<Player>} The player instance.
      */
+
     async connect(options) {
         if (this.connected) throw new Error("Player is already connected.");
         const { guildId, voiceChannel, deaf = true, mute = false } = options;
-
         this.send({ guild_id: guildId, channel_id: voiceChannel, self_deaf: deaf, self_mute: mute });
         this.connected = true;
         this.aqua.emit("debug", this.guildId, `Player connected to voice channel: ${voiceChannel}.`);
         return this;
     }
 
-
-    /**
-     * Destroys the player.
-     *
-     * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the player is not connected.
-     */
     async destroy() {
-        await this.disconnect()
-        this.cleanup()
-        this.clearData()
+        if (!this.connected) return this;
+        await this.updatePlayer({ track: { encoded: null } });
+        this.playing = false;
+        this.position = 0;
+        this.send({ guild_id: this.guildId, channel_id: null });
+        this.connected = false;
+        return this;
     }
+/**
+ * Pauses or resumes the player.
+ *
+ * @param {boolean} paused - If true, the player will be paused; if false, it will resume.
+ * @returns {Promise<Player>} The player instance.
+ */
 
-
-    /**
-     * Pauses or unpauses the player.
-     *
-     * @param {Boolean} paused whether to pause or not
-     * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the player is not connected.
-     */
     async pause(paused) {
         this.paused = paused;
         await this.updatePlayer({ paused });
@@ -138,11 +116,11 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Seeks the player to a given position.
+     * Seeks to a position in the currently playing track.
      *
-     * @param {Number} position the position to seek to in milliseconds
-     * @returns {Promise<Player>} The player instance.
+     * @param {number} position - The position in milliseconds to seek to.
      * @throws {Error} If the position is negative.
+     * @returns {Promise<Player>} The player instance.
      */
     async seek(position) {
         if (position < 0) throw new Error("Seek position cannot be negative.");
@@ -151,12 +129,6 @@ class Player extends EventEmitter {
         return this;
     }
 
-       /**
-     * Stops the player and resets its state.
-     *
-     * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the player is not connected.
-     */
     async stop() {
         if (!this.playing) return this;
         await this.updatePlayer({ track: { encoded: null } });
@@ -168,9 +140,9 @@ class Player extends EventEmitter {
     /**
      * Sets the volume of the player.
      *
-     * @param {Number} volume the volume to set, must be between 0 and 200
+     * @param {number} volume - The volume to set, between 0 and 200.
+     * @throws {Error} If the volume is out of range.
      * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the volume is invalid.
      */
     async setVolume(volume) {
         if (volume < 0 || volume > 200) throw new Error("Volume must be between 0 and 200.");
@@ -182,9 +154,9 @@ class Player extends EventEmitter {
     /**
      * Sets the loop mode of the player.
      *
-     * @param {String} mode the loop mode to set, must be 'none', 'track', or 'queue'
+     * @param {string} mode - The loop mode to set, either "none", "track", or "queue".
+     * @throws {Error} If the mode is not one of the above.
      * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the loop mode is invalid.
      */
     async setLoop(mode) {
         if (!["none", "track", "queue"].includes(mode)) throw new Error("Loop mode must be 'none', 'track', or 'queue'.");
@@ -194,24 +166,24 @@ class Player extends EventEmitter {
     }
 
     /**
-     * Sets the text channel that the player will send messages to.
+     * Sets the text channel for the player.
      *
-     * @param {String} channel the ID of the text channel to send messages to
+     * @param {string} channel - The ID of the text channel to set.
      * @returns {Promise<Player>} The player instance.
-     * @throws {Error} If the channel is invalid.
      */
+
     async setTextChannel(channel) {
         await this.updatePlayer({ text_channel: channel });
         return this;
     }
 
     /**
-     * Sets the voice channel that the player will connect to.
+     * Sets the voice channel for the player.
      *
-     * @param {String} channel the ID of the voice channel to connect to
-     * @returns {Promise<Player>} The player instance.
+     * @param {string} channel - The ID of the voice channel to set.
      * @throws {TypeError} If the channel is not a non-empty string.
-     * @throws {ReferenceError} If the player is already connected to the given channel.
+     * @throws {ReferenceError} If the player is already connected to the channel.
+     * @returns {Promise<Player>} The player instance.
      */
     async setVoiceChannel(channel) {
         if (typeof channel !== "string") throw new TypeError("Channel must be a non-empty string.");
@@ -223,12 +195,6 @@ class Player extends EventEmitter {
         return this;
     }
 
-    /**
-     * Disconnects the player from the voice channel and clears the current track.
-     *
-     * @returns {Promise<void>} Resolves when the player is disconnected.
-     * @throws {Error} If the player is not connected to a voice channel.
-     */
     async disconnect() {
         await this.updatePlayer({ track: { encoded: null } });
         this.connected = false;
@@ -236,11 +202,6 @@ class Player extends EventEmitter {
         this.aqua.emit("debug", this.guildId, "Player disconnected from voice channel.");
     }
 
-    /**
-     * Shuffles the queue using the Fisher-Yates shuffle algorithm.
-     *
-     * @returns {Promise<Player>} The player instance.
-     */
     async shuffle() {
         for (let i = this.queue.length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
@@ -249,31 +210,16 @@ class Player extends EventEmitter {
         return this;
     }
 
-    /**
-     * Retrieves the current queue of tracks.
-     *
-     * @returns {Promise<Array<Track>>} The current queue of tracks.
-     */
     async getQueue() {
         return this.queue;
     }
 
-    /**
-     * Replays the current track from the start.
-     *
-     * @returns {Promise<Player>} The player instance.
-     */
     async replay() {
         return this.seek(0);
     }
 
-    /**
-     * Skips the current track and plays the next one in the queue.
-     *
-     * @returns {Promise<Player>} The player instance.
-     */
     async skip() {
-        await this.stop()
+        await this.stop();
         if (this.playing) return this.play();
     }
 
@@ -304,6 +250,7 @@ class Player extends EventEmitter {
                 this.handleUnknownEvent(player, track, payload);
         }
     }
+
     trackStart(player, track, payload) {
         this.playing = true;
         this.paused = false;
@@ -312,7 +259,7 @@ class Player extends EventEmitter {
 
     trackChange(player, track, payload) {
         this.playing = true;
-        this.paused = false
+        this.paused = false;
         this.aqua.emit("trackChange", player, track, payload);
     }
 
@@ -320,37 +267,30 @@ class Player extends EventEmitter {
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
             this.nowPlayingMessage.delete().catch(console.error).finally(() => this.nowPlayingMessage = null);
         }
-
         const reason = payload.reason.replace("_", "").toLowerCase();
         switch (reason) {
             case "loadfailed":
             case "cleanup":
                 return player.queue.isEmpty() ? this.aqua.emit("queueEnd", player) : player.play();
-
             case "track":
                 this.aqua.emit("trackRepeat", player, track, payload);
                 player.queue.unshift(this.previous);
                 break;
-
             case "queue":
                 this.aqua.emit("queueRepeat", player, track, payload);
                 player.queue.push(this.previous);
                 break;
-
             default:
                 this.aqua.emit("trackEnd", player, track, payload);
                 await this.cleanup();
         }
-
         if (player.queue.length === 0) {
             this.playing = false;
             this.aqua.emit("queueEnd", player);
         }
-
         if (!player.playing) {
             return this.cleanup();
         }
-
         return player.play();
     }
 
@@ -409,8 +349,9 @@ class Player extends EventEmitter {
 
     async cleanup() {
         if (!this.playing && !this.paused && this.queue.isEmpty()) {
-            await this.destroy(); 
+            await this.destroy();
         }
+        this.data.clear();
     }
 }
 

package/build/structures/Track.js

@@ -14,7 +14,7 @@ class Track {
     this.info = data.info;
     this.requester = requester;
     this.nodes = nodes;
-    this.track = data.encoded || Buffer.from(data.track, "base64").toString("utf8");
+    this.track = data.encoded || null
     this.playlist = data.playlist || null;
   }
 
@@ -87,4 +87,5 @@ class Track {
   }
 }
 
-module.exports = { Track };
+module.exports = { Track };
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "1.4.2",
+  "version": "1.5.1",
   "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
   "main": "build/index.js",
   "scripts": {