for-modules 1.1.5 → 1.1.6

package/ff.txt

@@ -0,0 +1,3037 @@
+src } index.ts {
+export * from "./Structures/Manager";
+export * from "./Structures/Node";
+export * from "./Structures/Player";
+export * from "./Structures/Queue";
+export * from "./Structures/Utils";
+export * from "./Structures/Filters";
+export * from "./Structures/Rest";
+export * from "./Utils/FiltersEqualizers";
+export * from "./Utils/ManagerCheck";
+export * from "./Utils/NodeCheck";
+export * from "./Utils/PlayerCheck";
+export * from "./Structures/TikTok";
+}
+src } Utils } PlayerCheck.ts {
+    import { PlayerOptions } from "../Structures/Player";
+
+export default function PlayerCheck(options: PlayerOptions) {
+	if (!options) throw new TypeError("PlayerOptions must not be empty.");
+	
+	const { guild, node, selfDeafen, selfMute, textChannel, voiceChannel, volume } = options;
+
+	if (!/^\d+$/.test(guild)) {
+		throw new TypeError('Player option "guild" must be present and be a non-empty string.');
+	}
+
+	if (node && typeof node !== "string") {
+		throw new TypeError('Player option "node" must be a non-empty string.');
+	}
+
+	if (typeof selfDeafen !== "undefined" && typeof selfDeafen !== "boolean") {
+		throw new TypeError('Player option "selfDeafen" must be a boolean.');
+	}
+
+	if (typeof selfMute !== "undefined" && typeof selfMute !== "boolean") {
+		throw new TypeError('Player option "selfMute" must be a boolean.');
+	}
+
+	if (textChannel && !/^\d+$/.test(textChannel)) {
+		throw new TypeError('Player option "textChannel" must be a non-empty string.');
+	}
+
+	if (voiceChannel && !/^\d+$/.test(voiceChannel)) {
+		throw new TypeError('Player option "voiceChannel" must be a non-empty string.');
+	}
+
+	if (typeof volume !== "undefined" && typeof volume !== "number") {
+		throw new TypeError('Player option "volume" must be a number.');
+	}
+}
+
+}
+
+src } Utils } NodeCheck.ts {
+    import { NodeOptions } from "../Structures/Node";
+
+export default function NodeCheck(options: NodeOptions) {
+	if (!options) throw new TypeError("NodeOptions must not be empty.");
+
+	const { host, identifier, password, port, requestTimeout, resumeStatus, resumeTimeout, retryAmount, retryDelay, secure, priority } = options;
+
+	if (typeof host !== "string" || !/.+/.test(host)) {
+		throw new TypeError('Node option "host" must be present and be a non-empty string.');
+	}
+
+	if (typeof identifier !== "undefined" && typeof identifier !== "string") {
+		throw new TypeError('Node option "identifier" must be a non-empty string.');
+	}
+
+	if (typeof password !== "undefined" && (typeof password !== "string" || !/.+/.test(password))) {
+		throw new TypeError('Node option "password" must be a non-empty string.');
+	}
+
+	if (typeof port !== "undefined" && typeof port !== "number") {
+		throw new TypeError('Node option "port" must be a number.');
+	}
+
+	if (typeof requestTimeout !== "undefined" && typeof requestTimeout !== "number") {
+		throw new TypeError('Node option "requestTimeout" must be a number.');
+	}
+
+	if (typeof resumeStatus !== "undefined" && typeof resumeStatus !== "boolean") {
+		throw new TypeError('Node option "resumeStatus" must be a boolean.');
+	}
+
+	if (typeof resumeTimeout !== "undefined" && typeof resumeTimeout !== "number") {
+		throw new TypeError('Node option "resumeTimeout" must be a number.');
+	}
+
+	if (typeof retryAmount !== "undefined" && typeof retryAmount !== "number") {
+		throw new TypeError('Node option "retryAmount" must be a number.');
+	}
+
+	if (typeof retryDelay !== "undefined" && typeof retryDelay !== "number") {
+		throw new TypeError('Node option "retryDelay" must be a number.');
+	}
+
+	if (typeof secure !== "undefined" && typeof secure !== "boolean") {
+		throw new TypeError('Node option "secure" must be a boolean.');
+	}
+
+	if (typeof priority !== "undefined" && typeof priority !== "number") {
+		throw new TypeError('Node option "priority" must be a number.');
+	}
+}
+
+}
+
+src } Utils } ManagerCheck.ts {
+    import { ManagerOptions } from "../Structures/Manager";
+
+export default function ManagerCheck(options: ManagerOptions) {
+	if (!options) throw new TypeError("ManagerOptions must not be empty.");
+
+	const { autoPlay, clientId, clientName, defaultSearchPlatform, nodes, plugins, send, shards, trackPartial, usePriority, useNode, replaceYouTubeCredentials, caches } =
+		options;
+
+	if (typeof autoPlay !== "undefined" && typeof autoPlay !== "boolean") {
+		throw new TypeError('Manager option "autoPlay" must be a boolean.');
+	}
+
+	if (typeof clientId !== "undefined" && !/^\d+$/.test(clientId)) {
+		throw new TypeError('Manager option "clientId" must be a non-empty string.');
+	}
+
+	if (typeof clientName !== "undefined" && typeof clientName !== "string") {
+		throw new TypeError('Manager option "clientName" must be a string.');
+	}
+	if (typeof caches !== "undefined" && typeof caches !== "object") {
+		throw new TypeError('Manager option "caches" must be a object.');
+	}
+	if (typeof defaultSearchPlatform !== "undefined" && typeof defaultSearchPlatform !== "string") {
+		throw new TypeError('Manager option "defaultSearchPlatform" must be a string.');
+	}
+
+	if (typeof nodes !== "undefined" && !Array.isArray(nodes)) {
+		throw new TypeError('Manager option "nodes" must be an array.');
+	}
+
+	if (typeof plugins !== "undefined" && !Array.isArray(plugins)) {
+		throw new TypeError('Manager option "plugins" must be a Plugin array.');
+	}
+
+	if (typeof send !== "function") {
+		throw new TypeError('Manager option "send" must be present and a function.');
+	}
+
+	if (typeof shards !== "undefined" && typeof shards !== "number") {
+		throw new TypeError('Manager option "shards" must be a number.');
+	}
+
+	if (typeof trackPartial !== "undefined" && !Array.isArray(trackPartial)) {
+		throw new TypeError('Manager option "trackPartial" must be a string array.');
+	}
+
+	if (typeof usePriority !== "undefined" && typeof usePriority !== "boolean") {
+		throw new TypeError('Manager option "usePriority" must be a boolean.');
+	}
+
+	if (usePriority) {
+		for (let index = 0; index < nodes.length; index++) {
+			if (!nodes[index].priority) {
+				throw new TypeError(`Missing node option "priority" at position ${index}`);
+			}
+		}
+	}
+
+	if (typeof useNode !== "undefined") {
+		if (typeof useNode !== "string") {
+			throw new TypeError('Manager option "useNode" must be a string "leastLoad" or "leastPlayers".');
+		}
+
+		if (useNode !== "leastLoad" && useNode !== "leastPlayers") {
+			throw new TypeError('Manager option must be either "leastLoad" or "leastPlayers".');
+		}
+	}
+
+	if (typeof replaceYouTubeCredentials !== "undefined" && typeof replaceYouTubeCredentials !== "boolean") {
+		throw new TypeError('Manager option "replaceYouTubeCredentials" must be a boolean.');
+	}
+}
+
+}
+
+src } Utils } FiltersEqualizers.ts {
+    /** Represents an equalizer band. */
+export interface Band {
+	/** The index of the equalizer band. */
+	band: number;
+	/** The gain value of the equalizer band. */
+	gain: number;
+}
+
+export const bassBoostEqualizer: Band[] = [
+	{ band: 0, gain: 0.2 },
+	{ band: 1, gain: 0.15 },
+	{ band: 2, gain: 0.1 },
+	{ band: 3, gain: 0.05 },
+	{ band: 4, gain: 0.0 },
+	{ band: 5, gain: -0.05 },
+	{ band: 6, gain: -0.1 },
+	{ band: 7, gain: -0.1 },
+	{ band: 8, gain: -0.1 },
+	{ band: 9, gain: -0.1 },
+	{ band: 10, gain: -0.1 },
+	{ band: 11, gain: -0.1 },
+	{ band: 12, gain: -0.1 },
+	{ band: 13, gain: -0.1 },
+	{ band: 14, gain: -0.1 },
+];
+
+export const softEqualizer: Band[] = [
+	{ band: 0, gain: 0 },
+	{ band: 1, gain: 0 },
+	{ band: 2, gain: 0 },
+	{ band: 3, gain: 0 },
+	{ band: 4, gain: 0 },
+	{ band: 5, gain: 0 },
+	{ band: 6, gain: 0 },
+	{ band: 7, gain: 0 },
+	{ band: 8, gain: -0.25 },
+	{ band: 9, gain: -0.25 },
+	{ band: 10, gain: -0.25 },
+	{ band: 11, gain: -0.25 },
+	{ band: 12, gain: -0.25 },
+	{ band: 13, gain: -0.25 },
+];
+
+export const tvEqualizer: Band[] = [
+	{ band: 0, gain: 0 },
+	{ band: 1, gain: 0 },
+	{ band: 2, gain: 0 },
+	{ band: 3, gain: 0 },
+	{ band: 4, gain: 0 },
+	{ band: 5, gain: 0 },
+	{ band: 6, gain: 0 },
+	{ band: 7, gain: 0.65 },
+	{ band: 8, gain: 0.65 },
+	{ band: 9, gain: 0.65 },
+	{ band: 10, gain: 0.65 },
+	{ band: 11, gain: 0.65 },
+	{ band: 12, gain: 0.65 },
+	{ band: 13, gain: 0.65 },
+];
+
+export const trebleBassEqualizer: Band[] = [
+	{ band: 0, gain: 0.6 },
+	{ band: 1, gain: 0.67 },
+	{ band: 2, gain: 0.67 },
+	{ band: 3, gain: 0 },
+	{ band: 4, gain: -0.5 },
+	{ band: 5, gain: 0.15 },
+	{ band: 6, gain: -0.45 },
+	{ band: 7, gain: 0.23 },
+	{ band: 8, gain: 0.35 },
+	{ band: 9, gain: 0.45 },
+	{ band: 10, gain: 0.55 },
+	{ band: 11, gain: 0.6 },
+	{ band: 12, gain: 0.55 },
+	{ band: 13, gain: 0 },
+];
+
+export const vaporwaveEqualizer: Band[] = [
+	{ band: 0, gain: 0 },
+	{ band: 1, gain: 0 },
+	{ band: 2, gain: 0 },
+	{ band: 3, gain: 0 },
+	{ band: 4, gain: 0 },
+	{ band: 5, gain: 0 },
+	{ band: 6, gain: 0 },
+	{ band: 7, gain: 0 },
+	{ band: 8, gain: 0.15 },
+	{ band: 9, gain: 0.15 },
+	{ band: 10, gain: 0.15 },
+	{ band: 11, gain: 0.15 },
+	{ band: 12, gain: 0.15 },
+	{ band: 13, gain: 0.15 },
+];
+
+}
+
+src } Utils } Structures } Utils.ts {
+    /* eslint-disable @typescript-eslint/no-unused-vars*/
+import { ClientUser, User } from "discord.js";
+import { Manager } from "./Manager";
+import { Node, NodeStats } from "./Node";
+import { Player, Track, UnresolvedTrack } from "./Player";
+import { Queue } from "./Queue";
+
+/** @hidden */
+const TRACK_SYMBOL = Symbol("track"),
+	/** @hidden */
+	UNRESOLVED_TRACK_SYMBOL = Symbol("unresolved"),
+	SIZES = ["0", "1", "2", "3", "default", "mqdefault", "hqdefault", "maxresdefault"];
+
+/** @hidden */
+const escapeRegExp = (str: string): string => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+
+export abstract class TrackUtils {
+	static trackPartial: string[] | null = null;
+	private static manager: Manager;
+
+	/** @hidden */
+	public static init(manager: Manager): void {
+		this.manager = manager;
+	}
+
+	static setTrackPartial(partial: string[]): void {
+		if (!Array.isArray(partial) || !partial.every((str) => typeof str === "string")) throw new Error("Provided partial is not an array or not a string array.");
+		if (!partial.includes("track")) partial.unshift("track");
+
+		this.trackPartial = partial;
+	}
+
+	/**
+	 * Checks if the provided argument is a valid Track or UnresolvedTrack, if provided an array then every element will be checked.
+	 * @param trackOrTracks
+	 */
+	static validate(trackOrTracks: unknown): boolean {
+		if (typeof trackOrTracks === "undefined") throw new RangeError("Provided argument must be present.");
+
+		if (Array.isArray(trackOrTracks) && trackOrTracks.length) {
+			for (const track of trackOrTracks) {
+				if (!(track[TRACK_SYMBOL] || track[UNRESOLVED_TRACK_SYMBOL])) return false;
+			}
+			return true;
+		}
+
+		return (trackOrTracks[TRACK_SYMBOL] || trackOrTracks[UNRESOLVED_TRACK_SYMBOL]) === true;
+	}
+
+	/**
+	 * Checks if the provided argument is a valid UnresolvedTrack.
+	 * @param track
+	 */
+	static isUnresolvedTrack(track: unknown): boolean {
+		if (typeof track === "undefined") throw new RangeError("Provided argument must be present.");
+		return track[UNRESOLVED_TRACK_SYMBOL] === true;
+	}
+
+	/**
+	 * Checks if the provided argument is a valid Track.
+	 * @param track
+	 */
+	static isTrack(track: unknown): boolean {
+		if (typeof track === "undefined") throw new RangeError("Provided argument must be present.");
+		return track[TRACK_SYMBOL] === true;
+	}
+
+	/**
+	 * Builds a Track from the raw data from Lavalink and a optional requester.
+	 * @param data
+	 * @param requester
+	 */
+	static build(data: TrackData, requester?: User | ClientUser): Track {
+		if (typeof data === "undefined") throw new RangeError('Argument "data" must be present.');
+
+		try {
+			const track: Track = {
+				track: data.encoded,
+				title: data.info.title,
+				identifier: data.info.identifier,
+				author: data.info.author,
+				duration: data.info.length,
+				isrc: data.info?.isrc,
+				isSeekable: data.info.isSeekable,
+				isStream: data.info.isStream,
+				uri: data.info.uri,
+				artworkUrl: data.info?.artworkUrl,
+				sourceName: data.info?.sourceName,
+				thumbnail: data.info.uri.includes("youtube") ? `https://img.youtube.com/vi/${data.info.identifier}/default.jpg` : null,
+				displayThumbnail(size = "default"): string | null {
+					const finalSize = SIZES.find((s) => s === size) ?? "default";
+					return this.uri.includes("youtube") ? `https://img.youtube.com/vi/${data.info.identifier}/${finalSize}.jpg` : null;
+				},
+				requester,
+				pluginInfo: data.pluginInfo,
+				customData: {},
+			};
+
+			track.displayThumbnail = track.displayThumbnail.bind(track);
+
+			if (this.trackPartial) {
+				for (const key of Object.keys(track)) {
+					if (this.trackPartial.includes(key)) continue;
+					delete track[key];
+				}
+			}
+
+			Object.defineProperty(track, TRACK_SYMBOL, {
+				configurable: true,
+				value: true,
+			});
+
+			return track;
+		} catch (error) {
+			throw new RangeError(`Argument "data" is not a valid track: ${error.message}`);
+		}
+	}
+
+	/**
+	 * Builds a UnresolvedTrack to be resolved before being played  .
+	 * @param query
+	 * @param requester
+	 */
+	static buildUnresolved(query: string | UnresolvedQuery, requester?: User | ClientUser): UnresolvedTrack {
+		if (typeof query === "undefined") throw new RangeError('Argument "query" must be present.');
+
+		let unresolvedTrack: Partial<UnresolvedTrack> = {
+			requester,
+			async resolve(): Promise<void> {
+				const resolved = await TrackUtils.getClosestTrack(this);
+				Object.getOwnPropertyNames(this).forEach((prop) => delete this[prop]);
+				Object.assign(this, resolved);
+			},
+		};
+
+		if (typeof query === "string") unresolvedTrack.title = query;
+		else unresolvedTrack = { ...unresolvedTrack, ...query };
+
+		Object.defineProperty(unresolvedTrack, UNRESOLVED_TRACK_SYMBOL, {
+			configurable: true,
+			value: true,
+		});
+
+		return unresolvedTrack as UnresolvedTrack;
+	}
+
+	static async getClosestTrack(unresolvedTrack: UnresolvedTrack): Promise<Track> {
+		if (!TrackUtils.manager) throw new RangeError("Manager has not been initiated.");
+
+		if (!TrackUtils.isUnresolvedTrack(unresolvedTrack)) throw new RangeError("Provided track is not a UnresolvedTrack.");
+
+		const query = unresolvedTrack.uri ? unresolvedTrack.uri : [unresolvedTrack.author, unresolvedTrack.title].filter(Boolean).join(" - ");
+		const res = await TrackUtils.manager.search(query, unresolvedTrack.requester);
+
+		if (unresolvedTrack.author) {
+			const channelNames = [unresolvedTrack.author, `${unresolvedTrack.author} - Topic`];
+
+			const originalAudio = res.tracks.find((track) => {
+				return (
+					channelNames.some((name) => new RegExp(`^${escapeRegExp(name)}$`, "i").test(track.author)) ||
+					new RegExp(`^${escapeRegExp(unresolvedTrack.title)}$`, "i").test(track.title)
+				);
+			});
+
+			if (originalAudio) return originalAudio;
+		}
+
+		if (unresolvedTrack.duration) {
+			const sameDuration = res.tracks.find((track) => track.duration >= unresolvedTrack.duration - 1500 && track.duration <= unresolvedTrack.duration + 1500);
+
+			if (sameDuration) return sameDuration;
+		}
+
+		const finalTrack = res.tracks[0];
+		finalTrack.customData = unresolvedTrack.customData;
+		return finalTrack;
+	}
+}
+
+/** Gets or extends structures to extend the built in, or already extended, classes to add more functionality. */
+export abstract class Structure {
+	/**
+	 * Extends a class.
+	 * @param name
+	 * @param extender
+	 */
+	public static extend<K extends keyof Extendable, T extends Extendable[K]>(name: K, extender: (target: Extendable[K]) => T): T {
+		if (!structures[name]) throw new TypeError(`"${name} is not a valid structure`);
+		const extended = extender(structures[name]);
+		structures[name] = extended;
+		return extended;
+	}
+
+	/**
+	 * Get a structure from available structures by name.
+	 * @param name
+	 */
+	public static get<K extends keyof Extendable>(name: K): Extendable[K] {
+		const structure = structures[name];
+		if (!structure) throw new TypeError('"structure" must be provided.');
+		return structure;
+	}
+}
+
+export class Plugin {
+	public load(manager: Manager): void {}
+	public unload(manager: Manager): void {}
+}
+
+const structures = {
+	Player,
+	Queue,
+	Node,
+};
+
+export interface UnresolvedQuery {
+	/** The title of the unresolved track. */
+	title: string;
+	/** The author of the unresolved track. If provided it will have a more precise search. */
+	author?: string;
+	/** The duration of the unresolved track. If provided it will have a more precise search. */
+	duration?: number;
+}
+
+export type Sizes = "0" | "1" | "2" | "3" | "default" | "mqdefault" | "hqdefault" | "maxresdefault";
+
+export type LoadType = "track" | "playlist" | "search" | "empty" | "error";
+
+export type State = "CONNECTED" | "CONNECTING" | "DISCONNECTED" | "DISCONNECTING" | "DESTROYING" | "MOVING";
+
+export type PlayerEvents = TrackStartEvent | TrackEndEvent | TrackStuckEvent | TrackExceptionEvent | WebSocketClosedEvent;
+
+export type PlayerEventType = "TrackStartEvent" | "TrackEndEvent" | "TrackExceptionEvent" | "TrackStuckEvent" | "WebSocketClosedEvent";
+
+export type TrackEndReason = "finished" | "loadFailed" | "stopped" | "replaced" | "cleanup";
+
+export type Severity = "common" | "suspicious" | "fault";
+
+export interface TrackData {
+	/** The track information. */
+	encoded: string;
+	/** The detailed information of the track. */
+	info: TrackDataInfo;
+	/** Additional track info provided by plugins. */
+	pluginInfo: Record<string, string>;
+}
+
+export interface TrackDataInfo {
+	identifier: string;
+	isSeekable: boolean;
+	author: string;
+	length: number;
+	isrc?: string;
+	isStream: boolean;
+	title: string;
+	uri?: string;
+	artworkUrl?: string;
+	sourceName?: TrackSourceName;
+}
+
+export type TrackSourceName = "deezer" | "spotify" | "soundcloud" | "youtube" | "tiktok";
+
+export interface Extendable {
+	Player: typeof Player;
+	Queue: typeof Queue;
+	Node: typeof Node;
+}
+
+export interface VoiceState {
+	op: "voiceUpdate";
+	guildId: string;
+	event: VoiceServer;
+	sessionId?: string;
+}
+
+export interface VoiceServer {
+	token: string;
+	guild_id: string;
+	endpoint: string;
+}
+
+export interface VoiceState {
+	guild_id: string;
+	user_id: string;
+	session_id: string;
+	channel_id: string;
+}
+
+export interface VoicePacket {
+	t?: "VOICE_SERVER_UPDATE" | "VOICE_STATE_UPDATE";
+	d: VoiceState | VoiceServer;
+}
+
+export interface NodeMessage extends NodeStats {
+	type: PlayerEventType;
+	op: "stats" | "playerUpdate" | "event";
+	guildId: string;
+}
+
+export interface PlayerEvent {
+	op: "event";
+	type: PlayerEventType;
+	guildId: string;
+}
+
+export interface Exception {
+	message: string;
+	severity: Severity;
+	cause: string;
+}
+
+export interface TrackStartEvent extends PlayerEvent {
+	type: "TrackStartEvent";
+	track: TrackData;
+}
+
+export interface TrackEndEvent extends PlayerEvent {
+	type: "TrackEndEvent";
+	track: TrackData;
+	reason: TrackEndReason;
+}
+
+export interface TrackExceptionEvent extends PlayerEvent {
+	exception?: Exception;
+	guildId: string;
+	type: "TrackExceptionEvent";
+}
+
+export interface TrackStuckEvent extends PlayerEvent {
+	type: "TrackStuckEvent";
+	thresholdMs: number;
+}
+
+export interface WebSocketClosedEvent extends PlayerEvent {
+	type: "WebSocketClosedEvent";
+	code: number;
+	reason: string;
+	byRemote: boolean;
+}
+
+export interface PlayerUpdate {
+	op: "playerUpdate";
+	/** The guild id of the player. */
+	guildId: string;
+	state: {
+		/** Unix timestamp in milliseconds. */
+		time: number;
+		/** The position of the track in milliseconds. */
+		position: number;
+		/** Whether Lavalink is connected to the voice gateway. */
+		connected: boolean;
+		/** The ping of the node to the Discord voice server in milliseconds (-1 if not connected). */
+		ping: number;
+	};
+}
+
+}
+src } Utils } Structures } TikTok.ts {
+    import axios from "axios";
+import { TrackUtils, TrackSourceName } from "./Utils";
+import { User, ClientUser } from "discord.js"; 
+
+export class TikTok {
+    /**
+     * ตรวจสอบว่าลิงก์เป็นของ TikTok หรือไม่
+     */
+    static isTikTokURL(url: string): boolean {
+        return url.includes("tiktok.com");
+    }
+
+    /**
+     * ค้นหาและดึงลิงก์เสียงจาก TikTok
+     */
+    static async searchTikTok(url: string, requester?: User | ClientUser) {
+        const tiktokAudioURL = await this.extractTikTokAudio(url);
+    
+        if (!tiktokAudioURL) {
+            throw new Error("ไม่สามารถดึงข้อมูลเสียงจาก TikTok ได้");
+        }
+    
+        return {
+            loadType: "track",
+            tracks: [TrackUtils.build({
+                encoded: tiktokAudioURL, 
+                info: {
+                    title: "TikTok Audio",
+                    identifier: url,
+                    author: "TikTok User",
+                    length: 0,
+                    isSeekable: true,
+                    isStream: false,
+                    uri: url,
+                    sourceName: "tiktok" as TrackSourceName
+                },
+                pluginInfo: {}
+            }, requester)]
+        };
+    }
+
+    /**
+     * ดึงลิงก์เสียงจาก TikTok โดยใช้ API หรือ Web Scraper
+     */
+    static async extractTikTokAudio(url: string): Promise<string | null> {
+        try {
+            const response = await axios.get(`https://api.example.com/extract?tiktok_url=${encodeURIComponent(url)}`);
+            return response.data.audio_url;
+        } catch (error) {
+            console.error("Error extracting TikTok audio:", error);
+            return null;
+        }
+    }
+}
+
+}
+
+src } Utils } Structures } Rest.ts {
+    import { Node } from "./Node";
+import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
+
+/** Handles the requests sent to the Lavalink REST API. */
+export class Rest {
+	/** The Node that this Rest instance is connected to. */
+	private node: Node;
+	/** The ID of the current session. */
+	private sessionId: string;
+	/** The password for the Node. */
+	private readonly password: string;
+	/** The URL of the Node. */
+	private readonly url: string;
+
+	constructor(node: Node) {
+		this.node = node;
+		this.url = `http${node.options.secure ? "s" : ""}://${node.options.host}:${node.options.port}`;
+		this.sessionId = node.sessionId;
+		this.password = node.options.password;
+	}
+
+	/**
+	 * Sets the session ID.
+	 * @returns {string} Returns the session ID.
+	 */
+	public setSessionId(sessionId: string): string {
+		this.sessionId = sessionId;
+		return this.sessionId;
+	}
+
+	/** Retrieves all the players that are currently running on the node. */
+	public async getAllPlayers(): Promise<unknown> {
+		return await this.get(`/v4/sessions/${this.sessionId}/players`);
+	}
+
+	/** Sends a PATCH request to update player related data. */
+	public async updatePlayer(options: playOptions): Promise<unknown> {
+		return await this.patch(`/v4/sessions/${this.sessionId}/players/${options.guildId}?noReplace=false`, options.data);
+	}
+
+	/** Sends a DELETE request to the server to destroy the player. */
+	public async destroyPlayer(guildId: string): Promise<unknown> {
+		return await this.delete(`/v4/sessions/${this.sessionId}/players/${guildId}`);
+	}
+
+	/* Sends a GET request to the specified endpoint and returns the response data. */
+	private async request(method: Method, endpoint: string, body?: unknown): Promise<unknown> {
+		const config: AxiosRequestConfig = {
+			method,
+			url: this.url + endpoint,
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: this.password,
+			},
+			data: body,
+		};
+
+		try {
+			const response = await axios(config) as AxiosResponse
+			return response.data;
+		} catch (error) {
+			if (error?.response?.status === 404) {
+				this.node.destroy();
+				this.node.manager.createNode(this.node.options).connect();
+			}
+			return null;
+		}
+	}
+
+	/* Sends a GET request to the specified endpoint and returns the response data. */
+	public async get(endpoint: string): Promise<unknown> {
+		return await this.request("GET", endpoint);
+	}
+
+	/* Sends a PATCH request to the specified endpoint and returns the response data. */
+	public async patch(endpoint: string, body: unknown): Promise<unknown> {
+		return await this.request("PATCH", endpoint, body);
+	}
+
+	/* Sends a POST request to the specified endpoint and returns the response data. */
+	public async post(endpoint: string, body: unknown): Promise<unknown> {
+		return await this.request("POST", endpoint, body);
+	}
+
+	/* Sends a DELETE request to the specified endpoint and returns the response data. */
+	public async delete(endpoint: string): Promise<unknown> {
+		return await this.request("DELETE", endpoint);
+	}
+}
+
+interface playOptions {
+	guildId: string;
+	data: {
+		/** The base64 encoded track. */
+		encodedTrack?: string;
+		/** The track ID. */
+		identifier?: string;
+		/** The track time to start at. */
+		startTime?: number;
+		/** The track time to end at. */
+		endTime?: number;
+		/** The player volume level. */
+		volume?: number;
+		/** The player position in a track. */
+		position?: number;
+		/** Whether the player is paused. */
+		paused?: boolean;
+		/** The audio effects. */
+		filters?: object;
+		/** voice payload. */
+		voice?: {
+			token: string;
+			sessionId: string;
+			endpoint: string;
+		};
+		/** Whether to not replace the track if a play payload is sent. */
+		noReplace?: boolean;
+	};
+}
+
+export type Method = "GET" | "POST" | "PATCH" | "DELETE";
+}
+
+src } Utils } Structures } Queue.ts {
+    import { Track, UnresolvedTrack } from "./Player";
+import { TrackUtils } from "./Utils";
+
+/**
+ * The player's queue, the `current` property is the currently playing track, think of the rest as the up-coming tracks.
+ */
+export class Queue extends Array<Track | UnresolvedTrack> {
+	/** The total duration of the queue. */
+	public get duration(): number {
+		const current = this.current?.duration ?? 0;
+		return this.reduce((acc, cur) => acc + (cur.duration || 0), current);
+	}
+
+	/** The total size of tracks in the queue including the current track. */
+	public get totalSize(): number {
+		return this.length + (this.current ? 1 : 0);
+	}
+
+	/** The size of tracks in the queue. */
+	public get size(): number {
+		return this.length;
+	}
+
+	/** The current track */
+	public current: Track | UnresolvedTrack | null = null;
+
+	/** The previous track */
+	public previous: Track | UnresolvedTrack | null = null;
+
+	/**
+	 * Adds a track to the queue.
+	 * @param track
+	 * @param [offset=null]
+	 */
+	public add(track: (Track | UnresolvedTrack) | (Track | UnresolvedTrack)[], offset?: number): void {
+		if (!TrackUtils.validate(track)) {
+			throw new RangeError('Track must be a "Track" or "Track[]".');
+		}
+
+		if (!this.current) {
+			if (Array.isArray(track)) {
+				this.current = track.shift() || null;
+				this.push(...track);
+			} else {
+				this.current = track;
+			}
+		} else {
+			if (typeof offset !== "undefined" && typeof offset === "number") {
+				if (isNaN(offset)) {
+					throw new RangeError("Offset must be a number.");
+				}
+
+				if (offset < 0 || offset > this.length) {
+					throw new RangeError(`Offset must be between 0 and ${this.length}.`);
+				}
+
+				if (Array.isArray(track)) {
+					this.splice(offset, 0, ...track);
+				} else {
+					this.splice(offset, 0, track);
+				}
+			} else {
+				if (Array.isArray(track)) {
+					this.push(...track);
+				} else {
+					this.push(track);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Removes a track from the queue. Defaults to the first track, returning the removed track, EXCLUDING THE `current` TRACK.
+	 * @param [position=0]
+	 */
+	public remove(position?: number): (Track | UnresolvedTrack)[];
+
+	/**
+	 * Removes an amount of tracks using a exclusive start and end exclusive index, returning the removed tracks, EXCLUDING THE `current` TRACK.
+	 * @param start
+	 * @param end
+	 */
+	public remove(start: number, end: number): (Track | UnresolvedTrack)[];
+
+	public remove(startOrPosition = 0, end?: number): (Track | UnresolvedTrack)[] {
+		if (typeof end !== "undefined") {
+			if (isNaN(Number(startOrPosition)) || isNaN(Number(end))) {
+				throw new RangeError(`Missing "start" or "end" parameter.`);
+			}
+
+			if (startOrPosition >= end || startOrPosition >= this.length) {
+				throw new RangeError("Invalid start or end values.");
+			}
+
+			return this.splice(startOrPosition, end - startOrPosition);
+		}
+
+		return this.splice(startOrPosition, 1);
+	}
+
+	/** Clears the queue. */
+	public clear(): void {
+		this.splice(0);
+	}
+
+	/** Shuffles the queue. */
+	public shuffle(): void {
+		for (let i = this.length - 1; i > 0; i--) {
+			const j = Math.floor(Math.random() * (i + 1));
+			[this[i], this[j]] = [this[j], this[i]];
+		}
+	}
+
+	public equalizedShuffle() {
+		const userTracks = new Map<string, Array<Track | UnresolvedTrack>>();
+
+		this.forEach((track) => {
+			const user = track.requester.id;
+
+			if (!userTracks.has(user)) {
+				userTracks.set(user, []);
+			}
+
+			userTracks.get(user).push(track);
+		});
+
+		const shuffledQueue: Array<Track | UnresolvedTrack> = [];
+
+		while (shuffledQueue.length < this.length) {
+			userTracks.forEach((tracks) => {
+				const track = tracks.shift();
+				if (track) {
+					shuffledQueue.push(track);
+				}
+			});
+		}
+
+		this.clear();
+		this.add(shuffledQueue);
+		console.log(this);
+	}
+}
+
+}
+
+src } Utils } Structures } Player.ts {
+    import { Filters } from "./Filters";
+import { LavalinkResponse, Manager, PlaylistRawData, SearchQuery, SearchResult } from "./Manager";
+import { LavalinkInfo, Node } from "./Node";
+import { Queue } from "./Queue";
+import { Sizes, State, Structure, TrackSourceName, TrackUtils, VoiceState } from "./Utils";
+import * as _ from "lodash";
+import playerCheck from "../Utils/PlayerCheck";
+import { ClientUser, Message, User } from "discord.js";
+
+export class Player {
+	/** The Queue for the Player. */
+	public readonly queue = new (Structure.get("Queue"))() as Queue;
+	/** The filters applied to the audio. */
+	public filters: Filters;
+	/** Whether the queue repeats the track. */
+	public trackRepeat = false;
+	/** Whether the queue repeats the queue. */
+	public queueRepeat = false;
+	/**Whether the queue repeats and shuffles after each song. */
+	public dynamicRepeat = false;
+	/** The time the player is in the track. */
+	public position = 0;
+	/** Whether the player is playing. */
+	public playing = false;
+	/** Whether the player is paused. */
+	public paused = false;
+	/** The volume for the player */
+	public volume: number;
+	/** The Node for the Player. */
+	public node: Node;
+	/** The guild for the player. */
+	public guild: string;
+	/** The voice channel for the player. */
+	public voiceChannel: string | null = null;
+	/** The text channel for the player. */
+	public textChannel: string | null = null;
+	/**The now playing message. */
+	public nowPlayingMessage?: Message;
+	/** The current state of the player. */
+	public state: State = "DISCONNECTED";
+	/** The equalizer bands array. */
+	public bands = new Array<number>(15).fill(0.0);
+	/** The voice state object from Discord. */
+	public voiceState: VoiceState;
+	/** The Manager. */
+	public manager: Manager;
+	/** The autoplay state of the player. */
+	public isAutoplay: boolean = false;
+
+	private static _manager: Manager;
+	private readonly data: Record<string, unknown> = {};
+	private dynamicLoopInterval: NodeJS.Timeout;
+
+	/**
+	 * Set custom data.
+	 * @param key
+	 * @param value
+	 */
+	public set(key: string, value: unknown): void {
+		this.data[key] = value;
+	}
+
+	/**
+	 * Get custom data.
+	 * @param key
+	 */
+	public get<T>(key: string): T {
+		return this.data[key] as T;
+	}
+
+	/** @hidden */
+	public static init(manager: Manager): void {
+		this._manager = manager;
+	}
+
+	/**
+	 * Creates a new player, returns one if it already exists.
+	 * @param options
+	 */
+	constructor(public options: PlayerOptions) {
+		if (!this.manager) this.manager = Structure.get("Player")._manager;
+		if (!this.manager) throw new RangeError("Manager has not been initiated.");
+
+		if (this.manager.players.has(options.guild)) {
+			return this.manager.players.get(options.guild);
+		}
+
+		playerCheck(options);
+
+		this.guild = options.guild;
+		this.voiceState = Object.assign({
+			op: "voiceUpdate",
+			guild_id: options.guild,
+		});
+
+		if (options.voiceChannel) this.voiceChannel = options.voiceChannel;
+		if (options.textChannel) this.textChannel = options.textChannel;
+
+		const node = this.manager.nodes.get(options.node);
+		this.node = node || this.manager.useableNodes;
+
+		if (!this.node) throw new RangeError("No available nodes.");
+
+		this.manager.players.set(options.guild, this);
+		this.manager.emit("PlayerCreate", this);
+		this.setVolume(options.volume ?? 100);
+		this.filters = new Filters(this);
+	}
+
+	/**
+	 * Same as Manager#search() but a shortcut on the player itself.
+	 * @param query
+	 * @param requester
+	 */
+	public search(query: string | SearchQuery, requester?: User | ClientUser): Promise<SearchResult> {
+		return this.manager.search(query, requester);
+	}
+
+	/** Connect to the voice channel. */
+	public connect(): this {
+		if (!this.voiceChannel) throw new RangeError("No voice channel has been set.");
+		this.state = "CONNECTING";
+
+		this.manager.options.send(this.guild, {
+			op: 4,
+			d: {
+				guild_id: this.guild,
+				channel_id: this.voiceChannel,
+				self_mute: this.options.selfMute || false,
+				self_deaf: this.options.selfDeafen || false,
+			},
+		});
+
+		this.state = "CONNECTED";
+		return this;
+	}
+
+	/**
+	 * Moves the player to a different node.
+	 *
+	 * @param {string} [node] - The ID of the node to move to.
+	 * @returns {this} - The player instance.
+	 */
+	public async moveNode(node?: string): Promise<this> {
+		node = node || this.manager.leastLoadNode.first().options.identifier || this.manager.nodes.filter((n) => n.connected).first().options.identifier;
+		if (!this.manager.nodes.has(node)) throw new RangeError("No nodes available.");
+		if (this.node.options.identifier === node) return this;
+
+		const destroyOldNode = async (node: Node) => {
+			this.state = "MOVING";
+
+			if (this.manager.nodes.get(node.options.identifier) && this.manager.nodes.get(node.options.identifier).connected) await node.rest.destroyPlayer(this.guild);
+
+			setTimeout(() => (this.state = "CONNECTED"), 5000);
+		};
+
+		const currentNode = this.node;
+		const destinationNode = this.manager.nodes.get(node);
+		let position = this.position;
+
+		if (currentNode.connected) {
+			const fetchedPlayer = await currentNode.rest.get(`/v4/sessions/${currentNode.sessionId}/players/${this.guild}`) as { track?: { info: { position: number } } };
+			position = fetchedPlayer.track.info.position;
+		}
+
+		await destinationNode.rest.updatePlayer({
+			guildId: this.guild,
+			data: {
+				encodedTrack: this.queue.current?.track,
+				position: position,
+				volume: this.volume,
+				paused: this.paused,
+				filters: {
+					distortion: this.filters.distortion,
+					equalizer: this.filters.equalizer,
+					karaoke: this.filters.karaoke,
+					rotation: this.filters.rotation,
+					timescale: this.filters.timescale,
+					vibrato: this.filters.vibrato,
+					volume: this.filters.volume,
+				},
+			},
+		});
+
+		await destinationNode.rest.updatePlayer({
+			guildId: this.guild,
+			data: {
+				voice: {
+					token: this.voiceState.event.token,
+					endpoint: this.voiceState.event.endpoint,
+					sessionId: this.voiceState?.sessionId ?? "",
+				},
+			},
+		});
+
+		this.node = destinationNode;
+		destroyOldNode(currentNode);
+		return this;
+	}
+
+	/** Disconnect from the voice channel. */
+	public disconnect(): this {
+		if (this.voiceChannel === null) return this;
+		this.state = "DISCONNECTING";
+
+		this.pause(true);
+		this.manager.options.send(this.guild, {
+			op: 4,
+			d: {
+				guild_id: this.guild,
+				channel_id: null,
+				self_mute: false,
+				self_deaf: false,
+			},
+		});
+
+		this.voiceChannel = null;
+		this.state = "DISCONNECTED";
+		return this;
+	}
+
+	/** Destroys the player. */
+	public destroy(disconnect = true): void {
+		this.state = "DESTROYING";
+
+		if (disconnect) {
+			this.disconnect();
+		}
+
+		this.node.rest.destroyPlayer(this.guild);
+		this.manager.emit("PlayerDestroy", this);
+		this.manager.players.delete(this.guild);
+	}
+
+	/**
+	 * Sets the player voice channel.
+	 * @param channel
+	 */
+	public setVoiceChannel(channel: string): this {
+		if (typeof channel !== "string") throw new TypeError("Channel must be a non-empty string.");
+
+		this.voiceChannel = channel;
+		this.connect();
+		return this;
+	}
+
+	/**
+	 * Sets the player text channel.
+	 * @param channel
+	 */
+	public setTextChannel(channel: string): this {
+		if (typeof channel !== "string") throw new TypeError("Channel must be a non-empty string.");
+
+		this.textChannel = channel;
+		return this;
+	}
+
+	/** Sets the now playing message. */
+	public setNowPlayingMessage(message: Message): Message {
+		if (!message) {
+			throw new TypeError("You must provide the message of the now playing message.");
+		}
+		return (this.nowPlayingMessage = message);
+	}
+
+	/** Plays the next track. */
+	public async play(): Promise<void>;
+
+	/**
+	 * Plays the specified track.
+	 * @param track
+	 */
+	public async play(track: Track | UnresolvedTrack): Promise<void>;
+
+	/**
+	 * Plays the next track with some options.
+	 * @param options
+	 */
+	public async play(options: PlayOptions): Promise<void>;
+
+
+	/**
+	 * Plays the specified track with some options.
+	 * @param track
+	 * @param options
+	 */
+	public async play(track: Track | UnresolvedTrack, options: PlayOptions): Promise<void>;
+	public async play(optionsOrTrack?: PlayOptions | Track | UnresolvedTrack, playOptions?: PlayOptions): Promise<void> {
+		if (typeof optionsOrTrack !== "undefined" && TrackUtils.validate(optionsOrTrack)) {
+			if (this.queue.current) this.queue.previous = this.queue.current;
+			this.queue.current = optionsOrTrack as Track;
+		}
+
+		if (!this.queue.current) throw new RangeError("No current track.");
+
+		const finalOptions = playOptions
+			? playOptions
+			: ["startTime", "endTime", "noReplace"].every((v) => Object.keys(optionsOrTrack || {}).includes(v))
+			? (optionsOrTrack as PlayOptions)
+			: {};
+
+		if (TrackUtils.isUnresolvedTrack(this.queue.current)) {
+			try {
+				this.queue.current = await TrackUtils.getClosestTrack(this.queue.current as UnresolvedTrack);
+			} catch (error) {
+				this.manager.emit("TrackError", this, this.queue.current, error);
+				if (this.queue[0]) return this.play(this.queue[0]);
+				return;
+			}
+		}
+
+		await this.node.rest.updatePlayer({
+			guildId: this.guild,
+			data: {
+				encodedTrack: this.queue.current?.track,
+				...finalOptions,
+			},
+		});
+
+		Object.assign(this, { position: 0, playing: true });
+	}
+
+	/**
+	 * Sets the autoplay-state of the player.
+	 * @param autoplayState
+	 * @param botUser
+	 */
+	public setAutoplay(autoplayState: boolean, botUser: object) {
+		if (typeof autoplayState !== "boolean") {
+			throw new TypeError("autoplayState must be a boolean.");
+		}
+
+		if (typeof botUser !== "object") {
+			throw new TypeError("botUser must be a user-object.");
+		}
+
+		this.isAutoplay = autoplayState;
+		this.set("Internal_BotUser", botUser);
+
+		return this;
+	}
+	
+
+	/**
+	 * Gets recommended tracks and returns an array of tracks.
+	 * @param track
+	 * @param requester
+	 */
+	public async getRecommended(track: Track, requester?: User | ClientUser) {
+		const node = this.manager.useableNodes;
+
+		if (!node) {
+			throw new Error("No available nodes.");
+		}
+
+		const hasSpotifyURL = ["spotify.com", "open.spotify.com"].some((url) => track.uri.includes(url));
+		const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
+
+		if (hasSpotifyURL) {
+			const res = await node.rest.get(`/v4/info`);
+			const info = res as LavalinkInfo;
+
+			const isSpotifyPluginEnabled = info.plugins.some((plugin: { name: string }) => plugin.name === "lavasrc-plugin");
+			const isSpotifySourceManagerEnabled = info.sourceManagers.includes("spotify");
+
+			if (isSpotifyPluginEnabled && isSpotifySourceManagerEnabled) {
+				const trackID = node.extractSpotifyTrackID(track.uri);
+				const artistID = node.extractSpotifyArtistID(track.pluginInfo.artistUrl);
+
+				let identifier = "";
+				if (trackID && artistID) {
+					identifier = `sprec:seed_artists=${artistID}&seed_tracks=${trackID}`;
+				} else if (trackID) {
+					identifier = `sprec:seed_tracks=${trackID}`;
+				} else if (artistID) {
+					identifier = `sprec:seed_artists=${artistID}`;
+				}
+
+				if (identifier) {
+					const recommendedResult = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`)) as LavalinkResponse;
+
+					if (recommendedResult.loadType === "playlist") {
+						const playlistData = recommendedResult.data as PlaylistRawData;
+						const recommendedTracks = playlistData.tracks;
+
+						if (recommendedTracks) {
+							const tracks = recommendedTracks.map((track) => TrackUtils.build(track, requester));
+
+							return tracks;
+						}
+					}
+				}
+			}
+		}
+
+		let videoID = track.uri.substring(track.uri.indexOf("=") + 1);
+
+		if (!hasYouTubeURL) {
+			const res = await this.manager.search(`${track.author} - ${track.title}`);
+
+			videoID = res.tracks[0].uri.substring(res.tracks[0].uri.indexOf("=") + 1);
+		}
+
+		const searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}`;
+
+		const res = await this.manager.search(searchURI);
+
+		if (res.loadType === "empty" || res.loadType === "error") return;
+
+		let tracks = res.tracks;
+
+		if (res.loadType === "playlist") {
+			tracks = res.playlist.tracks;
+		}
+
+		const filteredTracks = tracks.filter((track) => track.uri !== `https://www.youtube.com/watch?v=${videoID}`);
+
+		if (this.manager.options.replaceYouTubeCredentials) {
+			for (const track of filteredTracks) {
+				track.author = track.author.replace("- Topic", "");
+				track.title = track.title.replace("Topic -", "");
+
+				if (track.title.includes("-")) {
+					const [author, title] = track.title.split("-").map((str: string) => str.trim());
+					track.author = author;
+					track.title = title;
+				}
+			}
+		}
+
+		return filteredTracks;
+	}
+
+	/**
+	 * Sets the player volume.
+	 * @param volume
+	 */
+	public setVolume(volume: number): this {
+		if (isNaN(volume)) throw new TypeError("Volume must be a number.");
+
+		this.node.rest.updatePlayer({
+			guildId: this.options.guild,
+			data: {
+				volume,
+			},
+		});
+
+		this.volume = volume;
+
+		return this;
+	}
+
+	/**
+	 * Sets the track repeat.
+	 * @param repeat
+	 */
+	public setTrackRepeat(repeat: boolean): this {
+		if (typeof repeat !== "boolean") throw new TypeError('Repeat can only be "true" or "false".');
+
+		const oldPlayer = { ...this };
+
+		if (repeat) {
+			this.trackRepeat = true;
+			this.queueRepeat = false;
+			this.dynamicRepeat = false;
+		} else {
+			this.trackRepeat = false;
+			this.queueRepeat = false;
+			this.dynamicRepeat = false;
+		}
+
+		this.manager.emit("PlayerStateUpdate", oldPlayer, this);
+		return this;
+	}
+
+	/**
+	 * Sets the queue repeat.
+	 * @param repeat
+	 */
+	public setQueueRepeat(repeat: boolean): this {
+		if (typeof repeat !== "boolean") throw new TypeError('Repeat can only be "true" or "false".');
+
+		const oldPlayer = { ...this };
+
+		if (repeat) {
+			this.trackRepeat = false;
+			this.queueRepeat = true;
+			this.dynamicRepeat = false;
+		} else {
+			this.trackRepeat = false;
+			this.queueRepeat = false;
+			this.dynamicRepeat = false;
+		}
+
+		this.manager.emit("PlayerStateUpdate", oldPlayer, this);
+		return this;
+	}
+
+	/**
+	 * Sets the queue to repeat and shuffles the queue after each song.
+	 * @param repeat "true" or "false".
+	 * @param ms After how many milliseconds to trigger dynamic repeat.
+	 */
+	public setDynamicRepeat(repeat: boolean, ms: number): this {
+		if (typeof repeat !== "boolean") {
+			throw new TypeError('Repeat can only be "true" or "false".');
+		}
+
+		if (this.queue.size <= 1) {
+			throw new RangeError("The queue size must be greater than 1.");
+		}
+
+		const oldPlayer = { ...this };
+
+		if (repeat) {
+			this.trackRepeat = false;
+			this.queueRepeat = false;
+			this.dynamicRepeat = true;
+
+			this.dynamicLoopInterval = setInterval(() => {
+				if (!this.dynamicRepeat) return;
+				const shuffled = _.shuffle(this.queue);
+				this.queue.clear();
+				shuffled.forEach((track) => {
+					this.queue.add(track);
+				});
+			}, ms) as NodeJS.Timeout;
+		} else {
+			clearInterval(this.dynamicLoopInterval);
+			this.trackRepeat = false;
+			this.queueRepeat = false;
+			this.dynamicRepeat = false;
+		}
+
+		this.manager.emit("PlayerStateUpdate", oldPlayer, this);
+		return this;
+	}
+
+	/** Restarts the current track to the start. */
+	public restart(): void {
+		if (!this.queue.current?.track) {
+			if (this.queue.length) this.play();
+			return;
+		}
+
+		this.node.rest.updatePlayer({
+			guildId: this.guild,
+			data: {
+				position: 0,
+				encodedTrack: this.queue.current?.track,
+			},
+		});
+	}
+
+	/** Stops the current track, optionally give an amount to skip to, e.g 5 would play the 5th song. */
+	public stop(amount?: number): this {
+		if (typeof amount === "number" && amount > 1) {
+			if (amount > this.queue.length) throw new RangeError("Cannot skip more than the queue length.");
+			this.queue.splice(0, amount - 1);
+		}
+
+		this.node.rest.updatePlayer({
+			guildId: this.guild,
+			data: {
+				encodedTrack: null,
+			},
+		});
+
+		return this;
+	}
+
+	/**
+	 * Pauses the current track.
+	 * @param pause
+	 */
+	public pause(pause: boolean): this {
+		if (typeof pause !== "boolean") throw new RangeError('Pause can only be "true" or "false".');
+
+		if (this.paused === pause || !this.queue.totalSize) return this;
+
+		const oldPlayer = { ...this };
+
+		this.playing = !pause;
+		this.paused = pause;
+
+		this.node.rest.updatePlayer({
+			guildId: this.guild,
+			data: {
+				paused: pause,
+			},
+		});
+
+		this.manager.emit("PlayerStateUpdate", oldPlayer, this);
+		return this;
+	}
+
+	/** Go back to the previous song. */
+	public previous(): this {
+		this.queue.unshift(this.queue.previous);
+		this.stop();
+
+		return this;
+	}
+
+	/**
+	 * Seeks to the position in the current track.
+	 * @param position
+	 */
+	public seek(position: number): this {
+		if (!this.queue.current) return undefined;
+		position = Number(position);
+
+		if (isNaN(position)) throw new RangeError("Position must be a number.");
+		if (position < 0 || position > this.queue.current.duration) position = Math.max(Math.min(position, this.queue.current.duration), 0);
+
+		this.position = position;
+
+		this.node.rest.updatePlayer({
+			guildId: this.guild,
+			data: {
+				position: position,
+			},
+		});
+
+		return this;
+	}
+}
+
+export interface PlayerOptions {
+	/** The guild the Player belongs to. */
+	guild: string;
+	/** The text channel the Player belongs to. */
+	textChannel: string;
+	/** The voice channel the Player belongs to. */
+	voiceChannel?: string;
+	/** The node the Player uses. */
+	node?: string;
+	/** The initial volume the Player will use. */
+	volume?: number;
+	/** If the player should mute itself. */
+	selfMute?: boolean;
+	/** If the player should deaf itself. */
+	selfDeafen?: boolean;
+}
+
+/** If track partials are set some of these will be `undefined` as they were removed. */
+export interface Track {
+	/** The base64 encoded track. */
+	readonly track: string;
+	/** The artwork url of the track. */
+	readonly artworkUrl: string;
+	/** The track source name. */
+	readonly sourceName: TrackSourceName;
+	/** The title of the track. */
+	title: string;
+	/** The identifier of the track. */
+	readonly identifier: string;
+	/** The author of the track. */
+	author: string;
+	/** The duration of the track. */
+	readonly duration: number;
+	/** The ISRC of the track. */
+	readonly isrc: string;
+	/** If the track is seekable. */
+	readonly isSeekable: boolean;
+	/** If the track is a stream.. */
+	readonly isStream: boolean;
+	/** The uri of the track. */
+	readonly uri: string;
+	/** The thumbnail of the track or null if it's a unsupported source. */
+	readonly thumbnail: string | null;
+	/** The user that requested the track. */
+	readonly requester: User | ClientUser | null;
+	/** Displays the track thumbnail with optional size or null if it's a unsupported source. */
+	displayThumbnail(size?: Sizes): string;
+	/** Additional track info provided by plugins. */
+	pluginInfo: TrackPluginInfo;
+	/** Add your own data to the track. */
+	customData: Record<string, unknown>;
+}
+
+export interface TrackPluginInfo {
+	albumName?: string;
+	albumUrl?: string;
+	artistArtworkUrl?: string;
+	artistUrl?: string;
+	isPreview?: string;
+	previewUrl?: string;
+}
+
+/** Unresolved tracks can't be played normally, they will resolve before playing into a Track. */
+export interface UnresolvedTrack extends Partial<Track> {
+	/** The title to search against. */
+	title: string;
+	/** The author to search against. */
+	author?: string;
+	/** The duration to search within 1500 milliseconds of the results from YouTube. */
+	duration?: number;
+	/** Resolves into a Track. */
+	resolve(): Promise<void>;
+}
+
+export interface PlayOptions {
+	/** The position to start the track. */
+	readonly startTime?: number;
+	/** The position to end the track. */
+	readonly endTime?: number;
+	/** Whether to not replace the track if a play payload is sent. */
+	readonly noReplace?: boolean;
+}
+
+export interface EqualizerBand {
+	/** The band number being 0 to 14. */
+	band: number;
+	/** The gain amount being -0.25 to 1.00, 0.25 being double. */
+	gain: number;
+}
+
+}
+
+src } Utils } Structures } Node.ts {
+    import {
+	PlayerEvent,
+	PlayerEvents,
+	Structure,
+	TrackEndEvent,
+	TrackExceptionEvent,
+	TrackStartEvent,
+	TrackStuckEvent,
+	TrackUtils,
+	WebSocketClosedEvent,
+} from "./Utils";
+import { LavalinkResponse, Manager, PlaylistRawData } from "./Manager";
+import { Player, Track, UnresolvedTrack } from "./Player";
+import { Rest } from "./Rest";
+import nodeCheck from "../Utils/NodeCheck";
+import WebSocket from "ws";
+
+export class Node {
+	/** The socket for the node. */
+	public socket: WebSocket | null = null;
+	/** The stats for the node. */
+	public stats: NodeStats;
+	public manager: Manager;
+	/** The node's session ID. */
+	public sessionId: string | null;
+	/** The REST instance. */
+	public readonly rest: Rest;
+
+	private static _manager: Manager;
+	private reconnectTimeout?: NodeJS.Timeout;
+	private reconnectAttempts = 1;
+
+	/** Returns if connected to the Node. */
+	public get connected(): boolean {
+		if (!this.socket) return false;
+		return this.socket.readyState === WebSocket.OPEN;
+	}
+
+	/** Returns the address for this node. */
+	public get address(): string {
+		return `${this.options.host}:${this.options.port}`;
+	}
+
+	/** @hidden */
+	public static init(manager: Manager): void {
+		this._manager = manager;
+	}
+
+	/**
+	 * Creates an instance of Node.
+	 * @param options
+	 */
+	constructor(public options: NodeOptions) {
+		if (!this.manager) this.manager = Structure.get("Node")._manager;
+		if (!this.manager) throw new RangeError("Manager has not been initiated.");
+
+		if (this.manager.nodes.has(options.identifier || options.host)) {
+			return this.manager.nodes.get(options.identifier || options.host);
+		}
+
+		nodeCheck(options);
+
+		this.options = {
+			port: 2333,
+			password: "youshallnotpass",
+			secure: false,
+			retryAmount: 30,
+			retryDelay: 60000,
+			priority: 0,
+			...options,
+		};
+
+		if (this.options.secure) {
+			this.options.port = 443;
+		}
+
+		this.options.identifier = options.identifier || options.host;
+		this.stats = {
+			players: 0,
+			playingPlayers: 0,
+			uptime: 0,
+			memory: {
+				free: 0,
+				used: 0,
+				allocated: 0,
+				reservable: 0,
+			},
+			cpu: {
+				cores: 0,
+				systemLoad: 0,
+				lavalinkLoad: 0,
+			},
+			frameStats: {
+				sent: 0,
+				nulled: 0,
+				deficit: 0,
+			},
+		};
+
+		this.manager.nodes.set(this.options.identifier, this);
+		this.manager.emit("NodeCreate", this);
+		this.rest = new Rest(this);
+	}
+
+	/** Connects to the Node. */
+	public connect(): void {
+		if (this.connected) return;
+
+		const headers = Object.assign({
+			Authorization: this.options.password,
+			"Num-Shards": String(this.manager.options.shards),
+			"User-Id": this.manager.options.clientId,
+			"Client-Name": this.manager.options.clientName,
+		});
+
+		this.socket = new WebSocket(`ws${this.options.secure ? "s" : ""}://${this.address}/v4/websocket`, { headers });
+		this.socket.on("open", this.open.bind(this));
+		this.socket.on("close", this.close.bind(this));
+		this.socket.on("message", this.message.bind(this));
+		this.socket.on("error", this.error.bind(this));
+	}
+
+	/** Destroys the Node and all players connected with it. */
+	public destroy(): void {
+		if (!this.connected) return;
+
+		const players = this.manager.players.filter((p) => p.node == this);
+		if (players.size) players.forEach((p) => p.destroy());
+
+		this.socket.close(1000, "destroy");
+		this.socket.removeAllListeners();
+		this.socket = null;
+
+		this.reconnectAttempts = 1;
+		clearTimeout(this.reconnectTimeout);
+
+		this.manager.emit("NodeDestroy", this);
+		this.manager.destroyNode(this.options.identifier);
+	}
+
+	private reconnect(): void {
+		this.reconnectTimeout = setTimeout(() => {
+			if (this.reconnectAttempts >= this.options.retryAmount) {
+				const error = new Error(`Unable to connect after ${this.options.retryAmount} attempts.`);
+
+				this.manager.emit("NodeError", this, error);
+				return this.destroy();
+			}
+			this.socket?.removeAllListeners();
+			this.socket = null;
+			this.manager.emit("NodeReconnect", this);
+			this.connect();
+			this.reconnectAttempts++;
+		}, this.options.retryDelay) as unknown as NodeJS.Timeout;
+	}
+
+	protected open(): void {
+		if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+		try {
+			this.manager.emit("NodeConnect", this);
+		} catch (err) {
+			console.error("Error emitting NodeConnect event:", err);
+		}
+	}
+	
+
+	protected close(code: number, reason: string): void {
+		this.manager.emit("NodeDisconnect", this, { code, reason });
+		if (code !== 1000 || reason !== "destroy") this.reconnect();
+	}
+
+	protected error(error: Error): void {
+		if (!error) return;
+		this.manager.emit("NodeError", this, error);
+	}
+
+	protected message(d: Buffer | string): void {
+		if (Array.isArray(d)) d = Buffer.concat(d);
+		else if (d instanceof ArrayBuffer) d = Buffer.from(d);
+
+		const payload = JSON.parse(d.toString());
+
+		if (!payload.op) return;
+		this.manager.emit("NodeRaw", payload);
+
+		let player: Player;
+
+		switch (payload.op) {
+			case "stats":
+				delete payload.op;
+				this.stats = { ...payload } as unknown as NodeStats;
+				break;
+			case "playerUpdate":
+				player = this.manager.players.get(payload.guildId);
+				if (player) player.position = payload.state.position || 0;
+				break;
+			case "event":
+				this.handleEvent(payload);
+				break;
+			case "ready":
+				this.rest.setSessionId(payload.sessionId);
+				this.sessionId = payload.sessionId;
+
+				if (this.options.resumeStatus) {
+					this.rest.patch(`/v4/sessions/${this.sessionId}`, {
+						resuming: this.options.resumeStatus,
+						timeout: this.options.resumeTimeout,
+					});
+				}
+				break;
+			default:
+				this.manager.emit("NodeError", this, new Error(`Unexpected op "${payload.op}" with data: ${payload.message}`));
+				return;
+		}
+	}
+
+	protected async handleEvent(payload: PlayerEvent & PlayerEvents): Promise<void> {
+		if (!payload.guildId) return;
+
+		const player = this.manager.players.get(payload.guildId);
+		if (!player) return;
+
+		const track = player.queue.current;
+		const type = payload.type;
+
+		let error: Error;
+		switch (type) {
+			case "TrackStartEvent":
+				this.trackStart(player, track as Track, payload);
+				break;
+
+			case "TrackEndEvent":
+				if (player?.nowPlayingMessage && player?.nowPlayingMessage.deletable) {
+					await player?.nowPlayingMessage?.delete().catch(() => {});
+				}
+
+				this.trackEnd(player, track as Track, payload);
+				break;
+
+			case "TrackStuckEvent":
+				this.trackStuck(player, track as Track, payload);
+				break;
+
+			case "TrackExceptionEvent":
+				this.trackError(player, track, payload);
+				break;
+
+			case "WebSocketClosedEvent":
+				this.socketClosed(player, payload);
+				break;
+
+			default:
+				error = new Error(`Node#event unknown event '${type}'.`);
+				this.manager.emit("NodeError", this, error);
+				break;
+		}
+	}
+
+	protected trackStart(player: Player, track: Track, payload: TrackStartEvent): void {
+		player.playing = true;
+		player.paused = false;
+		this.manager.emit("TrackStart", player, track, payload);
+	}
+
+	protected async trackEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void> {
+		const { reason } = payload;
+
+		// If the track failed to load or was cleaned up
+		if (["loadFailed", "cleanup"].includes(reason)) {
+			this.handleFailedTrack(player, track, payload);
+		}
+		// If the track was forcibly replaced
+		else if (reason === "replaced") {
+			this.manager.emit("TrackEnd", player, track, payload);
+			player.queue.previous = player.queue.current;
+		}
+		// If the track ended and it's set to repeat (track or queue)
+		else if (track && (player.trackRepeat || player.queueRepeat)) {
+			this.handleRepeatedTrack(player, track, payload);
+		}
+		// If there's another track in the queue
+		else if (player.queue.length) {
+			this.playNextTrack(player, track, payload);
+		}
+		// If there are no more tracks in the queue
+		else {
+			await this.queueEnd(player, track, payload);
+		}
+	}
+
+	public extractSpotifyTrackID(url: string): string | null {
+		const regex = /https:\/\/open\.spotify\.com\/track\/([a-zA-Z0-9]+)/;
+		const match = url.match(regex);
+		return match ? match[1] : null;
+	}
+
+	public extractSpotifyArtistID(url: string): string | null {
+		const regex = /https:\/\/open\.spotify\.com\/artist\/([a-zA-Z0-9]+)/;
+		const match = url.match(regex);
+		return match ? match[1] : null;
+	}
+
+	// Handle autoplay
+	private async handleAutoplay(player: Player, track: Track) {
+		const previousTrack = player.queue.previous;
+
+		if (!player.isAutoplay || !previousTrack) return;
+
+		const hasSpotifyURL = ["spotify.com", "open.spotify.com"].some((url) => previousTrack.uri.includes(url));
+
+		if (hasSpotifyURL) {
+			const node = this.manager.useableNodes;
+
+			const res = await node.rest.get(`/v4/info`);
+			const info = res as LavalinkInfo;
+
+			const isSpotifyPluginEnabled = info.plugins.some((plugin: { name: string }) => plugin.name === "lavasrc-plugin");
+			const isSpotifySourceManagerEnabled = info.sourceManagers.includes("spotify");
+
+			if (isSpotifyPluginEnabled && isSpotifySourceManagerEnabled) {
+				const trackID = this.extractSpotifyTrackID(previousTrack.uri);
+				const artistID = this.extractSpotifyArtistID(previousTrack.pluginInfo.artistUrl);
+
+				let identifier = "";
+				if (trackID && artistID) {
+					identifier = `sprec:seed_artists=${artistID}&seed_tracks=${trackID}`;
+				} else if (trackID) {
+					identifier = `sprec:seed_tracks=${trackID}`;
+				} else if (artistID) {
+					identifier = `sprec:seed_artists=${artistID}`;
+				}
+
+				if (identifier) {
+					const recommendedResult = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`)) as LavalinkResponse;
+
+					if (recommendedResult.loadType === "playlist") {
+						const playlistData = recommendedResult.data as PlaylistRawData;
+						const recommendedTrack = playlistData.tracks[0];
+
+						if (recommendedTrack) {
+							player.queue.add(TrackUtils.build(recommendedTrack, player.get("Internal_BotUser")));
+							player.play();
+							return;
+						}
+					}
+				}
+			}
+		}
+
+		const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => previousTrack.uri.includes(url));
+
+		let videoID = previousTrack.uri.substring(previousTrack.uri.indexOf("=") + 1);
+
+		if (!hasYouTubeURL) {
+			const res = await player.search(`${previousTrack.author} - ${previousTrack.title}`, player.get("Internal_BotUser"));
+
+			videoID = res.tracks[0].uri.substring(res.tracks[0].uri.indexOf("=") + 1);
+		}
+
+		let randomIndex: number;
+		let searchURI: string;
+
+		do {
+			randomIndex = Math.floor(Math.random() * 23) + 2;
+			searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}&index=${randomIndex}`;
+		} while (track.uri.includes(searchURI));
+
+		const res = await player.search(searchURI, player.get("Internal_BotUser"));
+
+		if (res.loadType === "empty" || res.loadType === "error") return;
+
+		let tracks = res.tracks;
+
+		if (res.loadType === "playlist") {
+			tracks = res.playlist.tracks;
+		}
+
+		const foundTrack = tracks.sort(() => Math.random() - 0.5).find((shuffledTrack) => shuffledTrack.uri !== track.uri);
+
+		if (foundTrack) {
+			if (this.manager.options.replaceYouTubeCredentials) {
+				foundTrack.author = foundTrack.author.replace("- Topic", "");
+				foundTrack.title = foundTrack.title.replace("Topic -", "");
+
+				if (foundTrack.title.includes("-")) {
+					const [author, title] = foundTrack.title.split("-").map((str: string) => str.trim());
+					foundTrack.author = author;
+					foundTrack.title = title;
+				}
+			}
+			player.queue.add(foundTrack);
+			player.play();
+		}
+	}
+
+	// Handle the case when a track failed to load or was cleaned up
+	private handleFailedTrack(player: Player, track: Track, payload: TrackEndEvent): void {
+		player.queue.previous = player.queue.current;
+		player.queue.current = player.queue.shift();
+
+		if (!player.queue.current) {
+			this.queueEnd(player, track, payload);
+			return;
+		}
+
+		this.manager.emit("TrackEnd", player, track, payload);
+		if (this.manager.options.autoPlay) player.play();
+	}
+
+	// Handle the case when a track ended and it's set to repeat (track or queue)
+	private handleRepeatedTrack(player: Player, track: Track, payload: TrackEndEvent): void {
+		const { queue, trackRepeat, queueRepeat } = player;
+		const { autoPlay } = this.manager.options;
+
+		if (trackRepeat) {
+			queue.unshift(queue.current);
+		} else if (queueRepeat) {
+			queue.add(queue.current);
+		}
+
+		queue.previous = queue.current;
+		queue.current = queue.shift();
+
+		this.manager.emit("TrackEnd", player, track, payload);
+
+		if (payload.reason === "stopped" && !(queue.current = queue.shift())) {
+			this.queueEnd(player, track, payload);
+			return;
+		}
+
+		if (autoPlay) player.play();
+	}
+
+	// Handle the case when there's another track in the queue
+	private playNextTrack(player: Player, track: Track, payload: TrackEndEvent): void {
+		player.queue.previous = player.queue.current;
+		player.queue.current = player.queue.shift();
+
+		this.manager.emit("TrackEnd", player, track, payload);
+		if (this.manager.options.autoPlay) player.play();
+	}
+
+	protected async queueEnd(player: Player, track: Track, payload: TrackEndEvent): Promise<void> {
+		player.queue.previous = player.queue.current;
+		player.queue.current = null;
+
+		if (!player.isAutoplay) {
+			player.queue.previous = player.queue.current;
+			player.queue.current = null;
+			player.playing = false;
+			this.manager.emit("QueueEnd", player, track, payload);
+			return;
+		}
+
+		await this.handleAutoplay(player, track);
+	}
+
+	protected trackStuck(player: Player, track: Track, payload: TrackStuckEvent): void {
+		player.stop();
+		this.manager.emit("TrackStuck", player, track, payload);
+	}
+
+	protected trackError(player: Player, track: Track | UnresolvedTrack, payload: TrackExceptionEvent): void {
+		player.stop();
+		this.manager.emit("TrackError", player, track, payload);
+	}
+
+	protected socketClosed(player: Player, payload: WebSocketClosedEvent): void {
+		this.manager.emit("SocketClosed", player, payload);
+	}
+}
+
+export interface NodeOptions {
+	/** The host for the node. */
+	host: string;
+	/** The port for the node. */
+	port?: number;
+	/** The password for the node. */
+	password?: string;
+	/** Whether the host uses SSL. */
+	secure?: boolean;
+	/** The identifier for the node. */
+	identifier?: string;
+	/** The retryAmount for the node. */
+	retryAmount?: number;
+	/** The retryDelay for the node. */
+	retryDelay?: number;
+	/** Whether to resume the previous session. */
+	resumeStatus?: boolean;
+	/** The time the manager will wait before trying to resume the previous session. */
+	resumeTimeout?: number;
+	/** The timeout used for api calls. */
+	requestTimeout?: number;
+	/** Priority of the node. */
+	priority?: number;
+}
+
+export interface NodeStats {
+	/** The amount of players on the node. */
+	players: number;
+	/** The amount of playing players on the node. */
+	playingPlayers: number;
+	/** The uptime for the node. */
+	uptime: number;
+	/** The memory stats for the node. */
+	memory: MemoryStats;
+	/** The cpu stats for the node. */
+	cpu: CPUStats;
+	/** The frame stats for the node. */
+	frameStats: FrameStats;
+}
+
+export interface MemoryStats {
+	/** The free memory of the allocated amount. */
+	free: number;
+	/** The used memory of the allocated amount. */
+	used: number;
+	/** The total allocated memory. */
+	allocated: number;
+	/** The reservable memory. */
+	reservable: number;
+}
+
+export interface CPUStats {
+	/** The core amount the host machine has. */
+	cores: number;
+	/** The system load. */
+	systemLoad: number;
+	/** The lavalink load. */
+	lavalinkLoad: number;
+}
+
+export interface FrameStats {
+	/** The amount of sent frames. */
+	sent?: number;
+	/** The amount of nulled frames. */
+	nulled?: number;
+	/** The amount of deficit frames. */
+	deficit?: number;
+}
+
+export interface LavalinkInfo {
+	version: { semver: string; major: number; minor: number; patch: number; preRelease: string };
+	buildTime: number;
+	git: { branch: string; commit: string; commitTime: number };
+	jvm: string;
+	lavaplayer: string;
+	sourceManagers: string[];
+	filters: string[];
+	plugins: { name: string; version: string }[];
+}
+
+}
+
+src } Utils } Structures } Manager.ts {
+
+    /* eslint-disable no-async-promise-executor */
+import { EventEmitter } from "events";
+import {
+	LoadType,
+	Plugin,
+	Structure,
+	TrackData,
+	TrackEndEvent,
+	TrackExceptionEvent,
+	TrackStartEvent,
+	TrackStuckEvent,
+	TrackUtils,
+	VoicePacket,
+	VoiceServer,
+	WebSocketClosedEvent,
+} from "./Utils";
+import { Collection } from "@discordjs/collection";
+import { Node, NodeOptions } from "./Node";
+import { Player, PlayerOptions, Track, UnresolvedTrack } from "./Player";
+import { VoiceState } from "..";
+import managerCheck from "../Utils/ManagerCheck";
+import { ClientUser, User } from "discord.js";
+import { TikTok } from "./TikTok";
+
+
+
+/**
+ * The main hub for interacting with Lavalink and using Magmastream,
+ */
+export class Manager extends EventEmitter {
+	public static readonly DEFAULT_SOURCES: Record<SearchPlatform, string> = {
+		"youtube music": "ytmsearch",
+		youtube: "ytsearch",
+		spotify: "spsearch",
+		jiosaavn: "jssearch",
+		soundcloud: "scsearch",
+		deezer: "dzsearch",
+		tidal: "tdsearch",
+		applemusic: "amsearch",
+		bandcamp: "bcsearch",
+		tiktok: "tiktok",
+	};
+
+	/** The map of players. */
+	public readonly players = new Collection<string, Player>();
+	/** The map of nodes. */
+	public readonly nodes = new Collection<string, Node>();
+	/** The options that were set. */
+	public readonly options: ManagerOptions;
+	private initiated = false;
+	public caches = new Collection<string, SearchResult>();
+
+	/** Returns the nodes that has the least load. */
+	public get leastLoadNode(): Collection<string, Node> {
+		return this.nodes
+			.filter((node) => node.connected)
+			.sort((a, b) => {
+				const aload = a.stats.cpu ? (a.stats.cpu.lavalinkLoad / a.stats.cpu.cores) * 100 : 0;
+				const bload = b.stats.cpu ? (b.stats.cpu.lavalinkLoad / b.stats.cpu.cores) * 100 : 0;
+				return aload - bload;
+			});
+	}
+
+	/** Returns the nodes that has the least amount of players. */
+	private get leastPlayersNode(): Collection<string, Node> {
+		return this.nodes.filter((node) => node.connected).sort((a, b) => a.stats.players - b.stats.players);
+	}
+
+	
+
+	/** Returns a node based on priority. */
+	private get priorityNode(): Node {
+		const filteredNodes = this.nodes.filter((node) => node.connected && node.options.priority > 0);
+		const totalWeight = filteredNodes.reduce((total, node) => total + node.options.priority, 0);
+		const weightedNodes = filteredNodes.map((node) => ({
+			node,
+			weight: node.options.priority / totalWeight,
+		}));
+		const randomNumber = Math.random();
+
+		let cumulativeWeight = 0;
+
+		for (const { node, weight } of weightedNodes) {
+			cumulativeWeight += weight;
+			if (randomNumber <= cumulativeWeight) {
+				return node;
+			}
+		}
+
+		return this.options.useNode === "leastLoad" ? this.leastLoadNode.first() : this.leastPlayersNode.first();
+	}
+
+	/** Returns the node to use. */
+	public get useableNodes(): Node {
+		return this.options.usePriority ? this.priorityNode : this.options.useNode === "leastLoad" ? this.leastLoadNode.first() : this.leastPlayersNode.first();
+	}
+
+	/**
+	 * Initiates the Manager class.
+	 * @param options
+	 */
+	constructor(options: ManagerOptions) {
+		super();
+
+		managerCheck(options);
+		Structure.get("Player").init(this);
+		Structure.get("Node").init(this);
+		TrackUtils.init(this);
+		
+		if (options.trackPartial) {
+			TrackUtils.setTrackPartial(options.trackPartial);
+			delete options.trackPartial;
+		}
+
+		this.options = {
+			plugins: [],
+			nodes: [
+				{
+					identifier: "default",
+					host: "localhost",
+					resumeStatus: false,
+					resumeTimeout: 1000,
+				},
+			],
+			shards: 1,
+			autoPlay: true,
+			usePriority: false,
+			clientName: "For v3.0",
+			defaultSearchPlatform: "youtube",
+			useNode: "leastPlayers",
+			...options,
+		};
+
+		
+
+		if (this.options.plugins) {
+			for (const [index, plugin] of this.options.plugins.entries()) {
+				if (!(plugin instanceof Plugin)) throw new RangeError(`Plugin at index ${index} does not extend Plugin.`);
+				plugin.load(this);
+			}
+		}
+
+		if (this.options.nodes) {
+			for (const nodeOptions of this.options.nodes) {
+				const node = new (Structure.get("Node"))(nodeOptions);
+				this.nodes.set(node.options.identifier, node);
+			}
+		}
+		setInterval(() => {
+			this.caches.clear();
+		}, this.options.caches.time);
+	}
+
+
+	/**
+	 * Initiates the Manager.
+	 * @param clientId
+	 */
+	public init(clientId?: string): this {
+		if (this.initiated) return this;
+		if (typeof clientId !== "undefined") this.options.clientId = clientId;
+
+		if (typeof this.options.clientId !== "string") throw new Error('"clientId" set is not type of "string"');
+
+		if (!this.options.clientId) throw new Error('"clientId" is not set. Pass it in Manager#init() or as a option in the constructor.');
+
+		for (const node of this.nodes.values()) {
+			try {
+				node.connect();
+			} catch (err) {
+				this.emit("NodeError", node, err);
+			}
+		}
+
+		this.initiated = true;
+		return this;
+	}
+
+	/**
+	 * Searches the enabled sources based off the URL or the `source` property.
+	 * @param query
+	 * @param requester
+	 * @returns The search result.
+	 */
+	public async search(query: string | SearchQuery, requester?: User | ClientUser): Promise<SearchResult> {
+		const node = this.useableNodes;
+
+		if (!node) {
+			throw new Error("No available nodes.");
+		}
+		if (this.options.caches.enabled && this.options.caches.time > 0 && typeof query === "string") {
+			const data = this.caches.get(query);
+			if (data) return data;
+		}
+		const _query: SearchQuery = typeof query === "string" ? { query } : query;
+		const _source = Manager.DEFAULT_SOURCES[_query.source ?? this.options.defaultSearchPlatform] ?? _query.source;
+		let search = _query.query;
+
+		if (!/^https?:\/\//.test(search)) {
+			search = `${_source}:${search}`;
+		}
+
+		if (typeof query !== "string") throw new TypeError("Query must be a string.");
+
+		if (TikTok.isTikTokURL(query)) {
+			const tiktokResult = await TikTok.searchTikTok(query, requester);
+			return {
+				loadType: tiktokResult.loadType as LoadType,
+				tracks: tiktokResult.tracks,
+			};
+		}
+
+		try {
+			const res = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(search)}`)) as LavalinkResponse;
+			if (!res) throw new Error("Query not found.");
+
+			let searchData = [];
+			let playlistData: PlaylistRawData | undefined;
+
+			switch (res.loadType) {
+				case "search":
+					searchData = res.data as TrackData[];
+					break;
+
+				case "track":
+					searchData = [res.data as TrackData[]];
+					break;
+
+				case "playlist":
+					playlistData = res.data as PlaylistRawData;
+					break;
+			}
+
+			const tracks = searchData.map((track) => TrackUtils.build(track, requester));
+			let playlist = null;
+
+			if (res.loadType === "playlist") {
+				playlist = {
+					name: playlistData!.info.name,
+					tracks: playlistData!.tracks.map((track) => TrackUtils.build(track, requester)),
+					duration: playlistData!.tracks.reduce((acc, cur) => acc + (cur.info.length || 0), 0),
+				};
+			}
+
+			const result: SearchResult = {
+				loadType: res.loadType,
+				tracks,
+				playlist,
+			};
+
+			if (this.options.replaceYouTubeCredentials) {
+				let tracksToReplace: Track[] = [];
+				if (result.loadType === "playlist") {
+					tracksToReplace = result.playlist.tracks;
+				} else {
+					tracksToReplace = result.tracks;
+				}
+
+				for (const track of tracksToReplace) {
+					if (isYouTubeURL(track.uri)) {
+						track.author = track.author.replace("- Topic", "");
+						track.title = track.title.replace("Topic -", "");
+					}
+					if (track.title.includes("-")) {
+						const [author, title] = track.title.split("-").map((str: string) => str.trim());
+						track.author = author;
+						track.title = title;
+					}
+				}
+			}
+			if (this.options.caches.enabled && this.options.caches.time > 0) this.caches.set(search, result);
+			return result;
+		} catch (err) {
+			throw new Error(err);
+		}
+
+		function isYouTubeURL(uri: string): boolean {
+			return uri.includes("youtube.com") || uri.includes("youtu.be");
+		}
+	}
+
+	/**
+	 * Decodes the base64 encoded tracks and returns a TrackData array.
+	 * @param tracks
+	 */
+	public decodeTracks(tracks: string[]): Promise<TrackData[]> {
+		return new Promise(async(resolve, reject) => {
+			const node = this.nodes.first();
+			if (!node) {
+				return reject(new Error("No available nodes."));
+			}
+	
+			await node.rest.post("/v4/decodetracks", JSON.stringify(tracks))
+				.then((res) => {
+					if (!res) return reject(new Error("No data returned from query."));
+					resolve(res as TrackData[]);
+				})
+				.catch((err) => reject(err));
+		});
+	}
+
+	/**
+	 * Decodes the base64 encoded track and returns a TrackData.
+	 * @param track
+	 */
+	public async decodeTrack(track: string): Promise<TrackData> {
+		const res = await this.decodeTracks([track]);
+		return res[0];
+	}
+
+	/**
+	 * Creates a player or returns one if it already exists.
+	 * @param options
+	 */
+	public create(options: PlayerOptions): Player {
+		if (this.players.has(options.guild)) {
+			return this.players.get(options.guild);
+		}
+
+		return new (Structure.get("Player"))(options);
+	}
+
+	/**
+	 * Returns a player or undefined if it does not exist.
+	 * @param guild
+	 */
+	public get(guild: string): Player | undefined {
+		return this.players.get(guild);
+	}
+
+	/**
+	 * Destroys a player if it exists.
+	 * @param guild
+	 */
+	public destroy(guild: string): void {
+		this.players.delete(guild);
+	}
+
+	/**
+	 * Creates a node or returns one if it already exists.
+	 * @param options
+	 */
+	public createNode(options: NodeOptions): Node {
+		if (this.nodes.has(options.identifier || options.host)) {
+			return this.nodes.get(options.identifier || options.host);
+		}
+
+		return new (Structure.get("Node"))(options);
+	}
+
+	/**
+	 * Destroys a node if it exists.
+	 * @param identifier
+	 */
+	public destroyNode(identifier: string): void {
+		const node = this.nodes.get(identifier);
+		if (!node) return;
+		node.destroy();
+		this.nodes.delete(identifier);
+	}
+
+	/**
+	 * Sends voice data to the Lavalink server.
+	 * @param data
+	 */
+	public async updateVoiceState(data: VoicePacket | VoiceServer | VoiceState): Promise<void> {
+		if ("t" in data && !["VOICE_STATE_UPDATE", "VOICE_SERVER_UPDATE"].includes(data.t)) return;
+
+		const update = "d" in data ? data.d : data;
+
+		if (!update || (!("token" in update) && !("session_id" in update))) return;
+
+		const player = this.players.get(update.guild_id);
+
+		if (!player) return;
+		if ("token" in update) {
+			player.voiceState.event = update;
+
+			const {
+				sessionId,
+				event: { token, endpoint },
+			} = player.voiceState;
+
+			await player.node.rest.updatePlayer({
+				guildId: player.guild,
+				data: { voice: { token, endpoint, sessionId } },
+			});
+
+			return;
+		}
+
+		if (update.user_id !== this.options.clientId) return;
+		if (update.channel_id) {
+			if (player.voiceChannel !== update.channel_id) {
+				this.emit("PlayerMove", player, player.voiceChannel, update.channel_id);
+			}
+
+			player.voiceState.sessionId = update.session_id;
+			player.voiceChannel = update.channel_id;
+			return;
+		}
+
+		this.emit("PlayerDisconnect", player, player.voiceChannel);
+		player.voiceChannel = null;
+		player.voiceState = Object.assign({});
+		player.destroy();
+		return;
+	}
+}
+
+export interface Payload {
+	/** The OP code */
+	op: number;
+	d: {
+		guild_id: string;
+		channel_id: string | null;
+		self_mute: boolean;
+		self_deaf: boolean;
+	};
+}
+
+export interface ManagerOptions {
+	/** Use priority mode over least amount of player or load? */
+	usePriority?: boolean;
+	/** Use the least amount of players or least load? */
+	useNode?: "leastLoad" | "leastPlayers";
+	/** The array of nodes to connect to. */
+	nodes?: NodeOptions[];
+	/** The client ID to use. */
+	clientId?: string;
+	/** Value to use for the `Client-Name` header. */
+	clientName?: string;
+	/** The shard count. */
+	shards?: number;
+	/** A array of plugins to use. */
+	plugins?: Plugin[];
+	/** Whether players should automatically play the next song. */
+	autoPlay?: boolean;
+	/** An array of track properties to keep. `track` will always be present. */
+	trackPartial?: string[];
+	/** The default search platform to use, can be "youtube", "youtube music", "soundcloud" or deezer. */
+	defaultSearchPlatform?: SearchPlatform;
+	/** Whether the YouTube video titles should be replaced if the Author does not exactly match. */
+	replaceYouTubeCredentials?: boolean;
+	caches: {
+		/** Whether to cache the search results. */
+		enabled: boolean;
+		/** The time to cache the search results. */
+		time: number;
+	}
+	/**
+	 * Function to send data to the websocket.
+	 * @param id
+	 * @param payload
+	 */
+	send(id: string, payload: Payload): void;
+}
+
+export type SearchPlatform = "deezer" | "soundcloud" | "youtube music" | "youtube" | "spotify" | "jiosaavn" | "tidal" | "applemusic" | "bandcamp" | "tiktok";
+
+export interface SearchQuery {
+	/** The source to search from. */
+	source?: SearchPlatform | string;
+	/** The query to search for. */
+	query: string;
+}
+
+export interface LavalinkResponse {
+	loadType: LoadType;
+	data: TrackData[] | PlaylistRawData;
+}
+
+export interface SearchResult {
+	/** The load type of the result. */
+	loadType: LoadType;
+	/** The array of tracks from the result. */
+	tracks: Track[];
+	/** The playlist info if the load type is 'playlist'. */
+	playlist?: PlaylistData;
+}
+
+export interface PlaylistRawData {
+	info: {
+		/** The playlist name. */
+		name: string;
+	};
+	/** Addition info provided by plugins. */
+	pluginInfo: object;
+	/** The tracks of the playlist */
+	tracks: TrackData[];
+}
+
+export interface PlaylistData {
+	/** The playlist name. */
+	name: string;
+	/** The length of the playlist. */
+	duration: number;
+	/** The songs of the playlist. */
+	tracks: Track[];
+}
+
+export interface ManagerEvents {
+	NodeCreate: (node: Node) => void;
+	NodeDestroy: (node: Node) => void;
+	NodeConnect: (node: Node) => void;
+	NodeReconnect: (node: Node) => void;
+	NodeDisconnect: (node: Node, reason: { code?: number; reason?: string }) => void;
+	NodeError: (node: Node, error: Error) => void;
+	NodeRaw: (payload: unknown) => void;
+	PlayerCreate: (player: Player) => void;
+	PlayerDestroy: (player: Player) => void;
+	PlayerStateUpdate: (oldPlayer: Player, newPlayer: Player) => void;
+	PlayerMove: (player: Player, initChannel: string, newChannel: string) => void;
+	PlayerDisconnect: (player: Player, oldChannel: string) => void;
+	QueueEnd: (player: Player, track: Track | UnresolvedTrack, payload: TrackEndEvent) => void;
+	SocketClosed: (player: Player, payload: WebSocketClosedEvent) => void;
+	TrackStart: (player: Player, track: Track, payload: TrackStartEvent) => void;
+	TrackEnd: (player: Player, track: Track, payload: TrackEndEvent) => void;
+	TrackStuck: (player: Player, track: Track, payload: TrackStuckEvent) => void;
+	TrackError: (player: Player, track: Track | UnresolvedTrack, payload: TrackExceptionEvent) => void;
+}
+
+}
+
+src } Utils } Structures } Filters.ts {
+    import { Band, bassBoostEqualizer, softEqualizer, trebleBassEqualizer, tvEqualizer, vaporwaveEqualizer } from "../Utils/FiltersEqualizers";
+import { Player } from "./Player";
+
+export class Filters {
+	public distortion: DistortionOptions | null;
+	public equalizer: Band[];
+	public karaoke: KaraokeOptions | null;
+	public player: Player;
+	public rotation: RotationOptions | null;
+	public timescale: TimescaleOptions | null;
+	public vibrato: VibratoOptions | null;
+	public volume: number;
+
+	private filterStatus: {
+		[key: string]: boolean;
+	};
+
+	constructor(player: Player) {
+		this.distortion = null;
+		this.equalizer = [];
+		this.karaoke = null;
+		this.player = player;
+		this.rotation = null;
+		this.timescale = null;
+		this.vibrato = null;
+		this.volume = 1.0;
+		// Initialize filter status
+		this.filterStatus = {
+			bassboost: false,
+			distort: false,
+			eightD: false,
+			karaoke: false,
+			nightcore: false,
+			slowmo: false,
+			soft: false,
+			trebleBass: false,
+			tv: false,
+			vaporwave: false,
+		};
+	}
+
+	private async updateFilters(): Promise<this> {
+		const { distortion, equalizer, karaoke, rotation, timescale, vibrato, volume } = this;
+
+		await this.player.node.rest.updatePlayer({
+			data: {
+				filters: {
+					distortion,
+					equalizer,
+					karaoke,
+					rotation,
+					timescale,
+					vibrato,
+					volume,
+				},
+			},
+			guildId: this.player.guild,
+		});
+
+		return this;
+	}
+
+	private applyFilter<T extends keyof Filters>(filter: { property: T; value: Filters[T] }, updateFilters: boolean = true): this {
+		this[filter.property] = filter.value as this[T];
+		if (updateFilters) {
+			this.updateFilters();
+		}
+		return this;
+	}
+
+	private setFilterStatus(filter: keyof AvailableFilters, status: boolean): this {
+		this.filterStatus[filter] = status;
+		return this;
+	}
+
+	/**
+	 * Sets the equalizer bands and updates the filters.
+	 * @param bands - The equalizer bands.
+	 */
+	public setEqualizer(bands?: Band[]): this {
+		return this.applyFilter({ property: "equalizer", value: bands });
+	}
+
+	/** Applies the eight dimension audio effect. */
+	public eightD(): this {
+		return this.setRotation({ rotationHz: 0.2 }).setFilterStatus("eightD", true);
+	}
+
+	/** Applies the bass boost effect. */
+	public bassBoost(): this {
+		return this.setEqualizer(bassBoostEqualizer).setFilterStatus("bassboost", true);
+	}
+
+	/** Applies the nightcore effect. */
+	public nightcore(): this {
+		return this.setTimescale({
+			speed: 1.1,
+			pitch: 1.125,
+			rate: 1.05,
+		}).setFilterStatus("nightcore", true);
+	}
+
+	/** Applies the slow motion audio effect. */
+	public slowmo(): this {
+		return this.setTimescale({
+			speed: 0.7,
+			pitch: 1.0,
+			rate: 0.8,
+		}).setFilterStatus("slowmo", true);
+	}
+
+	/** Applies the soft audio effect. */
+	public soft(): this {
+		return this.setEqualizer(softEqualizer).setFilterStatus("soft", true);
+	}
+
+	/** Applies the television audio effect. */
+	public tv(): this {
+		return this.setEqualizer(tvEqualizer).setFilterStatus("tv", true);
+	}
+
+	/** Applies the treble bass effect. */
+	public trebleBass(): this {
+		return this.setEqualizer(trebleBassEqualizer).setFilterStatus("trebleBass", true);
+	}
+
+	/** Applies the vaporwave effect. */
+	public vaporwave(): this {
+		return this.setEqualizer(vaporwaveEqualizer).setTimescale({ pitch: 0.55 }).setFilterStatus("vaporwave", true);
+	}
+
+	/** Applies the distortion audio effect. */
+	public distort(): this {
+		return this.setDistortion({
+			sinOffset: 0,
+			sinScale: 0.2,
+			cosOffset: 0,
+			cosScale: 0.2,
+			tanOffset: 0,
+			tanScale: 0.2,
+			offset: 0,
+			scale: 1.2,
+		}).setFilterStatus("distort", true);
+	}
+
+	/** Applies the karaoke options specified by the filter. */
+	public setKaraoke(karaoke?: KaraokeOptions): this {
+		return this.applyFilter({
+			property: "karaoke",
+			value: karaoke,
+		}).setFilterStatus("karaoke", true);
+	}
+
+	/** Applies the timescale options specified by the filter. */
+	public setTimescale(timescale?: TimescaleOptions): this {
+		return this.applyFilter({ property: "timescale", value: timescale });
+	}
+
+	/** Applies the vibrato options specified by the filter. */
+	public setVibrato(vibrato?: VibratoOptions): this {
+		return this.applyFilter({ property: "vibrato", value: vibrato });
+	}
+
+	/** Applies the rotation options specified by the filter. */
+	public setRotation(rotation?: RotationOptions): this {
+		return this.applyFilter({ property: "rotation", value: rotation });
+	}
+
+	/** Applies the distortion options specified by the filter. */
+	public setDistortion(distortion?: DistortionOptions): this {
+		return this.applyFilter({ property: "distortion", value: distortion });
+	}
+
+	/** Removes the audio effects and resets the filter status. */
+	public async clearFilters(): Promise<this> {
+		this.filterStatus = {
+			bassboost: false,
+			distort: false,
+			eightD: false,
+			karaoke: false,
+			nightcore: false,
+			slowmo: false,
+			soft: false,
+			trebleBass: false,
+			tv: false,
+			vaporwave: false,
+		};
+
+		this.player.filters = new Filters(this.player);
+		this.setEqualizer([]);
+		this.setDistortion(null);
+		this.setKaraoke(null);
+		this.setRotation(null);
+		this.setTimescale(null);
+		this.setVibrato(null);
+
+		await this.updateFilters();
+		return this;
+	}
+
+	/** Returns the status of the specified filter . */
+	public getFilterStatus(filter: keyof AvailableFilters): boolean {
+		return this.filterStatus[filter];
+	}
+}
+
+/** Options for adjusting the timescale of audio. */
+interface TimescaleOptions {
+	/** The speed factor for the timescale. */
+	speed?: number;
+	/** The pitch factor for the timescale. */
+	pitch?: number;
+	/** The rate factor for the timescale. */
+	rate?: number;
+}
+
+/** Options for applying vibrato effect to audio. */
+interface VibratoOptions {
+	/** The frequency of the vibrato effect. */
+	frequency: number;
+	/** * The depth of the vibrato effect.*/
+	depth: number;
+}
+
+/** Options for applying rotation effect to audio. */
+interface RotationOptions {
+	/** The rotation speed in Hertz (Hz). */
+	rotationHz: number;
+}
+
+/** Options for applying karaoke effect to audio. */
+interface KaraokeOptions {
+	/** The level of karaoke effect. */
+	level?: number;
+	/** The mono level of karaoke effect. */
+	monoLevel?: number;
+	/** The filter band of karaoke effect. */
+	filterBand?: number;
+	/** The filter width of karaoke effect. */
+	filterWidth?: number;
+}
+
+interface DistortionOptions {
+	sinOffset?: number;
+	sinScale?: number;
+	cosOffset?: number;
+	cosScale?: number;
+	tanOffset?: number;
+	tanScale?: number;
+	offset?: number;
+	scale?: number;
+}
+
+interface AvailableFilters {
+	bassboost: boolean;
+	distort: boolean;
+	eightD: boolean;
+	karaoke: boolean;
+	nightcore: boolean;
+	slowmo: boolean;
+	soft: boolean;
+	trebleBass: boolean;
+	tv: boolean;
+	vaporwave: boolean;
+}
+
+}