@khang07/zing-mp3-api 1.1.0 → 1.3.4

package/dist/cjs/index.cjs

@@ -5,11 +5,22 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var axios = require('axios');
 var m3u8stream = require('m3u8stream');
 var node_stream = require('node:stream');
+var node_url = require('node:url');
 var cookies = require('./utils/cookies.cjs');
 var encrypt = require('./utils/encrypt.cjs');
 var lapse = require('./utils/lapse.cjs');
+var refined = require('./utils/refined.cjs');
 
-class ZingClient {
+const isURL = (value) => {
+    try {
+        new node_url.URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+class Client {
     static BASE_URL = 'https://zingmp3.vn/';
     static VERSION_URL_V1 = '1.6.34';
     static VERSION_URL_V2 = '1.13.13';
@@ -17,35 +28,47 @@ class ZingClient {
     static SECRET_KEY_V2 = '10a01dcf33762d3a204cb96429918ff6';
     static API_KEY_V1 = '88265e23d4284f25963e6eedac8fbfa3';
     static API_KEY_V2 = '38e8643fb0dc04e8d65b99994d3dafff';
+    static API_VIDEO_PATH = '/api/v2/page/get/video';
+    static API_MUSIC_PATH = '/api/v2/song/get/streaming';
+    static EXTRA_API_MUSIC_PATH = '/api/song/get-song-info';
+    static API_SEARCH_PATH = '/api/v2/search';
+    static API_PLAYLIST_PATH = '/api/v2/page/get/playlist';
+    static API_MEDIA_DETAILS_PATH = '/api/v2/song/get/info';
+    static API_ARTIST_PATH = '/api/v2/page/get/artist';
+    static getIDFromURL(url) {
+        if (typeof url !== 'string' || !url.trim().length)
+            throw new lapse.Lapse('URL must be a non-empty string', 'ERROR_INVALID_URL');
+        const match = url.match(/\/([A-Z0-9]{8})\.html(?:\?|#|$)/i) || url.match(/^https?:\/\/zingmp3\.vn\/([^/?#]+)\/?(?:[?#].*)?$/i);
+        if (!match)
+            throw new lapse.Lapse('Could not extract ID from URL', 'ERROR_INVALID_URL');
+        return match[1];
+    }
     ctime = Math.floor(Date.now() / 1000).toString();
-    jar;
     instance;
-    maxRate;
+    maxLoad;
+    maxHighWaterMark;
+    userAgent;
+    jar;
     constructor(options = {}) {
-        this.maxRate = [
-            options?.maxRate?.[0] ?? 100 * 1024,
-            options?.maxRate?.[1] ?? 16 * 1024
-        ];
-        this.jar = new cookies.Cookies();
-        const axiosOptions = {
-            baseURL: ZingClient.BASE_URL,
+        this.maxLoad = options.maxLoad ?? 1024 * 1024;
+        this.maxHighWaterMark = options.maxHighWaterMark ?? 16 * 1024;
+        this.userAgent = options?.userAgent ?? 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3';
+        this.jar = options.jar instanceof cookies.Cookies ? options.jar : new cookies.Cookies();
+        this.instance = axios.create({
+            baseURL: Client.BASE_URL,
             params: {
-                version: ZingClient.VERSION_URL_V1,
-                apiKey: ZingClient.API_KEY_V1,
+                version: Client.VERSION_URL_V1,
+                apiKey: Client.API_KEY_V1,
                 ctime: this.ctime
             },
-            maxRate: [
-                100 * 1024,
-                this.maxRate[0]
-            ],
+            maxRate: this.maxLoad,
             headers: {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
+                'User-Agent': this.userAgent
             }
-        };
-        this.instance = axios.create(axiosOptions);
-        this.instance.interceptors.request.use((options) => {
+        });
+        this.instance.interceptors.request.use(async (options) => {
             const base = options.baseURL ?? '';
-            const url = new URL(options.url ?? '/', base).toString();
+            const url = new node_url.URL(options.url ?? '/', base).toString();
             const additionalHeaders = this.jar.applyToHeaders(url);
             for (const [key, value] of Object.entries(additionalHeaders))
                 options.headers.set(key, value);
@@ -56,34 +79,37 @@ class ZingClient {
             const requestUrl = response.request?.res?.responseUrl ?? response.config.url;
             if (requestUrl && Array.isArray(setCookie))
                 this.jar.setCookies(setCookie, requestUrl);
-            return response;
+            return response.data;
         });
     }
+    async ensureCookies() {
+        if (this.jar.getCookies(Client.BASE_URL).length === 0)
+            void await this.instance.get('/');
+    }
     async video(videoID) {
-        if (typeof videoID !== 'string' || !videoID.length)
+        const value = videoID instanceof node_url.URL ? videoID.toString() : videoID;
+        if (typeof value !== 'string' || !value.trim().length)
             throw new lapse.Lapse('ID must be a non-empty string', 'ERROR_INVALID_ID');
-        const uri = '/api/v2/page/get/video';
         try {
-            if (this.jar.getCookies(ZingClient.BASE_URL).length === 0)
-                void await this.instance.get('/');
-            const response = await this.instance.get(uri, {
+            videoID = isURL(value) ? Client.getIDFromURL(value) : value;
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_VIDEO_PATH, {
                 params: {
                     id: videoID,
-                    sig: encrypt.createSignature(uri, 'ctime=' + this.ctime + 'id=' + videoID + 'version=' + ZingClient.VERSION_URL_V1, ZingClient.SECRET_KEY_V1)
+                    sig: encrypt.createSignature(Client.API_VIDEO_PATH, 'ctime=' + this.ctime + 'id=' + videoID + 'version=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
                 }
             });
-            const body = response.data;
-            if (body.err !== 0)
-                throw new lapse.Lapse('Video could not be found', 'ERROR_VIDEO_NOT_FOUND', response.status, body);
-            const videoURL = body.data?.streaming?.hls?.['360p'];
+            if (response.err !== 0)
+                throw new lapse.Lapse('Video could not be found', 'ERROR_VIDEO_NOT_FOUND', response.err, response);
+            const videoURL = response.data?.streaming?.hls?.['720p'] || response.data?.streaming?.hls?.['360p'];
             if (!videoURL || !videoURL.length)
                 throw new lapse.Lapse('Streaming URL not found', 'ERROR_STREAM_URL_NOT_FOUND');
-            const streamVideo = m3u8stream(videoURL);
-            streamVideo.once('error', (error) => {
+            const source = m3u8stream(videoURL);
+            source.once('error', (error) => {
                 const lapse$1 = new lapse.Lapse('Stream download failed', 'ERROR_STREAM_DOWNLOAD', void 0, error);
-                streamVideo.destroy(lapse$1);
+                source.destroy(lapse$1);
             });
-            return streamVideo;
+            return source;
         }
         catch (error) {
             if (error instanceof lapse.Lapse)
@@ -91,78 +117,87 @@ class ZingClient {
             throw new lapse.Lapse('Failed to fetch video stream', 'ERROR_VIDEO_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
         }
     }
-    videoSyncLike(videoID) {
-        const video = new node_stream.PassThrough({ highWaterMark: this.maxRate[1] });
+    videoSync(videoID) {
+        const video = new node_stream.PassThrough({ highWaterMark: this.maxHighWaterMark });
+        let copySource;
+        let closed = false;
+        let sourceDestroyed = false;
+        const destroy = () => {
+            if (!copySource || sourceDestroyed)
+                return;
+            sourceDestroyed = true;
+            if (!copySource)
+                return;
+            copySource.unpipe(video);
+            if (!copySource.destroyed)
+                copySource.destroy();
+        };
+        const closer = () => {
+            closed = true;
+            destroy();
+        };
+        video.once('close', closer);
+        video.once('error', closer);
         void this.video(videoID)
             .then((source) => {
+            copySource = source;
             source.once('error', (error) => {
                 const lapse$1 = error instanceof lapse.Lapse ? error : new lapse.Lapse('Stream download failed', 'ERROR_STREAM_DOWNLOAD', void 0, error);
                 video.destroy(lapse$1);
             });
-            const destroy = () => {
-                if (!source.destroyed)
-                    source.destroy();
-            };
-            video.once('close', destroy);
-            video.once('error', destroy);
+            if (closed || video.destroyed) {
+                destroy();
+                return;
+            }
             source.pipe(video);
         })
             .catch((error) => {
-            if (error instanceof lapse.Lapse)
-                throw error;
-            throw new lapse.Lapse('Failed to fetch video stream', 'ERROR_VIDEO_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+            const lapse$1 = error instanceof lapse.Lapse ? error : new lapse.Lapse('Failed to fetch video stream', 'ERROR_VIDEO_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+            video.destroy(lapse$1);
         });
         return video;
     }
     async music(musicID) {
-        if (typeof musicID !== 'string' || !musicID.trim().length)
+        const value = musicID instanceof node_url.URL ? musicID.toString() : musicID;
+        if (typeof value !== 'string' || !value.trim().length)
             throw new lapse.Lapse('ID must be a non-empty string', 'ERROR_INVALID_ID');
-        let musicURL;
-        const uri = '/api/v2/song/get/streaming';
         try {
-            if (this.jar.getCookies(ZingClient.BASE_URL).length === 0)
-                void await this.instance.get('/');
-            const response = await this.instance.get(uri, {
+            musicID = isURL(value) ? Client.getIDFromURL(value) : value;
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_MUSIC_PATH, {
                 params: {
                     id: musicID,
-                    sig: encrypt.createSignature(uri, 'ctime=' + this.ctime + 'id=' + musicID + 'version=' + ZingClient.VERSION_URL_V1, ZingClient.SECRET_KEY_V1)
+                    sig: encrypt.createSignature(Client.API_MUSIC_PATH, 'ctime=' + this.ctime + 'id=' + musicID + 'version=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
                 }
             });
-            const body = response.data;
-            if (body.err === -1150) {
-                let retrySuccess = false;
-                const uri_v2 = '/api/song/get-song-info';
-                for (let step = 0; step < 2; step++) {
-                    const retry = await this.instance.get(uri_v2, {
+            let musicURL = response.data?.[320] && response.data[320] !== 'VIP' ? response.data[320] : response.data?.[128];
+            if (response.err === -1150) {
+                const retry = async (step, before) => {
+                    if (step > 3)
+                        throw new lapse.Lapse('Music requested by VIP, PRI', 'ERROR_MUSIC_VIP_ONLY', before ? before.err : void 0, before);
+                    const retryData = await this.instance.get(Client.EXTRA_API_MUSIC_PATH, {
                         params: {
                             id: musicID,
-                            api_key: ZingClient.API_KEY_V2,
-                            sig: encrypt.createSignature('/song/get-song-info', 'ctime=' + this.ctime + 'id=' + musicID, ZingClient.SECRET_KEY_V2),
+                            api_key: Client.API_KEY_V2,
+                            sig: encrypt.createSignature('/song/get-song-info', 'ctime=' + this.ctime + 'id=' + musicID, Client.SECRET_KEY_V2),
                             version: void 0,
                             apiKey: void 0
                         }
                     });
-                    if (retry.data.err === 0) {
-                        retrySuccess = true;
-                        musicURL = retry.data.data?.streaming?.default?.[128];
-                        break;
-                    }
-                }
-                if (!retrySuccess)
-                    throw new lapse.Lapse('Music requested by VIP, PRI', 'ERROR_MUSIC_VIP_ONLY', response.status, body);
+                    if (retryData.err === 0)
+                        return retryData.data?.streaming?.default?.[128];
+                    return retry(step + 1, retryData);
+                };
+                musicURL = await retry(0);
             }
-            else if (body.err === 0)
-                musicURL = body.data?.[128];
-            else
-                throw new lapse.Lapse('This song could not be found', 'ERROR_MUSIC_NOT_FOUND', response.status, body);
             if (!musicURL || !musicURL.length)
                 throw new lapse.Lapse('Streaming URL not found', 'ERROR_STREAM_URL_NOT_FOUND');
-            const streamMusic = await this.instance.get(musicURL, { responseType: 'stream' });
-            streamMusic.data.once('error', (error) => {
-                const lapse$1 = new lapse.Lapse('Stream download failed', 'ERROR_STREAM_DOWNLOAD', streamMusic.status, error);
-                streamMusic.data.destroy(lapse$1);
+            const source = await this.instance.get(musicURL, { responseType: 'stream' });
+            source.once('error', (error) => {
+                const lapse$1 = new lapse.Lapse('Stream download failed', 'ERROR_STREAM_DOWNLOAD', void 0, error);
+                source.destroy(lapse$1);
             });
-            return streamMusic.data;
+            return source;
         }
         catch (error) {
             if (error instanceof lapse.Lapse)
@@ -170,84 +205,217 @@ class ZingClient {
             throw new lapse.Lapse('Failed to fetch music stream', 'ERROR_MUSIC_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
         }
     }
-    musicSyncLike(musicID) {
-        const music = new node_stream.PassThrough({ highWaterMark: this.maxRate[1] });
+    musicSync(musicID) {
+        const music = new node_stream.PassThrough({ highWaterMark: this.maxHighWaterMark });
+        let copySource;
+        let closed = false;
+        let sourceDestroyed = false;
+        const destroy = () => {
+            if (!copySource || sourceDestroyed)
+                return;
+            sourceDestroyed = true;
+            copySource.unpipe(music);
+            if (!copySource.destroyed)
+                copySource.destroy();
+        };
+        const closer = () => {
+            closed = true;
+            destroy();
+        };
+        music.once('close', closer);
+        music.once('error', closer);
         void this.music(musicID)
             .then((source) => {
+            copySource = source;
             source.once('error', (error) => {
                 const lapse$1 = error instanceof lapse.Lapse ? error : new lapse.Lapse('Stream download failed', 'ERROR_STREAM_DOWNLOAD', void 0, error);
                 music.destroy(lapse$1);
             });
-            const destroy = () => {
-                if (!source.destroyed)
-                    source.destroy();
-            };
-            music.once('close', destroy);
-            music.once('error', destroy);
+            if (closed || music.destroyed) {
+                destroy();
+                return;
+            }
             source.pipe(music);
         })
             .catch((error) => {
-            if (error instanceof lapse.Lapse)
-                throw error;
-            throw new lapse.Lapse('Failed to fetch music stream', 'ERROR_MUSIC_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+            const lapse$1 = error instanceof lapse.Lapse ? error : new lapse.Lapse('Failed to fetch music stream', 'ERROR_MUSIC_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+            music.destroy(lapse$1);
         });
         return music;
     }
-    async search(keyword) {
-        if (typeof keyword !== 'string' || !keyword.trim().length)
-            throw new lapse.Lapse('Keyword must be a non-empty string', 'ERROR_INVALID_KEYWORD');
-        const uri = '/api/v2/search/multi';
+    async playlist(playlistID) {
+        const value = playlistID instanceof node_url.URL ? playlistID.toString() : playlistID;
+        if (typeof value !== 'string' || !value.trim().length)
+            throw new lapse.Lapse('ID must be a non-empty string', 'ERROR_INVALID_ID');
+        try {
+            playlistID = isURL(value) ? Client.getIDFromURL(value) : value;
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_PLAYLIST_PATH, {
+                params: {
+                    id: playlistID,
+                    sig: encrypt.createSignature(Client.API_PLAYLIST_PATH, 'ctime=' + this.ctime + 'id=' + playlistID + 'version=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
+                }
+            });
+            if (response.err !== 0)
+                throw new lapse.Lapse('Could not find playlist', 'ERROR_PLAYLIST_NOT_FOUND', response.err, response);
+            return refined.createPlayList(response.data);
+        }
+        catch (error) {
+            if (error instanceof lapse.Lapse)
+                throw error;
+            throw new lapse.Lapse('Failed to fetch playlist', 'ERROR_PLAYLIST_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+        }
+    }
+    async artist(aliasID) {
+        const value = aliasID instanceof node_url.URL ? aliasID.toString() : aliasID;
+        if (typeof value !== 'string' || !value.trim().length)
+            throw new lapse.Lapse('ID must be a non-empty string', 'ERROR_INVALID_ID');
         try {
-            if (this.jar.getCookies(ZingClient.BASE_URL).length === 0)
-                void await this.instance.get('/');
-            const response = await this.instance.get(uri, {
+            aliasID = isURL(value) ? Client.getIDFromURL(value) : value;
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_ARTIST_PATH, {
                 params: {
-                    q: keyword,
-                    sig: encrypt.createSignature(uri, 'ctime=' + this.ctime + 'version=' + ZingClient.VERSION_URL_V1, ZingClient.SECRET_KEY_V1)
+                    alias: aliasID,
+                    sig: encrypt.createSignature(Client.API_ARTIST_PATH, 'ctime=' + this.ctime + 'version=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
                 }
             });
-            const body = response.data;
-            if (body.err !== 0)
-                throw new lapse.Lapse('Could not perform search', 'ERROR_SEARCH_FAILED', response.status, body);
-            const songs = body.data?.songs ?? [];
-            return songs.map((song) => ({
-                id: song.encodeId,
-                name: song.title,
-                alias: song.alias,
-                isOffical: song.isOffical,
-                username: song.username,
-                artists: song.artists.map((artist) => ({
-                    id: artist.id,
-                    name: artist.name,
-                    alias: artist.alias,
-                    thumbnail: {
-                        w240: artist.thumbnailM,
-                        w360: artist.thumbnail
-                    }
-                })),
-                thumbnail: {
-                    w94: song.thumbnailM,
-                    w240: song.thumbnail
-                },
-                duration: song.duration,
-                releaseDate: song.releaseDate
-            }));
+            if (response.err === -108)
+                throw new lapse.Lapse('Artist not found', 'ERROR_ARTIST_NOT_FOUND', response.err, response);
+            if (response.err !== 0)
+                throw new lapse.Lapse('Could not fetch artist', 'ERROR_ARTIST_FETCH', response.err, response);
+            return refined.createArtist(response.data);
         }
         catch (error) {
             if (error instanceof lapse.Lapse)
                 throw error;
-            throw new lapse.Lapse('Failed to perform search', 'ERROR_SEARCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+            throw new lapse.Lapse('Failed to fetch artist', 'ERROR_ARTIST_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+        }
+    }
+    async mediaDetails(mediaID) {
+        const value = mediaID instanceof node_url.URL ? mediaID.toString() : mediaID;
+        if (typeof value !== 'string' || !value.trim().length)
+            throw new lapse.Lapse('ID must be a non-empty string', 'ERROR_INVALID_ID');
+        try {
+            mediaID = isURL(value) ? Client.getIDFromURL(value) : value;
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_MEDIA_DETAILS_PATH, {
+                params: {
+                    id: mediaID,
+                    sig: encrypt.createSignature(Client.API_MEDIA_DETAILS_PATH, 'ctime=' + this.ctime + 'id=' + mediaID + 'version=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
+                }
+            });
+            if (response.err === -1023)
+                throw new lapse.Lapse('Media not found', 'ERROR_MEDIA_NOT_FOUND', response.err, response);
+            if (response.err !== 0)
+                throw new lapse.Lapse('Could not fetch media', 'ERROR_MEDIA_FETCH', response.err, response);
+            return refined.createMedia(response.data);
+        }
+        catch (error) {
+            if (error instanceof lapse.Lapse)
+                throw error;
+            throw new lapse.Lapse('Failed to fetch media', 'ERROR_MEDIA_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+        }
+    }
+    async searchMusic(query) {
+        if (typeof query !== 'string' || !query.trim().length)
+            throw new lapse.Lapse('Query must be a non-empty string', 'ERROR_INVALID_QUERY');
+        try {
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_SEARCH_PATH, {
+                params: {
+                    q: query,
+                    type: 'song',
+                    page: 1,
+                    count: 20,
+                    sig: encrypt.createSignature(Client.API_SEARCH_PATH, 'count=20ctime=' + this.ctime + 'page=1type=songversion=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
+                }
+            });
+            if (response.err !== 0)
+                throw new lapse.Lapse('Search could not be fetched', 'ERROR_SEARCH_FAILED', response.err, response);
+            return response.data.items.map(refined.createSearchMedia);
+        }
+        catch (error) {
+            if (error instanceof lapse.Lapse)
+                throw error;
+            throw new lapse.Lapse('Search could not be fetch', 'ERROR_SEARCH_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+        }
+    }
+    async searchVideo(query) {
+        if (typeof query !== 'string' || !query.trim().length)
+            throw new lapse.Lapse('Query must be a non-empty string', 'ERROR_INVALID_QUERY');
+        try {
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_SEARCH_PATH, {
+                params: {
+                    q: query,
+                    type: 'video',
+                    page: 1,
+                    count: 20,
+                    sig: encrypt.createSignature(Client.API_SEARCH_PATH, 'count=20ctime=' + this.ctime + 'page=1type=videoversion=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
+                }
+            });
+            if (response.err !== 0)
+                throw new lapse.Lapse('Search could not be fetched', 'ERROR_SEARCH_FAILED', response.err, response);
+            return response.data.items.filter(item => item.artists).map(refined.createSearchMedia);
+        }
+        catch (error) {
+            if (error instanceof lapse.Lapse)
+                throw error;
+            throw new lapse.Lapse('Search could not be fetch', 'ERROR_SEARCH_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+        }
+    }
+    async searchList(query) {
+        if (typeof query !== 'string' || !query.trim().length)
+            throw new lapse.Lapse('Query must be a non-empty string', 'ERROR_INVALID_QUERY');
+        try {
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_SEARCH_PATH, {
+                params: {
+                    q: query,
+                    type: 'playlist',
+                    page: 1,
+                    count: 20,
+                    sig: encrypt.createSignature(Client.API_SEARCH_PATH, 'count=20ctime=' + this.ctime + 'page=1type=playlistversion=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
+                }
+            });
+            if (response.err !== 0)
+                throw new lapse.Lapse('Search could not be fetched', 'ERROR_SEARCH_FAILED', response.err, response);
+            return response.data.items.map(refined.createSearchPlayList);
+        }
+        catch (error) {
+            if (error instanceof lapse.Lapse)
+                throw error;
+            throw new lapse.Lapse('Search could not be fetch', 'ERROR_SEARCH_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
+        }
+    }
+    async searchArtist(query) {
+        if (typeof query !== 'string' || !query.trim().length)
+            throw new lapse.Lapse('Query must be a non-empty string', 'ERROR_INVALID_QUERY');
+        try {
+            void await this.ensureCookies();
+            const response = await this.instance.get(Client.API_SEARCH_PATH, {
+                params: {
+                    q: query,
+                    type: 'artist',
+                    page: 1,
+                    count: 20,
+                    sig: encrypt.createSignature(Client.API_SEARCH_PATH, 'count=20ctime=' + this.ctime + 'page=1type=artistversion=' + Client.VERSION_URL_V1, Client.SECRET_KEY_V1)
+                }
+            });
+            if (response.err !== 0)
+                throw new lapse.Lapse('Search could not be fetched', 'ERROR_SEARCH_FAILED', response.err, response);
+            return response.data.items.map(refined.createSearchArtist);
+        }
+        catch (error) {
+            if (error instanceof lapse.Lapse)
+                throw error;
+            throw new lapse.Lapse('Search could not be fetch', 'ERROR_SEARCH_FETCH', axios.isAxiosError(error) ? error.response?.status : void 0, error);
         }
     }
 }
-const clientOptions = {
-    maxRate: [
-        100 * 1024,
-        16 * 1024
-    ]
-};
-const client = new ZingClient(clientOptions);
+const client = new Client();
+client.searchMusic('skyfall');
 
-exports.ZingClient = ZingClient;
+exports.Client = Client;
 exports.default = client;
 //# sourceMappingURL=index.cjs.map