magmastream 2.9.0-dev.3 → 2.9.0-dev.31

package/dist/structures/Utils.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TrackSourceTypes = exports.SeverityTypes = exports.TrackEndReasonTypes = exports.StateTypes = exports.LoadTypes = exports.Structure = exports.AutoPlayUtils = exports.TrackUtils = void 0;
+exports.Structure = exports.AutoPlayUtils = exports.TrackUtils = void 0;
 const tslib_1 = require("tslib");
-const Manager_1 = require("./Manager");
 const axios_1 = tslib_1.__importDefault(require("axios"));
 const jsdom_1 = require("jsdom");
 const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const cheerio_1 = tslib_1.__importDefault(require("cheerio"));
+const Enums_1 = require("./Enums");
 /** @hidden */
 const SIZES = ["0", "1", "2", "3", "default", "mqdefault", "hqdefault", "maxresdefault"];
 class TrackUtils {
@@ -29,27 +30,27 @@ class TrackUtils {
         if (!Array.isArray(partial) || !partial.every((str) => typeof str === "string"))
             throw new Error("Provided partial is not an array or not a string array.");
         const defaultProperties = [
-            Manager_1.TrackPartial.Track,
-            Manager_1.TrackPartial.Title,
-            Manager_1.TrackPartial.Identifier,
-            Manager_1.TrackPartial.Author,
-            Manager_1.TrackPartial.Duration,
-            Manager_1.TrackPartial.Isrc,
-            Manager_1.TrackPartial.IsSeekable,
-            Manager_1.TrackPartial.IsStream,
-            Manager_1.TrackPartial.Uri,
-            Manager_1.TrackPartial.ArtworkUrl,
-            Manager_1.TrackPartial.SourceName,
-            Manager_1.TrackPartial.ThumbNail,
-            Manager_1.TrackPartial.Requester,
-            Manager_1.TrackPartial.PluginInfo,
-            Manager_1.TrackPartial.CustomData,
+            Enums_1.TrackPartial.Track,
+            Enums_1.TrackPartial.Title,
+            Enums_1.TrackPartial.Identifier,
+            Enums_1.TrackPartial.Author,
+            Enums_1.TrackPartial.Duration,
+            Enums_1.TrackPartial.Isrc,
+            Enums_1.TrackPartial.IsSeekable,
+            Enums_1.TrackPartial.IsStream,
+            Enums_1.TrackPartial.Uri,
+            Enums_1.TrackPartial.ArtworkUrl,
+            Enums_1.TrackPartial.SourceName,
+            Enums_1.TrackPartial.ThumbNail,
+            Enums_1.TrackPartial.Requester,
+            Enums_1.TrackPartial.PluginInfo,
+            Enums_1.TrackPartial.CustomData,
         ];
         /** The array of property names that will be removed from the Track class */
         this.trackPartial = Array.from(new Set([...defaultProperties, ...partial]));
         /** Make sure that the "track" property is always included */
-        if (!this.trackPartial.includes(Manager_1.TrackPartial.Track))
-            this.trackPartial.unshift(Manager_1.TrackPartial.Track);
+        if (!this.trackPartial.includes(Enums_1.TrackPartial.Track))
+            this.trackPartial.unshift(Enums_1.TrackPartial.Track);
     }
     /**
      * Checks if the provided argument is a valid Track.
@@ -143,58 +144,42 @@ class AutoPlayUtils {
             throw new Error("AutoPlayUtils.init() requires a valid Manager instance.");
         this.manager = manager;
     }
-    static async getRecommendedTracks(player, track, attempt = 0) {
+    /**
+     * Gets recommended tracks for the given track.
+     * @param track The track to get recommended tracks for.
+     * @returns An array of recommended tracks.
+     */
+    static async getRecommendedTracks(track) {
         const node = this.manager.useableNode;
         if (!node) {
             throw new Error("No available nodes.");
         }
-        if (!player.isAutoplay) {
-            return [];
-        }
-        if (attempt >= player.autoplayTries) {
-            return [];
-        }
-        if (!player.queue.previous.length) {
-            return [];
-        }
         const apiKey = this.manager.options.lastFmApiKey;
         const enabledSources = node.info.sourceManagers;
-        const { autoPlaySearchPlatform } = this.manager.options;
-        const supportedPlatforms = ["spotify", "deezer", "soundcloud", "youtube"];
-        const platformMapping = {
-            [Manager_1.SearchPlatform.AppleMusic]: "applemusic",
-            [Manager_1.SearchPlatform.Bandcamp]: "bandcamp",
-            [Manager_1.SearchPlatform.Deezer]: "deezer",
-            [Manager_1.SearchPlatform.Jiosaavn]: "jiosaavn",
-            [Manager_1.SearchPlatform.SoundCloud]: "soundcloud",
-            [Manager_1.SearchPlatform.Spotify]: "spotify",
-            [Manager_1.SearchPlatform.Tidal]: "tidal",
-            [Manager_1.SearchPlatform.VKMusic]: "vkmusic",
-            [Manager_1.SearchPlatform.YouTube]: "youtube",
-            [Manager_1.SearchPlatform.YouTubeMusic]: "youtube",
-        };
-        const mappedPlatform = platformMapping[autoPlaySearchPlatform];
-        // Last attempt fallback to YouTube
-        if (attempt === player.autoplayTries - 1 && player.autoplayTries > 1 && enabledSources.includes("youtube")) {
-            return await this.getRecommendedTracksFromYouTube(track);
-        }
-        // Check if the preferred autoplay platform is supported and enabled
-        if (mappedPlatform && supportedPlatforms.includes(mappedPlatform) && enabledSources.includes(mappedPlatform)) {
-            return await this.getRecommendedTracksFromSource(track, mappedPlatform);
+        const autoPlaySearchPlatforms = this.manager.options.autoPlaySearchPlatforms;
+        // Iterate over autoplay platforms in order of priority
+        for (const platform of autoPlaySearchPlatforms) {
+            if (enabledSources.includes(platform)) {
+                const recommendedTracks = await this.getRecommendedTracksFromSource(track, platform);
+                // If tracks are found, return them immediately
+                if (recommendedTracks.length > 0) {
+                    return recommendedTracks;
+                }
+            }
         }
         // Check if Last.fm API is available
         if (apiKey) {
             return await this.getRecommendedTracksFromLastFm(track, apiKey);
         }
-        // Fallback to YouTube if all else fails
-        if (enabledSources.includes("youtube")) {
-            return await this.getRecommendedTracksFromYouTube(track);
-        }
         return [];
     }
+    /**
+     * Gets recommended tracks from Last.fm for the given track.
+     * @param track The track to get recommended tracks for.
+     * @param apiKey The API key for Last.fm.
+     * @returns An array of recommended tracks.
+     */
     static async getRecommendedTracksFromLastFm(track, apiKey) {
-        const enabledSources = this.manager.useableNode.info.sourceManagers;
-        const selectedSource = this.selectPlatform(enabledSources);
         let { author: artist } = track;
         const { title } = track;
         if (!artist || !title) {
@@ -206,8 +191,8 @@ class AutoPlayUtils {
                     return [];
                 }
                 const randomTrack = response.data.toptracks.track[Math.floor(Math.random() * response.data.toptracks.track.length)];
-                const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, track.requester);
-                if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
+                if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
                     return [];
                 }
                 const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
@@ -233,7 +218,7 @@ class AutoPlayUtils {
             response = await axios_1.default.get(url);
         }
         catch (error) {
-            console.log(error);
+            console.error("[AutoPlay] Error fetching similar tracks from Last.fm:", error);
             return [];
         }
         if (response.data.error || !response.data.similartracks?.track?.length) {
@@ -244,8 +229,8 @@ class AutoPlayUtils {
                 return [];
             }
             const randomTrack = retryResponse.data.toptracks.track[Math.floor(Math.random() * retryResponse.data.toptracks.track.length)];
-            const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, track.requester);
-            if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+            const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
+            if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
                 return [];
             }
             const filteredTracks = res.tracks.filter((t) => t.uri !== track.uri);
@@ -258,27 +243,127 @@ class AutoPlayUtils {
         if (!randomTrack) {
             return [];
         }
-        const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, track.requester);
-        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+        const res = await this.manager.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: this.manager.options.defaultSearchPlatform }, track.requester);
+        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
             return [];
         }
-        if (res.loadType === LoadTypes.Playlist)
+        if (res.loadType === Enums_1.LoadTypes.Playlist)
             res.tracks = res.playlist.tracks;
         if (!res.tracks.length) {
             return [];
         }
         return res.tracks;
     }
-    static async getRecommendedTracksFromSource(track, mappedPlatform) {
-        switch (mappedPlatform) {
+    /**
+     * Gets recommended tracks from the given source.
+     * @param track The track to get recommended tracks for.
+     * @param platform The source to get recommended tracks from.
+     * @returns An array of recommended tracks.
+     */
+    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);
-                        if (res.loadType === LoadTypes.Empty || res.loadType === LoadTypes.Error) {
+                {
+                    try {
+                        if (!track.uri.includes("spotify")) {
+                            const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Spotify }, track.requester);
+                            if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                                return [];
+                            }
+                            if (res.loadType === Enums_1.LoadTypes.Playlist) {
+                                res.tracks = res.playlist.tracks;
+                            }
+                            if (!res.tracks.length) {
+                                return [];
+                            }
+                            track = res.tracks[0];
+                        }
+                        const periodMs = 30000;
+                        async function getSpotifyTotpParams() {
+                            try {
+                                const secretBuffer = await AutoPlayUtils.fetchSecretArray();
+                                const transformedSecret = AutoPlayUtils.transformSecret(secretBuffer);
+                                const totp = AutoPlayUtils.generateTotp(transformedSecret);
+                                const timestamp = Math.floor(Date.now() / periodMs) * periodMs;
+                                const params = {
+                                    reason: "transport",
+                                    productType: "embed",
+                                    totp,
+                                    totpVer: 5,
+                                    ts: timestamp,
+                                };
+                                return params;
+                            }
+                            catch (error) {
+                                console.error("Failed to generate Spotify TOTP params:", error);
+                                throw error;
+                            }
+                        }
+                        let body;
+                        try {
+                            const params = await getSpotifyTotpParams();
+                            const response = await axios_1.default.get("https://open.spotify.com/get_access_token", {
+                                params,
+                                headers: {
+                                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.6998.178 Spotify/1.2.65.255 Safari/537.36",
+                                    "App-Platform": "WebPlayer",
+                                    Referer: "https://open.spotify.com/",
+                                    Origin: "https://open.spotify.com",
+                                    "Accept-Language": "en",
+                                    "Content-Type": "application/json",
+                                },
+                            });
+                            body = response.data;
+                        }
+                        catch (error) {
+                            console.error("[AutoPlay] Failed to get spotify access token:", error.response?.status);
                             return [];
                         }
-                        if (res.loadType === LoadTypes.Playlist) {
+                        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);
+                            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: Enums_1.SearchPlatform.Spotify }, track.requester);
+                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        return res.tracks;
+                    }
+                    catch (error) {
+                        console.error("[AutoPlay] Unexpected spotify error:", error.message || error);
+                        return [];
+                    }
+                }
+                break;
+            case "deezer":
+                {
+                    if (!track.uri.includes("deezer")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Deezer }, track.requester);
+                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
                             res.tracks = res.playlist.tracks;
                         }
                         if (!res.tracks.length) {
@@ -286,253 +371,353 @@ class AutoPlayUtils {
                         }
                         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;
+                    const identifier = `dzrec:${track.identifier}`;
+                    const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    if (!recommendedResult) {
+                        return [];
                     }
-                    catch (error) {
-                        console.error("[AutoPlay] Failed to get access token:", error.response?.status, error.response?.data || error.message);
+                    let tracks = [];
+                    let playlist = null;
+                    const requester = track.requester;
+                    switch (recommendedResult.loadType) {
+                        case Enums_1.LoadTypes.Search:
+                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
+                            break;
+                        case Enums_1.LoadTypes.Track:
+                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
+                            break;
+                        case Enums_1.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 === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
+                        return [];
+                    }
+                    if (result.loadType === Enums_1.LoadTypes.Playlist) {
+                        result.tracks = result.playlist.tracks;
+                    }
+                    if (!result.tracks.length) {
                         return [];
                     }
-                    let json;
+                    return result.tracks;
+                }
+                break;
+            case "soundcloud":
+                {
+                    if (!track.uri.includes("soundcloud")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.SoundCloud }, track.requester);
+                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
+                    }
                     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",
-                            },
+                        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;
                         });
-                        json = response.data;
+                        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: Enums_1.SearchPlatform.SoundCloud }, track.requester);
+                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        return res.tracks;
                     }
                     catch (error) {
-                        console.error("[AutoPlay] Failed to fetch recommendations:", error.response?.status, error.response?.data || error.message);
+                        console.error("[AutoPlay] Error occurred while fetching soundcloud recommendations:", error);
                         return [];
                     }
-                    if (!json.tracks || !json.tracks.length) {
+                }
+                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: Enums_1.SearchPlatform.YouTube }, track.requester);
+                        videoID = searchResult.tracks[0]?.uri.split("=").pop();
+                    }
+                    if (!videoID) {
                         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) {
+                    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: Enums_1.SearchPlatform.YouTube }, track.requester);
+                    if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.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: Enums_1.SearchPlatform.Tidal }, track.requester);
+                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === Enums_1.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 [];
                     }
-                    return res.tracks;
-                }
-                catch (error) {
-                    console.error("[AutoPlay] Unexpected error:", error.message || error);
-                    return [];
-                }
-            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) {
+                    let tracks = [];
+                    let playlist = null;
+                    const requester = track.requester;
+                    switch (recommendedResult.loadType) {
+                        case Enums_1.LoadTypes.Search:
+                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
+                            break;
+                        case Enums_1.LoadTypes.Track:
+                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
+                            break;
+                        case Enums_1.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 === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
                         return [];
                     }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
+                    if (result.loadType === Enums_1.LoadTypes.Playlist) {
+                        result.tracks = result.playlist.tracks;
                     }
-                    if (!res.tracks.length) {
+                    if (!result.tracks.length) {
                         return [];
                     }
-                    track = res.tracks[0];
+                    return result.tracks;
                 }
-                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;
+                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: Enums_1.SearchPlatform.VKMusic }, track.requester);
+                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
                     }
-                }
-                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;
-            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) {
+                    const identifier = `vkrec:${track.identifier}`;
+                    const recommendedResult = (await this.manager.useableNode.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
+                    if (!recommendedResult) {
                         return [];
                     }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
+                    let tracks = [];
+                    let playlist = null;
+                    const requester = track.requester;
+                    switch (recommendedResult.loadType) {
+                        case Enums_1.LoadTypes.Search:
+                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
+                            break;
+                        case Enums_1.LoadTypes.Track:
+                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
+                            break;
+                        case Enums_1.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;
+                        }
                     }
-                    if (!res.tracks.length) {
+                    const result = { loadType: recommendedResult.loadType, tracks, playlist };
+                    if (result.loadType === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
                         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) {
-                        return [];
+                    if (result.loadType === Enums_1.LoadTypes.Playlist) {
+                        result.tracks = result.playlist.tracks;
                     }
-                    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.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 "qobuz":
+                {
+                    if (!track.uri.includes("qobuz.com")) {
+                        const res = await this.manager.search({ query: `${track.author} - ${track.title}`, source: Enums_1.SearchPlatform.Qobuz }, track.requester);
+                        if (res.loadType === Enums_1.LoadTypes.Empty || res.loadType === Enums_1.LoadTypes.Error) {
+                            return [];
+                        }
+                        if (res.loadType === Enums_1.LoadTypes.Playlist) {
+                            res.tracks = res.playlist.tracks;
+                        }
+                        if (!res.tracks.length) {
+                            return [];
+                        }
+                        track = res.tracks[0];
+                    }
+                    const identifier = `qbrec:${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 Enums_1.LoadTypes.Search:
+                            tracks = recommendedResult.data.map((track) => TrackUtils.build(track, requester));
+                            break;
+                        case Enums_1.LoadTypes.Track:
+                            tracks = [TrackUtils.build(recommendedResult.data, requester)];
+                            break;
+                        case Enums_1.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 === Enums_1.LoadTypes.Empty || result.loadType === Enums_1.LoadTypes.Error) {
                         return [];
                     }
-                    if (res.loadType === LoadTypes.Playlist) {
-                        res.tracks = res.playlist.tracks;
+                    if (result.loadType === Enums_1.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 recommendations:", error);
-                    return [];
+                    return result.tracks;
                 }
-            case "youtube":
-                return this.getRecommendedTracksFromYouTube(track);
+                break;
             default:
                 return [];
         }
     }
-    static async getRecommendedTracksFromYouTube(track) {
-        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;
+    static async fetchSecretArray() {
+        // Step 1: Get Spotify homepage HTML
+        const homepageRes = await axios_1.default.get("https://open.spotify.com/");
+        const $ = cheerio_1.default.load(homepageRes.data);
+        // Step 2: Find script URL with "mobile-web-player" but not "vendor"
+        const scriptUrl = $("script[src]")
+            .map((_, el) => $(el).attr("src"))
+            .get()
+            .find((src) => src.includes("mobile-web-player") && !src.includes("vendor"));
+        if (!scriptUrl)
+            throw new Error("Secret script not found");
+        // Full URL fix (if needed)
+        const fullScriptUrl = scriptUrl.startsWith("http") ? scriptUrl : "https://open.spotify.com" + scriptUrl;
+        // Step 3: Fetch the script content
+        const scriptRes = await axios_1.default.get(fullScriptUrl);
+        const scriptContent = scriptRes.data;
+        // Step 4: Extract secret array using regex
+        const secretPattern = /\(\[(\d+(?:,\d+)+)]\)/;
+        const match = secretPattern.exec(scriptContent);
+        if (!match)
+            throw new Error("Secret array not found in script");
+        // Parse the secret array into bytes
+        const secretArray = match[1].split(",").map((n) => parseInt(n.trim(), 10));
+        return Buffer.from(secretArray);
     }
-    static selectPlatform(enabledSources) {
-        const { autoPlaySearchPlatform } = this.manager.options;
-        const platformMapping = {
-            [Manager_1.SearchPlatform.AppleMusic]: "applemusic",
-            [Manager_1.SearchPlatform.Bandcamp]: "bandcamp",
-            [Manager_1.SearchPlatform.Deezer]: "deezer",
-            [Manager_1.SearchPlatform.Jiosaavn]: "jiosaavn",
-            [Manager_1.SearchPlatform.SoundCloud]: "soundcloud",
-            [Manager_1.SearchPlatform.Spotify]: "spotify",
-            [Manager_1.SearchPlatform.Tidal]: "tidal",
-            [Manager_1.SearchPlatform.VKMusic]: "vkmusic",
-            [Manager_1.SearchPlatform.YouTube]: "youtube",
-            [Manager_1.SearchPlatform.YouTubeMusic]: "youtube",
-        };
-        // Try the autoPlaySearchPlatform first
-        if (enabledSources.includes(platformMapping[autoPlaySearchPlatform])) {
-            return autoPlaySearchPlatform;
+    static transformSecret(buffer) {
+        const transformed = Buffer.alloc(buffer.length);
+        for (let i = 0; i < buffer.length; i++) {
+            transformed[i] = buffer[i] ^ ((i % 33) + 9);
         }
-        // Fallback to other platforms in a predefined order
-        const fallbackPlatforms = [
-            Manager_1.SearchPlatform.Spotify,
-            Manager_1.SearchPlatform.Deezer,
-            Manager_1.SearchPlatform.SoundCloud,
-            Manager_1.SearchPlatform.AppleMusic,
-            Manager_1.SearchPlatform.Bandcamp,
-            Manager_1.SearchPlatform.Jiosaavn,
-            Manager_1.SearchPlatform.Tidal,
-            Manager_1.SearchPlatform.VKMusic,
-            Manager_1.SearchPlatform.YouTubeMusic,
-            Manager_1.SearchPlatform.YouTube,
-        ];
-        for (const platform of fallbackPlatforms) {
-            if (enabledSources.includes(platformMapping[platform])) {
-                return platform;
-            }
-        }
-        return null;
+        return transformed;
+    }
+    static generateTotp(secretBuffer) {
+        const period = 30; // seconds
+        const digits = 6;
+        const counter = Math.floor(Date.now() / 1000 / period);
+        const counterBuffer = Buffer.alloc(8);
+        counterBuffer.writeBigInt64BE(BigInt(counter));
+        const hmac = crypto_1.default.createHmac("sha1", secretBuffer);
+        hmac.update(counterBuffer);
+        const hmacResult = hmac.digest();
+        const offset = hmacResult[hmacResult.length - 1] & 0x0f;
+        const binary = ((hmacResult[offset] & 0x7f) << 24) | ((hmacResult[offset + 1] & 0xff) << 16) | ((hmacResult[offset + 2] & 0xff) << 8) | (hmacResult[offset + 3] & 0xff);
+        const otp = binary % 10 ** digits;
+        return otp.toString().padStart(digits, "0");
     }
 }
 exports.AutoPlayUtils = AutoPlayUtils;
@@ -572,45 +757,3 @@ const structures = {
     Rest: require("./Rest").Rest,
     Utils: require("./Utils"),
 };
-var LoadTypes;
-(function (LoadTypes) {
-    LoadTypes["Track"] = "track";
-    LoadTypes["Playlist"] = "playlist";
-    LoadTypes["Search"] = "search";
-    LoadTypes["Empty"] = "empty";
-    LoadTypes["Error"] = "error";
-})(LoadTypes || (exports.LoadTypes = LoadTypes = {}));
-var StateTypes;
-(function (StateTypes) {
-    StateTypes["Connected"] = "CONNECTED";
-    StateTypes["Connecting"] = "CONNECTING";
-    StateTypes["Disconnected"] = "DISCONNECTED";
-    StateTypes["Disconnecting"] = "DISCONNECTING";
-    StateTypes["Destroying"] = "DESTROYING";
-})(StateTypes || (exports.StateTypes = StateTypes = {}));
-var TrackEndReasonTypes;
-(function (TrackEndReasonTypes) {
-    TrackEndReasonTypes["Finished"] = "finished";
-    TrackEndReasonTypes["LoadFailed"] = "loadFailed";
-    TrackEndReasonTypes["Stopped"] = "stopped";
-    TrackEndReasonTypes["Replaced"] = "replaced";
-    TrackEndReasonTypes["Cleanup"] = "cleanup";
-})(TrackEndReasonTypes || (exports.TrackEndReasonTypes = TrackEndReasonTypes = {}));
-var SeverityTypes;
-(function (SeverityTypes) {
-    SeverityTypes["Common"] = "common";
-    SeverityTypes["Suspicious"] = "suspicious";
-    SeverityTypes["Fault"] = "fault";
-})(SeverityTypes || (exports.SeverityTypes = SeverityTypes = {}));
-var TrackSourceTypes;
-(function (TrackSourceTypes) {
-    TrackSourceTypes["AppleMusic"] = "applemusic";
-    TrackSourceTypes["Bandcamp"] = "bandcamp";
-    TrackSourceTypes["Deezer"] = "deezer";
-    TrackSourceTypes["Jiosaavn"] = "jiosaavn";
-    TrackSourceTypes["SoundCloud"] = "soundcloud";
-    TrackSourceTypes["Spotify"] = "spotify";
-    TrackSourceTypes["Tidal"] = "tidal";
-    TrackSourceTypes["VKMusic"] = "vkmusic";
-    TrackSourceTypes["YouTube"] = "youtube";
-})(TrackSourceTypes || (exports.TrackSourceTypes = TrackSourceTypes = {}));