Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@爱听音乐@{"last_chapter_rule":"","title":"爱听音乐","author":"季风","url":"hiker://empty##http://www.2t58.com#fypage","version":4,"col_type":"movie_3","class_name":"","type":"music","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\n$.require(\"home\").Home();","search_url":"http://www.2t58.com/so/**/fypage.html","group":"⑤音频","searchFind":"js:\nvar d = []\nvar html = fetch(MY_URL)\nlet play_list = pdfa(html,\"body&&.play_list&&li\")\nplay_list.forEach((s) => {\n                let title = pdfh(s,\".name&&Text\")\n                let mv = pdfh(s,\".mv&&Text\")\n                let url = mv?\"http://www.2t58.com\"+pdfh(s,\".mv&&a&&href\")+$.require(\"hiker://page/public\").MV:\"http://www.2t58.com\"+pdfh(s,\"a&&href\")+'@rule=js:$.require(\"music\")'\n                d.push({\n                    title:title,\n                    desc:mv?mv:\"歌曲\",\n                    url: \"http://www.2t58.com\"+pdfh(s,\"a&&href\")+'@rule=js:$.require(\"music\")',\n                    //pic_url: img,\n                    //col_type:\"text_1\"\n                })\n            })\nsetResult(d)","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"if (request('hiker://home@α') == 'null') {\n    confirm({\n        title: '依赖检测',\n        content: '检测到缺少小程序,请导入!',\n        confirm: () => {\n            return \"海阔视界首页频道规则【α】￥home_rule_url￥http://hiker.nokia.press/hikerule/rulelist.json?id=6417\"\n        }\n    })\n}","pages":"[{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"home\",\"rule\":\"$.exports.Home = function() {\\n    let d = [];\\n    let page = MY_PAGE \\n    let host = \\\"http://www.2t58.com\\\";\\n    let tubiao = \\\"https://hikerfans.com/tubiao/red/\\\";\\n    let cla = pdfa(fetch(host),\\\"body&&.fed-text-center\\\").concat('<a href=\\\"/love\\\">收藏</a>');\\n    let tu = [\\\"119\\\", \\\"48\\\", \\\"35\\\",\\\"43\\\",\\\"53\\\",\\\"52\\\"];\\n    if(page==1){\\n    cla.forEach((x,i)=> {\\n        let li = pdfh(x,\\\"a&&Text\\\");\\n        let url = pd(x,\\\"a&&href\\\",host)\\n        d.push({\\n            title: getVar(\\\"fenl\\\", \\\"首页\\\") == li ? li.fontcolor('red'): li,\\n            pic: tubiao + tu[i] + \\\".png\\\",\\n            col_type: \\\"icon_small_3\\\",\\n            url: $(\\\"#noLoading#\\\").lazyRule((li,url) => {\\n                let keys = listMyVarKeys();\\n    for (let it of keys) {\\n        clearMyVar(it);\\n    };\\n                putVar(\\\"fenl\\\", li);\\n                putMyVar(\\\"url\\\",url);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },li,url)\\n            })\\n            })\\n            }\\n    function sy(url, d) {\\n        let html = fetch(url)\\n        let Lab = pdfa(html,'body&&.layui-row:lt(4)');\\r\\n        Lab.forEach((x) => {\\n            d.push({\\n                title: \\\"▐ \\\".fontcolor('#20a162')+pdfh(x,\\\"h1&&Text\\\"),\\n                col_type: \\\"rich_text\\\"\\n            })\\n            let item = pdfa(x, 'body&&li');\\r\\n            item.forEach((s) => {\\n                let img = pdfh(s,\\\"img&&src\\\").split('url=')[1]\\n                let title = pdfh(s,\\\".name&&Text\\\")\\n                let url = \\\"http://www.2t58.com\\\"+pdfh(s,\\\"a&&href\\\")\\n                let surl\\n                if(/song/.test(url)){\\n                    surl = url+$.require(\\\"hiker://page/public\\\").lazy\\n                }else if(/video/.test(url)){\\n                    surl= url+$.require(\\\"hiker://page/public\\\").MV\\n                }else if(/list/.test(url)){\\n                    surl= url.replace(/.html/,`/fypage.html`)+'@rule=js:$.require(\\\"playlist\\\")'\\n                }else if(/singer/.test(url)){\\n                    surl= url+'fypage@rule=js:$.require(\\\"singer\\\")'\\n                }\\n                \\n                d.push({\\n                    title:title,\\n                    url: surl,\\n                    pic_url: img,\\n                    col_type: img?\\\"card_pic_3\\\":\\\"text_1\\\",\\n                    extra:{\\n                        inheritTitle: false,\\n                        longClick:[{\\n                            title:\\\"歌曲详情\\\",\\n                            js: $.toString((url) => {\\n                                if(/song/.test(url)){\\n                                return url +'@rule=js:$.require(\\\"music\\\")'}\\n                                else return \\\"toast://这不是歌曲\\\"\\n                                \\n                            },url)\\n                        }]\\n                    }\\n                })\\n            })\\n        })\\n    }\\n    function leib(url,d,page,tag) {\\n    const 下一页 = \\\"pd(html, 'a:matches(下一页)&&href')\\\";\\n   eval(JSON.parse(request('hiker://page/yi?rule=α')).rule)\\nvar 定位信息 = [{\\n    大类定位: 'body&&.ilingku_fl:eq(0)',\\n    小类: 'body&&a',\\n}, {\\n    一级定位: 'body&&.ilingku_fl:gt(0)',\\n    小类: 'body&&a',\\n}];\\nlet true_url = getTruelink(MY_RULE.url, url,page);\\nlet url = true_url\\nlet html = fetch(url);\\nconst dc = dynamicClass({\\n    分类颜色: getRangeColors()\\n});\\ndc.开启折叠()\\ndc.开启搜索(false).创建动态分类(定位信息)\\nvar list = pdfa(html,tag);\\nlist.forEach((s)=> {\\n                let img = pdfh(s,\\\"img&&src\\\").split('url=')[1]\\n                let title = pdfh(s,\\\".name&&Text\\\")\\n                let url = \\\"http://www.2t58.com\\\"+pdfh(s,\\\"a&&href\\\")\\n                let surl\\n                if(/song/.test(url)){\\n                    surl = url+$.require(\\\"hiker://page/public\\\").lazy\\n                }else if(/video/.test(url)){\\n                    surl= url+$.require(\\\"hiker://page/public\\\").MV\\n                }else if(/list/.test(url)){\\n                    surl= url.replace(/.html/,`/fypage.html`)+'@rule=js:$.require(\\\"playlist\\\")'\\n                }else if(/singer/.test(url)){\\n                    surl= url+'fypage@rule=js:$.require(\\\"singer\\\")'\\n                }\\n                d.push({\\n                    title:title,\\n                    url: surl,\\n                    pic_url: img,\\n                    col_type: img?\\\"card_pic_3\\\":\\\"text_1\\\",\\n                    extra:{\\n                        inheritTitle: false,\\n                        longClick:[{\\n                            title:\\\"歌曲详情\\\",\\n                            js: $.toString((url) => {\\n                                if(/song/.test(url)){\\n                                return url +'@rule=js:$.require(\\\"music\\\")'}\\n                                else return \\\"toast://这不是歌曲\\\"\\n                                \\n                            },url)\\n                        }]\\n                    }\\n                })   \\n    })\\nautoPage();\\n    }\\nfunction love(d) {\\n    //感谢🔥🔥🔥大佬的代码\\n    var label = getVar(\\\"label\\\") ? getVar(\\\"label\\\") : \\\"歌曲\\\";\\nif (MY_PAGE == 1) {\\n    d.push({\\n        title: label == \\\"歌曲\\\" ? '““””'+\\\"歌曲\\\".fontcolor('red'):\\\"歌曲\\\",\\n        url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('label','歌曲');refreshPage(false);'toast://切换成功'\\\",\\n        pic_url: \\\"https://hikerfans.com/tubiao/unframed/4.png\\\",\\n        col_type: 'flex_button'\\n    },{\\n        title: label == \\\"歌单\\\" ? '““””'+\\\"歌单\\\".fontcolor('red') : \\\"歌单\\\",\\n        url: \\\"hiker://empty#noLoading#@lazyRule=.js:putVar('label','歌单');refreshPage(false);'toast://切换成功'\\\",\\n        pic_url: \\\"https://hikerfans.com/tubiao/unframed/185.png\\\",\\n        col_type: 'flex_button'\\n    })\\n    var u = label == \\\"歌曲\\\" ? 'hiker://files/rules/mon/爱听音乐/music.txt' : 'hiker://files/rules/mon/爱听音乐/album.txt';\\n    d.push({\\n        title:\\\"批量删除\\\",\\n        pic_url: \\\"https://hikerfans.com/tubiao/unframed/189.png\\\",\\n        col_type: \\\"flex_button\\\",\\n        url: $('#noLoading#').lazyRule((u) => {\\n    const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n    let list = JSON.parse(fetchPC(u) || '[]');\\n    let namelist = list.map(item => item.split('@@')[0]);\\n\\n    hikerPop.multiChoice({\\n        title: \\\"批量删除\\\",\\n        options: namelist,\\n        rightTitle: \\\"确认\\\",\\n        rightClick(options, checked) {\\n            let selectedNames = options.filter((_, i) => checked[i]);\\n            let on = selectedNames.length;\\n            if (on === 0) {\\n                return \\\"toast://最少选择一条！\\\";\\n            }\\n            return $(\\\"确认删除 \\\" + on + \\\" 条？\\\").confirm((list,selectedNames,on,u) => {\\n                list = list.filter(item => !selectedNames.includes(item.split('@@')[0]));\\n                writeFile(u, JSON.stringify(list));\\n                refreshPage(false);\\n                return \\\"toast://成功删除 \\\" + on + \\\" 首！\\\";\\n            },list,selectedNames,on,u);\\n        },\\n        leftTitle: \\\"全部删除\\\",\\n        leftClick() {\\n            return $(\\\"确认删除全部？\\\").confirm((list,u) => {\\n                list = [];\\n                writeFile(u, JSON.stringify(list));\\n                refreshPage(false);\\n                return \\\"toast://删除成功！\\\";\\n            },list,u);\\n        },\\n        centerTitle: \\\"取消\\\"\\n    });\\n\\n    return \\\"hiker://empty\\\";\\n},u)\\n\\n    })\\n}\\n\\nvar str = readFile(u, 0);\\nif (str) {\\n    var list = JSON.parse(str);\\n    list.forEach((list) => {\\n        let url = list.split('@@')[2]\\n       d.push({\\n            title: list.split('@@')[0],\\n            img: list.split('@@')[1],\\n            url: label == \\\"歌曲\\\"?url+$.require(\\\"hiker://page/public\\\").lazy:url.replace(/1/,`fypage`)+'@rule=js:$.require(\\\"playlist\\\")',\\n            col_type: 'card_pic_3',\\n           extra: {\\n              longClick: [{\\n                  title: '取消收藏',\\n                  js: $.toString((list, u) => {\\n                      var data = JSON.parse(fetchPC(u) || '[]');\\n                      data = data.filter(x => x != list);\\n                      writeFile(u, JSON.stringify(data));\\n                      refreshPage();\\n                      return \\\"hiker://empty\\\";\\n                  }, list, u)\\n              },{\\n                  title: \\\"查看详情\\\",\\n                  js: $.toString((url, label) => {\\n                      let Detail = label == \\\"歌曲\\\"?url+'@rule=js:$.require(\\\"music\\\")':url.replace(/1/,`fypage`)+'@rule=js:$.require(\\\"playlist\\\")'\\n                      return Detail\\n                  }, url, label)\\n              }],\\n          }\\n        });\\n    });\\n}\\n    \\n}\\n    if (getVar(\\\"fenl\\\",\\\"首页\\\") == \\\"首页\\\") {\\n        let url = getMyVar(\\\"url\\\",host)\\n        //log(url)\\n        if(page==1){\\n            sy(url, d);\\n            }\\n    } else\\n    if (getVar(\\\"fenl\\\") == \\\"排行\\\") {\\n        let url = getMyVar(\\\"url\\\",host)\\n        let tag = \\\".play_list&&li\\\"\\n        leib(url,d,page,tag)\\n    }else\\n    if (getVar(\\\"fenl\\\") == \\\"歌单\\\") {\\n        let url = getMyVar(\\\"url\\\",host)\\n        let tag = \\\".video_list&&li\\\"\\n        leib(url,d,page,tag)\\n    }else\\n    if (getVar(\\\"fenl\\\") == \\\"歌手\\\") {\\n        let url = getMyVar(\\\"url\\\",host)\\n        let tag = \\\".singer_list&&li\\\"\\n        leib(url,d,page,tag)\\n    }else\\n    if (getVar(\\\"fenl\\\") == \\\"MV\\\") {\\n        let url = getMyVar(\\\"url\\\",host)\\n        let tag = \\\".video_list&&li\\\"\\n        leib(url,d,page,tag)\\n    }else\\n    if (getVar(\\\"fenl\\\") == \\\"收藏\\\") {\\n        love(d)\\n    }\\n    setResult(d)\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"通用\",\"path\":\"public\",\"rule\":\"const lazy = $('').lazyRule(() => {\\n    var host = \\\"http://www.2t58.com\\\"\\n    var id = input.match(/\\\\/song\\\\/([^\\\\/]+)\\\\.html/)[1]\\n    var play = host+'/js/play.php';\\n    var json = JSON.parse(fetch(play,{\\n           headers:{\\n        \\\"User-Agent\\\":\\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36\\\",\\n        \\\"Referer\\\": input\\n                    },\\n           body:'id='+id+'&type=music',\\n    method: 'POST',\\n})).url\\n    var lrc = host+'/plug/down.php?ac=music&lk=lrc&id='+id;\\n    return JSON.stringify({\\n        urls: [json],\\n        lyric: lrc\\n    })\\n});\\nconst MV = $('').lazyRule(() => {\\n    var host = \\\"http://www.2t58.com\\\"\\n    var id = input.match(/\\\\/video\\\\/([^\\\\/]+)\\\\.html/)[1]\\n    var play = host+\\\"/plug/down.php?ac=vplay&id=\\\"+id+\\\"&q=3000\\\"+\\\"#isVideo=true#;{Referer@\\\"+input+\\\"}\\\"\\n    return play\\n});\\nconst 声明 = function (d) {\\n    d.push({\\n    title: '‘‘’’<small><font color=#20b2aa>数据资源收集于网络，海阔不提供任何资源！</font></small>',\\n    desc: '‘‘’’<small><font color=#ff7f50>本规则仅限学习与交流，请导入后24小时内删除，请勿传播！</font></small>',\\n    url: 'hiker://empty',\\n    col_type: 'text_center_1',\\n    extra: {\\n        lineVisible: false\\n    }\\n});\\n\\n  }\\n  function formatSongTitle(title,author) {\\n    var regex = /(.+)[_-](.+)/;\\n    var match = title.match(regex);\\n    \\n    if (match) {\\n        // 判断歌手名字和歌曲名字的位置\\n        var part1 = match[1].trim();\\n        var part2 = match[2].trim();\\n        \\n        if (part1.includes(author)) {\\n            return part2 + \\\" - \\\" + part1;\\n        } else {\\n            return part1 + \\\" - \\\" + part2;\\n        }\\n    }\\n    return title; // 如果不匹配，返回原始标题\\n}\\n$.exports = {\\n    lazy,\\n    MV,\\n    formatSongTitle,\\n    声明\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"歌单\",\"path\":\"playlist\",\"rule\":\"js:\\nvar d = []\\nconst page = MY_PAGE\\nlet html = fetch(MY_URL)\\n    let title = '<strong>'+pdfh(html,'h1&&Text')+'<strong>'+\\\"\\\\n““””\\\"+pdfh(html,\\\".info&&Text\\\").small()\\n    setPageTitle(pdfh(html,'h1&&Text'))\\n    let play_list = pdfa(html,\\\"body&&.play_list&&li\\\")\\n    var img = pdfh(html,\\\".pic&&img&&src\\\")\\n    var listVideos = JSON.parse(fetchPC('hiker://files/rules/mon/爱听音乐/album.txt') || '[]');\\nvar str = pdfh(html,'h1&&Text') + '@@' + img + '@@' + MY_URL;\\nif (listVideos.indexOf(str) == '-1') {\\n    var t = \\\"(未收藏)\\\".small()\\n    var p = \\\"hiker://images/icon_like\\\"\\n} else {\\n    var t = \\\"(已收藏)\\\".fontcolor('red').small()\\n    var p = \\\"hiker://images/icon_like_fill\\\"\\n}\\n\\n    if(page==1){\\n    d.push({\\n        title: title,\\n        url: 'hiker://empty#' + '\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t' + pdfh(html,\\\".info&&Text\\\") + `@rule=js:var res = {}; var d = [];d.push({title:MY_URL.split('hiker://empty#')[1],col_type: 'long_text'});res.data = d; setHomeResult(res);`,\\n        col_type: \\\"text_1\\\",\\n        extra:{\\n            lineVisible:false\\n        }\\n    },{\\n                //title: pdfh(html,\\\".play_list&&h1&&Text\\\")+t,\\n                title: pdfh(html,\\\".play_list&&.pagedata&&Text\\\").small(),\\n                pic_url: img,\\n                url: \\\"hiker://empty\\\",\\n                col_type: \\\"icon_small_3\\\"\\n            },{\\n                title: t,\\n                pic_url: p,\\n                col_type: \\\"icon_small_3\\\",\\n                url: $('#noLoading#').lazyRule((name) => {\\n                var str = fetchPC('hiker://files/rules/mon/爱听音乐/album.txt');\\n                if (!str) {\\n                    var list = [name];\\n                    writeFile('hiker://files/rules/mon/爱听音乐/album.txt', JSON.stringify(list));\\n                } else {\\n                    var list = JSON.parse(str);\\n                    if (list.indexOf(name) == '-1') {\\n                       // list.push(name);\\n                        list.unshift(name);\\n                        writeFile('hiker://files/rules/mon/爱听音乐/album.txt', JSON.stringify(list));\\n                    }else{\\n                      var index = list.indexOf(name);\\n                      list.splice(index, 1);\\n                      writeFile('hiker://files/rules/mon/爱听音乐/album.txt', JSON.stringify(list));\\n                      }\\n                }\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, str)\\n            },{\\n        title: \\\"批量添加\\\".small(),\\n        url:$('#noLoading#').lazyRule((play_list, img) => {\\n    const hikerPop = $.require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=6966\\\");\\n    let list = JSON.parse(fetchPC('hiker://files/rules/mon/爱听音乐/music.txt') || '[]');\\n    let namelist = play_list.map(s => pdfh(s, \\\".name&&Text\\\"));\\n    let newlist = play_list.map(s => pdfh(s, \\\".name&&Text\\\") + '@@' + img + '@@' + \\\"http://www.2t58.com\\\" + pdfh(s, \\\"a&&href\\\"));    \\n    let existingNames = new Set(list.map(item => item.split('@@')[0]));\\n    hikerPop.multiChoice({\\n        title: \\\"批量添加\\\",\\n        options: namelist,\\n        rightTitle: \\\"确认\\\",\\n        rightClick(options, checked) {\\n            let selectedNewList = newlist.filter((_, i) => checked[i]);\\n            let filteredNewList = selectedNewList.filter(item => !existingNames.has(item.split('@@')[0]));\\n            let on = filteredNewList.length;\\n            if (on === 0) {\\n                return \\\"toast://已添加，别重复!\\\";\\n            }\\n            return $(\\\"确认添加 \\\" + on + \\\" 首歌曲？\\\").confirm((list,filteredNewList,on) => {\\n                list = filteredNewList.concat(list);\\n                writeFile('hiker://files/rules/mon/爱听音乐/music.txt', JSON.stringify(list));\\n                refreshPage(false);\\n                return \\\"toast://成功添加 \\\" + on + \\\" 首！\\\";\\n            },list,filteredNewList,on);\\n        },\\n        leftTitle: \\\"全部添加\\\",\\n        leftClick() {\\n            let filteredNewList = newlist.filter(item => !existingNames.has(item.split('@@')[0]));\\n            return $(\\\"确认添加全部歌曲？\\\").confirm((list,filteredNewList) => {\\n                list = filteredNewList.concat(list);\\n                writeFile('hiker://files/rules/mon/爱听音乐/music.txt', JSON.stringify(list));\\n                refreshPage(false);\\n                return \\\"toast://添加成功！\\\";\\n            },list,filteredNewList);\\n        },\\n        centerTitle: \\\"取消\\\"\\n    });\\n    return \\\"hiker://empty\\\";\\n}, play_list, img),\\n     pic_url: \\\"hiker://images/icon_add2\\\",\\n     col_type: \\\"icon_small_3\\\"\\n    },{\\n        col_type: \\\"line_blank\\\"\\n    })    \\n    }\\n    play_list.forEach((s) => {\\n                let title = pdfh(s,\\\".name&&Text\\\")\\n                let url = \\\"http://www.2t58.com\\\"+pdfh(s,\\\"a&&href\\\")\\n                d.push({\\n                    title:title,\\n                    url: url+$.require(\\\"hiker://page/public\\\").lazy,\\n                    pic_url: img,\\n                    col_type:\\\"avatar\\\",\\n                    extra:{\\n                        inheritTitle: false,\\n                        longClick:[{\\n                            title:\\\"歌曲详情\\\",\\n                            js: $.toString((url) => {\\n                                return url +'@rule=js:$.require(\\\"music\\\")'\\n                                \\n                            },url)\\n                        }]\\n                    }\\n                })\\n            })\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"歌手\",\"path\":\"singer\",\"rule\":\"js:\\naddListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"ctitle\\\");\\n        clearMyVar(\\\"curl\\\");\\n}));\\nvar d = []\\nvar html = fetch(MY_URL)\\nconst page = MY_PAGE\\nvar pic = pdfh(html,\\\".pic&&img&&src\\\")\\nvar author = pdfh(html,\\\"h1&&Text\\\")\\nsetPageTitle(author)\\nif(page==1){\\nd.push({\\n    pic_url: pic,\\n    url: pic,\\n    desc: '0',\\n    col_type:\\\"card_pic_2\\\"   \\n},{\\n    title: '““””'+author.fontcolor('#5959AB').big()+\\\"\\\\n\\\\n\\\"+pdfh(html,\\\".info&&Text\\\").substr(0, 66).fontcolor('#5959AB').small(),\\n    url: 'hiker://empty#' + '\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t' + pdfh(html,\\\".info&&Text\\\") + `@rule=js:var res = {}; var d = [];d.push({title:MY_URL.split('hiker://empty#')[1],col_type: 'long_text'});res.data = d; setHomeResult(res);`,\\n    desc: '0',\\n    pic_url: 'https://hjdhnx.coding.net/p/hiker/d/dr/git/raw/master/img/yuedu/13.jpg',\\n    col_type: \\\"card_pic_2\\\",\\n    extra: {\\n        gradient: true\\n    }\\n})\\nvar cla = pdfa(html,\\\".ilingku_fl&&li\\\")\\n    cla.forEach(x => {\\n        let ctitle = pdfh(x,\\\"a&&Text\\\")\\n        let curl = pd(x,\\\"a&&href\\\",MY_URL)\\n        d.push({\\n            title: getMyVar('ctitle', \\\"最新歌曲\\\") == ctitle ? '““””'+ctitle.fontcolor('red').small(): '““””'+ctitle.small(),\\n            url: $('#noLoading##noHistory#').lazyRule((ctitle,curl) => {\\n                putMyVar(\\\"ctitle\\\", ctitle);\\n                putMyVar(\\\"curl\\\",curl);\\n                refreshPage();\\n                return 'hiker://empty'\\n            }, ctitle,curl),\\n            col_type: \\\"flex_button\\\"\\n        });\\n    })\\n    }\\n    var surl = getMyVar(\\\"curl\\\",MY_URL)\\n    //log(surl)\\n    if (getMyVar(\\\"ctitle\\\",\\\"最新歌曲\\\") == \\\"最新歌曲\\\") {\\n        var htmls = fetch(MY_URL.replace(/.html/,`/${page}.html`))\\n        var tags = \\\".play_list&&li\\\"\\n    }else{\\n        var htmls = fetch(surl.replace(/.html/,`/${page}.html`))\\n        var tags = \\\".video_list&&li\\\"\\n    }\\n    var list = pdfa(htmls,tags);\\nlist.forEach((s)=> {\\n                let img = pdfh(s,\\\"img&&src\\\").replace(/120/,'500').split('url=')[1]\\n                let title = pdfh(s,\\\".name&&Text\\\")\\n                let surl = \\\"http://www.2t58.com\\\"+pdfh(s,\\\"a&&href\\\")\\n                let url\\n                if(/song/.test(surl)){\\n                    url = surl+$.require(\\\"hiker://page/public\\\").lazy\\n                }else if(/video/.test(surl)){\\n                    url= surl+$.require(\\\"hiker://page/public\\\").MV\\n                }else if(/album/.test(surl)){\\n                    url= surl.replace(/.html/,`/fypage.html`)+'@rule=js:$.require(\\\"playlist\\\")'\\n                }\\n                d.push({\\n                    title:$.require(\\\"hiker://page/public\\\").formatSongTitle(title,author),\\n                    url: url,\\n                    pic_url: img?img:pic,\\n                    col_type: img?\\\"card_pic_3\\\":\\\"avatar\\\",\\n                    extra:{\\n                        inheritTitle: false,\\n                        longClick:[{\\n                            title:\\\"歌曲详情\\\",\\n                            js: $.toString((surl) => {\\n                                if(/song/.test(surl)){\\n                                return surl +'@rule=js:$.require(\\\"music\\\")'}\\n                                else return \\\"toast://这不是歌曲\\\"\\n                                \\n                            },surl)\\n                        }]\\n                    }\\n                })   \\n    })\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"歌曲\",\"path\":\"music\",\"rule\":\"js:\\nvar d = []\\nlet html = fetch(MY_URL)\\n    let title = pdfh(html,'h1&&Text').replace(' 刷新','')\\n    let play_list = pdfa(html,\\\"body&&.play_list\\\")\\n    let djpic = pdfh(html,\\\".djpic&&img&&src\\\").replace(/img1/,'img2').replace('300','600')\\n    let author = pdfh(html,\\\".play_singer&&.name&&Text\\\")\\n    let info = pdfh(html,\\\".play_singer&&.info&&Text\\\")\\n    let surl = pd(html,\\\".play_singer&&a&&href\\\")\\n    let spic = pdfh(html,\\\".play_singer&&img&&src\\\")\\n    let album_url = pd(html,\\\".sm&&a&&href\\\")\\n    let album = pdfh(html,\\\".sm&&Text\\\")\\n    let Title = $.require(\\\"hiker://page/public\\\").formatSongTitle(title,author)\\n    var listVideos = JSON.parse(fetchPC('hiker://files/rules/mon/爱听音乐/music.txt') || '[]');\\nvar str = Title + '@@' + djpic + '@@' + MY_URL;\\nif (listVideos.indexOf(str) == '-1') {\\n    var t = \\\"(未收藏)\\\".small()\\n} else {\\n    var t = \\\"(已收藏)\\\".fontcolor('red').small()\\n}\\n\\n    d.push({\\n        title: Title,\\n        desc: album,\\n        url: album_url.replace(/.html/,`/fypage.html`)+'@rule=js:$.require(\\\"playlist\\\")',\\n        col_type: \\\"text_center_1\\\",\\n        extra:{\\n            lineVisible:false\\n        }\\n    },{\\n        url:\\\"toast://点击图片播放\\\",\\n        col_type: \\\"card_pic_3_center\\\"\\n    },{\\n        pic_url: djpic,\\n        title: Title,\\n        url: MY_URL+$.require(\\\"hiker://page/public\\\").lazy,\\n        col_type: \\\"card_pic_3_center\\\",\\n        extra:{\\n            inheritTitle: false\\n        }\\n    },{\\n        url: \\\"toast://点击图片播放\\\",\\n        col_type: \\\"card_pic_3_center\\\"\\n    },{\\n        title: author,\\n        desc: info,\\n        pic_url: spic,\\n        url: surl+'fypage@rule=js:$.require(\\\"singer\\\")',\\n        col_type: \\\"avatar\\\"\\n    })\\n    play_list.forEach((x) => {\\n            d.push({\\n                title: pdfh(x,\\\"h1&&Text\\\")+t,\\n                //desc: t,\\n                pic_url: djpic,\\n                url: $('#noLoading#').lazyRule((name) => {\\n                var str = fetchPC('hiker://files/rules/mon/爱听音乐/music.txt');\\n                if (!str) {\\n                    var list = [name];\\n                    writeFile('hiker://files/rules/mon/爱听音乐/music.txt', JSON.stringify(list));\\n                } else {\\n                    var list = JSON.parse(str);\\n                    if (list.indexOf(name) == '-1') {\\n                       // list.push(name);\\n                        list.unshift(name);\\n                        writeFile('hiker://files/rules/mon/爱听音乐/music.txt', JSON.stringify(list));\\n                    }else{\\n                      var index = list.indexOf(name);\\n                      list.splice(index, 1);\\n                      writeFile('hiker://files/rules/mon/爱听音乐/music.txt', JSON.stringify(list));\\n                      }\\n                }\\n                refreshPage(false);\\n                return 'hiker://empty';\\n            }, str),\\n                col_type: \\\"text_icon\\\"\\n            })\\n            let item = pdfa(x, 'body&&li');\\r\\n            item.forEach((s) => {\\n                let title = pdfh(s,\\\".name&&Text\\\")\\n                let url = pd(s,\\\"a&&href\\\")+'@rule=js:$.require(\\\"music\\\")'\\n                d.push({\\n                    title:title,\\n                    url: url,\\n                    //pic_url: djpic,\\n                    col_type:\\\"text_2\\\"\\n                })\\n            })\\n        })\\n$.require(\\\"hiker://page/public\\\").声明(d)\\nsetResult(d)\\nsetPageTitle(Title)\"}]","icon":"http://www.2t58.com/favicon.ico","proxy":""}
Add Comment
Please, Sign In to add comment
