Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥喜欢听音乐的梦@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[],\"params\":\"{\\\"cls\\\":\\\"elelist 日常书签组 开关\\\",\\\"id\\\":\\\"我的主页#音乐歌单\\\",\\\"longClick\\\":[{\\\"js\\\":\\\"(\\\\n(key, jUrl, index, isGroup) => {\\\\n    eval(fetch(jUrl));\\\\n    const Localfile = HikerHome.getLocalfile();\\\\n    const bookMark = HikerHome.getBookmarksList(Localfile.getItem(\\\\\\\"BookmarksList\\\\\\\"));\\\\n    if (isGroup) {\\\\n        var tem = bookMark.get_group(key, index);\\\\n        tem.status = !tem.status;\\\\n        bookMark.modify_group(key, tem, index);\\\\n    } else {\\\\n        var tem = bookMark.get(key);\\\\n        tem.status = !tem.status;\\\\n        bookMark.modify(key, tem);\\\\n    }\\\\n    refreshPage(false);\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n}\\\\n)(2,\\\\\\\"hiker://assets/home.js\\\\\\\",11,true)\\\",\\\"title\\\":\\\"关 闭\\\"},{\\\"js\\\":\\\"(\\\\n(key, jUrl, groupName) => {\\\\n    eval(fetch(jUrl));\\\\n    return $().x5cKey(\\\\\\\"modify@\\\\\\\" + key + \\\\\\\"@\\\\\\\" + (groupName || \\\\\\\"#\\\\\\\\u7a7a\\\\\\\\u767d\\\\\\\\u7ec4#\\\\\\\"));\\\\n}\\\\n)(2,\\\\\\\"hiker://assets/home.js\\\\\\\",\\\\\\\"日常书签组\\\\\\\")\\\",\\\"title\\\":\\\"修 改\\\"},{\\\"js\\\":\\\"(\\\\n(key, jUrl, n, index, isGroup) => {\\\\n    eval(fetch(jUrl));\\\\n    confirm({title: \\\\\\\"\\\\\\\\u6e29\\\\\\\\u99a8\\\\\\\\u63d0\\\\\\\\u793a\\\\\\\", content: \\\\\\\"\\\\\\\\u786e\\\\\\\\u8ba4\\\\\\\\u5220\\\\\\\\u9664\\\\\\\\u300c\\\\\\\" + n + \\\\\\\"\\\\\\\\u300d?\\\\\\\", confirm: $.toString((key, jUrl, index, isGroup) => {\\\\n        eval(fetch(jUrl));\\\\n        const Localfile = HikerHome.getLocalfile();\\\\n        const bookMark = HikerHome.getBookmarksList(Localfile.getItem(\\\\\\\"BookmarksList\\\\\\\"));\\\\n        if (isGroup) {\\\\n            bookMark.del_group(key, index);\\\\n        } else {\\\\n            bookMark.del(key);\\\\n        }\\\\n        refreshPage(false);\\\\n        return \\\\\\\"toast://\\\\\\\\u5df2\\\\\\\\u5220\\\\\\\\u9664\\\\\\\";\\\\n    }\\\\n    , key, jUrl, index, isGroup)});\\\\n    return \\\\\\\"hiker://empty\\\\\\\";\\\\n}\\\\n)(2,\\\\\\\"hiker://assets/home.js\\\\\\\",\\\\\\\"音乐歌单\\\\\\\",11,true)\\\",\\\"title\\\":\\\"删 除\\\"}]}\",\"saved\":false,\"title\":\"我的主页\",\"version\":0,\"url\":\"hiker://empty#fypage#immersiveTheme##noRecordHistory#;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 15；； 2407FRK8EC Build/AP3A.240617.008；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/128.0.6613.127 Mobile Safari/537.36}\",\"col_type\":\"icon_small_4\",\"find_rule\":\"js:(\\n() => {\\n    setPageTitle(\\\"\\\\u559c\\\\u6b22\\\\u542c\\\\u97f3\\\\u4e50\\\\u7684\\\\u68a6\\\");\\n    let d = [];\\n    try {\\n        let id = getItem(\\\"music_img\\\", \\\"dongman\\\");\\n        var file = \\\"hiker://files/Jm/png/\\\" + id + \\\".json\\\";\\n        var imglist = JSON.parse(fetch(file));\\n        let max = imglist.length - 1;\\n        let min = 0;\\n        let num = Math.floor(Math.random() * (max - min + 1)) + min;\\n        var showImg = imglist[num];\\n    }\\n    catch {\\n    }\\n    if (MY_PAGE == 1) {\\n        d.push({title: \\\"\\\\u6c38\\\\u8fdc\\\\u76f8\\\\u4fe1\\\\u7f8e\\\\u597d\\\\u7684\\\\u4e8b\\\\u60c5\\\\u5373\\\\u5c06\\\\u53d1\\\\u751f\\\\uff01\\\", col_type: \\\"movie_1_vertical_pic_blur\\\", desc: \\\"\\\\ud83e\\\\uddf8 \\\\u4eac\\\\u68a6\\\\n\\\\n\\\\ud83d\\\\udc49\\\\ud83c\\\\udffb \\\\u672c\\\\u5730\\\\u97f3\\\\u4e50\\\", pic: showImg || \\\"\\\", url: \\\"select://\\\" + JSON.stringify({options: [\\\"\\\\u672c\\\\u5730\\\\u97f3\\\\u4e50\\\", \\\"\\\\u66f4\\\\u6362\\\\u56fe\\\\u7247\\\"], attachView: true, js: $.toString(() => {\\n            if (input == \\\"\\\\u672c\\\\u5730\\\\u97f3\\\\u4e50\\\") {\\n                return \\\"hiker://localMedia\\\";\\n            } else {\\n                let title = [\\\"\\\\u52a8\\\\u6f2b\\\", \\\"\\\\u7f8e\\\\u5973\\\", \\\"\\\\u98ce\\\\u666f\\\", \\\"\\\\u6c7d\\\\u8f66\\\", \\\"\\\\u52a8\\\\u56fe\\\"];\\n                let id = [\\\"dongman\\\", \\\"meinv\\\", \\\"fengjing\\\", \\\"qiche\\\", \\\"gif\\\"];\\n                var list = title.map((item, index) => {\\n                    return {name: item, id: id[index]};\\n                }\\n                );\\n                let name = list.map(j => j.name);\\n                return $(name, 2, \\\"\\\\u2757\\\\ufe0f\\\\u56fe\\\\u7247\\\\u5f15\\\\u7528\\\\u7684\\\\u5929\\\\u6c14\\\").select((list) => {\\n                    let a = list.findIndex(j => j.name == input);\\n                    let url = list[a].id;\\n                    setItem(\\\"music_img\\\", url);\\n                    refreshPage(false);\\n                    return \\\"hiker://empty\\\";\\n                }\\n                , list);\\n            }\\n        }\\n        )})}, {col_type: \\\"big_blank_block\\\"}, {col_type: \\\"big_blank_block\\\"}, {title: \\\"\\\\u5c0f\\\\u4e03\\\\u6b4c\\\\u5355\\\", col_type: \\\"icon_3_round_fill\\\", pic: \\\"hiker://files/Jm/lm/music/85.svg\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            if (!fileExist(\\\"hiker://files/Jm/gedan.json\\\")) {\\n                saveFile(\\\"hiker://files/Jm/gedan.json\\\", \\\"[{\\\\\\\"title\\\\\\\":\\\\\\\"\\\\u70ed\\\\u641c\\\\u6b4c\\\\u66f2\\\\\\\",\\\\\\\"icon\\\\\\\":\\\\\\\"http://qpic.y.qq.com/music_cover/hKFribMhwH4ClwNWJxicuCxjuwIkbZPq4HVT0Qgxsdb8JWQXXC2TFsuQ/600?n=1\\\\\\\",\\\\\\\"id\\\\\\\":7532670538},{\\\\\\\"title\\\\\\\":\\\\\\\"\\\\u6296\\\\u97f3\\\\u70ed\\\\u95e8\\\\\\\",\\\\\\\"icon\\\\\\\":\\\\\\\"http://qpic.y.qq.com/music_cover/WpvdJXfn798ibD4gcfjw0NSuBkFTJYpY5QOev3ExcBQiamRcobkpN77g/600?n=1\\\\\\\",\\\\\\\"id\\\\\\\":7630303474}]\\\");\\n            }\\n            var gedan = JSON.parse(request(\\\"hiker://files/Jm/gedan.json\\\"));\\n            return $(gedan, 2, \\\"\\\\u5c0f\\\\u4e03\\\\u6b4c\\\\u5355\\\").select((gedan) => {\\n                let a = gedan.findIndex(t => t.title == input);\\n                var id = gedan[a].id;\\n                return $(\\\"hiker://empty#immersiveTheme##noHistory##noRecordHistory#\\\").rule((id) => {\\n                    setPageTitle(\\\"\\\\u5c0f\\\\u4e03\\\\u6b4c\\\\u5355\\\");\\n                    let d = [];\\n                    let html = JSON.parse(fetch(\\\"https://api.yaohud.cn/api/qqmusic/v2?key=aUlykA35KgmwPUpehJKNbFjo6v&type=songlist&id=\\\" + id)).data;\\n                    var json = html.list.map(j => {\\n                        return {title: j.title, singer: j.author, album: j.album.name, pic: j.pic, id: j.mid};\\n                    }\\n                    );\\n                    d.push({title: html.info.title, col_type: \\\"movie_1_vertical_pic_blur\\\", desc: \\\"\\\\ud83e\\\\uddf8\\\\t\\\" + html.info.creator.nick + \\\"\\\\n\\\\n\\\\ud83c\\\\udfbc\\\\t\\\" + html.info.songnum + \\\"\\\\u9996\\\", pic: html.info.picurl, url: $(\\\"\\\", \\\"\\\\u66f2\\\\u540d\\\\u6216\\\\u6b4c\\\\u624b\\\").input((json) => {\\n                        function search(array, name) {\\n                            return array.filter(item => {\\n                                return item.title.toLowerCase().includes(name.toLowerCase()) || item.singer.toLowerCase().includes(name.toLowerCase());\\n                            }\\n                            );\\n                        }\\n                        let results = search(json, input);\\n                        if (results.length > 0) {\\n                            return $(\\\"hiker://empty\\\").rule((results) => {\\n                                setPageTitle(\\\"\\\\u641c\\\\u7d22\\\\u7ed3\\\\u679c\\\");\\n                                let d = [];\\n                                results.forEach(j => {\\n                                    d.push({title: j.title, col_type: \\\"text_1\\\", desc: j.album ? j.singer + \\\" -- \\\" + j.album : j.singer + \\\" -- \\\" + j.title, pic: j.pic, url: $(\\\"#noLoading#\\\").lazyRule((j) => {\\n                                        try {\\n                                            var js = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/QQmusicVIP/?br=11&mid=\\\" + j.id)).data.src;\\n                                            var url = [js + \\\"#isMusic=true#\\\"];\\n                                        }\\n                                        catch (e) {\\n                                            var json = JSON.parse(fetch(\\\"https://xiaoapi.cn/API/mv_sq.php?n=1&msg=\\\" + j.title, {timeout: 2000})).url;\\n                                            var url = [json[3] || json[2] || json[1] || json[0]];\\n                                        }\\n                                        try {\\n                                            var lrc = JSON.parse(fetch(\\\"https://api.yaohud.cn/api/music/lrc?key=aUlykA35KgmwPUpehJKNbFjo6v&type=qq&mid=\\\" + j.id)).data;\\n                                        }\\n                                        catch {\\n                                        }\\n                                        return JSON.stringify({urls: url, lyric: lrc});\\n                                    }\\n                                    , j), extra: {inheritTitle: false}});\\n                                }\\n                                );\\n                                setResult(d);\\n                            }\\n                            , results);\\n                        } else {\\n                            return \\\"toast://\\\\u6ca1\\\\u6709\\\\u627e\\\\u5230\\\";\\n                        }\\n                    }\\n                    , json), extra: {longClick: [{title: \\\"\\\\ud83d\\\\udce0\\\\u590d\\\\u5236\\\\u56fe\\\\u7247\\\\u94fe\\\\u63a5\\\", js: $.toString((html) => {\\n                        return \\\"copy://\\\" + html.info.picurl;\\n                    }\\n                    , html)}]}});\\n                    json.map(j => {\\n                        d.push({title: j.title, col_type: \\\"text_1\\\", desc: j.album ? j.singer + \\\" -- \\\" + j.album : j.singer + \\\" -- \\\" + j.title, pic_url: j.pic + \\\"@Referer=\\\", url: $(\\\"#noLoading##noHistory##noRecordHistory#\\\").lazyRule((j) => {\\n                            try {\\n                                var js = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/QQmusicVIP/?br=11&mid=\\\" + j.id)).data.src;\\n                                var url = [js + \\\"#isMusic=true#\\\"];\\n                            }\\n                            catch (e) {\\n                                var json = JSON.parse(fetch(\\\"https://xiaoapi.cn/API/mv_sq.php?n=1&msg=\\\" + j.title, {timeout: 2000})).url;\\n                                var url = [json[3] || json[2] || json[1] || json[0]];\\n                            }\\n                            try {\\n                                var lrc = JSON.parse(fetch(\\\"https://api.yaohud.cn/api/music/lrc?key=aUlykA35KgmwPUpehJKNbFjo6v&type=qq&mid=\\\" + j.id)).data;\\n                            }\\n                            catch {\\n                            }\\n                            return JSON.stringify({urls: url, lyric: lrc});\\n                        }\\n                        , j), extra: {inheritTitle: false, longClick: [{title: \\\"\\\\u4e0b\\\\u8f7d\\\\u6b4c\\\\u66f2\\\", js: $.toString((j) => {\\n                            var json = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/QQmusicVIP/?br=11&mid=\\\" + j.id)).data.src;\\n                            return \\\"download://\\\" + json;\\n                        }\\n                        , j)}, {title: \\\"\\\\u89c2\\\\u770bMV\\\", js: $.toString((j) => {\\n                            try {\\n                                var json = JSON.parse(fetch(\\\"https://xiaoapi.cn/API/mv_sq.php?n=1&msg=\\\" + j.title, {timeout: 2000})).url;\\n                                var url = [json[3] || json[2] || json[1] || json[0]];\\n                            }\\n                            catch (e) {\\n                                var url = [JSON.parse(fetch(\\\"https://api.cenguigui.cn/api/juhe/api.php?type=kgmv&n=1&msg=\\\" + j.title, {timeout: 2000})).data.url];\\n                            }\\n                            return JSON.stringify({urls: url});\\n                        }\\n                        , j)}]}});\\n                    }\\n                    );\\n                    setResult(d);\\n                }\\n                , id);\\n            }\\n            , gedan);\\n        }\\n        ), extra: {longClick: [{title: \\\"\\\\ud83d\\\\udc9e \\\\u83b7\\\\u53d6\\\\u6b4c\\\\u5355\\\", js: $.toString(() => {\\n            return $(\\\"\\\", \\\"\\\\u2757\\\\ufe0f\\\\u6b4c\\\\u5355\\\\u5982\\\\u679c\\\\u6709\\\\u65b0\\\\u589e\\\\uff0c\\\\u5219\\\\u9700\\\\u8981\\\\u91cd\\\\u65b0\\\\u83b7\\\\u53d6\\\\n\\\\nQQ\\\\u8d26\\\\u53f7\\\\u83b7\\\\u53d6\\\\u6b4c\\\\u5355\\\").input(() => {\\n                let json = JSON.parse(fetch(\\\"https://api.cenguigui.cn/api/music/qq/user_list.php?qq=\\\" + input)).myplaylist.map(j => {\\n                    return {title: j.name, icon: j.pic, id: j.id};\\n                }\\n                );\\n                gedan = JSON.parse(request(\\\"hiker://files/Jm/gedan.json\\\"));\\n                gedan = gedan.concat(json);\\n                saveFile(\\\"hiker://files/Jm/gedan.json\\\", JSON.stringify(gedan));\\n                refreshPage(false);\\n                return \\\"toast://\\\\u5df2\\\\u6dfb\\\\u52a0\\\";\\n            }\\n            );\\n        }\\n        )}, {title: \\\"\\\\ud83d\\\\udd30 \\\\u6b4c\\\\u5355\\\\u7ba1\\\\u7406\\\", js: $.toString(() => {\\n            return $(\\\"hiker://empty#noHistory##noRecordHistory#\\\").rule(() => {\\n                setPageTitle(\\\"\\\\u6b4c\\\\u5355\\\\u7ba1\\\\u7406\\\");\\n                let d = [];\\n                d.push({title: \\\"\\\\u63d0\\\\u53d6id\\\", col_type: \\\"input\\\", desc: \\\"\\\\u8bf7\\\\u8f93\\\\u5165\\\\u5206\\\\u4eab\\\\u540e\\\\u590d\\\\u5236\\\\u7684\\\\u94fe\\\\u63a5\\\", url: $.toString(() => {\\n                    if (!input) {\\n                        return \\\"toast://\\\\u4e0d\\\\u80fd\\\\u4e3a\\\\u7a7a\\\";\\n                    }\\n                    let txt = input;\\n                    let u1 = txt.split(\\\"&\\\")[4];\\n                    let id = u1.split(\\\"=\\\");\\n                    refreshPage(false);\\n                    copy(id[1]);\\n                    return \\\"toast://\\\\u5df2\\\\u590d\\\\u5236\\\" + id[1];\\n                }\\n                )});\\n                d.push({title: \\\"\\\\u6dfb\\\\u52a0\\\", col_type: \\\"input\\\", desc: \\\"\\\\u663e\\\\u793a\\\\u540d\\\\u79f0@\\\\u56fe\\\\u7247\\\\u94fe\\\\u63a5@QQ\\\\u97f3\\\\u4e50id\\\", url: $.toString(() => {\\n                    if (!input) {\\n                        return \\\"toast://\\\\u8bf7\\\\u6839\\\\u636e\\\\u63d0\\\\u793a\\\\u8f93\\\\u5165\\\\u5185\\\\u5bb9\\\";\\n                    }\\n                    let gedan = JSON.parse(request(\\\"hiker://files/Jm/gedan.json\\\"));\\n                    let n = input.split(\\\"@\\\");\\n                    data = {title: n[0], icon: n[1], id: n[2]};\\n                    gedan = gedan.concat(data);\\n                    saveFile(\\\"hiker://files/Jm/gedan.json\\\", JSON.stringify(gedan));\\n                    refreshPage(false);\\n                    return \\\"toast://\\\\u5df2\\\\u6dfb\\\\u52a0\\\";\\n                }\\n                ), extra: {type: \\\"textarea\\\", height: 2}});\\n                d.push({title: \\\"\\\\u6b4c\\\\u5355\\\\u56fe\\\\u7247\\\\u94fe\\\\u63a5\\\\u53ef\\\\u4ee5\\\\u5728\\\\u6b4c\\\\u5355\\\\u4e8c\\\\u7ea7\\\\u6d77\\\\u62a5\\\\u957f\\\\u6309\\\\u590d\\\\u5236\\\\uff0c\\\\u6240\\\\u4ee5\\\\u53ef\\\\u4ee5\\\\u5148\\\\u6dfb\\\\u52a0\\\\u6b4c\\\\u5355\\\\u518d\\\\u7f16\\\\u8f91\\\\u6dfb\\\\u52a0\\\\u6b4c\\\\u5355\\\\u56fe\\\\u7247\\\\uff0c\\\\u6216\\\\u8005\\\\u81ea\\\\u5df1\\\\u9009\\\\u4e00\\\\u5f20\\\\u56fe\\\\u4f5c\\\\u4e3a\\\\u5c01\\\\u9762\\\\u3002\\\", col_type: \\\"scroll_button\\\", url: \\\"hiker://empty\\\"});\\n                let gedan = JSON.parse(request(\\\"hiker://files/Jm/gedan.json\\\"));\\n                var index = 0;\\n                gedan.map(j => {\\n                    var item = j.title + \\\"@\\\" + j.icon + \\\"@\\\" + j.id;\\n                    d.push({title: index + \\\".\\\" + j.title, col_type: \\\"card_pic_3\\\", pic: j.icon, url: $([\\\"\\\\u7f16\\\\u8f91\\\", \\\"\\\\u79fb\\\\u4f4d\\\", \\\"\\\\u5220\\\\u9664\\\"], 3, \\\"\\\\u8bf7\\\\u9009\\\\u62e9\\\").select((index, item) => {\\n                        if (input == \\\"\\\\u7f16\\\\u8f91\\\") {\\n                            return $(item, \\\"\\\\u60f3\\\\u8981\\\\u66f4\\\\u6362\\\\u7684\\\\u6b4c\\\\u5355\\\\u540d,\\\\u6b4c\\\\u5355id,\\\\u56fe\\\\u7247\\\\u94fe\\\\u63a5 \\\").input((index) => {\\n                                let gedan = JSON.parse(request(\\\"hiker://files/Jm/gedan.json\\\"));\\n                                let n = input.split(\\\"@\\\");\\n                                gedan[index] = {title: n[0], icon: n[1], id: n[2]};\\n                                saveFile(\\\"hiker://files/Jm/gedan.json\\\", JSON.stringify(gedan));\\n                                refreshPage(false);\\n                                return \\\"toast://\\\\u66f4\\\\u6539\\\\u6210\\\\u529f~\\\";\\n                            }\\n                            , index);\\n                        } else {\\n                            if (input == \\\"\\\\u79fb\\\\u4f4d\\\") {\\n                                return $(\\\"\\\", \\\"\\\\u8981\\\\u79fb\\\\u52a8\\\\u5230\\\\u54ea\\\\u4e2a\\\\u5e8f\\\\u53f7\\\\u524d\\\\u9762/\\\\u540e\\\\u9762\\\").input((index) => {\\n                                    let gedan = JSON.parse(request(\\\"hiker://files/Jm/gedan.json\\\"));\\n                                    let temp = gedan[index];\\n                                    gedan.splice(input, 0, temp);\\n                                    if (input < index) {\\n                                        gedan.splice(index + 1, 1);\\n                                    } else {\\n                                        gedan.splice(index, 1);\\n                                    }\\n                                    saveFile(\\\"hiker://files/Jm/gedan.json\\\", JSON.stringify(gedan));\\n                                    refreshPage(false);\\n                                    return \\\"toast://\\\\u79fb\\\\u4f4d\\\\u6210\\\\u529f~\\\";\\n                                }\\n                                , index);\\n                            } else {\\n                                let gedan = JSON.parse(request(\\\"hiker://files/Jm/gedan.json\\\"));\\n                                gedan.splice(index, 1);\\n                                saveFile(\\\"hiker://files/Jm/gedan.json\\\", JSON.stringify(gedan));\\n                                refreshPage(false);\\n                                return \\\"toast://\\\\u5220\\\\u9664\\\\u6210\\\\u529f~\\\";\\n                            }\\n                        }\\n                    }\\n                    , index, item)});\\n                    index++;\\n                }\\n                );\\n                setResult(d);\\n            }\\n            );\\n        }\\n        )}, {title: \\\"\\\\u267b\\\\ufe0f \\\\u6062\\\\u590d\\\\u9ed8\\\\u8ba4\\\", js: $.toString(() => {\\n            deleteFile(\\\"hiker://files/Jm/gedan.json\\\");\\n            refreshPage(false);\\n            return \\\"toast://\\\\u5df2\\\\u6062\\\\u590d\\\\u9ed8\\\\u8ba4\\\";\\n        }\\n        )}]}});\\n        d.push({title: \\\"\\\\u5c0f\\\\u82b8\\\\u699c\\\\u5355\\\", col_type: \\\"icon_3_round_fill\\\", pic: \\\"hiker://files/Jm/lm/music/51.svg\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            var gedan = JSON.parse(fc(\\\"http://music.163.com/api/toplist\\\", 24)).list.map(l => {\\n                return {title: l.name, icon: l.coverImgUrl, id: l.id};\\n            }\\n            );\\n            return $(gedan, 2, \\\"\\\\u5c0f\\\\u82b8\\\\u6392\\\\u884c\\\\u699c\\\").select((gedan) => {\\n                let a = gedan.findIndex(t => t.title == input);\\n                let id = gedan[a].id;\\n                return $(\\\"hiker://empty#immersiveTheme##noHistory##noRecordHistory#\\\").rule((id) => {\\n                    let d = [];\\n                    setPageTitle(\\\"\\\\u5c0f\\\\u82b8\\\\u6b4c\\\\u5355\\\");\\n                    let html = JSON.parse(fetch(\\\"http://music.163.com/api/v6/playlist/detail?n=1000&id=\\\" + id, {headers: {\\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.0.0 Safari/537.36\\\", \\\"Cookie\\\": \\\"os=pc; MUSIC_U=00173997E57DC16112D2E1579F555444812E5133F16C34213D9BB5E3ECEC818845DF8A336A3B9D495EE182F3001AFEAF9E971591CCEDC4713842F3296A1E79DFB7817A8C7BB8154FF15483648F184D0E72D7D26A565E44507380824902C2152CC0BB5DB9A379E80F6F03D0D98B2793A20323034DE4A0BBB4672D48F9362960EF2136153D02E7DF14C9CE84F1F64C16EB307A5BBB58686C6095082AA450583E64EACD3E6B5BE0DFCACA9125F035057FE17B5BDA61D89DF5ABD77906F5E5D858C74DB2E178A3B0E6095DD75518D482DC9D61080A61D9B765D7E98EBE230CF017CD90208392D3E10DE964A68121B6C66D08C902A98ED7113AAE59D1E5559B071DE83126B8C295C780CCD4B0B4DE36E35C09AA634355AEDE2F880998719277E5EF9C7B9CAFFC90E279AAA2BAFCA44C0A83537D609E2DAA5D5D774848C98DD287118895C1C3D6574466F9262DECE07292AC157C1DB70CB703958A7FE55344E273422E69\\\"}})).playlist;\\n                    let json = html.tracks.map(j => {\\n                        let singer = j.ar.map(n => n.name);\\n                        return {title: j.name, singer: singer, album: j.tns, pic: j.al.picUrl, id: j.id, vid: j.mv};\\n                    }\\n                    );\\n                    d.push({title: html.description, col_type: \\\"movie_1_vertical_pic_blur\\\", desc: \\\"\\\\ud83e\\\\uddf8\\\\t\\\" + html.creator.nickname + \\\"\\\\n\\\\n\\\\ud83c\\\\udfbc\\\\t\\\" + html.trackCount + \\\"\\\\u9996\\\", pic: html.coverImgUrl, url: \\\"hiker://empty\\\"});\\n                    json.map(j => {\\n                        d.push({title: j.title, col_type: \\\"text_1\\\", desc: j.album ? j.singer + \\\" -- \\\" + j.album : j.singer + \\\" -- \\\" + j.title, pic_url: j.pic + \\\"@Referer=\\\", url: $(\\\"#noLoading##noHistory##noRecordHistory#\\\").lazyRule((j) => {\\n                            try {\\n                                var js = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/NetEase_CloudMusic_new/?br=5&songid=\\\" + j.id)).data.src;\\n                            }\\n                            catch (e) {\\n                                var js = (\\\"https://music.163.com/song/media/outer/url?id=\\\" + j.id);\\n                            }\\n                            let url = [js + \\\"#isMusic=true#\\\"];\\n                            try {\\n                                var lrc = JSON.parse(fetch(\\\"http://music.163.com/api/song/lyric?os=pc&lv=-1&kv=-1&tv=-1&id=\\\" + j.id)).lrc.lyric;\\n                            }\\n                            catch {\\n                            }\\n                            return JSON.stringify({urls: url, lyric: lrc});\\n                        }\\n                        , j), extra: {inheritTitle: false, longClick: [{title: \\\"\\\\u4e0b\\\\u8f7d\\\\u6b4c\\\\u66f2\\\", js: $.toString((j) => {\\n                            try {\\n                                var json = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/NetEase_CloudMusic_new/?br=5&songid=\\\" + j.id)).data.src;\\n                            }\\n                            catch (e) {\\n                                var json = (\\\"https://music.163.com/song/media/outer/url?id=\\\" + j.id);\\n                            }\\n                            return \\\"download://\\\" + json;\\n                        }\\n                        , j)}, {title: \\\"\\\\u89c2\\\\u770bMV\\\", js: $.toString((j) => {\\n                            var json = JSON.parse(fetch(\\\"https://api.vps02.top/API/kg_music_mv.php?n=1&type=json&msg=\\\" + j.title)).data.url;\\n                            return \\\"video://\\\" + json;\\n                        }\\n                        , j)}]}});\\n                    }\\n                    );\\n                    setResult(d);\\n                }\\n                , id);\\n            }\\n            , gedan);\\n        }\\n        )});\\n        d.push({title: getItem(\\\"kwgd\\\", \\\"new\\\") == \\\"new\\\" ? \\\"\\\\u6700\\\\u65b0\\\\u6b4c\\\\u5355\\\" : \\\"\\\\u6700\\\\u70ed\\\\u6b4c\\\\u5355\\\", col_type: \\\"icon_3_round_fill\\\", pic: \\\"hiker://files/Jm/lm/music/82.svg\\\", url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            setItem(\\\"kwgd\\\", getItem(\\\"kwgd\\\", \\\"new\\\") == \\\"new\\\" ? \\\"hot\\\" : \\\"new\\\");\\n            refreshPage(false);\\n            toast(\\\"\\\\u5df2\\\\u5207\\\\u6362\\\" + (getItem(\\\"kwgd\\\", \\\"new\\\") == \\\"new\\\" ? \\\"\\\\u6700\\\\u65b0\\\\u6b4c\\\\u5355\\\" : \\\"\\\\u6700\\\\u70ed\\\\u6b4c\\\\u5355\\\"));\\n            return \\\"hiker://empty\\\";\\n        }\\n        )}, {title: \\\"\\\\u641c\\\\u7d22\\\", col_type: \\\"input\\\", desc: \\\"\\\\ud83d\\\\udc49\\\\ud83c\\\\udffb \\\\u6b4c\\\\u540d\\\\u3001\\\\u6b4c\\\\u624b\\\\u3001\\\\u699c\\\\u5355\\\\u540d\\\\u79f0\\\", url: $.toString(() => {\\n            if (!input) {\\n                return \\\"toast://\\\\u8bf7\\\\u8f93\\\\u5165\\\\u5173\\\\u952e\\\\u8bcd\\\\u641c\\\\u7d22\\\";\\n            }\\n            var txt = input;\\n            setItem(\\\"sspt_input\\\", txt);\\n            return \\\"select://\\\" + JSON.stringify({options: [\\\"\\\\u5c0f\\\\u4e03\\\", \\\"\\\\u5c0f\\\\u82b8\\\", \\\"\\\\u5c0f\\\\u83b4\\\"], attachView: true, js: $.toString((txt) => {\\n                if (input == \\\"\\\\u5c0f\\\\u4e03\\\") {\\n                    return $(\\\"hiker://empty#fypage#immersiveTheme##noHistory##noRecordHistory#\\\").rule((txt) => {\\n                        setPageTitle(\\\"\\\\u5c0f\\\\u4e03\\\\u641c\\\\u7d22\\\");\\n                        let d = [];\\n                        let yiyan = JSON.parse(fetch(\\\"hiker://files/Jm/yiyan.json\\\"));\\n                        let max = yiyan.length - 1;\\n                        let min = 0;\\n                        let num = Math.floor(Math.random() * (max - min + 1)) + min;\\n                        var Display = yiyan[num];\\n                        let json = JSON.parse(fetch(\\\"https://api.yaohud.cn/api/qqmusic/v2?key=aUlykA35KgmwPUpehJKNbFjo6v&type=so&page=\\\" + MY_PAGE + \\\"&per_page=30&word=\\\" + txt)).data.list.map(j => {\\n                            return {title: j.title, singer: j.author, pic: j.pic, album: j.album.name, id: j.mid};\\n                        }\\n                        );\\n                        if (MY_PAGE == 1) {\\n                            d.push({title: \\\"\\\\ud83d\\\\udd0e\\\\t\\\" + txt, col_type: \\\"movie_1_vertical_pic_blur\\\", desc: \\\"\\\\ud83e\\\\uddf8\\\\t\\\\u5c0f\\\\u4e03\\\\u97f3\\\\u4e50\\\\n\\\\n\\\\ud83c\\\\udfa8\\\\t\\\" + Display.replace(/，|。/g, \\\" \\\"), pic: json[0].pic, url: \\\"hiker://empty\\\"});\\n                        }\\n                        json.forEach(j => {\\n                            d.push({title: j.title, col_type: \\\"text_1\\\", desc: j.album ? j.singer + \\\" -- \\\" + j.album : j.singer + \\\" -- \\\" + j.title, pic_url: j.pic + \\\"@Referer=\\\", url: $(\\\"#noLoading##noHistory##noRecordHistory#\\\").lazyRule((j) => {\\n                                try {\\n                                    var js = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/QQmusicVIP/?br=11&mid=\\\" + j.id)).data.src;\\n                                    var url = [js + \\\"#isMusic=true#\\\"];\\n                                }\\n                                catch {\\n                                    var json = JSON.parse(fetch(\\\"https://xiaoapi.cn/API/mv_sq.php?n=1&msg=\\\" + j.title, {timeout: 2000})).url;\\n                                    var url = [json[3] || json[2] || json[1] || json[0]];\\n                                }\\n                                try {\\n                                    var lrc = JSON.parse(fetch(\\\"https://api.yaohud.cn/api/music/lrc?key=aUlykA35KgmwPUpehJKNbFjo6v&type=qq&mid=\\\" + j.id)).data;\\n                                }\\n                                catch {\\n                                }\\n                                return JSON.stringify({urls: url, lyric: lrc});\\n                            }\\n                            , j), extra: {inheritTitle: false, longClick: [{title: \\\"\\\\u4e0b\\\\u8f7d\\\\u6b4c\\\\u66f2\\\", js: $.toString((j) => {\\n                                let json = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/QQmusicVIP/?br=11&mid=\\\" + j.id)).data.src;\\n                                return \\\"download://\\\" + json;\\n                            }\\n                            , j)}, {title: \\\"\\\\u89c2\\\\u770bMV\\\", js: $.toString((j) => {\\n                                try {\\n                                    var json = JSON.parse(fetch(\\\"https://xiaoapi.cn/API/mv_sq.php?n=1&msg=\\\" + j.title, {timeout: 2000})).url;\\n                                    var url = [json[3] || json[2] || json[1] || json[0]];\\n                                }\\n                                catch (e) {\\n                                    var url = [JSON.parse(fetch(\\\"https://api.cenguigui.cn/api/juhe/api.php?type=kgmv&n=1&msg=\\\" + j.title, {timeout: 2000})).data.url];\\n                                }\\n                                return JSON.stringify({urls: url});\\n                            }\\n                            , j)}]}});\\n                        }\\n                        );\\n                        setResult(d);\\n                    }\\n                    , txt);\\n                } else {\\n                    if (input == \\\"\\\\u5c0f\\\\u82b8\\\") {\\n                        return $(\\\"hiker://empty#immersiveTheme##noHistory##noRecordHistory#\\\").rule((txt) => {\\n                            setPageTitle(\\\"\\\\u5c0f\\\\u82b8\\\\u641c\\\\u7d22\\\");\\n                            let d = [];\\n                            let yiyan = JSON.parse(fetch(\\\"hiker://files/Jm/yiyan.json\\\"));\\n                            let max = yiyan.length - 1;\\n                            let min = 0;\\n                            let num = Math.floor(Math.random() * (max - min + 1)) + min;\\n                            var Display = yiyan[num];\\n                            var json = JSON.parse(fetch(\\\"http://music.163.com/api/search/get/web?type=1&offset=0&limit=90&s=\\\" + txt)).result.songs.map(j => {\\n                                let singer = j.artists.map(s => s.name);\\n                                return {title: j.name, singer: singer[0], pic: \\\"https://wanghun.top/qqmusic/wymusic.php?type=pic&id=\\\" + j.id, album: j.album.name, id: j.id, vid: j.mvid};\\n                            }\\n                            );\\n                            if (MY_PAGE == 1) {\\n                                d.push({title: \\\"\\\\ud83d\\\\udd0e\\\\t\\\" + txt, col_type: \\\"movie_1_vertical_pic_blur\\\", desc: \\\"\\\\ud83e\\\\uddf8\\\\t\\\\u5c0f\\\\u82b8\\\\u97f3\\\\u4e50\\\\n\\\\n\\\\ud83c\\\\udfa8\\\\t\\\" + Display.replace(/，|。/g, \\\" \\\"), pic: json[0].pic, url: \\\"hiker://empty\\\"});\\n                            }\\n                            json.map(j => {\\n                                d.push({title: j.title, col_type: \\\"text_1\\\", pic_url: j.pic + \\\"@Referer=\\\", desc: j.album ? j.singer + \\\" -- \\\" + j.album : j.singer + \\\" -- \\\" + j.title, url: $(\\\"#noLoading##noHistory##noRecordHistory#\\\").lazyRule((j) => {\\n                                    try {\\n                                        var js = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/NetEase_CloudMusic_new/?br=5&songid=\\\" + j.id)).data.src;\\n                                    }\\n                                    catch (e) {\\n                                        var js = (\\\"https://music.163.com/song/media/outer/url?id=\\\" + j.id);\\n                                    }\\n                                    var url = [js + \\\"#isMusic=true#\\\"];\\n                                    try {\\n                                        var lrc = JSON.parse(fetch(\\\"http://music.163.com/api/song/lyric?os=pc&lv=-1&kv=-1&tv=-1&id=\\\" + j.id)).lrc.lyric;\\n                                    }\\n                                    catch {\\n                                    }\\n                                    return JSON.stringify({urls: url, lyric: lrc});\\n                                }\\n                                , j), extra: {inheritTitle: false, longClick: [{title: \\\"\\\\u4e0b\\\\u8f7d\\\\u6b4c\\\\u66f2\\\", js: $.toString((j) => {\\n                                    try {\\n                                        var json = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/NetEase_CloudMusic_new/?br=5&songid=\\\" + j.id)).data.src;\\n                                    }\\n                                    catch (e) {\\n                                        var json = (\\\"https://music.163.com/song/media/outer/url?id=\\\" + j.id);\\n                                    }\\n                                    return \\\"download://\\\" + json;\\n                                }\\n                                , j)}, {title: \\\"\\\\u89c2\\\\u770bMV\\\", js: $.toString((j) => {\\n                                    var name = t.split(\\\" \\\")[0];\\n                                    var json = JSON.parse(fetch(\\\"https://api.vps02.top/API/kg_music_mv.php?n=1&type=json&msg=\\\" + j.title)).data.url;\\n                                    return \\\"video://\\\" + json;\\n                                }\\n                                , j)}]}});\\n                            }\\n                            );\\n                            setResult(d);\\n                        }\\n                        , txt);\\n                    } else {\\n                        return $(\\\"hiker://empty#fypage#immersiveTheme##noHistory##noRecordHistory#\\\").rule((txt) => {\\n                            setPageTitle(\\\"\\\\u5c0f\\\\u83b4\\\\u641c\\\\u7d22\\\");\\n                            let d = [];\\n                            let yiyan = JSON.parse(fetch(\\\"hiker://files/Jm/yiyan.json\\\"));\\n                            let max = yiyan.length - 1;\\n                            let min = 0;\\n                            let num = Math.floor(Math.random() * (max - min + 1)) + min;\\n                            var Display = yiyan[num];\\n                            var json = JSON.parse(fetch(\\\"https://search.kuwo.cn/r.s?client=kt&pn=\\\" + (MY_PAGE - 1) + \\\"&rn=30&vipver=1&ft=music&encoding=utf8&rformat=json&mobi=1&all=\\\" + txt)).abslist.map(j => {\\n                                let img = (\\\"http://img1.kwcdn.kuwo.cn/star/albumcover/500\\\" + j.web_albumpic_short.split(\\\"120\\\")[1]);\\n                                return {title: j.SONGNAME, singer: j.ARTIST, pic: img, album: j.ALBUM, rid: j.DC_TARGETID, vid: j.mvpayinfo.vid};\\n                            }\\n                            );\\n                            if (MY_PAGE == 1) {\\n                                d.push({title: \\\"\\\\ud83d\\\\udd0e\\\\t\\\" + txt, pic: json[0].pic, col_type: \\\"movie_1_vertical_pic_blur\\\", desc: \\\"\\\\ud83e\\\\uddf8\\\\t\\\\u5c0f\\\\u83b4\\\\u97f3\\\\u4e50\\\\n\\\\n\\\\ud83c\\\\udfa8\\\\t\\\" + Display.replace(/，|。/g, \\\" \\\"), url: \\\"hiker://empty\\\"});\\n                            }\\n                            json.map(j => {\\n                                d.push({title: j.title, col_type: \\\"text_1\\\", pic: j.pic + \\\"@Referer=\\\", desc: j.album ? j.singer + \\\" -- \\\" + j.album : j.singer + \\\" -- \\\" + j.title, url: $(\\\"#noLoading##noHistory##noRecordHistory#\\\").lazyRule((j) => {\\n                                    try {\\n                                        var js = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/Kuwo_BD_new/?n=1&br=5&name=\\\" + j.title)).data.src;\\n                                    }\\n                                    catch (e) {\\n                                        var js = fetch(\\\"https://antiserver.kuwo.cn/anti.s?type=convert_url&format=mp3&rid=\\\" + j.rid);\\n                                    }\\n                                    let url = [js + \\\"#isMusic=true#\\\"];\\n                                    try {\\n                                        var lrc = JSON.parse(fetch(\\\"https://m.kuwo.cn/newh5/singles/songinfoandlrc?musicId=\\\" + j.rid)).data.lrclist.map(d => {\\n                                            let s = (d.time % 60).toFixed(2).padStart(5, \\\"0\\\");\\n                                            let m = ((d.time - s) / 60).toFixed(0).padStart(2, \\\"0\\\");\\n                                            return \\\"[\\\" + m + \\\":\\\" + s + \\\"]\\\" + d.lineLyric;\\n                                        }\\n                                        ).join(\\\"\\\\n\\\");\\n                                    }\\n                                    catch {\\n                                    }\\n                                    return JSON.stringify({urls: url, lyric: lrc});\\n                                }\\n                                , j), extra: {inheritTitle: false, longClick: [{title: \\\"\\\\u4e0b\\\\u8f7d\\\\u6b4c\\\\u66f2\\\", js: $.toString((j) => {\\n                                    try {\\n                                        var json = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/Kuwo_BD_new/?n=1&br=5&name=\\\" + j.title)).data.src;\\n                                    }\\n                                    catch (e) {\\n                                        var json = fetch(\\\"https://antiserver.kuwo.cn/anti.s?type=convert_url&format=mp3&rid=\\\" + j.rid);\\n                                    }\\n                                    return \\\"download://\\\" + json;\\n                                }\\n                                , j)}, {title: \\\"\\\\u89c2\\\\u770bMV\\\", js: $.toString((j) => {\\n                                    if (vid == \\\"0\\\") {\\n                                        var url = JSON.parse(fetch(\\\"https://api.vps02.top/API/kg_music_mv.php?n=1&type=json&msg=\\\" + j.title)).data.url;\\n                                    } else {\\n                                        var html = fetch(\\\"https://anymatch.kuwo.cn/mobi.s?f=web&user=6f173cf9a2a9da4c&source=kwplayer_ar_10.8.2.2_138.apk&type=get_url_by_vid&quality=MP4HV&p2pid=1&vid=\\\" + j.vid);\\n                                        let a = html.split(\\\"=\\\")[3];\\n                                        let b = a.split(\\\"?\\\")[0];\\n                                        let url = b;\\n                                        return \\\"video://\\\" + url;\\n                                    }\\n                                }\\n                                , j)}]}});\\n                            }\\n                            );\\n                            setResult(d);\\n                        }\\n                        , txt);\\n                    }\\n                }\\n            }\\n            , txt)});\\n        }\\n        ), extra: {defaultValue: getItem(\\\"sspt_input\\\", \\\"\\\")}});\\n    }\\n    let kwgd = getItem(\\\"kwgd\\\", \\\"new\\\");\\n    let html = (\\\"http://wapi.kuwo.cn/api/pc/classify/playlist/getRcmPlayList?loginUid=0&loginSid=0&appUid=76039576&&pn=\\\" + MY_PAGE + \\\"&rn=36&order=\\\" + kwgd);\\n    var json = JSON.parse(fetch(html)).data;\\n    json.data.map(data => {\\n        d.push({title: data.name, col_type: \\\"card_pic_3\\\", pic: data.img, url: $(\\\"hiker://empty#fypage#immersiveTheme##noHistory##noRecordHistory#\\\").rule((data) => {\\n            setPageTitle(\\\"\\\\u5c0f\\\\u83b4\\\\u6b4c\\\\u5355\\\");\\n            let d = [];\\n            let html = JSON.parse(fetch(\\\"https://m.kuwo.cn/newh5app/wapi/api/www/playlist/playListInfo?pid=\\\" + data.id + \\\"&rn=30&ua=&ip=&pn=\\\" + MY_PAGE)).data;\\n            var json = html.musicList.map(j => {\\n                return {title: j.name, singer: j.artist, album: j.album, pic: j.pic, id: j.rid, vid: j.mvpayinfo.vid, time: j.songTimeMinutes};\\n            }\\n            );\\n            if (MY_PAGE == 1) {\\n                d.push({title: html.name, col_type: \\\"movie_1_vertical_pic_blur\\\", pic: html.img700 || html.uPic, desc: \\\"\\\\ud83e\\\\uddf8\\\\t\\\" + html.userName + \\\"\\\\n\\\\n\\\\ud83c\\\\udfbc\\\\t\\\" + data.total + \\\"\\\\u9996\\\", url: \\\"hiker://empty\\\"});\\n            }\\n            json.map(j => {\\n                d.push({title: j.title, col_type: \\\"text_1\\\", desc: j.album ? j.singer + \\\" -- \\\" + j.album : j.singer + \\\" -- \\\" + j.title, pic: j.pic + \\\"@Referer=\\\", url: $(\\\"#noLoading##noHistory##noRecordHistory#\\\").lazyRule((j) => {\\n                    try {\\n                        var js = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/Kuwo_BD_new/?n=1&br=5&name=\\\" + j.title)).data.src;\\n                    }\\n                    catch (e) {\\n                        var js = fetch(\\\"https://antiserver.kuwo.cn/anti.s?type=convert_url&format=mp3&rid=\\\" + j.id);\\n                    }\\n                    let url = [js + \\\"#isMusic=true#\\\"];\\n                    try {\\n                        var lrc = JSON.parse(fetch(\\\"https://m.kuwo.cn/newh5/singles/songinfoandlrc?musicId=\\\" + j.id)).data.lrclist.map(d => {\\n                            let s = (d.time % 60).toFixed(2).padStart(5, \\\"0\\\");\\n                            let m = ((d.time - s) / 60).toFixed(0).padStart(2, \\\"0\\\");\\n                            return \\\"[\\\" + m + \\\":\\\" + s + \\\"]\\\" + d.lineLyric;\\n                        }\\n                        ).join(\\\"\\\\n\\\");\\n                    }\\n                    catch {\\n                    }\\n                    return JSON.stringify({urls: url, lyric: lrc});\\n                }\\n                , j), extra: {inheritTitle: false, longClick: [{title: \\\"\\\\u4e0b\\\\u8f7d\\\\u6b4c\\\\u66f2\\\", js: $.toString((j) => {\\n                    try {\\n                        var json = JSON.parse(fetch(\\\"https://api.xingzhige.com/API/Kuwo_BD_new/?n=1&br=5&name=\\\" + j.title)).data.src;\\n                    }\\n                    catch (e) {\\n                        var json = fetch(\\\"https://antiserver.kuwo.cn/anti.s?type=convert_url&format=mp3&rid=\\\" + j.id);\\n                    }\\n                    return \\\"download://\\\" + json;\\n                }\\n                , j)}, {title: \\\"\\\\u89c2\\\\u770bMV\\\", js: $.toString((j) => {\\n                    if (j.vid == \\\"0\\\") {\\n                        var name = t.split(\\\" \\\")[0];\\n                        var url = JSON.parse(fetch(\\\"https://api.vps02.top/API/kg_music_mv.php?n=1&type=json&msg=\\\" + j.title)).data.url;\\n                    } else {\\n                        var html = fetch(\\\"https://anymatch.kuwo.cn/mobi.s?f=web&user=6f173cf9a2a9da4c&source=kwplayer_ar_10.8.2.2_138.apk&type=get_url_by_vid&quality=MP4HV&p2pid=1&vid=\\\" + j.id);\\n                        let a = html.split(\\\"=\\\")[3];\\n                        let b = a.split(\\\"?\\\")[0];\\n                        let url = b;\\n                    }\\n                    return \\\"video://\\\" + url;\\n                }\\n                , j)}]}});\\n            }\\n            );\\n            setResult(d);\\n        }\\n        , data)});\\n    }\\n    );\\n    setResult(d);\\n}\\n)()\",\"group\":\"①推荐\",\"ua\":\"mobile\",\"preRule\":\"\"}","picUrl":"hiker://files/Jm/lm/more/18.png","title":"喜欢听音乐的梦"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
