lavalink-client 2.1.7 → 2.2.1

package/dist/esm/structures/Node.js

@@ -1,14 +1,17 @@
 import { isAbsolute } from "path";
-import { Pool } from "undici";
 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,
@@ -30,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 };
@@ -43,97 +47,155 @@ export class LavalinkNode {
     reconnectAttempts = 1;
     /** The Socket of the Lavalink */
     socket = null;
-    /** The Rest Server for this Lavalink */
-    rest;
     /** Version of what the Lavalink Server should be */
     version = "v4";
     /**
      * 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 = {
             secure: false,
             retryAmount: 5,
             retryDelay: 30e3,
-            requestTimeout: 10e3,
+            requestSignalTimeoutMS: 10000,
             ...options
         };
         this.NodeManager = manager;
         this.validate();
         if (this.options.secure && this.options.port !== 443)
             throw new SyntaxError("If secure is true, then the port must be 443");
-        this.rest = new Pool(this.poolAddress, this.options.poolOptions);
         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 = {
             path: `/${this.version}/${endpoint.replace(/^\//gm, "")}`,
             method: "GET",
             headers: {
-                Authorization: this.options.authorization
+                "Authorization": this.options.authorization
             },
-            headersTimeout: this.options.requestTimeout,
+            signal: this.options.requestSignalTimeoutMS && this.options.requestSignalTimeoutMS > 0 ? AbortSignal.timeout(this.options.requestSignalTimeoutMS) : undefined,
         };
         modify?.(options);
-        const url = new URL(`${this.poolAddress}${options.path}`);
+        const url = new URL(`${this.restAddress}${options.path}`);
         url.searchParams.append("trace", "true");
-        options.path = url.pathname + url.search;
-        const request = await this.rest.request(options);
+        const urlToUse = this.getRequestingUrl(url, options?.extraQueryUrlParams);
+        delete options.path;
+        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);
         if (["DELETE", "PUT"].includes(options.method))
             return;
-        if (request.statusCode === 404)
+        if (request.status === 404)
             throw new Error(`Node Request resulted into an error, request-PATH: ${options.path} | headers: ${JSON.stringify(request.headers)}`);
-        return parseAsText ? await request.body.text() : await request.body.json();
+        return parseAsText ? await request.text() : await request.json();
     }
     /**
      * 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)
             this.NodeManager.LavalinkManager.utils.validateSourceString(this, Query.source);
-        if (["bcsearch", "bandcamp"].includes(Query.source)) {
-            throw new Error("Bandcamp Search only works on the player!");
+        if (["bcsearch", "bandcamp"].includes(Query.source) && !this.info.sourceManagers.includes("bandcamp")) {
+            throw new Error("Bandcamp Search only works on the player (lavaplayer version < 2.2.0!");
         }
         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,
@@ -150,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)
@@ -163,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)
+        const res = (request.status === 204 ? {} : await request.json());
+        if (throwOnEmpty === true && !Object.entries(res).flat().filter(Boolean).length)
             throw new Error("Nothing found");
-        const res = (request.statusCode === 204 ? {} : await request.body.json());
         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)) })) || [],
@@ -177,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)
@@ -190,7 +271,7 @@ export class LavalinkNode {
             r.headers["Content-Type"] = "application/json";
             r.body = JSON.stringify(data.playerOptions);
             if (data.noReplace) {
-                const url = new URL(`${this.poolAddress}${r.path}`);
+                const url = new URL(`${this.restAddress}${r.path}`);
                 url.searchParams.append("noReplace", data.noReplace === true && typeof data.noReplace === "boolean" ? "true" : "false");
                 r.path = url.pathname + url.search;
             }
@@ -200,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)
@@ -210,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)
@@ -230,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)
@@ -258,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)
@@ -278,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)
@@ -288,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)
@@ -312,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))
@@ -341,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
@@ -356,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`);
@@ -366,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)
@@ -374,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)
@@ -389,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)
@@ -400,7 +609,7 @@ export class LavalinkNode {
             });
         }
     };
-    /** Private Utils */
+    /** @private Utils for validating the */
     validate() {
         if (!this.options.authorization)
             throw new SyntaxError("LavalinkNode requires 'authorization'");
@@ -409,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);
@@ -419,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;
@@ -471,9 +687,22 @@ export class LavalinkNode {
         }
         return true;
     }
-    get poolAddress() {
+    /**
+     * 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) {
@@ -501,28 +730,32 @@ 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);
         // reset the reconnect attempts amount
         this.reconnectAttempts = 1;
-        this.info = await this.fetchInfo().catch(() => null);
+        this.info = await this.fetchInfo().catch((e) => (console.error(e, "ON-OPEN-FETCH"), null));
         if (!this.info && ["v3", "v4"].includes(this.version)) {
-            const errorString = `Lavalink Node (${this.poolAddress}) does not provide any /${this.version}/info`;
+            const errorString = `Lavalink Node (${this.restAddress}) does not provide any /${this.version}/info`;
             throw new Error(errorString);
         }
         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);
@@ -543,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);
                 }
@@ -598,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;
@@ -625,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);
@@ -639,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;
@@ -648,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")))
@@ -684,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
@@ -697,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
@@ -711,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"))
@@ -735,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"))
@@ -753,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"))
@@ -763,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;