inki-music-api 2.0.0

package/dist/lx-project-api.js

@@ -0,0 +1,1146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LxProjectApi = void 0;
+const zlib_1 = require("zlib");
+const TX_SEARCH_HEADERS = { 'User-Agent': 'QQMusic 14090508(android 12)' };
+const KG_HEADERS = {
+    'KG-RC': 1,
+    'KG-THash': 'expand_search_manager.cpp:852736169:451',
+    'User-Agent': 'KuGou2012-9020-ExpandSearchManager',
+};
+const KW_RANK_MAP = { hot: '16', new: '17', rise: '93' };
+const KG_RANK_MAP = { top500: '8888', hot: '23784', rise: '6666' };
+const TX_RANK_MAP = { hot: '26', new: '27', rise: '62' };
+const WY_RANK_MAP = { hot: '3778678', new: '3779629', rise: '19723756' };
+const MG_RANK_MAP = { hot: '27186466', new: '27553319', rise: '75959118' };
+const decodeHtmlMap = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&#39;': "'" };
+const encKey = Buffer.from([
+    0x40, 0x47, 0x61, 0x77, 0x5e, 0x32, 0x74, 0x47, 0x51, 0x36, 0x31, 0x2d, 0xce, 0xd2, 0x6e, 0x69,
+]);
+const asRecord = (value) => value && typeof value === 'object' ? value : {};
+const asArray = (value) => (Array.isArray(value) ? value.map(asRecord) : []);
+const asString = (value) => (typeof value === 'string' ? value : value == null ? '' : String(value));
+const asNumber = (value) => {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+};
+const decodeName = (str = '') => String(str).replace(/&(amp|lt|gt|quot|#39);/g, (m) => decodeHtmlMap[m] || m);
+const formatPlayTime = (time) => `${String(Math.trunc(Math.max(0, time) / 60)).padStart(2, '0')}:${String(Math.trunc(Math.max(0, time) % 60)).padStart(2, '0')}`;
+const sizeFormate = (size) => {
+    if (!size)
+        return null;
+    const mb = size / (1024 * 1024);
+    return mb < 1 ? `${(size / 1024).toFixed(2)}KB` : `${mb.toFixed(2)}MB`;
+};
+const formatSingerName = (list, key = 'name') => asArray(list)
+    .map((item) => asString(item[key]))
+    .filter(Boolean)
+    .join('、');
+const emptyLyric = () => ({ lyric: '', tlyric: '', rlyric: '', lxlyric: '' });
+const baseMusicInfo = (source) => ({
+    songmid: '',
+    source,
+    name: '',
+    singer: '',
+    albumName: '',
+    interval: '00:00',
+    img: null,
+    types: [],
+    _types: {},
+    typeUrl: {},
+});
+const formatDate = (time) => {
+    const d = new Date(time);
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    return `${y}-${m}-${day} ${hh}:${mm}:${ss}`;
+};
+const createComment = (item) => ({
+    id: item.id || '',
+    text: item.text || '',
+    time: item.time || 0,
+    timeStr: item.timeStr || '',
+    userName: item.userName || '',
+    avatar: item.avatar || '',
+    userId: item.userId || '',
+    likedCount: item.likedCount || 0,
+});
+const txHotTagReg = {
+    row: /class="c_bg_link js_tag_item" data-id="\w+">.+?<\/a>/g,
+    tag: /data-id="(\w+)">(.+?)<\/a>/,
+};
+const formatPlayCountText = (num) => {
+    if (num > 100000000)
+        return `${Math.trunc(num / 1000000) / 100}亿`;
+    if (num > 10000)
+        return `${Math.trunc(num / 100) / 100}万`;
+    return String(num);
+};
+const createSongListItem = (item) => ({
+    id: item.id || '',
+    name: item.name || '',
+    author: item.author || '',
+    img: item.img || '',
+    desc: item.desc || '',
+    play_count: item.play_count || '0',
+    total: item.total,
+    time: item.time,
+    source: item.source || '',
+});
+const createSongListDetailInfo = (info) => ({
+    name: info.name || '',
+    img: info.img || '',
+    desc: info.desc || '',
+    author: info.author || '',
+    play_count: info.play_count || '0',
+});
+const parseSongListId = (rawId, reg) => {
+    if (!/[?&:/]/.test(rawId))
+        return rawId;
+    const matched = reg.exec(rawId);
+    if (!matched)
+        return rawId;
+    return matched[1];
+};
+const mapKwTypes = (nMinfo) => {
+    const types = [];
+    const _types = {};
+    const reg = /level:(\w+),bitrate:(\d+),format:(\w+),size:([\w.]+)/g;
+    let matched;
+    while ((matched = reg.exec(nMinfo))) {
+        const size = String(matched[4]).toUpperCase();
+        if (matched[2] === '4000') {
+            types.push({ type: 'flac24bit', size });
+            _types.flac24bit = { size };
+        }
+        else if (matched[2] === '2000') {
+            types.push({ type: 'flac', size });
+            _types.flac = { size };
+        }
+        else if (matched[2] === '320') {
+            types.push({ type: '320k', size });
+            _types['320k'] = { size };
+        }
+        else if (matched[2] === '128') {
+            types.push({ type: '128k', size });
+            _types['128k'] = { size };
+        }
+    }
+    return { types: types.reverse(), _types };
+};
+const mapKgTypes = (item) => {
+    const types = [];
+    const _types = {};
+    const add = (key, type, sizeKey, hashKey) => {
+        const size = sizeFormate(asNumber(item[sizeKey]));
+        const hash = asString(item[hashKey]);
+        if (!size || !hash)
+            return;
+        types.push({ type, size, hash });
+        _types[key] = { size, hash };
+    };
+    add('128k', '128k', 'FileSize', 'FileHash');
+    add('320k', '320k', 'HQFileSize', 'HQFileHash');
+    add('flac', 'flac', 'SQFileSize', 'SQFileHash');
+    add('flac24bit', 'flac24bit', 'ResFileSize', 'ResFileHash');
+    if (!types.length) {
+        add('128k', '128k', 'filesize', 'hash');
+        add('320k', '320k', '320filesize', '320hash');
+        add('flac', 'flac', 'sqfilesize', 'sqhash');
+        add('flac24bit', 'flac24bit', 'filesize_high', 'hash_high');
+    }
+    return { types, _types };
+};
+const mapTxTypes = (file) => {
+    const types = [];
+    const _types = {};
+    const add = (key, type, sizeKey) => {
+        const size = sizeFormate(asNumber(file[sizeKey]));
+        if (!size)
+            return;
+        types.push({ type, size });
+        _types[key] = { size };
+    };
+    add('128k', '128k', 'size_128mp3');
+    add('320k', '320k', 'size_320mp3');
+    add('flac', 'flac', 'size_flac');
+    add('flac24bit', 'flac24bit', 'size_hires');
+    return { types, _types };
+};
+const parseKrc = (base64) => new Promise((resolve, reject) => {
+    const buf = Buffer.from(base64, 'base64').subarray(4);
+    for (let i = 0; i < buf.length; i++)
+        buf[i] = buf[i] ^ encKey[i % 16];
+    (0, zlib_1.inflate)(buf, (err, result) => {
+        if (err)
+            return reject(err);
+        resolve({
+            lyric: result
+                .toString()
+                .replace(/\r/g, '')
+                .replace(/<\d+,\d+>/g, ''),
+            tlyric: '',
+            rlyric: '',
+            lxlyric: '',
+        });
+    });
+});
+class LxProjectApi {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    async http(url, options = {}) {
+        return this.httpClient.requestPromise(url, options);
+    }
+    async search(source, keywords, page = 1, limit = 20) {
+        if (source === 'kw') {
+            const response = asRecord((await this.http(`http://search.kuwo.cn/r.s?client=kt&all=${encodeURIComponent(keywords)}&pn=${page - 1}&rn=${limit}&uid=794762570&ver=kwplayer_ar_9.2.2.1&vipver=1&show_copyright_off=1&newver=1&ft=music&cluster=0&strategy=2012&encoding=utf8&rformat=json&vermerge=1&mobi=1&issubtitle=1`)).body);
+            const list = asArray(response.abslist).map((item) => {
+                const mapped = mapKwTypes(asString(item.N_MINFO));
+                return {
+                    ...baseMusicInfo('kw'),
+                    singer: decodeName(asString(item.ARTIST)),
+                    name: decodeName(asString(item.SONGNAME)),
+                    albumName: decodeName(asString(item.ALBUM)),
+                    albumId: decodeName(asString(item.ALBUMID)),
+                    interval: formatPlayTime(asNumber(item.DURATION)),
+                    songmid: asString(item.MUSICRID).replace('MUSIC_', ''),
+                    lrc: null,
+                    ...mapped,
+                };
+            });
+            return {
+                list,
+                allPage: Math.ceil(asNumber(response.TOTAL) / limit),
+                total: asNumber(response.TOTAL),
+                limit,
+                source,
+            };
+        }
+        if (source === 'kg') {
+            const response = asRecord((await this.http(`https://songsearch.kugou.com/song_search_v2?keyword=${encodeURIComponent(keywords)}&page=${page}&pagesize=${limit}&userid=0&clientver=&platform=WebFilter&filter=2&iscorrection=1&privilege_filter=0&area_code=1`)).body);
+            const data = asRecord(response.data);
+            const list = asArray(data.lists).map((item) => {
+                const mapped = mapKgTypes(item);
+                return {
+                    ...baseMusicInfo('kg'),
+                    singer: decodeName(formatSingerName(item.Singers)),
+                    name: decodeName(asString(item.SongName)),
+                    albumName: decodeName(asString(item.AlbumName)),
+                    albumId: asString(item.AlbumID),
+                    interval: formatPlayTime(asNumber(item.Duration)),
+                    songmid: asString(item.Audioid),
+                    _interval: asNumber(item.Duration),
+                    hash: asString(item.FileHash),
+                    lrc: null,
+                    ...mapped,
+                };
+            });
+            return { list, allPage: Math.ceil(asNumber(data.total) / limit), total: asNumber(data.total), limit, source };
+        }
+        if (source === 'tx') {
+            const response = asRecord((await this.http('https://u.y.qq.com/cgi-bin/musicu.fcg', {
+                method: 'post',
+                headers: TX_SEARCH_HEADERS,
+                body: {
+                    comm: { ct: '11', cv: '14090508', tmeAppID: 'qqmusic' },
+                    req: {
+                        module: 'music.search.SearchCgiService',
+                        method: 'DoSearchForQQMusicMobile',
+                        param: {
+                            search_type: 0,
+                            query: keywords,
+                            page_num: page,
+                            num_per_page: limit,
+                            highlight: 0,
+                            nqc_flag: 0,
+                            multi_zhida: 0,
+                            cat: 2,
+                            grp: 1,
+                            sin: 0,
+                            sem: 0,
+                        },
+                    },
+                },
+            })).body);
+            const req = asRecord(response.req);
+            const data = asRecord(req.data);
+            const body = asRecord(data.body);
+            const meta = asRecord(data.meta);
+            const list = asArray(body.item_song).map((item) => {
+                const file = asRecord(item.file);
+                const album = asRecord(item.album);
+                const mapped = mapTxTypes(file);
+                const albumId = asString(album.mid);
+                return {
+                    ...baseMusicInfo('tx'),
+                    singer: formatSingerName(item.singer),
+                    name: `${asString(item.name)}${asString(item.title_extra)}`,
+                    albumName: asString(album.name),
+                    albumId,
+                    interval: formatPlayTime(asNumber(item.interval)),
+                    songId: asNumber(item.id),
+                    albumMid: albumId,
+                    strMediaMid: asString(file.media_mid),
+                    songmid: asString(item.mid),
+                    img: albumId ? `https://y.gtimg.cn/music/photo_new/T002R500x500M000${albumId}.jpg` : '',
+                    ...mapped,
+                };
+            });
+            return {
+                list,
+                allPage: Math.ceil(asNumber(meta.estimate_sum) / limit),
+                total: asNumber(meta.estimate_sum),
+                limit,
+                source,
+            };
+        }
+        if (source === 'wy') {
+            const offset = (page - 1) * limit;
+            const response = asRecord((await this.http(`https://music.163.com/api/search/get/web?csrf_token=&s=${encodeURIComponent(keywords)}&type=1&offset=${offset}&limit=${limit}`)).body);
+            const result = asRecord(response.result);
+            const list = asArray(result.songs).map((item) => {
+                const album = asRecord(item.album);
+                return {
+                    ...baseMusicInfo('wy'),
+                    singer: formatSingerName(item.artists),
+                    name: asString(item.name),
+                    albumName: asString(album.name),
+                    albumId: asString(album.id),
+                    interval: formatPlayTime(asNumber(item.duration) / 1000),
+                    songmid: asString(item.id),
+                    img: asString(album.picUrl),
+                    lrc: null,
+                    types: [{ type: '128k', size: null }],
+                    _types: { '128k': { size: null } },
+                };
+            });
+            return {
+                list,
+                allPage: Math.ceil(asNumber(result.songCount) / limit),
+                total: asNumber(result.songCount),
+                limit,
+                source,
+            };
+        }
+        if (source === 'mg') {
+            const response = asRecord((await this.http(`http://jadeite.migu.cn:7090/music_search/v3/search/searchAll?isCorrect=0&isCopyright=1&searchSwitch=%7B%22song%22%3A1%2C%22album%22%3A0%2C%22singer%22%3A0%2C%22tagSong%22%3A1%2C%22mvSong%22%3A0%2C%22bestShow%22%3A1%2C%22songlist%22%3A0%2C%22lyricSong%22%3A0%7D&pageSize=${limit}&text=${encodeURIComponent(keywords)}&pageNo=${page}&sort=0&sid=USS`)).body);
+            const result = asRecord(response.songResultData);
+            const list = [];
+            for (const part of asArray(result.resultList)) {
+                for (const item of asArray(part)) {
+                    const songmid = asString(item.songId);
+                    const copyrightId = asString(item.copyrightId);
+                    if (!songmid || !copyrightId)
+                        continue;
+                    list.push({
+                        ...baseMusicInfo('mg'),
+                        singer: formatSingerName(item.singerList),
+                        name: asString(item.name),
+                        albumName: asString(item.album),
+                        albumId: asString(item.albumId),
+                        songmid,
+                        copyrightId,
+                        interval: formatPlayTime(asNumber(item.duration)),
+                        img: asString(item.img3) || asString(item.img2) || asString(item.img1) || null,
+                        lrcUrl: asString(item.lrcUrl),
+                        mrcUrl: asString(item.mrcurl),
+                        trcUrl: asString(item.trcUrl),
+                        types: [{ type: '128k', size: null }],
+                        _types: { '128k': { size: null } },
+                    });
+                }
+            }
+            return {
+                list,
+                allPage: Math.ceil(asNumber(result.totalCount) / limit),
+                total: asNumber(result.totalCount),
+                limit,
+                source,
+            };
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+    async hot(source, page = 1, limit = 20) {
+        return this.rank(source, 'hot', page, limit);
+    }
+    async rank(source, rankType, page = 1, limit = 20) {
+        if (source === 'kw') {
+            const id = KW_RANK_MAP[rankType] || String(rankType || KW_RANK_MAP.hot);
+            const body = asRecord((await this.http(`http://kbangserver.kuwo.cn/ksong.s?from=pc&fmt=json&pn=${page - 1}&rn=${limit}&type=bang&data=content&id=${id}&show_copyright_off=0&pcmp4=1&isbang=1`)).body);
+            const list = asArray(body.musiclist).map((item, idx) => ({
+                ...baseMusicInfo('kw'),
+                rank: (page - 1) * limit + idx + 1,
+                singer: decodeName(asString(item.artist) || asString(item.ARTIST)),
+                name: decodeName(asString(item.name) || asString(item.SONGNAME)),
+                albumName: decodeName(asString(item.album) || asString(item.ALBUM)),
+                albumId: asString(item.albumid) || asString(item.ALBUMID),
+                songmid: asString(item.id) || asString(item.MUSICRID).replace('MUSIC_', ''),
+                interval: formatPlayTime(asNumber(item.duration) || asNumber(item.DURATION)),
+                img: asString(item.pic) || null,
+                ...mapKwTypes(asString(item.n_minfo) || asString(item.N_MINFO)),
+            }));
+            return { rankType: id, total: asNumber(body.num) || list.length, list, page, limit, source };
+        }
+        if (source === 'kg') {
+            const id = KG_RANK_MAP[rankType] || String(rankType || KG_RANK_MAP.hot);
+            const body = asRecord((await this.http(`http://mobilecdnbj.kugou.com/api/v3/rank/song?version=9108&ranktype=1&plat=0&pagesize=${limit}&area_code=1&page=${page}&rankid=${id}&with_res_tag=0&show_portrait_mv=1`)).body);
+            const data = asRecord(body.data);
+            const list = asArray(data.info).map((item, idx) => ({
+                ...baseMusicInfo('kg'),
+                rank: (page - 1) * limit + idx + 1,
+                singer: formatSingerName(item.authors, 'author_name'),
+                name: decodeName(asString(item.songname)),
+                albumName: decodeName(asString(item.remark)),
+                albumId: asString(item.album_id),
+                songmid: asString(item.audio_id),
+                interval: formatPlayTime(asNumber(item.duration)),
+                hash: asString(item.hash),
+                ...mapKgTypes(item),
+            }));
+            return { rankType: id, total: asNumber(data.total) || list.length, list, page, limit, source };
+        }
+        if (source === 'tx') {
+            const id = Number(TX_RANK_MAP[rankType] || rankType || TX_RANK_MAP.hot);
+            const body = asRecord((await this.http('https://u.y.qq.com/cgi-bin/musicu.fcg', {
+                method: 'post',
+                body: {
+                    toplist: {
+                        module: 'musicToplist.ToplistInfoServer',
+                        method: 'GetDetail',
+                        param: { topid: id, num: limit },
+                    },
+                    comm: { uin: 0, format: 'json', ct: 20, cv: 1859 },
+                },
+            })).body);
+            const rows = asArray(asRecord(asRecord(body.toplist).data).songInfoList);
+            const list = rows.map((item, idx) => {
+                const album = asRecord(item.album);
+                const file = asRecord(item.file);
+                const albumId = asString(album.mid);
+                return {
+                    ...baseMusicInfo('tx'),
+                    rank: (page - 1) * limit + idx + 1,
+                    singer: formatSingerName(item.singer),
+                    name: asString(item.title),
+                    albumName: asString(album.name),
+                    albumId,
+                    interval: formatPlayTime(asNumber(item.interval)),
+                    songId: asNumber(item.id),
+                    albumMid: albumId,
+                    strMediaMid: asString(file.media_mid),
+                    songmid: asString(item.mid),
+                    img: albumId ? `https://y.gtimg.cn/music/photo_new/T002R500x500M000${albumId}.jpg` : '',
+                    ...mapTxTypes(file),
+                };
+            });
+            return { rankType: String(id), total: list.length, list, page: 1, limit, source };
+        }
+        if (source === 'wy') {
+            const id = WY_RANK_MAP[rankType] || String(rankType || WY_RANK_MAP.hot);
+            const body = asRecord((await this.http(`https://music.163.com/api/playlist/detail?id=${id}`)).body);
+            const tracks = asArray(asRecord(body.result).tracks);
+            const list = tracks.map((item, idx) => {
+                const album = asRecord(item.album);
+                return {
+                    ...baseMusicInfo('wy'),
+                    rank: (page - 1) * limit + idx + 1,
+                    singer: formatSingerName(item.artists),
+                    name: asString(item.name),
+                    albumName: asString(album.name),
+                    albumId: asString(album.id),
+                    interval: formatPlayTime(asNumber(item.duration) / 1000),
+                    songmid: asString(item.id),
+                    img: asString(album.picUrl),
+                    types: [{ type: '128k', size: null }],
+                    _types: { '128k': { size: null } },
+                };
+            });
+            return { rankType: id, total: list.length, list, page: 1, limit, source };
+        }
+        if (source === 'mg') {
+            const id = MG_RANK_MAP[rankType] || String(rankType || MG_RANK_MAP.hot);
+            const body = asRecord((await this.http(`https://app.c.nf.migu.cn/MIGUM2.0/v1.0/content/querycontentbyId.do?columnId=${id}&needAll=0`))
+                .body);
+            const list = asArray(asRecord(body.columnInfo).contents)
+                .map((item) => asRecord(item.objectInfo))
+                .filter((item) => Object.keys(item).length)
+                .map((item, idx) => ({
+                ...baseMusicInfo('mg'),
+                rank: (page - 1) * limit + idx + 1,
+                singer: formatSingerName(item.singerList),
+                name: asString(item.songName) || asString(item.name),
+                albumName: asString(item.album),
+                albumId: asString(item.albumId),
+                songmid: asString(item.songId),
+                copyrightId: asString(item.copyrightId),
+                interval: formatPlayTime(asNumber(item.duration)),
+                img: asString(item.img3) || asString(item.img2) || asString(item.img1) || null,
+                lrcUrl: asString(item.lrcUrl),
+                mrcUrl: asString(item.mrcurl),
+                trcUrl: asString(item.trcUrl),
+                types: [{ type: '128k', size: null }],
+                _types: { '128k': { size: null } },
+            }));
+            return { rankType: id, total: list.length, list, page, limit, source };
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+    async lyric(source, musicInfo) {
+        if (source === 'kw') {
+            const body = asRecord((await this.http(`http://m.kuwo.cn/newh5/singles/songinfoandlrc?musicId=${musicInfo.songmid}`)).body);
+            const lyric = asArray(asRecord(body.data).lrclist)
+                .map((line) => `[${formatPlayTime(asNumber(line.time))}.${String(Math.trunc((asNumber(line.time) % 1) * 1000)).padStart(3, '0')}]${decodeName(asString(line.lineLyric))}`)
+                .join('\n');
+            return { ...emptyLyric(), lyric };
+        }
+        if (source === 'kg') {
+            const duration = musicInfo._interval ??
+                asNumber(musicInfo.interval.split(':')[0]) * 60 + asNumber(musicInfo.interval.split(':')[1]);
+            const search = asRecord((await this.http(`http://lyrics.kugou.com/search?ver=1&man=yes&client=pc&keyword=${encodeURIComponent(musicInfo.name)}&hash=${musicInfo.hash || ''}&timelength=${duration}&lrctxt=1`, { headers: KG_HEADERS })).body);
+            const cand = asRecord(asArray(search.candidates)[0]);
+            if (!Object.keys(cand).length)
+                return emptyLyric();
+            const down = asRecord((await this.http(`http://lyrics.kugou.com/download?ver=1&client=pc&id=${asString(cand.id)}&accesskey=${asString(cand.accesskey)}&fmt=${asNumber(cand.krctype) === 1 ? 'krc' : 'lrc'}&charset=utf8`, { headers: KG_HEADERS })).body);
+            if (asString(down.fmt) === 'krc')
+                return parseKrc(asString(down.content));
+            return { ...emptyLyric(), lyric: Buffer.from(asString(down.content), 'base64').toString('utf-8') };
+        }
+        if (source === 'tx') {
+            const body = asRecord((await this.http('https://u.y.qq.com/cgi-bin/musicu.fcg', {
+                method: 'post',
+                headers: { referer: 'https://y.qq.com' },
+                body: {
+                    comm: { ct: '19', cv: '1859', uin: '0' },
+                    req: {
+                        method: 'GetPlayLyricInfo',
+                        module: 'music.musichallSong.PlayLyricInfo',
+                        param: { format: 'json', crypt: 0, qrc: 0, roma: 0, trans: 1, songID: musicInfo.songId || 0 },
+                    },
+                },
+            })).body);
+            const data = asRecord(asRecord(body.req).data);
+            return { ...emptyLyric(), lyric: asString(data.lyric), tlyric: asString(data.trans) };
+        }
+        if (source === 'wy') {
+            const body = asRecord((await this.http(`https://music.163.com/api/song/lyric?id=${musicInfo.songmid}&lv=-1&tv=-1&rv=-1`)).body);
+            return {
+                ...emptyLyric(),
+                lyric: asString(asRecord(body.lrc).lyric),
+                tlyric: asString(asRecord(body.tlyric).lyric),
+                rlyric: asString(asRecord(body.romalrc).lyric),
+            };
+        }
+        if (source === 'mg') {
+            if (!musicInfo.lrcUrl)
+                return emptyLyric();
+            const lyricBody = (await this.http(musicInfo.lrcUrl)).body;
+            const tlyricBody = musicInfo.trcUrl ? (await this.http(musicInfo.trcUrl)).body : '';
+            return {
+                ...emptyLyric(),
+                lyric: typeof lyricBody === 'string' ? lyricBody : '',
+                tlyric: typeof tlyricBody === 'string' ? tlyricBody : '',
+            };
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+    async pic(source, musicInfo) {
+        if (source === 'kw') {
+            const body = (await this.http(`http://artistpicserver.kuwo.cn/pic.web?corp=kuwo&type=rid_pic&pictype=500&size=500&rid=${musicInfo.songmid}`)).body;
+            return typeof body === 'string' && /^http/.test(body) ? body : null;
+        }
+        if (source === 'kg') {
+            const body = asRecord((await this.http('http://media.store.kugou.com/v1/get_res_privilege', {
+                method: 'post',
+                headers: KG_HEADERS,
+                body: {
+                    appid: 1001,
+                    area_code: '1',
+                    behavior: 'play',
+                    clientver: '9020',
+                    need_hash_offset: 1,
+                    relate: 1,
+                    resource: [
+                        {
+                            album_audio_id: musicInfo.songmid,
+                            album_id: musicInfo.albumId,
+                            hash: musicInfo.hash,
+                            id: 0,
+                            name: `${musicInfo.singer} - ${musicInfo.name}.mp3`,
+                            type: 'audio',
+                        },
+                    ],
+                    token: '',
+                    userid: 2626431536,
+                    vip: 1,
+                },
+            })).body);
+            const info = asRecord(asRecord(asArray(body.data)[0]).info);
+            const image = asString(info.image);
+            const size = asString(asArray(info.imgsize)[0]);
+            return image ? (size ? image.replace('{size}', size) : image) : null;
+        }
+        if (source === 'tx')
+            return musicInfo.albumId ? `https://y.gtimg.cn/music/photo_new/T002R500x500M000${musicInfo.albumId}.jpg` : null;
+        if (source === 'wy') {
+            if (musicInfo.img)
+                return musicInfo.img;
+            const body = asRecord((await this.http(`https://music.163.com/api/song/detail/?id=${musicInfo.songmid}&ids=[${musicInfo.songmid}]`))
+                .body);
+            return asString(asRecord(asRecord(asArray(body.songs)[0]).album).picUrl) || null;
+        }
+        if (source === 'mg') {
+            if (musicInfo.img)
+                return musicInfo.img;
+            const body = asRecord((await this.http(`http://music.migu.cn/v3/api/music/audioPlayer/getSongPic?songId=${musicInfo.songmid}`, {
+                headers: { Referer: 'http://music.migu.cn/v3/music/player/audio?from=migu' },
+            })).body);
+            const url = asString(body.largePic) || asString(body.mediumPic) || asString(body.smallPic);
+            if (!url)
+                return null;
+            return /^https?:/.test(url) ? url : `http:${url}`;
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+    async comment(source, musicInfo, page = 1, limit = 20, hot = false) {
+        if (source === 'kw') {
+            const type = hot ? 'get_rec_comment' : 'get_comment';
+            const countKey = hot ? 'hot_comments_counts' : 'comments_counts';
+            const listKey = hot ? 'hot_comments' : 'comments';
+            const body = asRecord((await this.http(`http://ncomment.kuwo.cn/com.s?f=web&type=${type}&aapiver=1&prod=kwplayer_ar_10.5.2.0&digest=15&sid=${musicInfo.songmid}&start=${limit * (page - 1)}&msgflag=1&count=${limit}&newver=3&uid=0`, {
+                headers: { 'User-Agent': 'Dalvik/2.1.0 (Linux; U; Android 9;)' },
+            })).body);
+            const total = asNumber(body[countKey]);
+            const comments = asArray(body[listKey]).map((item) => {
+                const time = asNumber(item.time) * 1000;
+                return createComment({
+                    id: asString(item.id),
+                    text: asString(item.msg),
+                    time,
+                    timeStr: formatDate(time),
+                    userName: asString(item.u_name),
+                    avatar: asString(item.u_pic),
+                    userId: asString(item.u_id),
+                    likedCount: asNumber(item.like_num),
+                });
+            });
+            return { source, comments, total, page, limit, maxPage: Math.ceil(total / limit) || 1 };
+        }
+        if (source === 'kg') {
+            const hash = musicInfo.hash || '';
+            const timestamp = Date.now();
+            const path = hot ? 'topliked' : 'newest';
+            const params = `dfid=0&mid=16249512204336365674023395779019&clienttime=${timestamp}&uuid=0&extdata=${hash}&appid=1005&code=fc4be23b4e972707f36b8a828a93ba8a&schash=${hash}&clientver=11409&p=${page}&clienttoken=&pagesize=${limit}&ver=10&kugouid=0`;
+            const body = asRecord((await this.http(`http://m.comment.service.kugou.com/r/v1/rank/${path}?${params}`, {
+                headers: { 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64)' },
+            })).body);
+            const total = asNumber(body.count);
+            const comments = asArray(body.list).map((item) => {
+                const user = asRecord(item.user);
+                const time = asNumber(item.addtime) * 1000;
+                return createComment({
+                    id: asString(item.id),
+                    text: asString(item.content),
+                    time,
+                    timeStr: formatDate(time),
+                    userName: asString(user.name),
+                    avatar: asString(user.avatar),
+                    userId: asString(user.userid),
+                    likedCount: asNumber(item.like),
+                });
+            });
+            return { source, comments, total, page, limit, maxPage: Math.ceil(total / limit) || 1 };
+        }
+        if (source === 'tx') {
+            const cmd = hot ? '9' : '8';
+            const body = asRecord((await this.http('http://c.y.qq.com/base/fcgi-bin/fcg_global_comment_h5.fcg', {
+                method: 'POST',
+                headers: { 'User-Agent': 'Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)' },
+                form: {
+                    uin: '0',
+                    format: 'json',
+                    cid: '205360772',
+                    reqtype: '2',
+                    biztype: '1',
+                    topid: String(musicInfo.songId || musicInfo.songmid),
+                    cmd,
+                    needmusiccrit: '1',
+                    pagenum: page - 1,
+                    pagesize: limit,
+                },
+            })).body);
+            const comment = asRecord(body.comment);
+            const total = asNumber(comment.commenttotal);
+            const comments = asArray(comment.commentlist).map((item) => {
+                const user = asRecord(item.rootcommentuin ? item : asRecord(item.middlecommentcontent));
+                const time = asNumber(item.time) * 1000;
+                return createComment({
+                    id: asString(item.rootcommentid || item.commentid),
+                    text: asString(item.rootcommentcontent || item.rootcommentcontentdetail || item.middlecommentcontent),
+                    time,
+                    timeStr: formatDate(time),
+                    userName: asString(item.rootcommentnick || user.nick),
+                    avatar: asString(item.avatarurl || ''),
+                    userId: asString(item.rootcommentuin || ''),
+                    likedCount: asNumber(item.praisenum || 0),
+                });
+            });
+            return { source, comments, total, page, limit, maxPage: Math.ceil(total / limit) || 1 };
+        }
+        if (source === 'wy') {
+            const offset = (page - 1) * limit;
+            const body = asRecord((await this.http(`https://music.163.com/api/v1/resource/comments/R_SO_4_${musicInfo.songmid}?offset=${offset}&limit=${limit}`)).body);
+            const raw = hot ? asArray(body.hotComments) : asArray(body.comments);
+            const total = asNumber(body.total);
+            const comments = raw.map((item) => {
+                const user = asRecord(item.user);
+                const time = asNumber(item.time);
+                return createComment({
+                    id: asString(item.commentId),
+                    text: asString(item.content),
+                    time,
+                    timeStr: formatDate(time),
+                    userName: asString(user.nickname),
+                    avatar: asString(user.avatarUrl),
+                    userId: asString(user.userId),
+                    likedCount: asNumber(item.likedCount),
+                });
+            });
+            return { source, comments, total, page, limit, maxPage: Math.ceil(total / limit) || 1 };
+        }
+        if (source === 'mg') {
+            const queryType = hot ? 2 : 1;
+            const songId = musicInfo.songId || musicInfo.songmid;
+            const body = asRecord((await this.http(`https://app.c.nf.migu.cn/MIGUM3.0/user/comment/stack/v1.0?pageSize=${limit}&queryType=${queryType}&resourceId=${songId}&resourceType=2&hotCommentStart=${(page - 1) * limit}`, {
+                headers: { 'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)' },
+            })).body);
+            const data = asRecord(body.data);
+            const total = asNumber(hot ? data.cfgHotCount : data.commentNums);
+            const comments = asArray(hot ? data.hotComments : data.comments).map((item) => {
+                const user = asRecord(item.user);
+                const opNumItem = asRecord(item.opNumItem);
+                const time = asNumber(item.commentTime);
+                return createComment({
+                    id: asString(item.commentId),
+                    text: asString(item.commentInfo),
+                    time,
+                    timeStr: formatDate(time),
+                    userName: asString(user.nickName),
+                    avatar: asString(user.middleIcon || user.bigIcon || user.smallIcon),
+                    userId: asString(user.userId),
+                    likedCount: asNumber(opNumItem.thumbNum),
+                });
+            });
+            return { source, comments, total, page, limit, maxPage: Math.ceil(total / limit) || 1 };
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+    getMusicDetailPageUrl(source, musicInfo) {
+        if (source === 'kw')
+            return `http://www.kuwo.cn/play_detail/${musicInfo.songmid}`;
+        if (source === 'kg')
+            return `https://www.kugou.com/song/#hash=${musicInfo.hash || ''}&album_id=${musicInfo.albumId || ''}`;
+        if (source === 'tx')
+            return `https://y.qq.com/n/yqq/song/${musicInfo.songmid}.html`;
+        if (source === 'wy')
+            return `https://music.163.com/#/song?id=${musicInfo.songmid}`;
+        if (source === 'mg')
+            return `http://music.migu.cn/v3/music/song/${musicInfo.copyrightId || ''}`;
+        return null;
+    }
+    async songListTags(source) {
+        if (source === 'kw') {
+            const tagsBody = asRecord((await this.http('http://wapi.kuwo.cn/api/pc/classify/playlist/getTagList?cmd=rcm_keyword_playlist&user=0&prod=kwplayer_pc_9.0.5.0&vipver=9.0.5.0&source=kwplayer_pc_9.0.5.0&loginUid=0&loginSid=0&appUid=76039576')).body);
+            const hotBody = asRecord((await this.http('http://wapi.kuwo.cn/api/pc/classify/playlist/getRcmTagList?loginUid=0&loginSid=0&appUid=76039576')).body);
+            const tags = asArray(tagsBody.data).map((group) => ({
+                name: asString(group.name),
+                list: asArray(group.data).map((tag) => ({
+                    id: `${asString(tag.id)}-${asString(tag.digest)}`,
+                    name: asString(tag.name),
+                    parent_id: asString(group.id),
+                    parent_name: asString(group.name),
+                    source,
+                })),
+            }));
+            const hotTag = asArray(asRecord(asArray(hotBody.data)[0]).data).map((tag) => ({
+                id: `${asString(tag.id)}-${asString(tag.digest)}`,
+                name: asString(tag.name),
+                source,
+            }));
+            return { source, tags, hotTag };
+        }
+        if (source === 'tx') {
+            const tagsBody = asRecord((await this.http('https://u.y.qq.com/cgi-bin/musicu.fcg?loginUin=0&hostUin=0&format=json&inCharset=utf-8&outCharset=utf-8&notice=0&platform=wk_v15.json&needNewCode=0&data=%7B%22tags%22%3A%7B%22method%22%3A%22get_all_categories%22%2C%22param%22%3A%7B%22qq%22%3A%22%22%7D%2C%22module%22%3A%22playlist.PlaylistAllCategoriesServer%22%7D%7D')).body);
+            const hotHtml = (await this.http('https://c.y.qq.com/node/pc/wk_v15/category_playlist.html')).body;
+            const tags = asArray(asRecord(asRecord(tagsBody.tags).data).v_group).map((group) => ({
+                name: asString(group.group_name),
+                list: asArray(group.v_item).map((tag) => ({
+                    id: asString(tag.id),
+                    name: asString(tag.name),
+                    parent_id: asString(group.group_id),
+                    parent_name: asString(group.group_name),
+                    source,
+                })),
+            }));
+            const hotTag = typeof hotHtml === 'string'
+                ? (hotHtml.match(txHotTagReg.row) || [])
+                    .map((row) => {
+                    const matched = row.match(txHotTagReg.tag);
+                    if (!matched)
+                        return null;
+                    return { id: matched[1], name: matched[2], source };
+                })
+                    .filter((item) => item != null)
+                : [];
+            return { source, tags, hotTag };
+        }
+        if (source === 'wy') {
+            const body = asRecord((await this.http('https://music.163.com/api/playlist/catalogue')).body);
+            const all = asRecord(body.all);
+            const sub = asArray(body.sub);
+            const groups = Object.entries(all).map(([id, name]) => ({
+                name: asString(name),
+                list: sub
+                    .filter((tag) => asString(tag.category) === id)
+                    .map((tag) => ({
+                    id: asString(tag.name),
+                    name: asString(tag.name),
+                    parent_id: id,
+                    parent_name: asString(name),
+                    source,
+                })),
+            }));
+            const hotTag = asArray(body.hot).map((tag) => ({
+                id: asString(tag.name),
+                name: asString(tag.name),
+                source,
+            }));
+            return { source, tags: groups, hotTag };
+        }
+        if (source === 'kg') {
+            const body = asRecord((await this.http('http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_smarty=1&')).body);
+            const data = asRecord(body.data);
+            const tags = Object.keys(data).map((name) => {
+                const group = asRecord(data[name]);
+                return {
+                    name,
+                    list: asArray(group.data).map((tag) => ({
+                        id: asString(tag.id),
+                        name: asString(tag.name),
+                        parent_id: asString(tag.parent_id),
+                        parent_name: asString(tag.pname),
+                        source,
+                    })),
+                };
+            });
+            const hotTag = [];
+            return { source, tags, hotTag };
+        }
+        if (source === 'mg') {
+            const body = asRecord((await this.http('https://app.c.nf.migu.cn/pc/v1.0/template/musiclistplaza-taglist/release', {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)',
+                    Referer: 'https://m.music.migu.cn/',
+                },
+            })).body);
+            const contents = asArray(asRecord(body.data).contents);
+            const groups = contents.map((group) => ({
+                name: asString(group.title || group.columnTitle),
+                list: asArray(group.contents).map((tag) => {
+                    const info = asRecord(tag.objectInfo);
+                    return {
+                        id: asString(info.tagId || info.columnId),
+                        name: asString(info.tagName || info.columnTitle),
+                        source,
+                    };
+                }),
+            }));
+            const hotTag = groups[0]?.list || [];
+            return { source, tags: groups, hotTag };
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+    async songList(source, sortId = 'hot', tagId = '', page = 1, limit = 30) {
+        if (source === 'kw') {
+            const requestUrl = tagId
+                ? `http://wapi.kuwo.cn/api/pc/classify/playlist/getTagPlayList?loginUid=0&loginSid=0&appUid=76039576&pn=${page}&id=${asString(tagId).split('-')[0]}&rn=${limit}`
+                : `http://wapi.kuwo.cn/api/pc/classify/playlist/getRcmPlayList?loginUid=0&loginSid=0&appUid=76039576&&pn=${page}&rn=${limit}&order=${sortId}`;
+            const body = asRecord((await this.http(requestUrl)).body);
+            const data = asRecord(body.data);
+            const list = asArray(data.data).map((item) => createSongListItem({
+                id: `digest-${asString(item.digest)}__${asString(item.id)}`,
+                name: asString(item.name),
+                author: asString(item.uname),
+                img: asString(item.img),
+                desc: asString(item.desc),
+                total: asNumber(item.total),
+                play_count: formatPlayCountText(asNumber(item.listencnt)),
+                source,
+            }));
+            return {
+                source,
+                list,
+                total: asNumber(data.total),
+                page: asNumber(data.pn) || page,
+                limit: asNumber(data.rn) || limit,
+            };
+        }
+        if (source === 'tx') {
+            const url = tagId
+                ? `https://u.y.qq.com/cgi-bin/musicu.fcg?loginUin=0&hostUin=0&format=json&inCharset=utf-8&outCharset=utf-8&notice=0&platform=wk_v15.json&needNewCode=0&data=${encodeURIComponent(JSON.stringify({ comm: { cv: 1602, ct: 20 }, playlist: { method: 'get_category_content', param: { titleid: Number(tagId), caller: '0', category_id: Number(tagId), size: limit, page: page - 1, use_page: 1 }, module: 'playlist.PlayListCategoryServer' } }))}`
+                : `https://u.y.qq.com/cgi-bin/musicu.fcg?loginUin=0&hostUin=0&format=json&inCharset=utf-8&outCharset=utf-8&notice=0&platform=wk_v15.json&needNewCode=0&data=${encodeURIComponent(JSON.stringify({ comm: { cv: 1602, ct: 20 }, playlist: { method: 'get_playlist_by_tag', param: { id: 10000000, sin: limit * (page - 1), size: limit, order: Number(sortId) || 5, cur_page: page }, module: 'playlist.PlayListPlazaServer' } }))}`;
+            const body = asRecord((await this.http(url)).body);
+            const playlist = asRecord(body.playlist);
+            const data = asRecord(playlist.data);
+            if (tagId) {
+                const content = asRecord(data.content);
+                const list = asArray(content.v_item).map((item) => {
+                    const basic = asRecord(item.basic);
+                    const creator = asRecord(basic.creator);
+                    const cover = asRecord(basic.cover);
+                    return createSongListItem({
+                        id: asString(basic.tid),
+                        name: asString(basic.title),
+                        author: asString(creator.nick),
+                        img: asString(cover.medium_url || cover.default_url),
+                        desc: decodeName(asString(basic.desc)).replace(/<br>/g, '\n'),
+                        play_count: formatPlayCountText(asNumber(basic.play_cnt)),
+                        source,
+                    });
+                });
+                return { source, list, total: asNumber(content.total_cnt), page, limit };
+            }
+            const list = asArray(data.v_playlist).map((item) => {
+                const creator = asRecord(item.creator_info);
+                return createSongListItem({
+                    id: asString(item.tid),
+                    name: asString(item.title),
+                    author: asString(creator.nick),
+                    img: asString(item.cover_url_medium),
+                    desc: decodeName(asString(item.desc)).replace(/<br>/g, '\n'),
+                    total: asNumber(asArray(item.song_ids).length),
+                    play_count: formatPlayCountText(asNumber(item.access_num)),
+                    source,
+                });
+            });
+            return { source, list, total: asNumber(data.total), page, limit };
+        }
+        if (source === 'wy') {
+            const offset = (page - 1) * limit;
+            const url = `https://music.163.com/api/playlist/list?cat=${encodeURIComponent(tagId || '全部')}&order=${sortId || 'hot'}&offset=${offset}&total=true&limit=${limit}`;
+            const body = asRecord((await this.http(url)).body);
+            const list = asArray(body.playlists).map((item) => {
+                const creator = asRecord(item.creator);
+                return createSongListItem({
+                    id: asString(item.id),
+                    name: asString(item.name),
+                    author: asString(creator.nickname),
+                    img: asString(item.coverImgUrl),
+                    desc: asString(item.description),
+                    total: asNumber(item.trackCount),
+                    play_count: formatPlayCountText(asNumber(item.playCount)),
+                    source,
+                });
+            });
+            return { source, list, total: asNumber(body.total), page, limit };
+        }
+        if (source === 'kg') {
+            const body = asRecord((await this.http(`http://www2.kugou.kugou.com/yueku/v9/special/getSpecial?is_ajax=1&cdn=cdn&t=${sortId || '5'}&c=${tagId || ''}&p=${page}`)).body);
+            const list = asArray(body.special_db).map((item) => createSongListItem({
+                id: `id_${asString(item.specialid)}`,
+                name: asString(item.specialname),
+                author: asString(item.nickname),
+                img: asString(item.img || item.imgurl),
+                desc: asString(item.intro),
+                total: asNumber(item.songcount),
+                play_count: formatPlayCountText(asNumber(item.total_play_count || item.play_count)),
+                source,
+            }));
+            return { source, list, total: list.length, page, limit };
+        }
+        if (source === 'mg') {
+            const url = tagId
+                ? `https://app.c.nf.migu.cn/pc/v1.0/template/musiclistplaza-listbytag/release?pageNumber=${page}&templateVersion=2&tagId=${tagId}`
+                : `https://app.c.nf.migu.cn/pc/bmw/page-data/playlist-square-recommend/v1.0?templateVersion=2&pageNo=${page}`;
+            const body = asRecord((await this.http(url, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)',
+                    Referer: 'https://m.music.migu.cn/',
+                },
+            })).body);
+            const data = asRecord(body.data);
+            const list = asArray(data.contents).map((item) => createSongListItem({
+                id: asString(item.resId || item.contentId),
+                name: asString(item.txt || item.title),
+                author: '',
+                img: asString(item.img || item.imageUrl),
+                desc: asString(item.txt2 || ''),
+                play_count: formatPlayCountText(asNumber(asRecord(item.opNumItem).playNum)),
+                source,
+            }));
+            return { source, list, total: list.length, page, limit };
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+    async songListDetail(source, listId, page = 1, limit = 100) {
+        if (source === 'kw') {
+            const id = parseSongListId(listId, /^.+\/playlist(?:_detail)?\/(\d+)(?:\?.*|&.*$|#.*$|$)/);
+            const body = asRecord((await this.http(`http://nplserver.kuwo.cn/pl.svc?op=getlistinfo&pid=${id}&pn=${page - 1}&rn=${limit}&encode=utf8&keyset=pl2012&identity=kuwo&pcmp4=1&vipver=MUSIC_9.0.5.0_W1&newver=1`)).body);
+            const list = asArray(body.musiclist).map((item) => {
+                const mapped = mapKwTypes(asString(item.N_MINFO || item.n_minfo));
+                return {
+                    ...baseMusicInfo(source),
+                    singer: decodeName(asString(item.ARTIST || item.artist)),
+                    name: decodeName(asString(item.SONGNAME || item.name)),
+                    albumName: decodeName(asString(item.ALBUM || item.album)),
+                    albumId: asString(item.ALBUMID || item.albumid),
+                    interval: formatPlayTime(asNumber(item.DURATION || item.duration)),
+                    songmid: asString(item.MUSICRID || item.id).replace('MUSIC_', ''),
+                    img: asString(item.web_albumpic_short),
+                    ...mapped,
+                };
+            });
+            const info = createSongListDetailInfo({
+                name: asString(body.title),
+                img: asString(body.pic),
+                desc: asString(body.info),
+                author: asString(body.uname),
+                play_count: formatPlayCountText(asNumber(body.playnum)),
+            });
+            return { source, list, page, limit: asNumber(body.rn) || limit, total: asNumber(body.total), info };
+        }
+        if (source === 'tx') {
+            const id = parseSongListId(listId, /(?:\/playlist\/|id=)(\d+)/);
+            const body = asRecord((await this.http(`https://c.y.qq.com/qzone/fcg-bin/fcg_ucc_getcdinfo_byids_cp.fcg?type=1&json=1&utf8=1&onlysong=0&new_format=1&disstid=${id}&loginUin=0&hostUin=0&format=json&inCharset=utf8&outCharset=utf-8&notice=0&platform=yqq.json&needNewCode=0`, {
+                headers: { Origin: 'https://y.qq.com', Referer: `https://y.qq.com/n/yqq/playsquare/${id}.html` },
+            })).body);
+            const cdlist = asRecord(asArray(body.cdlist)[0]);
+            const songlist = asArray(cdlist.songlist);
+            const list = songlist.map((item) => {
+                const album = asRecord(item.album);
+                const file = asRecord(item.file);
+                const albumId = asString(album.mid);
+                return {
+                    ...baseMusicInfo(source),
+                    singer: formatSingerName(item.singer),
+                    name: asString(item.title),
+                    albumName: asString(album.name),
+                    albumId,
+                    interval: formatPlayTime(asNumber(item.interval)),
+                    songmid: asString(item.mid),
+                    songId: asNumber(item.id),
+                    img: albumId ? `https://y.gtimg.cn/music/photo_new/T002R500x500M000${albumId}.jpg` : '',
+                    ...mapTxTypes(file),
+                };
+            });
+            const info = createSongListDetailInfo({
+                name: asString(cdlist.dissname),
+                img: asString(cdlist.logo),
+                desc: decodeName(asString(cdlist.desc)).replace(/<br>/g, '\n'),
+                author: asString(cdlist.nickname),
+                play_count: formatPlayCountText(asNumber(cdlist.visitnum)),
+            });
+            return { source, list, page: 1, limit: songlist.length, total: songlist.length, info };
+        }
+        if (source === 'wy') {
+            const id = parseSongListId(listId, /(?:id=|\/playlist\/)(\d+)/);
+            const body = asRecord((await this.http(`https://music.163.com/api/v3/playlist/detail?id=${id}&n=100000&s=8`)).body);
+            const playlist = asRecord(body.playlist);
+            const tracks = asArray(playlist.tracks);
+            const list = tracks.map((item) => {
+                const album = asRecord(item.al);
+                return {
+                    ...baseMusicInfo(source),
+                    singer: formatSingerName(item.ar),
+                    name: asString(item.name),
+                    albumName: asString(album.name),
+                    albumId: asString(album.id),
+                    interval: formatPlayTime(asNumber(item.dt) / 1000),
+                    songmid: asString(item.id),
+                    img: asString(album.picUrl),
+                    types: [{ type: '128k', size: null }],
+                    _types: { '128k': { size: null } },
+                };
+            });
+            const info = createSongListDetailInfo({
+                name: asString(playlist.name),
+                img: asString(playlist.coverImgUrl),
+                desc: asString(playlist.description),
+                author: asString(asRecord(playlist.creator).nickname),
+                play_count: formatPlayCountText(asNumber(playlist.playCount)),
+            });
+            return { source, list, page, limit, total: asNumber(playlist.trackCount), info };
+        }
+        if (source === 'kg') {
+            const id = parseSongListId(listId.replace(/^id_/, ''), /^.+\/(\d+)\.html(?:\?.*|&.*$|#.*$|$)/);
+            const htmlBody = (await this.http(`http://www2.kugou.kugou.com/yueku/v9/special/single/${id}-5-9999.html`)).body;
+            if (typeof htmlBody !== 'string')
+                throw new Error('invalid kg song list detail response');
+            const match = htmlBody.match(/global\.data = (\[.+\]);/);
+            const listData = match ? JSON.parse(match[1]) : [];
+            const list = asArray(listData).map((item) => {
+                const mapped = mapKgTypes(item);
+                return {
+                    ...baseMusicInfo(source),
+                    singer: asString(item.singername),
+                    name: decodeName(asString(item.songname)),
+                    albumName: asString(item.album_name),
+                    albumId: asString(item.album_id),
+                    interval: formatPlayTime(asNumber(item.duration)),
+                    songmid: asString(item.audio_id),
+                    hash: asString(item.hash),
+                    ...mapped,
+                };
+            });
+            const info = createSongListDetailInfo({ name: '', img: '', desc: '', author: '', play_count: '0' });
+            return { source, list, page: 1, limit: list.length, total: list.length, info };
+        }
+        if (source === 'mg') {
+            const id = parseSongListId(listId, /(?:playlistId|id|\/playlist\/)(\d+)/);
+            const body = asRecord((await this.http(`https://app.c.nf.migu.cn/MIGUM3.0/resource/playlist/song/v2.0?pageNo=${page}&pageSize=${limit}&playlistId=${id}`, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)',
+                    Referer: 'https://m.music.migu.cn/',
+                },
+            })).body);
+            const data = asRecord(body.data);
+            const list = asArray(data.songList).map((item) => ({
+                ...baseMusicInfo(source),
+                singer: formatSingerName(item.singerList),
+                name: asString(item.songName || item.name),
+                albumName: asString(item.album),
+                albumId: asString(item.albumId),
+                interval: formatPlayTime(asNumber(item.duration)),
+                songmid: asString(item.songId),
+                copyrightId: asString(item.copyrightId),
+                img: asString(item.img3 || item.img2 || item.img1),
+                lrcUrl: asString(item.lrcUrl),
+                mrcUrl: asString(item.mrcurl),
+                trcUrl: asString(item.trcUrl),
+                types: [{ type: '128k', size: null }],
+                _types: { '128k': { size: null } },
+            }));
+            const detailBody = asRecord((await this.http(`https://c.musicapp.migu.cn/MIGUM3.0/resource/playlist/v2.0?playlistId=${id}`, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X)',
+                    Referer: 'https://m.music.migu.cn/',
+                },
+            })).body);
+            const detail = asRecord(detailBody.data);
+            const info = createSongListDetailInfo({
+                name: asString(detail.title),
+                img: asString(asRecord(detail.imgItem).img),
+                desc: asString(detail.summary),
+                author: asString(detail.ownerName),
+                play_count: formatPlayCountText(asNumber(asRecord(detail.opNumItem).playNum)),
+            });
+            return { source, list, page, limit, total: asNumber(data.totalCount), info };
+        }
+        throw new Error(`unsupported source: ${source}`);
+    }
+}
+exports.LxProjectApi = LxProjectApi;