magmastream 2.9.0-dev.4 → 2.9.0-dev.6

package/dist/index.d.ts

@@ -1135,7 +1135,7 @@ interface ManagerOptions {
     playNextOnEnd?: boolean;
     /** An array of search platforms to use for autoplay. First to last matters
      * Use enum `AutoPlayPlatform`.
-    */
+     */
     autoPlaySearchPlatforms?: AutoPlayPlatform[];
     /** The client ID to use. */
     clientId?: string;
@@ -1222,6 +1222,8 @@ declare enum AutoPlayPlatform {
     Spotify = "spotify",
     Deezer = "deezer",
     SoundCloud = "soundcloud",
+    Tidal = "tidal",
+    VKMusic = "vkmusic",
     YouTube = "youtube"
 }
 declare enum PlayerStateEventTypes {

package/dist/structures/Manager.js

@@ -391,6 +391,7 @@ class Manager extends events_1.EventEmitter {
                             voiceChannelId: state.options.voiceChannelId,
                             selfDeafen: state.options.selfDeafen,
                             volume: lavaPlayer.volume || state.options.volume,
+                            node: nodeId,
                         };
                         this.emit(ManagerEventTypes.Debug, `[MANAGER] Recreating player: ${state.guildId} from saved file: ${JSON.stringify(state.options)}`);
                         const player = this.create(playerOptions);
@@ -928,6 +929,8 @@ var AutoPlayPlatform;
     AutoPlayPlatform["Spotify"] = "spotify";
     AutoPlayPlatform["Deezer"] = "deezer";
     AutoPlayPlatform["SoundCloud"] = "soundcloud";
+    AutoPlayPlatform["Tidal"] = "tidal";
+    AutoPlayPlatform["VKMusic"] = "vkmusic";
     AutoPlayPlatform["YouTube"] = "youtube";
 })(AutoPlayPlatform || (exports.AutoPlayPlatform = AutoPlayPlatform = {}));
 var PlayerStateEventTypes;

package/dist/structures/Utils.js

@@ -262,9 +262,73 @@ class AutoPlayUtils {
     static async getRecommendedTracksFromSource(track, platform) {
         switch (platform) {
             case "spotify":
-                try {
-                    if (!track.uri.includes("spotify")) {
-                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
+                {
+                    try {
+                        if (!track.uri.includes("spotify")) {
+                            const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
+                            if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                                return [];
+                            }
+                            if (res.loadType === LoadTypes.Playlist) {
+                                res.tracks = res.playlist.tracks;
+                            }
+                            if (!res.tracks.length) {
+                                return [];
+                            }
+                            track = res.tracks[0];
+                        }
+                        const TOTP_SECRET = new Uint8Array([
+                            53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57, 53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55,
+                        ]);
+                        const hmac = crypto_1.default.createHmac("sha1", TOTP_SECRET);
+                        function generateTotp() {
+                            const counter = Math.floor(Date.now() / 30000);
+                            const counterBuffer = Buffer.alloc(8);
+                            counterBuffer.writeBigInt64BE(BigInt(counter));
+                            hmac.update(counterBuffer);
+                            const hmacResult = hmac.digest();
+                            const offset = hmacResult[hmacResult.length - 1] & 15;
+                            const truncatedValue = ((hmacResult[offset] & 127) << 24) | ((hmacResult[offset + 1] & 255) << 16) | ((hmacResult[offset + 2] & 255) << 8) | (hmacResult[offset + 3] & 255);
+                            const totp = (truncatedValue % 1000000).toString().padStart(6, "0");
+                            return [totp, counter * 30000];
+                        }
+                        const [totp, timestamp] = generateTotp();
+                        const params = {
+                            reason: "transport",
+                            productType: "embed",
+                            totp: totp,
+                            totpVer: 5,
+                            ts: timestamp,
+                        };
+                        let body;
+                        try {
+                            const response = await axios_1.default.get("https://open.spotify.com/get_access_token", { params });
+                            body = response.data;
+                        }
+                        catch (error) {
+                            console.error("[AutoPlay] Failed to get spotify access token:", error.response?.status, error.response?.data || error.message);
+                            return [];
+                        }
+                        let json;
+                        try {
+                            const response = await axios_1.default.get(`https://api.spotify.com/v1/recommendations`, {
+                                params: { limit: 10, seed_tracks: track.identifier },
+                                headers: {
+                                    Authorization: `Bearer ${body.accessToken}`,
+                                    "Content-Type": "application/json",
+                                },
+                            });
+                            json = response.data;
+                        }
+                        catch (error) {
+                            console.error("[AutoPlay] Failed to fetch spotify recommendations:", error.response?.status, error.response?.data || error.message);
+                            return [];
+                        }
+                        if (!json.tracks || !json.tracks.length) {
+                            return [];
+                        }
+                        const recommendedTrackId = json.tracks[Math.floor(Math.random() * json.tracks.length)].id;
+                        const res = await this.manager.search({ query: `https://open.spotify.com/track/${recommendedTrackId}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
                         if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
                             return [];
                         }
@@ -274,214 +338,271 @@ class AutoPlayUtils {
                         if (!res.tracks.length) {
                             return [];
                         }
-                        track = res.tracks[0];
-                    }
-                    const TOTP_SECRET = new Uint8Array([
-                        53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57, 53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55,
-                    ]);
-                    const hmac = crypto_1.default.createHmac("sha1", TOTP_SECRET);
-                    function generateTotp() {
-                        const counter = Math.floor(Date.now() / 30000);
-                        const counterBuffer = Buffer.alloc(8);
-                        counterBuffer.writeBigInt64BE(BigInt(counter));
-                        hmac.update(counterBuffer);
-                        const hmacResult = hmac.digest();
-                        const offset = hmacResult[hmacResult.length - 1] & 15;
-                        const truncatedValue = ((hmacResult[offset] & 127) << 24) | ((hmacResult[offset + 1] & 255) << 16) | ((hmacResult[offset + 2] & 255) << 8) | (hmacResult[offset + 3] & 255);
-                        const totp = (truncatedValue % 1000000).toString().padStart(6, "0");
-                        return [totp, counter * 30000];
-                    }
-                    const [totp, timestamp] = generateTotp();
-                    const params = {
-                        reason: "transport",
-                        productType: "embed",
-                        totp: totp,
-                        totpVer: 5,
-                        ts: timestamp,
-                    };
-                    let body;
-                    try {
-                        const response = await axios_1.default.get("https://open.spotify.com/get_access_token", { params });
-                        body = response.data;
+                        return res.tracks;
                     }
                     catch (error) {
-                        console.error("[AutoPlay] Failed to get spotify access token:", error.response?.status, error.response?.data || error.message);
+                        console.error("[AutoPlay] Unexpected spotify error:", error.message || error);
                         return [];
                     }
-                    let json;
-                    try {
-                        const response = await axios_1.default.get(`https://api.spotify.com/v1/recommendations`, {
-                            params: { limit: 10, seed_tracks: track.identifier },
-                            headers: {
-                                Authorization: `Bearer ${body.accessToken}`,
-                                "Content-Type": "application/json",
-                            },
-                        });
-                        json = response.data;
+                }
+                break;
+            case "deezer":
+                {
+                    if (!track.uri.includes("deezer")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Deezer }, track.requester);
+                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
                     }
-                    catch (error) {
-                        console.error("[AutoPlay] Failed to fetch spotify recommendations:", error.response?.status, error.response?.data || error.message);
+                    const identifier = `dzrec:${track.identifier}`;
+                    const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    if (!recommendedResult) {
                         return [];
                     }
-                    if (!json.tracks || !json.tracks.length) {
-                        return [];
+                    let tracks = [];
+                    let playlist = null;
+                    const requester = track.requester;
+                    switch (recommendedResult.loadType) {
+                        case LoadTypes.Search:
+                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
+                            break;
+                        case LoadTypes.Track:
+                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
+                            break;
+                        case LoadTypes.Playlist: {
+                            const playlistData = recommendedResult.data;
+                            tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
+                            playlist = {
+                                name: playlistData.info.name,
+                                playlistInfo: playlistData.pluginInfo,
+                                requester: requester,
+                                tracks,
+                                duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
+                            };
+                            break;
+                        }
                     }
-                    const recommendedTrackId = json.tracks[Math.floor(Math.random() * json.tracks.length)].id;
-                    const res = await this.manager.search({ query: `https://open.spotify.com/track/${recommendedTrackId}`, source: Manager_1.SearchPlatform.Spotify }, track.requester);
-                    if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
+                    if (result.loadType === LoadTypes.Empty || result.loadType === LoadTypes.Error) {
                         return [];
                     }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
+                    if (result.loadType === LoadTypes.Playlist) {
+                        result.tracks = result.playlist.tracks;
                     }
-                    if (!res.tracks.length) {
+                    if (!result.tracks.length) {
                         return [];
                     }
-                    return res.tracks;
-                }
-                catch (error) {
-                    console.error("[AutoPlay] Unexpected spotify error:", error.message || error);
-                    return [];
+                    return result.tracks;
                 }
                 break;
-            case "deezer":
-                if (!track.uri.includes("deezer")) {
-                    const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Deezer }, track.requester);
-                    if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                        return [];
+            case "soundcloud":
+                {
+                    if (!track.uri.includes("soundcloud")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
+                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
                     }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
+                    try {
+                        const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`).catch((err) => {
+                            console.error(`[AutoPlay] Failed to fetch SoundCloud recommendations. Status: ${err.response?.status || "Unknown"}`, err.message);
+                            return null;
+                        });
+                        if (!recommendedRes) {
+                            return [];
+                        }
+                        const html = recommendedRes.data;
+                        const dom = new jsdom_1.JSDOM(html);
+                        const document = dom.window.document;
+                        const secondNoscript = document.querySelectorAll("noscript")[1];
+                        const sectionElement = secondNoscript.querySelector("section");
+                        const articleElements = sectionElement.querySelectorAll("article");
+                        if (!articleElements || articleElements.length === 0) {
+                            return [];
+                        }
+                        const urls = Array.from(articleElements)
+                            .map((articleElement) => {
+                            const h2Element = articleElement.querySelector('h2[itemprop="name"]');
+                            const aElement = h2Element?.querySelector('a[itemprop="url"]');
+                            return aElement ? `https://soundcloud.com${aElement.getAttribute("href")}` : null;
+                        })
+                            .filter(Boolean);
+                        if (!urls.length) {
+                            return [];
+                        }
+                        const randomUrl = urls[Math.floor(Math.random() * urls.length)];
+                        const res = await this.manager.search({ query: randomUrl, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
+                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        return res.tracks;
                     }
-                    if (!res.tracks.length) {
+                    catch (error) {
+                        console.error("[AutoPlay] Error occurred while fetching soundcloud recommendations:", error);
                         return [];
                     }
-                    track = res.tracks[0];
-                }
-                const identifier = `dzrec:${track.identifier}`;
-                const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-                if (!recommendedResult) {
-                    return [];
-                }
-                let tracks = [];
-                let playlist = null;
-                const requester = track.requester;
-                switch (recommendedResult.loadType) {
-                    case LoadTypes.Search:
-                        tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
-                        break;
-                    case LoadTypes.Track:
-                        tracks = [TrackUtils.build(recommendedResult.data, requester)];
-                        break;
-                    case LoadTypes.Playlist: {
-                        const playlistData = recommendedResult.data;
-                        tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
-                        playlist = {
-                            name: playlistData.info.name,
-                            playlistInfo: playlistData.pluginInfo,
-                            requester: requester,
-                            tracks,
-                            duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
-                        };
-                        break;
-                    }
-                }
-                const result = { loadType: recommendedResult.loadType, tracks, playlist };
-                if (result.loadType === LoadTypes.Empty || result.loadType === LoadTypes.Error) {
-                    return [];
-                }
-                if (result.loadType === LoadTypes.Playlist) {
-                    result.tracks = result.playlist.tracks;
                 }
-                if (!result.tracks.length) {
-                    return [];
-                }
-                return result.tracks;
                 break;
-            case "soundcloud":
-                if (!track.uri.includes("soundcloud")) {
-                    const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
+            case "youtube":
+                {
+                    const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
+                    let videoID = null;
+                    if (hasYouTubeURL) {
+                        videoID = track.uri.split("=").pop();
+                    }
+                    else {
+                        const searchResult = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.YouTube }, track.requester);
+                        videoID = searchResult.tracks[0]?.uri.split("=").pop();
+                    }
+                    if (!videoID) {
+                        return [];
+                    }
+                    let randomIndex;
+                    let searchURI;
+                    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 this.manager.search({ query: searchURI, source: Manager_1.SearchPlatform.YouTube }, track.requester);
                     if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
                         return [];
                     }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
+                    const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
+                    return filteredTracks;
+                }
+                break;
+            case "tidal":
+                {
+                    if (!track.uri.includes("tidal")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.Tidal }, track.requester);
+                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
                     }
-                    if (!res.tracks.length) {
+                    const identifier = `tdrec:${track.identifier}`;
+                    const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    if (!recommendedResult) {
                         return [];
                     }
-                    track = res.tracks[0];
-                }
-                try {
-                    const recommendedRes = await axios_1.default.get(`${track.uri}/recommended`).catch((err) => {
-                        console.error(`[AutoPlay] Failed to fetch SoundCloud recommendations. Status: ${err.response?.status || "Unknown"}`, err.message);
-                        return null;
-                    });
-                    if (!recommendedRes) {
+                    let tracks = [];
+                    let playlist = null;
+                    const requester = track.requester;
+                    switch (recommendedResult.loadType) {
+                        case LoadTypes.Search:
+                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
+                            break;
+                        case LoadTypes.Track:
+                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
+                            break;
+                        case LoadTypes.Playlist: {
+                            const playlistData = recommendedResult.data;
+                            tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
+                            playlist = {
+                                name: playlistData.info.name,
+                                playlistInfo: playlistData.pluginInfo,
+                                requester: requester,
+                                tracks,
+                                duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
+                            };
+                            break;
+                        }
+                    }
+                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
+                    if (result.loadType === LoadTypes.Empty || result.loadType === LoadTypes.Error) {
                         return [];
                     }
-                    const html = recommendedRes.data;
-                    const dom = new jsdom_1.JSDOM(html);
-                    const document = dom.window.document;
-                    const secondNoscript = document.querySelectorAll("noscript")[1];
-                    const sectionElement = secondNoscript.querySelector("section");
-                    const articleElements = sectionElement.querySelectorAll("article");
-                    if (!articleElements || articleElements.length === 0) {
+                    if (result.loadType === LoadTypes.Playlist) {
+                        result.tracks = result.playlist.tracks;
+                    }
+                    if (!result.tracks.length) {
                         return [];
                     }
-                    const urls = Array.from(articleElements)
-                        .map((articleElement) => {
-                        const h2Element = articleElement.querySelector('h2[itemprop="name"]');
-                        const aElement = h2Element?.querySelector('a[itemprop="url"]');
-                        return aElement ? `https://soundcloud.com${aElement.getAttribute("href")}` : null;
-                    })
-                        .filter(Boolean);
-                    if (!urls.length) {
+                    return result.tracks;
+                }
+                break;
+            case "vkmusic":
+                {
+                    if (!track.uri.includes("vk.com") && !track.uri.includes("vk.ru")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.VKMusic }, track.requester);
+                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
+                    }
+                    const identifier = `vkrec:${track.identifier}`;
+                    const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    if (!recommendedResult) {
                         return [];
                     }
-                    const randomUrl = urls[Math.floor(Math.random() * urls.length)];
-                    const res = await this.manager.search({ query: randomUrl, source: Manager_1.SearchPlatform.SoundCloud }, track.requester);
-                    if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                    let tracks = [];
+                    let playlist = null;
+                    const requester = track.requester;
+                    switch (recommendedResult.loadType) {
+                        case LoadTypes.Search:
+                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
+                            break;
+                        case LoadTypes.Track:
+                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
+                            break;
+                        case LoadTypes.Playlist: {
+                            const playlistData = recommendedResult.data;
+                            tracks = playlistData.tracks.map((track) => TrackUtils.build(track, requester));
+                            playlist = {
+                                name: playlistData.info.name,
+                                playlistInfo: playlistData.pluginInfo,
+                                requester: requester,
+                                tracks,
+                                duration: tracks.reduce((acc, cur) => acc + (cur.duration || 0), 0),
+                            };
+                            break;
+                        }
+                    }
+                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
+                    if (result.loadType === LoadTypes.Empty || result.loadType === LoadTypes.Error) {
                         return [];
                     }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
+                    if (result.loadType === LoadTypes.Playlist) {
+                        result.tracks = result.playlist.tracks;
                     }
-                    if (!res.tracks.length) {
+                    if (!result.tracks.length) {
                         return [];
                     }
-                    return res.tracks;
-                }
-                catch (error) {
-                    console.error("[AutoPlay] Error occurred while fetching soundcloud recommendations:", error);
-                    return [];
+                    return result.tracks;
                 }
                 break;
-            case "youtube":
-                const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => track.uri.includes(url));
-                let videoID = null;
-                if (hasYouTubeURL) {
-                    videoID = track.uri.split("=").pop();
-                }
-                else {
-                    const searchResult = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Manager_1.SearchPlatform.YouTube }, track.requester);
-                    videoID = searchResult.tracks[0]?.uri.split("=").pop();
-                }
-                if (!videoID) {
-                    return [];
-                }
-                let randomIndex;
-                let searchURI;
-                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 this.manager.search({ query: searchURI, source: Manager_1.SearchPlatform.YouTube }, track.requester);
-                if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
-                    return [];
-                }
-                const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
-                return filteredTracks;
             default:
                 return [];
         }

package/dist/utils/managerCheck.js

@@ -16,19 +16,19 @@ function managerCheck(options) {
         throw new TypeError('Manager option "playNextOnEnd" must be a boolean.');
     }
     // Validate clientName option
-    if (typeof clientName !== undefined) {
+    if (typeof clientName !== "undefined") {
         if (typeof clientName !== "string" || clientName.trim().length === 0) {
             throw new TypeError('Manager option "clientName" must be a non-empty string.');
         }
     }
     // Validate defaultSearchPlatform option
-    if (typeof defaultSearchPlatform !== undefined) {
+    if (typeof defaultSearchPlatform !== "undefined") {
         if (!Object.values(Manager_1.SearchPlatform).includes(defaultSearchPlatform)) {
             throw new TypeError(`Manager option "defaultSearchPlatform" must be one of: ${Object.values(Manager_1.SearchPlatform).join(", ")}.`);
         }
     }
     // Validate autoPlaySearchPlatforms
-    if (autoPlaySearchPlatforms !== undefined) {
+    if (typeof autoPlaySearchPlatforms !== "undefined") {
         if (!Array.isArray(autoPlaySearchPlatforms)) {
             throw new TypeError('Manager option "autoPlaySearchPlatforms" must be an array.');
         }
@@ -37,11 +37,11 @@ function managerCheck(options) {
         }
     }
     // Validate nodes option
-    if (typeof nodes === undefined || !Array.isArray(nodes)) {
+    if (typeof nodes === "undefined" || !Array.isArray(nodes)) {
         throw new TypeError('Manager option "nodes" must be an array.');
     }
     // Validate enabledPlugins option
-    if (typeof enabledPlugins !== undefined && !Array.isArray(enabledPlugins)) {
+    if (typeof enabledPlugins !== "undefined" && !Array.isArray(enabledPlugins)) {
         throw new TypeError('Manager option "enabledPlugins" must be a Plugin array.');
     }
     // Validate send option
@@ -49,7 +49,7 @@ function managerCheck(options) {
         throw new TypeError('Manager option "send" must be present and a function.');
     }
     // Validate trackPartial option
-    if (typeof trackPartial !== undefined) {
+    if (typeof trackPartial !== "undefined") {
         if (!Array.isArray(trackPartial)) {
             throw new TypeError('Manager option "trackPartial" must be an array.');
         }
@@ -58,7 +58,7 @@ function managerCheck(options) {
         }
     }
     // Validate enablePriorityMode option
-    if (typeof enablePriorityMode !== undefined && typeof enablePriorityMode !== "boolean") {
+    if (typeof enablePriorityMode !== "undefined" && typeof enablePriorityMode !== "boolean") {
         throw new TypeError('Manager option "enablePriorityMode" must be a boolean.');
     }
     // Validate node priority if enablePriorityMode is enabled
@@ -70,7 +70,7 @@ function managerCheck(options) {
         }
     }
     // Validate useNode option
-    if (typeof useNode !== undefined) {
+    if (typeof useNode !== "undefined") {
         if (typeof useNode !== "string") {
             throw new TypeError('Manager option "useNode" must be a string "leastLoad" or "leastPlayers".');
         }
@@ -79,15 +79,15 @@ function managerCheck(options) {
         }
     }
     // Validate normalizeYouTubeTitles option
-    if (typeof normalizeYouTubeTitles !== undefined && typeof normalizeYouTubeTitles !== "boolean") {
+    if (typeof normalizeYouTubeTitles !== "undefined" && typeof normalizeYouTubeTitles !== "boolean") {
         throw new TypeError('Manager option "normalizeYouTubeTitles" must be a boolean.');
     }
     // Validate lastFmApiKey option
-    if (typeof lastFmApiKey !== undefined && (typeof lastFmApiKey !== "string" || lastFmApiKey.trim().length === 0)) {
+    if (typeof lastFmApiKey !== "undefined" && (typeof lastFmApiKey !== "string" || lastFmApiKey.trim().length === 0)) {
         throw new TypeError('Manager option "lastFmApiKey" must be a non-empty string.');
     }
     // Validate maxPreviousTracks option
-    if (typeof maxPreviousTracks !== undefined) {
+    if (typeof maxPreviousTracks !== "undefined") {
         if (typeof maxPreviousTracks !== "number" || isNaN(maxPreviousTracks)) {
             throw new TypeError('Manager option "maxPreviousTracks" must be a number.');
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.9.0-dev.4",
+	"version": "2.9.0-dev.6",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",