poru 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 parasop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,50 @@
+<p align="center">
+  <img src="https://cdn.discordapp.com/attachments/732987654165233744/987656504373026816/20220618_000923_0000.png" />
+</p>
+<p align="center">
+ [![Discord](https://img.shields.io/discord/567705326774779944?style=flat-square)](https://discord.gg/Zmmc47Nrh8)
+[![npm](https://img.shields.io/npm/v/poru?style=flat-square)](https://www.npmjs.com/package/poru)
+![Github Stars](https://img.shields.io/github/stars/parasop/poru?style=flat-square)
+![GitHub issues](https://img.shields.io/github/issues-raw/parasop/poru?style=flat-square)
+![Snyk Vulnerabilities for npm package](https://img.shields.io/snyk/vulnerabilities/npm/poru?style=flat-square) 
+![NPM](https://img.shields.io/npm/l/poru?style=flat-square)
+
+</p>
+
+
+<p align="center">
+  <a href="https://nodei.co/npm/poru/"><img src="https://nodei.co/npm/poru.png?downloads=true&downloadRank=true&stars=true"></a>
+</p>
+
+## Table of contents
+
+- [Documentation](https://gorillas-team.github.io/Gorilink/)
+- [Installation](#installation)
+- [About](#about)
+- [Example](#example-usage-basic-bot)
+
+# Installation
+```
+// Using npm
+npm install poru
+
+// Using yarn
+yarn add poru
+```
+
+# About
+To use you need a configured [Lavalink](https://github.com/Frederikam/Lavalink) instance.
+
+- Stable client
+- 100% Compatible with Lavalink
+- Object-oriented
+- 100% Customizable
+- Easy to setup
+
+## Example usage basic bot
+```javascript
+//  adding soon
+```
+
+## Need Help?
+If you do not understand something in the documentation or have any questions, please join our [My disocrd server ](https://discord.gg/Zmmc47Nrh8)

package/index.js

@@ -0,0 +1,20 @@
+module.exports = {
+    Node: require("./src/Node"),
+    Player: require("./src/Player"),
+    Poru: require("./src/Poru")
+}
+process.on('unhandledRejection', error => {
+    if (error.code === '10008' || error.code === '10062') return;
+    console.log(error.stack);
+  });
+  process.on('uncaughtException', (err, origin) => {
+    console.log(err, origin);
+  });
+  
+  process.on('uncaughtExceptionMonitor', (err, origin) => {
+    console.log(err, origin);
+  });
+  
+  process.on('multipleResolves', (type, promise, reason) => {
+    console.log(type, promise, reason);
+  });

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "poru",
+  "version": "1.0.0",
+  "description": "A stable and powefull lavalink client with so many features",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/parasop/poru.git"
+  },
+  "author": "PARAS",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/parasop/poru/issues"
+  },
+  "homepage": "https://github.com/parasop/poru#readme",
+  "dependencies": {
+    "node-fetch": "^3.2.6",
+    "ws": "^8.8.0"
+  }
+}

package/src/Node.js

@@ -0,0 +1,137 @@
+const WebSocket = require("ws");
+const config = require("./config.json")
+
+class Node {
+    constructor(manager, options = { }) {
+
+        this.manager = manager
+        this.name= options.name || null;
+        this.host = options.host || "localhost"
+        this.port = options.port || 2333
+        this.url = `${options.secure ? 'wss' : 'ws'}://${options.host}:${options.port}`;
+        this.password = options.password ||"youshallnotpass"
+        this.secure = options.secure || false;
+        this.ws = null;
+        this.reconnect = options.reconnect || 10000;
+        this.reconnectTime = 50000;
+        this.resumeKey = options.resumeKey || null;
+        this._resumeTimeout = options.resumeTimeout || 60
+        this.queue = [];
+        this.isConnected = false;
+        this.stats = {
+            players: 0,
+            playingPlayers: 0,
+            uptime: 0,
+            memory: {
+                free: 0,
+                used: 0,
+                allocated: 0,
+                reservable: 0,
+            },
+            cpu: {
+                cores: 0,
+                systemLoad: 0,
+                lavalinkLoad: 0,
+            },
+        };
+
+
+ }
+
+ connect() {
+    if (this.ws) this.ws.close();
+    const headers = {
+        Authorization: this.password,
+        "Num-Shards": this.manager.shards || 1,
+        "User-Id": this.manager.user,
+        "Client-Name": config.client
+   };
+   if (this.resumeKey) headers["Resume-Key"] = this.resumeKey;
+   this.ws = new WebSocket(`ws${this.secure ? "s" : ""}:${this.host}:${this.port}/`, { headers });
+   this.ws.on("open", this.open.bind(this));
+   this.ws.on("error", this.error.bind(this));
+   this.ws.on("message", this.message.bind(this));
+   this.ws.on("close", this.close.bind(this));
+ }
+
+
+open(){
+    if (this.reconnect) {
+        clearTimeout(this.reconnect);
+        delete this.reconnect;
+    }
+
+this.queue =[];
+if (this.resumeKey) this.send({ op: "configureResuming", key: (this.resumeKey).toString(), timeout: this._resumeTimeout });
+ this.manager.emit("nodeConnect", this);
+this.isConnected = true;
+}
+
+message(payload) {
+    // eslint-disable-next-line no-param-reassign
+    if (Array.isArray(payload)) payload = Buffer.concat(payload);
+    // eslint-disable-next-line no-param-reassign
+    else if (payload instanceof ArrayBuffer) payload = Buffer.from(payload);
+
+    const packet = JSON.parse(payload);
+    if (packet.op && packet.op === "stats") {
+        this.stats = { ...packet };
+        delete this.stats.op;
+    }
+    const player = this.manager.players.get(packet.guildId);
+    if (packet.guildId && player) player.emit(packet.op, packet);
+
+    packet.node = this;
+    /**
+     * Fire up when raw packets / or sending raw data
+     */
+    this.manager.emit("raw", packet);
+}
+
+    close(event) {
+    // if (!event) return "Unknown event";
+    /**
+     * Fire up when node disconnect
+     * @event nodeClosed
+     */
+    this.manager.emit("nodeClose", event, this);
+    if (event !== 1000) return this.reconnect();
+}
+
+
+    error(event) {
+    if (!event) return "Unknown event";
+
+    /**
+     * Fire up when node return an error
+     * @event nodeError
+     */
+    this.manager.emit("nodeError", event, this);
+    return this.reconnect();
+}
+
+reconnect() {
+    this.reconnect = setTimeout(() => {
+        this.connected = false;
+        this.ws.removeAllListeners();
+        this.ws = null;
+        this.manager.emit("nodeReconnect", this);
+        this.connect();
+    }, this.reconnectTime);
+}
+
+send(payload) {
+    this.ws.send(JSON.stringify(payload), (error) => {
+        if (error) return error;
+        return null;
+    });
+}
+
+
+
+ }
+
+
+
+ module.exports = Node;
+

package/src/Player.js

@@ -0,0 +1,317 @@
+const { EventEmitter } = require("events");
+const Queue = require("./guild/Queue");
+const Filters = require("./guild/Filter")
+class Player extends EventEmitter {
+    constructor(node, options, manager) {
+        super();
+
+        this.manager = manager;
+        this.queue = new Queue()
+        this.node = node;
+        this.filters = new Filters(this,this.node)
+
+       
+        this.guild = options.guild.id || options.guild;
+
+        this.voiceChannel = options.voiceChannel.id || options.voiceChannel;
+
+        this.textChannel = options.textChannel || null;
+
+        this.state = { volume: 100, equalizer: [] };
+
+        this.isConnectd = false;
+
+        this.trackRepeat = false;
+
+        this.queueRepeat = false;
+
+        this.loop = 0;
+
+
+        this.playing = false;
+
+        this.timestamp = Date.now();
+
+        this.position = 0;
+
+        this.isPaused = false
+
+       // this.tracks = {}
+       
+        this.currentTrack = {};
+
+        this.previousTrack = {};
+
+       
+        this.voiceUpdateState = null;
+
+       
+
+    
+
+
+        this.on("event", (data) => (this.lavalinkEvent(data).bind(this))());
+        this.on("event",(data)=> this.manager.emit("debug",data))
+        this.on("playerUpdate", (packet) => {
+            this.isConnectd = packet.state.connected,
+            this.position = packet.state.position
+            this.state = {
+                volume: this.state.volume,
+                equalizer: this.state.equalizer,
+                ...packet.state,
+            };
+        });
+    }
+    async play() {
+       
+        if(!this.queue.length){
+             return nulll;
+        }
+        this.currentTrack = this.queue.shift();
+        this.playing = true;
+        this.timestamp = Date.now();
+        this.node.send({
+            op: "play",
+            guildId: this.guild,
+            track: this.currentTrack.track,
+            volume: this.volume || 100,
+        });
+        this.position =0;
+        return this;
+    }
+
+
+    async stop() {
+
+        this.position = 0;
+        this.isConnectd = false
+        this.playing =false;
+        this.node.send({
+            op: "stop",
+            guildId: this.guild
+        });
+        return this;
+    }
+
+    pause(pause = true) {
+        if (typeof pause !== "boolean") throw new RangeError("Pause function must be pass with boolean value.");
+        if (this.paused || !this.queue.size) return this;
+        this.playing = !pause;
+        this.paused = pause;
+        this.node.send({
+            op: "pause",
+            guildId: this.guild,
+            pause,
+        });
+        return this;
+    }
+
+    async seekTo(position) {
+        if (Number.isNaN(position)) throw new RangeError("[Poru Error] Position must be a number.");
+        this.position = position;
+        this.node.send({
+            op: "seek",
+            guildId: this.guild,
+            position,
+        });
+        return this;
+    }
+
+    async setVolume(volume) {
+        if (Number.isNaN(volume)) throw new RangeError("Volume level must be a number.");
+        this.volume = volume;
+        this.node.send({
+            op: "volume",
+            guildId: this.guild,
+            volume: this.volume,
+        });
+        return this;
+
+    }
+
+    async TrackRepeat() {
+        this.loop = 1;
+        this.trackRepeat = true;
+        this.queueRepeat = false;
+        return this;
+    }
+
+    async QueueRepeat() {
+        this.loop = 2;
+        this.queueRepeat = true;
+        this.trackRepeat= false;
+        return this;
+    }
+
+    async DisableRepeat() {
+        this.loop = 0;
+        this.trackRepeat =false;
+        this.queueRepeat = false;
+     
+      
+        return this;
+    }
+
+ async   setTextChannel(channel) {
+        if (typeof channel !== "string") throw new RangeError("Channel must be a string.");
+        this.textChannel = channel;
+        return this;
+    }
+
+   async setVoiceChannel(channel) {
+        if (typeof channel !== "string") throw new RangeError("Channel must be a string.");
+        this.voiceChannel = channel;
+        return this;
+    }
+
+ async   connect(data) {
+        this.voiceUpdateState = data;
+        this.node.send({
+            op: "voiceUpdate",
+            guildId: this.guild,
+            ...data,
+        });
+        return this;
+    }
+
+    async reconnect() {
+        if (this.voiceChannel === null) return null;
+        this.node.send({
+            op: 4,
+            d: {
+                guild_id: this.guild,
+                channel_id: this.voiceChannel,
+                self_mute: false,
+                self_deaf: false,
+            },
+        });
+        return this;
+    }
+
+ 
+
+
+   async disconnect() {
+        if (this.voiceChannel === null) return null;
+        this.pause(true);
+        this.isConnectd = false;
+        this.manager.sendWS({
+            op: 4,
+            d: {
+                guild_id: this.guild,
+                channel_id: null,
+                self_mute: false,
+                self_deaf: false,
+            },
+        });
+        this.voiceChannel = null;
+        return this;
+    }
+
+    destroy() {
+        this.disconnect();
+        this.node.send({
+            op: "destroy",
+            guildId: this.guild,
+        });
+        this.manager.emit("playerDestroy", this);
+        this.manager.players.delete(this.guild);
+    }
+
+  async  autoplay(toggle =false){
+
+    if(!toggle) return null;
+        try{
+        if(!this.previousTrack) return this.stop();
+        let data = `https://www.youtube.com/watch?v=${this.previousTrack.identifier}&list=RD${this.previousTrack.identifier}`;
+
+        let response = await this.manager.search(data);
+
+        if (!response || !response.tracks || ["LOAD_FAILED", "NO_MATCHES"].includes(response.type)) return this.stop();
+
+        let track = response.tracks[Math.floor(Math.random() * Math.floor(response.tracks.length))];
+
+        this.queue.push(track);
+
+        this.play();
+
+        return this;
+
+        }catch(e){
+            console.log(`[Poru Autoplay] error : ${e}`)
+            return this.stop();
+        }
+
+    }
+
+
+    lavalinkEvent(data) {
+        const events = {
+            TrackStartEvent() {
+                this.playing =true;
+                this.paused =false;
+                this.manager.emit("trackStart", this, this.currentTrack);
+            },
+            // eslint-disable-next-line consistent-return
+            TrackEndEvent() {
+          
+               this.previousTrack = this.currentTrack;
+    
+                if (this.currentTrack && this.loop === 1) {
+                  
+                     this.queue.unshift(this.previousTrack)
+                     return this.play();
+                } else if (this.currentTrack && this.loop === 2) {
+                   
+                    this.queue.push(this.previousTrack)
+                    return this.play();
+                } 
+
+                if(this.queue.length ===0){
+                return this.manager.emit("queueEnd", this, this.track,data);
+                   // this.destroy();
+                } else if (this.queue.length>0) {
+                           
+                   return this.play();
+                }
+                    this.manager.emit("queueEnd", this, this.track,data);
+              
+            },
+            TrackStuckEvent() {
+              this.queue.shift();
+              this.manager.emit("trackError", this, this.track, data);
+            },
+            TrackExceptionEvent() {
+              this.queue.shift();
+              /**
+               * Fire up when there's an error while playing the track
+               * @event trackError
+               */
+              this.manager.emit("trackError", this, this.track, data);
+            },
+            WebSocketClosedEvent() {
+                if ([4015, 4009].includes(data.code)) {
+                    this.manager.sendWS({
+                        op: 4,
+                        d: {
+                            guild_id: data.guildId,
+                            channel_id: this.voiceChannel.id || this.voiceChannel,
+                            self_mute: this.options.selfMute || false,
+                            self_deaf: this.options.selfDeaf || false,
+                        },
+                    });
+                }
+                this.manager.emit("socketClosed", this, data);
+            },
+            default() {
+                throw new Error(`An unknown event: ${data}`);
+            },
+        };
+        return events[data.type] || events.default;
+    }
+
+
+}
+
+module.exports = Player;
+

package/src/Poru.js

@@ -0,0 +1,194 @@
+const { EventEmitter } = require("events");
+const fetch = (...args) => import('node-fetch').then(({
+    default: fetch
+}) => fetch(...args));const Player = require("./Player");
+const Node = require("./Node");
+const Response = require("./guild/Response");
+
+class Poru extends EventEmitter {
+    constructor(client, nodes, options = {}) {
+        super();
+        if (!client) throw new Error("[Poru Error] you did't provide a valid client");
+        if (!nodes) throw new Error("[Poru Error] you did't provide a lavalink nodes");
+
+        this.client = client;
+        this.player = options.player || Player;
+        this._nodes = nodes;
+        this.nodes = new Map();
+        this.players = new Map();
+        this.voiceStates = new Map();
+        this.voiceServers = new Map();
+        this.user = null;
+        this.shards = options.shards || 1;
+        this.sendWS = null;
+    }
+
+
+
+    //create a node and connect it with lavalink
+    createNode(options) {
+        const node = new Node(this, options);
+        if (options.name) {
+            this.nodes.set(options.name || options.host, node);
+            node.connect();
+            return node;
+        }
+        this.nodes.set(options.host, node);
+        node.connect();
+        return node;
+    }
+
+    //create  connection with discord voice channel
+    createConnection(data = {}, options = {}) {
+        const player = this.players.get(data.guild.id || data.guild);
+        if (player){
+            return player;
+        }
+        this.sendWS({
+            op: 4,
+            d: {
+                guild_id: data.guild.id || data.guild,
+                channel_id: data.voiceChannel.id || data.voiceChannel,
+                self_mute: options.selfMute || false,
+                self_deaf: options.selfDeaf || true,
+            },
+        });
+        return this.Player(data);
+    }
+
+    init(client) {
+
+        this.user =client.user.id;
+        this.sendWS = (data) => {
+            const guild = client.guilds.cache.get(data.d.guild_id);
+            if (guild) guild.shard.send(data);
+        }
+           // eslint-disable-next-line no-underscore-dangle
+        this._nodes.forEach((node) => this.createNode(node));
+        console.log(`Thanks for using Poru`)
+    }
+
+    voiceServersUpdate(data) {
+        this.voiceServers.set(data.guild_id, data);
+        return this.connectionProcess(data.guild_id);
+    }
+
+    voiceStateUpdate(data) {
+        if (data.user_id !== this.user) return;
+        if (data.channel_id) {
+            this.voiceStates.set(data.guild_id, data);
+            // eslint-disable-next-line consistent-return
+            return this.connectionProcess(data.guild_id);
+        }
+        this.voiceServers.delete(data.guild_id);
+        this.voiceStates.delete(data.guild_id);
+    }
+
+    packetUpdate(packet) {
+        if (packet.t === "VOICE_SERVER_UPDATE"){ 
+            this.voiceServersUpdate(packet.d);
+        }
+
+        if (packet.t === "VOICE_STATE_UPDATE"){
+             this.voiceStateUpdate(packet.d);
+        }
+    }
+
+    connectionProcess(guildId) {
+        const server = this.voiceServers.get(guildId);
+        const state = this.voiceStates.get(guildId);
+        if (!server) return false;
+        const player = this.players.get(guildId);
+        if (!player) return false;
+
+        player.connect({
+            sessionId: state ? state.session_id : player.voiceUpdateState.sessionId,
+            event: server,
+        });
+        return true;
+    }
+
+
+    get leastUsedNodes() {
+        return [...this.nodes.values()]
+            .filter((node) => node.isConnected)
+            .sort((a, b) => {
+                const aLoad = a.stats.cpu ? (a.stats.cpu.systemLoad / a.stats.cpu.cores) * 100 : 0;
+                const bLoad = b.stats.cpu ? (b.stats.cpu.systemLoad / b.stats.cpu.cores) * 100 : 0;
+                return aLoad - bLoad;
+            });
+    }
+
+    Player(data) {
+        const guild = data.guild.id || data.guild;
+        const Nodes = this.nodes.get(guild);
+        if (Nodes) return Nodes;
+        if (this.leastUsedNodes.length === 0) throw new Error("No nodes are avaliable");
+        const node = this.nodes.get(this.leastUsedNodes[0].name
+            || this.leastUsedNodes[0].host);
+        if (!node) throw new Error("No nodes are avalible");
+
+        // eslint-disable-next-line new-cap
+        const player = new this.player(node, data, this);
+        this.players.set(guild, player);
+
+        return player;
+    }
+
+    async search(track, source) {
+        const node = this.leastUsedNodes[0];
+        if (!node) throw new Error("No nodes are available.");
+        const regex = /^https?:\/\//;
+        if (!regex.test(track)) {
+            // eslint-disable-next-line no-param-reassign
+            track = `${source || "yt"}search:${track}`;
+        }
+        const result = await this.request(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
+      //  this.emit("error", result);
+        if (!result) throw new Error("No tracks found.");
+        return new Response(result);
+    }
+
+
+    async resolve(track, source) {
+        const node = this.leastUsedNodes[0];
+        if (!node) throw new Error("No nodes are available.");
+        const regex = /^https?:\/\//;
+        if (!regex.test(track)) {
+            // eslint-disable-next-line no-param-reassign
+            track = `${source || "yt"}search:${track}`;
+        }
+        const result = await this.request(node, "loadtracks", `identifier=${encodeURIComponent(track)}`);
+      //  this.emit("error", result);
+        if (!result) throw new Error("No tracks found.");
+        return new Response(result);
+    }
+
+
+    async decodeTrack(track) {
+        const node = this.leastUsedNodes[0];
+        if (!node) throw new Error("No nodes are available.");
+        const result = await this.request(node, "decodetrack", `track=${track}`);
+        this.emit("error", result);
+        if (result.status === 500) return null;
+        return result;
+    }
+
+    request(node, endpoint, param) {
+        return fetch(`http${node.secure ? "s" : ""}://${node.host}:${node.port}/${endpoint}?${param}`, {
+            headers: {
+                Authorization: node.password,
+            },
+        })
+            .then((r) => r.json())
+            .catch((e) => {
+                throw new Error(`[Poru Error] Failed to request to the lavalink.\n  error: ${e}`);
+            });
+    }
+
+    get(guildId) {
+        return this.players.get(guildId);
+    }
+}
+
+module.exports = Poru

package/src/config.json

@@ -0,0 +1,3 @@
+{
+    "client" :"Poru"
+}

package/src/guild/Filter.js

@@ -0,0 +1,168 @@
+class Filters {
+
+    constructor(player,options = {}) {
+        this._8d =options._8d|| null;
+        this.bassboost = options.bassboost || null;
+        this.player = player;
+        this.node = player.node
+        this.volume = player.volume ?? 1.0 ;
+        this.equalizer = options.equalizer || [];
+        this.karaoke = options.karaoke || null;
+        this.timescale = options.timescale || null;
+        this.tremolo = options.tremolo || null;
+        this.vibrato = options.vibrato || null;
+        this.rotation = options.rotation || null;
+        this.distortion = options.distortion || null;
+        this.channelMix = options.channelMix || null;
+        this.lowPass = options.lowPass || null;
+      }
+
+
+    setEqualizer(bands){
+        this.equalizer = bands;
+        this.updateFilters();
+        return this;
+    }
+    setKaraoke(karaoke) {
+        this.karaoke = karaoke|| null;
+        this.updateFilters();
+        return this;
+    }
+    setTimescale(timescale) {
+        this.updateFilters();
+        this.timescale = timescale || null;
+        return this;
+    }
+    setTremolo(tremolo) {
+        this.tremolo = tremolo || null;
+        this.updateFilters();
+        return this;
+    }
+
+    setVibrato(vibrato){
+        this.vibrato = vibrato || null;
+        this.updateFilters();
+        return this;
+    }
+
+    setRotation(rotation) {
+        this.rotation = rotation || null;
+        this.updateFilters();
+        return this;
+    }
+    setDistortion(distortion) {
+        this.distortion = distortion || null;
+        this.updateFilters();
+        return this;
+    }
+
+    setChannelMix(mix) {
+        this.channelMix = mix || null;
+        this.updateFilters();
+        return this;
+    }
+
+    setLowPass(pass) {
+        this.lowPass = pass || null;
+        this.updateFilters();
+        return this;
+    }
+
+    setFilters(options) {
+        this.player.filters = new Filters(options);
+        this.updateFilters();
+        return this;
+    }
+
+    clearFilters() {
+        this.player.filters = new Filters();
+        this.node.send({
+            op: "filters",
+            guildId: this.player.guild
+        });
+        return this;
+    }
+    setNightcore(val) {
+        if (!this.player) return;
+        this.setTimescale(val ? { rate: 1.5 } : null);
+        this.nightcore = val;
+        if (val) {
+          this.doubleTime = false;
+          this.vaporwave = false;
+        }
+        return this
+      }
+
+      setSlowmode(val) {
+        if (!this.player) return;
+        this.slowmode = val;
+        if (val) {
+        }
+        this.setFilters(
+          val
+            ? {
+                timescale: {
+                  speed: 0.5,
+                  pitch: 1.0,
+                  rate: 0.8,
+                },
+              }
+            : this.clearFilters()
+        );
+      }
+
+      setVaporwave(val) {
+        if (!this.player) return;
+        this.vaporwave = val;
+        if (val) {
+          this.doubleTime = false;
+          this.nightcore = false;
+        }
+        this.setTimescale(val ? { pitch: 0.5 } : null);
+      }
+    
+      set8D(val) {
+        if (!this.player) return;
+        this._8d = val;
+        this.setRotation(val ? { rotationHz: 0.2 } : null);
+      }
+
+    setBassboost(val) {
+        if (!this.player) return;
+        this.bassboost = !!val;
+        this.bassboost = val / 100;
+        this.player.setEqualizer(
+          val
+            ? Array(6)
+                .fill(0.22)
+                .map((x, i) => ({ band: i, gain: x * val }))
+            : []
+        );
+      }
+
+    updateFilters(){
+        console.log(this.node.send)
+        const { volume, equalizer, karaoke, timescale, tremolo, vibrato, rotation, distortion, channelMix, lowPass } = this;
+        this.node.send({
+            op:"filters",
+            guildId: this.player.guild,
+            volume,
+            equalizer,
+            karaoke,
+            timescale,
+            tremolo,
+            vibrato,
+            rotation,
+            distortion,
+            channelMix,
+            lowPass
+        });
+    }
+
+
+}
+
+
+
+
+module.exports = Filters;

package/src/guild/Queue.js

@@ -0,0 +1,50 @@
+class Queue extends Array{
+    constructor() {
+        super(...arguments);
+    }
+        get duration() {
+            return this.reduce((acc, val) => acc + val.info.length, 0);
+        }
+    
+        get totalSize() {
+            return this.length  + (this.current ? 1 : 0);
+        }
+    
+        get size() {
+            return this.length 
+        }
+    
+        get empty() {
+            return this.length / 2 < 1;
+        }
+    
+        first() {
+            return this ? this[0] : 0;
+        }
+
+        add(track) {
+            this.push(track);
+            return this;
+           }
+    
+        removeFirst() {
+            return this.shift();
+        }
+    
+        remove(index) {
+            return this.splice(index, 1)[0];
+        }
+    
+        clear() {
+            return this.splice(0);
+        }
+    
+        shuffle() {
+            for (let i = this.length - 1; i > 0; i -= 1) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [this[i], this[j]] = [this[j], this[i]];
+            }
+        }
+    }
+
+module.exports = Queue;

package/src/guild/Response.js

@@ -0,0 +1,11 @@
+const Track = require("./Track");
+
+class Response {
+    constructor(data) {
+        this.tracks = data.tracks.map((track) => new Track(track));
+        this.loadType = data.loadType;
+        this.playlistInfo = data.playlistInfo;
+      }
+  }
+  
+  module.exports =Response

package/src/guild/Track.js

@@ -0,0 +1,15 @@
+class Track {
+    constructor(data) {
+      this.uri = data.info.uri;
+      this.title = data.info.title;
+      this.author = data.info.author;
+      this.duration = data.info.length;
+      this.identifier = data.info.identifier;
+      this.isStream = data.info.isStream;
+      this.isSeekable = data.info.isSeekable;
+      this.track = data.track;
+      this.thumbnail = `https://i.ytimg.com/vi/${data.info.identifier}/maxresdefault.jpg` || null;
+    }
+}
+
+module.exports = Track;