aqualink 2.0.0 → 2.0.2

package/README.md

@@ -4,7 +4,8 @@ An Stable, performant, Recourse friendly and fast lavalink wrapper
 This code is based in riffy, but its an 100% Rewrite made from scratch...
 
 # Why use AquaLink
-- Dependecy-free (0 dependencys), may change in future
+- Only uses 1 dependecy (ws for websocket, atm)
+- HTTP1.1 / HTTP2 Support
 - Very Low memory comsuption
 - Built in Queue manager
 - Lots of features to use
@@ -22,15 +23,19 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
   - https://github.com/DRSchlaubi/lyrics.kt (?)
   - https://github.com/DuncteBot/java-timed-lyrics (RECOMMENDED)
   
-# Tralalero Tralala 2.0.0 Released  
+# Tralalero Tralala 2.0.2 Released  
 ---
-
-### Now aqualink is 100% depedency free!
-  - Rewrite the rest to use https / http 
-  - Removed undici usage
-  - Rewrite NODE to use built-in WebSocket (no need to upgrade to node 20 or more!)
-  - Uses my own made websocket system, so please report any bugs (i beg)
-  - more stuff soon, now bye
+- Updated the `PLAYER` module
+  - Now uses Set() and WeakMap()
+  - More simple logic
+  - Improved error handling, and also a bit of memory management
+  - Rewrite the shuffle() method to use Fisher-Yates shuffle
+  - Fix updatePlayer sending an extra pause request
+  - Improved the clean up system (correctly uses clearData now)
+
+- Updated the `NODE` module
+  - Optimized stats creating / reusing
+  - Some stuff i made on the reconnecting system
 
 # Docs (Wiki)
 - https://github.com/ToddyTheNoobDud/AquaLink/wiki

package/build/handlers/fetchImage.js

@@ -1,19 +1,14 @@
-const { request } = require("undici");
-
+const http2 = require('http2');
 const sourceHandlers = new Map([
     ['spotify', uri => fetchThumbnail(`https://open.spotify.com/oembed?url=${uri}`)],
     ['youtube', identifier => fetchYouTubeThumbnail(identifier)]
 ]);
-
 const YOUTUBE_URL_TEMPLATE = (quality) => (id) => `https://img.youtube.com/vi/${id}/${quality}.jpg`;
 const YOUTUBE_QUALITIES = ['maxresdefault', 'hqdefault', 'mqdefault', 'default'].map(YOUTUBE_URL_TEMPLATE);
-
 async function getImageUrl(info) {
     if (!info?.sourceName || !info?.uri) return null;
-
     const handler = sourceHandlers.get(info.sourceName.toLowerCase());
     if (!handler) return null;
-
     try {
         return await handler(info.uri);
     } catch (error) {
@@ -21,28 +16,42 @@ async function getImageUrl(info) {
         return null;
     }
 }
-
-async function fetchThumbnail(url) {
-    try {
-        const { body } = await request(url, {
-            method: "GET",
-            headers: { 'Accept': 'application/json' }
+function fetchThumbnail(url) {
+    return new Promise((resolve, reject) => {
+        const client = http2.connect(url);
+        
+        const req = client.request({ ':path': '/' });
+        
+        let data = '';
+        
+        req.on('response', (headers, flags) => {
+            if (headers[':status'] !== 200) {
+                return reject(`Failed to fetch: ${headers[':status']}`);
+            }
         });
-        const json = await body.json();
-        return json.thumbnail_url || null;
-    } catch (error) {
-        console.error(`Error fetching thumbnail from ${url}:`, error);
-        return null;
-    }
+        req.on('data', chunk => {
+            data += chunk;
+        });
+        req.on('end', () => {
+            try {
+                const json = JSON.parse(data);
+                resolve(json.thumbnail_url || null);
+            } catch (error) {
+                reject(`JSON parse error: ${error.message}`);
+            } finally {
+                client.close();
+            }
+        });
+        req.on('error', (error) => {
+            reject(`Request error: ${error.message}`);
+            client.close();
+        });
+        req.end();
+    });
 }
-
 async function fetchYouTubeThumbnail(identifier) {
-    return Promise.race(
-        YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)))
-    ).catch(() => {
-        console.error('No valid YouTube thumbnail found.');
-        return null;
-    });
+    const promises = YOUTUBE_QUALITIES.map(urlFunc => fetchThumbnail(urlFunc(identifier)));
+    const results = await Promise.race(promises);
+    return results || null;
 }
-
-module.exports = { getImageUrl };
+module.exports = { getImageUrl };

package/build/index.d.ts

@@ -1,80 +1,352 @@
-declare module "AquaLink" {
-    export class Aqua {
-    /**
-     * @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 {boolean} [options.autoResume=false] - Automatically resume tracks on reconnect.
-     * @param {boolean} [options.infiniteReconnects=false] - Reconnect infinitely.
-     */
-        constructor(client: any, nodes: Array<any>, options?: { [key: string]: any });
+declare module "aqualink" {
+    import { EventEmitter } from "events";
+
+    export class Aqua extends EventEmitter {
+        constructor(client: any, nodes: Array<NodeConfig>, options?: AquaOptions);
         init(clientId: string): this;
-        createNode(options: { [key: string]: any }): Node;
-        createPlayer(node: Node, options: { [key: string]: any }): Player;
+        createNode(options: NodeConfig): Node;
+        createPlayer(node: Node, options: PlayerOptions): Player;
         destroyPlayer(guildId: string): Promise<void>;
-        resolve(options: { query: string, source?: string, requester?: any, nodes?: any }): Promise<any>;
-        updateVoiceState(data: { d: any, t: string }): void;
+        resolve(options: ResolveOptions): Promise<ResolveResponse>;
+        updateVoiceState(data: VoiceStateUpdate): void;
+        getOption<T>(options: Record<string, any>, key: string, defaultValue: T): T;
+        defaultSendFunction(payload: any): void;
+        validateInputs(client: any, nodes: Array<NodeConfig>): void;
+        get leastUsedNodes(): Node[];
+        fetchRegion(region: string): Node[];
+        calculateLoad(node: Node): number;
+        createConnection(options: PlayerOptions): Player;
+        getRequestNode(nodes?: string | Node): Node;
+        ensureInitialized(): void;
+        formatQuery(query: string, source: string): string;
+        handleNoMatches(rest: Rest, query: string): Promise<ResolveResponse>;
+        constructorResponse(response: any, requester: any, requestNode: Node): ResolveResponse;
+        get(guildId: string): Player;
+        cleanupPlayer(player: Player): void;
+
+        client: any;
+        nodes: Array<NodeConfig>;
+        nodeMap: Map<string, Node>;
+        players: Map<string, Player>;
+        clientId: string | null;
+        initiated: boolean;
+        options: AquaOptions;
+        shouldDeleteMessage: boolean;
+        defaultSearchPlatform: string;
+        leaveOnEnd: boolean;
+        restVersion: string;
+        plugins: Array<Plugin>;
+        version: string;
+        send: (payload: any) => void;
+        autoResume: boolean;
+        infiniteReconnects: boolean;
+        _leastUsedCache: { nodes: Node[], timestamp: number };
+    }
+
+    export interface AquaOptions {
+        send?: (payload: any) => void;
+        defaultSearchPlatform?: string;
+        restVersion?: string;
+        plugins?: Array<Plugin>;
+        autoResume?: boolean;
+        infiniteReconnects?: boolean;
+        shouldDeleteMessage?: boolean;
+        leaveOnEnd?: boolean;
+    }
+
+    export interface NodeConfig {
+        name?: string;
+        host: string;
+        port: number;
+        password: string;
+        secure?: boolean;
+        sessionId?: string;
+        regions?: string[];
+    }
+
+    export interface PlayerOptions {
+        guildId: string;
+        textChannel?: string;
+        voiceChannel?: string;
+        defaultVolume?: number;
+        loop?: string;
+        shouldDeleteMessage?: boolean;
+        leaveOnEnd?: boolean;
+        region?: string;
+    }
+
+    export interface ResolveOptions {
+        query: string;
+        source?: string;
+        requester?: any;
+        nodes?: string | Node;
+    }
+
+    export interface ResolveResponse {
+        loadType: string;
+        exception: any;
+        playlistInfo: any;
+        pluginInfo: any;
+        tracks: Track[];
+    }
+
+    export interface VoiceStateUpdate {
+        d: any;
+        t: string;
     }
 
     export class Connection {
         constructor(player: Player);
         setServerUpdate(data: { endpoint: string, token: string }): void;
         setStateUpdate(data: { channel_id: string, session_id: string, self_deaf: boolean, self_mute: boolean }): void;
+        _updatePlayerVoiceData(): Promise<void>;
+
+        playerRef: WeakRef<Player>;
+        voice: { sessionId: string | null, endpoint: string | null, token: string | null };
+        region: string | null;
+        selfDeaf: boolean;
+        selfMute: boolean;
+        voiceChannel: string;
+        guildId: string;
+        aqua: Aqua;
+        nodes: any;
     }
 
     export class Filters {
-        constructor(player: Player, options?: { [key: string]: any });
+        constructor(player: Player, options?: FiltersOptions);
         setEqualizer(bands: Array<any>): Promise<void>;
-        setKaraoke(enabled: boolean, options?: { [key: string]: any }): Promise<void>;
+        setKaraoke(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setTimescale(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setTremolo(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setVibrato(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setRotation(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setDistortion(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setChannelMix(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setLowPass(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setBassboost(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setSlowmode(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setNightcore(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        setVaporwave(enabled: boolean, options?: FiltersOptions): Promise<void>;
+        set8D(enabled: boolean, options?: FiltersOptions): Promise<void>;
         clearFilters(): Promise<void>;
+        updateFilters(): Promise<void>;
+
+        player: Player;
+        volume: number;
+        equalizer: any[];
+        karaoke: any;
+        timescale: any;
+        tremolo: any;
+        vibrato: any;
+        rotation: any;
+        distortion: any;
+        channelMix: any;
+        lowPass: any;
+        bassboost: any;
+        slowmode: any;
+        nightcore: any;
+        vaporwave: any;
+        _8d: any;
+    }
+
+    export interface FiltersOptions {
+        volume?: number;
+        equalizer?: any[];
+        karaoke?: any;
+        timescale?: any;
+        tremolo?: any;
+        vibrato?: any;
+        rotation?: any;
+        distortion?: any;
+        channelMix?: any;
+        lowPass?: any;
+        bassboost?: any;
+        slowmode?: any;
+        nightcore?: any;
+        vaporwave?: any;
+        _8d?: any;
     }
 
     export class Node {
-        constructor(aqua: Aqua, connOptions: { [key: string]: any }, options?: { [key: string]: any });
+        constructor(aqua: Aqua, connOptions: NodeConfig, options?: NodeOptions);
         connect(): Promise<void>;
         getStats(): Promise<any>;
         destroy(clean?: boolean): void;
+
+        aqua: Aqua;
+        name: string;
+        host: string;
+        port: number;
+        password: string;
+        secure: boolean;
+        sessionId: string | null;
+        regions: string[];
+        wsUrl: URL;
+        rest: Rest;
+        resumeTimeout: number;
+        autoResume: boolean;
+        reconnectTimeout: number;
+        reconnectTries: number;
+        infiniteReconnects: boolean;
+        connected: boolean;
+        info: any;
+        defaultStats: any;
+        stats: any;
+    }
+
+    export interface NodeOptions {
+        resumeTimeout?: number;
+        autoResume?: boolean;
+        reconnectTimeout?: number;
+        reconnectTries?: number;
+        infiniteReconnects?: boolean;
     }
 
-    export class Player {
-        constructor(aqua: Aqua, nodes: any, options?: { [key: string]: any });
+    export class Player extends EventEmitter {
+        constructor(aqua: Aqua, nodes: any, options?: PlayerOptions);
         play(): Promise<void>;
         pause(paused: boolean): this;
         skip(): Promise<void>;
         destroy(): void;
+        connect(options: PlayerOptions): this;
+        disconnect(): this;
+        setVolume(volume: number): this;
+        setLoop(mode: string): this;
+        setTextChannel(channel: string): this;
+        setVoiceChannel(channel: string): this;
+        shuffle(): this;
+        replay(): this;
+        stop(): this;
+        seek(position: number): this;
+        searchLyrics(query: string): Promise<any>;
+        lyrics(): Promise<any>;
+        addToPreviousTrack(track: Track): void;
+        updatePlayer(data: any): Promise<void>;
+        cleanup(): Promise<void>;
+        updateTrackState(playing: boolean, paused: boolean): void;
+        handleEvent(payload: any): Promise<void>;
+        handleUnknownEvent(payload: any): void;
+        trackStart(player: Player, track: Track): Promise<void>;
+        trackEnd(player: Player, track: Track, payload: any): Promise<void>;
+        trackError(player: Player, track: Track, payload: any): Promise<void>;
+        trackStuck(player: Player, track: Track, payload: any): Promise<void>;
+        socketClosed(player: Player, payload: any): Promise<void>;
+        send(data: any): void;
+
+        static LOOP_MODES: { NONE: string, TRACK: string, QUEUE: string };
+        static EVENT_HANDLERS: { [key: string]: string };
+        static validModes: Set<string>;
+
+        aqua: Aqua;
+        nodes: any;
+        guildId: string;
+        textChannel: string;
+        voiceChannel: string;
+        connection: Connection;
+        filters: Filters;
+        volume: number;
+        loop: string;
+        queue: Queue;
+        previousTracks: Track[];
+        shouldDeleteMessage: boolean;
+        leaveOnEnd: boolean;
+        playing: boolean;
+        paused: boolean;
+        connected: boolean;
+        current: Track | null;
+        timestamp: number;
+        ping: number;
+        nowPlayingMessage: any;
+        onPlayerUpdate: (state: any) => void;
     }
 
     export class Plugin {
         constructor(name: string);
         load(aqua: Aqua): void;
         unload(aqua: Aqua): void;
+
+        name: string;
     }
 
-    export class Queue extends Array {
+    export class Queue extends Array<any> {
+        constructor(...elements: any[]);
+        size: number;
+        first: any;
+        last: any;
         add(track: any): this;
         remove(track: any): void;
         clear(): void;
         shuffle(): void;
         peek(): any;
-        toArray(): Array<any>;
+        toArray(): any[];
         at(index: number): any;
         dequeue(): any;
         isEmpty(): boolean;
+        enqueue(track: any): this;
     }
 
     export class Rest {
-        constructor(aqua: Aqua, options: { [key: string]: any });
+        constructor(aqua: Aqua, options: RestOptions);
         makeRequest(method: string, endpoint: string, body?: any): Promise<any>;
         getPlayers(): Promise<any>;
         destroyPlayer(guildId: string): Promise<void>;
+        getTracks(identifier: string): Promise<any>;
+        decodeTrack(track: string): Promise<any>;
+        decodeTracks(tracks: any[]): Promise<any>;
+        getStats(): Promise<any>;
+        getInfo(): Promise<any>;
+        getRoutePlannerStatus(): Promise<any>;
+        getRoutePlannerAddress(address: string): Promise<any>;
+        getLyrics(options: { track: any }): Promise<any>;
+        setSessionId(sessionId: string): void;
+        buildEndpoint(...segments: string[]): string;
+        validateSessionId(): void;
+        updatePlayer(options: { guildId: string, data: any }): Promise<void>;
+
+        aqua: Aqua;
+        sessionId: string;
+        version: string;
+        baseUrl: string;
+        headers: Record<string, string>;
+        client: any;
+    }
+
+    export interface RestOptions {
+        secure: boolean;
+        host: string;
+        port: number;
+        sessionId: string;
+        password: string;
     }
 
     export class Track {
-        constructor(data: { [key: string]: any }, requester: Player, nodes: Node);
+        constructor(data: TrackData, requester: Player, nodes: Node);
         resolve(aqua: Aqua): Promise<Track | null>;
+        resolveThumbnail(thumbnail: string): string | null;
+        _findMatchingTrack(tracks: Track[]): Track | null;
+
+        info: TrackInfo;
+        track: string | null;
+        playlist: any;
+        requester: Player;
+        nodes: Node;
+    }
+
+    export interface TrackData {
+        info?: TrackInfo;
+        encoded?: string;
+        playlist?: any;
+    }
+
+    export interface TrackInfo {
+        identifier: string;
+        isSeekable: boolean;
+        author: string;
+        length: number;
+        isStream: boolean;
+        title: string;
+        uri: string;
+        sourceName: string;
+        artworkUrl: string;
     }
 }

package/build/structures/Node.js

@@ -1,5 +1,5 @@
 "use strict";
-const WebSocket = require('../handlers/WebSocket');
+const WebSocket = require('ws');
 const Rest = require("./Rest");
 
 class Node {
@@ -37,16 +37,7 @@ class Node {
         this.infiniteReconnects = options.infiniteReconnects || false;
         this.connected = false;
         this.info = null;
-        this.defaultStats = this.#createDefaultStats();
-        this.stats = { ...this.defaultStats };
-        this._onOpen = this.#onOpen.bind(this);
-        this._onError = this.#onError.bind(this);
-        this._onMessage = this.#onMessage.bind(this);
-        this._onClose = this.#onClose.bind(this);
-    }
-
-    #createDefaultStats() {
-        return {
+        this.stats = {
             players: 0,
             playingPlayers: 0,
             uptime: 0,
@@ -55,8 +46,13 @@ class Node {
             frameStats: { sent: 0, nulled: 0, deficit: 0 },
             ping: 0
         };
+        this._onOpen = this.#onOpen.bind(this);
+        this._onError = this.#onError.bind(this);
+        this._onMessage = this.#onMessage.bind(this);
+        this._onClose = this.#onClose.bind(this);
     }
 
+
     async connect() {
         this.#ws = new WebSocket(this.wsUrl.href, {
             headers: this.#constructHeaders(),
@@ -97,10 +93,8 @@ class Node {
     }
 
     async getStats() {
-        const stats = await this.rest.getStats();
-        if (JSON.stringify(this.stats) !== JSON.stringify({ ...this.defaultStats, ...stats })) {
-            this.stats = { ...this.defaultStats, ...stats };
-        }
+        const newStats = await this.rest.getStats();
+        Object.assign(this.stats, newStats);
         return this.stats;
     }
 
@@ -141,48 +135,41 @@ class Node {
 
     #updateStats(payload) {
         if (!payload) return;
-        const newStats = {
-            ...this.stats,
-            ...payload,
-            memory: this.#updateMemoryStats(payload.memory),
-            cpu: this.#updateCpuStats(payload.cpu),
-            frameStats: this.#updateFrameStats(payload.frameStats)
-        };
-        if (JSON.stringify(this.stats) !== JSON.stringify(newStats)) {
-            this.stats = newStats;
-        }
-    }
 
-    #updateMemoryStats(memory = {}) {
-        const allocated = memory.allocated || 0;
-        const free = memory.free || 0;
-        const used = memory.used || 0;
-        return {
+        this.stats.players = payload.players || this.stats.players;
+        this.stats.playingPlayers = payload.playingPlayers || this.stats.playingPlayers;
+        this.stats.uptime = payload.uptime || this.stats.uptime;
+        this.stats.ping = payload.ping || this.stats.ping;
+
+        const memory = payload.memory || {};
+        const allocated = memory.allocated || this.stats.memory.allocated;
+        const free = memory.free || this.stats.memory.free;
+        const used = memory.used || this.stats.memory.used;
+
+        this.stats.memory = {
             free,
             used,
             allocated,
-            reservable: memory.reservable || 0,
-            freePercentage: allocated ? (free / allocated) * 100 : 0,
-            usedPercentage: allocated ? (used / allocated) * 100 : 0
+            reservable: memory.reservable || this.stats.memory.reservable,
+            freePercentage: allocated ? (free / allocated) * 100 : this.stats.memory.freePercentage,
+            usedPercentage: allocated ? (used / allocated) * 100 : this.stats.memory.usedPercentage
         };
-    }
 
-    #updateCpuStats(cpu = {}) {
-        const cores = cpu.cores || 0;
-        return {
+        const cpu = payload.cpu || {};
+        const cores = cpu.cores || this.stats.cpu.cores;
+
+        this.stats.cpu = {
             cores,
-            systemLoad: cpu.systemLoad || 0,
-            lavalinkLoad: cpu.lavalinkLoad || 0,
-            lavalinkLoadPercentage: cores ? (cpu.lavalinkLoad / cores) * 100 : 0
+            systemLoad: cpu.systemLoad || this.stats.cpu.systemLoad,
+            lavalinkLoad: cpu.lavalinkLoad || this.stats.cpu.lavalinkLoad,
+            lavalinkLoadPercentage: cores ? (cpu.lavalinkLoad / cores) * 100 : this.stats.cpu.lavalinkLoadPercentage
         };
-    }
 
-    #updateFrameStats(frameStats = {}) {
-        if (!frameStats) return { sent: 0, nulled: 0, deficit: 0 };
-        return {
-            sent: frameStats.sent || 0,
-            nulled: frameStats.nulled || 0,
-            deficit: frameStats.deficit || 0
+        const frameStats = payload.frameStats || {};
+        this.stats.frameStats = {
+            sent: frameStats.sent || this.stats.frameStats.sent,
+            nulled: frameStats.nulled || this.stats.frameStats.nulled,
+            deficit: frameStats.deficit || this.stats.frameStats.deficit
         };
     }
 

package/build/structures/Player.js

@@ -11,6 +11,7 @@ class Player extends EventEmitter {
         TRACK: "track",
         QUEUE: "queue"
     });
+
     static EVENT_HANDLERS = Object.freeze({
         TrackStartEvent: "trackStart",
         TrackEndEvent: "trackEnd",
@@ -19,7 +20,8 @@ class Player extends EventEmitter {
         TrackChangeEvent: "trackChange",
         WebSocketClosedEvent: "socketClosed"
     });
-    static validModes = ["none", "track", "queue"]
+
+    static validModes = new Set(Object.values(Player.LOOP_MODES));
 
     constructor(aqua, nodes, options = {}) {
         super();
@@ -31,7 +33,7 @@ class Player extends EventEmitter {
         this.connection = new Connection(this);
         this.filters = new Filters(this);
         this.volume = Math.min(Math.max(options.defaultVolume ?? 100, 0), 200);
-        this.loop = Player.LOOP_MODES[options.loop?.toUpperCase()] || Player.LOOP_MODES.NONE;
+        this.loop = Player.validModes.has(options.loop) ? options.loop : Player.LOOP_MODES.NONE;
         this.queue = new Queue();
         this.previousTracks = [];
         this.shouldDeleteMessage = options.shouldDeleteMessage ?? false;
@@ -45,23 +47,19 @@ class Player extends EventEmitter {
         this.ping = 0;
         this.nowPlayingMessage = null;
 
-        this.onPlayerUpdate = ({ state }) => state && Object.assign(this, state) && this.aqua.emit("playerUpdate", this, { state });
-        this.handleEvent = async (payload) => {
-            const player = this.aqua.players.get(payload.guildId);
-            if (!player) return;
+        this.on("playerUpdate", ({ state }) => {
+            if (state) Object.assign(this, state);
+            this.aqua.emit("playerUpdate", this, { state });
+        });
+
+        this.on("event", async (payload) => {
             const handler = Player.EVENT_HANDLERS[payload.type];
             if (handler && typeof this[handler] === "function") {
-                await this[handler](player, this.current, payload);
+                await this[handler](this, this.current, payload);
             } else {
                 this.handleUnknownEvent(payload);
             }
-        };
-        if (!this.listenerCount("playerUpdate")) {
-            this.on("playerUpdate", this.onPlayerUpdate);
-        }
-        if (!this.listenerCount("event")) {
-            this.on("event", this.handleEvent);
-        }
+        });
     }
 
     get previous() {
@@ -107,11 +105,13 @@ class Player extends EventEmitter {
         this.nowPlayingMessage?.delete().catch(() => { });
         this.aqua.destroyPlayer(this.guildId);
         this.nodes.rest.destroyPlayer(this.guildId);
+        this.clearData();
         this.removeAllListeners();
         return this;
     }
 
     pause(paused) {
+        if (this.paused === paused) return this;
         this.paused = paused;
         this.updatePlayer({ paused });
         return this;
@@ -184,7 +184,10 @@ class Player extends EventEmitter {
         return this;
     }
     shuffle() {
-        this.queue = this.queue.sort(() => Math.random() - 0.5);
+        for (let i = this.queue.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [this.queue[i], this.queue[j]] = [this.queue[j], this.queue[i]];
+        }
         return this;
     }
 
@@ -213,14 +216,16 @@ class Player extends EventEmitter {
 
     async trackEnd(player, track, payload) {
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
-            await this.nowPlayingMessage.delete().catch(() => { });
-            this.nowPlayingMessage = null;
+            try {
+                await this.nowPlayingMessage.delete();
+                this.nowPlayingMessage = null;
+            } catch {}
         }
 
         const reason = payload.reason?.replace("_", "").toLowerCase();
-
-        if (reason === "loadfailed" || reason === "cleanup") {
-            if (player.queue.isEmpty()) {
+        if (["loadfailed", "cleanup"].includes(reason)) {
+            if (!player.queue.length) {
+                this.clearData();
                 this.aqua.emit("queueEnd", player);
             } else {
                 await player.play();
@@ -228,20 +233,16 @@ class Player extends EventEmitter {
             return;
         }
 
-        switch (this.loop) {
-            case Player.LOOP_MODES.TRACK:
-                this.aqua.emit("trackRepeat", player, track);
-                player.queue.unshift(track);
-                break;
-            case Player.LOOP_MODES.QUEUE:
-                this.aqua.emit("queueRepeat", player, track);
-                player.queue.push(track);
-                break;
+        if (this.loop === Player.LOOP_MODES.TRACK) {
+            player.queue.unshift(track);
+        } else if (this.loop === Player.LOOP_MODES.QUEUE) {
+            player.queue.push(track);
         }
 
         if (player.queue.isEmpty()) {
             this.playing = false;
             if (this.leaveOnEnd) {
+                this.clearData();   
                 this.cleanup();
             }
             this.aqua.emit("queueEnd", player);
@@ -290,11 +291,11 @@ class Player extends EventEmitter {
     }
 
     clearData() {
+        if (this.previousTracks) this.previousTracks.length = 0;
         this.#dataStore = new WeakMap();
         return this;
     }
 
-
     updatePlayer(data) {
         return this.nodes.rest.updatePlayer({ guildId: this.guildId, data });
     }
@@ -313,7 +314,6 @@ class Player extends EventEmitter {
     updateTrackState(playing, paused) {
         this.playing = playing;
         this.paused = paused;
-        this.updatePlayer({ paused });
     }
 }
 

package/build/structures/Rest.js

@@ -1,6 +1,12 @@
 "use strict";
 const https = require("https");
 const http = require("http");
+let http2;
+try {
+    http2 = require("http2");
+} catch (e) {
+    http2 = null;
+}
 
 class Rest {
     constructor(aqua, { secure, host, port, sessionId, password }) {
@@ -12,7 +18,7 @@ class Rest {
             "Content-Type": "application/json",
             Authorization: password,
         };
-        this.client = secure ? https : http;
+        this.client = secure ? (http2 ? http2 : https) : http;
     }
 
     setSessionId(sessionId) {
@@ -113,4 +119,4 @@ class Rest {
     }
 }
 
-module.exports = Rest;
+module.exports = Rest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",
@@ -40,6 +40,9 @@
     "type": "git",
     "url": "https://github.com/ToddyTheNoobDud/AquaLink"
   },
+  "dependencies": {
+    "ws": "^8.18.1"
+  },
   "maintainers": [
     {
       "name": "mushroom0162",

package/build/handlers/WebSocket.js

@@ -1,259 +0,0 @@
-const https = require('node:https');
-const http = require('node:http');
-const crypto = require('node:crypto');
-const { EventEmitter } = require('node:events');
-const { URL } = require('node:url');
-const { Buffer } = require('node:buffer');
-
-let nativeWs = null;
-if (process.isBun) nativeWs = require('ws');
-const frameHeaderPool = Buffer.alloc(10);
-
-
-class BufferPool {
-  constructor(initialSize = 8192) {
-    this.buffer = Buffer.allocUnsafe(initialSize);
-    this.used = 0;
-  }
-
-  append(data) {
-    const dataLength = data.length;
-    if (this.used + dataLength > this.buffer.length) {
-      const newSize = Math.max(this.buffer.length * 2, this.used + dataLength);
-      const newBuffer = Buffer.allocUnsafe(newSize);
-      this.buffer.copy(newBuffer, 0, 0, this.used);
-      this.buffer = newBuffer;
-    }
-    data.copy(this.buffer, this.used);
-    this.used += dataLength;
-  }
-
-  consume(bytes) {
-    if (bytes === this.used) {
-      this.used = 0;
-      return;
-    }
-    
-    this.buffer.copy(this.buffer, 0, bytes, this.used);
-    this.used -= bytes;
-  }
-
-  get data() {
-    return this.buffer.subarray(0, this.used);
-  }
-}
-
-class WebSocket extends EventEmitter {
-  constructor(url, options = {}) {
-    super();
-    this.url = url;
-    this.options = options;
-    this.socket = null;
-    this.bufferPool = new BufferPool();
-    this.frameInfo = null;
-    this.reconnectAttempts = 0;
-    this.maxReconnectAttempts = options.maxReconnectAttempts || 10;
-    this.baseReconnectDelay = options.baseReconnectDelay || 1000; // 1 second
-    this.connect();
-  }
-
-  connect() {
-    const { hostname, protocol, port, pathname, search } = new URL(this.url);
-    const isSecure = protocol === 'wss:';
-    const agent = isSecure ? https : http;
-    const key = crypto.randomBytes(16).toString('base64');
-
-    const request = agent.request({
-      hostname,
-      port: port || (isSecure ? 443 : 80),
-      path: pathname + search,
-      timeout: this.options.timeout || 30000,
-      headers: {
-        'Sec-WebSocket-Key': key,
-        'Sec-WebSocket-Version': 13,
-        'Upgrade': 'websocket',
-        'Connection': 'Upgrade',
-        ...this.options.headers
-      },
-      method: 'GET'
-    });
-
-    request.once('error', (err) => this._handleError(err));
-    request.once('upgrade', (res, socket, head) => this._handleUpgrade(res, socket, head, key));
-    request.end();
-  }
-
-  _handleUpgrade(res, socket, head, key) {
-    if (res.headers.upgrade.toLowerCase() !== 'websocket') {
-      return socket.destroy();
-    }
-
-    const expectedAccept = crypto.createHash('sha1')
-      .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
-      .digest('base64');
-
-    if (res.headers['sec-websocket-accept'] !== expectedAccept) {
-      return socket.destroy();
-    }
-
-    this.reconnectAttempts = 0;
-    
-    this.socket = socket;
-    this.socket.setNoDelay(true);
-    this.socket.setKeepAlive(true);
-    this.socket.on('data', (data) => this._processData(data));
-    this.socket.once('close', () => this._handleClose(1006));
-    this.socket.once('error', (err) => this._handleError(err));
-    if (head.length) this._processData(head);
-    this.emit('open');
-  }
-
-  _processData(data) {
-    this.bufferPool.append(data);
-    
-    while (this.bufferPool.used >= 2) {
-      const bufferData = this.bufferPool.data;
-      const lengthByte = bufferData[1] & 127;
-      let headerSize = 2 + ((bufferData[1] & 128) ? 4 : 0);
-      if (lengthByte === 126) headerSize += 2;
-      else if (lengthByte === 127) headerSize += 8;
-      if (this.bufferPool.used < headerSize) return;
-      
-      const frame = this._parseFrame();
-      if (!frame) return;
-      this._handleFrame(frame);
-    }
-  }
-
-  _parseFrame() {
-    const bufferData = this.bufferPool.data;
-    if (bufferData.length < 2) return null;
-  
-    const fin = (bufferData[0] & 128) !== 0;
-    const opcode = bufferData[0] & 15;
-    let payloadLength = bufferData[1] & 127;
-    let offset = 2;
-  
-    if (payloadLength === 126) {
-      if (bufferData.length < offset + 2) return null;
-      payloadLength = bufferData.readUInt16BE(offset);
-      offset += 2;
-    } else if (payloadLength === 127) {
-      if (bufferData.length < offset + 8) return null;
-      payloadLength = Number(bufferData.readBigUInt64BE(offset));
-      offset += 8;
-    }
-  
-    const hasMask = (bufferData[1] & 128) !== 0;
-    const mask = hasMask ? bufferData.subarray(offset, offset + 4) : null;
-    offset += hasMask ? 4 : 0;
-  
-    if (bufferData.length < offset + payloadLength) return null;
-  
-    let payload = Buffer.from(bufferData.subarray(offset, offset + payloadLength));
-  
-    if (mask) {
-      for (let i = 0; i < payload.length; i++) {
-        payload[i] = payload[i] ^ mask[i % 4];
-      }
-    }
-  
-    const totalFrameSize = offset + payloadLength;
-    this.bufferPool.consume(totalFrameSize);
-  
-    return { fin, opcode, payload };
-  }
-
-  _handleFrame({ fin, opcode, payload }) {
-    if (opcode === 0x8) return this._handleClose(payload.length >= 2 ? payload.readUInt16BE(0) : 1006);
-    if (opcode === 0x9) return this._sendFrame(0xA, payload);
-    if (opcode === 0xA) return this.emit('pong', payload);
-    if (!fin) return;
-    
-    if (opcode === 0x1) {
-      this.emit('message', payload.toString('utf-8'));
-    } else {
-      this.emit('message', payload);
-    }
-  }
-
-  _sendFrame(opcode, payload = Buffer.alloc(0)) {
-    if (!this.socket || this.socket.destroyed) return;
-    const length = payload.length;
-    let headerSize = length < 126 ? 2 : length < 65536 ? 4 : 10;
-  
-    frameHeaderPool[0] = 0x80 | opcode;
-    if (length < 126) {
-      frameHeaderPool[1] = length;
-    } else if (length < 65536) {
-      frameHeaderPool[1] = 126;
-      frameHeaderPool.writeUInt16BE(length, 2);
-    } else {
-      frameHeaderPool[1] = 127;
-      frameHeaderPool.writeBigUInt64BE(BigInt(length), 2);
-    }
-  
-    this.socket.write(frameHeaderPool.subarray(0, headerSize));
-    this.socket.write(payload);
-  }
-
-  send(data) {
-    if (typeof data === 'string') {
-      data = Buffer.from(data, 'utf-8');
-    } else if (!Buffer.isBuffer(data)) {
-      throw new Error('Data must be a string or Buffer');
-    }
-    this._sendFrame(0x1, data);
-  }
-
-  ping(data = '') {
-    const pingData = typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
-    this._sendFrame(0x9, pingData);
-  }
-
-  close(code = 1000) {
-    const codeBuffer = Buffer.allocUnsafe(2);
-    codeBuffer.writeUInt16BE(code, 0);
-    this._sendFrame(0x8, codeBuffer);
-    setTimeout(() => this._handleClose(code), 100);
-  }
-
-  _handleClose(code) {
-    if (this.socket) {
-      this.socket.destroy();
-      this.socket = null;
-    }
-    this.bufferPool = new BufferPool();
-    this.emit('close', code);
-  }
-
-  _handleError(err) {
-    if (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT') {
-      if (this.reconnectAttempts < this.maxReconnectAttempts) {
-        this.reconnectAttempts++;
-        const delay = Math.min(
-          this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
-          30000
-        );
-        
-        const jitter = Math.random() * 0.3 * delay;
-        const reconnectDelay = delay + jitter;
-        
-        setTimeout(() => this.connect(), reconnectDelay);
-        this.emit('reconnecting', { 
-          attempt: this.reconnectAttempts, 
-          delay: reconnectDelay,
-          error: err
-        });
-      } else {
-        this.emit('error', new Error(`Maximum reconnection attempts (${this.maxReconnectAttempts}) exceeded: ${err.message}`));
-        this._handleClose(1006);
-      }
-    } else {
-      this.emit('error', err);
-      this._handleClose(1006);
-    }
-  }
-}
-
-module.exports = nativeWs || WebSocket;