lavalink-client 2.2.0 → 2.2.1

package/dist/esm/structures/Node.js

@@ -3,11 +3,15 @@ import WebSocket from "ws";
 import { DestroyReasons } from "./Player";
 import { NodeSymbol, queueTrackEnd } from "./Utils";
 export const validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];
+/**
+ * Lavalink Node creator class
+ */
 export class LavalinkNode {
     /** The provided Options of the Node */
     options;
     /** The amount of rest calls the node has made. */
     calls = 0;
+    /** Stats from lavalink, will be updated via an interval by lavalink. */
     stats = {
         players: 0,
         playingPlayers: 0,
@@ -29,6 +33,7 @@ export class LavalinkNode {
             sent: 0,
         }
     };
+    /** The current sessionId, only present when connected */
     sessionId = null;
     /** Wether the node resuming is enabled or not */
     resuming = { enabled: true, timeout: null };
@@ -48,6 +53,14 @@ export class LavalinkNode {
      * Create a new Node
      * @param options Lavalink Node Options
      * @param manager Node Manager
+     *
+     *
+     * @example
+     * ```ts
+     * // don't create a node manually, instead use:
+     *
+     * client.lavalink.nodeManager.createNode(options)
+     * ```
      */
     constructor(options, manager) {
         this.options = {
@@ -64,11 +77,43 @@ export class LavalinkNode {
         this.options.regions = (this.options.regions || []).map(a => a.toLowerCase());
         Object.defineProperty(this, NodeSymbol, { configurable: true, value: true });
     }
+    /**
+     * Parse url params correctly for lavalink requests, including support for urls and uris.
+     * @param url input url object
+     * @param extraQueryUrlParams UrlSearchParams to use in a encodedURI, useful for example for flowertts
+     * @returns the url as a valid string
+     *
+     * @example
+     * ```ts
+     * player.node.getRequestingUrl(new URL(`http://localhost:2333/v4/loadtracks?identifier=Never gonna give you up`));
+     * ```
+     */
+    getRequestingUrl(url, extraQueryUrlParams) {
+        if (!url.searchParams.size)
+            return `${url.origin}${url.pathname}`;
+        const keysToAdd = [];
+        for (const [paramKey, paramValue] of url.searchParams.entries()) {
+            const decoded = decodeURIComponent(paramValue).trim(); // double decoding, once internally, a second time if decoded by provided user.
+            if (decoded.includes("://") && !/^https?:\/\//.test(decoded)) { // uri, but not url.
+                const [key, ...values] = decoded.split("://");
+                keysToAdd.push(`${paramKey}=${encodeURI(`${key}://${encodeURIComponent(values.join("://"))}${extraQueryUrlParams && extraQueryUrlParams?.size > 0 ? `?${extraQueryUrlParams.toString()}` : ""}`)}`);
+                continue;
+            }
+            keysToAdd.push(`${paramKey}=${encodeURIComponent(decoded)}`);
+        }
+        return `${url.origin}${url.pathname}?${keysToAdd.join("&")}`;
+    }
     /**
      * Raw Request util function
      * @param endpoint endpoint string
      * @param modify modify the request
-     * @returns
+     * @param extraQueryUrlParams UrlSearchParams to use in a encodedURI, useful for example for flowertts
+     * @returns object containing request and option information
+     *
+     * @example
+     * ```ts
+     * player.node.rawRequest(`/loadtracks?identifier=Never gonna give you up`, (options) => options.method = "GET");
+     * ```
      */
     async rawRequest(endpoint, modify) {
         const options = {
@@ -82,16 +127,23 @@ export class LavalinkNode {
         modify?.(options);
         const url = new URL(`${this.restAddress}${options.path}`);
         url.searchParams.append("trace", "true");
+        const urlToUse = this.getRequestingUrl(url, options?.extraQueryUrlParams);
         delete options.path;
-        const request = await fetch(url.href, options);
+        delete options.extraQueryUrlParams;
+        const request = await fetch(urlToUse, options);
         this.calls++;
         return { request, options };
     }
     /**
-     * Makes an API call to the Node
+     * Makes an API call to the Node. Should only be used for manual parsing like for not supported plugins
      * @param endpoint The endpoint that we will make the call to
      * @param modify Used to modify the request before being sent
      * @returns The returned data
+     *
+     * @example
+     * ```ts
+     * player.node.request(`/loadtracks?identifier=Never gonna give you up`, (options) => options.method = "GET", false);
+     * ```
      */
     async request(endpoint, modify, parseAsText = false) {
         const { request, options } = await this.rawRequest(endpoint, modify);
@@ -105,9 +157,17 @@ export class LavalinkNode {
      * Search something raw on the node, please note only add tracks to players of that node
      * @param query SearchQuery Object
      * @param requestUser Request User for creating the player(s)
+     * @param throwOnEmpty Wether to throw on an empty result or not
      * @returns Searchresult
+     *
+     * @example
+     * ```ts
+     * // use player.search() instead
+     * player.node.search({ query: "Never gonna give you up by Rick Astley", source: "soundcloud" }, interaction.user);
+     * player.node.search({ query: "https://deezer.com/track/123456789" }, interaction.user);
+     * ```
      */
-    async search(query, requestUser) {
+    async search(query, requestUser, throwOnEmpty = false) {
         const Query = this.NodeManager.LavalinkManager.utils.transformQuery(query);
         this.NodeManager.LavalinkManager.utils.validateQueryString(this, Query.query, Query.source);
         if (Query.source)
@@ -117,19 +177,25 @@ export class LavalinkNode {
         }
         let uri = `/loadtracks?identifier=`;
         if (/^https?:\/\//.test(Query.query) || ["http", "https", "link", "uri"].includes(Query.source)) { // if it's a link simply encode it
-            uri += encodeURIComponent(decodeURIComponent(Query.query));
+            uri += encodeURIComponent(Query.query);
         }
         else { // if not make a query out of it
             if (Query.source !== "local")
                 uri += `${Query.source}:`; // only add the query source string if it's not a local track
             if (Query.source === "ftts")
-                uri += `//${encodeURIComponent(encodeURI(decodeURIComponent(Query.query)))}`;
+                uri += `//${encodeURIComponent(Query.query)}`;
             else
-                uri += encodeURIComponent(decodeURIComponent(Query.query));
+                uri += encodeURIComponent(Query.query);
         }
-        const res = await this.request(uri);
+        const res = await this.request(uri, (options) => {
+            if (typeof query === "object" && typeof query.extraQueryUrlParams?.size === "number" && query.extraQueryUrlParams?.size > 0) {
+                options.extraQueryUrlParams = query.extraQueryUrlParams;
+            }
+        });
         // transform the data which can be Error, Track or Track[] to enfore [Track]
         const resTracks = res.loadType === "playlist" ? res.data?.tracks : res.loadType === "track" ? [res.data] : res.loadType === "search" ? Array.isArray(res.data) ? res.data : [res.data] : [];
+        if (throwOnEmpty === true && (res.loadType === "empty" || !resTracks.length))
+            throw new Error("Nothing found");
         return {
             loadType: res.loadType,
             exception: res.loadType === "error" ? res.data : null,
@@ -146,6 +212,19 @@ export class LavalinkNode {
             tracks: (resTracks.length ? resTracks.map(t => this.NodeManager.LavalinkManager.utils.buildTrack(t, requestUser)) : [])
         };
     }
+    /**
+     * Search something using the lavaSearchPlugin (filtered searches by types)
+     * @param query LavaSearchQuery Object
+     * @param requestUser Request User for creating the player(s)
+     * @param throwOnEmpty Wether to throw on an empty result or not
+     * @returns LavaSearchresult
+     *
+     * @example
+     * ```ts
+     * // use player.search() instead
+     * player.node.lavaSearch({ types: ["playlist", "album"], query: "Rick Astley", source: "spotify" }, interaction.user);
+     * ```
+     */
     async lavaSearch(query, requestUser, throwOnEmpty = false) {
         const Query = this.NodeManager.LavalinkManager.utils.transformLavaSearchQuery(query);
         if (Query.source)
@@ -159,9 +238,9 @@ export class LavalinkNode {
         if (!this.info.plugins.find(v => v.name === "lavasrc-plugin"))
             throw new RangeError(`there is no lavasrc-plugin available in the lavalink node: ${this.id}`);
         const { request } = await this.rawRequest(`/loadsearch?query=${Query.source ? `${Query.source}:` : ""}${encodeURIComponent(Query.query)}${Query.types?.length ? `&types=${Query.types.join(",")}` : ""}`);
-        if (throwOnEmpty === true)
-            throw new Error("Nothing found");
         const res = (request.status === 204 ? {} : await request.json());
+        if (throwOnEmpty === true && !Object.entries(res).flat().filter(Boolean).length)
+            throw new Error("Nothing found");
         return {
             tracks: res.tracks?.map(v => this.NodeManager.LavalinkManager.utils.buildTrack(v, requestUser)) || [],
             albums: res.albums?.map(v => ({ info: v.info, pluginInfo: v?.plugin || v.pluginInfo, tracks: v.tracks.map(v => this.NodeManager.LavalinkManager.utils.buildTrack(v, requestUser)) })) || [],
@@ -173,8 +252,14 @@ export class LavalinkNode {
     }
     /**
      * Update the Player State on the Lavalink Server
-     * @param data
-     * @returns
+     * @param data data to send to lavalink and sync locally
+     * @returns result from lavalink
+     *
+     * @example
+     * ```ts
+     * // use player.search() instead
+     * player.node.updatePlayer({ guildId: player.guildId, playerOptions: { paused: true } }); // example to pause it
+     * ```
      */
     async updatePlayer(data) {
         if (!this.sessionId)
@@ -196,7 +281,13 @@ export class LavalinkNode {
     /**
      * Destroys the Player on the Lavalink Server
      * @param guildId
-     * @returns
+     * @returns request result
+     *
+     * @example
+     * ```ts
+     * // use player.destroy() instead
+     * player.node.destroyPlayer(player.guildId);
+     * ```
      */
     async destroyPlayer(guildId) {
         if (!this.sessionId)
@@ -206,7 +297,15 @@ export class LavalinkNode {
     /**
      * Connect to the Lavalink Node
      * @param sessionId Provide the Session Id of the previous connection, to resume the node and it's player(s)
-     * @returns
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * player.node.connect(); // if provided on bootup in managerOptions#nodes, this will be called automatically when doing lavalink.init()
+     *
+     * // or connect from a resuming session:
+     * player.node.connect("sessionId");
+     * ```
      */
     connect(sessionId) {
         if (this.connected)
@@ -226,13 +325,28 @@ export class LavalinkNode {
         this.socket.on("message", this.message.bind(this));
         this.socket.on("error", this.error.bind(this));
     }
-    /** Get the id of the node */
+    /**
+     * Get the id of the node
+     *
+     * @example
+     * ```ts
+     * const nodeId = player.node.id;
+     * console.log("node id is: ", nodeId)
+     * ```
+     */
     get id() {
         return this.options.id || `${this.options.host}:${this.options.port}`;
     }
     /**
      * Destroys the Node-Connection (Websocket) and all player's of the node
-     * @returns
+     * @param destroyReason Destroyreason to use when destroying the players
+     * @param deleteNode wether to delete the nodte from the nodes list too, if false it will emit a disconnect. @default true
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * player.node.destroy("custom Player Destroy Reason", true);
+     * ```
      */
     destroy(destroyReason, deleteNode = true) {
         if (!this.connected)
@@ -254,14 +368,47 @@ export class LavalinkNode {
         }
         return;
     }
-    /** Returns if connected to the Node. */
+    /**
+     * Returns if connected to the Node.
+     *
+     * @example
+     * ```ts
+     * const isConnected = player.node.connected;
+     * console.log("node is connected: ", isConnected ? "yes" : "no")
+     * ```
+     */
     get connected() {
         if (!this.socket)
             return false;
         return this.socket.readyState === WebSocket.OPEN;
     }
+    /**
+     * Returns the current ConnectionStatus
+     *
+     * @example
+     * ```ts
+     * try {
+     *     const statusOfConnection = player.node.connectionStatus;
+     *     console.log("node's connection status is:", statusOfConnection)
+     * } catch (error) {
+     *     console.error("no socket available?", error)
+     * }
+     * ```
+     */
+    get connectionStatus() {
+        if (!this.socket)
+            throw new Error("no websocket was initialized yet");
+        return ["CONNECTING", "OPEN", "CLOSING", "CLOSED"][this.socket.readyState] || "UNKNOWN";
+    }
     /**
      * Gets all Players of a Node
+     * @returns array of players inside of lavalink
+     *
+     * @example
+     * ```ts
+     * const node = lavalink.nodes.get("NODEID");
+     * const playersOfLavalink = await node?.fetchAllPlayers();
+     * ```
      */
     async fetchAllPlayers() {
         if (!this.sessionId)
@@ -274,6 +421,13 @@ export class LavalinkNode {
     }
     /**
      * Gets specific Player Information
+     * @returns lavalink player object if player exists on lavalink
+     *
+     * @example
+     * ```ts
+     * const node = lavalink.nodes.get("NODEID");
+     * const playerInformation = await node?.fetchPlayer("guildId");
+     * ```
      */
     async fetchPlayer(guildId) {
         if (!this.sessionId)
@@ -284,6 +438,13 @@ export class LavalinkNode {
      * Updates the session with and enables/disables resuming and timeout
      * @param resuming Whether resuming is enabled for this session or not
      * @param timeout The timeout in seconds (default is 60s)
+     * @returns the result of the request
+     *
+     * @example
+     * ```ts
+     * const node = player.node || lavalink.nodes.get("NODEID");
+     * await node?.updateSession(true, 180e3); // will enable resuming for 180seconds
+     * ```
      */
     async updateSession(resuming, timeout) {
         if (!this.sessionId)
@@ -308,20 +469,35 @@ export class LavalinkNode {
      */
     decode = {
         /**
-         * Decode a single track into its info, where BASE64 is the encoded base64 data.
-         * @param encoded
-         * @returns
+         * Decode a single track into its info
+         * @param encoded valid encoded base64 string from a track
+         * @param requester the requesteruser for building the track
+         * @returns decoded track from lavalink
+         *
+         * @example
+         * ```ts
+         * const encodedBase64 = 'QAACDgMACk5vIERpZ2dpdHkAC0JsYWNrc3RyZWV0AAAAAAAEo4AABjkxNjQ5NgABAB9odHRwczovL2RlZXplci5jb20vdHJhY2svOTE2NDk2AQBpaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvY292ZXIvZGFlN2EyNjViNzlmYjcxMjc4Y2RlMjUwNDg0OWQ2ZjcvMTAwMHgxMDAwLTAwMDAwMC04MC0wLTAuanBnAQAMVVNJUjE5NjAwOTc4AAZkZWV6ZXIBAChObyBEaWdnaXR5OiBUaGUgVmVyeSBCZXN0IE9mIEJsYWNrc3RyZWV0AQAjaHR0cHM6Ly93d3cuZGVlemVyLmNvbS9hbGJ1bS8xMDMyNTQBACJodHRwczovL3d3dy5kZWV6ZXIuY29tL2FydGlzdC8xODYxAQBqaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvYXJ0aXN0L2YxNmNhYzM2ZmVjMzkxZjczN2I3ZDQ4MmY1YWM3M2UzLzEwMDB4MTAwMC0wMDAwMDAtODAtMC0wLmpwZwEAT2h0dHBzOi8vY2RuLXByZXZpZXctYS5kemNkbi5uZXQvc3RyZWFtL2MtYTE1Yjg1NzFhYTYyMDBjMDQ0YmY1OWM3NmVkOTEyN2MtNi5tcDMAAAAAAAAAAAA=';
+         * const track = await player.node.decode.singleTrack(encodedBase64, interaction.user);
+         * ```
          */
         singleTrack: async (encoded, requester) => {
             if (!encoded)
                 throw new SyntaxError("No encoded (Base64 string) was provided");
             // return the decoded + builded track
-            return this.NodeManager.LavalinkManager.utils.buildTrack(await this.request(`/decodetrack?encodedTrack=${encoded}`), requester);
+            return this.NodeManager.LavalinkManager.utils?.buildTrack(await this.request(`/decodetrack?encodedTrack=${encodeURIComponent(encoded.replace(/\s/g, ""))}`), requester);
         },
         /**
+         * Decodes multiple tracks into their info
+         * @param encodeds valid encoded base64 string array from all tracks
+         * @param requester the requesteruser for building the tracks
+         * @returns array of all tracks you decoded
          *
-         * @param encodeds Decodes multiple tracks into their info
-         * @returns
+         * @example
+         * ```ts
+         * const encodedBase64_1 = 'QAACDgMACk5vIERpZ2dpdHkAC0JsYWNrc3RyZWV0AAAAAAAEo4AABjkxNjQ5NgABAB9odHRwczovL2RlZXplci5jb20vdHJhY2svOTE2NDk2AQBpaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvY292ZXIvZGFlN2EyNjViNzlmYjcxMjc4Y2RlMjUwNDg0OWQ2ZjcvMTAwMHgxMDAwLTAwMDAwMC04MC0wLTAuanBnAQAMVVNJUjE5NjAwOTc4AAZkZWV6ZXIBAChObyBEaWdnaXR5OiBUaGUgVmVyeSBCZXN0IE9mIEJsYWNrc3RyZWV0AQAjaHR0cHM6Ly93d3cuZGVlemVyLmNvbS9hbGJ1bS8xMDMyNTQBACJodHRwczovL3d3dy5kZWV6ZXIuY29tL2FydGlzdC8xODYxAQBqaHR0cHM6Ly9lLWNkbnMtaW1hZ2VzLmR6Y2RuLm5ldC9pbWFnZXMvYXJ0aXN0L2YxNmNhYzM2ZmVjMzkxZjczN2I3ZDQ4MmY1YWM3M2UzLzEwMDB4MTAwMC0wMDAwMDAtODAtMC0wLmpwZwEAT2h0dHBzOi8vY2RuLXByZXZpZXctYS5kemNkbi5uZXQvc3RyZWFtL2MtYTE1Yjg1NzFhYTYyMDBjMDQ0YmY1OWM3NmVkOTEyN2MtNi5tcDMAAAAAAAAAAAA=';
+         * const encodedBase64_2 = 'QAABJAMAClRhbGsgYSBMb3QACjQwNHZpbmNlbnQAAAAAAAHr1gBxTzpodHRwczovL2FwaS12Mi5zb3VuZGNsb3VkLmNvbS9tZWRpYS9zb3VuZGNsb3VkOnRyYWNrczo4NTE0MjEwNzYvMzUyYTRiOTAtNzYxOS00M2E5LWJiOGItMjIxMzE0YzFjNjNhL3N0cmVhbS9obHMAAQAsaHR0cHM6Ly9zb3VuZGNsb3VkLmNvbS80MDR2aW5jZW50L3RhbGstYS1sb3QBADpodHRwczovL2kxLnNuZGNkbi5jb20vYXJ0d29ya3MtRTN1ek5Gc0Y4QzBXLTAtb3JpZ2luYWwuanBnAQAMUVpITkExOTg1Nzg0AApzb3VuZGNsb3VkAAAAAAAAAAA=';
+         * const tracks = await player.node.decode.multipleTracks([encodedBase64_1, encodedBase64_2], interaction.user);
+         * ```
          */
         multipleTracks: async (encodeds, requester) => {
             if (!Array.isArray(encodeds) || !encodeds.every(v => typeof v === "string" && v.length > 1))
@@ -337,14 +513,24 @@ export class LavalinkNode {
     };
     /**
      * Request Lavalink statistics.
-     * @returns
+     * @returns the lavalink node stats
+     *
+     * @example
+     * ```ts
+     * const lavalinkStats = await player.node.fetchStats();
+     * ```
      */
     async fetchStats() {
         return await this.request(`/stats`);
     }
     /**
      * Request Lavalink version.
-     * @returns
+     * @returns the current used lavalink version
+     *
+     * @example
+     * ```ts
+     * const lavalinkVersion = await player.node.fetchVersion();
+     * ```
      */
     async fetchVersion() {
         // need to adjust path for no-prefix version info
@@ -352,7 +538,14 @@ export class LavalinkNode {
     }
     /**
      * Request Lavalink information.
-     * @returns
+     * @returns lavalink info object
+     *
+     * @example
+     * ```ts
+     * const lavalinkInfo = await player.node.fetchInfo();
+     * const availablePlugins:string[] = lavalinkInfo.plugins.map(plugin => plugin.name);
+     * const availableSources:string[] = lavalinkInfo.sourceManagers;
+     * ```
      */
     async fetchInfo() {
         return await this.request(`/info`);
@@ -362,7 +555,15 @@ export class LavalinkNode {
      */
     routePlannerApi = {
         /**
-         * Get routplanner Info from Lavalink
+         * Get routplanner Info from Lavalink for ip rotation
+         * @returns the status of the routeplanner
+         *
+         * @example
+         * ```ts
+         * const routePlannerStatus = await player.node.routePlannerApi.getStatus();
+         * const usedBlock = routePlannerStatus.details?.ipBlock;
+         * const currentIp = routePlannerStatus.currentAddress;
+         * ```
          */
         getStatus: async () => {
             if (!this.sessionId)
@@ -370,8 +571,14 @@ export class LavalinkNode {
             return await this.request(`/routeplanner/status`);
         },
         /**
-         * Release blacklisted IP address into pool of IPs
+         * Release blacklisted IP address into pool of IPs for ip rotation
          * @param address IP address
+         * @returns request data of the request
+         *
+         * @example
+         * ```ts
+         * await player.node.routePlannerApi.unmarkFailedAddress("ipv6address");
+         * ```
          */
         unmarkFailedAddress: async (address) => {
             if (!this.sessionId)
@@ -385,6 +592,12 @@ export class LavalinkNode {
         },
         /**
          * Release all blacklisted IP addresses into pool of IPs
+         * @returns request data of the request
+         *
+         * @example
+         * ```ts
+         * await player.node.routePlannerApi.unmarkAllFailedAddresses();
+         * ```
          */
         unmarkAllFailedAddresses: async () => {
             if (!this.sessionId)
@@ -396,7 +609,7 @@ export class LavalinkNode {
             });
         }
     };
-    /** Private Utils */
+    /** @private Utils for validating the */
     validate() {
         if (!this.options.authorization)
             throw new SyntaxError("LavalinkNode requires 'authorization'");
@@ -405,6 +618,12 @@ export class LavalinkNode {
         if (!this.options.port)
             throw new SyntaxError("LavalinkNode requires 'port'");
     }
+    /**
+     * Sync the data of the player you make an action to lavalink to
+     * @param data data to use to update the player
+     * @param res result data from lavalink, to override, if available
+     * @returns boolean
+     */
     syncPlayerData(data, res) {
         if (typeof data === "object" && typeof data?.guildId === "string" && typeof data.playerOptions === "object" && Object.keys(data.playerOptions).length > 1) {
             const player = this.NodeManager.LavalinkManager.getPlayer(data.guildId);
@@ -415,8 +634,9 @@ export class LavalinkNode {
                 player.playing = !data.playerOptions.paused;
             }
             if (typeof data.playerOptions.position === "number") {
-                player.position = data.playerOptions.position;
+                // player.position = data.playerOptions.position;
                 player.lastPosition = data.playerOptions.position;
+                player.lastPositionChange = Date.now();
             }
             if (typeof data.playerOptions.voice !== "undefined")
                 player.voice = data.playerOptions.voice;
@@ -467,9 +687,22 @@ export class LavalinkNode {
         }
         return true;
     }
+    /**
+     * Get the rest Adress for making requests
+     */
     get restAddress() {
         return `http${this.options.secure ? "s" : ""}://${this.options.host}:${this.options.port}`;
     }
+    /**
+     * Reconnect to the lavalink node
+     * @param instaReconnect @default false wether to instantly try to reconnect
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * await player.node.reconnect();
+     * ```
+     */
     reconnect(instaReconnect = false) {
         if (instaReconnect) {
             if (this.reconnectAttempts >= this.options.retryAmount) {
@@ -497,6 +730,7 @@ export class LavalinkNode {
             this.reconnectAttempts++;
         }, this.options.retryDelay || 1000);
     }
+    /** @private util function for handling opening events from websocket */
     async open() {
         if (this.reconnectTimeout)
             clearTimeout(this.reconnectTimeout);
@@ -509,16 +743,19 @@ export class LavalinkNode {
         }
         this.NodeManager.emit("connect", this);
     }
+    /** @private util function for handling closing events from websocket */
     close(code, reason) {
         this.NodeManager.emit("disconnect", this, { code, reason });
         if (code !== 1000 || reason !== "Node-Destroy")
             this.reconnect();
     }
+    /** @private util function for handling error events from websocket */
     error(error) {
         if (!error)
             return;
         this.NodeManager.emit("error", this, error);
     }
+    /** @private util function for handling message events from websocket */
     async message(d) {
         if (Array.isArray(d))
             d = Buffer.concat(d);
@@ -539,42 +776,15 @@ export class LavalinkNode {
                     if (!player)
                         return;
                     const oldPlayer = player?.toJSON();
-                    if (player.get("internal_updateInterval"))
-                        clearInterval(player.get("internal_updateInterval"));
-                    // override the position
-                    player.position = payload.state.position || 0;
+                    player.lastPositionChange = Date.now();
                     player.lastPosition = payload.state.position || 0;
                     player.connected = payload.state.connected;
                     player.ping.ws = payload.state.ping >= 0 ? payload.state.ping : player.ping.ws <= 0 && player.connected ? null : player.ping.ws || 0;
                     if (!player.createdTimeStamp && payload.state.time)
                         player.createdTimeStamp = payload.state.time;
-                    if (typeof this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval === "number" && this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval >= 10) {
-                        player.set("internal_updateInterval", setInterval(() => {
-                            player.position += this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval || 250;
-                            if (player.filterManager.filterUpdatedState >= 1) {
-                                player.filterManager.filterUpdatedState++;
-                                const maxMins = 8;
-                                const currentDuration = player.queue.current?.info?.duration || 0;
-                                if (currentDuration <= maxMins * 6e4 || isAbsolute(player.queue.current?.info?.uri)) {
-                                    if (player.filterManager.filterUpdatedState >= ((this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval || 250) > 400 ? 2 : 3)) {
-                                        player.filterManager.filterUpdatedState = 0;
-                                        player.seek(player.position);
-                                    }
-                                }
-                                else {
-                                    player.filterManager.filterUpdatedState = 0;
-                                }
-                            }
-                        }, this.NodeManager.LavalinkManager.options.playerOptions.clientBasedPositionUpdateInterval || 250));
-                    }
-                    else {
-                        if (player.filterManager.filterUpdatedState >= 1) { // if no interval but instafix available, findable via the "filterUpdatedState" property
-                            const maxMins = 8;
-                            const currentDuration = player.queue.current?.info?.duration || 0;
-                            if (currentDuration <= maxMins * 6e4 || isAbsolute(player.queue.current?.info?.uri))
-                                player.seek(player.position);
-                            player.filterManager.filterUpdatedState = 0;
-                        }
+                    if (player.filterManager.filterUpdatedState === true && ((player.queue.current?.info?.duration || 0) <= (player.LavalinkManager.options.advancedOptions.maxFilterFixDuration || 600000) || isAbsolute(player.queue.current?.info?.uri))) {
+                        player.filterManager.filterUpdatedState = false;
+                        await player.seek(player.position);
                     }
                     this.NodeManager.LavalinkManager.emit("playerUpdate", oldPlayer, player);
                 }
@@ -594,7 +804,7 @@ export class LavalinkNode {
                 return;
         }
     }
-    // LAVALINK EVENT HANDLING UTIL FUNCTION
+    /** @private middleware util function for handling all kind of events from websocket */
     async handleEvent(payload) {
         if (!payload.guildId)
             return;
@@ -621,7 +831,7 @@ export class LavalinkNode {
                 this.SponsorBlockSegmentLoaded(player, player.queue.current, payload);
                 break;
             case "SegmentSkipped":
-                this.SponsorBlockSegmentkipped(player, player.queue.current, payload);
+                this.SponsorBlockSegmentSkipped(player, player.queue.current, payload);
                 break;
             case "ChaptersLoaded":
                 this.SponsorBlockChaptersLoaded(player, player.queue.current, payload);
@@ -635,7 +845,7 @@ export class LavalinkNode {
         }
         return;
     }
-    // LAVALINK EVENT HANDLING FUNCTIONS
+    /** @private util function for handling trackStart event */
     trackStart(player, track, payload) {
         player.playing = true;
         player.paused = false;
@@ -644,6 +854,7 @@ export class LavalinkNode {
             return;
         return this.NodeManager.LavalinkManager.emit("trackStart", player, track, payload);
     }
+    /** @private util function for handling trackEnd event */
     async trackEnd(player, track, payload) {
         // If there are no songs in the queue
         if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
@@ -680,6 +891,7 @@ export class LavalinkNode {
         // play track if autoSkip is true
         return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
     }
+    /** @private util function for handling trackStuck event */
     async trackStuck(player, track, payload) {
         this.NodeManager.LavalinkManager.emit("trackStuck", player, track, payload);
         // If there are no songs in the queue
@@ -693,6 +905,7 @@ export class LavalinkNode {
         // play track if autoSkip is true
         return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
     }
+    /** @private util function for handling trackError event */
     async trackError(player, track, payload) {
         this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
         return; // get's handled by trackEnd
@@ -707,23 +920,37 @@ export class LavalinkNode {
         // play track if autoSkip is true
         return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
     }
+    /** @private util function for handling socketClosed event */
     socketClosed(player, payload) {
         return this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);
     }
-    // SPONSOR BLOCK EVENT FUNCTIONS
+    /** @private util function for handling SponsorBlock Segmentloaded event */
     SponsorBlockSegmentLoaded(player, track, payload) {
         return this.NodeManager.LavalinkManager.emit("SegmentsLoaded", player, track, payload);
     }
-    SponsorBlockSegmentkipped(player, track, payload) {
+    /** @private util function for handling SponsorBlock SegmentSkipped event */
+    SponsorBlockSegmentSkipped(player, track, payload) {
         return this.NodeManager.LavalinkManager.emit("SegmentSkipped", player, track, payload);
     }
+    /** @private util function for handling SponsorBlock Chaptersloaded event */
     SponsorBlockChaptersLoaded(player, track, payload) {
         return this.NodeManager.LavalinkManager.emit("ChaptersLoaded", player, track, payload);
     }
+    /** @private util function for handling SponsorBlock Chaptersstarted event */
     SponsorBlockChapterStarted(player, track, payload) {
         return this.NodeManager.LavalinkManager.emit("ChapterStarted", player, track, payload);
     }
-    // SPONSOR BLOCK EXECUTE FUNCTIONS
+    /**
+     * Get the current sponsorblocks for the sponsorblock plugin
+     * @param player passthrough the player
+     * @returns sponsorblock seggment from lavalink
+     *
+     * @example
+     * ```ts
+     * // use it on the player via player.getSponsorBlock();
+     * const sponsorBlockSegments = await player.node.getSponsorBlock(player);
+     * ```
+     */
     async getSponsorBlock(player) {
         // no plugin enabled
         if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
@@ -731,6 +958,17 @@ export class LavalinkNode {
         // do the request
         return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`);
     }
+    /**
+     * Set the current sponsorblocks for the sponsorblock plugin
+     * @param player passthrough the player
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * // use it on the player via player.setSponsorBlock();
+     * const sponsorBlockSegments = await player.node.setSponsorBlock(player, ["sponsor", "selfpromo"]);
+     * ```
+     */
     async setSponsorBlock(player, segments = ["sponsor", "selfpromo"]) {
         // no plugin enabled
         if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
@@ -749,6 +987,17 @@ export class LavalinkNode {
         });
         return;
     }
+    /**
+     * Delete the sponsorblock plugins
+     * @param player passthrough the player
+     * @returns void
+     *
+     * @example
+     * ```ts
+     * // use it on the player via player.deleteSponsorBlock();
+     * const sponsorBlockSegments = await player.node.deleteSponsorBlock(player);
+     * ```
+     */
     async deleteSponsorBlock(player) {
         // no plugin enabled
         if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
@@ -759,7 +1008,7 @@ export class LavalinkNode {
         });
         return;
     }
-    // UTIL FOR QUEUE END
+    /** private util function for handling the queue end event */
     async queueEnd(player, track, payload) {
         // add previous track to the queue!
         player.queue.current = null;