lavalink-client 1.1.25 → 1.2.1

package/dist/esm/structures/Node.js

@@ -3,6 +3,7 @@ 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"];
 export class LavalinkNode {
     /** The provided Options of the Node */
     options;
@@ -94,9 +95,8 @@ export class LavalinkNode {
     }
     async search(query, requestUser) {
         const Query = this.NodeManager.LavalinkManager.utils.transformQuery(query);
-        if (/^https?:\/\//.test(Query.query))
-            this.NodeManager.LavalinkManager.utils.validateQueryString(this, Query.source);
-        else if (Query.source)
+        this.NodeManager.LavalinkManager.utils.validateQueryString(this, Query.query);
+        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!");
@@ -562,6 +562,7 @@ export class LavalinkNode {
                 return;
         }
     }
+    // LAVALINK EVENT HANDLING UTIL FUNCTION
     async handleEvent(payload) {
         if (!payload.guildId)
             return;
@@ -584,20 +585,36 @@ export class LavalinkNode {
             case "WebSocketClosedEvent":
                 this.socketClosed(player, payload);
                 break;
+            case "SegmentsLoaded":
+                this.SponsorBlockSegmentLoaded(player, player.queue.current, payload);
+                break;
+            case "SegmentSkipped":
+                this.SponsorBlockSegmentkipped(player, player.queue.current, payload);
+                break;
+            case "ChaptersLoaded":
+                this.SponsorBlockChaptersLoaded(player, player.queue.current, payload);
+                break;
+            case "ChapterStarted":
+                this.SponsorBlockChapterStarted(player, player.queue.current, payload);
+                break;
             default:
                 this.NodeManager.emit("error", this, new Error(`Node#event unknown event '${payload.type}'.`), payload);
                 break;
         }
         return;
     }
+    // LAVALINK EVENT HANDLING FUNCTIONS
     trackStart(player, track, payload) {
         player.playing = true;
         player.paused = false;
+        // don't emit the event if previous track == new track aka track loop
+        if (this.NodeManager.LavalinkManager.options?.emitNewSongsOnly === true && player.queue.previous[0]?.info?.identifier === track?.info?.identifier)
+            return;
         return this.NodeManager.LavalinkManager.emit("trackStart", player, track, payload);
     }
     async trackEnd(player, track, payload) {
         // If there are no songs in the queue
-        if (!player.queue.tracks.length && player.repeatMode === "off")
+        if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
             return this.queueEnd(player, track, payload);
         // If a track was forcibly played
         if (payload.reason === "replaced")
@@ -616,6 +633,12 @@ export class LavalinkNode {
         // remove tracks from the queue
         if (player.repeatMode !== "track")
             await queueTrackEnd(player);
+        else if (player.queue.current) { // If there was a current Track already and repeatmode === true, add it to the queue.
+            player.queue.previous.unshift(player.queue.current);
+            if (player.queue.previous.length > player.queue.options.maxPreviousTracks)
+                player.queue.previous.splice(player.queue.options.maxPreviousTracks, player.queue.previous.length);
+            await player.queue.utils.save();
+        }
         // if no track available, end queue
         if (!player.queue.current)
             return this.queueEnd(player, track, payload);
@@ -624,11 +647,92 @@ export class LavalinkNode {
         // play track if autoSkip is true
         return this.NodeManager.LavalinkManager.options.autoSkip && player.play({ noReplace: true });
     }
+    async trackStuck(player, track, payload) {
+        this.NodeManager.LavalinkManager.emit("trackStuck", player, track, payload);
+        // If there are no songs in the queue
+        if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
+            return this.queueEnd(player, track, payload);
+        // remove the current track, and enqueue the next one
+        await queueTrackEnd(player);
+        // if no track available, end queue
+        if (!player.queue.current)
+            return this.queueEnd(player, track, payload);
+        // play track if autoSkip is true
+        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
+    }
+    async trackError(player, track, payload) {
+        this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
+        // If there are no songs in the queue
+        if (!player.queue.tracks.length && (player.repeatMode === "off" || player.get("internal_stopPlaying")))
+            return this.queueEnd(player, track, payload);
+        // remove the current track, and enqueue the next one
+        await queueTrackEnd(player);
+        // if no track available, end queue
+        if (!player.queue.current)
+            return this.queueEnd(player, track, payload);
+        // play track if autoSkip is true
+        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
+    }
+    socketClosed(player, payload) {
+        return this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);
+    }
+    // SPONSOR BLOCK EVENT FUNCTIONS
+    SponsorBlockSegmentLoaded(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("SegmentsLoaded", player, track, payload);
+    }
+    SponsorBlockSegmentkipped(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("SegmentSkipped", player, track, payload);
+    }
+    SponsorBlockChaptersLoaded(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("ChaptersLoaded", player, track, payload);
+    }
+    SponsorBlockChapterStarted(player, track, payload) {
+        return this.NodeManager.LavalinkManager.emit("ChapterStarted", player, track, payload);
+    }
+    // SPONSOR BLOCK EXECUTE FUNCTIONS
+    async getSponsorBlock(player) {
+        // no plugin enabled
+        if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
+            throw new RangeError(`there is no sponsorblock-plugin available in the lavalink node: ${this.id}`);
+        // do the request
+        return await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`);
+    }
+    async setSponsorBlock(player, segments = ["sponsor", "selfpromo"]) {
+        // no plugin enabled
+        if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
+            throw new RangeError(`there is no sponsorblock-plugin available in the lavalink node: ${this.id}`);
+        // no segments length
+        if (!segments.length)
+            throw new RangeError("No Segments provided. Did you ment to use 'deleteSponsorBlock'?");
+        // a not valid segment
+        if (segments.some(v => !validSponsorBlocks.includes(v.toLowerCase())))
+            throw new SyntaxError(`You provided a sponsorblock which isn't valid, valid ones are: ${validSponsorBlocks.map(v => `'${v}'`).join(", ")}`);
+        // do the request
+        await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (request) => {
+            request.method = "PUT";
+            request.body = JSON.stringify(segments.map(v => v.toLowerCase()));
+            return request;
+        });
+        return;
+    }
+    async deleteSponsorBlock(player) {
+        // no plugin enabled
+        if (!this.info.plugins.find(v => v.name === "sponsorblock-plugin"))
+            throw new RangeError(`there is no sponsorblock-plugin available in the lavalink node: ${this.id}`);
+        // do the request
+        await this.request(`/sessions/${this.sessionId}/players/${player.guildId}/sponsorblock/categories`, (request) => {
+            request.method = "DELETE";
+            return request;
+        });
+        return;
+    }
+    // UTIL FOR QUEUE END
     async queueEnd(player, track, payload) {
         // add previous track to the queue!
         player.queue.current = null;
         player.playing = false;
-        if (typeof this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function") {
+        player.set("internal_stopPlaying", undefined);
+        if (typeof this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction === "function" && typeof player.get("internal_autoplayStopPlaying") === "undefined") {
             await this.NodeManager.LavalinkManager.options?.playerOptions?.onEmptyQueue?.autoPlayFunction(player, track);
             if (player.queue.tracks.length > 0)
                 await queueTrackEnd(player);
@@ -638,6 +742,7 @@ export class LavalinkNode {
                 return player.play({ noReplace: true, paused: false });
             }
         }
+        player.set("internal_autoplayStopPlaying", undefined);
         player.queue.previous.unshift(track);
         if (payload?.reason !== "stopped") {
             await player.queue.utils.save();
@@ -657,30 +762,4 @@ export class LavalinkNode {
         }
         return this.NodeManager.LavalinkManager.emit("queueEnd", player, track, payload);
     }
-    async trackStuck(player, track, payload) {
-        this.NodeManager.LavalinkManager.emit("trackStuck", player, track, payload);
-        // If there are no songs in the queue
-        if (!player.queue.tracks.length && player.repeatMode === "off")
-            return;
-        // remove the current track, and enqueue the next one
-        await queueTrackEnd(player);
-        // if no track available, end queue
-        if (!player.queue.current)
-            return this.queueEnd(player, track, payload);
-        // play track if autoSkip is true
-        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
-    }
-    async trackError(player, track, payload) {
-        this.NodeManager.LavalinkManager.emit("trackError", player, track, payload);
-        // remove the current track, and enqueue the next one
-        await queueTrackEnd(player);
-        // if no track available, end queue
-        if (!player.queue.current)
-            return this.queueEnd(player, track, payload);
-        // play track if autoSkip is true
-        return (this.NodeManager.LavalinkManager.options.autoSkip && player.queue.current) && player.play({ noReplace: true });
-    }
-    socketClosed(player, payload) {
-        return this.NodeManager.LavalinkManager.emit("playerSocketClosed", player, payload);
-    }
 }

package/dist/esm/structures/Player.d.ts

@@ -1,6 +1,6 @@
 import { EQBand, FilterData, FilterManager, LavalinkFilterData } from "./Filters";
 import { LavalinkManager } from "./LavalinkManager";
-import { LavalinkNode } from "./Node";
+import { LavalinkNode, SponsorBlockSegment } from "./Node";
 import { Queue } from "./Queue";
 import { Track, UnresolvedTrack } from "./Track";
 import { LavalinkPlayerVoiceOptions, LavaSearchQuery, SearchQuery } from "./Utils";
@@ -149,6 +149,9 @@ export declare class Player {
      */
     setVolume(volume: number, ignoreVolumeDecrementer?: boolean): Promise<this>;
     lavaSearch(query: LavaSearchQuery, requestUser: unknown): Promise<import("./Utils").SearchResult | import("./Utils").LavaSearchResponse>;
+    setSponsorBlock(segments?: SponsorBlockSegment[]): Promise<void>;
+    getSponsorBlock(): Promise<SponsorBlockSegment[]>;
+    deleteSponsorBlock(): Promise<void>;
     /**
      *
      * @param query Query for your data
@@ -177,12 +180,22 @@ export declare class Player {
      * Skip the current song, or a specific amount of songs
      * @param amount provide the index of the next track to skip to
      */
-    skip(skipTo?: number): Promise<any>;
+    skip(skipTo?: number, throwError?: boolean): Promise<any>;
+    /**
+     * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
+     * @returns
+     */
+    stopPlaying(clearQueue?: boolean, executeAutoplay?: boolean): Promise<this>;
     /**
      * Connects the Player to the Voice Channel
      * @returns
      */
     connect(): Promise<this>;
+    changeVoiceState(data: {
+        voiceChannelId?: string;
+        selfDeaf?: boolean;
+        selfMute?: boolean;
+    }): Promise<this>;
     /**
      * Disconnects the Player from the Voice Channel, but keeps the player in the cache
      * @param force If false it throws an error, if player thinks it's already disconnected

package/dist/esm/structures/Player.js

@@ -212,6 +212,15 @@ export class Player {
     async lavaSearch(query, requestUser) {
         return this.node.lavaSearch(query, requestUser);
     }
+    async setSponsorBlock(segments = ["sponsor", "selfpromo"]) {
+        return this.node.setSponsorBlock(this, segments);
+    }
+    async getSponsorBlock() {
+        return this.node.getSponsorBlock(this);
+    }
+    async deleteSponsorBlock() {
+        return this.node.deleteSponsorBlock(this);
+    }
     /**
      *
      * @param query Query for your data
@@ -219,10 +228,6 @@ export class Player {
      */
     async search(query, requestUser) {
         const Query = this.LavalinkManager.utils.transformQuery(query);
-        if (/^https?:\/\//.test(Query.query))
-            this.LavalinkManager.utils.validateQueryString(this.node, Query.source);
-        else if (Query.source)
-            this.LavalinkManager.utils.validateSourceString(this.node, Query.source);
         if (["bcsearch", "bandcamp"].includes(Query.source))
             return await bandCampSearch(this, Query.query, requestUser);
         return this.node.search(Query, requestUser);
@@ -286,8 +291,8 @@ export class Player {
      * Skip the current song, or a specific amount of songs
      * @param amount provide the index of the next track to skip to
      */
-    async skip(skipTo = 0) {
-        if (!this.queue.tracks.length)
+    async skip(skipTo = 0, throwError = true) {
+        if (!this.queue.tracks.length && (throwError || (typeof skipTo === "boolean" && skipTo === true)))
             throw new RangeError("Can't skip more than the queue size");
         if (typeof skipTo === "number" && skipTo > 1) {
             if (skipTo > this.queue.tracks.length)
@@ -301,13 +306,33 @@ export class Player {
         this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
         return this;
     }
+    /**
+     * Clears the queue and stops playing. Does not destroy the Player and not leave the channel
+     * @returns
+     */
+    async stopPlaying(clearQueue = true, executeAutoplay = false) {
+        // use internal_stopPlaying on true, so that it doesn't utilize current loop states. on trackEnd event
+        this.set("internal_stopPlaying", true);
+        // remove tracks from the queue
+        if (this.queue.tracks.length && clearQueue === true)
+            await this.queue.splice(0, this.queue.tracks.length);
+        if (executeAutoplay === false)
+            this.set("internal_autoplayStopPlaying", true);
+        else
+            this.set("internal_autoplayStopPlaying", undefined);
+        const now = performance.now();
+        // send to lavalink, that it should stop playing
+        await this.node.updatePlayer({ guildId: this.guildId, playerOptions: { encodedTrack: null } });
+        this.ping.lavalink = Math.round((performance.now() - now) / 10) / 100;
+        return this;
+    }
     /**
      * Connects the Player to the Voice Channel
      * @returns
      */
     async connect() {
         if (!this.options.voiceChannelId)
-            throw new RangeError("No Voice Channel id has been set.");
+            throw new RangeError("No Voice Channel id has been set. (player.options.voiceChannelId)");
         await this.LavalinkManager.options.sendToShard(this.guildId, {
             op: 4,
             d: {
@@ -317,6 +342,26 @@ export class Player {
                 self_deaf: this.options.selfDeaf ?? true,
             }
         });
+        this.voiceChannelId = this.options.voiceChannelId;
+        return this;
+    }
+    async changeVoiceState(data) {
+        if (this.options.voiceChannelId === data.voiceChannelId)
+            throw new RangeError("New Channel can't be equal to the old Channel.");
+        await this.LavalinkManager.options.sendToShard(this.guildId, {
+            op: 4,
+            d: {
+                guild_id: this.guildId,
+                channel_id: data.voiceChannelId,
+                self_mute: data.selfMute ?? this.options.selfMute ?? false,
+                self_deaf: data.selfDeaf ?? this.options.selfDeaf ?? true,
+            }
+        });
+        // override the options
+        this.options.voiceChannelId = data.voiceChannelId;
+        this.options.selfMute = data.selfMute;
+        this.options.selfDeaf = data.selfDeaf;
+        this.voiceChannelId = data.voiceChannelId;
         return this;
     }
     /**
@@ -326,7 +371,7 @@ export class Player {
      */
     async disconnect(force = false) {
         if (!force && !this.options.voiceChannelId)
-            throw new RangeError("No Voice Channel id has been set.");
+            throw new RangeError("No Voice Channel id has been set. (player.options.voiceChannelId)");
         await this.LavalinkManager.options.sendToShard(this.guildId, {
             op: 4,
             d: {
@@ -343,10 +388,10 @@ export class Player {
      * Destroy the player and disconnect from the voice channel
      */
     async destroy(reason, disconnect = true) {
-        if (this.LavalinkManager.options.debugOptions.playerDestroy.debugLog)
+        if (this.LavalinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
             console.log(`Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Destroy-Reason: ${String(reason)}`);
         if (this.get("internal_destroystatus") === true) {
-            if (this.LavalinkManager.options.debugOptions.playerDestroy.debugLog)
+            if (this.LavalinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
                 console.log(`Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Already destroying somewhere else..`);
             return;
         }
@@ -362,7 +407,7 @@ export class Player {
         this.LavalinkManager.deletePlayer(this.guildId);
         // destroy the player on lavalink side
         await this.node.destroyPlayer(this.guildId);
-        if (this.LavalinkManager.options.debugOptions.playerDestroy.debugLog)
+        if (this.LavalinkManager.options.advancedOptions?.debugOptions.playerDestroy.debugLog)
             console.log(`Lavalink-Client-Debug | PlayerDestroy [::] destroy Function, [guildId ${this.guildId}] - Player got destroyed successfully`);
         // emit the event
         this.LavalinkManager.emit("playerDestroy", this, reason);

package/dist/esm/structures/Queue.d.ts

@@ -18,7 +18,7 @@ export interface QueueStoreManager extends Record<string, any> {
     parse: (value: unknown) => Promise<Partial<StoredQueue>>;
 }
 export interface ManagerQueueOptions {
-    /** Maximum Amount of tracks for the queue.previous array */
+    /** Maximum Amount of tracks for the queue.previous array. Set to 0 to not save previous songs. Defaults to 25 Tracks */
     maxPreviousTracks?: number;
     /** Custom Queue Store option */
     queueStore?: QueueStoreManager;

package/dist/esm/structures/Utils.d.ts

@@ -51,6 +51,17 @@ export interface UnresolvedSearchResult {
     playlist: PlaylistInfo | null;
     tracks: UnresolvedTrack[];
 }
+/**
+ * Parses Node Connection Url: "lavalink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>"
+ * @param connectionUrl
+ * @returns
+ */
+export declare function parseLavalinkConnUrl(connectionUrl: string): {
+    authorization: string;
+    id: string;
+    host: string;
+    port: number;
+};
 export declare class ManagerUtils {
     LavalinkManager: LavalinkManager | null;
     constructor(LavalinkManager?: LavalinkManager);
@@ -152,7 +163,7 @@ export declare class MiniMap<K, V> extends Map<K, V> {
     map<T>(fn: (value: V, key: K, miniMap: this) => T): T[];
     map<This, T>(fn: (this: This, value: V, key: K, miniMap: this) => T, thisArg: This): T[];
 }
-export type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent;
+export type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent | SponsorBlockSegmentEvents;
 export type Severity = "COMMON" | "SUSPICIOUS" | "FAULT";
 export interface Exception {
     severity: Severity;
@@ -188,9 +199,52 @@ export interface WebSocketClosedEvent extends PlayerEvent {
     byRemote: boolean;
     reason: string;
 }
+/**
+ * Types & Events for Sponsorblock-plugin from Lavalink: https://github.com/topi314/Sponsorblock-Plugin#segmentsloaded
+ */
+export type SponsorBlockSegmentEvents = SponsorBlockSegmentSkipped | SponsorBlockSegmentsLoaded | SponsorBlockChapterStarted | SponsorBlockChaptersLoaded;
+export type SponsorBlockSegmentEventType = "SegmentSkipped" | "SegmentsLoaded" | "ChaptersLoaded" | "ChapterStarted";
+export interface SponsorBlockSegmentsLoaded extends PlayerEvent {
+    type: "SegmentsLoaded";
+    segments: {
+        category: string;
+        start: number;
+        end: number;
+    }[];
+}
+export interface SponsorBlockSegmentSkipped extends PlayerEvent {
+    type: "SegmentSkipped";
+    segment: {
+        category: string;
+        start: number;
+        end: number;
+    };
+}
+export interface SponsorBlockChapterStarted extends PlayerEvent {
+    type: "ChapterStarted";
+    /** The Chapter which started */
+    chapter: {
+        /** The Name of the Chapter */
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    };
+}
+export interface SponsorBlockChaptersLoaded extends PlayerEvent {
+    type: "ChaptersLoaded";
+    /** All Chapters loaded */
+    chapters: {
+        /** The Name of the Chapter */
+        name: string;
+        start: number;
+        end: number;
+        duration: number;
+    }[];
+}
 export type LoadTypes = "track" | "playlist" | "search" | "error" | "empty";
 export type State = "CONNECTED" | "CONNECTING" | "DISCONNECTED" | "DISCONNECTING" | "DESTROYING";
-export type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent";
+export type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent" | SponsorBlockSegmentEventType;
 export type TrackEndReason = "finished" | "loadFailed" | "stopped" | "replaced" | "cleanup";
 export interface InvalidLavalinkRestRequest {
     timestamp: number;

package/dist/esm/structures/Utils.js

@@ -1,3 +1,5 @@
+import { URL } from "node:url";
+import { isRegExp } from "node:util/types";
 import { DefaultSources, LavalinkPlugins, SourceLinksRegexes } from "./LavalinkManagerStatics";
 export const TrackSymbol = Symbol("LC-Track");
 export const UnresolvedTrackSymbol = Symbol("LC-Track-Unresolved");
@@ -5,6 +7,22 @@ export const QueueSymbol = Symbol("LC-Queue");
 export const NodeSymbol = Symbol("LC-Node");
 /** @hidden */
 const escapeRegExp = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+ * Parses Node Connection Url: "lavalink://<nodeId>:<nodeAuthorization(Password)>@<NodeHost>:<NodePort>"
+ * @param connectionUrl
+ * @returns
+ */
+export function parseLavalinkConnUrl(connectionUrl) {
+    if (!connectionUrl.startsWith("lavalink://"))
+        throw new Error(`ConnectionUrl (${connectionUrl}) must start with 'lavalink://'`);
+    const parsed = new URL(connectionUrl);
+    return {
+        authorization: parsed.password,
+        id: parsed.username,
+        host: parsed.hostname,
+        port: Number(parsed.port),
+    };
+}
 export class ManagerUtils {
     LavalinkManager = null;
     constructor(LavalinkManager) {
@@ -163,6 +181,18 @@ export class ManagerUtils {
             throw new Error("No Lavalink Node was provided");
         if (!node.info.sourceManagers?.length)
             throw new Error("Lavalink Node, has no sourceManagers enabled");
+        // checks for blacklisted links / domains / queries
+        if (this.LavalinkManager.options?.linksBlacklist?.length > 0 && this.LavalinkManager.options?.linksBlacklist.some(v => (typeof v === "string" && (queryString.toLowerCase().includes(v.toLowerCase()) || v.toLowerCase().includes(queryString.toLowerCase()))) || isRegExp(v) && v.test(queryString))) {
+            throw new Error(`Query string contains a link / word which is blacklisted.`);
+        }
+        if (!/^https?:\/\//.test(queryString))
+            return;
+        else if (this.LavalinkManager.options?.linksAllowed === false)
+            throw new Error("Using links to make a request is not allowed.");
+        // checks for if the query is whitelisted (should only work for links, so it skips the check for no link queries)
+        if (this.LavalinkManager.options?.linksWhitelist?.length > 0 && !this.LavalinkManager.options?.linksWhitelist.some(v => (typeof v === "string" && (queryString.toLowerCase().includes(v.toLowerCase()) || v.toLowerCase().includes(queryString.toLowerCase()))) || isRegExp(v) && v.test(queryString))) {
+            throw new Error(`Query string contains a link / word which isn't whitelisted.`);
+        }
         // missing links: beam.pro local getyarn.io clypit pornhub reddit ocreamix soundgasm
         if ((SourceLinksRegexes.YoutubeMusicRegex.test(queryString) || SourceLinksRegexes.YoutubeRegex.test(queryString)) && !node.info?.sourceManagers?.includes("youtube")) {
             throw new Error("Lavalink Node has not 'youtube' enabled");

package/dist/types/structures/LavalinkManager.d.ts

@@ -5,7 +5,7 @@ import { NodeManager } from "./NodeManager";
 import { DestroyReasonsType, Player, PlayerJson, PlayerOptions } from "./Player";
 import { ManagerQueueOptions } from "./Queue";
 import { Track, UnresolvedTrack } from "./Track";
-import { ChannelDeletePacket, GuildShardPayload, ManagerUtils, MiniMap, SearchPlatform, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
+import { ChannelDeletePacket, GuildShardPayload, ManagerUtils, MiniMap, SearchPlatform, SponsorBlockChaptersLoaded, SponsorBlockChapterStarted, SponsorBlockSegmentSkipped, SponsorBlockSegmentsLoaded, TrackEndEvent, TrackExceptionEvent, TrackStartEvent, TrackStuckEvent, VoicePacket, VoiceServer, VoiceState, WebSocketClosedEvent } from "./Utils";
 export interface LavalinkManager {
     nodeManager: NodeManager;
     utils: ManagerUtils;
@@ -33,7 +33,7 @@ export interface ManagerPlayerOptions {
     onDisconnect?: {
         /** Try to reconnect? -> If fails -> Destroy */
         autoReconnect?: boolean;
-        /** Instantly destroy player (overrides autoReconnect) */
+        /** Instantly destroy player (overrides autoReconnect) | Don't provide == disable feature*/
         destroyPlayer?: boolean;
     };
     onEmptyQueue?: {
@@ -56,16 +56,27 @@ export interface ManagerOptions {
     playerOptions?: ManagerPlayerOptions;
     /** If it should skip to the next Track on TrackEnd / TrackError etc. events */
     autoSkip?: boolean;
-    /** optional */
-    debugOptions?: {
-        /** logs for debugging the "no-Audio" playing error */
-        noAudio?: boolean;
-        /** For Logging the Destroy function */
-        playerDestroy?: {
-            /** To show the debug reason at all times. */
-            debugLog?: boolean;
-            /** If you get 'Error: Use Player#destroy("reason") not LavalinkManager#deletePlayer() to stop the Player' put it on true */
-            dontThrowError?: boolean;
+    /** If it should emit only new (unique) songs and not when a looping track (or similar) is plaid, default false */
+    emitNewSongsOnly?: boolean;
+    /** Only allow link requests with links either matching some of that regExp or including some of that string */
+    linksWhitelist?: (RegExp | string)[];
+    /** Never allow link requests with links either matching some of that regExp or including some of that string (doesn't even allow if it's whitelisted) */
+    linksBlacklist?: (RegExp | string)[];
+    /** If links should be allowed or not. If set to false, it will throw an error if a link was provided. */
+    linksAllowed?: boolean;
+    /** Advanced Options for the Library, which may or may not be "library breaking" */
+    advancedOptions?: {
+        /** optional */
+        debugOptions?: {
+            /** logs for debugging the "no-Audio" playing error */
+            noAudio?: boolean;
+            /** For Logging the Destroy function */
+            playerDestroy?: {
+                /** To show the debug reason at all times. */
+                debugLog?: boolean;
+                /** If you get 'Error: Use Player#destroy("reason") not LavalinkManager#deletePlayer() to stop the Player' put it on true */
+                dontThrowError?: boolean;
+            };
         };
     };
 }
@@ -125,6 +136,34 @@ interface LavalinkManagerEvents {
      * @event Manager#playerUpdate
      */
     "playerUpdate": (oldPlayerJson: PlayerJson, newPlayer: Player) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when Segments are loaded
+     * @link https://github.com/topi314/Sponsorblock-Plugin#segmentsloaded
+     * @event Manager#trackError
+     */
+    "SegmentsLoaded": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockSegmentsLoaded) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when a specific Segment was skipped
+     * @link https://github.com/topi314/Sponsorblock-Plugin#segmentskipped
+     * @event Manager#trackError
+     */
+    "SegmentSkipped": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockSegmentSkipped) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when a specific Chapter starts playing
+     * @link https://github.com/topi314/Sponsorblock-Plugin#chapterstarted
+     * @event Manager#trackError
+     */
+    "ChapterStarted": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockChapterStarted) => void;
+    /**
+     * SPONSORBLOCK-PLUGIN EVENT
+     * Emitted when Chapters are loaded
+     * @link https://github.com/topi314/Sponsorblock-Plugin#chaptersloaded
+     * @event Manager#trackError
+     */
+    "ChaptersLoaded": (player: Player, track: Track | UnresolvedTrack, payload: SponsorBlockChaptersLoaded) => void;
 }
 export interface LavalinkManager {
     options: ManagerOptions;

package/dist/types/structures/Node.d.ts

@@ -2,11 +2,13 @@
 import internal from "stream";
 import { Dispatcher, Pool } from "undici";
 import { NodeManager } from "./NodeManager";
-import { DestroyReasonsType } from "./Player";
+import { DestroyReasonsType, Player } from "./Player";
 import { Track } from "./Track";
 import { Base64, InvalidLavalinkRestRequest, LavalinkPlayer, LavaSearchQuery, LavaSearchResponse, PlayerUpdateInfo, RoutePlanner, SearchQuery, SearchResult, Session } from "./Utils";
 /** Modifies any outgoing REST requests. */
 export type ModifyRequest = (options: Dispatcher.RequestOptions) => void;
+export declare const validSponsorBlocks: string[];
+export type SponsorBlockSegment = "sponsor" | "selfpromo" | "interaction" | "intro" | "outro" | "preview" | "music_offtopic" | "filler";
 export interface LavalinkNodeOptions {
     /** The Lavalink Server-Ip / Domain-URL */
     host: string;
@@ -240,8 +242,15 @@ export declare class LavalinkNode {
     private handleEvent;
     private trackStart;
     private trackEnd;
-    private queueEnd;
     private trackStuck;
     private trackError;
     private socketClosed;
+    private SponsorBlockSegmentLoaded;
+    private SponsorBlockSegmentkipped;
+    private SponsorBlockChaptersLoaded;
+    private SponsorBlockChapterStarted;
+    getSponsorBlock(player: Player): Promise<SponsorBlockSegment[]>;
+    setSponsorBlock(player: Player, segments?: SponsorBlockSegment[]): Promise<void>;
+    deleteSponsorBlock(player: Player): Promise<void>;
+    private queueEnd;
 }