API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：我喜欢的音乐

xiaomianao666
Dec 4th, 2022
156
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 325.90 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥我喜欢的音乐@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"页面\",\"path\":\"Config.view\",\"rule\":\"const empty = 'hiker://empty'\\nconst myname = '简单音乐'\\n\\nconst Color = (test) => {\\n    return test.fontcolor('#FA7298');\\n}\\n\\nconst SpringGreen = (test) => {\\n    return test.fontcolor('#3CB371');\\n}\\n\\nconst Strong = (test) => {\\n    return '<strong>' + test + '</strong>';\\n}\\n\\nconst Small = (test) => {\\n    return '<small>' + test + '</small>';\\n}\\n\\nconst Gray = (test) => {\\n    return \\\"<font color='gray'>\\\" + test + \\\"</font>\\\";\\n}\\n\\nconst Rich = (test) => {\\n    return \\\"‘‘’’\\\" + test;\\n}\\n\\nconst getMove = (arr, index, tindex) => {\\n    if (index > tindex) {\\n        arr.splice(tindex, 0, arr[index]);\\n        arr.splice(index + 1, 1)\\n    } else {\\n        arr.splice(tindex + 1, 0, arr[index]);\\n        arr.splice(index, 1)\\n    }\\n}\\n\\nconst aesEncrypt = (word) => {\\n    eval(getCryptoJS());\\n    let str_key = CryptoJS.enc.Utf8.parse(\\\"0CoJUm6Qyw8W8jud\\\");\\n    let str_iv = CryptoJS.enc.Utf8.parse('0102030405060708');\\n    let aes_str = CryptoJS.AES.encrypt(word, str_key, {\\n        iv: str_iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7\\n    }).toString();\\n    str_key = CryptoJS.enc.Utf8.parse(\\\"aaaabbbbccccdddd\\\");\\n    return CryptoJS.AES.encrypt(aes_str, str_key, {\\n        iv: str_iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7\\n    }).toString();\\n}\\n\\nconst NetEaseConfig = (path, body, method) => {\\n    NetEaseUrl = 'https://music.163.com'\\n    if (method != 'GET') {\\n        body = 'params=' + aesEncrypt(JSON.stringify(body)) + '&encSecKey=' + '814e4abf9c1c6a2af74a7ecca8843f3052626c5c054584352e3fd38a519bd659e687cf1c079e1aac5dd9d491af6b8abf92109862ada93dc7b0ef94a8ee79d557ff2a20512b87ce507e357861366b8542139c67896748852d4086104a8dfc99a2e2e0640b46a4357407b72407b2849b323425c6ed45a0222e69d551a2e59e15b7'\\n    }\\n    NetEaseMap = request(NetEaseUrl + path, {\\n        headers: {\\n            'Referer': NetEaseUrl,\\n            'Origin': NetEaseUrl,\\n            'Cookie': 'NMTID=00OQ5Vi-4NKTGfogEunoULh0Qy8PMsAAAGEbKo-Yg; os=pc'\\n        },\\n        body: body,\\n        method: method\\n    })\\n    return JSON.parse(NetEaseMap)\\n}\\n\\nconst TencentConfig = (mid) => {\\n    TencentUrl = mid;\\n    if (typeof mid == \\\"number\\\") {\\n        body = {\\n            \\\"Songlist\\\": {\\n                \\\"module\\\": \\\"music.srfDissInfo.DissInfo\\\",\\n                \\\"method\\\": \\\"CgiGetDiss\\\",\\n                \\\"param\\\": {\\n                    \\\"dirid\\\": 0,\\n                    \\\"from\\\": 15,\\n                    \\\"ctx\\\": 0,\\n                    \\\"onlysonglist\\\": 0,\\n                    \\\"orderlist\\\": 1,\\n                    \\\"tag\\\": 1,\\n                    \\\"rec_flag\\\": 1,\\n                    \\\"disstid\\\": mid,\\n                    \\\"new_format\\\": 1,\\n                    \\\"host_uin\\\": 0,\\n                    \\\"optype\\\": 2,\\n                    \\\"enc_host_uin\\\": \\\"0\\\"\\n                }\\n            },\\n            \\\"comm\\\": {\\n                \\\"ct\\\": \\\"1\\\",\\n                \\\"v\\\": \\\"90\\\",\\n                \\\"cv\\\": \\\"101805\\\",\\n                \\\"gzip\\\": \\\"0\\\"\\n            }\\n        }\\n        TencentUrl = 'http://u6.y.qq.com/cgi-bin/musicu.fcg?data=' + escape(JSON.stringify(body))\\n    }\\n    TencentMap = request(TencentUrl, {\\n        headers: {\\n            'Referer': 'https://y.qq.com/portal/player.html'\\n        }\\n    }).replace(/callback\\\\(|MusicJsonCallback\\\\(|jsonCallback\\\\(|\\\\)$/g, '')\\n    return JSON.parse(TencentMap)\\n}\\n\\nconst KwmusiccarConfig = (KwmusiccarUrl) => {\\n    let host = 'http://m.kuwo.cn/newh5app/'\\n    if (!getMyVar('Kwmusiccar')) {\\n        Cookie = fetchCookie(host + 'api/mobile/v1/home')\\n        Cookie = JSON.parse(Cookie)[0]\\n        putMyVar('Kwmusiccar', Cookie)\\n    }\\n    const x = (t) => {\\n        let e = getMyVar('Kwmusiccar'),\\n            n = e.indexOf(t + \\\"=\\\");\\n        if (-1 != n) {\\n            n = n + t.length + 1;\\n            let o = e.indexOf(\\\";\\\", n);\\n            return -1 == o && (o = e.length),\\n                unescape(e.substring(n, o))\\n        }\\n        return null\\n    }\\n    Token = md5(x(\\\"BAIDU_RANDOM\\\")).toUpperCase()\\n    KwmusiccarUrl = host + 'api/mobile/v1/' + KwmusiccarUrl\\n    KwmusiccarMap = request(KwmusiccarUrl, {\\n        headers: {\\n            'Referer': host,\\n            'Token': Token,\\n            'Cookie': getMyVar('Kwmusiccar')\\n        }\\n    })\\n    return JSON.parse(KwmusiccarMap).data\\n}\\n\\nconst KugouConfig = (data) => {\\n    let MusicUrl = 'http://www.kugou.com/yy/index.php?r=play/getdata&hash=' + data.hash + '&album_id=' + data.album_id\\n    let MusicMap = request(MusicUrl, {\\n        headers: {\\n            'Cookie': 'kg_mid=1'\\n        }\\n    })\\n    return JSON.parse(MusicMap).data\\n}\\n\\nconst MiguFill = (url) => {\\n    if (!/^(https?)/.test(url)) {\\n        return \\\"http://d.musicapp.migu.cn/\\\" + url;\\n    } else {\\n        return url;\\n    }\\n}\\n\\nconst MiguConfig = (MiguUrl) => {\\n    MiguHost = 'https://app.c.nf.migu.cn/'\\n    if (!/^(https?)/.test(MiguUrl)) {\\n        MiguUrl = MiguHost + MiguUrl\\n    }\\n    MiguMap = request(MiguUrl, {\\n        headers: {\\n            'Referer': MiguHost\\n        }\\n    })\\n    return JSON.parse(MiguMap)\\n}\\n\\nconst getSelectMap = (MusicMap, SelectMap, i, mid, name) => {\\n    switch (getItem('getUpMap', SelectMap[SelectMap.length - 1])) {\\n        case SelectMap[0]:\\n            getCopy = getMyVar('BuildMusic', MusicMap[0]) + '\\\\n歌单名称：' + name + '\\\\n歌单识别：' + base64Encode('' + mid + '')\\n            copy(getCopy)\\n            break;\\n        case SelectMap[1]:\\n            return $(empty).lazyRule((empty, MusicMap, i) => {\\n                storage0.putMyVar('MusicMapConfirm', MusicMap)\\n                putMyVar('indexConfirm', i)\\n                confirm({\\n                    title: \\\"歌单删除\\\",\\n                    content: \\\"确定好了吗，该歌单将删除\\\",\\n                    confirm: () => {\\n                        MusicMap = storage0.getMyVar('MusicMapConfirm')\\n                        i = getMyVar('indexConfirm')\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\n                        dataMap = readFile(down);\\n                        eval('dataMap =' + dataMap)\\n                        switch (getMyVar('BuildMusic', MusicMap[0])) {\\n                            case MusicMap[0]:\\n                                dataMap.BuildMusic.NetEase.splice(i, 1)\\n                                break;\\n                            case MusicMap[1]:\\n                                dataMap.BuildMusic.Tencent.splice(i, 1)\\n                                break;\\n                            case MusicMap[2]:\\n                                dataMap.BuildMusic.Kwmusiccar.splice(i, 1)\\n                                break;\\n                            case MusicMap[3]:\\n                                dataMap.BuildMusic.Kugou.splice(i, 1)\\n                                break;\\n                            default:\\n                                dataMap.BuildMusic.Migu.splice(i, 1)\\n                                break;\\n                        }\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                        toast('删除成功');\\n                    }\\n                })\\n                return empty\\n            }, empty, MusicMap, i)\\n            break;\\n        case SelectMap[2]:\\n            putMyVar('getMove', i)\\n            refreshPage(false)\\n            break;\\n        default:\\n            return $(empty + '#autoCache#fypage').rule((mid, MusicMap, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let page = MY_PAGE\\n                let layout = [];\\n                switch (getMyVar('BuildMusic', MusicMap[0])) {\\n                    case MusicMap[0]:\\n                        if (page == 1) {\\n                            NetEaseMap = '/api/v6/playlist/detail?id=' + mid + '&n=1000&limit=1000'\\n                            NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET')\\n                            try {\\n                                NetEaseParse(layout, NetEaseMap.playlist.tracks)\\n                            } catch (e) {\\n                                layout.push({\\n                                    title: Rich(Small(Gray('～～～' + NetEaseMap.message + '～～～'))),\\n                                    url: empty,\\n                                    col_type: 'text_center_1',\\n                                    extra: {\\n                                        lineVisible: false\\n                                    }\\n                                })\\n                            }\\n                        }\\n                        break;\\n                    case MusicMap[1]:\\n                        if (page == 1) {\\n                            TencentMap = TencentConfig(mid).Songlist.data.songlist\\n                            TencentParse(layout, TencentMap)\\n                        }\\n                        break;\\n                    case MusicMap[2]:\\n                        KwmusiccarUrl = 'music/playlist/' + mid + '?pn=' + page + '&rn=20&ua=&ip='\\n                        try {\\n                            KwmusiccarMap = KwmusiccarConfig(KwmusiccarUrl).musicList\\n                            KwmusiccarParse(layout, KwmusiccarMap)\\n                        } catch (e) {\\n                            toast('糟糕API崩溃了')\\n                        }\\n                        break;\\n                    case MusicMap[3]:\\n                        if (page == 1) {\\n                            try {\\n                                KugouUrl = 'https://m.kugou.com/plist/list/' + mid + '/?json=true'\\n                                KugouMap = JSON.parse(request(KugouUrl)).list.list.info\\n                                KugouParse(layout, KugouMap)\\n                            } catch (e) {\\n                                mid = pdfh(request(mid), 'body&&script,2&&Html')\\n                                mid = mid.match(/window\\\\.\\\\$output = ([\\\\S\\\\s].*);/)[1]\\n                                KugouMap = JSON.parse(mid).info.songs\\n                                KugouParse(layout, KugouMap)\\n                            }\\n                        }\\n                        break;\\n                    default:\\n                        MiguUrl = 'MIGUM3.0/resource/playlist/song/v2.0?pageNo=' + page + '&pageSize=50&playlistId=' + mid\\n                        MiguMap = MiguConfig(MiguUrl).data.songList\\n                        MiguParse(layout, MiguMap)\\n                        break;\\n                }\\n                setResult(layout);\\n            }, mid, MusicMap, myname)\\n    }\\n    return empty\\n}\\n\\nconst getImport = (MusicMap, input) => {\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\n    let dataMap = readFile(down);\\n    eval('dataMap =' + dataMap)\\n    let NetEase = dataMap.BuildMusic.NetEase\\n    let Tencent = dataMap.BuildMusic.Tencent\\n    let Kwmusiccar = dataMap.BuildMusic.Kwmusiccar\\n    let Kugou = dataMap.BuildMusic.Kugou\\n    let Migu = dataMap.BuildMusic.Migu\\n    try {\\n        switch (getMyVar('BuildMusic', MusicMap[0])) {\\n            case MusicMap[0]:\\n                if (input.startsWith(MusicMap[0])) {\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\n                    mid = base64Decode(mid)\\n                } else if (input.search('music.163') >= 1) {\\n                    mid = input.match(/(playlist\\\\/|id=)(\\\\d+)/)[2]\\n                }\\n                NetEaseMap = '/api/v6/playlist/detail?id=' + mid + '&n=1000&limit=1000'\\n                NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET').playlist\\n                Break = true\\n                NetEase.forEach(item => {\\n                    if (item.mid == NetEaseMap.id) {\\n                        toast('歌单重复导入了哦')\\n                        Break = false\\n                    }\\n                })\\n                if (Break) {\\n                    NetEase.push({\\n                        name: NetEaseMap.name,\\n                        picUrl: NetEaseMap.coverImgUrl,\\n                        mid: NetEaseMap.id\\n                    })\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\n                    refreshPage(false)\\n                }\\n                break;\\n            case MusicMap[1]:\\n                if (input.startsWith(MusicMap[1])) {\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\n                    mid = base64Decode(mid)\\n                } else if (input.search('qq.com') >= 1) {\\n                    mid = input.match(/id=(\\\\d+)/)[1]\\n                }\\n                TencentMap = TencentConfig(Number(mid)).Songlist.data.dirinfo\\n                Break = true\\n                Tencent.forEach(item => {\\n                    if (item.mid == TencentMap.id) {\\n                        toast('歌单重复导入了哦')\\n                        Break = false\\n                    }\\n                })\\n                if (Break) {\\n                    Tencent.push({\\n                        name: TencentMap.title,\\n                        picUrl: TencentMap.picurl,\\n                        mid: TencentMap.id\\n                    })\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\n                    refreshPage(false)\\n                }\\n                break;\\n            case MusicMap[2]:\\n                if (input.startsWith(MusicMap[2])) {\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\n                    mid = base64Decode(mid)\\n                } else if (input.search('kuwo.cn') >= 1) {\\n                    mid = input.match(/(playlist\\\\/|playlist_detail\\\\/)(\\\\d+)/)[2]\\n                }\\n                KwmusiccarUrl = 'music/playlist/' + mid + '?pn=1&rn=20&ua=&ip='\\n                KwmusiccarMap = KwmusiccarConfig(KwmusiccarUrl)\\n                Break = true\\n                Kwmusiccar.forEach(item => {\\n                    if (item.mid == KwmusiccarMap.id) {\\n                        toast('歌单重复导入了哦')\\n                        Break = false\\n                    }\\n                })\\n                if (Break) {\\n                    Kwmusiccar.push({\\n                        name: KwmusiccarMap.name,\\n                        picUrl: KwmusiccarMap.pic,\\n                        mid: KwmusiccarMap.id\\n                    })\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\n                    refreshPage(false)\\n                }\\n                break;\\n            case MusicMap[3]:\\n                try {\\n                    if (input.startsWith(MusicMap[3])) {\\n                        Input = input.match(/[A-Za-z0-9+/=]+$/)[0]\\n                        Input = base64Decode(Input)\\n                        mid = pdfh(request(Input), 'body&&script,2&&Html')\\n                        mid = mid.match(/window\\\\.\\\\$output = ([\\\\S\\\\s].*);/)[1]\\n                    } else if (input.search('kugou.com') >= 1) {\\n                        Input = input.match(/(https|http)(.*link)/)[0]\\n                        mid = pdfh(request(Input), 'body&&script,2&&Html')\\n                        mid = mid.match(/window\\\\.\\\\$output = ([\\\\S\\\\s].*);/)[1]\\n                    }\\n                    KugouMap = JSON.parse(mid).info.listinfo\\n                    Break = true\\n                    Kugou.forEach(item => {\\n                        if (item.mid == Input) {\\n                            toast('歌单重复导入了哦')\\n                            Break = false\\n                        }\\n                    })\\n                    if (Break) {\\n                        Kugou.push({\\n                            name: KugouMap.name,\\n                            picUrl: KugouMap.pic.replace('{size}', '400'),\\n                            mid: Input\\n                        })\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                    }\\n                } catch (e) {\\n                    if (input.startsWith(MusicMap[3])) {\\n                        mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\n                        mid = base64Decode(mid)\\n                    } else if (input.search('kugou.com') >= 1) {\\n                        mid = input.match(/(\\\\/list\\\\/)(.*)\\\\//)[2]\\n                    }\\n                    KugouUrl = 'https://m3ws.kugou.com/plist/list/' + mid\\n                    KugouMap = request(KugouUrl)\\n                    Break = true\\n                    Kugou.forEach(item => {\\n                        if (item.mid == mid) {\\n                            toast('歌单重复导入了哦')\\n                            Break = false\\n                        }\\n                    })\\n                    if (Break) {\\n                        Kugou.push({\\n                            name: pdfh(KugouMap, '.content&&p&&Text'),\\n                            picUrl: pdfh(KugouMap, '.content&&img&&_src'),\\n                            mid: mid\\n                        })\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                    }\\n                }\\n                break;\\n            default:\\n                if (input.startsWith(MusicMap[4])) {\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\n                    mid = base64Decode(mid)\\n                } else if (input.search('migu.cn') >= 1) {\\n                    if (input.startsWith('分享')) {\\n                        mid = input.match(/(https|http).*(\\\\w)/)[0]\\n                        mid = JSON.parse(request(mid, {\\n                            onlyHeaders: true\\n                        })).url\\n                        mid = mid.match(/(id=)(\\\\d+)/)[2]\\n                    } else {\\n                        mid = input.match(/(playlist\\\\/)(\\\\d+)/)[2]\\n                    }\\n                }\\n                MiguUrl = 'MIGUM3.0/resource/playlist/v2.0?playlistId=' + mid\\n                MiguMap = MiguConfig(MiguUrl).data\\n                Break = true\\n                Migu.forEach(item => {\\n                    if (item.mid == MiguMap.musicListId) {\\n                        toast('歌单重复导入了哦')\\n                        Break = false\\n                    }\\n                })\\n                if (Break) {\\n                    Migu.push({\\n                        name: MiguMap.title,\\n                        picUrl: MiguMap.imgItem.img,\\n                        mid: MiguMap.musicListId\\n                    })\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\n                    refreshPage(false)\\n                }\\n                break;\\n        }\\n    } catch (e) {\\n        toast('糟糕崩溃了，请检查链接是否有误')\\n    }\\n}\\n\\nconst getMySelectMap = (MusicMap, SelectMap, mid, name, input) => {\\n    switch (getItem('getUpMap', SelectMap[SelectMap.length - 1])) {\\n        case SelectMap[0]:\\n            getCopy = getMyVar('MusicMyMap', MusicMap[0]) + '\\\\n歌单名称：' + name + '\\\\n歌单识别：' + base64Encode('' + mid + '')\\n            copy(getCopy)\\n            break;\\n        default:\\n            return $(empty + '#autoCache#').rule((MusicMap, mid, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                switch (getMyVar('MusicMyMap', MusicMap[0])) {\\n                    case MusicMap[0]:\\n                        NetEaseMap = '/api/v6/playlist/detail?id=' + mid + '&n=1000&limit=1000'\\n                        NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET')\\n                        try {\\n                            NetEaseParse(layout, NetEaseMap.playlist.tracks)\\n                        } catch (e) {\\n                            layout.push({\\n                                title: Rich(Small(Gray('～～～' + NetEaseMap.message + '～～～'))),\\n                                url: empty,\\n                                col_type: 'text_center_1',\\n                                extra: {\\n                                    lineVisible: false\\n                                }\\n                            })\\n                        }\\n                        break;\\n                    default:\\n                        TencentMap = TencentConfig(mid).Songlist.data.songlist\\n                        TencentParse(layout, TencentMap)\\n                        break;\\n                }\\n                setResult(layout);\\n            }, MusicMap, mid, myname)\\n    }\\n    return empty\\n}\\n\\nconst getSelectListMap = (SelectMap, i, item) => {\\n    switch (getItem('getUpMap', SelectMap[SelectMap.length - 1])) {\\n        case SelectMap[0]:\\n            getCopy = sharePaste(base64Encode(JSON.stringify(item))) + '\\\\n\\\\n自建歌单：' + item.name\\n            copy(getCopy)\\n            break;\\n        case SelectMap[1]:\\n            putMyVar('indexConfirm', i)\\n            return $(empty).lazyRule((empty) => {\\n                confirm({\\n                    title: \\\"歌单删除\\\",\\n                    content: \\\"确定好了吗，该歌单将删除\\\",\\n                    confirm: () => {\\n                        i = getMyVar('indexConfirm')\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\n                        dataMap = readFile(down);\\n                        eval('dataMap =' + dataMap)\\n                        dataMap.BuildList.splice(i, 1)\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                        toast('删除成功');\\n                    }\\n                })\\n                return empty\\n            }, empty)\\n            break;\\n        case SelectMap[2]:\\n            putMyVar('getMove', i)\\n            refreshPage(false)\\n            break;\\n        case SelectMap[3]:\\n            return $(empty).rule((i, item, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                getEditParse(layout, i, item)\\n                setResult(layout);\\n            }, i, item, myname)\\n            break;\\n        default:\\n            return $(empty).rule((i, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                BuildListParse(layout, i)\\n                setResult(layout);\\n            }, i, myname)\\n    }\\n    return empty\\n}\\n\\nconst getSelectListImport = (input) => {\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\n    let dataMap = readFile(down);\\n    eval('dataMap =' + dataMap)\\n    let BuildList = dataMap.BuildList\\n    if (input.indexOf('自建歌单') > 0) {\\n        input = input.match(/(https|http).*(\\\\w)/)[0]\\n        data = parsePaste(input)\\n        data = base64Decode(data)\\n        eval('data =' + data)\\n        storage0.putMyVar('自建歌单', data)\\n        Break = true\\n        BuildList.forEach((item, i) => {\\n            if (item.name == data.name) {\\n                putMyVar('BreakIndex', i)\\n                confirm({\\n                    title: \\\"歌单覆盖\\\",\\n                    content: \\\"确定好了吗，该歌单将覆盖\\\",\\n                    confirm: () => {\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\n                        let dataMap = readFile(down);\\n                        eval('dataMap =' + dataMap)\\n                        let BuildList = dataMap.BuildList\\n                        let data = storage0.getMyVar('自建歌单')\\n                        BuildList[getMyVar('BreakIndex')] = {\\n                            name: data.name,\\n                            pics: data.pics,\\n                            data: data.data\\n                        }\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                    }\\n                })\\n                Break = false\\n            }\\n        })\\n        if (Break) {\\n            BuildList.push({\\n                name: data.name,\\n                pics: data.pics,\\n                data: data.data\\n            })\\n            saveFile(down, JSON.stringify(dataMap), 0);\\n            refreshPage(false)\\n        }\\n    } else {\\n        toast('导入失败')\\n    }\\n}\\n\\nconst getBaseParse = () => {\\n    MusicMap = ['我的歌单', '歌单收藏', '自建歌单', '音乐菜单'];\\n    const layout = [];\\n    getSearchParse(layout)\\n    MusicMap.forEach(item => {\\n        layout.push({\\n            title: item == getMyVar('MusicMap', MusicMap[0]) ? Rich(Strong(Color(item))) : item,\\n            url: $('#noLoading#').lazyRule((item, empty, myname, MusicMap) => {\\n                switch (item) {\\n                    case MusicMap[MusicMap.length - 1]:\\n                        upMap = ['歌单样式']\\n                        upsMap = storage0.getMyVar('SearchMusicMap', ['聚合搜索'])\\n                        storageMap = storage0.getMyVar('SelectMap')\\n                        upMap = storageMap.concat(upsMap.concat(upMap))\\n                        return $(upMap, 2, '已选择-' + '[' + getItem('getUpMap', storageMap[storageMap.length - 1]) + ']').select((upMap, empty, myname) => {\\n                            switch (input) {\\n                                case upMap[upMap.length - 1]:\\n                                    return $(getColTypes(), 2, '已选择-' + '[' + getItem('getColTypes', 'card_pic_3') + ']').select(() => {\\n                                        setItem('getColTypes', input)\\n                                        toast('切换样式-' + input)\\n                                    })\\n                                    break;\\n                                case upMap[upMap.length - 2]:\\n                                    funMap = ['聚合搜索']\\n                                    funsMap = ['原生搜索']\\n                                    switch (storage0.getMyVar('SearchMusicMap', funMap)[0]) {\\n                                        case funMap[0]:\\n                                            storage0.putMyVar('SearchMusicMap', funsMap);\\n                                            break;\\n                                        default:\\n                                            storage0.putMyVar('SearchMusicMap', funMap);\\n                                            break;\\n                                    }\\n                                    refreshPage();\\n                                    return empty;\\n                                    break;\\n                                case '创建歌单':\\n                                    return $(empty).rule((myname) => {\\n                                        setPageTitle('创建歌单')\\n                                        require('hiker://page/Config.view?rule=' + myname)\\n                                        let layout = [];\\n                                        CreateListParse(layout)\\n                                        setResult(layout);\\n                                    }, myname)\\n                                    break;\\n                                default:\\n                                    setItem('getUpMap', input)\\n                                    toast('切换方法-' + input)\\n                                    break;\\n                            }\\n                            return empty\\n                        }, upMap, empty, myname)\\n                        break;\\n                    default:\\n                        putMyVar('MusicMap', item);\\n                        clearItem('getUpMap')\\n                        refreshPage();\\n                        return empty;\\n                        break;\\n                }\\n            }, item, empty, myname, MusicMap),\\n            col_type: 'scroll_button'\\n        })\\n    })\\n    layout.push({\\n        col_type: 'blank_block'\\n    })\\n    switch (getMyVar('MusicMap', MusicMap[0])) {\\n        case MusicMap[0]:\\n            getMyMusicParse(layout)\\n            break;\\n        case MusicMap[1]:\\n            getBuildMusicParse(layout)\\n            break;\\n        default:\\n            getBuildListParse(layout)\\n            break;\\n    }\\n    setResult(layout)\\n}\\n\\nconst getMyMusicParse = (layout) => {\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\n    let dataMap;\\n    if (fileExist(down)) {\\n        eval('dataMap =' + readFile(down))\\n    } else {\\n        dataMap = {}\\n        saveFile(down, JSON.stringify(dataMap), 0);\\n    }\\n    MusicMap = ['网易歌单', '腾讯歌单'];\\n    MusicMap.forEach(item => {\\n        layout.push({\\n            title: item == getMyVar('MusicMyMap', MusicMap[0]) ? Rich(Strong(Color(item))) : item,\\n            url: $('#noLoading#').lazyRule((item, empty) => {\\n                putMyVar('MusicMyMap', item);\\n                refreshPage();\\n                return empty;\\n            }, item, empty),\\n            col_type: 'scroll_button'\\n        })\\n    })\\n    addListener('onRefresh', $.toString(() => {\\n        switch (getMyVar('注销', '0')) {\\n            case '0':\\n                putMyVar('注销', 1);\\n                break;\\n            default:\\n                putMyVar('注销', 0);\\n                break;\\n        }\\n    }));\\n    switch (getMyVar('MusicMyMap', MusicMap[0])) {\\n        case MusicMap[0]:\\n            getNetEaseParse(layout, dataMap, MusicMap)\\n            break;\\n        default:\\n            getTencentParse(layout, dataMap, MusicMap)\\n            break;\\n    }\\n}\\n\\nconst getBuildMusicParse = (layout) => {\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\n    let dataMap;\\n    eval('dataMap =' + readFile(down))\\n    getSaveFile = false\\n    if (dataMap.BuildMusic == null) {\\n        dataMap.BuildMusic = {}\\n        getSaveFile = true\\n    }\\n    if (dataMap.BuildMusic.NetEase == null) {\\n        dataMap.BuildMusic.NetEase = []\\n        getSaveFile = true\\n    }\\n    if (dataMap.BuildMusic.Tencent == null) {\\n        dataMap.BuildMusic.Tencent = []\\n        getSaveFile = true\\n    }\\n    if (dataMap.BuildMusic.Kwmusiccar == null) {\\n        dataMap.BuildMusic.Kwmusiccar = []\\n        getSaveFile = true\\n    }\\n    if (dataMap.BuildMusic.Kugou == null) {\\n        dataMap.BuildMusic.Kugou = []\\n        getSaveFile = true\\n    }\\n    if (dataMap.BuildMusic.Migu == null) {\\n        dataMap.BuildMusic.Migu = []\\n        getSaveFile = true\\n    }\\n    if (getSaveFile) {\\n        saveFile(down, JSON.stringify(dataMap), 0);\\n        eval('dataMap =' + readFile(down))\\n    }\\n    MusicMap = ['网易歌单', '腾讯歌单', '酷我歌单', '酷狗歌单', '咪咕歌单'];\\n    MusicMap.forEach(item => {\\n        layout.push({\\n            title: item == getMyVar('BuildMusic', MusicMap[0]) ? Rich(Strong(Color(item))) : item,\\n            url: $('#noLoading#').lazyRule((item, empty) => {\\n                putMyVar('BuildMusic', item);\\n                refreshPage();\\n                return empty;\\n            }, item, empty),\\n            col_type: 'scroll_button'\\n        })\\n    })\\n    switch (getMyVar('BuildMusic', MusicMap[0])) {\\n        case MusicMap[0]:\\n            dataMap = dataMap.BuildMusic.NetEase\\n            break;\\n        case MusicMap[1]:\\n            dataMap = dataMap.BuildMusic.Tencent\\n            break;\\n        case MusicMap[2]:\\n            dataMap = dataMap.BuildMusic.Kwmusiccar\\n            break;\\n        case MusicMap[3]:\\n            dataMap = dataMap.BuildMusic.Kugou\\n            break;\\n        default:\\n            dataMap = dataMap.BuildMusic.Migu\\n            break;\\n    }\\n    SelectMap = ['歌单分享', '删除歌单', '歌单移动', '查看内容']\\n    storage0.putMyVar('SelectMap', SelectMap)\\n    dataMap.forEach((item, i) => {\\n        name = item.name\\n        select = $(empty + '#noLoading#').lazyRule((MusicMap, SelectMap, i, mid, name, myname) => {\\n            require('hiker://page/Config.view?rule=' + myname)\\n            clearMyVar('switch')\\n            return getSelectMap(MusicMap, SelectMap, i, mid, name)\\n        }, MusicMap, SelectMap, i, item.mid, item.name, myname)\\n        if (getMyVar('getMove', '')) {\\n            if (getMyVar('getMove', '') == i) {\\n                name = Rich(Small(SpringGreen(name)))\\n            }\\n            select = $(empty).lazyRule((MusicMap, i, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                down = 'hiker://files/rules/js/简单音乐.js'\\n                eval('dataMap =' + readFile(down))\\n                index = Number(getMyVar('getMove'))\\n                switch (getMyVar('BuildMusic', MusicMap[0])) {\\n                    case MusicMap[0]:\\n                        getMove(dataMap.BuildMusic.NetEase, index, i)\\n                        break;\\n                    case MusicMap[1]:\\n                        getMove(dataMap.BuildMusic.Tencent, index, i)\\n                        break;\\n                    case MusicMap[2]:\\n                        getMove(dataMap.BuildMusic.Kwmusiccar, index, i)\\n                        break;\\n                    case MusicMap[3]:\\n                        getMove(dataMap.BuildMusic.Kugou, index, i)\\n                        break;\\n                    default:\\n                        getMove(dataMap.BuildMusic.Migu, index, i)\\n                        break;\\n                }\\n                saveFile(down, JSON.stringify(dataMap), 0);\\n                clearMyVar('getMove')\\n                refreshPage(false)\\n                return empty\\n            }, MusicMap, i, myname)\\n        }\\n        layout.push({\\n            title: name,\\n            img: item.picUrl,\\n            url: select,\\n            col_type: 'card_pic_3',\\n            extra: {\\n                inheritTitle: false,\\n                longClick: [{\\n                    title: '歌单分享',\\n                    js: $.toString((MusicMap, mid, name) => {\\n                        getCopy = getMyVar('BuildMusic', MusicMap[0]) + '\\\\n歌单名称：' + name + '\\\\n歌单识别：' + base64Encode('' + mid + '')\\n                        copy(getCopy)\\n                    }, MusicMap, item.mid, item.name)\\n                }, {\\n                    title: '删除歌单',\\n                    js: $.toString((MusicMap, i) => {\\n                        storage0.putMyVar('MusicMapConfirm', MusicMap)\\n                        putMyVar('indexConfirm', i)\\n                        confirm({\\n                            title: \\\"歌单删除\\\",\\n                            content: \\\"确定好了吗，该歌单将删除\\\",\\n                            confirm: () => {\\n                                MusicMap = storage0.getMyVar('MusicMapConfirm')\\n                                i = getMyVar('indexConfirm')\\n                                down = 'hiker://files/rules/js/简单音乐.js'\\n                                dataMap = readFile(down);\\n                                eval('dataMap =' + dataMap)\\n                                switch (getMyVar('BuildMusic', MusicMap[0])) {\\n                                    case MusicMap[0]:\\n                                        dataMap.BuildMusic.NetEase.splice(i, 1)\\n                                        break;\\n                                    case MusicMap[1]:\\n                                        dataMap.BuildMusic.Tencent.splice(i, 1)\\n                                        break;\\n                                    case MusicMap[2]:\\n                                        dataMap.BuildMusic.Kwmusiccar.splice(i, 1)\\n                                        break;\\n                                    case MusicMap[3]:\\n                                        dataMap.BuildMusic.Kugou.splice(i, 1)\\n                                        break;\\n                                    default:\\n                                        dataMap.BuildMusic.Migu.splice(i, 1)\\n                                        break;\\n                                }\\n                                saveFile(down, JSON.stringify(dataMap), 0);\\n                                refreshPage(false)\\n                                toast('删除成功');\\n                            }\\n                        })\\n                    }, MusicMap, i)\\n                }, {\\n                    title: '置顶歌单',\\n                    js: $.toString((name, MusicMap) => {\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\n                        eval('dataMap =' + readFile(down))\\n                        switch (getMyVar('BuildMusic', MusicMap[0])) {\\n                            case MusicMap[0]:\\n                                data = dataMap.BuildMusic.NetEase\\n                                break;\\n                            case MusicMap[1]:\\n                                data = dataMap.BuildMusic.Tencent\\n                                break;\\n                            case MusicMap[2]:\\n                                data = dataMap.BuildMusic.Kwmusiccar\\n                                break;\\n                            case MusicMap[3]:\\n                                data = dataMap.BuildMusic.Kugou\\n                                break;\\n                            default:\\n                                data = dataMap.BuildMusic.Migu\\n                                break;\\n                        }\\n                        let obj = {};\\n                        data.forEach((item, index) => {\\n                            if (item.name === name) {\\n                                obj = item;\\n                                data.splice(index, 1)\\n                                return;\\n                            }\\n                        })\\n                        data.unshift(obj);\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                    }, item.name, MusicMap)\\n                }, {\\n                    title: '置底歌单',\\n                    js: $.toString((name, MusicMap) => {\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\n                        eval('dataMap =' + readFile(down))\\n                        switch (getMyVar('BuildMusic', MusicMap[0])) {\\n                            case MusicMap[0]:\\n                                data = dataMap.BuildMusic.NetEase\\n                                break;\\n                            case MusicMap[1]:\\n                                data = dataMap.BuildMusic.Tencent\\n                                break;\\n                            case MusicMap[2]:\\n                                data = dataMap.BuildMusic.Kwmusiccar\\n                                break;\\n                            case MusicMap[3]:\\n                                data = dataMap.BuildMusic.Kugou\\n                                break;\\n                            default:\\n                                data = dataMap.BuildMusic.Migu\\n                                break;\\n                        }\\n                        let obj = {};\\n                        data.forEach((item, index) => {\\n                            if (item.name === name) {\\n                                obj = item;\\n                                data.splice(index, 1)\\n                                return;\\n                            }\\n                        })\\n                        data.push(obj);\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                    }, item.name, MusicMap)\\n                }]\\n            }\\n        })\\n    })\\n    layout.push({\\n        title: '歌单导入',\\n        img: 'https://missuo.ru/file/1eb6219db8632428a2396.jpg',\\n        url: $('{{clipboard}}').input((MusicMap, myname) => {\\n            require('hiker://page/Config.view?rule=' + myname)\\n            return getImport(MusicMap, input)\\n        }, MusicMap, myname),\\n        col_type: 'card_pic_3'\\n    })\\n}\\n\\nconst getBuildListParse = (layout) => {\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\n    let dataMap;\\n    eval('dataMap =' + readFile(down))\\n    if (dataMap.BuildList == null) {\\n        dataMap.BuildList = []\\n        saveFile(down, JSON.stringify(dataMap), 0);\\n        eval('dataMap =' + readFile(down))\\n    }\\n    SelectMap = ['歌单分享', '删除歌单', '歌单移动', '编辑歌单', '创建歌单', '查看内容']\\n    storage0.putMyVar('SelectMap', SelectMap)\\n    dataMap.BuildList.forEach((item, i) => {\\n        name = item.name\\n        select = $(empty + '#noLoading#').lazyRule((SelectMap, i, item, myname) => {\\n            require('hiker://page/Config.view?rule=' + myname)\\n            return getSelectListMap(SelectMap, i, item)\\n        }, SelectMap, i, item, myname)\\n        if (getMyVar('getMove', '')) {\\n            if (getMyVar('getMove', '') == i) {\\n                name = Rich(Small(SpringGreen(name)))\\n            }\\n            select = $(empty).lazyRule((i, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                down = 'hiker://files/rules/js/简单音乐.js'\\n                eval('dataMap =' + readFile(down))\\n                index = Number(getMyVar('getMove'))\\n                getMove(dataMap.BuildList, index, i)\\n                saveFile(down, JSON.stringify(dataMap), 0);\\n                clearMyVar('getMove')\\n                refreshPage(false)\\n                return empty\\n            }, i, myname)\\n        }\\n        layout.push({\\n            title: name,\\n            img: item.pics,\\n            url: select,\\n            col_type: 'card_pic_3',\\n            extra: {\\n                inheritTitle: false,\\n                longClick: [{\\n                    title: '歌单分享',\\n                    js: $.toString((item) => {\\n                        getCopy = sharePaste(base64Encode(JSON.stringify(item))) + '\\\\n\\\\n自建歌单：' + item.name\\n                        copy(getCopy)\\n                    }, item)\\n                }, {\\n                    title: '删除歌单',\\n                    js: $.toString((i) => {\\n                        putMyVar('indexConfirm', i)\\n                        confirm({\\n                            title: \\\"歌单删除\\\",\\n                            content: \\\"确定好了吗，该歌单将删除\\\",\\n                            confirm: () => {\\n                                i = getMyVar('indexConfirm')\\n                                down = 'hiker://files/rules/js/简单音乐.js'\\n                                dataMap = readFile(down);\\n                                eval('dataMap =' + dataMap)\\n                                dataMap.BuildList.splice(i, 1)\\n                                saveFile(down, JSON.stringify(dataMap), 0);\\n                                refreshPage(false)\\n                                toast('删除成功');\\n                            }\\n                        })\\n                    }, i)\\n                }, {\\n                    title: '置顶歌单',\\n                    js: $.toString((name) => {\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\n                        eval('dataMap =' + readFile(down))\\n                        let obj = {};\\n                        dataMap.BuildList.forEach((item, index) => {\\n                            if (item.name === name) {\\n                                obj = item;\\n                                dataMap.BuildList.splice(index, 1)\\n                                return;\\n                            }\\n                        })\\n                        dataMap.BuildList.unshift(obj);\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                    }, item.name)\\n                }, {\\n                    title: '置底歌单',\\n                    js: $.toString((name) => {\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\n                        eval('dataMap =' + readFile(down))\\n                        let obj = {};\\n                        dataMap.BuildList.forEach((item, index) => {\\n                            if (item.name === name) {\\n                                obj = item;\\n                                dataMap.BuildList.splice(index, 1)\\n                                return;\\n                            }\\n                        })\\n                        dataMap.BuildList.push(obj);\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                    }, item.name)\\n                }]\\n            }\\n        })\\n    })\\n    layout.push({\\n        title: '歌单导入',\\n        img: 'https://missuo.ru/file/1eb6219db8632428a2396.jpg',\\n        url: $('{{clipboard}}').input((myname) => {\\n            require('hiker://page/Config.view?rule=' + myname)\\n            return getSelectListImport(input)\\n        }, myname),\\n        col_type: 'card_pic_3'\\n    })\\n}\\n\\nconst getNetEaseParse = (layout, dataMap, MusicMap) => {\\n    NetEaseMap = dataMap.NetEase\\n    if (NetEaseMap == null || NetEaseMap.length == 0) {\\n        layout.push({\\n            title: '查\\\\n询',\\n            desc: \\\"输入关键词查询用户\\\",\\n            url: $.toString((empty) => {\\n                putMyVar('关键词', input);\\n                refreshPage();\\n                return empty;\\n            }, empty),\\n            col_type: 'input',\\n            extra: {\\n                type: 'textarea',\\n                height: 3,\\n                defaultValue: getMyVar('关键词')\\n            }\\n        })\\n        if (getMyVar('关键词', '') != '') {\\n            path = '/weapi/search/get'\\n            body = {\\n                \\\"s\\\": getMyVar('关键词'),\\n                \\\"type\\\": 1002,\\n                \\\"limit\\\": 30,\\n                \\\"offset\\\": 0\\n            }\\n            data = NetEaseConfig(path, body, 'POST')\\n            data.result.userprofiles.forEach(item => {\\n                layout.push({\\n                    title: item.nickname,\\n                    img: item.avatarUrl,\\n                    url: $(empty).lazyRule((empty, userId) => {\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\n                        data = readFile(down);\\n                        eval('data =' + data)\\n                        data.NetEase = []\\n                        data.NetEase.push(userId)\\n                        saveFile(down, JSON.stringify(data), 0);\\n                        refreshPage()\\n                        return empty\\n                    }, empty, item.userId),\\n                    col_type: 'avatar'\\n                })\\n            })\\n        }\\n    } else {\\n        NetEaseMap = '/api/user/playlist?offset=0&uid=' + dataMap.NetEase[0] + '&limit=1000'\\n        NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET').playlist\\n        SelectMap = ['歌单分享', '查看内容']\\n        storage0.putMyVar('SelectMap', SelectMap)\\n        NetEaseMap.forEach(item => {\\n            if (item.name.search('喜欢的音乐') < 1) {\\n                layout.push({\\n                    title: item.name,\\n                    img: item.coverImgUrl,\\n                    url: $(empty + '#noLoading#').lazyRule((MusicMap, SelectMap, mid, name, myname) => {\\n                        require('hiker://page/Config.view?rule=' + myname)\\n                        clearMyVar('switch')\\n                        return getMySelectMap(MusicMap, SelectMap, mid, name, input)\\n                    }, MusicMap, SelectMap, item.id, item.name, myname),\\n                    col_type: 'card_pic_3',\\n                    extra: {\\n                        inheritTitle: false,\\n                        longClick: [{\\n                            title: '歌单分享',\\n                            js: $.toString((MusicMap, mid, name) => {\\n                                getCopy = getMyVar('MusicMyMap', MusicMap[0]) + '\\\\n歌单名称：' + name + '\\\\n歌单识别：' + base64Encode('' + mid + '')\\n                                copy(getCopy)\\n                            }, MusicMap, item.id, item.name)\\n                        }]\\n                    }\\n                })\\n            }\\n        })\\n        if (getMyVar('注销', '0') == 1) {\\n            layout.push({\\n                title: Rich(Small(Gray('～～～注销绑定～～～'))),\\n                url: $(empty).lazyRule((empty) => {\\n                    down = 'hiker://files/rules/js/简单音乐.js'\\n                    data = readFile(down);\\n                    eval('data =' + data)\\n                    data.NetEase = []\\n                    saveFile(down, JSON.stringify(data), 0);\\n                    clearMyVar('注销')\\n                    refreshPage()\\n                    return empty\\n                }, empty),\\n                col_type: 'text_center_1',\\n                extra: {\\n                    lineVisible: false\\n                }\\n            })\\n        }\\n    }\\n}\\n\\nconst getTencentParse = (layout, dataMap, MusicMap) => {\\n    TencentMap = dataMap.Tencent\\n    if (TencentMap == null || TencentMap.length == 0) {\\n        layout.push({\\n            desc: \\\"请输入您的QQ号\\\",\\n            col_type: \\\"input\\\",\\n            extra: {\\n                type: 'textarea',\\n                height: 3,\\n                onChange: \\\"setItem('QQ', input)\\\",\\n                titleVisible: false\\n            }\\n        }, {\\n            title: Rich(Strong(Gray('绑定账号'))),\\n            url: $(empty).lazyRule((empty) => {\\n                down = 'hiker://files/rules/js/简单音乐.js'\\n                data = readFile(down);\\n                eval('data =' + data)\\n                data.Tencent = []\\n                data.Tencent.push(getItem('QQ'))\\n                saveFile(down, JSON.stringify(data), 0);\\n                refreshPage()\\n                return empty\\n            }, empty),\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false\\n            }\\n        })\\n    } else {\\n        TencentUrl = 'http://c.y.qq.com/rsc/fcgi-bin/fcg_user_created_diss?hostuin=' + dataMap.Tencent[0] + '&size=1000&format=json'\\n        TencentMap = TencentConfig(TencentUrl)\\n        SelectMap = ['歌单分享', '查看内容']\\n        storage0.putMyVar('SelectMap', SelectMap)\\n        try {\\n            TencentMap = TencentMap.data.disslist\\n            TencentMap = TencentMap.filter(item => item.tid != 0)\\n            if (TencentMap.length > 0) {\\n                TencentMap.forEach(item => {\\n                    layout.push({\\n                        title: item.diss_name,\\n                        img: item.diss_cover,\\n                        url: $(empty + '#noLoading#').lazyRule((MusicMap, SelectMap, mid, name, myname) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            clearMyVar('switch')\\n                            return getMySelectMap(MusicMap, SelectMap, mid, name, input)\\n                        }, MusicMap, SelectMap, item.tid, item.diss_name, myname),\\n                        col_type: 'card_pic_3',\\n                        extra: {\\n                            inheritTitle: false,\\n                            longClick: [{\\n                                title: '歌单分享',\\n                                js: $.toString((MusicMap, mid, name) => {\\n                                    getCopy = getMyVar('MusicMyMap', MusicMap[0]) + '\\\\n歌单名称：' + name + '\\\\n歌单识别：' + base64Encode('' + mid + '')\\n                                    copy(getCopy)\\n                                }, MusicMap, item.tid, item.diss_name)\\n                            }]\\n                        }\\n                    })\\n                })\\n            } else {\\n                layout.push({\\n                    title: Rich(Small(Gray('～～～啥也没有留下～～～'))),\\n                    url: empty,\\n                    col_type: 'text_center_1',\\n                    extra: {\\n                        lineVisible: false\\n                    }\\n                })\\n            }\\n        } catch (e) {\\n            layout.push({\\n                title: Rich(Small(Gray('～～～' + TencentMap.message + '～～～'))),\\n                url: empty,\\n                col_type: 'text_center_1',\\n                extra: {\\n                    lineVisible: false\\n                }\\n            })\\n        }\\n        if (getMyVar('注销', '0') == 1) {\\n            layout.push({\\n                title: Rich(Small(Gray('～～～注销绑定～～～'))),\\n                url: $(empty).lazyRule((empty) => {\\n                    down = 'hiker://files/rules/js/简单音乐.js'\\n                    data = readFile(down);\\n                    eval('data =' + data)\\n                    data.Tencent = []\\n                    saveFile(down, JSON.stringify(data), 0);\\n                    clearMyVar('注销')\\n                    refreshPage()\\n                    return empty\\n                }, empty),\\n                col_type: 'text_center_1',\\n                extra: {\\n                    lineVisible: false\\n                }\\n            })\\n        }\\n    }\\n}\\n\\nconst getConfirm = () => {\\n    if (!getMyVar('失败')) {\\n        confirm({\\n            title: \\\"搜索歌曲\\\",\\n            content: \\\"若免嗅失败，将搜索歌曲\\\",\\n            confirm: () => {\\n                putMyVar('失败', true);\\n                toast('emmm~');\\n                java.lang.Thread.sleep(3000);\\n                toast('下次重启，将重新拉启弹窗')\\n            },\\n            cancel: () => {\\n                putMyVar('失败', false);\\n                toast('俺不要ヽ(≧Д≦)ノ~');\\n                java.lang.Thread.sleep(3000);\\n                toast('下次重启，将重新拉启弹窗')\\n            }\\n        })\\n    }\\n}\\n\\nconst getIncludedParse = (layout) => {\\n    getConfirm()\\n    addListener('onRefresh', $.toString(() => {\\n        switch (getMyVar('更多', '0')) {\\n            case '0':\\n                putMyVar('更多', 1);\\n                break;\\n            default:\\n                putMyVar('更多', 0);\\n                break;\\n        }\\n    }));\\n    addListener('onClose', () => {\\n        clearMyVar('更多')\\n    })\\n    SelectMap = ['收录歌曲', '聆听歌曲']\\n    if (getMyVar('更多', '0') == 1 && MY_PAGE == 1) {\\n        layout.push({\\n            col_type: 'line_blank'\\n        }, {\\n            title: Rich(Small(Gray('～～～更多选项～～～'))),\\n            url: $(SelectMap, 1, '已选择-' + '[' + getMyVar('更多功能', SelectMap[SelectMap.length - 1]) + ']').select((empty) => {\\n                putMyVar('更多功能', input)\\n                refreshPage()\\n                return empty\\n            }, empty),\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false\\n            }\\n        }, {\\n            col_type: 'line_blank'\\n        })\\n    }\\n}\\n\\nconst getIncludedFun = () => {\\n    down = 'hiker://files/rules/js/简单音乐.js'\\n    data = readFile(down);\\n    eval('data =' + data)\\n    if (data.BuildList == null) {\\n        data.BuildList = []\\n        saveFile(down, JSON.stringify(data), 0);\\n        eval('data =' + readFile(down))\\n    }\\n    names = data.BuildList.map(it => it.name)\\n    upMap = names.concat(['创建歌单'])\\n    index = 1\\n    if (upMap.length > 2) {\\n        index = 2\\n    }\\n}\\n\\nconst getIncludedNetEase = (item, input) => {\\n    switch (input) {\\n        case '创建歌单':\\n            return $(empty).rule((myname) => {\\n                setPageTitle('创建歌单')\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                CreateListParse(layout)\\n                setResult(layout);\\n            }, myname)\\n            break;\\n        default:\\n            down = 'hiker://files/rules/js/简单音乐.js'\\n            data = readFile(down);\\n            eval('data =' + data)\\n            getBreak = false\\n            data.BuildList.forEach((Item, x) => {\\n                if (input == Item.name) {\\n                    getBreak = true\\n                    index = x\\n                    storage0.putMyVar('自建歌单', item)\\n                    Item.data.forEach((Items, i) => {\\n                        if (Items.mid == item.id && Items.id == 'netease') {\\n                            putMyVar('BreakIndex', index)\\n                            putMyVar('BreakIndexs', i)\\n                            confirm({\\n                                title: \\\"收录覆盖\\\",\\n                                content: \\\"确定好了吗，歌曲将覆盖原有的\\\",\\n                                confirm: () => {\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\n                                    let dataMap = readFile(down);\\n                                    eval('dataMap =' + dataMap)\\n                                    let BuildList = dataMap.BuildList\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\n                                    let data = storage0.getMyVar('自建歌单')\\n                                    cont = data.ar.map(tag => tag.name).join('、')\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\n                                        name: data.name,\\n                                        cont: cont,\\n                                        pics: data.al.picUrl,\\n                                        mid: data.id,\\n                                        id: 'netease'\\n                                    }\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\n                                    toast('覆盖成功')\\n                                }\\n                            })\\n                            getBreak = false\\n                        }\\n                    })\\n                }\\n            })\\n            if (getBreak) {\\n                cont = item.ar.map(tag => tag.name).join('、')\\n                data.BuildList[index].data.push({\\n                    name: item.name,\\n                    cont: cont,\\n                    pics: item.al.picUrl,\\n                    mid: item.id,\\n                    id: 'netease'\\n                })\\n                saveFile(down, JSON.stringify(data), 0);\\n                toast('收录成功')\\n            }\\n            break;\\n    }\\n}\\n\\nconst getIncludedTencent = (item, input) => {\\n    switch (input) {\\n        case '创建歌单':\\n            return $(empty).rule((myname) => {\\n                setPageTitle('创建歌单')\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                CreateListParse(layout)\\n                setResult(layout);\\n            }, myname)\\n            break;\\n        default:\\n            down = 'hiker://files/rules/js/简单音乐.js'\\n            data = readFile(down);\\n            eval('data =' + data)\\n            getBreak = false\\n            data.BuildList.forEach((Item, x) => {\\n                if (input == Item.name) {\\n                    getBreak = true\\n                    index = x\\n                    storage0.putMyVar('自建歌单', item)\\n                    Item.data.forEach((Items, i) => {\\n                        if (Items.mid == item.mid && Items.id == 'tencent') {\\n                            putMyVar('BreakIndex', index)\\n                            putMyVar('BreakIndexs', i)\\n                            confirm({\\n                                title: \\\"收录覆盖\\\",\\n                                content: \\\"确定好了吗，歌曲将覆盖原有的\\\",\\n                                confirm: () => {\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\n                                    let dataMap = readFile(down);\\n                                    eval('dataMap =' + dataMap)\\n                                    let BuildList = dataMap.BuildList\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\n                                    let data = storage0.getMyVar('自建歌单')\\n                                    subtitle = ''\\n                                    if (data.subtitle) {\\n                                        subtitle = data.subtitle + '-'\\n                                    }\\n                                    singer = data.singer.map(tag => tag.name).join('、')\\n                                    img = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\n                                    if (data.album.mid) {\\n                                        img = 'https://y.gtimg.cn/music/photo_new/T002R300x300M000' + data.album.mid + '.jpg'\\n                                    }\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\n                                        name: data.title,\\n                                        cont: subtitle + singer,\\n                                        pics: img,\\n                                        mid: data.mid,\\n                                        id: 'tencent'\\n                                    }\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\n                                    toast('覆盖成功')\\n                                }\\n                            })\\n                            getBreak = false\\n                        }\\n                    })\\n                }\\n            })\\n            if (getBreak) {\\n                subtitle = ''\\n                if (item.subtitle) {\\n                    subtitle = item.subtitle + '-'\\n                }\\n                singer = item.singer.map(tag => tag.name).join('、')\\n                img = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\n                if (item.album.mid) {\\n                    img = 'https://y.gtimg.cn/music/photo_new/T002R300x300M000' + item.album.mid + '.jpg'\\n                }\\n                data.BuildList[index].data.push({\\n                    name: item.title,\\n                    cont: subtitle + singer,\\n                    pics: img,\\n                    mid: item.mid,\\n                    id: 'tencent'\\n                })\\n                saveFile(down, JSON.stringify(data), 0);\\n                toast('收录成功')\\n            }\\n            break;\\n    }\\n}\\n\\nconst getIncludedKwmusiccar = (item, pics, input) => {\\n    switch (input) {\\n        case '创建歌单':\\n            return $(empty).rule((myname) => {\\n                setPageTitle('创建歌单')\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                CreateListParse(layout)\\n                setResult(layout);\\n            }, myname)\\n            break;\\n        default:\\n            down = 'hiker://files/rules/js/简单音乐.js'\\n            data = readFile(down);\\n            eval('data =' + data)\\n            getBreak = false\\n            data.BuildList.forEach((Item, x) => {\\n                if (input == Item.name) {\\n                    getBreak = true\\n                    index = x\\n                    storage0.putMyVar('自建歌单', item)\\n                    putMyVar('KwmusicPics', pics)\\n                    Item.data.forEach((Items, i) => {\\n                        if (Items.mid == item.id && Items.id == 'kuwo') {\\n                            putMyVar('BreakIndex', index)\\n                            putMyVar('BreakIndexs', i)\\n                            confirm({\\n                                title: \\\"收录覆盖\\\",\\n                                content: \\\"确定好了吗，歌曲将覆盖原有的\\\",\\n                                confirm: () => {\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\n                                    let dataMap = readFile(down);\\n                                    eval('dataMap =' + dataMap)\\n                                    let BuildList = dataMap.BuildList\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\n                                    let data = storage0.getMyVar('自建歌单')\\n                                    subtitle = ''\\n                                    if (data.artist_name) {\\n                                        subtitle = data.artist_name + '-'\\n                                    }\\n                                    singer = ''\\n                                    if (data.album_name) {\\n                                        singer = data.album_name\\n                                    }\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\n                                        name: data.name,\\n                                        cont: subtitle + singer,\\n                                        pics: getMyVar('KwmusicPics'),\\n                                        mid: data.id,\\n                                        id: 'kuwo'\\n                                    }\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\n                                    toast('覆盖成功')\\n                                }\\n                            })\\n                            getBreak = false\\n                        }\\n                    })\\n                }\\n            })\\n            if (getBreak) {\\n                subtitle = ''\\n                if (item.artist_name) {\\n                    subtitle = item.artist_name + '-'\\n                }\\n                singer = ''\\n                if (item.album_name) {\\n                    singer = item.album_name\\n                }\\n                data.BuildList[index].data.push({\\n                    name: item.name,\\n                    cont: subtitle + singer,\\n                    pics: pics,\\n                    mid: item.id,\\n                    id: 'kuwo'\\n                })\\n                saveFile(down, JSON.stringify(data), 0);\\n                toast('收录成功')\\n            }\\n            break;\\n    }\\n}\\n\\nconst getIncludedKugou = (date, item, i, input) => {\\n    switch (input) {\\n        case '创建歌单':\\n            return $(empty).rule((myname) => {\\n                setPageTitle('创建歌单')\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                CreateListParse(layout)\\n                setResult(layout);\\n            }, myname)\\n            break;\\n        default:\\n            down = 'hiker://files/rules/js/简单音乐.js'\\n            data = readFile(down);\\n            eval('data =' + data)\\n            getBreak = false\\n            data.BuildList.forEach((Item, x) => {\\n                if (input == Item.name) {\\n                    getBreak = true\\n                    index = x\\n                    storage0.putMyVar('自建歌单', item)\\n                    storage0.putMyVar('自建Play', date[i])\\n                    Item.data.forEach((Items, l) => {\\n                        if (Items.mid.hash == date[i].hash && Items.id == 'kugou') {\\n                            putMyVar('BreakIndex', index)\\n                            putMyVar('BreakIndexs', l)\\n                            confirm({\\n                                title: \\\"收录覆盖\\\",\\n                                content: \\\"确定好了吗，歌曲将覆盖原有的\\\",\\n                                confirm: () => {\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\n                                    let dataMap = readFile(down);\\n                                    eval('dataMap =' + dataMap)\\n                                    let BuildList = dataMap.BuildList\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\n                                    let data = storage0.getMyVar('自建歌单')\\n                                    let date = storage0.getMyVar('自建Play')\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\n                                        name: date.filename,\\n                                        pics: data.img,\\n                                        mid: date,\\n                                        id: 'kugou'\\n                                    }\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\n                                    toast('覆盖成功')\\n                                }\\n                            })\\n                            getBreak = false\\n                        }\\n                    })\\n                }\\n            })\\n            if (getBreak) {\\n                data.BuildList[index].data.push({\\n                    name: date[i].filename,\\n                    pics: item.img,\\n                    mid: date[i],\\n                    id: 'kugou'\\n                })\\n                saveFile(down, JSON.stringify(data), 0);\\n                toast('收录成功')\\n            }\\n            break;\\n    }\\n}\\n\\nconst getIncludedMigu = (item, input) => {\\n    switch (input) {\\n        case '创建歌单':\\n            return $(empty).rule((myname) => {\\n                setPageTitle('创建歌单')\\n                require('hiker://page/Config.view?rule=' + myname)\\n                let layout = [];\\n                CreateListParse(layout)\\n                setResult(layout);\\n            }, myname)\\n            break;\\n        default:\\n            down = 'hiker://files/rules/js/简单音乐.js'\\n            data = readFile(down);\\n            eval('data =' + data)\\n            getBreak = false\\n            data.BuildList.forEach((Item, x) => {\\n                if (input == Item.name) {\\n                    getBreak = true\\n                    index = x\\n                    storage0.putMyVar('自建歌单', item)\\n                    Item.data.forEach((Items, i) => {\\n                        if (Items.mid.copyrightId == item.copyrightId && Items.id == 'migu') {\\n                            putMyVar('BreakIndex', index)\\n                            putMyVar('BreakIndexs', i)\\n                            confirm({\\n                                title: \\\"收录覆盖\\\",\\n                                content: \\\"确定好了吗，歌曲将覆盖原有的\\\",\\n                                confirm: () => {\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\n                                    let dataMap = readFile(down);\\n                                    eval('dataMap =' + dataMap)\\n                                    let BuildList = dataMap.BuildList\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\n                                    let data = storage0.getMyVar('自建歌单')\\n                                    const MiguFill = (url) => {\\n                                        if (!/^(https?)/.test(url)) {\\n                                            return \\\"http://d.musicapp.migu.cn/\\\" + url;\\n                                        } else {\\n                                            return url;\\n                                        }\\n                                    }\\n                                    subtitle = ''\\n                                    if (data.album) {\\n                                        subtitle = data.album + '-'\\n                                    }\\n                                    singer = data.singerList.map(tag => tag.name).join('、')\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\n                                        name: data.songName,\\n                                        cont: subtitle + singer,\\n                                        pics: MiguFill(data.img1),\\n                                        mid: data,\\n                                        id: 'migu'\\n                                    }\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\n                                    toast('覆盖成功')\\n                                }\\n                            })\\n                            getBreak = false\\n                        }\\n                    })\\n                }\\n            })\\n            if (getBreak) {\\n                subtitle = ''\\n                if (item.album) {\\n                    subtitle = item.album + '-'\\n                }\\n                singer = item.singerList.map(tag => tag.name).join('、')\\n                data.BuildList[index].data.push({\\n                    name: item.songName,\\n                    cont: subtitle + singer,\\n                    pics: MiguFill(item.img1),\\n                    mid: item,\\n                    id: 'migu'\\n                })\\n                saveFile(down, JSON.stringify(data), 0);\\n                toast('收录成功')\\n            }\\n            break;\\n    }\\n}\\n\\nconst NetEaseParse = (layout, data) => {\\n    getIncludedParse(layout)\\n    try {\\n        if (data.length > 0) {\\n            data.forEach(item => {\\n                singer = item.ar.map(tag => tag.name).join('、')\\n                layout.push({\\n                    title: item.name,\\n                    desc: singer,\\n                    img: item.al.picUrl,\\n                    url: $(empty).lazyRule((item, myname, SelectMap) => {\\n                        require('hiker://page/Config.view?rule=' + myname)\\n                        switch (getMyVar('更多功能', SelectMap[1])) {\\n                            case SelectMap[0]:\\n                                getIncludedFun()\\n                                return $(upMap, index, '收录歌曲').select((item, myname) => {\\n                                    require('hiker://page/Config.view?rule=' + myname)\\n                                    return getIncludedNetEase(item, input)\\n                                }, item, myname)\\n                                break\\n                            default:\\n                                return getNetEasePlayer(item.id, item.name)\\n                                break\\n                        }\\n                    }, item, myname, SelectMap),\\n                    col_type: getItem('getColTypes', 'card_pic_3'),\\n                    extra: {\\n                        inheritTitle: false,\\n                        longClick: [{\\n                            title: '收录歌曲',\\n                            js: $.toString((item, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                getIncludedFun()\\n                                return $(upMap, index, '收录歌曲').select((item, myname) => {\\n                                    require('hiker://page/Config.view?rule=' + myname)\\n                                    return getIncludedNetEase(item, input)\\n                                }, item, myname)\\n                            }, item, myname)\\n                        }, {\\n                            title: '搜索 => ' + item.name,\\n                            js: $.toString((name, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getConfirmSearch(name)\\n                            }, item.name, myname)\\n                        }]\\n                    }\\n                })\\n            })\\n        } else {\\n            layout.push({\\n                title: Rich(Small(Gray('～～～啥也没有留下～～～'))),\\n                url: empty,\\n                col_type: 'text_center_1',\\n                extra: {\\n                    lineVisible: false\\n                }\\n            })\\n        }\\n    } catch (e) {\\n        toast('到底了哦')\\n    }\\n}\\n\\nconst TencentParse = (layout, data) => {\\n    getIncludedParse(layout)\\n    if (data.length > 0) {\\n        data.forEach(item => {\\n            subtitle = ''\\n            if (item.subtitle) {\\n                subtitle = item.subtitle + '-'\\n            }\\n            singer = item.singer.map(tag => tag.name).join('、')\\n            img = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\n            if (item.album.mid) {\\n                img = 'https://y.gtimg.cn/music/photo_new/T002R300x300M000' + item.album.mid + '.jpg'\\n            }\\n            layout.push({\\n                title: item.title,\\n                desc: subtitle + singer,\\n                img: img,\\n                url: $(empty).lazyRule((item, myname, SelectMap) => {\\n                    require('hiker://page/Config.view?rule=' + myname)\\n                    switch (getMyVar('更多功能', SelectMap[1])) {\\n                        case SelectMap[0]:\\n                            getIncludedFun()\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getIncludedTencent(item, input)\\n                            }, item, myname)\\n                            break\\n                        default:\\n                            return getTencentPlayer(item.mid, item.title)\\n                            break\\n                    }\\n                }, item, myname, SelectMap),\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\n                extra: {\\n                    inheritTitle: false,\\n                    longClick: [{\\n                        title: '收录歌曲',\\n                        js: $.toString((item, myname) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            getIncludedFun()\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getIncludedTencent(item, input)\\n                            }, item, myname)\\n                        }, item, myname)\\n                    }, {\\n                        title: '搜索 => ' + item.title,\\n                        js: $.toString((name, myname) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            return getConfirmSearch(name)\\n                        }, item.title, myname)\\n                    }]\\n                }\\n            })\\n        })\\n    } else {\\n        layout.push({\\n            title: Rich(Small(Gray('～～～啥也没有留下～～～'))),\\n            url: empty,\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false\\n            }\\n        })\\n    }\\n}\\n\\nconst KwmusiccarParse = (layout, data) => {\\n    getIncludedParse(layout)\\n    try {\\n        if (data.length > 0) {\\n            datas = data\\n            if (getMyVar('switch', '0') == '1') {\\n                data = data.map(item => {\\n                    return KwmusiccarConfig('music/info/' + item.id).info\\n                })\\n            }\\n            data.forEach((item, i) => {\\n                subtitle = ''\\n                if (datas[i].artist_name) {\\n                    subtitle = datas[i].artist_name + '-'\\n                }\\n                singer = ''\\n                if (datas[i].album_name) {\\n                    singer = datas[i].album_name\\n                }\\n                layout.push({\\n                    title: datas[i].name,\\n                    desc: subtitle + singer,\\n                    img: item.pic || 'https://missuo.ru/file/51e785d34aba81f61994f.jpg',\\n                    url: $(empty).lazyRule((item, pics, myname, SelectMap) => {\\n                        require('hiker://page/Config.view?rule=' + myname)\\n                        switch (getMyVar('更多功能', SelectMap[1])) {\\n                            case SelectMap[0]:\\n                                getIncludedFun()\\n                                return $(upMap, index, '收录歌曲').select((item, pics, myname) => {\\n                                    require('hiker://page/Config.view?rule=' + myname)\\n                                    return getIncludedKwmusiccar(item, pics, input)\\n                                }, item, pics, myname)\\n                                break\\n                            default:\\n                                return getKwmusiccarPlayer(item.id)\\n                                break\\n                        }\\n                    }, datas[i], item.pic, myname, SelectMap),\\n                    col_type: getItem('getColTypes', 'card_pic_3'),\\n                    extra: {\\n                        inheritTitle: false,\\n                        longClick: [{\\n                            title: '收录歌曲',\\n                            js: $.toString((item, pics, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                getIncludedFun()\\n                                return $(upMap, index, '收录歌曲').select((item, pics, myname) => {\\n                                    require('hiker://page/Config.view?rule=' + myname)\\n                                    return getIncludedKwmusiccar(item, pics, input)\\n                                }, item, pics, myname)\\n                            }, datas[i], item.pic, myname)\\n                        }, {\\n                            title: '搜索 => ' + datas[i].name,\\n                            js: $.toString((name, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getConfirmSearch(name)\\n                            }, datas[i].name, myname)\\n                        }]\\n                    }\\n                })\\n            })\\n        }\\n    } catch (e) {\\n        toast('糟糕API崩溃了')\\n    }\\n}\\n\\nconst KugouParse = (layout, data) => {\\n    getIncludedParse(layout)\\n    if (data.length > 0) {\\n        let KugouMap = data.map(item => {\\n            return KugouConfig(item)\\n        })\\n        KugouMap.forEach((item, i) => {\\n            layout.push({\\n                title: data[i].filename,\\n                img: item.img || 'https://missuo.ru/file/51e785d34aba81f61994f.jpg',\\n                url: $(empty).lazyRule((data, item, myname, SelectMap, i) => {\\n                    require('hiker://page/Config.view?rule=' + myname)\\n                    switch (getMyVar('更多功能', SelectMap[1])) {\\n                        case SelectMap[0]:\\n                            getIncludedFun()\\n                            return $(upMap, index, '收录歌曲').select((data, item, i, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getIncludedKugou(data, item, i, input)\\n                            }, data, item, i, myname)\\n                            break\\n                        default:\\n                            return getKugouPlayer(data[i], data[i].filename)\\n                            break\\n                    }\\n                }, data, item, myname, SelectMap, i),\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\n                extra: {\\n                    inheritTitle: false,\\n                    longClick: [{\\n                        title: '收录歌曲',\\n                        js: $.toString((data, item, myname, i) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            getIncludedFun()\\n                            return $(upMap, index, '收录歌曲').select((data, item, i, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getIncludedKugou(data, item, i, input)\\n                            }, data, item, i, myname)\\n                        }, data, item, myname, i)\\n                    }, {\\n                        title: '搜索 => ' + data[i].filename,\\n                        js: $.toString((name, myname) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            return getConfirmSearch(name)\\n                        }, data[i].filename, myname)\\n                    }]\\n                }\\n            })\\n        })\\n    }\\n}\\n\\nconst MiguParse = (layout, data) => {\\n    getIncludedParse(layout)\\n    if (data.length > 0) {\\n        data.forEach(item => {\\n            subtitle = ''\\n            if (item.album) {\\n                subtitle = item.album + '-'\\n            }\\n            singer = item.singerList || item.singers\\n            singer = singer.map(tag => tag.name).join('、')\\n            layout.push({\\n                title: item.songName || item.name,\\n                desc: subtitle + singer,\\n                img: MiguFill(item.img1 || item.imgItems[0].img),\\n                url: $(empty).lazyRule((item, myname, SelectMap) => {\\n                    require('hiker://page/Config.view?rule=' + myname)\\n                    switch (getMyVar('更多功能', SelectMap[1])) {\\n                        case SelectMap[0]:\\n                            getIncludedFun()\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getIncludedMigu(item, input)\\n                            }, item, myname)\\n                            break\\n                        default:\\n                            return getMiguPlayer(item, (item.songName || item.name))\\n                            break\\n                    }\\n                }, item, myname, SelectMap),\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\n                extra: {\\n                    inheritTitle: false,\\n                    longClick: [{\\n                        title: '收录歌曲',\\n                        js: $.toString((item, myname) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            getIncludedFun()\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\n                                require('hiker://page/Config.view?rule=' + myname)\\n                                return getIncludedMigu(item, input)\\n                            }, item, myname)\\n                        }, item, myname)\\n                    }, {\\n                        title: '搜索 => ' + (item.songName || item.name),\\n                        js: $.toString((name, myname) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            return getConfirmSearch(name)\\n                        }, (item.songName || item.name), myname)\\n                    }]\\n                }\\n            })\\n        })\\n    }\\n}\\n\\nconst getBuildListMap = (SelectMap, index, item, indexs) => {\\n    down = 'hiker://files/rules/js/简单音乐.js'\\n    data = readFile(down);\\n    eval('data =' + data)\\n    if (data.BuildList == null) {\\n        data.BuildList = []\\n        saveFile(down, JSON.stringify(data), 0);\\n        eval('data =' + readFile(down))\\n    }\\n    putMyVar('indexConfirm', index)\\n    putMyVar('indexsConfirm', indexs)\\n    switch (getMyVar('收录功能', SelectMap[SelectMap.length - 1])) {\\n        case SelectMap[0]:\\n            return $(empty).lazyRule((empty) => {\\n                confirm({\\n                    title: \\\"歌曲删除\\\",\\n                    content: \\\"确定好了吗，该歌曲将删除\\\",\\n                    confirm: () => {\\n                        index = getMyVar('indexConfirm')\\n                        indexs = getMyVar('indexsConfirm')\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\n                        dataMap = readFile(down);\\n                        eval('dataMap =' + dataMap)\\n                        dataMap.BuildList[indexs].data.splice(index, 1)\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\n                        refreshPage(false)\\n                        toast('删除成功');\\n                    }\\n                })\\n                return empty\\n            }, empty)\\n            break;\\n        case SelectMap[1]:\\n            putMyVar('getMove', index)\\n            refreshPage(false)\\n            break;\\n        case SelectMap[2]:\\n            names = data.BuildList.map(it => it.name)\\n            upMap = names.concat(['创建歌单'])\\n            index = 1\\n            if (upMap.length > 2) {\\n                index = 2\\n            }\\n            return $(upMap, index, SelectMap[2]).select((myname, empty) => {\\n                switch (input) {\\n                    case '创建歌单':\\n                        return $(empty).rule((myname) => {\\n                            setPageTitle('创建歌单')\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            let layout = [];\\n                            CreateListParse(layout)\\n                            setResult(layout);\\n                        }, myname)\\n                        break;\\n                    default:\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\n                        eval('dataMap =' + readFile(down))\\n                        Index = getMyVar('indexConfirm')\\n                        Indexs = getMyVar('indexsConfirm')\\n                        item = dataMap.BuildList[Indexs].data[Index]\\n                        getBreak = false\\n                        dataMap.BuildList.forEach((Item, x) => {\\n                            if (input == Item.name) {\\n                                getBreak = true\\n                                index = x\\n                                storage0.putMyVar('自建歌单', item)\\n                                Item.data.forEach((Items, i) => {\\n                                    if (Items.name == item.name) {\\n                                        putMyVar('BreakIndex', index)\\n                                        putMyVar('BreakIndexs', i)\\n                                        confirm({\\n                                            title: \\\"收录覆盖\\\",\\n                                            content: \\\"确定好了吗，歌曲将覆盖原有的\\\",\\n                                            confirm: () => {\\n                                                let down = 'hiker://files/rules/js/简单音乐.js'\\n                                                eval('dataMap =' + readFile(down))\\n                                                Index = getMyVar('indexConfirm')\\n                                                Indexs = getMyVar('indexsConfirm')\\n                                                index = getMyVar('BreakIndex')\\n                                                indexs = getMyVar('BreakIndexs')\\n                                                let BuildList = dataMap.BuildList\\n                                                BuildList = BuildList[index].data\\n                                                BuildList[indexs] = storage0.getMyVar('自建歌单')\\n                                                if (Indexs != index) {\\n                                                    dataMap.BuildList[Indexs].data.splice(Index, 1)\\n                                                }\\n                                                saveFile(down, JSON.stringify(dataMap), 0);\\n                                                toast('覆盖成功')\\n                                                refreshPage(false)\\n                                            }\\n                                        })\\n                                        getBreak = false\\n                                    }\\n                                })\\n                            }\\n                        })\\n                        if (getBreak) {\\n                            dataMap.BuildList[Indexs].data.splice(Index, 1)\\n                            dataMap.BuildList[index].data.push(item)\\n                            saveFile(down, JSON.stringify(dataMap), 0);\\n                            toast('更换成功')\\n                            refreshPage(false)\\n                        }\\n                        break;\\n                }\\n            }, myname, empty)\\n            break;\\n        default:\\n            return $(empty).lazyRule((item, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                switch (item.id) {\\n                    case 'netease':\\n                        return getNetEasePlayer(item.mid, item.name)\\n                        break\\n                    case 'tencent':\\n                        return getTencentPlayer(item.mid, item.name)\\n                        break\\n                    case 'kuwo':\\n                        return getKwmusiccarPlayer(item.mid)\\n                        break\\n                    case 'kugou':\\n                        return getKugouPlayer(item.mid, item.name)\\n                        break\\n                    case 'migu':\\n                        return getMiguPlayer(item.mid, item.name)\\n                        break\\n                }\\n            }, item, myname)\\n    }\\n    return empty\\n}\\n\\nconst BuildListParse = (layout, index) => {\\n    getConfirm()\\n    SelectMap = ['删除歌曲', '歌曲移动', '更换歌单', '聆听歌曲']\\n    addListener('onRefresh', $.toString(() => {\\n        switch (getMyVar('更多', '0')) {\\n            case '0':\\n                putMyVar('更多', 1);\\n                break;\\n            default:\\n                putMyVar('更多', 0);\\n                break;\\n        }\\n    }));\\n    addListener('onClose', () => {\\n        clearMyVar('更多')\\n    })\\n    if (getMyVar('更多', '0') == 1) {\\n        layout.push({\\n            col_type: 'line_blank'\\n        }, {\\n            title: Rich(Small(Gray('～～～更多选项～～～'))),\\n            url: $(SelectMap, 2, '已选择-' + '[' + getMyVar('收录功能', SelectMap[SelectMap.length - 1]) + ']').select((empty) => {\\n                putMyVar('收录功能', input)\\n                refreshPage()\\n                return empty\\n            }, empty),\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false\\n            }\\n        }, {\\n            col_type: 'line_blank'\\n        })\\n    }\\n    down = 'hiker://files/rules/js/简单音乐.js'\\n    dataMap = readFile(down);\\n    eval('dataMap =' + dataMap)\\n    data = dataMap.BuildList[index].data\\n    if (data.length != 0) {\\n        data.forEach((item, i) => {\\n            name = item.name\\n            select = $(empty + '#noLoading#').lazyRule((SelectMap, i, item, index, myname) => {\\n                require('hiker://page/Config.view?rule=' + myname)\\n                clearMyVar('switch')\\n                return getBuildListMap(SelectMap, i, item, index)\\n            }, SelectMap, i, item, index, myname)\\n            if (getMyVar('getMove', '')) {\\n                if (getMyVar('getMove', '') == i) {\\n                    name = Rich(Small(SpringGreen(name)))\\n                }\\n                select = $(empty).lazyRule((index, i, myname) => {\\n                    require('hiker://page/Config.view?rule=' + myname)\\n                    down = 'hiker://files/rules/js/简单音乐.js'\\n                    eval('dataMap =' + readFile(down))\\n                    indexs = Number(getMyVar('getMove'))\\n                    getMove(dataMap.BuildList[index].data, indexs, i)\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\n                    clearMyVar('getMove')\\n                    refreshPage(false)\\n                    return empty\\n                }, index, i, myname)\\n            }\\n            layout.push({\\n                title: name,\\n                desc: item.cont,\\n                img: item.pics || 'https://missuo.ru/file/51e785d34aba81f61994f.jpg',\\n                url: select,\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\n                extra: {\\n                    inheritTitle: false,\\n                    longClick: [{\\n                        title: '搜索 => ' + item.name,\\n                        js: $.toString((name, myname) => {\\n                            require('hiker://page/Config.view?rule=' + myname)\\n                            return getConfirmSearch(name)\\n                        }, item.name, myname)\\n                    }, {\\n                        title: '删除',\\n                        js: $.toString((index, indexs) => {\\n                            putMyVar('indexConfirm', index)\\n                            putMyVar('indexsConfirm', indexs)\\n                            confirm({\\n                                title: \\\"歌曲删除\\\",\\n                                content: \\\"确定好了吗，该歌曲将删除\\\",\\n                                confirm: () => {\\n                                    index = getMyVar('indexConfirm')\\n                                    indexs = getMyVar('indexsConfirm')\\n                                    down = 'hiker://files/rules/js/简单音乐.js'\\n                                    dataMap = readFile(down);\\n                                    eval('dataMap =' + dataMap)\\n                                    dataMap.BuildList[indexs].data.splice(index, 1)\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\n                                    refreshPage(false)\\n                                    toast('删除成功');\\n                                }\\n                            })\\n                        }, i, index)\\n                    }, {\\n                        title: '置顶',\\n                        js: $.toString((name, indexs) => {\\n                            let down = 'hiker://files/rules/js/简单音乐.js'\\n                            eval('dataMap =' + readFile(down))\\n                            let obj = {};\\n                            dataMap.BuildList[indexs].data.forEach((item, index) => {\\n                                if (item.name === name) {\\n                                    obj = item;\\n                                    dataMap.BuildList[indexs].data.splice(index, 1)\\n                                    return;\\n                                }\\n                            })\\n                            dataMap.BuildList[indexs].data.unshift(obj);\\n                            saveFile(down, JSON.stringify(dataMap), 0);\\n                            refreshPage(false)\\n                        }, item.name, index)\\n                    }, {\\n                        title: '置底',\\n                        js: $.toString((name, indexs) => {\\n                            let down = 'hiker://files/rules/js/简单音乐.js'\\n                            eval('dataMap =' + readFile(down))\\n                            let obj = {};\\n                            dataMap.BuildList[indexs].data.forEach((item, index) => {\\n                                if (item.name === name) {\\n                                    obj = item;\\n                                    dataMap.BuildList[indexs].data.splice(index, 1)\\n                                    return;\\n                                }\\n                            })\\n                            dataMap.BuildList[indexs].data.push(obj);\\n                            saveFile(down, JSON.stringify(dataMap), 0);\\n                            refreshPage(false)\\n                        }, item.name, index)\\n                    }]\\n                }\\n            })\\n        })\\n    } else {\\n        layout.push({\\n            title: Rich(Small(Gray('～～～啥也没有哦～～～'))),\\n            url: empty,\\n            col_type: 'text_center_1',\\n            extra: {\\n                lineVisible: false\\n            }\\n        })\\n    }\\n}\\n\\nconst CreateListParse = (layout) => {\\n    layout.push({\\n        desc: \\\"请输入歌单名称\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            type: 'textarea',\\n            height: 3,\\n            onChange: \\\"setItem('名称', input)\\\",\\n            titleVisible: false\\n        }\\n    }, {\\n        desc: \\\"请输入歌单封面（非必填）\\\",\\n        col_type: \\\"input\\\",\\n        extra: {\\n            type: 'textarea',\\n            height: 3,\\n            onChange: \\\"setItem('封面', input)\\\",\\n            titleVisible: false\\n        }\\n    }, {\\n        title: Rich(Strong(Gray('创建歌单'))),\\n        url: $(empty).lazyRule((empty) => {\\n            down = 'hiker://files/rules/js/简单音乐.js'\\n            data = readFile(down);\\n            eval('data =' + data)\\n            pics = getItem('封面')\\n            name = getItem('名称')\\n            getBreak = true\\n            if (name != undefined && name != '') {\\n                data.BuildList.forEach(item => {\\n                    if (name == item.name) {\\n                        getBreak = false\\n                    }\\n                })\\n            } else {\\n                getBreak = false\\n            }\\n            if (getBreak) {\\n                if (pics == undefined || pics == '') {\\n                    pics = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\n                }\\n                dataMusic = {\\n                    name: name,\\n                    pics: pics,\\n                    data: []\\n                }\\n                data.BuildList.push(dataMusic)\\n                saveFile(down, JSON.stringify(data), 0);\\n            } else {\\n                toast('创建失败！！')\\n            }\\n            back()\\n            return empty\\n        }, empty),\\n        col_type: 'text_center_1',\\n        extra: {\\n            lineVisible: false\\n        }\\n    })\\n}\\n\\nconst getEditParse = (layout, i, item) => {\\n    layout.push({\\n        desc: item.name,\\n        col_type: \\\"input\\\",\\n        extra: {\\n            type: 'textarea',\\n            height: 3,\\n            onChange: \\\"setItem('名称', input)\\\",\\n            titleVisible: false\\n        }\\n    }, {\\n        desc: item.pics,\\n        col_type: \\\"input\\\",\\n        extra: {\\n            type: 'textarea',\\n            height: 3,\\n            onChange: \\\"setItem('封面', input)\\\",\\n            titleVisible: false\\n        }\\n    }, {\\n        title: Rich(Strong(Gray('确认修改'))),\\n        url: $(empty).lazyRule((empty, i) => {\\n            down = 'hiker://files/rules/js/简单音乐.js'\\n            data = readFile(down);\\n            eval('data =' + data)\\n            pics = getItem('封面')\\n            name = getItem('名称')\\n            getBreak = true\\n            index = ''\\n            if (name != undefined) {\\n                data.BuildList.forEach((item, x) => {\\n                    if (name == item.name) {\\n                        getBreak = false\\n                        index = x\\n                    }\\n                })\\n            } else {\\n                getBreak = false\\n            }\\n            if (getBreak || index == i) {\\n                if (pics == undefined || pics == '') {\\n                    pics = data.BuildList[i].pics\\n                }\\n                if (name == '') {\\n                    name = data.BuildList[i].name\\n                }\\n                data.BuildList[i].name = name\\n                data.BuildList[i].pics = pics\\n                saveFile(down, JSON.stringify(data), 0);\\n            } else {\\n                toast('修改失败！！！')\\n            }\\n            back()\\n            return empty\\n        }, empty, i),\\n        col_type: 'text_center_1',\\n        extra: {\\n            lineVisible: false\\n        }\\n    })\\n}\\n\\nconst getConfirmSearch = (name) => {\\n    if (getMyVar('失败', 'false') == 'true' && getMyVar('switch', '0') == '0') {\\n        putMyVar('switch', '1')\\n        return \\\"hiker://page/Searchs.view?rule=\\\" + myname + \\\"&page=fypage&searchTerms=\\\" + encodeURIComponent(name);\\n    }\\n    toast('暂无资源')\\n    return empty\\n}\\n\\nconst getNetEasePlayer = (mid, name) => {\\n    musicUrl = '/api/song/enhance/player/url?br=320000&ids=[' + mid + ']'\\n    musicMap = NetEaseConfig(musicUrl, '', 'GET')\\n    lysicUrl = '/api/song/lyric?os=osx&id=' + mid + '&lv=-1&kv=-1&tv=-1'\\n    lysicMap = NetEaseConfig(lysicUrl, '', 'GET')\\n    if (musicMap.data[0].url) {\\n        return JSON.stringify({\\n            urls: [musicMap.data[0].url],\\n            lyric: lysicMap.lrc.lyric\\n        })\\n    }\\n    return getConfirmSearch(name)\\n}\\n\\nconst getTencentPlayer = (mid, name) => {\\n    let typeMap = {\\n        m4a: {\\n            s: 'C400',\\n            e: '.m4a',\\n        },\\n        128: {\\n            s: 'M500',\\n            e: '.mp3',\\n        },\\n        320: {\\n            s: 'M800',\\n            e: '.mp3',\\n        },\\n        ape: {\\n            s: 'A000',\\n            e: '.ape',\\n        },\\n        flac: {\\n            s: 'F000',\\n            e: '.flac',\\n        },\\n    };\\n    let time = new Date().getTime()\\n    let guid = (Math.random() * 10000000).toFixed(0);\\n    let typeObj = typeMap['128'];\\n    let file = typeObj.s + mid + mid + typeObj.e;\\n    let url = {\\n        '-': 'getplaysongvkey',\\n        g_tk: 5381,\\n        hostUin: 0,\\n        format: 'json',\\n        inCharset: 'utf8',\\n        outCharset: 'utf-8¬ice=0',\\n        platform: 'yqq.json',\\n        needNewCode: 0,\\n        data: JSON.stringify({\\n            req_0: {\\n                module: 'vkey.GetVkeyServer',\\n                method: 'CgiGetVkey',\\n                param: {\\n                    filename: [file],\\n                    guid: guid,\\n                    songmid: [mid],\\n                    songtype: [0],\\n                    uin: '',\\n                    loginflag: 1,\\n                    platform: '20',\\n                },\\n            },\\n            comm: {\\n                uin: '',\\n                format: 'json',\\n                ct: 19,\\n                cv: 0,\\n                authst: '',\\n            },\\n        }),\\n    }\\n    let result = buildUrl('https://u.y.qq.com/cgi-bin/musicu.fcg', url)\\n    result = JSON.parse(fetch(result))\\n    let purl = '';\\n    let domain = '';\\n    if (result.req_0 && result.req_0.data && result.req_0.data.midurlinfo) {\\n        purl = result.req_0.data.midurlinfo[0].purl;\\n    }\\n    if (domain === '') {\\n        domain = result.req_0.data.sip.find(i => !i.startsWith('http://ws')) || result.req_0.data.sip[0];\\n    }\\n    let lyrics = 'http://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg?songmid=' + mid + '&pcachetime=' + time + '&g_tk=5381&loginUin=0&hostUin=0&inCharset=utf8&outCharset=utf-8&notice=0&platform=yqq&needNewCode=0'\\n    lyrics = TencentConfig(lyrics).lyric\\n    if (lyrics) {\\n        lyrics = base64Decode(lyrics)\\n    } else {\\n        lyrics = ''\\n    }\\n    if (purl != '' && domain != '') {\\n        return JSON.stringify({\\n            urls: [domain + purl],\\n            lyric: lyrics\\n        })\\n    }\\n    return getConfirmSearch(name)\\n}\\n\\nconst getKwmusiccarPlayer = (mid) => {\\n    let lyric = KwmusiccarConfig('music/info/' + mid).lrc\\n    const getTime = (time) => {\\n        let h = parseInt(time / 60 / 60 % 24)\\n        h = h < 10 ? '0' + h : h\\n        let m = parseInt(time / 60 % 60)\\n        m = m < 10 ? '0' + m : m\\n        let s = parseInt(time % 60)\\n        s = s < 10 ? '0' + s : s\\n        return [m + ':' + s + '.00']\\n    }\\n    let api = 'http://antiserver.kuwo.cn/anti.s?type=convert_url3&format=mp3&response=url&rid='\\n    names = ['320k', '192k', '128k']\\n    let urls = []\\n    names.forEach(item => {\\n        urls.push({\\n            url: api + mid + '&br=' + item + 'mp3'\\n        })\\n    })\\n    urls = bf(urls).map(data => JSON.parse(data).url)\\n    lyric = lyric.map(i => '[' + getTime(i.time) + ']' + i.lineLyric).join('\\\\r\\\\n')\\n    return JSON.stringify({\\n        urls: urls,\\n        names: names,\\n        lyric: lyric\\n    })\\n}\\n\\nconst getKugouPlayer = (data, name) => {\\n    let MusicMap = KugouConfig(data)\\n    if (MusicMap.play_url) {\\n        return JSON.stringify({\\n            urls: [MusicMap.play_url],\\n            lyric: MusicMap.lyrics\\n        })\\n    }\\n    return getConfirmSearch(name)\\n}\\n\\nconst getMiguPlayer = (item, name) => {\\n    let MusicUrl = 'https://app.c.nf.migu.cn/MIGUM2.0/v1.0/content/sub/listenSong.do?toneFlag=formatType=HQ&netType=00&userId=15548614588710179085069&ua=Android_migu&version=5.1&copyrightId=0&contentId=' + item.contentId + '&resourceType=2&channel=0'\\n    let MiguMusic = JSON.parse(request(MusicUrl, {\\n        onlyHeaders: true\\n    })).url\\n    let lyricUrl = 'http://music.migu.cn/v3/api/music/audioPlayer/getLyric?copyrightId=' + item.copyrightId\\n    let MiguLyric = MiguConfig(lyricUrl)\\n    if (MiguMusic.search('Key') >= 1) {\\n        return JSON.stringify({\\n            urls: [MiguMusic],\\n            lyric: MiguLyric.lyric\\n        })\\n    }\\n    return getConfirmSearch(name)\\n}\\n\\nconst getSearchParse = (layout) => {\\n    funMap = ['聚合搜索']\\n    switch (storage0.getMyVar('SearchMusicMap', funMap)[0]) {\\n        case funMap[0]:\\n            layout.push({\\n                title: '🔍',\\n                desc: \\\"请输入歌曲名称/关键词\\\",\\n                url: '\\\"hiker://search?s=\\\"+input',\\n                col_type: \\\"input\\\",\\n                extra: {\\n                    rules: $.toString(() => {\\n                        let data = [];\\n                        let searchMap = ['网易', '腾讯', '酷我', '酷狗', '咪咕'];\\n                        putMyVar('switch', '1')\\n                        searchMap.forEach((Map, i) => {\\n                            data.push({\\n                                \\\"title\\\": Map + '音乐',\\n                                \\\"search_url\\\": \\\"hiker://empty?searchTerms=**&page=fypage&index=\\\" + i,\\n                                \\\"searchFind\\\": \\\"js: $.require('hiker://page/Search.view?rule=简单音乐');\\\"\\n                            });\\n                        })\\n                        return JSON.stringify(data);\\n                    }),\\n                    defaultValue: getMyVar(\\\"searchKey\\\", \\\"\\\"),\\n                    onChange: \\\"putMyVar('searchKey',input)\\\"\\n                }\\n            });\\n            break;\\n        default:\\n            layout.push({\\n                title: '🔍',\\n                desc: \\\"请输入歌曲名称/关键词\\\",\\n                url: $.toString((myname) => {\\n                    let keywords = input.trim();\\n                    putMyVar('switch', '1')\\n                    if (keywords) {\\n                        return \\\"hiker://page/Searchs.view?rule=\\\" + myname + \\\"&page=fypage&searchTerms=\\\" + encodeURIComponent(keywords);\\n                    } else {\\n                        return \\\"toast://请输入关键词\\\";\\n                    }\\n                }, myname),\\n                col_type: \\\"input\\\",\\n                extra: {\\n                    defaultValue: getMyVar(\\\"searchKey\\\", \\\"\\\"),\\n                    onChange: \\\"putMyVar('searchKey',input)\\\"\\n                }\\n            })\\n            break;\\n    }\\n}\\n\\nconst getSearchsParse = (layout, page) => {\\n    addListener('onClose', () => {\\n        clearMyVar('searchMap')\\n        clearMyVar('switch')\\n    })\\n    indexs = getMyVar('searchMap', '0')\\n    keyword = decodeURIComponent(getParam(\\\"searchTerms\\\"));\\n    setPageTitle(\\\"「\\\" + keyword + \\\"」#\\\" + page);\\n    if (page === 1) {\\n        searchMap = ['网易', '腾讯', '酷我', '酷狗', '咪咕'];\\n        searchMap.forEach((item, index) => {\\n            layout.push({\\n                title: index == indexs ? Rich(Strong(Color(item))) : item,\\n                url: $('#noLoading#').lazyRule((empty, index) => {\\n                    putMyVar('searchMap', index);\\n                    refreshPage();\\n                    return empty;\\n                }, empty, index),\\n                col_type: 'text_5'\\n            })\\n        })\\n    }\\n    getSearchSelection(layout, indexs, keyword, page)\\n}\\n\\nconst getSearchSelection = (layout, index, keyword, page) => {\\n    switch (index) {\\n        case '0':\\n            path = '/weapi/cloudsearch/get/web?csrf_token='\\n            body = {\\n                's': keyword,\\n                'limit': 30,\\n                'type': 1,\\n                'offset': (page - 1) * 30,\\n                'csrf_token': ''\\n            }\\n            data = NetEaseConfig(path, body, 'POST').result.songs\\n            NetEaseParse(layout, data)\\n            break;\\n        case '1':\\n            path = 'https://u.y.qq.com/cgi-bin/musicu.fcg'\\n            body = {\\n                \\\"req_1\\\": {\\n                    \\\"method\\\": \\\"DoSearchForQQMusicDesktop\\\",\\n                    \\\"module\\\": \\\"music.search.SearchCgiService\\\",\\n                    \\\"param\\\": {\\n                        \\\"num_per_page\\\": 20,\\n                        \\\"page_num\\\": page,\\n                        \\\"query\\\": keyword,\\n                        \\\"search_type\\\": 0\\n                    }\\n                }\\n            }\\n            data = request(path, {\\n                headers: {\\n                    'Referer': 'https://y.qq.com'\\n                },\\n                body: body,\\n                method: 'POST'\\n            })\\n            data = JSON.parse(data).req_1.data.body.song.list\\n            TencentParse(layout, data)\\n            break;\\n        case '2':\\n            path = 'search/music?key=' + keyword + '&pn=' + page\\n            data = KwmusiccarConfig(path)\\n            KwmusiccarParse(layout, data)\\n            break;\\n        case '3':\\n            path = 'http://mobilecdn.kugou.com/api/v3/search/song?format=json&keyword=' + keyword + '&page=' + page + '&pagesize=20&showtype=1'\\n            data = JSON.parse(request(path)).data.info\\n            KugouParse(layout, data)\\n            break;\\n        case '4':\\n            path = 'http://pd.musicapp.migu.cn/MIGUM2.0/v1.0/content/search_all.do?&ua=Android_migu&version=5.0.1&text=' + keyword + '&pageNo=' + page + '&pageSize=10&searchSwitch='\\n            body = {\\n                \\\"song\\\": 1,\\n                \\\"album\\\": 0,\\n                \\\"singer\\\": 0,\\n                \\\"tagSong\\\": 0,\\n                \\\"mvSong\\\": 0,\\n                \\\"songlist\\\": 0,\\n                \\\"bestShow\\\": 1\\n            }\\n            data = MiguConfig(path + JSON.stringify(body)).songResultData.result\\n            MiguParse(layout, data)\\n            break;\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"聚合\",\"path\":\"Search.view\",\"rule\":\"require('hiker://page/Config.view?rule=' + '简单音乐')\\nconst keyword = getParam(\\\"searchTerms\\\") || \\\"\\\";\\nconst index = getParam(\\\"index\\\") || \\\"0\\\";\\nconst page = MY_PAGE;\\nconst layout = []\\nclearMyVar('更多功能')\\ngetSearchSelection(layout, index, keyword, page)\\nsetResult(layout)\"},{\"col_type\":\"movie_3\",\"name\":\"原生\",\"path\":\"Searchs.view\",\"rule\":\"js:\\nrequire('hiker://page/Config.view?rule=' + '简单音乐')\\nconst page = MY_PAGE;\\nconst layout = []\\ngetSearchsParse(layout, page)\\nsetResult(layout)\"}],\"params\":\"{\\\"inheritTitle\\\":false,\\\"longClick\\\":[{\\\"js\\\":\\\"(\\\\n(MusicMap, mid, name) => {\\\\n    getCopy = getMyVar(\\\\\\\"BuildMusic\\\\\\\", MusicMap[0]) + \\\\\\\"\\\\\\\\n\\\\\\\\u6b4c\\\\\\\\u5355\\\\\\\\u540d\\\\\\\\u79f0\\\\\\\\uff1a\\\\\\\" + name + \\\\\\\"\\\\\\\\n\\\\\\\\u6b4c\\\\\\\\u5355\\\\\\\\u8bc6\\\\\\\\u522b\\\\\\\\uff1a\\\\\\\" + base64Encode(\\\\\\\"\\\\\\\" + mid + \\\\\\\"\\\\\\\");\\\\n    copy(getCopy);\\\\n}\\\\n)([\\\\\\\"网易歌单\\\\\\\",\\\\\\\"腾讯歌单\\\\\\\",\\\\\\\"酷我歌单\\\\\\\",\\\\\\\"酷狗歌单\\\\\\\",\\\\\\\"咪咕歌单\\\\\\\"],7786802346,\\\\\\\"我喜欢的音乐\\\\\\\")\\\",\\\"title\\\":\\\"歌单分享\\\"}]}\",\"saved\":false,\"title\":\"简单音乐\",\"version\":0,\"url\":\"hiker://empty#autoCache#fypage;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\",\"col_type\":\"movie_3\",\"find_rule\":\"js:(\\n(mid, MusicMap, myname) => {\\n    require(\\\"hiker://page/Config.view?rule=\\\" + myname);\\n    let page = MY_PAGE;\\n    let layout = [];\\n    switch (getMyVar(\\\"BuildMusic\\\", MusicMap[0])) {\\n      case MusicMap[0]:\\n        if (page == 1) {\\n            NetEaseMap = \\\"/api/v6/playlist/detail?id=\\\" + mid + \\\"&n=1000&limit=1000\\\";\\n            NetEaseMap = NetEaseConfig(NetEaseMap, \\\"\\\", \\\"GET\\\");\\n            try {\\n                NetEaseParse(layout, NetEaseMap.playlist.tracks);\\n            }\\n            catch (e) {\\n                layout.push({title: Rich(Small(Gray(\\\"\\\\uff5e\\\\uff5e\\\\uff5e\\\" + NetEaseMap.message + \\\"\\\\uff5e\\\\uff5e\\\\uff5e\\\"))), url: empty, col_type: \\\"text_center_1\\\", extra: {lineVisible: false}});\\n            }\\n        }\\n        break;\\n      case MusicMap[1]:\\n        if (page == 1) {\\n            TencentMap = TencentConfig(mid).Songlist.data.songlist;\\n            TencentParse(layout, TencentMap);\\n        }\\n        break;\\n      case MusicMap[2]:\\n        KwmusiccarUrl = \\\"music/playlist/\\\" + mid + \\\"?pn=\\\" + page + \\\"&rn=20&ua=&ip=\\\";\\n        try {\\n            KwmusiccarMap = KwmusiccarConfig(KwmusiccarUrl).musicList;\\n            KwmusiccarParse(layout, KwmusiccarMap);\\n        }\\n        catch (e) {\\n            toast(\\\"\\\\u7cdf\\\\u7cd5API\\\\u5d29\\\\u6e83\\\\u4e86\\\");\\n        }\\n        break;\\n      case MusicMap[3]:\\n        if (page == 1) {\\n            try {\\n                KugouUrl = \\\"https://m.kugou.com/plist/list/\\\" + mid + \\\"/?json=true\\\";\\n                KugouMap = JSON.parse(request(KugouUrl)).list.list.info;\\n                KugouParse(layout, KugouMap);\\n            }\\n            catch (e) {\\n                mid = pdfh(request(mid), \\\"body&&script,2&&Html\\\");\\n                mid = mid.match(/window\\\\.\\\\$output = ([\\\\S\\\\s].*);/)[1];\\n                KugouMap = JSON.parse(mid).info.songs;\\n                KugouParse(layout, KugouMap);\\n            }\\n        }\\n        break;\\n      default:\\n        MiguUrl = \\\"MIGUM3.0/resource/playlist/song/v2.0?pageNo=\\\" + page + \\\"&pageSize=50&playlistId=\\\" + mid;\\n        MiguMap = MiguConfig(MiguUrl).data.songList;\\n        MiguParse(layout, MiguMap);\\n        break;\\n    }\\n    setResult(layout);\\n}\\n)(7786802346,[\\\"网易歌单\\\",\\\"腾讯歌单\\\",\\\"酷我歌单\\\",\\\"酷狗歌单\\\",\\\"咪咕歌单\\\"],\\\"简单音乐\\\")\",\"group\":\"①推荐\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面\\\",\\\"path\\\":\\\"Config.view\\\",\\\"rule\\\":\\\"const empty = 'hiker://empty'\\\\nconst myname = '简单音乐'\\\\n\\\\nconst Color = (test) => {\\\\n    return test.fontcolor('#FA7298');\\\\n}\\\\n\\\\nconst SpringGreen = (test) => {\\\\n    return test.fontcolor('#3CB371');\\\\n}\\\\n\\\\nconst Strong = (test) => {\\\\n    return '<strong>' + test + '</strong>';\\\\n}\\\\n\\\\nconst Small = (test) => {\\\\n    return '<small>' + test + '</small>';\\\\n}\\\\n\\\\nconst Gray = (test) => {\\\\n    return \\\\\\\"<font color='gray'>\\\\\\\" + test + \\\\\\\"</font>\\\\\\\";\\\\n}\\\\n\\\\nconst Rich = (test) => {\\\\n    return \\\\\\\"‘‘’’\\\\\\\" + test;\\\\n}\\\\n\\\\nconst getMove = (arr, index, tindex) => {\\\\n    if (index > tindex) {\\\\n        arr.splice(tindex, 0, arr[index]);\\\\n        arr.splice(index + 1, 1)\\\\n    } else {\\\\n        arr.splice(tindex + 1, 0, arr[index]);\\\\n        arr.splice(index, 1)\\\\n    }\\\\n}\\\\n\\\\nconst aesEncrypt = (word) => {\\\\n    eval(getCryptoJS());\\\\n    let str_key = CryptoJS.enc.Utf8.parse(\\\\\\\"0CoJUm6Qyw8W8jud\\\\\\\");\\\\n    let str_iv = CryptoJS.enc.Utf8.parse('0102030405060708');\\\\n    let aes_str = CryptoJS.AES.encrypt(word, str_key, {\\\\n        iv: str_iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7\\\\n    }).toString();\\\\n    str_key = CryptoJS.enc.Utf8.parse(\\\\\\\"aaaabbbbccccdddd\\\\\\\");\\\\n    return CryptoJS.AES.encrypt(aes_str, str_key, {\\\\n        iv: str_iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7\\\\n    }).toString();\\\\n}\\\\n\\\\nconst NetEaseConfig = (path, body, method) => {\\\\n    NetEaseUrl = 'https://music.163.com'\\\\n    if (method != 'GET') {\\\\n        body = 'params=' + aesEncrypt(JSON.stringify(body)) + '&encSecKey=' + '814e4abf9c1c6a2af74a7ecca8843f3052626c5c054584352e3fd38a519bd659e687cf1c079e1aac5dd9d491af6b8abf92109862ada93dc7b0ef94a8ee79d557ff2a20512b87ce507e357861366b8542139c67896748852d4086104a8dfc99a2e2e0640b46a4357407b72407b2849b323425c6ed45a0222e69d551a2e59e15b7'\\\\n    }\\\\n    NetEaseMap = request(NetEaseUrl + path, {\\\\n        headers: {\\\\n            'Referer': NetEaseUrl,\\\\n            'Origin': NetEaseUrl,\\\\n            'Cookie': 'NMTID=00OQ5Vi-4NKTGfogEunoULh0Qy8PMsAAAGEbKo-Yg; os=pc'\\\\n        },\\\\n        body: body,\\\\n        method: method\\\\n    })\\\\n    return JSON.parse(NetEaseMap)\\\\n}\\\\n\\\\nconst TencentConfig = (mid) => {\\\\n    TencentUrl = mid;\\\\n    if (typeof mid == \\\\\\\"number\\\\\\\") {\\\\n        body = {\\\\n            \\\\\\\"Songlist\\\\\\\": {\\\\n                \\\\\\\"module\\\\\\\": \\\\\\\"music.srfDissInfo.DissInfo\\\\\\\",\\\\n                \\\\\\\"method\\\\\\\": \\\\\\\"CgiGetDiss\\\\\\\",\\\\n                \\\\\\\"param\\\\\\\": {\\\\n                    \\\\\\\"dirid\\\\\\\": 0,\\\\n                    \\\\\\\"from\\\\\\\": 15,\\\\n                    \\\\\\\"ctx\\\\\\\": 0,\\\\n                    \\\\\\\"onlysonglist\\\\\\\": 0,\\\\n                    \\\\\\\"orderlist\\\\\\\": 1,\\\\n                    \\\\\\\"tag\\\\\\\": 1,\\\\n                    \\\\\\\"rec_flag\\\\\\\": 1,\\\\n                    \\\\\\\"disstid\\\\\\\": mid,\\\\n                    \\\\\\\"new_format\\\\\\\": 1,\\\\n                    \\\\\\\"host_uin\\\\\\\": 0,\\\\n                    \\\\\\\"optype\\\\\\\": 2,\\\\n                    \\\\\\\"enc_host_uin\\\\\\\": \\\\\\\"0\\\\\\\"\\\\n                }\\\\n            },\\\\n            \\\\\\\"comm\\\\\\\": {\\\\n                \\\\\\\"ct\\\\\\\": \\\\\\\"1\\\\\\\",\\\\n                \\\\\\\"v\\\\\\\": \\\\\\\"90\\\\\\\",\\\\n                \\\\\\\"cv\\\\\\\": \\\\\\\"101805\\\\\\\",\\\\n                \\\\\\\"gzip\\\\\\\": \\\\\\\"0\\\\\\\"\\\\n            }\\\\n        }\\\\n        TencentUrl = 'http://u6.y.qq.com/cgi-bin/musicu.fcg?data=' + escape(JSON.stringify(body))\\\\n    }\\\\n    TencentMap = request(TencentUrl, {\\\\n        headers: {\\\\n            'Referer': 'https://y.qq.com/portal/player.html'\\\\n        }\\\\n    }).replace(/callback\\\\\\\\(|MusicJsonCallback\\\\\\\\(|jsonCallback\\\\\\\\(|\\\\\\\\)$/g, '')\\\\n    return JSON.parse(TencentMap)\\\\n}\\\\n\\\\nconst KwmusiccarConfig = (KwmusiccarUrl) => {\\\\n    let host = 'http://m.kuwo.cn/newh5app/'\\\\n    if (!getMyVar('Kwmusiccar')) {\\\\n        Cookie = fetchCookie(host + 'api/mobile/v1/home')\\\\n        Cookie = JSON.parse(Cookie)[0]\\\\n        putMyVar('Kwmusiccar', Cookie)\\\\n    }\\\\n    const x = (t) => {\\\\n        let e = getMyVar('Kwmusiccar'),\\\\n            n = e.indexOf(t + \\\\\\\"=\\\\\\\");\\\\n        if (-1 != n) {\\\\n            n = n + t.length + 1;\\\\n            let o = e.indexOf(\\\\\\\";\\\\\\\", n);\\\\n            return -1 == o && (o = e.length),\\\\n                unescape(e.substring(n, o))\\\\n        }\\\\n        return null\\\\n    }\\\\n    Token = md5(x(\\\\\\\"BAIDU_RANDOM\\\\\\\")).toUpperCase()\\\\n    KwmusiccarUrl = host + 'api/mobile/v1/' + KwmusiccarUrl\\\\n    KwmusiccarMap = request(KwmusiccarUrl, {\\\\n        headers: {\\\\n            'Referer': host,\\\\n            'Token': Token,\\\\n            'Cookie': getMyVar('Kwmusiccar')\\\\n        }\\\\n    })\\\\n    return JSON.parse(KwmusiccarMap).data\\\\n}\\\\n\\\\nconst KugouConfig = (data) => {\\\\n    let MusicUrl = 'http://www.kugou.com/yy/index.php?r=play/getdata&hash=' + data.hash + '&album_id=' + data.album_id\\\\n    let MusicMap = request(MusicUrl, {\\\\n        headers: {\\\\n            'Cookie': 'kg_mid=1'\\\\n        }\\\\n    })\\\\n    return JSON.parse(MusicMap).data\\\\n}\\\\n\\\\nconst MiguFill = (url) => {\\\\n    if (!/^(https?)/.test(url)) {\\\\n        return \\\\\\\"http://d.musicapp.migu.cn/\\\\\\\" + url;\\\\n    } else {\\\\n        return url;\\\\n    }\\\\n}\\\\n\\\\nconst MiguConfig = (MiguUrl) => {\\\\n    MiguHost = 'https://app.c.nf.migu.cn/'\\\\n    if (!/^(https?)/.test(MiguUrl)) {\\\\n        MiguUrl = MiguHost + MiguUrl\\\\n    }\\\\n    MiguMap = request(MiguUrl, {\\\\n        headers: {\\\\n            'Referer': MiguHost\\\\n        }\\\\n    })\\\\n    return JSON.parse(MiguMap)\\\\n}\\\\n\\\\nconst getSelectMap = (MusicMap, SelectMap, i, mid, name) => {\\\\n    switch (getItem('getUpMap', SelectMap[SelectMap.length - 1])) {\\\\n        case SelectMap[0]:\\\\n            getCopy = getMyVar('BuildMusic', MusicMap[0]) + '\\\\\\\\n歌单名称：' + name + '\\\\\\\\n歌单识别：' + base64Encode('' + mid + '')\\\\n            copy(getCopy)\\\\n            break;\\\\n        case SelectMap[1]:\\\\n            return $(empty).lazyRule((empty, MusicMap, i) => {\\\\n                storage0.putMyVar('MusicMapConfirm', MusicMap)\\\\n                putMyVar('indexConfirm', i)\\\\n                confirm({\\\\n                    title: \\\\\\\"歌单删除\\\\\\\",\\\\n                    content: \\\\\\\"确定好了吗，该歌单将删除\\\\\\\",\\\\n                    confirm: () => {\\\\n                        MusicMap = storage0.getMyVar('MusicMapConfirm')\\\\n                        i = getMyVar('indexConfirm')\\\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        dataMap = readFile(down);\\\\n                        eval('dataMap =' + dataMap)\\\\n                        switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n                            case MusicMap[0]:\\\\n                                dataMap.BuildMusic.NetEase.splice(i, 1)\\\\n                                break;\\\\n                            case MusicMap[1]:\\\\n                                dataMap.BuildMusic.Tencent.splice(i, 1)\\\\n                                break;\\\\n                            case MusicMap[2]:\\\\n                                dataMap.BuildMusic.Kwmusiccar.splice(i, 1)\\\\n                                break;\\\\n                            case MusicMap[3]:\\\\n                                dataMap.BuildMusic.Kugou.splice(i, 1)\\\\n                                break;\\\\n                            default:\\\\n                                dataMap.BuildMusic.Migu.splice(i, 1)\\\\n                                break;\\\\n                        }\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                        toast('删除成功');\\\\n                    }\\\\n                })\\\\n                return empty\\\\n            }, empty, MusicMap, i)\\\\n            break;\\\\n        case SelectMap[2]:\\\\n            putMyVar('getMove', i)\\\\n            refreshPage(false)\\\\n            break;\\\\n        default:\\\\n            return $(empty + '#autoCache#fypage').rule((mid, MusicMap, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let page = MY_PAGE\\\\n                let layout = [];\\\\n                switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n                    case MusicMap[0]:\\\\n                        if (page == 1) {\\\\n                            NetEaseMap = '/api/v6/playlist/detail?id=' + mid + '&n=1000&limit=1000'\\\\n                            NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET')\\\\n                            try {\\\\n                                NetEaseParse(layout, NetEaseMap.playlist.tracks)\\\\n                            } catch (e) {\\\\n                                layout.push({\\\\n                                    title: Rich(Small(Gray('～～～' + NetEaseMap.message + '～～～'))),\\\\n                                    url: empty,\\\\n                                    col_type: 'text_center_1',\\\\n                                    extra: {\\\\n                                        lineVisible: false\\\\n                                    }\\\\n                                })\\\\n                            }\\\\n                        }\\\\n                        break;\\\\n                    case MusicMap[1]:\\\\n                        if (page == 1) {\\\\n                            TencentMap = TencentConfig(mid).Songlist.data.songlist\\\\n                            TencentParse(layout, TencentMap)\\\\n                        }\\\\n                        break;\\\\n                    case MusicMap[2]:\\\\n                        KwmusiccarUrl = 'music/playlist/' + mid + '?pn=' + page + '&rn=20&ua=&ip='\\\\n                        try {\\\\n                            KwmusiccarMap = KwmusiccarConfig(KwmusiccarUrl).musicList\\\\n                            KwmusiccarParse(layout, KwmusiccarMap)\\\\n                        } catch (e) {\\\\n                            toast('糟糕API崩溃了')\\\\n                        }\\\\n                        break;\\\\n                    case MusicMap[3]:\\\\n                        if (page == 1) {\\\\n                            try {\\\\n                                KugouUrl = 'https://m.kugou.com/plist/list/' + mid + '/?json=true'\\\\n                                KugouMap = JSON.parse(request(KugouUrl)).list.list.info\\\\n                                KugouParse(layout, KugouMap)\\\\n                            } catch (e) {\\\\n                                mid = pdfh(request(mid), 'body&&script,2&&Html')\\\\n                                mid = mid.match(/window\\\\\\\\.\\\\\\\\$output = ([\\\\\\\\S\\\\\\\\s].*);/)[1]\\\\n                                KugouMap = JSON.parse(mid).info.songs\\\\n                                KugouParse(layout, KugouMap)\\\\n                            }\\\\n                        }\\\\n                        break;\\\\n                    default:\\\\n                        MiguUrl = 'MIGUM3.0/resource/playlist/song/v2.0?pageNo=' + page + '&pageSize=50&playlistId=' + mid\\\\n                        MiguMap = MiguConfig(MiguUrl).data.songList\\\\n                        MiguParse(layout, MiguMap)\\\\n                        break;\\\\n                }\\\\n                setResult(layout);\\\\n            }, mid, MusicMap, myname)\\\\n    }\\\\n    return empty\\\\n}\\\\n\\\\nconst getImport = (MusicMap, input) => {\\\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n    let dataMap = readFile(down);\\\\n    eval('dataMap =' + dataMap)\\\\n    let NetEase = dataMap.BuildMusic.NetEase\\\\n    let Tencent = dataMap.BuildMusic.Tencent\\\\n    let Kwmusiccar = dataMap.BuildMusic.Kwmusiccar\\\\n    let Kugou = dataMap.BuildMusic.Kugou\\\\n    let Migu = dataMap.BuildMusic.Migu\\\\n    try {\\\\n        switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n            case MusicMap[0]:\\\\n                if (input.startsWith(MusicMap[0])) {\\\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\\\n                    mid = base64Decode(mid)\\\\n                } else if (input.search('music.163') >= 1) {\\\\n                    mid = input.match(/(playlist\\\\\\\\/|id=)(\\\\\\\\d+)/)[2]\\\\n                }\\\\n                NetEaseMap = '/api/v6/playlist/detail?id=' + mid + '&n=1000&limit=1000'\\\\n                NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET').playlist\\\\n                Break = true\\\\n                NetEase.forEach(item => {\\\\n                    if (item.mid == NetEaseMap.id) {\\\\n                        toast('歌单重复导入了哦')\\\\n                        Break = false\\\\n                    }\\\\n                })\\\\n                if (Break) {\\\\n                    NetEase.push({\\\\n                        name: NetEaseMap.name,\\\\n                        picUrl: NetEaseMap.coverImgUrl,\\\\n                        mid: NetEaseMap.id\\\\n                    })\\\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                    refreshPage(false)\\\\n                }\\\\n                break;\\\\n            case MusicMap[1]:\\\\n                if (input.startsWith(MusicMap[1])) {\\\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\\\n                    mid = base64Decode(mid)\\\\n                } else if (input.search('qq.com') >= 1) {\\\\n                    mid = input.match(/id=(\\\\\\\\d+)/)[1]\\\\n                }\\\\n                TencentMap = TencentConfig(Number(mid)).Songlist.data.dirinfo\\\\n                Break = true\\\\n                Tencent.forEach(item => {\\\\n                    if (item.mid == TencentMap.id) {\\\\n                        toast('歌单重复导入了哦')\\\\n                        Break = false\\\\n                    }\\\\n                })\\\\n                if (Break) {\\\\n                    Tencent.push({\\\\n                        name: TencentMap.title,\\\\n                        picUrl: TencentMap.picurl,\\\\n                        mid: TencentMap.id\\\\n                    })\\\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                    refreshPage(false)\\\\n                }\\\\n                break;\\\\n            case MusicMap[2]:\\\\n                if (input.startsWith(MusicMap[2])) {\\\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\\\n                    mid = base64Decode(mid)\\\\n                } else if (input.search('kuwo.cn') >= 1) {\\\\n                    mid = input.match(/(playlist\\\\\\\\/|playlist_detail\\\\\\\\/)(\\\\\\\\d+)/)[2]\\\\n                }\\\\n                KwmusiccarUrl = 'music/playlist/' + mid + '?pn=1&rn=20&ua=&ip='\\\\n                KwmusiccarMap = KwmusiccarConfig(KwmusiccarUrl)\\\\n                Break = true\\\\n                Kwmusiccar.forEach(item => {\\\\n                    if (item.mid == KwmusiccarMap.id) {\\\\n                        toast('歌单重复导入了哦')\\\\n                        Break = false\\\\n                    }\\\\n                })\\\\n                if (Break) {\\\\n                    Kwmusiccar.push({\\\\n                        name: KwmusiccarMap.name,\\\\n                        picUrl: KwmusiccarMap.pic,\\\\n                        mid: KwmusiccarMap.id\\\\n                    })\\\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                    refreshPage(false)\\\\n                }\\\\n                break;\\\\n            case MusicMap[3]:\\\\n                try {\\\\n                    if (input.startsWith(MusicMap[3])) {\\\\n                        Input = input.match(/[A-Za-z0-9+/=]+$/)[0]\\\\n                        Input = base64Decode(Input)\\\\n                        mid = pdfh(request(Input), 'body&&script,2&&Html')\\\\n                        mid = mid.match(/window\\\\\\\\.\\\\\\\\$output = ([\\\\\\\\S\\\\\\\\s].*);/)[1]\\\\n                    } else if (input.search('kugou.com') >= 1) {\\\\n                        Input = input.match(/(https|http)(.*link)/)[0]\\\\n                        mid = pdfh(request(Input), 'body&&script,2&&Html')\\\\n                        mid = mid.match(/window\\\\\\\\.\\\\\\\\$output = ([\\\\\\\\S\\\\\\\\s].*);/)[1]\\\\n                    }\\\\n                    KugouMap = JSON.parse(mid).info.listinfo\\\\n                    Break = true\\\\n                    Kugou.forEach(item => {\\\\n                        if (item.mid == Input) {\\\\n                            toast('歌单重复导入了哦')\\\\n                            Break = false\\\\n                        }\\\\n                    })\\\\n                    if (Break) {\\\\n                        Kugou.push({\\\\n                            name: KugouMap.name,\\\\n                            picUrl: KugouMap.pic.replace('{size}', '400'),\\\\n                            mid: Input\\\\n                        })\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                    }\\\\n                } catch (e) {\\\\n                    if (input.startsWith(MusicMap[3])) {\\\\n                        mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\\\n                        mid = base64Decode(mid)\\\\n                    } else if (input.search('kugou.com') >= 1) {\\\\n                        mid = input.match(/(\\\\\\\\/list\\\\\\\\/)(.*)\\\\\\\\//)[2]\\\\n                    }\\\\n                    KugouUrl = 'https://m3ws.kugou.com/plist/list/' + mid\\\\n                    KugouMap = request(KugouUrl)\\\\n                    Break = true\\\\n                    Kugou.forEach(item => {\\\\n                        if (item.mid == mid) {\\\\n                            toast('歌单重复导入了哦')\\\\n                            Break = false\\\\n                        }\\\\n                    })\\\\n                    if (Break) {\\\\n                        Kugou.push({\\\\n                            name: pdfh(KugouMap, '.content&&p&&Text'),\\\\n                            picUrl: pdfh(KugouMap, '.content&&img&&_src'),\\\\n                            mid: mid\\\\n                        })\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                    }\\\\n                }\\\\n                break;\\\\n            default:\\\\n                if (input.startsWith(MusicMap[4])) {\\\\n                    mid = input.match(/[A-Za-z0-9+/=]+$/)[0]\\\\n                    mid = base64Decode(mid)\\\\n                } else if (input.search('migu.cn') >= 1) {\\\\n                    if (input.startsWith('分享')) {\\\\n                        mid = input.match(/(https|http).*(\\\\\\\\w)/)[0]\\\\n                        mid = JSON.parse(request(mid, {\\\\n                            onlyHeaders: true\\\\n                        })).url\\\\n                        mid = mid.match(/(id=)(\\\\\\\\d+)/)[2]\\\\n                    } else {\\\\n                        mid = input.match(/(playlist\\\\\\\\/)(\\\\\\\\d+)/)[2]\\\\n                    }\\\\n                }\\\\n                MiguUrl = 'MIGUM3.0/resource/playlist/v2.0?playlistId=' + mid\\\\n                MiguMap = MiguConfig(MiguUrl).data\\\\n                Break = true\\\\n                Migu.forEach(item => {\\\\n                    if (item.mid == MiguMap.musicListId) {\\\\n                        toast('歌单重复导入了哦')\\\\n                        Break = false\\\\n                    }\\\\n                })\\\\n                if (Break) {\\\\n                    Migu.push({\\\\n                        name: MiguMap.title,\\\\n                        picUrl: MiguMap.imgItem.img,\\\\n                        mid: MiguMap.musicListId\\\\n                    })\\\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                    refreshPage(false)\\\\n                }\\\\n                break;\\\\n        }\\\\n    } catch (e) {\\\\n        toast('糟糕崩溃了，请检查链接是否有误')\\\\n    }\\\\n}\\\\n\\\\nconst getMySelectMap = (MusicMap, SelectMap, mid, name, input) => {\\\\n    switch (getItem('getUpMap', SelectMap[SelectMap.length - 1])) {\\\\n        case SelectMap[0]:\\\\n            getCopy = getMyVar('MusicMyMap', MusicMap[0]) + '\\\\\\\\n歌单名称：' + name + '\\\\\\\\n歌单识别：' + base64Encode('' + mid + '')\\\\n            copy(getCopy)\\\\n            break;\\\\n        default:\\\\n            return $(empty + '#autoCache#').rule((MusicMap, mid, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                switch (getMyVar('MusicMyMap', MusicMap[0])) {\\\\n                    case MusicMap[0]:\\\\n                        NetEaseMap = '/api/v6/playlist/detail?id=' + mid + '&n=1000&limit=1000'\\\\n                        NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET')\\\\n                        try {\\\\n                            NetEaseParse(layout, NetEaseMap.playlist.tracks)\\\\n                        } catch (e) {\\\\n                            layout.push({\\\\n                                title: Rich(Small(Gray('～～～' + NetEaseMap.message + '～～～'))),\\\\n                                url: empty,\\\\n                                col_type: 'text_center_1',\\\\n                                extra: {\\\\n                                    lineVisible: false\\\\n                                }\\\\n                            })\\\\n                        }\\\\n                        break;\\\\n                    default:\\\\n                        TencentMap = TencentConfig(mid).Songlist.data.songlist\\\\n                        TencentParse(layout, TencentMap)\\\\n                        break;\\\\n                }\\\\n                setResult(layout);\\\\n            }, MusicMap, mid, myname)\\\\n    }\\\\n    return empty\\\\n}\\\\n\\\\nconst getSelectListMap = (SelectMap, i, item) => {\\\\n    switch (getItem('getUpMap', SelectMap[SelectMap.length - 1])) {\\\\n        case SelectMap[0]:\\\\n            getCopy = sharePaste(base64Encode(JSON.stringify(item))) + '\\\\\\\\n\\\\\\\\n自建歌单：' + item.name\\\\n            copy(getCopy)\\\\n            break;\\\\n        case SelectMap[1]:\\\\n            putMyVar('indexConfirm', i)\\\\n            return $(empty).lazyRule((empty) => {\\\\n                confirm({\\\\n                    title: \\\\\\\"歌单删除\\\\\\\",\\\\n                    content: \\\\\\\"确定好了吗，该歌单将删除\\\\\\\",\\\\n                    confirm: () => {\\\\n                        i = getMyVar('indexConfirm')\\\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        dataMap = readFile(down);\\\\n                        eval('dataMap =' + dataMap)\\\\n                        dataMap.BuildList.splice(i, 1)\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                        toast('删除成功');\\\\n                    }\\\\n                })\\\\n                return empty\\\\n            }, empty)\\\\n            break;\\\\n        case SelectMap[2]:\\\\n            putMyVar('getMove', i)\\\\n            refreshPage(false)\\\\n            break;\\\\n        case SelectMap[3]:\\\\n            return $(empty).rule((i, item, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                getEditParse(layout, i, item)\\\\n                setResult(layout);\\\\n            }, i, item, myname)\\\\n            break;\\\\n        default:\\\\n            return $(empty).rule((i, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                BuildListParse(layout, i)\\\\n                setResult(layout);\\\\n            }, i, myname)\\\\n    }\\\\n    return empty\\\\n}\\\\n\\\\nconst getSelectListImport = (input) => {\\\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n    let dataMap = readFile(down);\\\\n    eval('dataMap =' + dataMap)\\\\n    let BuildList = dataMap.BuildList\\\\n    if (input.indexOf('自建歌单') > 0) {\\\\n        input = input.match(/(https|http).*(\\\\\\\\w)/)[0]\\\\n        data = parsePaste(input)\\\\n        data = base64Decode(data)\\\\n        eval('data =' + data)\\\\n        storage0.putMyVar('自建歌单', data)\\\\n        Break = true\\\\n        BuildList.forEach((item, i) => {\\\\n            if (item.name == data.name) {\\\\n                putMyVar('BreakIndex', i)\\\\n                confirm({\\\\n                    title: \\\\\\\"歌单覆盖\\\\\\\",\\\\n                    content: \\\\\\\"确定好了吗，该歌单将覆盖\\\\\\\",\\\\n                    confirm: () => {\\\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        let dataMap = readFile(down);\\\\n                        eval('dataMap =' + dataMap)\\\\n                        let BuildList = dataMap.BuildList\\\\n                        let data = storage0.getMyVar('自建歌单')\\\\n                        BuildList[getMyVar('BreakIndex')] = {\\\\n                            name: data.name,\\\\n                            pics: data.pics,\\\\n                            data: data.data\\\\n                        }\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                    }\\\\n                })\\\\n                Break = false\\\\n            }\\\\n        })\\\\n        if (Break) {\\\\n            BuildList.push({\\\\n                name: data.name,\\\\n                pics: data.pics,\\\\n                data: data.data\\\\n            })\\\\n            saveFile(down, JSON.stringify(dataMap), 0);\\\\n            refreshPage(false)\\\\n        }\\\\n    } else {\\\\n        toast('导入失败')\\\\n    }\\\\n}\\\\n\\\\nconst getBaseParse = () => {\\\\n    MusicMap = ['我的歌单', '歌单收藏', '自建歌单', '音乐菜单'];\\\\n    const layout = [];\\\\n    getSearchParse(layout)\\\\n    MusicMap.forEach(item => {\\\\n        layout.push({\\\\n            title: item == getMyVar('MusicMap', MusicMap[0]) ? Rich(Strong(Color(item))) : item,\\\\n            url: $('#noLoading#').lazyRule((item, empty, myname, MusicMap) => {\\\\n                switch (item) {\\\\n                    case MusicMap[MusicMap.length - 1]:\\\\n                        upMap = ['歌单样式']\\\\n                        upsMap = storage0.getMyVar('SearchMusicMap', ['聚合搜索'])\\\\n                        storageMap = storage0.getMyVar('SelectMap')\\\\n                        upMap = storageMap.concat(upsMap.concat(upMap))\\\\n                        return $(upMap, 2, '已选择-' + '[' + getItem('getUpMap', storageMap[storageMap.length - 1]) + ']').select((upMap, empty, myname) => {\\\\n                            switch (input) {\\\\n                                case upMap[upMap.length - 1]:\\\\n                                    return $(getColTypes(), 2, '已选择-' + '[' + getItem('getColTypes', 'card_pic_3') + ']').select(() => {\\\\n                                        setItem('getColTypes', input)\\\\n                                        toast('切换样式-' + input)\\\\n                                    })\\\\n                                    break;\\\\n                                case upMap[upMap.length - 2]:\\\\n                                    funMap = ['聚合搜索']\\\\n                                    funsMap = ['原生搜索']\\\\n                                    switch (storage0.getMyVar('SearchMusicMap', funMap)[0]) {\\\\n                                        case funMap[0]:\\\\n                                            storage0.putMyVar('SearchMusicMap', funsMap);\\\\n                                            break;\\\\n                                        default:\\\\n                                            storage0.putMyVar('SearchMusicMap', funMap);\\\\n                                            break;\\\\n                                    }\\\\n                                    refreshPage();\\\\n                                    return empty;\\\\n                                    break;\\\\n                                case '创建歌单':\\\\n                                    return $(empty).rule((myname) => {\\\\n                                        setPageTitle('创建歌单')\\\\n                                        require('hiker://page/Config.view?rule=' + myname)\\\\n                                        let layout = [];\\\\n                                        CreateListParse(layout)\\\\n                                        setResult(layout);\\\\n                                    }, myname)\\\\n                                    break;\\\\n                                default:\\\\n                                    setItem('getUpMap', input)\\\\n                                    toast('切换方法-' + input)\\\\n                                    break;\\\\n                            }\\\\n                            return empty\\\\n                        }, upMap, empty, myname)\\\\n                        break;\\\\n                    default:\\\\n                        putMyVar('MusicMap', item);\\\\n                        clearItem('getUpMap')\\\\n                        refreshPage();\\\\n                        return empty;\\\\n                        break;\\\\n                }\\\\n            }, item, empty, myname, MusicMap),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n    })\\\\n    layout.push({\\\\n        col_type: 'blank_block'\\\\n    })\\\\n    switch (getMyVar('MusicMap', MusicMap[0])) {\\\\n        case MusicMap[0]:\\\\n            getMyMusicParse(layout)\\\\n            break;\\\\n        case MusicMap[1]:\\\\n            getBuildMusicParse(layout)\\\\n            break;\\\\n        default:\\\\n            getBuildListParse(layout)\\\\n            break;\\\\n    }\\\\n    setResult(layout)\\\\n}\\\\n\\\\nconst getMyMusicParse = (layout) => {\\\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n    let dataMap;\\\\n    if (fileExist(down)) {\\\\n        eval('dataMap =' + readFile(down))\\\\n    } else {\\\\n        dataMap = {}\\\\n        saveFile(down, JSON.stringify(dataMap), 0);\\\\n    }\\\\n    MusicMap = ['网易歌单', '腾讯歌单'];\\\\n    MusicMap.forEach(item => {\\\\n        layout.push({\\\\n            title: item == getMyVar('MusicMyMap', MusicMap[0]) ? Rich(Strong(Color(item))) : item,\\\\n            url: $('#noLoading#').lazyRule((item, empty) => {\\\\n                putMyVar('MusicMyMap', item);\\\\n                refreshPage();\\\\n                return empty;\\\\n            }, item, empty),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n    })\\\\n    addListener('onRefresh', $.toString(() => {\\\\n        switch (getMyVar('注销', '0')) {\\\\n            case '0':\\\\n                putMyVar('注销', 1);\\\\n                break;\\\\n            default:\\\\n                putMyVar('注销', 0);\\\\n                break;\\\\n        }\\\\n    }));\\\\n    switch (getMyVar('MusicMyMap', MusicMap[0])) {\\\\n        case MusicMap[0]:\\\\n            getNetEaseParse(layout, dataMap, MusicMap)\\\\n            break;\\\\n        default:\\\\n            getTencentParse(layout, dataMap, MusicMap)\\\\n            break;\\\\n    }\\\\n}\\\\n\\\\nconst getBuildMusicParse = (layout) => {\\\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n    let dataMap;\\\\n    eval('dataMap =' + readFile(down))\\\\n    getSaveFile = false\\\\n    if (dataMap.BuildMusic == null) {\\\\n        dataMap.BuildMusic = {}\\\\n        getSaveFile = true\\\\n    }\\\\n    if (dataMap.BuildMusic.NetEase == null) {\\\\n        dataMap.BuildMusic.NetEase = []\\\\n        getSaveFile = true\\\\n    }\\\\n    if (dataMap.BuildMusic.Tencent == null) {\\\\n        dataMap.BuildMusic.Tencent = []\\\\n        getSaveFile = true\\\\n    }\\\\n    if (dataMap.BuildMusic.Kwmusiccar == null) {\\\\n        dataMap.BuildMusic.Kwmusiccar = []\\\\n        getSaveFile = true\\\\n    }\\\\n    if (dataMap.BuildMusic.Kugou == null) {\\\\n        dataMap.BuildMusic.Kugou = []\\\\n        getSaveFile = true\\\\n    }\\\\n    if (dataMap.BuildMusic.Migu == null) {\\\\n        dataMap.BuildMusic.Migu = []\\\\n        getSaveFile = true\\\\n    }\\\\n    if (getSaveFile) {\\\\n        saveFile(down, JSON.stringify(dataMap), 0);\\\\n        eval('dataMap =' + readFile(down))\\\\n    }\\\\n    MusicMap = ['网易歌单', '腾讯歌单', '酷我歌单', '酷狗歌单', '咪咕歌单'];\\\\n    MusicMap.forEach(item => {\\\\n        layout.push({\\\\n            title: item == getMyVar('BuildMusic', MusicMap[0]) ? Rich(Strong(Color(item))) : item,\\\\n            url: $('#noLoading#').lazyRule((item, empty) => {\\\\n                putMyVar('BuildMusic', item);\\\\n                refreshPage();\\\\n                return empty;\\\\n            }, item, empty),\\\\n            col_type: 'scroll_button'\\\\n        })\\\\n    })\\\\n    switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n        case MusicMap[0]:\\\\n            dataMap = dataMap.BuildMusic.NetEase\\\\n            break;\\\\n        case MusicMap[1]:\\\\n            dataMap = dataMap.BuildMusic.Tencent\\\\n            break;\\\\n        case MusicMap[2]:\\\\n            dataMap = dataMap.BuildMusic.Kwmusiccar\\\\n            break;\\\\n        case MusicMap[3]:\\\\n            dataMap = dataMap.BuildMusic.Kugou\\\\n            break;\\\\n        default:\\\\n            dataMap = dataMap.BuildMusic.Migu\\\\n            break;\\\\n    }\\\\n    SelectMap = ['歌单分享', '删除歌单', '歌单移动', '查看内容']\\\\n    storage0.putMyVar('SelectMap', SelectMap)\\\\n    dataMap.forEach((item, i) => {\\\\n        name = item.name\\\\n        select = $(empty + '#noLoading#').lazyRule((MusicMap, SelectMap, i, mid, name, myname) => {\\\\n            require('hiker://page/Config.view?rule=' + myname)\\\\n            clearMyVar('switch')\\\\n            return getSelectMap(MusicMap, SelectMap, i, mid, name)\\\\n        }, MusicMap, SelectMap, i, item.mid, item.name, myname)\\\\n        if (getMyVar('getMove', '')) {\\\\n            if (getMyVar('getMove', '') == i) {\\\\n                name = Rich(Small(SpringGreen(name)))\\\\n            }\\\\n            select = $(empty).lazyRule((MusicMap, i, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                down = 'hiker://files/rules/js/简单音乐.js'\\\\n                eval('dataMap =' + readFile(down))\\\\n                index = Number(getMyVar('getMove'))\\\\n                switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n                    case MusicMap[0]:\\\\n                        getMove(dataMap.BuildMusic.NetEase, index, i)\\\\n                        break;\\\\n                    case MusicMap[1]:\\\\n                        getMove(dataMap.BuildMusic.Tencent, index, i)\\\\n                        break;\\\\n                    case MusicMap[2]:\\\\n                        getMove(dataMap.BuildMusic.Kwmusiccar, index, i)\\\\n                        break;\\\\n                    case MusicMap[3]:\\\\n                        getMove(dataMap.BuildMusic.Kugou, index, i)\\\\n                        break;\\\\n                    default:\\\\n                        getMove(dataMap.BuildMusic.Migu, index, i)\\\\n                        break;\\\\n                }\\\\n                saveFile(down, JSON.stringify(dataMap), 0);\\\\n                clearMyVar('getMove')\\\\n                refreshPage(false)\\\\n                return empty\\\\n            }, MusicMap, i, myname)\\\\n        }\\\\n        layout.push({\\\\n            title: name,\\\\n            img: item.picUrl,\\\\n            url: select,\\\\n            col_type: 'card_pic_3',\\\\n            extra: {\\\\n                inheritTitle: false,\\\\n                longClick: [{\\\\n                    title: '歌单分享',\\\\n                    js: $.toString((MusicMap, mid, name) => {\\\\n                        getCopy = getMyVar('BuildMusic', MusicMap[0]) + '\\\\\\\\n歌单名称：' + name + '\\\\\\\\n歌单识别：' + base64Encode('' + mid + '')\\\\n                        copy(getCopy)\\\\n                    }, MusicMap, item.mid, item.name)\\\\n                }, {\\\\n                    title: '删除歌单',\\\\n                    js: $.toString((MusicMap, i) => {\\\\n                        storage0.putMyVar('MusicMapConfirm', MusicMap)\\\\n                        putMyVar('indexConfirm', i)\\\\n                        confirm({\\\\n                            title: \\\\\\\"歌单删除\\\\\\\",\\\\n                            content: \\\\\\\"确定好了吗，该歌单将删除\\\\\\\",\\\\n                            confirm: () => {\\\\n                                MusicMap = storage0.getMyVar('MusicMapConfirm')\\\\n                                i = getMyVar('indexConfirm')\\\\n                                down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                dataMap = readFile(down);\\\\n                                eval('dataMap =' + dataMap)\\\\n                                switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n                                    case MusicMap[0]:\\\\n                                        dataMap.BuildMusic.NetEase.splice(i, 1)\\\\n                                        break;\\\\n                                    case MusicMap[1]:\\\\n                                        dataMap.BuildMusic.Tencent.splice(i, 1)\\\\n                                        break;\\\\n                                    case MusicMap[2]:\\\\n                                        dataMap.BuildMusic.Kwmusiccar.splice(i, 1)\\\\n                                        break;\\\\n                                    case MusicMap[3]:\\\\n                                        dataMap.BuildMusic.Kugou.splice(i, 1)\\\\n                                        break;\\\\n                                    default:\\\\n                                        dataMap.BuildMusic.Migu.splice(i, 1)\\\\n                                        break;\\\\n                                }\\\\n                                saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                refreshPage(false)\\\\n                                toast('删除成功');\\\\n                            }\\\\n                        })\\\\n                    }, MusicMap, i)\\\\n                }, {\\\\n                    title: '置顶歌单',\\\\n                    js: $.toString((name, MusicMap) => {\\\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        eval('dataMap =' + readFile(down))\\\\n                        switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n                            case MusicMap[0]:\\\\n                                data = dataMap.BuildMusic.NetEase\\\\n                                break;\\\\n                            case MusicMap[1]:\\\\n                                data = dataMap.BuildMusic.Tencent\\\\n                                break;\\\\n                            case MusicMap[2]:\\\\n                                data = dataMap.BuildMusic.Kwmusiccar\\\\n                                break;\\\\n                            case MusicMap[3]:\\\\n                                data = dataMap.BuildMusic.Kugou\\\\n                                break;\\\\n                            default:\\\\n                                data = dataMap.BuildMusic.Migu\\\\n                                break;\\\\n                        }\\\\n                        let obj = {};\\\\n                        data.forEach((item, index) => {\\\\n                            if (item.name === name) {\\\\n                                obj = item;\\\\n                                data.splice(index, 1)\\\\n                                return;\\\\n                            }\\\\n                        })\\\\n                        data.unshift(obj);\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                    }, item.name, MusicMap)\\\\n                }, {\\\\n                    title: '置底歌单',\\\\n                    js: $.toString((name, MusicMap) => {\\\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        eval('dataMap =' + readFile(down))\\\\n                        switch (getMyVar('BuildMusic', MusicMap[0])) {\\\\n                            case MusicMap[0]:\\\\n                                data = dataMap.BuildMusic.NetEase\\\\n                                break;\\\\n                            case MusicMap[1]:\\\\n                                data = dataMap.BuildMusic.Tencent\\\\n                                break;\\\\n                            case MusicMap[2]:\\\\n                                data = dataMap.BuildMusic.Kwmusiccar\\\\n                                break;\\\\n                            case MusicMap[3]:\\\\n                                data = dataMap.BuildMusic.Kugou\\\\n                                break;\\\\n                            default:\\\\n                                data = dataMap.BuildMusic.Migu\\\\n                                break;\\\\n                        }\\\\n                        let obj = {};\\\\n                        data.forEach((item, index) => {\\\\n                            if (item.name === name) {\\\\n                                obj = item;\\\\n                                data.splice(index, 1)\\\\n                                return;\\\\n                            }\\\\n                        })\\\\n                        data.push(obj);\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                    }, item.name, MusicMap)\\\\n                }]\\\\n            }\\\\n        })\\\\n    })\\\\n    layout.push({\\\\n        title: '歌单导入',\\\\n        img: 'https://missuo.ru/file/1eb6219db8632428a2396.jpg',\\\\n        url: $('{{clipboard}}').input((MusicMap, myname) => {\\\\n            require('hiker://page/Config.view?rule=' + myname)\\\\n            return getImport(MusicMap, input)\\\\n        }, MusicMap, myname),\\\\n        col_type: 'card_pic_3'\\\\n    })\\\\n}\\\\n\\\\nconst getBuildListParse = (layout) => {\\\\n    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n    let dataMap;\\\\n    eval('dataMap =' + readFile(down))\\\\n    if (dataMap.BuildList == null) {\\\\n        dataMap.BuildList = []\\\\n        saveFile(down, JSON.stringify(dataMap), 0);\\\\n        eval('dataMap =' + readFile(down))\\\\n    }\\\\n    SelectMap = ['歌单分享', '删除歌单', '歌单移动', '编辑歌单', '创建歌单', '查看内容']\\\\n    storage0.putMyVar('SelectMap', SelectMap)\\\\n    dataMap.BuildList.forEach((item, i) => {\\\\n        name = item.name\\\\n        select = $(empty + '#noLoading#').lazyRule((SelectMap, i, item, myname) => {\\\\n            require('hiker://page/Config.view?rule=' + myname)\\\\n            return getSelectListMap(SelectMap, i, item)\\\\n        }, SelectMap, i, item, myname)\\\\n        if (getMyVar('getMove', '')) {\\\\n            if (getMyVar('getMove', '') == i) {\\\\n                name = Rich(Small(SpringGreen(name)))\\\\n            }\\\\n            select = $(empty).lazyRule((i, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                down = 'hiker://files/rules/js/简单音乐.js'\\\\n                eval('dataMap =' + readFile(down))\\\\n                index = Number(getMyVar('getMove'))\\\\n                getMove(dataMap.BuildList, index, i)\\\\n                saveFile(down, JSON.stringify(dataMap), 0);\\\\n                clearMyVar('getMove')\\\\n                refreshPage(false)\\\\n                return empty\\\\n            }, i, myname)\\\\n        }\\\\n        layout.push({\\\\n            title: name,\\\\n            img: item.pics,\\\\n            url: select,\\\\n            col_type: 'card_pic_3',\\\\n            extra: {\\\\n                inheritTitle: false,\\\\n                longClick: [{\\\\n                    title: '歌单分享',\\\\n                    js: $.toString((item) => {\\\\n                        getCopy = sharePaste(base64Encode(JSON.stringify(item))) + '\\\\\\\\n\\\\\\\\n自建歌单：' + item.name\\\\n                        copy(getCopy)\\\\n                    }, item)\\\\n                }, {\\\\n                    title: '删除歌单',\\\\n                    js: $.toString((i) => {\\\\n                        putMyVar('indexConfirm', i)\\\\n                        confirm({\\\\n                            title: \\\\\\\"歌单删除\\\\\\\",\\\\n                            content: \\\\\\\"确定好了吗，该歌单将删除\\\\\\\",\\\\n                            confirm: () => {\\\\n                                i = getMyVar('indexConfirm')\\\\n                                down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                dataMap = readFile(down);\\\\n                                eval('dataMap =' + dataMap)\\\\n                                dataMap.BuildList.splice(i, 1)\\\\n                                saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                refreshPage(false)\\\\n                                toast('删除成功');\\\\n                            }\\\\n                        })\\\\n                    }, i)\\\\n                }, {\\\\n                    title: '置顶歌单',\\\\n                    js: $.toString((name) => {\\\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        eval('dataMap =' + readFile(down))\\\\n                        let obj = {};\\\\n                        dataMap.BuildList.forEach((item, index) => {\\\\n                            if (item.name === name) {\\\\n                                obj = item;\\\\n                                dataMap.BuildList.splice(index, 1)\\\\n                                return;\\\\n                            }\\\\n                        })\\\\n                        dataMap.BuildList.unshift(obj);\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                    }, item.name)\\\\n                }, {\\\\n                    title: '置底歌单',\\\\n                    js: $.toString((name) => {\\\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        eval('dataMap =' + readFile(down))\\\\n                        let obj = {};\\\\n                        dataMap.BuildList.forEach((item, index) => {\\\\n                            if (item.name === name) {\\\\n                                obj = item;\\\\n                                dataMap.BuildList.splice(index, 1)\\\\n                                return;\\\\n                            }\\\\n                        })\\\\n                        dataMap.BuildList.push(obj);\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                    }, item.name)\\\\n                }]\\\\n            }\\\\n        })\\\\n    })\\\\n    layout.push({\\\\n        title: '歌单导入',\\\\n        img: 'https://missuo.ru/file/1eb6219db8632428a2396.jpg',\\\\n        url: $('{{clipboard}}').input((myname) => {\\\\n            require('hiker://page/Config.view?rule=' + myname)\\\\n            return getSelectListImport(input)\\\\n        }, myname),\\\\n        col_type: 'card_pic_3'\\\\n    })\\\\n}\\\\n\\\\nconst getNetEaseParse = (layout, dataMap, MusicMap) => {\\\\n    NetEaseMap = dataMap.NetEase\\\\n    if (NetEaseMap == null || NetEaseMap.length == 0) {\\\\n        layout.push({\\\\n            title: '查\\\\\\\\n询',\\\\n            desc: \\\\\\\"输入关键词查询用户\\\\\\\",\\\\n            url: $.toString((empty) => {\\\\n                putMyVar('关键词', input);\\\\n                refreshPage();\\\\n                return empty;\\\\n            }, empty),\\\\n            col_type: 'input',\\\\n            extra: {\\\\n                type: 'textarea',\\\\n                height: 3,\\\\n                defaultValue: getMyVar('关键词')\\\\n            }\\\\n        })\\\\n        if (getMyVar('关键词', '') != '') {\\\\n            path = '/weapi/search/get'\\\\n            body = {\\\\n                \\\\\\\"s\\\\\\\": getMyVar('关键词'),\\\\n                \\\\\\\"type\\\\\\\": 1002,\\\\n                \\\\\\\"limit\\\\\\\": 30,\\\\n                \\\\\\\"offset\\\\\\\": 0\\\\n            }\\\\n            data = NetEaseConfig(path, body, 'POST')\\\\n            data.result.userprofiles.forEach(item => {\\\\n                layout.push({\\\\n                    title: item.nickname,\\\\n                    img: item.avatarUrl,\\\\n                    url: $(empty).lazyRule((empty, userId) => {\\\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        data = readFile(down);\\\\n                        eval('data =' + data)\\\\n                        data.NetEase = []\\\\n                        data.NetEase.push(userId)\\\\n                        saveFile(down, JSON.stringify(data), 0);\\\\n                        refreshPage()\\\\n                        return empty\\\\n                    }, empty, item.userId),\\\\n                    col_type: 'avatar'\\\\n                })\\\\n            })\\\\n        }\\\\n    } else {\\\\n        NetEaseMap = '/api/user/playlist?offset=0&uid=' + dataMap.NetEase[0] + '&limit=1000'\\\\n        NetEaseMap = NetEaseConfig(NetEaseMap, '', 'GET').playlist\\\\n        SelectMap = ['歌单分享', '查看内容']\\\\n        storage0.putMyVar('SelectMap', SelectMap)\\\\n        NetEaseMap.forEach(item => {\\\\n            if (item.name.search('喜欢的音乐') < 1) {\\\\n                layout.push({\\\\n                    title: item.name,\\\\n                    img: item.coverImgUrl,\\\\n                    url: $(empty + '#noLoading#').lazyRule((MusicMap, SelectMap, mid, name, myname) => {\\\\n                        require('hiker://page/Config.view?rule=' + myname)\\\\n                        clearMyVar('switch')\\\\n                        return getMySelectMap(MusicMap, SelectMap, mid, name, input)\\\\n                    }, MusicMap, SelectMap, item.id, item.name, myname),\\\\n                    col_type: 'card_pic_3',\\\\n                    extra: {\\\\n                        inheritTitle: false,\\\\n                        longClick: [{\\\\n                            title: '歌单分享',\\\\n                            js: $.toString((MusicMap, mid, name) => {\\\\n                                getCopy = getMyVar('MusicMyMap', MusicMap[0]) + '\\\\\\\\n歌单名称：' + name + '\\\\\\\\n歌单识别：' + base64Encode('' + mid + '')\\\\n                                copy(getCopy)\\\\n                            }, MusicMap, item.id, item.name)\\\\n                        }]\\\\n                    }\\\\n                })\\\\n            }\\\\n        })\\\\n        if (getMyVar('注销', '0') == 1) {\\\\n            layout.push({\\\\n                title: Rich(Small(Gray('～～～注销绑定～～～'))),\\\\n                url: $(empty).lazyRule((empty) => {\\\\n                    down = 'hiker://files/rules/js/简单音乐.js'\\\\n                    data = readFile(down);\\\\n                    eval('data =' + data)\\\\n                    data.NetEase = []\\\\n                    saveFile(down, JSON.stringify(data), 0);\\\\n                    clearMyVar('注销')\\\\n                    refreshPage()\\\\n                    return empty\\\\n                }, empty),\\\\n                col_type: 'text_center_1',\\\\n                extra: {\\\\n                    lineVisible: false\\\\n                }\\\\n            })\\\\n        }\\\\n    }\\\\n}\\\\n\\\\nconst getTencentParse = (layout, dataMap, MusicMap) => {\\\\n    TencentMap = dataMap.Tencent\\\\n    if (TencentMap == null || TencentMap.length == 0) {\\\\n        layout.push({\\\\n            desc: \\\\\\\"请输入您的QQ号\\\\\\\",\\\\n            col_type: \\\\\\\"input\\\\\\\",\\\\n            extra: {\\\\n                type: 'textarea',\\\\n                height: 3,\\\\n                onChange: \\\\\\\"setItem('QQ', input)\\\\\\\",\\\\n                titleVisible: false\\\\n            }\\\\n        }, {\\\\n            title: Rich(Strong(Gray('绑定账号'))),\\\\n            url: $(empty).lazyRule((empty) => {\\\\n                down = 'hiker://files/rules/js/简单音乐.js'\\\\n                data = readFile(down);\\\\n                eval('data =' + data)\\\\n                data.Tencent = []\\\\n                data.Tencent.push(getItem('QQ'))\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n                refreshPage()\\\\n                return empty\\\\n            }, empty),\\\\n            col_type: 'text_center_1',\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        })\\\\n    } else {\\\\n        TencentUrl = 'http://c.y.qq.com/rsc/fcgi-bin/fcg_user_created_diss?hostuin=' + dataMap.Tencent[0] + '&size=1000&format=json'\\\\n        TencentMap = TencentConfig(TencentUrl)\\\\n        SelectMap = ['歌单分享', '查看内容']\\\\n        storage0.putMyVar('SelectMap', SelectMap)\\\\n        try {\\\\n            TencentMap = TencentMap.data.disslist\\\\n            TencentMap = TencentMap.filter(item => item.tid != 0)\\\\n            if (TencentMap.length > 0) {\\\\n                TencentMap.forEach(item => {\\\\n                    layout.push({\\\\n                        title: item.diss_name,\\\\n                        img: item.diss_cover,\\\\n                        url: $(empty + '#noLoading#').lazyRule((MusicMap, SelectMap, mid, name, myname) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            clearMyVar('switch')\\\\n                            return getMySelectMap(MusicMap, SelectMap, mid, name, input)\\\\n                        }, MusicMap, SelectMap, item.tid, item.diss_name, myname),\\\\n                        col_type: 'card_pic_3',\\\\n                        extra: {\\\\n                            inheritTitle: false,\\\\n                            longClick: [{\\\\n                                title: '歌单分享',\\\\n                                js: $.toString((MusicMap, mid, name) => {\\\\n                                    getCopy = getMyVar('MusicMyMap', MusicMap[0]) + '\\\\\\\\n歌单名称：' + name + '\\\\\\\\n歌单识别：' + base64Encode('' + mid + '')\\\\n                                    copy(getCopy)\\\\n                                }, MusicMap, item.tid, item.diss_name)\\\\n                            }]\\\\n                        }\\\\n                    })\\\\n                })\\\\n            } else {\\\\n                layout.push({\\\\n                    title: Rich(Small(Gray('～～～啥也没有留下～～～'))),\\\\n                    url: empty,\\\\n                    col_type: 'text_center_1',\\\\n                    extra: {\\\\n                        lineVisible: false\\\\n                    }\\\\n                })\\\\n            }\\\\n        } catch (e) {\\\\n            layout.push({\\\\n                title: Rich(Small(Gray('～～～' + TencentMap.message + '～～～'))),\\\\n                url: empty,\\\\n                col_type: 'text_center_1',\\\\n                extra: {\\\\n                    lineVisible: false\\\\n                }\\\\n            })\\\\n        }\\\\n        if (getMyVar('注销', '0') == 1) {\\\\n            layout.push({\\\\n                title: Rich(Small(Gray('～～～注销绑定～～～'))),\\\\n                url: $(empty).lazyRule((empty) => {\\\\n                    down = 'hiker://files/rules/js/简单音乐.js'\\\\n                    data = readFile(down);\\\\n                    eval('data =' + data)\\\\n                    data.Tencent = []\\\\n                    saveFile(down, JSON.stringify(data), 0);\\\\n                    clearMyVar('注销')\\\\n                    refreshPage()\\\\n                    return empty\\\\n                }, empty),\\\\n                col_type: 'text_center_1',\\\\n                extra: {\\\\n                    lineVisible: false\\\\n                }\\\\n            })\\\\n        }\\\\n    }\\\\n}\\\\n\\\\nconst getConfirm = () => {\\\\n    if (!getMyVar('失败')) {\\\\n        confirm({\\\\n            title: \\\\\\\"搜索歌曲\\\\\\\",\\\\n            content: \\\\\\\"若免嗅失败，将搜索歌曲\\\\\\\",\\\\n            confirm: () => {\\\\n                putMyVar('失败', true);\\\\n                toast('emmm~');\\\\n                java.lang.Thread.sleep(3000);\\\\n                toast('下次重启，将重新拉启弹窗')\\\\n            },\\\\n            cancel: () => {\\\\n                putMyVar('失败', false);\\\\n                toast('俺不要ヽ(≧Д≦)ノ~');\\\\n                java.lang.Thread.sleep(3000);\\\\n                toast('下次重启，将重新拉启弹窗')\\\\n            }\\\\n        })\\\\n    }\\\\n}\\\\n\\\\nconst getIncludedParse = (layout) => {\\\\n    getConfirm()\\\\n    addListener('onRefresh', $.toString(() => {\\\\n        switch (getMyVar('更多', '0')) {\\\\n            case '0':\\\\n                putMyVar('更多', 1);\\\\n                break;\\\\n            default:\\\\n                putMyVar('更多', 0);\\\\n                break;\\\\n        }\\\\n    }));\\\\n    addListener('onClose', () => {\\\\n        clearMyVar('更多')\\\\n    })\\\\n    SelectMap = ['收录歌曲', '聆听歌曲']\\\\n    if (getMyVar('更多', '0') == 1 && MY_PAGE == 1) {\\\\n        layout.push({\\\\n            col_type: 'line_blank'\\\\n        }, {\\\\n            title: Rich(Small(Gray('～～～更多选项～～～'))),\\\\n            url: $(SelectMap, 1, '已选择-' + '[' + getMyVar('更多功能', SelectMap[SelectMap.length - 1]) + ']').select((empty) => {\\\\n                putMyVar('更多功能', input)\\\\n                refreshPage()\\\\n                return empty\\\\n            }, empty),\\\\n            col_type: 'text_center_1',\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        }, {\\\\n            col_type: 'line_blank'\\\\n        })\\\\n    }\\\\n}\\\\n\\\\nconst getIncludedFun = () => {\\\\n    down = 'hiker://files/rules/js/简单音乐.js'\\\\n    data = readFile(down);\\\\n    eval('data =' + data)\\\\n    if (data.BuildList == null) {\\\\n        data.BuildList = []\\\\n        saveFile(down, JSON.stringify(data), 0);\\\\n        eval('data =' + readFile(down))\\\\n    }\\\\n    names = data.BuildList.map(it => it.name)\\\\n    upMap = names.concat(['创建歌单'])\\\\n    index = 1\\\\n    if (upMap.length > 2) {\\\\n        index = 2\\\\n    }\\\\n}\\\\n\\\\nconst getIncludedNetEase = (item, input) => {\\\\n    switch (input) {\\\\n        case '创建歌单':\\\\n            return $(empty).rule((myname) => {\\\\n                setPageTitle('创建歌单')\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                CreateListParse(layout)\\\\n                setResult(layout);\\\\n            }, myname)\\\\n            break;\\\\n        default:\\\\n            down = 'hiker://files/rules/js/简单音乐.js'\\\\n            data = readFile(down);\\\\n            eval('data =' + data)\\\\n            getBreak = false\\\\n            data.BuildList.forEach((Item, x) => {\\\\n                if (input == Item.name) {\\\\n                    getBreak = true\\\\n                    index = x\\\\n                    storage0.putMyVar('自建歌单', item)\\\\n                    Item.data.forEach((Items, i) => {\\\\n                        if (Items.mid == item.id && Items.id == 'netease') {\\\\n                            putMyVar('BreakIndex', index)\\\\n                            putMyVar('BreakIndexs', i)\\\\n                            confirm({\\\\n                                title: \\\\\\\"收录覆盖\\\\\\\",\\\\n                                content: \\\\\\\"确定好了吗，歌曲将覆盖原有的\\\\\\\",\\\\n                                confirm: () => {\\\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                    let dataMap = readFile(down);\\\\n                                    eval('dataMap =' + dataMap)\\\\n                                    let BuildList = dataMap.BuildList\\\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\\\n                                    let data = storage0.getMyVar('自建歌单')\\\\n                                    cont = data.ar.map(tag => tag.name).join('、')\\\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\\\n                                        name: data.name,\\\\n                                        cont: cont,\\\\n                                        pics: data.al.picUrl,\\\\n                                        mid: data.id,\\\\n                                        id: 'netease'\\\\n                                    }\\\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                    toast('覆盖成功')\\\\n                                }\\\\n                            })\\\\n                            getBreak = false\\\\n                        }\\\\n                    })\\\\n                }\\\\n            })\\\\n            if (getBreak) {\\\\n                cont = item.ar.map(tag => tag.name).join('、')\\\\n                data.BuildList[index].data.push({\\\\n                    name: item.name,\\\\n                    cont: cont,\\\\n                    pics: item.al.picUrl,\\\\n                    mid: item.id,\\\\n                    id: 'netease'\\\\n                })\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n                toast('收录成功')\\\\n            }\\\\n            break;\\\\n    }\\\\n}\\\\n\\\\nconst getIncludedTencent = (item, input) => {\\\\n    switch (input) {\\\\n        case '创建歌单':\\\\n            return $(empty).rule((myname) => {\\\\n                setPageTitle('创建歌单')\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                CreateListParse(layout)\\\\n                setResult(layout);\\\\n            }, myname)\\\\n            break;\\\\n        default:\\\\n            down = 'hiker://files/rules/js/简单音乐.js'\\\\n            data = readFile(down);\\\\n            eval('data =' + data)\\\\n            getBreak = false\\\\n            data.BuildList.forEach((Item, x) => {\\\\n                if (input == Item.name) {\\\\n                    getBreak = true\\\\n                    index = x\\\\n                    storage0.putMyVar('自建歌单', item)\\\\n                    Item.data.forEach((Items, i) => {\\\\n                        if (Items.mid == item.mid && Items.id == 'tencent') {\\\\n                            putMyVar('BreakIndex', index)\\\\n                            putMyVar('BreakIndexs', i)\\\\n                            confirm({\\\\n                                title: \\\\\\\"收录覆盖\\\\\\\",\\\\n                                content: \\\\\\\"确定好了吗，歌曲将覆盖原有的\\\\\\\",\\\\n                                confirm: () => {\\\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                    let dataMap = readFile(down);\\\\n                                    eval('dataMap =' + dataMap)\\\\n                                    let BuildList = dataMap.BuildList\\\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\\\n                                    let data = storage0.getMyVar('自建歌单')\\\\n                                    subtitle = ''\\\\n                                    if (data.subtitle) {\\\\n                                        subtitle = data.subtitle + '-'\\\\n                                    }\\\\n                                    singer = data.singer.map(tag => tag.name).join('、')\\\\n                                    img = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\\\n                                    if (data.album.mid) {\\\\n                                        img = 'https://y.gtimg.cn/music/photo_new/T002R300x300M000' + data.album.mid + '.jpg'\\\\n                                    }\\\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\\\n                                        name: data.title,\\\\n                                        cont: subtitle + singer,\\\\n                                        pics: img,\\\\n                                        mid: data.mid,\\\\n                                        id: 'tencent'\\\\n                                    }\\\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                    toast('覆盖成功')\\\\n                                }\\\\n                            })\\\\n                            getBreak = false\\\\n                        }\\\\n                    })\\\\n                }\\\\n            })\\\\n            if (getBreak) {\\\\n                subtitle = ''\\\\n                if (item.subtitle) {\\\\n                    subtitle = item.subtitle + '-'\\\\n                }\\\\n                singer = item.singer.map(tag => tag.name).join('、')\\\\n                img = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\\\n                if (item.album.mid) {\\\\n                    img = 'https://y.gtimg.cn/music/photo_new/T002R300x300M000' + item.album.mid + '.jpg'\\\\n                }\\\\n                data.BuildList[index].data.push({\\\\n                    name: item.title,\\\\n                    cont: subtitle + singer,\\\\n                    pics: img,\\\\n                    mid: item.mid,\\\\n                    id: 'tencent'\\\\n                })\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n                toast('收录成功')\\\\n            }\\\\n            break;\\\\n    }\\\\n}\\\\n\\\\nconst getIncludedKwmusiccar = (item, pics, input) => {\\\\n    switch (input) {\\\\n        case '创建歌单':\\\\n            return $(empty).rule((myname) => {\\\\n                setPageTitle('创建歌单')\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                CreateListParse(layout)\\\\n                setResult(layout);\\\\n            }, myname)\\\\n            break;\\\\n        default:\\\\n            down = 'hiker://files/rules/js/简单音乐.js'\\\\n            data = readFile(down);\\\\n            eval('data =' + data)\\\\n            getBreak = false\\\\n            data.BuildList.forEach((Item, x) => {\\\\n                if (input == Item.name) {\\\\n                    getBreak = true\\\\n                    index = x\\\\n                    storage0.putMyVar('自建歌单', item)\\\\n                    putMyVar('KwmusicPics', pics)\\\\n                    Item.data.forEach((Items, i) => {\\\\n                        if (Items.mid == item.id && Items.id == 'kuwo') {\\\\n                            putMyVar('BreakIndex', index)\\\\n                            putMyVar('BreakIndexs', i)\\\\n                            confirm({\\\\n                                title: \\\\\\\"收录覆盖\\\\\\\",\\\\n                                content: \\\\\\\"确定好了吗，歌曲将覆盖原有的\\\\\\\",\\\\n                                confirm: () => {\\\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                    let dataMap = readFile(down);\\\\n                                    eval('dataMap =' + dataMap)\\\\n                                    let BuildList = dataMap.BuildList\\\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\\\n                                    let data = storage0.getMyVar('自建歌单')\\\\n                                    subtitle = ''\\\\n                                    if (data.artist_name) {\\\\n                                        subtitle = data.artist_name + '-'\\\\n                                    }\\\\n                                    singer = ''\\\\n                                    if (data.album_name) {\\\\n                                        singer = data.album_name\\\\n                                    }\\\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\\\n                                        name: data.name,\\\\n                                        cont: subtitle + singer,\\\\n                                        pics: getMyVar('KwmusicPics'),\\\\n                                        mid: data.id,\\\\n                                        id: 'kuwo'\\\\n                                    }\\\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                    toast('覆盖成功')\\\\n                                }\\\\n                            })\\\\n                            getBreak = false\\\\n                        }\\\\n                    })\\\\n                }\\\\n            })\\\\n            if (getBreak) {\\\\n                subtitle = ''\\\\n                if (item.artist_name) {\\\\n                    subtitle = item.artist_name + '-'\\\\n                }\\\\n                singer = ''\\\\n                if (item.album_name) {\\\\n                    singer = item.album_name\\\\n                }\\\\n                data.BuildList[index].data.push({\\\\n                    name: item.name,\\\\n                    cont: subtitle + singer,\\\\n                    pics: pics,\\\\n                    mid: item.id,\\\\n                    id: 'kuwo'\\\\n                })\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n                toast('收录成功')\\\\n            }\\\\n            break;\\\\n    }\\\\n}\\\\n\\\\nconst getIncludedKugou = (date, item, i, input) => {\\\\n    switch (input) {\\\\n        case '创建歌单':\\\\n            return $(empty).rule((myname) => {\\\\n                setPageTitle('创建歌单')\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                CreateListParse(layout)\\\\n                setResult(layout);\\\\n            }, myname)\\\\n            break;\\\\n        default:\\\\n            down = 'hiker://files/rules/js/简单音乐.js'\\\\n            data = readFile(down);\\\\n            eval('data =' + data)\\\\n            getBreak = false\\\\n            data.BuildList.forEach((Item, x) => {\\\\n                if (input == Item.name) {\\\\n                    getBreak = true\\\\n                    index = x\\\\n                    storage0.putMyVar('自建歌单', item)\\\\n                    storage0.putMyVar('自建Play', date[i])\\\\n                    Item.data.forEach((Items, l) => {\\\\n                        if (Items.mid.hash == date[i].hash && Items.id == 'kugou') {\\\\n                            putMyVar('BreakIndex', index)\\\\n                            putMyVar('BreakIndexs', l)\\\\n                            confirm({\\\\n                                title: \\\\\\\"收录覆盖\\\\\\\",\\\\n                                content: \\\\\\\"确定好了吗，歌曲将覆盖原有的\\\\\\\",\\\\n                                confirm: () => {\\\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                    let dataMap = readFile(down);\\\\n                                    eval('dataMap =' + dataMap)\\\\n                                    let BuildList = dataMap.BuildList\\\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\\\n                                    let data = storage0.getMyVar('自建歌单')\\\\n                                    let date = storage0.getMyVar('自建Play')\\\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\\\n                                        name: date.filename,\\\\n                                        pics: data.img,\\\\n                                        mid: date,\\\\n                                        id: 'kugou'\\\\n                                    }\\\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                    toast('覆盖成功')\\\\n                                }\\\\n                            })\\\\n                            getBreak = false\\\\n                        }\\\\n                    })\\\\n                }\\\\n            })\\\\n            if (getBreak) {\\\\n                data.BuildList[index].data.push({\\\\n                    name: date[i].filename,\\\\n                    pics: item.img,\\\\n                    mid: date[i],\\\\n                    id: 'kugou'\\\\n                })\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n                toast('收录成功')\\\\n            }\\\\n            break;\\\\n    }\\\\n}\\\\n\\\\nconst getIncludedMigu = (item, input) => {\\\\n    switch (input) {\\\\n        case '创建歌单':\\\\n            return $(empty).rule((myname) => {\\\\n                setPageTitle('创建歌单')\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                let layout = [];\\\\n                CreateListParse(layout)\\\\n                setResult(layout);\\\\n            }, myname)\\\\n            break;\\\\n        default:\\\\n            down = 'hiker://files/rules/js/简单音乐.js'\\\\n            data = readFile(down);\\\\n            eval('data =' + data)\\\\n            getBreak = false\\\\n            data.BuildList.forEach((Item, x) => {\\\\n                if (input == Item.name) {\\\\n                    getBreak = true\\\\n                    index = x\\\\n                    storage0.putMyVar('自建歌单', item)\\\\n                    Item.data.forEach((Items, i) => {\\\\n                        if (Items.mid.copyrightId == item.copyrightId && Items.id == 'migu') {\\\\n                            putMyVar('BreakIndex', index)\\\\n                            putMyVar('BreakIndexs', i)\\\\n                            confirm({\\\\n                                title: \\\\\\\"收录覆盖\\\\\\\",\\\\n                                content: \\\\\\\"确定好了吗，歌曲将覆盖原有的\\\\\\\",\\\\n                                confirm: () => {\\\\n                                    let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                    let dataMap = readFile(down);\\\\n                                    eval('dataMap =' + dataMap)\\\\n                                    let BuildList = dataMap.BuildList\\\\n                                    BuildList = BuildList[getMyVar('BreakIndex')].data\\\\n                                    let data = storage0.getMyVar('自建歌单')\\\\n                                    const MiguFill = (url) => {\\\\n                                        if (!/^(https?)/.test(url)) {\\\\n                                            return \\\\\\\"http://d.musicapp.migu.cn/\\\\\\\" + url;\\\\n                                        } else {\\\\n                                            return url;\\\\n                                        }\\\\n                                    }\\\\n                                    subtitle = ''\\\\n                                    if (data.album) {\\\\n                                        subtitle = data.album + '-'\\\\n                                    }\\\\n                                    singer = data.singerList.map(tag => tag.name).join('、')\\\\n                                    BuildList[getMyVar('BreakIndexs')] = {\\\\n                                        name: data.songName,\\\\n                                        cont: subtitle + singer,\\\\n                                        pics: MiguFill(data.img1),\\\\n                                        mid: data,\\\\n                                        id: 'migu'\\\\n                                    }\\\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                    toast('覆盖成功')\\\\n                                }\\\\n                            })\\\\n                            getBreak = false\\\\n                        }\\\\n                    })\\\\n                }\\\\n            })\\\\n            if (getBreak) {\\\\n                subtitle = ''\\\\n                if (item.album) {\\\\n                    subtitle = item.album + '-'\\\\n                }\\\\n                singer = item.singerList.map(tag => tag.name).join('、')\\\\n                data.BuildList[index].data.push({\\\\n                    name: item.songName,\\\\n                    cont: subtitle + singer,\\\\n                    pics: MiguFill(item.img1),\\\\n                    mid: item,\\\\n                    id: 'migu'\\\\n                })\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n                toast('收录成功')\\\\n            }\\\\n            break;\\\\n    }\\\\n}\\\\n\\\\nconst NetEaseParse = (layout, data) => {\\\\n    getIncludedParse(layout)\\\\n    try {\\\\n        if (data.length > 0) {\\\\n            data.forEach(item => {\\\\n                singer = item.ar.map(tag => tag.name).join('、')\\\\n                layout.push({\\\\n                    title: item.name,\\\\n                    desc: singer,\\\\n                    img: item.al.picUrl,\\\\n                    url: $(empty).lazyRule((item, myname, SelectMap) => {\\\\n                        require('hiker://page/Config.view?rule=' + myname)\\\\n                        switch (getMyVar('更多功能', SelectMap[1])) {\\\\n                            case SelectMap[0]:\\\\n                                getIncludedFun()\\\\n                                return $(upMap, index, '收录歌曲').select((item, myname) => {\\\\n                                    require('hiker://page/Config.view?rule=' + myname)\\\\n                                    return getIncludedNetEase(item, input)\\\\n                                }, item, myname)\\\\n                                break\\\\n                            default:\\\\n                                return getNetEasePlayer(item.id, item.name)\\\\n                                break\\\\n                        }\\\\n                    }, item, myname, SelectMap),\\\\n                    col_type: getItem('getColTypes', 'card_pic_3'),\\\\n                    extra: {\\\\n                        inheritTitle: false,\\\\n                        longClick: [{\\\\n                            title: '收录歌曲',\\\\n                            js: $.toString((item, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                getIncludedFun()\\\\n                                return $(upMap, index, '收录歌曲').select((item, myname) => {\\\\n                                    require('hiker://page/Config.view?rule=' + myname)\\\\n                                    return getIncludedNetEase(item, input)\\\\n                                }, item, myname)\\\\n                            }, item, myname)\\\\n                        }, {\\\\n                            title: '搜索 => ' + item.name,\\\\n                            js: $.toString((name, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getConfirmSearch(name)\\\\n                            }, item.name, myname)\\\\n                        }]\\\\n                    }\\\\n                })\\\\n            })\\\\n        } else {\\\\n            layout.push({\\\\n                title: Rich(Small(Gray('～～～啥也没有留下～～～'))),\\\\n                url: empty,\\\\n                col_type: 'text_center_1',\\\\n                extra: {\\\\n                    lineVisible: false\\\\n                }\\\\n            })\\\\n        }\\\\n    } catch (e) {\\\\n        toast('到底了哦')\\\\n    }\\\\n}\\\\n\\\\nconst TencentParse = (layout, data) => {\\\\n    getIncludedParse(layout)\\\\n    if (data.length > 0) {\\\\n        data.forEach(item => {\\\\n            subtitle = ''\\\\n            if (item.subtitle) {\\\\n                subtitle = item.subtitle + '-'\\\\n            }\\\\n            singer = item.singer.map(tag => tag.name).join('、')\\\\n            img = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\\\n            if (item.album.mid) {\\\\n                img = 'https://y.gtimg.cn/music/photo_new/T002R300x300M000' + item.album.mid + '.jpg'\\\\n            }\\\\n            layout.push({\\\\n                title: item.title,\\\\n                desc: subtitle + singer,\\\\n                img: img,\\\\n                url: $(empty).lazyRule((item, myname, SelectMap) => {\\\\n                    require('hiker://page/Config.view?rule=' + myname)\\\\n                    switch (getMyVar('更多功能', SelectMap[1])) {\\\\n                        case SelectMap[0]:\\\\n                            getIncludedFun()\\\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getIncludedTencent(item, input)\\\\n                            }, item, myname)\\\\n                            break\\\\n                        default:\\\\n                            return getTencentPlayer(item.mid, item.title)\\\\n                            break\\\\n                    }\\\\n                }, item, myname, SelectMap),\\\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\\\n                extra: {\\\\n                    inheritTitle: false,\\\\n                    longClick: [{\\\\n                        title: '收录歌曲',\\\\n                        js: $.toString((item, myname) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            getIncludedFun()\\\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getIncludedTencent(item, input)\\\\n                            }, item, myname)\\\\n                        }, item, myname)\\\\n                    }, {\\\\n                        title: '搜索 => ' + item.title,\\\\n                        js: $.toString((name, myname) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            return getConfirmSearch(name)\\\\n                        }, item.title, myname)\\\\n                    }]\\\\n                }\\\\n            })\\\\n        })\\\\n    } else {\\\\n        layout.push({\\\\n            title: Rich(Small(Gray('～～～啥也没有留下～～～'))),\\\\n            url: empty,\\\\n            col_type: 'text_center_1',\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        })\\\\n    }\\\\n}\\\\n\\\\nconst KwmusiccarParse = (layout, data) => {\\\\n    getIncludedParse(layout)\\\\n    try {\\\\n        if (data.length > 0) {\\\\n            datas = data\\\\n            if (getMyVar('switch', '0') == '1') {\\\\n                data = data.map(item => {\\\\n                    return KwmusiccarConfig('music/info/' + item.id).info\\\\n                })\\\\n            }\\\\n            data.forEach((item, i) => {\\\\n                subtitle = ''\\\\n                if (datas[i].artist_name) {\\\\n                    subtitle = datas[i].artist_name + '-'\\\\n                }\\\\n                singer = ''\\\\n                if (datas[i].album_name) {\\\\n                    singer = datas[i].album_name\\\\n                }\\\\n                layout.push({\\\\n                    title: datas[i].name,\\\\n                    desc: subtitle + singer,\\\\n                    img: item.pic || 'https://missuo.ru/file/51e785d34aba81f61994f.jpg',\\\\n                    url: $(empty).lazyRule((item, pics, myname, SelectMap) => {\\\\n                        require('hiker://page/Config.view?rule=' + myname)\\\\n                        switch (getMyVar('更多功能', SelectMap[1])) {\\\\n                            case SelectMap[0]:\\\\n                                getIncludedFun()\\\\n                                return $(upMap, index, '收录歌曲').select((item, pics, myname) => {\\\\n                                    require('hiker://page/Config.view?rule=' + myname)\\\\n                                    return getIncludedKwmusiccar(item, pics, input)\\\\n                                }, item, pics, myname)\\\\n                                break\\\\n                            default:\\\\n                                return getKwmusiccarPlayer(item.id)\\\\n                                break\\\\n                        }\\\\n                    }, datas[i], item.pic, myname, SelectMap),\\\\n                    col_type: getItem('getColTypes', 'card_pic_3'),\\\\n                    extra: {\\\\n                        inheritTitle: false,\\\\n                        longClick: [{\\\\n                            title: '收录歌曲',\\\\n                            js: $.toString((item, pics, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                getIncludedFun()\\\\n                                return $(upMap, index, '收录歌曲').select((item, pics, myname) => {\\\\n                                    require('hiker://page/Config.view?rule=' + myname)\\\\n                                    return getIncludedKwmusiccar(item, pics, input)\\\\n                                }, item, pics, myname)\\\\n                            }, datas[i], item.pic, myname)\\\\n                        }, {\\\\n                            title: '搜索 => ' + datas[i].name,\\\\n                            js: $.toString((name, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getConfirmSearch(name)\\\\n                            }, datas[i].name, myname)\\\\n                        }]\\\\n                    }\\\\n                })\\\\n            })\\\\n        }\\\\n    } catch (e) {\\\\n        toast('糟糕API崩溃了')\\\\n    }\\\\n}\\\\n\\\\nconst KugouParse = (layout, data) => {\\\\n    getIncludedParse(layout)\\\\n    if (data.length > 0) {\\\\n        let KugouMap = data.map(item => {\\\\n            return KugouConfig(item)\\\\n        })\\\\n        KugouMap.forEach((item, i) => {\\\\n            layout.push({\\\\n                title: data[i].filename,\\\\n                img: item.img || 'https://missuo.ru/file/51e785d34aba81f61994f.jpg',\\\\n                url: $(empty).lazyRule((data, item, myname, SelectMap, i) => {\\\\n                    require('hiker://page/Config.view?rule=' + myname)\\\\n                    switch (getMyVar('更多功能', SelectMap[1])) {\\\\n                        case SelectMap[0]:\\\\n                            getIncludedFun()\\\\n                            return $(upMap, index, '收录歌曲').select((data, item, i, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getIncludedKugou(data, item, i, input)\\\\n                            }, data, item, i, myname)\\\\n                            break\\\\n                        default:\\\\n                            return getKugouPlayer(data[i], data[i].filename)\\\\n                            break\\\\n                    }\\\\n                }, data, item, myname, SelectMap, i),\\\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\\\n                extra: {\\\\n                    inheritTitle: false,\\\\n                    longClick: [{\\\\n                        title: '收录歌曲',\\\\n                        js: $.toString((data, item, myname, i) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            getIncludedFun()\\\\n                            return $(upMap, index, '收录歌曲').select((data, item, i, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getIncludedKugou(data, item, i, input)\\\\n                            }, data, item, i, myname)\\\\n                        }, data, item, myname, i)\\\\n                    }, {\\\\n                        title: '搜索 => ' + data[i].filename,\\\\n                        js: $.toString((name, myname) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            return getConfirmSearch(name)\\\\n                        }, data[i].filename, myname)\\\\n                    }]\\\\n                }\\\\n            })\\\\n        })\\\\n    }\\\\n}\\\\n\\\\nconst MiguParse = (layout, data) => {\\\\n    getIncludedParse(layout)\\\\n    if (data.length > 0) {\\\\n        data.forEach(item => {\\\\n            subtitle = ''\\\\n            if (item.album) {\\\\n                subtitle = item.album + '-'\\\\n            }\\\\n            singer = item.singerList || item.singers\\\\n            singer = singer.map(tag => tag.name).join('、')\\\\n            layout.push({\\\\n                title: item.songName || item.name,\\\\n                desc: subtitle + singer,\\\\n                img: MiguFill(item.img1 || item.imgItems[0].img),\\\\n                url: $(empty).lazyRule((item, myname, SelectMap) => {\\\\n                    require('hiker://page/Config.view?rule=' + myname)\\\\n                    switch (getMyVar('更多功能', SelectMap[1])) {\\\\n                        case SelectMap[0]:\\\\n                            getIncludedFun()\\\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getIncludedMigu(item, input)\\\\n                            }, item, myname)\\\\n                            break\\\\n                        default:\\\\n                            return getMiguPlayer(item, (item.songName || item.name))\\\\n                            break\\\\n                    }\\\\n                }, item, myname, SelectMap),\\\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\\\n                extra: {\\\\n                    inheritTitle: false,\\\\n                    longClick: [{\\\\n                        title: '收录歌曲',\\\\n                        js: $.toString((item, myname) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            getIncludedFun()\\\\n                            return $(upMap, index, '收录歌曲').select((item, myname) => {\\\\n                                require('hiker://page/Config.view?rule=' + myname)\\\\n                                return getIncludedMigu(item, input)\\\\n                            }, item, myname)\\\\n                        }, item, myname)\\\\n                    }, {\\\\n                        title: '搜索 => ' + (item.songName || item.name),\\\\n                        js: $.toString((name, myname) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            return getConfirmSearch(name)\\\\n                        }, (item.songName || item.name), myname)\\\\n                    }]\\\\n                }\\\\n            })\\\\n        })\\\\n    }\\\\n}\\\\n\\\\nconst getBuildListMap = (SelectMap, index, item, indexs) => {\\\\n    down = 'hiker://files/rules/js/简单音乐.js'\\\\n    data = readFile(down);\\\\n    eval('data =' + data)\\\\n    if (data.BuildList == null) {\\\\n        data.BuildList = []\\\\n        saveFile(down, JSON.stringify(data), 0);\\\\n        eval('data =' + readFile(down))\\\\n    }\\\\n    putMyVar('indexConfirm', index)\\\\n    putMyVar('indexsConfirm', indexs)\\\\n    switch (getMyVar('收录功能', SelectMap[SelectMap.length - 1])) {\\\\n        case SelectMap[0]:\\\\n            return $(empty).lazyRule((empty) => {\\\\n                confirm({\\\\n                    title: \\\\\\\"歌曲删除\\\\\\\",\\\\n                    content: \\\\\\\"确定好了吗，该歌曲将删除\\\\\\\",\\\\n                    confirm: () => {\\\\n                        index = getMyVar('indexConfirm')\\\\n                        indexs = getMyVar('indexsConfirm')\\\\n                        down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        dataMap = readFile(down);\\\\n                        eval('dataMap =' + dataMap)\\\\n                        dataMap.BuildList[indexs].data.splice(index, 1)\\\\n                        saveFile(down, JSON.stringify(dataMap), 0);\\\\n                        refreshPage(false)\\\\n                        toast('删除成功');\\\\n                    }\\\\n                })\\\\n                return empty\\\\n            }, empty)\\\\n            break;\\\\n        case SelectMap[1]:\\\\n            putMyVar('getMove', index)\\\\n            refreshPage(false)\\\\n            break;\\\\n        case SelectMap[2]:\\\\n            names = data.BuildList.map(it => it.name)\\\\n            upMap = names.concat(['创建歌单'])\\\\n            index = 1\\\\n            if (upMap.length > 2) {\\\\n                index = 2\\\\n            }\\\\n            return $(upMap, index, SelectMap[2]).select((myname, empty) => {\\\\n                switch (input) {\\\\n                    case '创建歌单':\\\\n                        return $(empty).rule((myname) => {\\\\n                            setPageTitle('创建歌单')\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            let layout = [];\\\\n                            CreateListParse(layout)\\\\n                            setResult(layout);\\\\n                        }, myname)\\\\n                        break;\\\\n                    default:\\\\n                        let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                        eval('dataMap =' + readFile(down))\\\\n                        Index = getMyVar('indexConfirm')\\\\n                        Indexs = getMyVar('indexsConfirm')\\\\n                        item = dataMap.BuildList[Indexs].data[Index]\\\\n                        getBreak = false\\\\n                        dataMap.BuildList.forEach((Item, x) => {\\\\n                            if (input == Item.name) {\\\\n                                getBreak = true\\\\n                                index = x\\\\n                                storage0.putMyVar('自建歌单', item)\\\\n                                Item.data.forEach((Items, i) => {\\\\n                                    if (Items.name == item.name) {\\\\n                                        putMyVar('BreakIndex', index)\\\\n                                        putMyVar('BreakIndexs', i)\\\\n                                        confirm({\\\\n                                            title: \\\\\\\"收录覆盖\\\\\\\",\\\\n                                            content: \\\\\\\"确定好了吗，歌曲将覆盖原有的\\\\\\\",\\\\n                                            confirm: () => {\\\\n                                                let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                                eval('dataMap =' + readFile(down))\\\\n                                                Index = getMyVar('indexConfirm')\\\\n                                                Indexs = getMyVar('indexsConfirm')\\\\n                                                index = getMyVar('BreakIndex')\\\\n                                                indexs = getMyVar('BreakIndexs')\\\\n                                                let BuildList = dataMap.BuildList\\\\n                                                BuildList = BuildList[index].data\\\\n                                                BuildList[indexs] = storage0.getMyVar('自建歌单')\\\\n                                                if (Indexs != index) {\\\\n                                                    dataMap.BuildList[Indexs].data.splice(Index, 1)\\\\n                                                }\\\\n                                                saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                                toast('覆盖成功')\\\\n                                                refreshPage(false)\\\\n                                            }\\\\n                                        })\\\\n                                        getBreak = false\\\\n                                    }\\\\n                                })\\\\n                            }\\\\n                        })\\\\n                        if (getBreak) {\\\\n                            dataMap.BuildList[Indexs].data.splice(Index, 1)\\\\n                            dataMap.BuildList[index].data.push(item)\\\\n                            saveFile(down, JSON.stringify(dataMap), 0);\\\\n                            toast('更换成功')\\\\n                            refreshPage(false)\\\\n                        }\\\\n                        break;\\\\n                }\\\\n            }, myname, empty)\\\\n            break;\\\\n        default:\\\\n            return $(empty).lazyRule((item, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                switch (item.id) {\\\\n                    case 'netease':\\\\n                        return getNetEasePlayer(item.mid, item.name)\\\\n                        break\\\\n                    case 'tencent':\\\\n                        return getTencentPlayer(item.mid, item.name)\\\\n                        break\\\\n                    case 'kuwo':\\\\n                        return getKwmusiccarPlayer(item.mid)\\\\n                        break\\\\n                    case 'kugou':\\\\n                        return getKugouPlayer(item.mid, item.name)\\\\n                        break\\\\n                    case 'migu':\\\\n                        return getMiguPlayer(item.mid, item.name)\\\\n                        break\\\\n                }\\\\n            }, item, myname)\\\\n    }\\\\n    return empty\\\\n}\\\\n\\\\nconst BuildListParse = (layout, index) => {\\\\n    getConfirm()\\\\n    SelectMap = ['删除歌曲', '歌曲移动', '更换歌单', '聆听歌曲']\\\\n    addListener('onRefresh', $.toString(() => {\\\\n        switch (getMyVar('更多', '0')) {\\\\n            case '0':\\\\n                putMyVar('更多', 1);\\\\n                break;\\\\n            default:\\\\n                putMyVar('更多', 0);\\\\n                break;\\\\n        }\\\\n    }));\\\\n    addListener('onClose', () => {\\\\n        clearMyVar('更多')\\\\n    })\\\\n    if (getMyVar('更多', '0') == 1) {\\\\n        layout.push({\\\\n            col_type: 'line_blank'\\\\n        }, {\\\\n            title: Rich(Small(Gray('～～～更多选项～～～'))),\\\\n            url: $(SelectMap, 2, '已选择-' + '[' + getMyVar('收录功能', SelectMap[SelectMap.length - 1]) + ']').select((empty) => {\\\\n                putMyVar('收录功能', input)\\\\n                refreshPage()\\\\n                return empty\\\\n            }, empty),\\\\n            col_type: 'text_center_1',\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        }, {\\\\n            col_type: 'line_blank'\\\\n        })\\\\n    }\\\\n    down = 'hiker://files/rules/js/简单音乐.js'\\\\n    dataMap = readFile(down);\\\\n    eval('dataMap =' + dataMap)\\\\n    data = dataMap.BuildList[index].data\\\\n    if (data.length != 0) {\\\\n        data.forEach((item, i) => {\\\\n            name = item.name\\\\n            select = $(empty + '#noLoading#').lazyRule((SelectMap, i, item, index, myname) => {\\\\n                require('hiker://page/Config.view?rule=' + myname)\\\\n                clearMyVar('switch')\\\\n                return getBuildListMap(SelectMap, i, item, index)\\\\n            }, SelectMap, i, item, index, myname)\\\\n            if (getMyVar('getMove', '')) {\\\\n                if (getMyVar('getMove', '') == i) {\\\\n                    name = Rich(Small(SpringGreen(name)))\\\\n                }\\\\n                select = $(empty).lazyRule((index, i, myname) => {\\\\n                    require('hiker://page/Config.view?rule=' + myname)\\\\n                    down = 'hiker://files/rules/js/简单音乐.js'\\\\n                    eval('dataMap =' + readFile(down))\\\\n                    indexs = Number(getMyVar('getMove'))\\\\n                    getMove(dataMap.BuildList[index].data, indexs, i)\\\\n                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                    clearMyVar('getMove')\\\\n                    refreshPage(false)\\\\n                    return empty\\\\n                }, index, i, myname)\\\\n            }\\\\n            layout.push({\\\\n                title: name,\\\\n                desc: item.cont,\\\\n                img: item.pics || 'https://missuo.ru/file/51e785d34aba81f61994f.jpg',\\\\n                url: select,\\\\n                col_type: getItem('getColTypes', 'card_pic_3'),\\\\n                extra: {\\\\n                    inheritTitle: false,\\\\n                    longClick: [{\\\\n                        title: '搜索 => ' + item.name,\\\\n                        js: $.toString((name, myname) => {\\\\n                            require('hiker://page/Config.view?rule=' + myname)\\\\n                            return getConfirmSearch(name)\\\\n                        }, item.name, myname)\\\\n                    }, {\\\\n                        title: '删除',\\\\n                        js: $.toString((index, indexs) => {\\\\n                            putMyVar('indexConfirm', index)\\\\n                            putMyVar('indexsConfirm', indexs)\\\\n                            confirm({\\\\n                                title: \\\\\\\"歌曲删除\\\\\\\",\\\\n                                content: \\\\\\\"确定好了吗，该歌曲将删除\\\\\\\",\\\\n                                confirm: () => {\\\\n                                    index = getMyVar('indexConfirm')\\\\n                                    indexs = getMyVar('indexsConfirm')\\\\n                                    down = 'hiker://files/rules/js/简单音乐.js'\\\\n                                    dataMap = readFile(down);\\\\n                                    eval('dataMap =' + dataMap)\\\\n                                    dataMap.BuildList[indexs].data.splice(index, 1)\\\\n                                    saveFile(down, JSON.stringify(dataMap), 0);\\\\n                                    refreshPage(false)\\\\n                                    toast('删除成功');\\\\n                                }\\\\n                            })\\\\n                        }, i, index)\\\\n                    }, {\\\\n                        title: '置顶',\\\\n                        js: $.toString((name, indexs) => {\\\\n                            let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                            eval('dataMap =' + readFile(down))\\\\n                            let obj = {};\\\\n                            dataMap.BuildList[indexs].data.forEach((item, index) => {\\\\n                                if (item.name === name) {\\\\n                                    obj = item;\\\\n                                    dataMap.BuildList[indexs].data.splice(index, 1)\\\\n                                    return;\\\\n                                }\\\\n                            })\\\\n                            dataMap.BuildList[indexs].data.unshift(obj);\\\\n                            saveFile(down, JSON.stringify(dataMap), 0);\\\\n                            refreshPage(false)\\\\n                        }, item.name, index)\\\\n                    }, {\\\\n                        title: '置底',\\\\n                        js: $.toString((name, indexs) => {\\\\n                            let down = 'hiker://files/rules/js/简单音乐.js'\\\\n                            eval('dataMap =' + readFile(down))\\\\n                            let obj = {};\\\\n                            dataMap.BuildList[indexs].data.forEach((item, index) => {\\\\n                                if (item.name === name) {\\\\n                                    obj = item;\\\\n                                    dataMap.BuildList[indexs].data.splice(index, 1)\\\\n                                    return;\\\\n                                }\\\\n                            })\\\\n                            dataMap.BuildList[indexs].data.push(obj);\\\\n                            saveFile(down, JSON.stringify(dataMap), 0);\\\\n                            refreshPage(false)\\\\n                        }, item.name, index)\\\\n                    }]\\\\n                }\\\\n            })\\\\n        })\\\\n    } else {\\\\n        layout.push({\\\\n            title: Rich(Small(Gray('～～～啥也没有哦～～～'))),\\\\n            url: empty,\\\\n            col_type: 'text_center_1',\\\\n            extra: {\\\\n                lineVisible: false\\\\n            }\\\\n        })\\\\n    }\\\\n}\\\\n\\\\nconst CreateListParse = (layout) => {\\\\n    layout.push({\\\\n        desc: \\\\\\\"请输入歌单名称\\\\\\\",\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            type: 'textarea',\\\\n            height: 3,\\\\n            onChange: \\\\\\\"setItem('名称', input)\\\\\\\",\\\\n            titleVisible: false\\\\n        }\\\\n    }, {\\\\n        desc: \\\\\\\"请输入歌单封面（非必填）\\\\\\\",\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            type: 'textarea',\\\\n            height: 3,\\\\n            onChange: \\\\\\\"setItem('封面', input)\\\\\\\",\\\\n            titleVisible: false\\\\n        }\\\\n    }, {\\\\n        title: Rich(Strong(Gray('创建歌单'))),\\\\n        url: $(empty).lazyRule((empty) => {\\\\n            down = 'hiker://files/rules/js/简单音乐.js'\\\\n            data = readFile(down);\\\\n            eval('data =' + data)\\\\n            pics = getItem('封面')\\\\n            name = getItem('名称')\\\\n            getBreak = true\\\\n            if (name != undefined && name != '') {\\\\n                data.BuildList.forEach(item => {\\\\n                    if (name == item.name) {\\\\n                        getBreak = false\\\\n                    }\\\\n                })\\\\n            } else {\\\\n                getBreak = false\\\\n            }\\\\n            if (getBreak) {\\\\n                if (pics == undefined || pics == '') {\\\\n                    pics = 'https://missuo.ru/file/51e785d34aba81f61994f.jpg'\\\\n                }\\\\n                dataMusic = {\\\\n                    name: name,\\\\n                    pics: pics,\\\\n                    data: []\\\\n                }\\\\n                data.BuildList.push(dataMusic)\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n            } else {\\\\n                toast('创建失败！！')\\\\n            }\\\\n            back()\\\\n            return empty\\\\n        }, empty),\\\\n        col_type: 'text_center_1',\\\\n        extra: {\\\\n            lineVisible: false\\\\n        }\\\\n    })\\\\n}\\\\n\\\\nconst getEditParse = (layout, i, item) => {\\\\n    layout.push({\\\\n        desc: item.name,\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            type: 'textarea',\\\\n            height: 3,\\\\n            onChange: \\\\\\\"setItem('名称', input)\\\\\\\",\\\\n            titleVisible: false\\\\n        }\\\\n    }, {\\\\n        desc: item.pics,\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        extra: {\\\\n            type: 'textarea',\\\\n            height: 3,\\\\n            onChange: \\\\\\\"setItem('封面', input)\\\\\\\",\\\\n            titleVisible: false\\\\n        }\\\\n    }, {\\\\n        title: Rich(Strong(Gray('确认修改'))),\\\\n        url: $(empty).lazyRule((empty, i) => {\\\\n            down = 'hiker://files/rules/js/简单音乐.js'\\\\n            data = readFile(down);\\\\n            eval('data =' + data)\\\\n            pics = getItem('封面')\\\\n            name = getItem('名称')\\\\n            getBreak = true\\\\n            index = ''\\\\n            if (name != undefined) {\\\\n                data.BuildList.forEach((item, x) => {\\\\n                    if (name == item.name) {\\\\n                        getBreak = false\\\\n                        index = x\\\\n                    }\\\\n                })\\\\n            } else {\\\\n                getBreak = false\\\\n            }\\\\n            if (getBreak || index == i) {\\\\n                if (pics == undefined || pics == '') {\\\\n                    pics = data.BuildList[i].pics\\\\n                }\\\\n                if (name == '') {\\\\n                    name = data.BuildList[i].name\\\\n                }\\\\n                data.BuildList[i].name = name\\\\n                data.BuildList[i].pics = pics\\\\n                saveFile(down, JSON.stringify(data), 0);\\\\n            } else {\\\\n                toast('修改失败！！！')\\\\n            }\\\\n            back()\\\\n            return empty\\\\n        }, empty, i),\\\\n        col_type: 'text_center_1',\\\\n        extra: {\\\\n            lineVisible: false\\\\n        }\\\\n    })\\\\n}\\\\n\\\\nconst getConfirmSearch = (name) => {\\\\n    if (getMyVar('失败', 'false') == 'true' && getMyVar('switch', '0') == '0') {\\\\n        putMyVar('switch', '1')\\\\n        return \\\\\\\"hiker://page/Searchs.view?rule=\\\\\\\" + myname + \\\\\\\"&page=fypage&searchTerms=\\\\\\\" + encodeURIComponent(name);\\\\n    }\\\\n    toast('暂无资源')\\\\n    return empty\\\\n}\\\\n\\\\nconst getNetEasePlayer = (mid, name) => {\\\\n    musicUrl = '/api/song/enhance/player/url?br=320000&ids=[' + mid + ']'\\\\n    musicMap = NetEaseConfig(musicUrl, '', 'GET')\\\\n    lysicUrl = '/api/song/lyric?os=osx&id=' + mid + '&lv=-1&kv=-1&tv=-1'\\\\n    lysicMap = NetEaseConfig(lysicUrl, '', 'GET')\\\\n    if (musicMap.data[0].url) {\\\\n        return JSON.stringify({\\\\n            urls: [musicMap.data[0].url],\\\\n            lyric: lysicMap.lrc.lyric\\\\n        })\\\\n    }\\\\n    return getConfirmSearch(name)\\\\n}\\\\n\\\\nconst getTencentPlayer = (mid, name) => {\\\\n    let typeMap = {\\\\n        m4a: {\\\\n            s: 'C400',\\\\n            e: '.m4a',\\\\n        },\\\\n        128: {\\\\n            s: 'M500',\\\\n            e: '.mp3',\\\\n        },\\\\n        320: {\\\\n            s: 'M800',\\\\n            e: '.mp3',\\\\n        },\\\\n        ape: {\\\\n            s: 'A000',\\\\n            e: '.ape',\\\\n        },\\\\n        flac: {\\\\n            s: 'F000',\\\\n            e: '.flac',\\\\n        },\\\\n    };\\\\n    let time = new Date().getTime()\\\\n    let guid = (Math.random() * 10000000).toFixed(0);\\\\n    let typeObj = typeMap['128'];\\\\n    let file = typeObj.s + mid + mid + typeObj.e;\\\\n    let url = {\\\\n        '-': 'getplaysongvkey',\\\\n        g_tk: 5381,\\\\n        hostUin: 0,\\\\n        format: 'json',\\\\n        inCharset: 'utf8',\\\\n        outCharset: 'utf-8¬ice=0',\\\\n        platform: 'yqq.json',\\\\n        needNewCode: 0,\\\\n        data: JSON.stringify({\\\\n            req_0: {\\\\n                module: 'vkey.GetVkeyServer',\\\\n                method: 'CgiGetVkey',\\\\n                param: {\\\\n                    filename: [file],\\\\n                    guid: guid,\\\\n                    songmid: [mid],\\\\n                    songtype: [0],\\\\n                    uin: '',\\\\n                    loginflag: 1,\\\\n                    platform: '20',\\\\n                },\\\\n            },\\\\n            comm: {\\\\n                uin: '',\\\\n                format: 'json',\\\\n                ct: 19,\\\\n                cv: 0,\\\\n                authst: '',\\\\n            },\\\\n        }),\\\\n    }\\\\n    let result = buildUrl('https://u.y.qq.com/cgi-bin/musicu.fcg', url)\\\\n    result = JSON.parse(fetch(result))\\\\n    let purl = '';\\\\n    let domain = '';\\\\n    if (result.req_0 && result.req_0.data && result.req_0.data.midurlinfo) {\\\\n        purl = result.req_0.data.midurlinfo[0].purl;\\\\n    }\\\\n    if (domain === '') {\\\\n        domain = result.req_0.data.sip.find(i => !i.startsWith('http://ws')) || result.req_0.data.sip[0];\\\\n    }\\\\n    let lyrics = 'http://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg?songmid=' + mid + '&pcachetime=' + time + '&g_tk=5381&loginUin=0&hostUin=0&inCharset=utf8&outCharset=utf-8&notice=0&platform=yqq&needNewCode=0'\\\\n    lyrics = TencentConfig(lyrics).lyric\\\\n    if (lyrics) {\\\\n        lyrics = base64Decode(lyrics)\\\\n    } else {\\\\n        lyrics = ''\\\\n    }\\\\n    if (purl != '' && domain != '') {\\\\n        return JSON.stringify({\\\\n            urls: [domain + purl],\\\\n            lyric: lyrics\\\\n        })\\\\n    }\\\\n    return getConfirmSearch(name)\\\\n}\\\\n\\\\nconst getKwmusiccarPlayer = (mid) => {\\\\n    let lyric = KwmusiccarConfig('music/info/' + mid).lrc\\\\n    const getTime = (time) => {\\\\n        let h = parseInt(time / 60 / 60 % 24)\\\\n        h = h < 10 ? '0' + h : h\\\\n        let m = parseInt(time / 60 % 60)\\\\n        m = m < 10 ? '0' + m : m\\\\n        let s = parseInt(time % 60)\\\\n        s = s < 10 ? '0' + s : s\\\\n        return [m + ':' + s + '.00']\\\\n    }\\\\n    let api = 'http://antiserver.kuwo.cn/anti.s?type=convert_url3&format=mp3&response=url&rid='\\\\n    names = ['320k', '192k', '128k']\\\\n    let urls = []\\\\n    names.forEach(item => {\\\\n        urls.push({\\\\n            url: api + mid + '&br=' + item + 'mp3'\\\\n        })\\\\n    })\\\\n    urls = bf(urls).map(data => JSON.parse(data).url)\\\\n    lyric = lyric.map(i => '[' + getTime(i.time) + ']' + i.lineLyric).join('\\\\\\\\r\\\\\\\\n')\\\\n    return JSON.stringify({\\\\n        urls: urls,\\\\n        names: names,\\\\n        lyric: lyric\\\\n    })\\\\n}\\\\n\\\\nconst getKugouPlayer = (data, name) => {\\\\n    let MusicMap = KugouConfig(data)\\\\n    if (MusicMap.play_url) {\\\\n        return JSON.stringify({\\\\n            urls: [MusicMap.play_url],\\\\n            lyric: MusicMap.lyrics\\\\n        })\\\\n    }\\\\n    return getConfirmSearch(name)\\\\n}\\\\n\\\\nconst getMiguPlayer = (item, name) => {\\\\n    let MusicUrl = 'https://app.c.nf.migu.cn/MIGUM2.0/v1.0/content/sub/listenSong.do?toneFlag=formatType=HQ&netType=00&userId=15548614588710179085069&ua=Android_migu&version=5.1&copyrightId=0&contentId=' + item.contentId + '&resourceType=2&channel=0'\\\\n    let MiguMusic = JSON.parse(request(MusicUrl, {\\\\n        onlyHeaders: true\\\\n    })).url\\\\n    let lyricUrl = 'http://music.migu.cn/v3/api/music/audioPlayer/getLyric?copyrightId=' + item.copyrightId\\\\n    let MiguLyric = MiguConfig(lyricUrl)\\\\n    if (MiguMusic.search('Key') >= 1) {\\\\n        return JSON.stringify({\\\\n            urls: [MiguMusic],\\\\n            lyric: MiguLyric.lyric\\\\n        })\\\\n    }\\\\n    return getConfirmSearch(name)\\\\n}\\\\n\\\\nconst getSearchParse = (layout) => {\\\\n    funMap = ['聚合搜索']\\\\n    switch (storage0.getMyVar('SearchMusicMap', funMap)[0]) {\\\\n        case funMap[0]:\\\\n            layout.push({\\\\n                title: '🔍',\\\\n                desc: \\\\\\\"请输入歌曲名称/关键词\\\\\\\",\\\\n                url: '\\\\\\\"hiker://search?s=\\\\\\\"+input',\\\\n                col_type: \\\\\\\"input\\\\\\\",\\\\n                extra: {\\\\n                    rules: $.toString(() => {\\\\n                        let data = [];\\\\n                        let searchMap = ['网易', '腾讯', '酷我', '酷狗', '咪咕'];\\\\n                        putMyVar('switch', '1')\\\\n                        searchMap.forEach((Map, i) => {\\\\n                            data.push({\\\\n                                \\\\\\\"title\\\\\\\": Map + '音乐',\\\\n                                \\\\\\\"search_url\\\\\\\": \\\\\\\"hiker://empty?searchTerms=**&page=fypage&index=\\\\\\\" + i,\\\\n                                \\\\\\\"searchFind\\\\\\\": \\\\\\\"js: $.require('hiker://page/Search.view?rule=简单音乐');\\\\\\\"\\\\n                            });\\\\n                        })\\\\n                        return JSON.stringify(data);\\\\n                    }),\\\\n                    defaultValue: getMyVar(\\\\\\\"searchKey\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n                    onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n                }\\\\n            });\\\\n            break;\\\\n        default:\\\\n            layout.push({\\\\n                title: '🔍',\\\\n                desc: \\\\\\\"请输入歌曲名称/关键词\\\\\\\",\\\\n                url: $.toString((myname) => {\\\\n                    let keywords = input.trim();\\\\n                    putMyVar('switch', '1')\\\\n                    if (keywords) {\\\\n                        return \\\\\\\"hiker://page/Searchs.view?rule=\\\\\\\" + myname + \\\\\\\"&page=fypage&searchTerms=\\\\\\\" + encodeURIComponent(keywords);\\\\n                    } else {\\\\n                        return \\\\\\\"toast://请输入关键词\\\\\\\";\\\\n                    }\\\\n                }, myname),\\\\n                col_type: \\\\\\\"input\\\\\\\",\\\\n                extra: {\\\\n                    defaultValue: getMyVar(\\\\\\\"searchKey\\\\\\\", \\\\\\\"\\\\\\\"),\\\\n                    onChange: \\\\\\\"putMyVar('searchKey',input)\\\\\\\"\\\\n                }\\\\n            })\\\\n            break;\\\\n    }\\\\n}\\\\n\\\\nconst getSearchsParse = (layout, page) => {\\\\n    addListener('onClose', () => {\\\\n        clearMyVar('searchMap')\\\\n        clearMyVar('switch')\\\\n    })\\\\n    indexs = getMyVar('searchMap', '0')\\\\n    keyword = decodeURIComponent(getParam(\\\\\\\"searchTerms\\\\\\\"));\\\\n    setPageTitle(\\\\\\\"「\\\\\\\" + keyword + \\\\\\\"」#\\\\\\\" + page);\\\\n    if (page === 1) {\\\\n        searchMap = ['网易', '腾讯', '酷我', '酷狗', '咪咕'];\\\\n        searchMap.forEach((item, index) => {\\\\n            layout.push({\\\\n                title: index == indexs ? Rich(Strong(Color(item))) : item,\\\\n                url: $('#noLoading#').lazyRule((empty, index) => {\\\\n                    putMyVar('searchMap', index);\\\\n                    refreshPage();\\\\n                    return empty;\\\\n                }, empty, index),\\\\n                col_type: 'text_5'\\\\n            })\\\\n        })\\\\n    }\\\\n    getSearchSelection(layout, indexs, keyword, page)\\\\n}\\\\n\\\\nconst getSearchSelection = (layout, index, keyword, page) => {\\\\n    switch (index) {\\\\n        case '0':\\\\n            path = '/weapi/cloudsearch/get/web?csrf_token='\\\\n            body = {\\\\n                's': keyword,\\\\n                'limit': 30,\\\\n                'type': 1,\\\\n                'offset': (page - 1) * 30,\\\\n                'csrf_token': ''\\\\n            }\\\\n            data = NetEaseConfig(path, body, 'POST').result.songs\\\\n            NetEaseParse(layout, data)\\\\n            break;\\\\n        case '1':\\\\n            path = 'https://u.y.qq.com/cgi-bin/musicu.fcg'\\\\n            body = {\\\\n                \\\\\\\"req_1\\\\\\\": {\\\\n                    \\\\\\\"method\\\\\\\": \\\\\\\"DoSearchForQQMusicDesktop\\\\\\\",\\\\n                    \\\\\\\"module\\\\\\\": \\\\\\\"music.search.SearchCgiService\\\\\\\",\\\\n                    \\\\\\\"param\\\\\\\": {\\\\n                        \\\\\\\"num_per_page\\\\\\\": 20,\\\\n                        \\\\\\\"page_num\\\\\\\": page,\\\\n                        \\\\\\\"query\\\\\\\": keyword,\\\\n                        \\\\\\\"search_type\\\\\\\": 0\\\\n                    }\\\\n                }\\\\n            }\\\\n            data = request(path, {\\\\n                headers: {\\\\n                    'Referer': 'https://y.qq.com'\\\\n                },\\\\n                body: body,\\\\n                method: 'POST'\\\\n            })\\\\n            data = JSON.parse(data).req_1.data.body.song.list\\\\n            TencentParse(layout, data)\\\\n            break;\\\\n        case '2':\\\\n            path = 'search/music?key=' + keyword + '&pn=' + page\\\\n            data = KwmusiccarConfig(path)\\\\n            KwmusiccarParse(layout, data)\\\\n            break;\\\\n        case '3':\\\\n            path = 'http://mobilecdn.kugou.com/api/v3/search/song?format=json&keyword=' + keyword + '&page=' + page + '&pagesize=20&showtype=1'\\\\n            data = JSON.parse(request(path)).data.info\\\\n            KugouParse(layout, data)\\\\n            break;\\\\n        case '4':\\\\n            path = 'http://pd.musicapp.migu.cn/MIGUM2.0/v1.0/content/search_all.do?&ua=Android_migu&version=5.0.1&text=' + keyword + '&pageNo=' + page + '&pageSize=10&searchSwitch='\\\\n            body = {\\\\n                \\\\\\\"song\\\\\\\": 1,\\\\n                \\\\\\\"album\\\\\\\": 0,\\\\n                \\\\\\\"singer\\\\\\\": 0,\\\\n                \\\\\\\"tagSong\\\\\\\": 0,\\\\n                \\\\\\\"mvSong\\\\\\\": 0,\\\\n                \\\\\\\"songlist\\\\\\\": 0,\\\\n                \\\\\\\"bestShow\\\\\\\": 1\\\\n            }\\\\n            data = MiguConfig(path + JSON.stringify(body)).songResultData.result\\\\n            MiguParse(layout, data)\\\\n            break;\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"聚合\\\",\\\"path\\\":\\\"Search.view\\\",\\\"rule\\\":\\\"require('hiker://page/Config.view?rule=' + '简单音乐')\\\\nconst keyword = getParam(\\\\\\\"searchTerms\\\\\\\") || \\\\\\\"\\\\\\\";\\\\nconst index = getParam(\\\\\\\"index\\\\\\\") || \\\\\\\"0\\\\\\\";\\\\nconst page = MY_PAGE;\\\\nconst layout = []\\\\nclearMyVar('更多功能')\\\\ngetSearchSelection(layout, index, keyword, page)\\\\nsetResult(layout)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"原生\\\",\\\"path\\\":\\\"Searchs.view\\\",\\\"rule\\\":\\\"js:\\\\nrequire('hiker://page/Config.view?rule=' + '简单音乐')\\\\nconst page = MY_PAGE;\\\\nconst layout = []\\\\ngetSearchsParse(layout, page)\\\\nsetResult(layout)\\\"}]\"}","picUrl":"https://p1.music.126.net/7vDL2LYsFJDzkHYWRabQ3Q==/109951167798696543.jpg","title":"我喜欢的音乐"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!