API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：排行榜-顶了十几年的锅盖头终究还是没了！

xiaomianao666
Mar 18th, 2022
86
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 491.72 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥排行榜-顶了十几年的锅盖头终究还是没了！@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"js:\\nlet html = getResCode()\\n// log(html)\\nlet regex = /window\\\\.__INITIAL_STATE__=(.*?);\\\\(function\\\\(\\\\)\\\\{/\\n// log(MY_URL)\\nif(MY_URL.startsWith('https://api.bilibili.com/x/web-interface/view/detail')) {\\n    let code = JSON.parse(html)\\n    try {\\n        if (code.data.View['redirect_url']) {\\n            MY_URL = code.data.View['redirect_url'];\\n            html = fetch(MY_URL, {});\\n        }\\n    } catch (e) {\\n        log (e.message)\\n    }\\n}\\n// log(html)\\nif (MY_URL.startsWith('https://www.bilibili.com/bangumi/play/') && regex.test(html)) {\\n    // 番剧\\n    // log('匹配：' + RegExp.$1)\\n    let res = JSON.parse(RegExp.$1)\\n    let result = res.newestEp\\n    if(!result) {\\n        result = res.mediaInfo.new_ep\\n    }\\n    setResult(\\\"更新至：第\\\" + result.title + \\\"话\\\")\\n} else if (MY_URL.startsWith('https://api.bilibili.com/x/space/arc/search')) {\\n    // UP 主\\n    let res = JSON.parse(html)\\n    let result = res.data.list.vlist[0].title\\n    setResult(\\\"更新至：\\\" + result)\\n} else {\\n    setResult(\\\"\\\")\\n}\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"代码-一级\",\"path\":\"common\",\"rule\":\"var res = {};\\nvar d = [];\\nif (MY_URL.split('#')[1] == '1') {\\n    //.replace('m.bilibili.com', 'www.bilibili.com').replace(/\\\\?/g, '？？').replace(/\\\\&/g, '＆＆')\\n    d.push({\\n        title: '解析',\\n        url: \\\"'hiker://page/detail?url='+'https://'+input.split('https://')[1]+'#immersiveTheme#'\\\",\\n        col_type: 'input',\\n        desc: '请输入网址或者b站复制的链接'\\n    });\\n\\n    d.push({\\n        url: $(\\\"更多\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://img0.baidu.com/it/u=1612101423,1145982163&fm=253&app=138&f=JPEG?w=500&h=424',\\n        col_type: 'card_pic_1',\\n        desc:\\\"0\\\"\\n    });\\n    d.push({\\n        title: '排行榜',\\n        url: $(\\\"排行榜\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/50.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '直播',\\n        url: $(\\\"直播\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/22.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '时光机',\\n        url: $(\\\"时光机\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/56.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: 'UP',\\n        url: $(\\\"UP主\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/98.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '索引',\\n        url: $(\\\"索引\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/47.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '新番',\\n        url: $(\\\"新番\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/23.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '漫游',\\n        url: $(\\\"漫游\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/83.png',\\n        col_type: 'icon_2'\\n    });\\n\\n    d.push({\\n        title: '登录',\\n        url: 'hiker://page/newlogin',\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/2.png',\\n        col_type: 'icon_2'\\n    });\\n}\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"pic_1_card\",\"name\":\"代码-排行榜\",\"path\":\"phb\",\"rule\":\"//分类\\n\\nif (MY_URL.split('#')[1] == '1') {\\nvar c1 = 'all&bangumi&guochan&douga&music&knowledge&tech&car&life&food&kichiku&fashion&cinephile&origin&rookie&game&ent&dance&movie&tv&documentary&animal&guochuang';\\nvar w1 = '全部&番剧&国创&动画&音乐&知识&科技&汽车&生活&美食&鬼畜&时尚&影视&原创&新人&游戏&娱乐&舞蹈&电影&电视剧&纪录片&动物圈&国创相关';\\nvar word1 = w1.split('&');\\nvar class1 = c1.split('&');\\nvar lab1 = getVar('lab1', '全部');\\nvar key1 = getVar('key1', 'all');\\n\\n    for (var i in word1) {\\n        var a = word1[i];\\n        var b = class1[i];\\n        var c = a + '&' + b;\\n        d.push({\\n            title:  a == lab1 ? getHead(a) : a,\\n            url: $(\\\"#noLoading#\\\").lazyRule((c) => {\\n                putVar(\\\"lab1\\\", c.split('&')[0]);\\n                putVar(\\\"key1\\\", c.split('&')[1]);\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\"\\n            }, c),\\n            col_type: 'scroll_button'\\n        });\\n    }\\n}\\n//分类\\n//log(MY_PAGE)\\n\\nvar url = 'https://www.bilibili.com/v/popular/rank/all';\\n\\nMY_URL = url.replace('all', getVar('key1'));\\n\\nvar ym = request(MY_URL, {}).replace(/\\\\\\\\u002F/g, '/');\\nif (ym.includes('rank-tips')) {\\n\\n    /*提示信息\\n      d.push({\\n        title:'““'+parseDomForHtml(ym,'.rank-tips&&Text')+'””',\\n        col_type:'text_1'\\n      });\\n    提示信息*/\\n\\n    var pi = JSON.parse(ym.split('\\\"rankList\\\":')[1].split(',\\\"rankNote\\\"')[0]);\\n    for (var i = 0; pi != null && i < pi.length; i++) {\\n        var num = i + 1;\\n        var q = JSON.stringify(pi[i]);\\n        if (!pi[i].url) {\\n            var rurl = 'https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + pi[i].bvid;\\n        } else {\\n            var rurl = pi[i].url;\\n        }\\n        \\n        d.push({\\n            title: pi[i].title,\\n            pic_url: pi[i].pic + Referer,\\n            desc: (!q.includes('name') ? pi[i].new_ep.index_show : ('up: ' + pi[i].owner.name)),\\n            url: 'hiker://page/detail?url=' + rurl + '#immersiveTheme#',\\n            col_type: 'pic_1_card'\\n        });\\n        /*\\n        d.push({\\n                title:'No.'+num+'\\\\n\\\\n‘‘<small>'+pi[i].title+'\\\\n'+(!q.includes('name')?pi[i].new_ep.index_show:('up: '+pi[i].owner.name))+'</small>',\\n                pic_url:pi[i].pic+Referer,\\n                desc:'0',\\n                url:'hiker://page/detail?url='+rurl+'#immersiveTheme#',\\n                col_type:'pic_1_card'\\n              });\\n        */\\n    }\\n} else {\\n    d.push({\\n        title: '““节制一点，休息啦！””',\\n        col_type: 'text_center_1'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-up🐷\",\"path\":\"up\",\"rule\":\"const headColor = \\\"#358ccd\\\";\\n\\n//时间戳转换方法\\n/*\\nfunction getLocalTime(nS) { \\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\n     var YMD = sss.split('日')[0].replace('年','-').replace('月','-');\\n     return (YMD)\\n}\\n*/\\nfunction getLocalTime(nS) {\\n    var date = new Date(nS);\\n    var YY = date.getFullYear() + '-';\\n    var MM = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';\\n    var DD = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate());\\n    var time = YY + MM + DD;\\n    return time\\n}\\nvar sr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/收藏.txt\\\",input);putVar('up','');putVar('UP','');putVar('set','');refreshPage(false);\\\"toast://切换成功\\\"`;\\n//时间戳转换\\n\\nvar uid = fetch(\\\"hiker://files/bili/up_cache.txt\\\", {});\\nvar UP_URL = 'https://api.bilibili.com/x/space/arc/search?mid=uid&ps=30&tid=0&keyword=&jsonp=jsonp&pn=' + pagenum + '&order=pubdate';\\nvar up_url = UP_URL.replace(\\\"uid\\\", uid);\\nvar xx = getVar('lb2').split('\\\\n');\\n//更新头像\\nfor (var k in xx) {\\n    if (!xx[k].split('##')[1]) {\\n        try {\\n            var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid=' + xx[k].split('&&')[1] + '&jsonp=jsonp', {})).data.face;\\n        } catch (e) {\\n            var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid=' + xx[k].split('&&')[1] + '&need_top=1', {})).data.cards[0].desc.user_profile.info.face;\\n        }\\n        var face = xx[k] + '##' + pic;\\n        var face = fetch(\\\"hiker://files/bili/up.txt\\\", {}).replace(xx[k], face);\\n        writeFile(\\\"hiker://files/bili/up.txt\\\", face);\\n    }\\n}\\n\\n\\n\\nif (MY_URL.split('#')[1] == '1') {\\n    var s_tab = fetch('hiker://files/bili/收藏.txt', {});\\n    if (getVar(\\\"access_key\\\") && getVar('starid')) {\\n        d.push({\\n            title: s_tab == '推荐' ? '🔴' + getHead(s_tab) : '⚪️推荐',\\n            url: '推荐' + sr,\\n            col_type: 'text_4'\\n        });\\n        d.push({\\n            title: s_tab == '收藏' ? '🔴' + getHead(s_tab) : '⚪️收藏',\\n            url: '收藏' + sr,\\n            col_type: 'text_4'\\n        });\\n        d.push({\\n            title: s_tab == '追番' ? '🔴' + getHead(s_tab) : '⚪️追番',\\n            url: '追番' + sr,\\n            col_type: 'text_4'\\n        });\\n        d.push({\\n            title: s_tab == '追剧' ? '🔴' + getHead(s_tab) : '⚪️追剧',\\n            url: '追剧' + sr,\\n            col_type: 'text_4'\\n        });\\n    }\\n    //自己的关注\\n    var starjson = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid=' + getVar('starid') + '&jsonp=jsonp', {}));\\n    d.push({\\n        title: (getVar('UP') == '关注' ? '☺️' : '') + starjson.data.name,\\n        pic_url: starjson.data.face + Referer,\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('UP', getVar('UP')=='关注'?'折叠':'关注');putVar('set','');clearVar('htm');writeFile('hiker://files/bili/收藏.txt','');refreshPage(false);'toast://'+getVar('UP','专注')\\\",\\n        col_type: 'icon_2_round'\\n    });\\n    //自己的关注\\n\\n    d.push({\\n        title: '<strong>' + '‘‘UP’’' + '</strong>' + (getVar('up', '折叠') == '展开' ? '🙉' : '🙈'),\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('up', getVar('up')=='展开'?'折叠':'展开');putVar('set','');writeFile('hiker://files/bili/收藏.txt','');refreshPage(false);'toast://已'+getVar('up','展开');\\\",\\n        col_type: 'text_4'\\n    });\\n\\n    d.push({\\n        title: getVar('set') != '' ? (getVar('set') == '置顶' ? '<strong>' + '““置顶' + '</strong>' : '<strong>' + '““取关””' + '</strong>') : '设置',\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('set', getVar('set','展开')=='取关'?'置顶':'取关');putVar('up','');putVar('UP','');writeFile('hiker://files/bili/收藏.txt','');refreshPage(false);'toast://'+getVar('set','展开')+'ing~'\\\",\\n        col_type: 'text_4'\\n    });\\n\\n    if (getVar('UP') == '关注') {\\n        if (getVar('htm') == '' || getVar('up') == '展开') {\\n            var urls = [];\\n            var surl = 'https://space.bilibili.com/h5/follow?type=follow&mid=' + getVar('starid');\\n            var id = surl.split('mid=')[1];\\n            var code = fetch(surl, {});\\n            var starlist = JSON.parse('{\\\"my' + code.split('{\\\"my')[1].split('}};')[0] + '}}');\\n\\n            var starls = starlist['list']['getFollowList-page-mid-' + id]['result'];\\n            for (x in starls) {\\n                var yurl = 'https://api.bilibili.com/x/space/arc/search?mid=' + starls[x].mid + '&ps=30&tid=0&keyword=&jsonp=jsonp&pn=fypage&order=pubdate';\\n                urls.push({\\n                    url: yurl.replace(/fypage/g, '1')\\n                });\\n\\n                if (getVar('up') == '展开')\\n                    d.push({\\n                        title: starls[x].uname,\\n                        img: starls[x].face + Referer,\\n                        url: 'hiker://page/gz2?url=' + yurl,\\n                        col_type: 'icon_round_4'\\n                    });\\n            }\\n        }\\n    }\\n    //关注列表\\n\\n    if (getVar('up') == '展开' && getVar('UP') != '关注') {\\n        for (var k in xx) {\\n            var st = uid == xx[k].split('&&')[1].split('##')[0] ? '✓' : '';\\n            var pic = xx[k].split('##')[1];\\n            /*头像获取\\n                try{\\n                 var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+xx[k].split('&&')[1]+'&jsonp=jsonp',{})).data.face;\\n                }catch(e){\\n                   var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid='+xx[k].split('&&')[1]+'&need_top=1',{})).data.cards[0].desc.user_profile.info.face;\\n                }\\n            */\\n            if (!pic) {\\n                var pic = 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif';\\n            }\\n            d.push({\\n                title: st + xx[k].split('&&')[0],\\n                url: 'hiker://empty#' + xx[k].split('&&')[1] + `@lazyRule=.js:input=input.split('#')[1];putVar2('uid',input);writeFile(\\\"hiker://files/bili/up_cache.txt\\\",input);putVar('up','折叠');refreshPage(false);\\\"toast://切换成功\\\";`,\\n                pic_url: pic + Referer,\\n                col_type: 'icon_round_4'\\n            });\\n        }\\n    }\\n\\n    //取关相关\\n\\n    if (getVar('set') == '取关') {\\n\\n        for (var k in xx) {\\n            var st = uid == xx[k].split('&&')[1] ? '✓' : '';\\n            var pic = xx[k].split('##')[1];\\n            /*头像获取\\n                try{\\n                 var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+xx[k].split('&&')[1]+'&jsonp=jsonp',{})).data.face;\\n                }catch(e){\\n                   var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid='+xx[k].split('&&')[1]+'&need_top=1',{})).data.cards[0].desc.user_profile.info.face;\\n                }\\n            */\\n            if (!pic) {\\n                var pic = 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif';\\n            }\\n            d.push({\\n                title: '❌' + st + xx[k].split('&&')[0],\\n                url: xx[k] + `@lazyRule=.js:var sc=input+'\\\\\\\\n';var xr=getVar('lb2')+'\\\\\\\\n';var xz=xr.replace(sc,'');writeFile(\\\"hiker://files/rules/js/up.js\\\",xz);refreshPage(false);'toast://取关成功！铁子再见🦆'`,\\n                pic_url: pic + Referer,\\n                col_type: 'icon_round_4'\\n            });\\n        }\\n    }\\n\\n    //置顶相关\\n\\n    if (getVar('set') == '置顶') {\\n\\n        for (var k in xx) {\\n            var st = uid == xx[k].split('&&')[1] ? '✓' : '';\\n            var pic = xx[k].split('##')[1];\\n            /*头像获取\\n                try{\\n                 var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+xx[k].split('&&')[1]+'&jsonp=jsonp',{})).data.face;\\n                }catch(e){\\n                   var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid='+xx[k].split('&&')[1]+'&need_top=1',{})).data.cards[0].desc.user_profile.info.face;\\n                }\\n            */\\n            if (!pic) {\\n                var pic = 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif';\\n            }\\n            d.push({\\n                title: '🔝' + st + xx[k].split('&&')[0],\\n                url: xx[k] + `@lazyRule=.js:var sc=input+'\\\\\\\\n';var xr=getVar('lb2')+'\\\\\\\\n';var xz=xr.replace(sc,'');writeFile(\\\"hiker://files/rules/js/up.js\\\",sc+xz);refreshPage(false);'toast://置顶成功🔝'`,\\n                pic_url: pic + Referer,\\n                col_type: 'icon_round_4'\\n            });\\n        }\\n    }\\n\\n\\n}\\n//d.push({title:xx});\\nif (s_tab == '推荐') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/feed\\\")).rule);\\n} else if (s_tab == '收藏') {\\n    if (MY_URL.split('#')[1] == '1') eval(JSON.parse(fetch(\\\"hiker://page/video\\\")).rule);\\n} else if (s_tab == '追剧') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/dsj\\\")).rule)\\n} else if (s_tab == '追番') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/fanju\\\")).rule)\\n} else if (getVar('UP') != '关注' && getVar('up') != '展开' && getVar('set') == '') {\\n    var json = {};\\n    eval('json=' + fetch(up_url, {}));\\n    for (var i = 0; i < json.data.list.vlist.length; i++) {\\n        var r = {};\\n        var j = json.data.list.vlist[i];\\n        var t = Number(j.created) * 1000;\\n\\n\\n        var time = getLocalTime(t);\\n\\n        if (j.play > 10000)\\n            var play = (j.play / 10000).toFixed(1) + '万';\\n        else\\n            var play = j.play;\\n\\n        var pics = (j.pic.indexOf(':') != -1) ? j.pic : 'https:' + j.pic;\\n\\n        r.pic_url = pics + Referer;\\n        r.url = 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + j.bvid + '#immersiveTheme#';\\n        r.title = j.title;\\n        r.col_type = 'movie_1_vertical_pic';\\n        r.desc = '时长：' + j.length + '  播放量：' + play + '  发布日期：' + time;\\n        if (j.length != \\\"00:00\\\") {\\n            d.push(r)\\n        };\\n    }\\n} else if (getVar('UP') == '关注' && getVar('up') != '展开') {\\n\\n    if (getVar('htm') == '') {\\n        htm = [];\\n        var ym = batchFetch(urls).map(function(a) {\\n            var h = JSON.parse(a).data.list.vlist;\\n            htm = htm.concat(h);\\n        });\\n        htm = htm.sort(function(a, b) {\\n            return b.created - a.created;\\n        }).map(function(a) {\\n            a.created = getLocalTime(Number(a.created) * 1000);\\n            return a\\n        });\\n        putVar('htm', JSON.stringify(htm));\\n    } else htm = JSON.parse(getVar('htm'));\\n    var i = 0;\\n    var k = 0;\\n    var r = new Date();\\n    var M = r.getMonth() + 1;\\n    var tD = r.getFullYear() + '-' + (M < 10 ? ('0' + M) : M) + '-' + (r.getDate() < 10 ? ('0' + r.getDate()) : r.getDate());\\n\\n    for (var j = 0; j < htm.length; j++) {\\n        try {\\n\\n            if (j != 0 && htm[j - 1].created != htm[j].created) i++;\\n\\n            if (i + 1 == MY_URL.split('#')[1]) {\\n                if (k == 0) {\\n                    var date = htm[j].created;\\n                    k++;\\n                    if (date == tD) date = '<strong>今天</strong>';\\n                    d.push({\\n                        title: '““””<font color=\\\"#358ccd\\\">' + date + '<\\\\font>',\\n                        col_type: 'text_center_1',\\n                        //url:`@lazyRule=.js:clearVar('htm');refreshPage(false);'toast://刷新成功';`\\n                    });\\n                }\\n                if (htm[j].play > 10000)\\n                    var play = (htm[j].play / 10000).toFixed(1) + '万';\\n                else\\n                    var play = htm[j].play;\\n                d.push({\\n                    title: htm[j].title,\\n                    img: ((htm[j].pic.indexOf(':') != -1) ? htm[j].pic : ('https:' + htm[j].pic)) + Referer,\\n                    desc: 'UP:' + htm[j].author + '  时长：' + htm[j].length + '\\\\n播放量：' + play + '  发布日期：' + htm[j].created,\\n                    url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + htm[j].bvid + '#immersiveTheme#',\\n                    col_type: 'movie_1_vertical_pic'\\n                });\\n            } else if (i + 1 > MY_URL.split('#')[1]) {\\n                break;\\n            }\\n        } catch (e) {}\\n    }\\n\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-时光🐔\",\"path\":\"sgj\",\"rule\":\"//分类\\nvar pagenum = MY_URL.split('#')[1];\\nif (MY_URL.split('#')[1]=='1'){\\nvar c2 = '22&212&71&182&138&28&33&185';\\n\\nvar w2 = '鬼畜&美食&综艺&影视&生活&音乐&番剧&电视剧';\\n\\nvar word2 = w2.split('&');\\nvar class2 = c2.split('&');\\nvar lab2 = getVar('lab2', '鬼畜');\\nvar key2 = getVar('key2', '22');\\nfor (var i in word2){\\n    var a = word2[i];\\n    var b = class2[i];\\n    var c = a + '&' + b;\\n    d.push({\\n    title: a==lab2? getHead(a):a,\\n    url: $(\\\"#noLoading#\\\").lazyRule((c)=>{\\n        putVar(\\\"lab2\\\",c.split('&')[0]);\\n        putVar(\\\"key2\\\",c.split('&')[1]);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    }, c),\\n    col_type:'scroll_button'\\n    });\\n}\\n}\\n//分类\\n\\nvar m = Number(fetch(\\\"hiker://files/bili/mouths.txt\\\",{}));\\nvar t = m<0?0:m;\\nvar num1 = Number(t)-12;\\nvar num2 = Number(t)+12;\\nvar num3 = Number(t)-1;\\nvar num4 = Number(t)+1;\\n//var timestamp = Date.parse(new Date());\\nvar timestamp = new Date().getTime();\\nvar stamp1 = timestamp - t*30*24*60*60*1000;\\nvar stamp2 = timestamp - (t+1)*30*24*60*60*1000;\\n/*\\nfunction getLocalTime(nS) { \\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\n     var mm = sss.split('年')[1].split('月')[0];\\n     var dd = sss.split('月')[1].split('日')[0];\\n     var YY = sss.split('年')[0];\\n     var MM = (mm< 10 ? '0' + mm:mm);\\n     var DD = (dd< 10 ? '0' + dd:dd);\\n     return (YY+MM+DD)\\n}\\n*/\\nfunction getLocalTime(nS) { \\nvar date = new Date(nS);\\nvar YY = String(date.getFullYear()); \\nvar MM = String((date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1)); \\nvar DD = String((date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate())); \\nvar time = YY + MM + DD;\\nreturn time\\n}\\n//时间戳转换\\nvar time1 = getLocalTime(stamp1);\\nvar time2 = getLocalTime(stamp2);\\nvar SGJ_URL = 'https://s.search.bilibili.com/cate/search?main_ver=v3&search_type=video&view_type=hot_rank&order=click&copy_right=-1&cate_id=22&page='+pagenum+'&pagesize=10&time_from=time2&time_to=time1';\\nvar URL = SGJ_URL.replace('time1',time1).replace('time2',time2).replace('22',getVar('key2')!=''?getVar('key2'):'22');\\nvar json = JSON.parse(request(URL,{}));\\n\\nif (MY_URL.split('#')[1]=='1'){\\nd.push({\\n          title:'+1年',\\n          url:\\nnum1+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:'-1年',\\n          url:\\nnum2+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:'+1月',\\n          url:\\nnum3+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:'-1月',\\n          url:\\nnum4+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:getHead(('当前时间线: '+time2+'~'+time1)),\\n          \\n          col_type:'text_center_1'\\n       });\\n/*\\nd.push({\\n          title: getLocalTime(timestamp). split('日')[0],\\n          \\n          col_type:'text_center_1'\\n       });\\n*/\\n}\\n/*\\nd.push({\\n          title: getLocalTime(sss),\\n          \\n          col_type:'text_center_1'\\n       });\\n*/\\nfor (var i in json.result)\\n{\\n var r = {};\\n var j = json.result[i];\\n if (j.play>10000)\\n    var play = (j.play/10000).toFixed(1)+'万';\\n else\\n    var play = j.play;\\n d.push({\\n          title:j.title,\\n          img:'https:'+j.pic+Referer,\\n          desc:'up🐷:'+j.author+'\\\\n播放量: '+play+'        发布日期: '+j.pubdate/*+'\\\\n描述:'+j.description*/,\\n          url:\\n'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + j.bvid+'#immersiveTheme#',\\n          col_type:'movie_2'\\n       });\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面-二级\",\"path\":\"detail\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\n//log(MY_RULE.title)\\nvar Referer = '@Referer=http://www.bilibili.com';\\n//颜色\\nvar Colors = [\\\"4\\\", \\\"5\\\", \\\"0\\\", \\\"1\\\", \\\"A\\\", \\\"3\\\", \\\"8\\\", \\\"9\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"E\\\", \\\"6\\\", \\\"7\\\", \\\"F\\\"];\\nvar Color = '#';\\nif (getVar('YS') == '随机') {\\n    for (var i = 0; i < 6; i++) {\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\n        var Color = Color + Colors[num];\\n    }\\n} else {\\n    var Color = \\\"#FA7298\\\";\\n}\\n\\nfunction getHead(title) {\\n    return '‘‘’’<strong><font color=\\\"' + Color + '\\\">' + title + '</front></strong>';\\n}\\n\\nd.push({\\n    desc: '258&&float',\\n    col_type: 'x5_webview_single'\\n});\\nvar bangumi = getResCode();\\nif (MY_URL.indexOf('api.bili') == -1) {\\n    try {\\n        var a = fetch(MY_URL, {});\\n        var b = JSON.parse(a.split('\\\"epList\\\":')[1].split('}]')[0] + '}]');\\n        //log(b)\\n        var rurl = 'https://api.bilibili.com/x/web-interface/view/detail?aid=&bvid=' + b[0].bvid;\\n    } catch (e) {\\n        var a = fetch(MY_URL, {\\n            redirect: false\\n        });\\n        var b = a.split('video/')[1].split('\\\"')[0].split(\\\"?\\\")[0];\\n        var rurl = 'https://api.bilibili.com/x/web-interface/view/detail?aid=&bvid=' + b;\\n    }\\n    var bangumi = fetch(rurl, {});\\n}\\nvar json = JSON.parse(bangumi);\\nvar v = json.data.View;\\nvar p = v.pages;\\nvar card = json.data.Card.card;\\nvar related = json.data.Related;\\nvar tags = fetch(\\\"hiker://files/cache/bilibili2.txt\\\", {});\\nvar setting1 = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili2.txt',input);refreshPage();'toast://正常页面切换成功👌可能并没有什么变化'`;\\nvar setting2 = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili2.txt',input);refreshPage();'toast://隐藏页面切换成功👌可能并没有什么变化'`;\\nvar ts = new Date().getTime();\\nvar like_url = 'https://app.bilibili.com/x/v2/view/like';\\nvar coin_url = 'https://app.bilibili.com/x/v2/view/coin/add';\\nvar add_url = 'https://api.bilibili.com/pgc/app/follow/add';\\nvar del_url = 'https://api.bilibili.com/pgc/app/follow/del';\\nvar content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\nvar c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\nvar l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\nvar xlxz = \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\";\\nvar jxgl = \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\";\\nif (v['redirect_url']) {\\n    var redirect = v['redirect_url'];\\n    var ym = fetch(redirect, {});\\n\\n}\\n\\nevalPrivateJS(\\\"XUiFT1vXYWrUw+Vhpnqlg0N0vAWgpglh8MhZ+9vPD99NJ5VgeFdHmwaKawIy6C0h6FFQhEQ5RhJmV0EQHnL9xybPHAchAL7hZEZd+hbGHV5jeG+nK5Q3ie78puGDb1TJ4fAI7g6ezLIjQMBxN/2XM92YNNPKDHdhLIMQGV69Mq8cTOWjKpZQp0/vgNuxaPQKEzSdHQJue7tTxdSEvDt3s/txdEh/oGzFCCNWeZCUU53zhEhC06q6ZFjZCM+d8FsZ5cXlNJemtegMgJULdTqaVdRwVhVX+1uBQ9Ny0DpsNGx2LwHgOjls9hw14LhEqthEe73yPBGvSgKEBdSYgG7cK7hYVTENeGTiRAzKPQ7jGEqEJ8aadHOHAeSa25aBbzc81hhxgXtialX8Uqepn7k4g2GksqoG3JVI+qTfWZxPWqNM/0jUXbrUTCRZnrzGVow6NwPQXKq3CDKl9i+aZveWz5If5ENEZGiWlW5z4aJSEcexCDsiZlo1/QJIj2rWonE0u54ah2/ZZ//ZGoMBJ+d19GmepkLBD3n2qogKnjZj2rjWqgPadEee1ZIhZ3SGbmTlJf1A4BYIuuPwv4dGZdRoDW64BhC5juCn6wDm7Ymy7BXf1sQaFimEnrSIiHGhM+WKg3IyWecuh/Gk++MmN6AxxcvNAyp8bC4hzBMvZJ/l5tRyapomdCV5BpiXfjkWRnbopIjI+WKB3fCaYyRdeNLERKnElscDiz7UenLprhYc/a4LsGeMMFVZ8Yo8/wGYH38J\\\")\\n\\nvar purl = 'https://www.bilibili.com/video/' + v.bvid;\\nvar mode = fetch(\\\"hiker://files/cache/bilibili.txt\\\", {});\\nvar mode_url = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili.txt',input);refreshPage();'toast://切换成功, 点个视频试试吧(^_^) '`;\\nvar zl = \\\"hiker://empty@lazyRule=.js:putVar('page', getVar('page')=='直链'?'关闭':'直链');refreshPage();if(getVar('page')=='直链'){'toast://点击下方切换清晰度🤟'}else{'toast://已关闭'}\\\";\\nif (mode == 'yhc') {\\n    var lazy = yhc\\n}\\nd.push({\\n    title: v.title,\\n    desc: '描述: ' + v.desc + '　类型: ' + v.tname,\\n    url: tags == 'up' ? 'fan' + setting2 : 'up' + setting1,\\n    img: v.pic + Referer,\\n    col_type: 'movie_1_vertical_pic_blur'\\n});\\nd.push({\\n    title: '  ' + card.name,\\n    pic_url: card.face + Referer,\\n    //url: 'hiker://page/gz1?url=https://space.bilibili.com/h5/follow？？type=follow＆＆mid=' + card.mid,\\n    url: 'hiker://page/ss?url=https://api.bilibili.com/x/space/arc/search？？mid=' + card.mid + '＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate',\\n    col_type: 'icon_2_round'\\n});\\nd.push({\\n    title: '““⭐️Star””',\\n    url: 'hiker://empty#' + card.name + '&&' + card.mid + `@lazyRule=.js:input=input.split('#')[1];var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+input.split(\\\"&&\\\")[1]+'&jsonp=jsonp',{})).data.face;if(!getVar('lb2').includes(input.split('&&')[1].split('##')[0])){var xr=getVar('lb2')+'\\\\\\\\n'+input+'##'+pic;writeFile(\\\"hiker://files/rules/js/up.js\\\",xr);'toast://关注成功'}else{'toast://年轻人，耗子尾汁'}`,\\n    col_type: 'text_2'\\n});\\n\\nfunction request_bili_api(baseUrl, SecretId, SecretKey) {\\n    if (!SecretId || !SecretKey) return request(baseUrl)\\n    eval(getCryptoJS())\\n    let nowDate = new Date();\\n    let dateTime = nowDate.toUTCString();\\n    let source = 'bili-api';\\n    let auth = \\\"hmac id=\\\\\\\"\\\" + SecretId + \\\"\\\\\\\", algorithm=\\\\\\\"hmac-sha1\\\\\\\", headers=\\\\\\\"x-date source\\\\\\\", signature=\\\\\\\"\\\";\\n    let signStr = \\\"x-date: \\\" + dateTime + \\\"\\\\n\\\" + \\\"source: \\\" + source;\\n    let sign = CryptoJS.HmacSHA1(signStr, SecretKey)\\n    sign = CryptoJS.enc.Base64.stringify(sign)\\n    sign = auth + sign + \\\"\\\\\\\"\\\"\\n    return request(baseUrl, {\\n        headers: {\\n            \\\"Source\\\": source,\\n            \\\"X-Date\\\": dateTime,\\n            \\\"Authorization\\\": sign\\n        }\\n    })\\n}\\n\\neval(JSON.parse(fetch(\\\"hiker://page/api\\\")).rule)\\n\\n//自定义api项\\nvar mApi = {\\n    author: '',\\n    type: '',\\n    id: '',\\n    baseUrl: '',\\n    secretId: '',\\n    secretKey: ''\\n}\\nif (mApi.baseUrl && mApi.secretId && mApi.secretKey) {\\n    putVar('api', JSON.stringify(mApi))\\n}\\n\\nvar apiIndexStr = getVar('apiIndex', '')\\nvar apiIndex = parseInt(apiIndexStr)\\n\\n\\ntry {\\n    for (var i = 0; i < p.length; i++) {\\n        var part = v.videos != 1 ? p[i].part : '当前视频无选集，点击此处播放';\\n        putVar('UA', ';{User-Agent@Mozilla/5.0 (Windows NT 10.0\\\\\\\\；\\\\\\\\； WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36＆＆＆＆Referer@https://www.bilibili.com/video}');\\n        evalPrivateJS(\\\"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\\\")\\n\\n        if (v['redirect_url']) {\\n            var ep = JSON.parse(ym.split('\\\"epList\\\":')[1].split('}]')[0] + '}]');\\n            var season_id = ym.split('\\\"season_id\\\":')[1].split(',')[0];\\n            log(season_id)\\n            putVar('aid', String(ep[0].aid));\\n            d.push({\\n                title: mode == '直链' ? getHead('直链') : '直链',\\n                url: '直链' + mode_url,\\n                col_type: 'text_2'\\n            });\\n            d.push({\\n                title: mode == '断插' ? getHead('断插') : '断插',\\n                url: (mode == '断插' ? xlxz : '断插' + mode_url),\\n                col_type: 'text_2'\\n            });\\n            if (getVar('like_type') === '开启' && getVar('access_key')) {\\n                d.push({\\n                    title: '点赞',\\n                    url: $(like_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\n                        var l_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: l_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(l_code);\\n                        return 'toast://' + l_code.data.toast;\\n                    }, ),\\n                    col_type: 'text_4'\\n                });\\n                d.push({\\n                    title: '投币',\\n                    url: $(coin_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\n                        var c_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: c_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(c_code);\\n                        return 'toast://投了1个币';\\n                    }, ),\\n                    col_type: 'text_4'\\n                });\\n                d.push({\\n                    title: '追番',\\n                    url: $(add_url).lazyRule((season_id) => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var add_body_txt = 'access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&season_id=' + season_id + '&statistics={\\\"appId\\\":1,\\\"platform\\\":3,\\\"version\\\":\\\"6.9.1\\\",\\\"abtest\\\":\\\"\\\"}&ts=' + ts + '&sign=c64b4c50832d29e40a3ddeded3667135';\\n                        var add_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: add_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(add_code);\\n                        return 'toast://' + add_code.result.toast;\\n                    }, season_id),\\n                    col_type: 'text_4'\\n                });\\n                d.push({\\n                    title: '取消',\\n                    url: $(del_url).lazyRule((season_id) => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var del_body_txt = 'access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&season_id=' + season_id + '&statistics={\\\"appId\\\":1,\\\"platform\\\":3,\\\"version\\\":\\\"6.9.1\\\",\\\"abtest\\\":\\\"\\\"}&ts=' + ts + '&sign=c64b4c50832d29e40a3ddeded3667135';\\n                        var del_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: del_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(del_code);\\n                        return 'toast://' + del_code.result.toast;\\n                    }, season_id),\\n                    col_type: 'text_4'\\n                });\\n            }\\n            d.push({\\n                title: '',\\n                col_type: 'blank_block'\\n            });\\n\\n\\n\\n            for (var i = 0; i < ep.length; i++) {\\n                var badgeType = ep[i]['badgeType'] === 0 ? ((ep[i]['badge'] != '') ? '💰' : '🆓') : '📢';\\n                var badge = ep[i]['badge'] ? '[' + ep[i]['badge'] + ']' : ''\\n                if (mode == 'X5') {\\n                    var purl = 'x5Rule://' + jx + 'https://www.bilibili.com/bangumi/play/ep' + ep[i]['id'] + '@';\\n                } else {\\n                    var purl = 'https://www.bilibili.com/bangumi/play/ep' + ep[i]['id'];\\n                }\\n                var pics = (ep[i]['cover'].indexOf(':') != -1) ? ep[i]['cover'] : 'https:' + ep[i]['cover'];\\n                var titles = (ep[i]['titleFormat']) ? ep[i]['titleFormat'] : ep[i]['title'];\\n                var desc = (ep[i]['longTitle']) ? ep[i]['longTitle'] : (ep[i]['long_title'] ? ep[i]['long_title'] : '');\\n                evalPrivateJS(\\\"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\\\")\\n\\n                var dc = $(purl).lazyRule(() => {\\n                    eval(\\\"var config =\\\" + fetch(\\\"hiker://files/rules/DuanNian/MyParse.json\\\"));\\n                    eval(request(config.settings.cj));\\n                    return aytmParse(input);\\n                });\\n                d.push({\\n                    title: titles + badgeType,\\n                    img: pics + Referer,\\n                    desc: badge + desc,\\n                    url: (mode == '直链' ? true_url : (mode == '断插' ? dc : purl + lazy)),\\n                    col_type: 'movie_2'\\n                });\\n\\n            }\\n        } else {\\n            putVar('aid', String(v.aid));\\n\\n            d.push({\\n                title: mode == '直链' ? getHead('直链') : '直链', //'直链播放',\\n                url: '直链' + mode_url, //lazy1,\\n                col_type: 'text_2'\\n            });\\n\\n            d.push({\\n                title: mode == 'yhc' ? getHead('萤火虫') : mode == '断插' ? getHead('断插') : '萤火虫',\\n                url: mode == '断插' ? 'yhc' + mode_url : '断插' + mode_url,\\n                col_type: 'text_2'\\n            });\\n            if (getVar('like_type') === '开启') {\\n                d.push({\\n                    title: '点赞',\\n                    url: $(like_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\n                        var l_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: l_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(l_code);\\n                        return 'toast://' + l_code.data.toast;\\n                    }, ),\\n                    col_type: 'text_2'\\n                });\\n                d.push({\\n                    title: '投币',\\n                    url: $(coin_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\n                        var c_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: c_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(c_code);\\n                        return 'toast://投了1个币';\\n                    }, ),\\n                    col_type: 'text_2'\\n                });\\n            }\\n            d.push({\\n                title: '',\\n                col_type: 'blank_block'\\n            });\\n\\n\\n            if (v.videos != 1) {\\n                var rurl = purl + '?p=' + p[i].page;\\n            } else {\\n                var rurl = purl\\n            }\\n            var dc = $(rurl).lazyRule(() => {\\n                eval(\\\"var config =\\\" + fetch(\\\"hiker://files/rules/DuanNian/MyParse.json\\\"));\\n                eval(request(config.settings.cj));\\n                return aytmParse(input);\\n            });\\n            d.push({\\n                title: part,\\n                pic_url: 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif',\\n                url: /*mode == 'X5' ? 'x5Rule://' + jx + rurl + '@' + lazy : (*/ mode == '直链' ? lazy1 : mode == '断插' ? dc : rurl + lazy,\\n                col_type: v.videos != 1 ? 'text_center_1' : 'avatar'\\n            });\\n\\n\\n        }\\n    }\\n\\n    d.push({\\n        col_type: 'line_blank'\\n    });\\n    if (getVar('reply_type') === '开启') {\\n        d.push({\\n            title: '<strong>' + '““评论区””' + (getVar('label') == '评论' ? '““ ⊙””' : '““ ⊕””') + '</strong>',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('label', getVar('label')=='评论'?'关闭':'评论');refreshPage();'toast://'+getVar('label','评论')\\\",\\n            col_type: 'text_2'\\n        });\\n\\n        d.push({\\n            title: '<strong>' + '““推荐区””' + (getVar('label') == '推荐' ? '““ ⊙””' : '““ ⊕””') + '</strong>',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('label', getVar('label')=='推荐'?'关闭':'推荐');refreshPage();'toast://'+getVar('label','推荐')\\\",\\n            col_type: 'text_2'\\n        });\\n\\n\\n        if (getVar(\\\"label\\\") == '评论') {\\n            var rely = JSON.parse(fetch('https://api.bilibili.com/x/v2/reply/main?oid=' + v.aid + '&type=1', {}));\\n            var counts = rely['data']['cursor']['all_count'];\\n            var replies = rely.data.replies;\\n            for (var x in replies) {\\n                var repliesx = replies[x];\\n                var message = replies[x].content.message;\\n                var member = replies[x].member;\\n                d.push({\\n                    title: member.uname,\\n                    img: member.avatar,\\n                    col_type: 'avatar'\\n                });\\n                d.push({\\n                    title: '<small><strong>' + message + '</strong></small>',\\n                    col_type: 'rich_text'\\n                });\\n                var reply = replies[x].replies;\\n                for (var z in reply) {\\n                    var mess = reply[z].content.message;\\n                    var mem = reply[z].member.uname;\\n                    d.push({\\n                        title: '<small>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;' + mem + ':' + mess + '</small>',\\n                        col_type: 'rich_text'\\n                    });\\n                }\\n            }\\n        }\\n\\n        if (getVar(\\\"label\\\") == '推荐') {\\n            for (var r in related) {\\n                d.push({\\n                    title: related[r].title,\\n                    img: related[r].pic,\\n                    desc: related[r].desc,\\n                    url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + related[r].bvid + '#immersiveTheme#',\\n                    col_type: 'movie_2'\\n                });\\n            }\\n        }\\n    }\\n} catch (e) {\\n throw e\\n}\\n\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"页面-关注1\",\"path\":\"gz1\",\"rule\":\"js:\\nvar res = {};var d = [];\\nvar id = MY_URL.split('mid=')[1];\\nvar surl = MY_URL;\\nvar code = fetch(surl,{});\\nvar ym = JSON.parse('{\\\"my'+code.split('{\\\"my')[1].split('}};')[0]+'}}');\\n\\nvar ep = ym['list']['getFollowList-page-mid-'+id]['result'];\\nfor ( x in ep){\\n  var yurl = 'https://api.bilibili.com/x/space/arc/search？？mid='+ep[x].mid+'＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate';\\n    d.push({\\n       title:ep[x].uname,\\n       img:ep[x].face,\\n       url:'hiker://page/gz2?url='+yurl,\\n       col_type:'icon_round_4'\\n       });\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"页面-关注2\",\"path\":\"gz2\",\"rule\":\"js:\\nvar res = {};var d = [];\\nconst headColor=\\\"#358ccd\\\";\\nvar json = {};\\neval('json=' + fetch(MY_URL,{}));\\nfor (var i = 0; i < json.data.list.vlist.length; i++)\\n{\\n var r = {};\\n var j = json.data.list.vlist[i];\\n var t = Number(j.created)*1000;\\n \\n //时间戳转换方法\\n /*\\nfunction getLocalTime(nS) { \\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\n     var YMD = sss.split('日')[0].replace('年','-').replace('月','-');\\n     return (YMD)\\n}\\n*/\\nfunction getLocalTime(nS) { \\nvar date = new Date(nS);\\nvar YY = date.getFullYear()+'-'; \\nvar MM = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1)+'-'; \\nvar DD = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate()); \\nvar time = YY + MM + DD;\\nreturn time\\n}\\n//时间戳转换\\nvar time = getLocalTime(t);\\n\\nif (j.play>10000)\\n    var play = (j.play/10000).toFixed(1)+'万';\\nelse\\n    var play = j.play;\\n\\nvar pics = (j.pic.indexOf(':')!=-1)?j.pic:'https:' + j.pic;\\n\\n if (j.length!=\\\"00:00\\\"){\\n    d.push({\\n     pic_url : pics,\\n     url : 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + j.bvid+'#immersiveTheme#',\\n     title : j.title,\\n     col_type : 'movie_1_left_pic',\\n     desc : '时长：' + j.length + '  播放量：' + play + '  日期：' + time\\n    \\n    });\\n}\\n}\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"movie_3\",\"name\":\"代码块-搜索一级\",\"path\":\"s\",\"rule\":\"try {\\n    var res = {};\\n    var d = [];\\n    var code = getResCode();\\n    var xs = JSON.parse(code.split('video\\\",\\\"data\\\":')[1].split('}]')[0] + '}]');\\n    //if(MY_URL.split('page=')[1]=='1&pagesize=20'){\\n    var page = MY_URL.split('page=')[1].split('&pagesize=')[0];\\n    try {\\n        var w =\\n            JSON.parse(fetch('https://api.bilibili.com/x/web-interface/search/type?keyword=' + MY_URL.split('keyword=')[1].split('&')[0] + '&page=' + page + '&search_type=bili_user&order=totalrank&pagesize=20', {})).data.result;\\n        for (ii = 0; ii < w.length && ii < 2; ii++) {\\n            d.push({\\n                title: 'up：' + w[ii].uname,\\n                img: 'https:' + w[ii].upic,\\n                desc: '关注：' + w[ii].fans,\\n                content: '视频数：' + w[ii].videos,\\n                url: 'hiker://page/ss?url=https://api.bilibili.com/x/space/arc/search？？mid=' + w[ii].mid + '＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate#' + w[ii].uname + '#',\\n            });\\n        }\\n    } catch (e) {\\n        d.push({\\n            title: '‘‘找不到你想要的啊，要不换个关键词？’’',\\n            col_type: 'text_center_1'\\n        });\\n    }\\n    var fan = JSON.parse(code.split('media_bangumi\\\",\\\"data\\\":')[1].split('},{\\\"result_type')[0]);\\n    for (x in fan) {\\n        d.push({\\n            title: fan[x].title.replace(/<em class=\\\"keyword\\\">|<\\\\/em>/g, ''),\\n            img: fan[x].cover,\\n            desc: fan[x].desc,\\n            content: fan[x].cv.replace(/<em class=\\\"keyword\\\">|<\\\\/em>/g, ''),\\n            url: 'hiker://page/detail?url=' + fan[x].goto_url + '#immersiveTheme#',\\n            col_type: 'movie_1_left_pic'\\n        });\\n    }\\n    var fan2 = JSON.parse(code.split('media_ft\\\",\\\"data\\\":')[1].split('},{\\\"result_type')[0]);\\n    for (x in fan2) {\\n        d.push({\\n            title: fan2[x].title.replace(/<em class=\\\"keyword\\\">|<\\\\/em>/g, ''),\\n            img: fan2[x].cover,\\n            desc: fan2[x].desc,\\n            content: fan2[x].cv.replace(/<em class=\\\"keyword\\\">|<\\\\/em>/g, ''),\\n            url: 'hiker://page/detail?url=' + fan2[x].goto_url + '#immersiveTheme#',\\n            col_type: 'movie_1_left_pic'\\n        });\\n    }\\n    //}\\n\\n    for (x in xs) {\\n        d.push({\\n            title: xs[x].title.replace(/<em class=\\\"keyword\\\">|<\\\\/em>/g, ''),\\n            img: 'http:' + xs[x].pic,\\n            desc: xs[x].description,\\n            content: xs[x].author,\\n            url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + xs[x].bvid + '#immersiveTheme#',\\n            col_type: 'movie_1_left_pic'\\n        });\\n    }\\n\\n    res.data = d;\\n    setResult(res);\\n} catch (e) {\\n    var res = {};\\n    var d = [];\\n    var keyword = MY_URL.split('keyword=')[1].split('&page=')[0];\\n    var url = 'https://app.bilibili.com/x/v2/search/type?appkey=1d8b6e7d45233436&build=6270200&c_locale=zh_CN&channel=xiaomi&highlight=1&keyword=' + keyword + '&mobi_app=android&order=totalrank&platform=android&pn=1&ps=20&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.27.0%22%2C%22abtest%22%3A%22%22%7D&ts=1623076140&type=2&user_type=0&sign=5066216febb28a619812e88e5ff1a034';\\n    var code = JSON.parse(request(url, {}));\\n    var list = code.data.items;\\n    for (let x of list) {\\n        d.push({\\n            title: x.title,\\n            img: x.cover,\\n            desc: x.sign,\\n            url: 'hiker://page/ss?url=https://api.bilibili.com/x/space/arc/search?mid=' + x.param + '＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate#' + x.title + '#' + getVar('ua'),\\n            col_type: 'movie_1_left_pic'\\n        });\\n    }\\n    setResult(d);\\n}\"},{\"col_type\":\"movie_1_vertical_pic\",\"name\":\"页面-搜索二级\",\"path\":\"ss\",\"rule\":\"js:\\nvar json = {};\\neval('json=' + getResCode());\\nvar res = {};\\nvar d = [];\\nif (MY_URL.indexOf('pn=1&')!=-1){\\nd.push({\\ntitle:'““关注””',\\nurl:'hiker://empty#'+MY_URL.split('#')[1]+'&&'+MY_URL.split('mid=')[1].split('&')[0]+`@lazyRule=.js:input=input.split('#')[1];var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+input.split(\\\"&&\\\")[1]+'&jsonp=jsonp',{})).data.face;if(!getVar('lb2').includes(input.split('&&')[1].split('&&')[0])){var xr=getVar('lb2')+'\\\\\\\\n'+input+'##'+pic;writeFile(\\\"hiker://files/rules/js/up.js\\\",xr);'toast://关注成功'}else{'toast://年轻人，耗子尾汁'}`,\\ncol_type: 'text_center_1'\\n});\\n}\\n\\nfor (var i = 0; i < json.data.list.vlist.length; i++)\\n{\\n var r = {};\\n var j = json.data.list.vlist[i];\\n var t = Number(j.created)*1000;\\n \\n //时间戳转换方法\\nfunction getLocalTime(nS) { \\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\n     var YMD = sss.split('日')[0].replace('年','-').replace('月','-');\\n     return (YMD)\\n}\\n\\n//时间戳转换\\nvar time = getLocalTime(t);\\n\\nif (j.play>10000)\\n    var play = (j.play/10000).toFixed(1)+'万';\\nelse\\n    var play = j.play;\\n\\nvar pics = (j.pic.indexOf(':')!=-1)?j.pic:'https:' + j.pic;\\n\\n r.pic_url = pics;\\n r.url = 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid='+j.bvid+'#immersiveTheme#',\\n       \\n\\n r.title = j.title;\\n r.desc = '时长：' + j.length + '  播放量：' + play + '  日期：' + time;\\n if (j.length!=\\\"00:00\\\"){d.push(r)};\\n}\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"movie_3\",\"name\":\"代码-预处理\",\"path\":\"ycl\",\"rule\":\"putVar2('ua',';get;utf-8;{User-Agent@Mozilla/5.0 (Linux；； Android 7.0；； wv lite baiduboxapp) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/78.0.3904.96 Mobile Safari/537.36 T7/10.3 SearchCraft/2.6.2 (Baidu；； P1 7.0)}');\\n\\nputVar('key',fetch('hiker://files/rules/bili/key.txt'));\\n\\nputVar('X5',\\\"@lazyRule=.js:var jx = fetch('hiker://files/bili/up_jxcache.txt',{});refreshX5WebView(jx+input);'toast://播放中'\\\");\\n\\nif (!fetch('hiker://files/bili/多合一.txt')) {\\n   writeFile('hiker://files/bili/多合一.txt','UP主');\\n   }\\n\\nif (!fetch('hiker://files/bili/收藏.txt')) {\\n   writeFile('hiker://files/bili/收藏.txt','视频');\\n   }\\n\\nif (fetch(\\\"hiker://files/rules/js/up.js\\\", {})==''){\\n    if (fetch(\\\"hiker://files/bili/up.txt\\\", {})!=''){\\n    writeFile(\\\"hiker://files/rules/js/up.js\\\",fetch(\\\"hiker://files/bili/up.txt\\\", {}));\\n    }\\n    else{\\n      var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid=103256880&jsonp=jsonp',{})).data.face;\\n      writeFile(\\\"hiker://files/rules/js/up.js\\\", \\\"北城&&103256880##\\\"+pic);\\n      }\\n}\\n\\nif (!fetch(\\\"hiker://files/bili/up_cache.txt\\\", {})) {\\n  writeFile(\\\"hiker://files/bili/up_cache.txt\\\", \\\"103256880\\\");\\n}\\n\\nputVar2('lb2',fetch(\\\"hiker://files/rules/js/up.js\\\",{}));\\n\\n/*\\nputVar(\\\"解析口\\\",`hiker://empty#noHistory#@rule=js:var d = [];d.push({desc: '200',url: 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/bili/upjx.html',col_type: 'x5_webview_single'});var titles = fetch(\\\"hiker://files/bili/upjx.txt\\\", {}).split(/\\\\\\\\n/);for(var i = 0; i < titles.length; i++){var t = titles[i].split(\\\"&&\\\");d.push({title:fetch(\\\"hiker://files/bili/up_jxcache.txt\\\",{}) == t[1] ? t[0] + \\\"‘‘（当前）’’\\\" : t[0],desc:t[1],url:t[1] + '@lazyRule=.js:putVar2(\\\"uid\\\",input);writeFile(\\\"hiker://files/bili/up_jxcache.txt\\\",input);back();\\\"toast://修改成功\\\"',col_type: 'text_1'});}setResult(d);`);\\n\\nif (!fetch(\\\"hiker://files/bili/upjx.txt\\\", {})) {\\n  writeFile(\\\"hiker://files/bili/upjx.txt\\\", \\\"全网VIP&&https://jxx.smys8.cn/index.php?url=\\\\n加速&&https://www.cuan.la/m3u8.php?url=\\\");\\n}\\n\\n\\nlet localHtml2 = fetch(\\\"hiker://files/bili/upjx.html\\\", {});\\nlet gitHtml2 = fetch(\\\"https://cdn.jsdelivr.net/gh/Zruiry/hikerview/html/jiexi.html\\\", {}).replace(/jiexi\\\\/jiexi/g,\\\"bili/upjx\\\");\\nif (!localHtml2) {\\n  writeFile(\\\"hiker://files/bili/upjx.html\\\", gitHtml2);\\n  var titles = fetch(\\\"hiker://files/bili/upjx.txt\\\", {});\\n  var t = titles.split(\\\"&&\\\")[1];\\n  writeFile(\\\"hiker://files/bili/up_jxcache.txt\\\",t);\\n}\\n*/\"},{\"col_type\":\"movie_3\",\"name\":\"代码-推荐\",\"path\":\"feed\",\"rule\":\"var url = 'https://app.bilibili.com/x/intl/feed/index?access_key=' + getVar(\\\"access_key\\\") + '&autoplay_card=2&build=6225300&c_locale=zh_CN&channel=master&column=2&device_name=&device_type=0&flush=8&fnval=464&fnver=0&force_host=0&fourk=1&guidance=0&https_url_req=0&mobi_app=android&network=wifi&platform=android&player_net=1&pull=false&qn=80&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.22.5%22%2C%22abtest%22%3A%22%22%7D';\\nvar list = JSON.parse(request(url, {})).data.items;\\nfor (let x of list) {\\n    var url = x.goto == \\\"bangumi\\\" ? \\\"hiker://page/detail?url=\\\" + x.uri.split(\\\"?\\\")[0] + '#immersiveTheme#' : \\\"hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=\\\" + x.param + \\\"＆＆bvid=\\\" + '#immersiveTheme#';\\n    d.push({\\n        title: x.goto == \\\"bangumi\\\" ? \\\"💰\\\" + x.title : x.title,\\n        desc: x.cover_left_1_content_description + \\\" \\\" + x.cover_left_2_content_description + \\\"  \\\" + x.cover_right_text,\\n        pic: x.cover + \\\"@Referer=https://www.bilibili.com/\\\",\\n        url: url,\\n        col_type: 'movie_2'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-新番\",\"path\":\"newbgm\",\"rule\":\"if (MY_URL.split('#')[1]=='1') {\\n\\n    let url = 'https://api.bilibili.com/pgc/app/timeline?access_key=&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&filter_type=0&mobi_app=android&night_mode=0&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=1635952840&sign=6e4df4542d38eee2fabf212885b90c64';\\n    try {\\n        var source_code = JSON.parse(request(url, {}));\\n        var dateline = [{\\n            \\\"code\\\": source_code.result.data[4],\\n            \\\"name\\\": \\\"前日\\\",\\n            \\\"id\\\": \\\"0\\\"\\n        },{\\n            \\\"code\\\": source_code.result.data[5],\\n            \\\"name\\\": \\\"昨日\\\",\\n            \\\"id\\\": \\\"1\\\"\\n        }, {\\n            \\\"code\\\": source_code.result.data[6],\\n            \\\"name\\\": \\\"今日\\\",\\n            \\\"id\\\": \\\"2\\\"\\n        }, {\\n            \\\"code\\\": source_code.result.data[7],\\n            \\\"name\\\": \\\"明日\\\",\\n            \\\"id\\\": \\\"3\\\"\\n        },{\\n            \\\"code\\\": source_code.result.data[8],\\n            \\\"name\\\": \\\"后日\\\",\\n            \\\"id\\\": \\\"4\\\"\\n        }];\\n        if (!getVar('id')) {\\n            putVar('id', '2');\\n        }\\n        let id = getVar('id');\\n        d.push({\\n            title: id == '0' ? getHead('前日') : '前日',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('id', '0');refreshPage();'toast://success!'\\\",\\n            col_type: 'text_5'\\n        });\\n        d.push({\\n            title: id == '1' ? getHead('昨日') : '昨日',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('id', '1');refreshPage();'toast://success!'\\\",\\n            col_type: 'text_5'\\n        });\\n        d.push({\\n            title: id == '2' ? getHead('今日') : '今日',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('id', '2');refreshPage();'toast://success!'\\\",\\n            col_type: 'text_5'\\n        });\\n        d.push({\\n            title: id == '3' ? getHead('明日') : '明日',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('id', '3');refreshPage();'toast://success!'\\\",\\n            col_type: 'text_5'\\n        });\\n        d.push({\\n            title: id == '4' ? getHead('后日') : '后日',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('id', '4');refreshPage();'toast://success!'\\\",\\n            col_type: 'text_5'\\n        });\\n        let list = dateline[id].code.episodes;\\n        for (let x of list) {\\n            let type = (x.published == '1' ? '已发布' : '未发布');\\n            log(type)\\n            d.push({\\n                title: x.title,\\n                desc: '‘‘' + type + '’’\\\\n' + x.pub_index + '\\\\n更新时间：' + getHead(x.pub_time),\\n                url: 'hiker://page/detail?url=' + x.url + '#immersiveTheme#',\\n                img: x.cover+Referer,\\n                col_type:'movie_1_vertical_pic'\\n            });\\n        }\\n    } catch (e) {\\n        d.push({\\n            title: getHead('链接炸了，等修复'),\\n            col_type: 'text_center_1'\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-番剧索引\",\"path\":\"sy\",\"rule\":\"const { CategoriesHeader } = $.require(\\\"hiker://page/categories-header\\\")\\n\\n/**\\n * 获取分类数据源，可动态可静态，自己根据实际情况处理\\n * https://www.bilibili.com/anime/index/\\n */\\nlet mCategories = {}\\nlet catInVar = getVar(MY_RULE.url + \\\"#categories\\\", '')\\nif (getVar(MY_RULE.url + \\\"#categories\\\", '')) {\\n    mCategories = JSON.parse(catInVar)\\n} else {\\n    let catUrl = 'https://www.bilibili.com/anime/index/'\\n    let catSrc = request(catUrl)\\n    // log(catSrc)\\n    let catRegex = /window\\\\.__INITIAL_STATE__=(.*?);\\\\(function\\\\(\\\\)\\\\{/\\n    if (catRegex.test(catSrc)) {\\n        // log(RegExp.$1)\\n        let category = JSON.parse(RegExp.$1)\\n        let mFilters = category.filters;\\n        // log(mFilters)\\n        mFilters.map(filter => mCategories[filter.key] = filter.list)\\n        let orders = category.orders\\n        let mOrders = []\\n        orders.map(order => {\\n            let mOrder = {}\\n            mOrder.name = order.title\\n            mOrder.value = order.key\\n            mOrders.push(mOrder)\\n        })\\n        // log(mOrders)\\n        mCategories['order'] = mOrders\\n    }\\n    putVar(MY_RULE.url + \\\"#categories\\\", JSON.stringify(mCategories))\\n}\\nlet keys = Object.keys(mCategories)\\n// log(mCategories)\\n// log(keys)\\n/**\\n * 组合当前分类链接\\n */\\nlet true_url = getVar(MY_RULE.url, MY_URL)\\ntrue_url = 'https://api.bilibili.com/pgc/season/index/result?'\\nfor (let it of keys) {\\n    let cat_url = getVar(MY_RULE.url + \\\"#\\\" + it, it === 'orders' ? '3' : '-1')\\n    true_url += (cat_url ? '&' + it + '=' + cat_url : '')\\n}\\n// let page = 1\\nconst page = MY_URL.split('#')[1]\\nif(page==1){\\n    \\n}\\ntrue_url = true_url +\\n    '&st=1&sort=0&season_type=1&pagesize=20&type=1' +\\n    '&page=' + page\\n// log(true_url)\\n\\nconst empty = \\\"hiker://empty\\\"\\n\\nCategoriesHeader\\n    .setSubCategoriesItemKey('name', 'value')\\n    .get(d, mCategories, page)\\n/**\\n * 获取当前分类页面源码\\n */\\ntry {\\n    var sylist = JSON.parse(request(true_url, {})).data.list;\\n\\n    /**\\n     * 列表数据源\\n     */\\n    for (let data of sylist) {\\n        d.push({\\n            title: data.title /*+ '/' + data.index_show*/ ,\\n            desc: data.order,\\n            img: data.cover+Referer,\\n            url: 'hiker://page/detail?url=' + data.link + '#immersiveTheme#',\\n            col_type: 'movie_3'\\n        });\\n    }\\n} catch (e) {}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-动态分类模块\",\"path\":\"categories-header\",\"rule\":\"js:\\n/**\\n * 使用说明：\\n * 1.提前建立好 分类所属类型和分类列表 的对应关系，即 get 函数中的 categories\\n * 2.设置子分类数据的 key，调用 setSubCategoriesItemKey(titleKey, urlKey)\\n * 3.然后调用 CategoriesHeader.get(layout, categories, page)\\n *\\n * 支持链式调用，一句话即可调用生成分类，即：\\n * CategoriesHeader\\n *    .setSubCategoriesItemKey(titleKey, urlKey)\\n *    .get(layout, categories, page)\\n *\\n * @type {{setSubCategoriesItemKey: CategoriesHeader.setSubCategoriesItemKey, get: CategoriesHeader.get, categoriesKey: {title: string, url: string}}}\\n */\\nlet CategoriesHeader = {\\n    categoriesKey: {\\n        sub_categories: '',\\n        title: '',\\n        url: '',\\n    },\\n    /**\\n     * 1.设置从分类列表中拿的子分类的数据 key，\\n     *   根据 key 拿到数据后，\\n     *   会自动赋值给 scroll_button 的 { title: item[titleKey], url: item[urlKey] }\\n     *\\n     * @param title_key title 的 key\\n     * @param url_key url 的 key\\n     */\\n    setSubCategoriesItemKey : (title_key, url_key) => {\\n        CategoriesHeader.categoriesKey.title = title_key\\n        CategoriesHeader.categoriesKey.url = url_key\\n        return CategoriesHeader;\\n    },\\n    setSubCategoriesKey: (sub_categories_key) => {\\n        CategoriesHeader.categoriesKey.sub_categories = sub_categories_key\\n        return CategoriesHeader;\\n    },\\n    /**\\n     * 2.获取分类头部\\n     *\\n     * @param layout 当前界面，即常用的 d.push 的 d\\n     * @param categories 分类所属类型和分类列表的对应关系表，\\n     *        如：\\n     *        {\\n     *           \\\"年份\\\": [{ \\\"name\\\": \\\"2021\\\", \\\"value\\\": \\\"2021\\\" }, { \\\"name\\\": \\\"2020\\\", \\\"value\\\": \\\"2020\\\" }...],\\n     *           \\\"排序\\\": [{ \\\"name\\\": \\\"热度\\\", \\\"value\\\": \\\"hot\\\" }, { \\\"name\\\": \\\"时间\\\", \\\"value\\\": \\\"time\\\" }...],\\n     *        }\\n     * @param page 页码\\n     * @param urlListener 额外处理 button 的 url，需要 return\\n     */\\n    get: (layout, categories, page, urlListener) => {\\n        // log(categories)\\n        // 分类所属类型的列表，如：[ \\\"年份\\\", \\\"排序\\\" ]\\n        let category_names = Object.keys(categories)\\n        let types = []\\n        // 根据对应关系表拿分类列表\\n        category_names.map(category_name => {\\n            // 这里会拿到 年份 排序... 其中一个\\n            types.push(categories[category_name]);\\n            // 这里下面对 types 的值进行处理\\n        })\\n        categories = types;\\n        let init_cate = []\\n\\n        for (let i = 0; i < 20; i++) {\\n            init_cate.push(\\\"0\\\")\\n        }\\n\\n        const cate_temp_json = getVar(MY_RULE.title, JSON.stringify(init_cate))\\n        const cate_temp = JSON.parse(cate_temp_json)\\n\\n        if (parseInt(page) === 1) {\\n            /**\\n             * 遍历第 index 层分类\\n             */\\n            categories.forEach((category, index) => {\\n                let sub_category_name = category_names[index]\\n                let sub_categories_key = CategoriesHeader.categoriesKey.sub_categories\\n                let sub_categories = sub_categories_key ? category[sub_categories_key] : category;\\n                // log(category)\\n                /**\\n                 * 在第 index 层分类中遍历该层所有子分类\\n                 */\\n                sub_categories.forEach((item, key) => {\\n                    let title = item[CategoriesHeader.categoriesKey.title]\\n                    let url = escape(item[CategoriesHeader.categoriesKey.url])\\n                    if (urlListener) url = urlListener.onDeal(item, sub_category_name, url)\\n                    layout.push({\\n                        title: key.toString() === cate_temp[index] ? '““””<b><span style=\\\"color: #098AC1\\\">' + title + '</span></b>' : title,\\n                        url: $(url).lazyRule((params) => {\\n                            params.cate_temp[params.index] = params.key.toString()\\n\\n                            putVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\n                            putVar(MY_RULE.url + \\\"#\\\" + params.sub_category_name, input)\\n                            refreshPage(true)\\n                            return \\\"hiker://empty\\\"\\n                        }, {\\n                            cate_temp: cate_temp,\\n                            index: index,\\n                            key: key,\\n                            page: page,\\n                            sub_category_name: sub_category_name\\n                        }),\\n                        col_type: 'scroll_button',\\n                    })\\n                })\\n                layout.push({\\n                    col_type: \\\"blank_block\\\"\\n                });\\n            })\\n        }\\n    }\\n}\\n$.exports.CategoriesHeader=CategoriesHeader\"},{\"col_type\":\"movie_3\",\"name\":\"我的收藏-视频\",\"path\":\"video\",\"rule\":\"var ts = new Date().getTime();\\nvar video_url = 'https://api.bilibili.com/x/v3/fav/folder/space?access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&up_mid=' + getVar('starid') + '&sign=0a51b772f81dc7812cd66226a8325383';\\nvar list = JSON.parse(request(video_url)).data;\\nfor (var x of list) {\\n    d.push({\\n        title: x.name,\\n        img: 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif',\\n        url: \\\"hiker://empty#\\\"+x.id+\\\"@lazyRule=.js:putVar('change',getVar('change')==input.split('#')[1]?'0':input.split('#')[1]);refreshPage();'toast://已刷新'\\\",\\n        col_type: 'avatar'\\n    });\\n    if (getVar('change') == x.id) {\\n        var list2 = x.mediaListResponse.list;\\n        log(list2)\\n        for (var a in list2) {\\n            d.push({\\n                title: list2[a].title,\\n                img: list2[a].cover+Referer,\\n                url:'hiker://page/collection?url=https://api.bilibili.com/x/v3/fav/resource/ids？？access_key='+getVar('access_key')+'＆＆appkey=1d8b6e7d45233436＆＆build=6130400＆＆c_locale=zh_CN＆＆channel=master＆＆media_id='+list2[a].id+'＆＆mid='+getVar('starid')+'＆＆mobi_app=android＆＆platform=android＆＆s_locale=zh_CN＆＆statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D＆＆ts='+ts+'＆＆sign=7e0f1b92f3ef3828b19be66838915007',\\n               // desc: a['media_count'],\\n                col_type: 'movie_1_vertical_pic'\\n            });\\n        }\\n\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"我的收藏-追番\",\"path\":\"fanju\",\"rule\":\"var ts = new Date().getTime();\\nvar video_url = 'https://api.bilibili.com/pgc/app/follow/v2/bangumi?access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&pn=' + pagenum + '&ps=20&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.9.1%22%2C%22abtest%22%3A%22%22%7D&status=2&ts=' + ts + '&sign=1624f9598dca06eb129534e4765f9b1a';\\ntry {\\n    var list = JSON.parse(request(video_url)).result.follow_list;\\n    for (var x of list) {\\n        var 类型 = x.is_finish == 1 ? \\\"完结\\\" : \\\"连载\\\";\\n        var 标识 = x['season_type_name'] + \\\" | \\\" + x.badge;\\n        var desc = x.progress ? 标识 + \\\"\\\\n““\\\" + x.new_ep.index_show + \\\"””\\\\n\\\" + x.progress.index_show : 标识 + \\\"\\\\n““\\\" + x.new_ep.index_show + \\\"””\\\\n\\\";\\n        d.push({\\n            title: x.title + \\\"\\\\t\\\" + getHead(类型),\\n            img: x.new_ep.cover + Referer,\\n            desc: desc,\\n            url: \\\"hiker://page/detail?url=\\\" + x.url + '#immersiveTheme#',\\n            col_type: 'movie_1_vertical_pic'\\n        });\\n    }\\n} catch (e) {}\"},{\"col_type\":\"movie_3\",\"name\":\"我的收藏-追剧\",\"path\":\"dsj\",\"rule\":\"var ts = new Date().getTime();\\nvar video_url = 'https://api.bilibili.com/pgc/app/follow/v2/cinema?access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&pn=' + pagenum + '&ps=20&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.9.1%22%2C%22abtest%22%3A%22%22%7D&status=2&ts=' + ts + '&sign=1624f9598dca06eb129534e4765f9b1a';\\ntry {\\n    var list = JSON.parse(request(video_url)).result.follow_list;\\n    for (var x of list) {\\n        var 类型 = x.is_finish == 1 ? \\\"完结\\\" : \\\"连载\\\";\\n        var 标识 = x['season_type_name'] + \\\" | \\\" + x.areas[0].name;\\n        var desc = x.progress ? 标识 + \\\"\\\\n““\\\" + x.new_ep.index_show + \\\"””\\\\n\\\" + x.progress.index_show : 标识 + \\\"\\\\n““\\\" + x.new_ep.index_show + \\\"””\\\\n\\\";\\n        d.push({\\n            title: x.title + \\\"\\\\t\\\" + getHead(类型),\\n            img: x.new_ep.cover + Referer,\\n            desc: desc,\\n            url: \\\"hiker://page/detail?url=\\\" + x.url + '#immersiveTheme#',\\n            col_type: 'movie_1_vertical_pic'\\n        });\\n    }\\n} catch (e) {}\"},{\"col_type\":\"movie_3\",\"name\":\"我的收藏-收藏\",\"path\":\"collection\",\"rule\":\"js:var res = {};var d = [];\\nvar ts = new Date().getTime();\\nvar code = JSON.parse(request(MY_URL)).data;\\nvar resources = '';\\nfor (var x of code){\\n    var resources = resources + x.id + ':' + x.type + ',';\\n}\\nvar resources = resources.slice(0,resources.length-1);\\nvar url = 'https://api.bilibili.com/x/v3/fav/resource/infos?access_key='+getVar('access_key')+'&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=maste&mid='+getVar('starid')+'&mobi_app=android&platform=android&resources='+resources+'&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts='+ts+'&sign=7e0f1b92f3ef3828b19be66838915007';\\nvar list = JSON.parse(request(url,{})).data;\\nfor (var y of list ){\\nd.push({\\n    title:y.title,\\n    img:y.cover,\\n    desc:'播放量: '+y.cnt_info.play+'  弹幕: '+y.cnt_info.danmaku,\\n    url:'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + y.bvid +'#immersiveTheme#',\\n    col_type:'movie_1_vertical_pic'\\n    });\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"代码-登录\",\"path\":\"login\",\"rule\":\"evalPrivateJS('Lle0naydszQ250IhOydRA1kJr0XnNa/rFlsjiEKZW7retZFeuHNJlPKWME4a9BcfB9B0hTawYM8v+hEwzF3RVN2sR/iH8NvyHY6uzKNgjMbJ85GLEg0JyjPItfGGRgwJFUVNL1ILeRNbae39XVroD7WKUKBPfv7Hwqj2HYFH5uQLpOVZvG4UcYOzAs7j8NiaPEUJMS424Bkbns1Nf6FIDXlfkNIIsWBHWRdO6mp73Vy2vu5hg1aG0AVek5+pQcqakxEM9cWGgCJC5mKpUiZSEtP92sKA9SK+/NHsqf13COtQRiix6gFhyFhLez7+GpuSbLH13k1FDUZkilY7OBP8yCZP+Ym41Yhi/yITx3ElLmgjiBexj0qTLjrKIXnx4DDXiipSw/YpUNdqtgUXHNi98a7cGtLE+95Aqk2DcV/H3OG5hpswSHC2+ilrRLP8+TyLTogrFUaJYMxOmrWwAjUM1FfLs/MSx601W/ueFDAmhO/ZZoUZwf3MYbhtkv+BxgyG/76WfDAQbGARJ94NajZ9pzzvcuXIErgr1D/PugFmhOWHk/MSdFDlBqMDpE8x95Yj6tL4wFsw2OaGOoe8MhsniFYEF8BqMPRed0z7cBC4RGxD5NgV1FKWHAPgZPYFKjgO9glNJv71ISgIo9SKRBEjKmE4cEvb/kJEOCEDLjBQrVsOT11OuZcZudCZEOTzmriGHdPfflKBrFsEh7ylUtPZYEcEpCy1Wh1e1YxNKZhbOuk02wtA7FfHNP0DqIZ83F8RFG38RY36fFI//zLpCMEM8UXhzljw5qoSPvzfheR1/GF3MjjFfszXZ3UCvcBg2wC1OkAVKp0uScGLmeq6QaEbQN2unz02ppFV7eK9H73yD1EElNKCQCkkmB6dxpqtkV6JhRsxigMceXn4dUGt+AtfkA2Kvyme5rkuppBceFvMfhIFsxYGR2UE9+ox6kflYBtPp55Q6ulIKydhrk5TATzM2iv9f9xqYpJIIBntIVIof3OanHJWrEtxQ2c1gcvOt/WbE/lkNdrQ33IOYrOFb2cbZ4M/lh5nVtzijvpYe0M6O5v+IoZMpOiVqse7yNiXhAHxE05ziiVcj9pizpWzIebzO4g+KkaqJrBS6yz5QXmiFcWVESIIIovYHeCKRDLgBojqJdTeIXaR/Ke49st03X2HRw2r0B0Mnif8tEPda1glcBLsTEZEW2hbkdtoEicIRFvki55x9HQtQT4zp2TWp3au7TIzwDitCUbbDOV1zFgSHh0873LlyBK4K9Q/z7oBZoTlh5PzEnRQ5QajA6RPMfeWI+rS+MBbMNjmhjqHvDIbJ4iBp+xXhjc+2rviDaAOyFC9ulvkxza+TW4Mat0hxtYDrIl+DpouejyIMTW8DsvXxPXCAQbmwGlDEAfOiyqtqLQ9Hf8gDXE35Q7ay0yABEej1qKWgrj/YnBbY/dYAOPSHpmlddFLJnKpApdMXvYBswrWF0CRRSb1s7CZRgMfOQzK6Iz6/tehasmOs7Ml9w/Hpn5nKh10+n0iGXMvx5II+SGpoLueCtRmJ7UVVCtDG6xevxYMm04sAGGGJaCDAhGH8icbhIE2b+oqDFEpmU0eY7RtG79hPhL+gXYOyYNUvJqejlbZ1/OdvL5nYy6m30Gwl3z7w5eslZCUA0kaRs5kmUOLvL0QQPD74fagAdqGsLHUGDWb4BzCLF2MYLHy+DsckK3FYJMw0U5qN7L700sVSalf6tK96dWqzn5eIrewf1iGo83Icwz9o81JmuKA1LpISS9098nwAx1qP1FzPcwIhTSVuR8+Aoo1p3Di0WLwNKQNOI8x75DmaE6BLPiDkaDLKJyc+bzX0hIC3sPb2+dfvlksCnK22cGhK25Fs9OFR3rF/VFVSRbDG7+7AqOkE24bokEUjd8nS5Hjqp3D/uk+0XzBy9222X6bJmJhwFlKz46TBVXezzm3dzQW7Ol+0Oqf/Ex2AY+rwP+M6xFRHUX/j2GcGa5mhbJUzRRBdO5IprU2Ns6HtSXC9IqcxW1Vl5bCObMG9+Hvvzu0sG7AWNguZJCsxkJXhhgwf2GB6FPu6+oFRz6D4A05ssDsLLVymZ5cgTbDcbeq19UmiYam3Pn7qWIcjuh9OsN4tiFTrrUEPZIRX9Xk0UGDYfabQ1pXfxM/+ySh8q7dwnVJ/g7luihGOeeNwHXAFAy4n3acPH2XBc/msx5XKgIreORMVY/cFb9Kcm3oWZzzK6+HSP85tkFKKm55hg8Mxwi5Ix9RQE/pGAx1csovSp3jRP0h62o6NhFktCDKWzjEUl9bma28fZyiY4dXBEsHBOpKvBzAA0lRkezTnEvvXs9Z55UrAa8ZhAFux6ZENw4cMTIuSkVfw+V/U/momltJ9vGPgiqb5nZl9Ku7d0ROV15J3QAsbhOxT6SgkIVuguVaTVRcj0HW+mMNYKbQynrNRAqKDeJquVxc9HlPM6L8qPnZIWbbHAfUfGbw0lRlwSuOpF7+A2WJLZ4XzSgHbcMXkulzPPDP9/caRIB8e2VkzEZSPnUiZApWP6wWusHuB39WAM78+NBi4Bp2mxWjLKHLWQMDeIXXhdxecK5qUUfYLgITih9DeFpgLNWcBLGQFbdSNkJ3NWpcG56DajDIuLUa8k00i94cJwAzMkJBxNJb5ehBRkVvWXosmtJBMdRf6NEbsV9u8vpZjNEogUknmltJ9vGPgiqb5nZl9Ku7d1ZqTPzopwZhh+itDpUb0Lr27c5wNAAEjrphOqfe0Nj39CNW0LH4Wxjf2lwlxMtOKR1HQL/CPw51yyYJ/LVrQz+if3iIBNU4nCgObuW5JULTvsQss2RneLCw6rphxgMsdawMEgZ9qCrCM7yTM0EylFxfjiIZKqbK10Bae2NoHD+GuoUKAQp5Su4AqXSfKLzmx4hWbmSiNV7mCB/rdw1ybsPvgAFcG85N53kNjzcPvbKLOOxHXHYVWClBmJprwJtHA6B1WZpGWRx5M/gDmsGzVRmVuBDvmSAZMwIeVr5bzDE86m0NqcmgTNepxwqB+yBBp5Kzd42EAQht2EK5T2zMxvgTzeS/z3K/q5lRHl1zK0J/sQwLx9z8lMVg9RBbAe/eb20VowzcqPde/qi0jHMwGcMaC9duyW56wlGOsnkbeyBQ/PfRSSrkUG/vcaCbTa4IT84ZztpNQRvbeUnIAoPkW/eZ6wOUia4Jsyaw99Wa8+E4LjDmZ0zRhnSHgUyC/yb9rZT2lE1S7JBIk7YZPXyA00a2LgKFG88YzV80hi+AVTwRZPk9wlO7gRS2NR/577nIxG0H22llFscmN1LhI91FD2VbVXbqiKUVjJcVn6/sQcTwwz7tvB6z9yMmrDlyCMvyUdwGI6ur9Eac4qW6EUz1xH2y5TI8AfhxxxOrAQZnERbTMICdfKGQGDJe/TdKRKQtgbpb5Mc2vk1uDGrdIcbWA6zDPu28HrP3IyasOXIIy/JRNdvsX6DlKdYwLnFUQj2t6HQHhtjkOli+tcOnRljAa32orfx79VOuviNq+mOqR1N+CGRF2bmKU1kpDArx4VzDdWJddEra+OkFnONEGz4YecwERZUd77+nnPL2MoCMmEDYcvXIs2EuZHdkTfn1iweogD01QfwqZHNF8HvlBWMU/f6EdzXKLqIgRK2ipAMFgKRvlRbasHPlRusSg0pRNVUCQR5ebNyxqFXhLc2+oedK8JEoLoMEQ5D3fJarYgd9jy6fOiBkG8C9IITB8mytyyswcKtwhy1/1WbHO7Cz/RdqVcyJ34A2q2Z3yui1Q5a1oPmO0NWLfnya4+sRNQrksiQ4HuO26GaZUR8kWzF1OxdduaPVxINMb658csXVuDGZ5MYpWdbckFW6eYPFiu+xSDC/eDzsXAH6FL3PV8OpDUPBmpTek2XXfeKdqU2pS9m7SCiCB5u2qbiKC2c9vBV24M6s8Ra4hmd+Paj4FTytv36SH1bLK8tI1lZz+wif+9ZIAdT22cr57jq+ypMPeN1y59Dqv7pshD+JTI8UgdS4QVlCwF17YrvJHPD42KFEbgQY++0j0dalyHYcgf58QyAl9+nnBJZVUVlIilQ6qEPsHzb6rMbV67YSqZHcLvfCTobRi4paBCEUxcyNLQvJSKcKpZAuf2+8K81zKyz3MdEcurtshnsxQA+ocDC2Oy58iyCK6dSjIrTPiFFQ80Bmpa2D3lscLVmY5IR4ok9tgdBeXI6XZ8u2k9KLJWd+Fqsf8YOQGxO6EH2cCKO2u0+3F/GOz6+/OrutLahqR2mkVGIdJKuXeYGsZnDBgeJgBJZ8rIHC0C0NWLLxijLLFJfzi0pzGIRHW4LAJAhO/fLpSL50RlrhMYvbQs4oZu1pe+79XT5RR88dlXs1r6D4sJHYh6+7x3kPQuMls9rc1nywzBdl35CIZxEw6cACjP8Y4dn6zwNYPnt9QmG2IV4Z4rMVwI5pZQimV4cB1Jyp/yK3vOcFepWba0iNL7xAhEGDts8I7hK/5NHSCzws67TSkJ8UHywGktSTJCT015ypQCaSnKmOOqUimxCahfS4e4f9XtfBlSlGWcZ+yyvLSNZWc/sIn/vWSAHU9jxsCP2pK8IpH8jRyaDxaiGFLxMmQxc5kDgg6vGdP6Ky24A2A0eBieXbgPfXyHs82R456922Jz0pVAGsjP443mxiE+o6Wv3Lndnm0+F/Q1Hkv74PdvImHDN4urGF8tEB+DlCFQ+lFSqh+bCPIvhzhe6Nxzq8Dh+iozunZIofIzrio1gcrBfB0QYdjXG0FTR7pdN54m2MpvEH0yftEo19nrvLK8tI1lZz+wif+9ZIAdT2tHV/CPSsKt7zwcytaGrLaao42D22sswTRLPaG/q6Gi7DjEhhwKlBxjjw7IMytII3NkM8cb+JtEyf8wFkTEFiFLUYimQ/hPXI93zrXk++vqogLru0taXgtlM17qtAfzGQu8yUdI4qqYzeJxXxf0NNZ2oBjeDr2DiwI9OXPUuBHbsL4c3/nw10Em2U6MFBUcrZj/DMaSFxVcZ7MoWl2on8Gm0VowzcqPde/qi0jHMwGcMf9z49egZRQzL7hKSUM5TPt37Amk379ccwpLtPTT23Bh7UhnkdG0GUoHvHsy99GxmQaR4nayO/rQFboqustSFLrO80/PtnH8EJcwQaQYZJzN1b9bD6RrJl6zQIomwMfYuu+m8FsO7zd4/cfr6hiOebHSKZmDPFd3XRJe/9CNnLGLYXJLrYvEvtFzwD8A3n3dhXWPimkAisF0R+7PhQ9VJLWcGh8tqKgoVoZ7kzBGuD7Sh9c+2Sr+SAGH6aHBT4Ft1eswUnb+fnJGhaHSC/SvozKCLmWNrPQ94aZuYyOOv0flPU9Pv9KOQUy+5UudlMvtql7BIJfo4Pih/lK8e1NG9JN0D9MLu2f7+UBBcgncB9EhucKQCJsRhPLgZpX/r+sLgnbS1HcBK56v7qNmPQYzlMLwgUFQF7AdewToe/YiuAbqcKcM1MwLfI4be/gnG4c8R4U9BP1Gl81Z5TLZfWfe1x6V8GzJI987VuK2Y710nlEsIUACp0DA+p3b6qw/bEUG0boLPzoNrITGtOIwEbuXiAjxkvhs/JAvwIG65v6oNSk7YxJZzFNo+j1fIaz0+FBjW5cWf+siOp3vYhkXWo5Sl6aC7nQr9DzhN70TOi9nBzHQRFlR3vv6ec8vYygIyYQNhy9cizYS5kd2RN+fWLB6iAdQ/DF7wyH99zIprINU4Nxevb6HyVJPk51XFB1SIgSIrrpz3Ej3J+VigpgEbhVZ6qsFl8An2UYpAl3xLy1ucBF2xBuqZKYbpJUtD9FwGeRkVyE1tGqjHtQYh/IMgqvfayLZBxiO+V3TC2VPFz2roCxxN8ILzyKCccxIY6EYsg2wLb1b9B+rWH4G8N/rgC9D0rXrnQKEbYp+lXXltwESQgPzrb5EoRPty9diblSBbxr4PwEl/GnxRlFZpYk8DyfFJduN8121X5mRWKU669muG3jI4LsXrhl6BVVMcXN9kaq9qzOr2vTf6Is5OzV+xgQNBDsMidsJ5/8+U+ZLXooktS7zB9DjyEnTQxWXOnhIw4k7Wzj6pm+ZI5W1N30QbVB+QfOIfFzkA8R3ksoDuIxfkg+sY6kPGs7McrSWE2w0WZZTciDomTNz/a/AARGaKLE/e4kg1r0pSEd5Lqfv2GPD0CVG+IIRsq95HMFrXDIff/w9bLK8tI1lZz+wif+9ZIAdT2x9Jcdx8/+EML6sF+RBhZOIizdnUCcvjLvE3dvjT2XBicdQFz71GSOegjg+HfysTa94p46Us/g+iuWHA2sdHuEGYSEnQl/1XkrGI1wOqLc4xW/TxfcJOSBY1fOI2WNAypKSJ3XLq1b4bHlq6BVxRl7ZGpXIA+4TjhjcNWD3hW0hQro0681tHtg7+bjwCsPkvMUz0G5kPZhm/yp1ZuayG8a+hnLAsvu/MlKnPYwrlTFPELPCzrtNKQnxQfLAaS1JMkRyCGvxaTkkQ/ifF7KdzVnxyQ2c88xQwGcJwb5iFwTIrLK8tI1lZz+wif+9ZIAdT2emWu4WD5JL9pYQys6uuTjpUny3GCBqtmlSF7WAqb/SDNNGzyNQ7fa8cz6o2BueH7nsewtLrWI8139kDY7buwIJlZPNrQO14nKC4FRdYTd6tGLRzdzpRQ3YSN1eboqLyDaiDtt2Eeo2SuONSXDKkDPUtDN/yEXhCQcgUN7oLJ0p9TTgsA4Im93RL/HXnEZvqueehEN0RguyiEk6xfqjtG//qrodfXYdZ2XevUA0e3Q1ODqusogZ69NPTwcMIIEB9OjlCdCXtDlGFiwYh9nsKaWYZ2hZz9paAA965yRCRT6FSOLxanRho2EslI/exdY3m6hnaFnP2loAD3rnJEJFPoVKSeV4Hc2K+PHpdmAU7lCi0nC8wS6LVpMSS12B4zm2Jiy//r3rFrCj89wCVM4rWMeHjGNEqIOkcAKIphTn8N+3tWrLuevJCW8uCPmRqNBIx3o5u9Agg2CoxBcbeKhSkgxcsry0jWVnP7CJ/71kgB1PZs8QX0w330Rbt+n+qfGOKgltTi9TUIE+nakOwBUwlGzGCovcjF/eseYfisT1kATZa5CBpREh+fnc3LetLh6lJzbRzCOU7hvYmfqCfQIEE2LK/wnuo7xKFM5xu7wdcbYl7LK8tI1lZz+wif+9ZIAdT2+iFwD087enS9Qmnc+6TtGwyqcszuz6j00BFIS/SbMVhnJAC+ZQWSoOYSszkenPYmkS9yFcPlFfjBZmhDidyKnssry0jWVnP7CJ/71kgB1PbGa2IL2v0JL+05yqpEk1RXRsPddqu9G/gZBwYtb02/64LJUc7mZtw5Kv/4U84of/Zwl4bpqF9az5NJrKKkF/xiyyvLSNZWc/sIn/vWSAHU9h+tl9Qxi87K2h+5/B9WHgzH7X1iy29OZCoMelXD+ClVyyvLSNZWc/sIn/vWSAHU9iESMOovMkB7avWagqdVAZXzc/gbpOlx0gsFjhPwn0uhLe12efa0moU5Z+xasdZL/GCj43tCVBTmFULrvTiygpaGdoWc/aWgAPeuckQkU+hUGhG7LjAMXhktEXburGQZnmctBLaT/3k8tNbHApVgKXjLK8tI1lZz+wif+9ZIAdT23lwKr6chBa0V0BztPzGuIzFXblPx9CPjiaWXHh/siMDLK8tI1lZz+wif+9ZIAdT2P4l02BuKBDE30kv9BbF3Sn/xI8zs49r8XIE2TnGTQXjLK8tI1lZz+wif+9ZIAdT2T9e6lPquATe/wxV3XTSTiUDNG5Ozmy1nzOMSr0Ibjs70+bfFx8h7YBg00AMs6ciKz4mnW7bruOHmC44nXkfswrl5ELh4EtZWSqrhfkapCoKif3iIBNU4nCgObuW5JULTw1AICZyACExn9w6W2iBVIq2UUcWF6N5dkEODGAIwIWp4YQB6wrS0bTwZL/XoGV9XsJw3rz/E24VzsAMYJ1jpKAxI12d70l/zACYCklU/dtRAgUnKfCCxwcLQq4KQqALdumxQwu+dNBBUoX4mPpDzhTnpUcNWeudlTfvdA6VafWFxy0GmLrhbeMqCOq6THp7VOZSVUDp56nnK8Oj0brrm9Ad3Hze4aitTsg2U/fcH+7z1rcEFQrwASuMEgFT/Dbg+0n0+ocGDXogzwsxAZDyaSubRsmtV05BQFTJ/BNvv/uf5kSY9i/97KU7IFmYxl8spwzkTrio4jARH6ZwTXpRlH96TZdd94p2pTalL2btIKIK5Wk74K5wH32SYTshVOf/iyyvLSNZWc/sIn/vWSAHU9sQsVJzm/pYAfNfVhXGRMJ6SoD2ofkH9J+ZSnLfDJE80j8nGWSjfGqnP8m3Q7scl8gdcEsVSDVxqQSxwaiRUwDBh5OTCl7DvoZqDwoixp0O5VqKvyx8WCUyOOffyOrAf55oeUKna5p2IAwctyh4IRnUn19QRxIda+Tx+nKfD4GRgEMP5K78fb/meoPkbAdHPUbCf6yB8yO4+96WmQMqrEiazKeyZtjbvlikbOeMP5fC8m7O1O/CBnhfnOrGYzHZwHkCqcwxAqrB9WkbLLyHMZvp5gGgrIoKGhFHD5bnf9fAzzpQy+w7887DkJyvv2wnOJ+KqlmZAoyHViH43Fz0XaA0RmmBbpHJfABcJl2pAkKoHVUcbd6x5CzRR8/OAtnqOvNtCzihm7Wl77v1dPlFHzx3LK8tI1lZz+wif+9ZIAdT2lhBF3H0Po9FEWCAx+v0nfgUsYWd2iwh89yAMr6aqRdwbMZfcaIPrfMGih8Q6RUSdGNt9r2aW+Q85qHFJti9AfWM+n+lsglw2ycWJm8HBBkFLmQ0WpsNgEAjdSj/+w8Bl1UUwhxnLkc/zsitKLRtrHCrNWRcP9VL3Td8HaUO6fSlqh36Rucfw8TQ1B1MWoupjhPR8OTz+CUkdyKPbE7Uj1UDph9kYaqXPMl1/6mpq02bLK8tI1lZz+wif+9ZIAdT2OPfZqfErPwt8fJloo3FHoZsHj3uNR0yOjISZQFXfhdWYgtUmb3XNIDHoHGxWnq5M6dR/hBBo5V4i+TLZvMUqeFJcR4ny1TDRd8tO3dBd906Rwn/BCqHKOO0GKMvxFA9v8fTm1MPfyrgNlswXAuZjyH9sq+50wlZhqoJMVlK1Uq+t1B8IKYeY2d3/w53tee9gS7tQIESKVLRRSMeycuLgooMHJHghLZdbyJp0Y++kEqq1rALvEKcfudOuS02a1O6E31A9YymQPyV+ogA5Ra7YMiLgQ60T0eoSk+cii4hPKJxe/4be/X32N8pIIBLHnGqTtjElnMU2j6PV8hrPT4UGNblxZ/6yI6ne9iGRdajlKXpoLudCv0POE3vRM6L2cHMdBEWVHe+/p5zy9jKAjJhA2HL1yLNhLmR3ZE359YsHqIAePyCNrDJ35dzUq8sr75k5p9sfsN9f6dzvxAoEgNzgwVzKPFlxWqwzUwazWydGCSWpDlHKgOILYHiLzZdfH5ptcl6PiCDbUgtxNrQPKNgXUBYApK4F/J9xZl9JPw1MrYI1k4Up7GMUaacXtz2ilDPF6TxPBbrSCyiMTvoFZyry6Q5m49vcVKgkROP/PB106zgqzVkXD/VS903fB2lDun0p2yOdEh/CwcuFY2NEUaDuIBogybCoASpGSv/dP/Na99aafB+3vA6xC7sg91gGRmxtlXNvYiCMmDDzCZhMfnf/qhx1f8vIODrjL5id6jxHrmhARcUOxD4j9/58WtJYvamtCzws67TSkJ8UHywGktSTJMpgZtizoAXN59hQ+U5ChIQ0UTjIpCChcAvWp9/CHyo4Rg9/iqiNLSBOW41pYvgGU7tH1iPuhex19bXM5o8E6WCjOynp7NgACV3+RAz4ral1hnaFnP2loAD3rnJEJFPoVC1QOCGDO/o1xXb68gGiHiBCssH7WkTsxTfPTqiuXG2NiWsuoNcP/8447TODwBwQhxa1f3RFL0qVylqGrbPeqfgwQX0TNuBq9D/NTHIyheTuwAoVYG8v4lMj7orvnunUwwgk6UX+3UUbLaAZ4KmtdR3hTsxKiiK4RriEp075EH52ldjRJb4ubI/QX+qdrTLxFwIdYeP/wiikNVOXPMCm7uHvrcIpvhqcVtVEX+G9aL8vPnzc+hHnxA708bD6LfJNga3FyHKiBR3Uf9n0DgHGN5X1hxGlQbm8UTL9LIBviD960V7JQvmqAh/k4pdgG9qw4UghOhjEy5DmCp+dv4RWOUOam5qd+KegkkESOG8kQQepzpQy+w7887DkJyvv2wnOJ8CJRl1EODM0QYzkzMtv8XHLK8tI1lZz+wif+9ZIAdT2CotroRPr9LAL1Kt+d7D3MdtxNasLTuJdDI+qNbb8PTtPut/tDqOPXi11yu4zV33nRY6Fj/ZR5oK8ow7kWmbs0+E8GOhhGjF5a7sb/QXw2QODqusogZ69NPTwcMIIEB9ODCWOKB+1vrFKTFh8fWoOBgLRJrE751k0SaDDlVN3isNJAOsfXjzGvoYzW2bapjGlqyjj6fyBU+5IwN8Fq4lBvgN8YI8VMd8bbwIjvJ5vKWASfAAEBy+LDVc6sXtcsPvWt3+sus9I22zK2Tj7hS6p6Msry0jWVnP7CJ/71kgB1Pbx/aLzSLQmtwO4WRoN22KYVJA3/XzSEgbgnegxqqNOBi3tdnn2tJqFOWfsWrHWS/zv7q2U0HAmSHcb+nttlsVLjMjRwjaOgAtRej3dEvSPVFw/i0aCK0xMQbLKhWbxtQCBklfFaYVFLPZZE0n3S/xj1BPTmFdaUGyZRZ26QDGhOMsry0jWVnP7CJ/71kgB1PYzLNIT67swhJ1TEnIALcUs+5JlwJu7mxTRU4WXAnBP13ge5gVjj1NaJ68wuaPiVh7Ad6UPWWgR6wLIPnTUftFj0p6VXSJPuTeawRRQ4c3crXeQmtCHCpUgXKVotcDdzWATTnOKJVyP2mLOlbMh5vM7+u4fL7M16z87SJEHTTTmm+K9NHNpmSmwJbhasZwdgx/Ad6UPWWgR6wLIPnTUftFjOIihF/C31gsK4EvtuusmUk89cckAP5ivmpyGRL66xKT3bBA/54lVOirVxrZQB/w7TS7l/Ee/2o1KEUL8p7Dto/c5snQJlCSUfDDDOuexmXjAObQgs37bLDyE74YKKbLRdwxJeEkCjDdwLvMuJGrsCOz2OtjAPIQTkjChNJyWCzSEdzXKLqIgRK2ipAMFgKRvlRbasHPlRusSg0pRNVUCQZ3XPgl3qTIlaMHobBQRnP011voh5y6DBMKC16lYND8UfmygclTYsZCedep7UloDqwcjHa6KH8W1WFZ9DXxP3WvYF0RDrYTb4joQmIVV/cJned3cP2Urvplr6LndTrkNqBYApK4F/J9xZl9JPw1MrYI1k4Up7GMUaacXtz2ilDPF6TxPBbrSCyiMTvoFZyry6Q5m49vcVKgkROP/PB106zgqzVkXD/VS903fB2lDun0p2yOdEh/CwcuFY2NEUaDuIOrz5smZuLvIXmWOpEXWiGoIliykpnHcmlZZHlJpVuvoUz0G5kPZhm/yp1ZuayG8a9qRorVXIt/ha94Kc2wfTcvLK8tI1lZz+wif+9ZIAdT2zuZhFqHVFRJUcj0O/eTGLl3BYLVPDUQaL9fHt35Sv6mFIi2EBV7lfkpjlSLRXQO9Czws67TSkJ8UHywGktSTJIHIaw3gXkqAo0ejwJXr22KrbYfJ9G5X89PmCHiypzGJAo03cI20wL2EwW3jTeY7b/YWYCplrNqMCEn8Gok4n6Wfb/mvc3uiSz2Sdm79UiXjJjfL305hU1b+BHjx2KrSCKgEVo/BGRYRt/utyktri6ZBeHBULang6ry+/dRV5N3EsDubJRX6IDZPzj8twQ6Scvkvn4cKC1QZ+TpMURrM/RThBMEETpTfqyO4ZMazVsbIeR04eLG2qZblGXrTv4UEaxT3JyhtNGZeShbg+Pd79/243zXbVfmZFYpTrr2a4beMZtyyg3yaTN9zuRir4LVzoltVduqIpRWMlxWfr+xBxPBRRhZAALeMUAgb5xUDz1SxstcYu6mrfEhPi8+jj+GdkKbiQm2Vyc7dJZVP8UOQ7Dvax98To3jxQADu9byYDiQudH+LlGbtrPPk1BG5stJ1S2p/nmRXZ4IOANLoEDn2zSBF3DMC6ds76jgv35b4yFTxyyvLSNZWc/sIn/vWSAHU9hQv3rswsBH5YnNBO+01/BnOlDL7DvzzsOQnK+/bCc4n4WExriS7DLCZduiEOJkXMvfynpEr1dM8pkO6w9zY+TstfgD4cQkpTIy5Y+GypSnHoDLinR0ifrSjwBRx8/cYnM6UMvsO/POw5Ccr79sJzidyS6lbvcdYyU8b8G6Haz2Sasvg5FeNVummceijoi8zDV1uHzlpJ9buUAbmLP1NweNeuqK6YVvp6vCeE4GhfHyHYKi9yMX96x5h+KxPWQBNlvTv34bJGwsh7cUYXy31wZTOlDL7DvzzsOQnK+/bCc4nicfnIrnymM+RhcVNfZuuu15RVyGa64KPm45QKAWeu0nhTBDQYwFFsH/9TZMRN2lbHt4Yh/cVEh3HoCYFj2AgMUob8Kn1KViDOsve8jmh68upUhmH6I7HeXi1YdTHUj6JhnaFnP2loAD3rnJEJFPoVKJfPwh2GkXD7FqF50GR9GbjwX8fbfjYwordkXs35DopA88+Yu4+SbzgzJKEwiJfq1oJS8CmehucOsLFrRTWmnqAzB8D08TYt4LolBKmOFDp1XVXSVqmaxpHkxzsoG97hs/9pwW5TlKDFuawF+3SPgth8bBlQx6jIaXeRoSYv4j7kjnhczq/BF2+pyfDwSAjSBjXN+A4k4F95IHX+ePEwFzuJtmTCLf9vTAxWE8ocS5eBPeO+sD4Qw/B2/1o7FBhByYstoD3jTb+sx8gY/c9Ivvr3KOjZgOSDzTufy8M7VXhPu2Z7PSNrL9/kmA6ys5v1tKm+jQawv3/QHX42J9y8hA2uLkFaNyO4XxCV0urTpiEWcGMMr+lOEJyd7+nNmKwj8ZDEV+zPmLHLlCHIBtMu4vLK8tI1lZz+wif+9ZIAdT2cvI7cONOUxvnn/he1IEPk6Yacj2re3hKsrmcI8+mO4jLK8tI1lZz+wif+9ZIAdT2VoT5PX7TnVoL33KeqrR7bqczF/F7hcE/04Hl0N1vIs2V8FZQ/uhcuSbsNjcxBQb/HnH96+vP/l/bH02Qv3tVhHQv9cFuqJUEasrTyzCXa0Ir1jkLF8/rhvjcq2jy6i15r6I17eifCiy+dYW6r6vQXWO9pYbO2sniXX2yTxVsokEyTLBg81UD/cCcSmfk6quwcGQtqzz9Sbq624oryQ6u2ZFYno5/+FqbhHRqvNpLewIEQsGkljkrSDCA5NZToac95E5Nzehwh8SCkyohKOhQa1fCZuHdvW9DeBqU8Xis1LvaEXTBw00GgdoKOOCSqqVWdvGhKrLIjya11yBp2LMtzOrs8o3/9knlxSVaERypWZdspAzMsEyjyzggITPjZTT+vkBMydwm0u65NLeSjeKIfex24TN0hun0HlWiHQIU+3Yx6Ypri1tDhwz383QphEyKFhw0hZg1r7lGv0npUopzQvuSZcCbu5sU0VOFlwJwT9d7pgoRnQhufFDByEd/jk0KM+F5+E6k9JVut5AqqqIjDqNTilkTcZch3z1+YnN3YsHbP+AjWHjVcYqHMPeM61uiqeQdqPBRUDAKqHyXzEoRyLJCGnn350uaIs8dxPxXcgo8R/4Q6iMpYTaVHIOpHJnWhJmIrx5H2bcLbfT5/QmMIMW5Lgous15y/AJrR0nVmeVcMJixUr8xB8wOaesqYadFyyvLSNZWc/sIn/vWSAHU9kOYoggul44zIZ61LroFgXKGdoWc/aWgAPeuckQkU+hUPbVc080akkhLXOr7cg8VEUvZbz0HX8hPFsabUD6r+a2MLl0FNyZ2EHYkV7zAB/WNAEZLq3auv+p7ObvX7s/pLlR4YgKVCROBVxlN8g3XWKn369N1jlosqRBdDMfJBBbDTzck883DYJ2NNdVQYjOqgsbKnlq8Y+Pj27d5wC+aZKS5C/7CeSu8frIgbginhf7Q+w218h9AtKTXCQilgeuRLI6ofJTdWtyHBCcaNr7X9hgprR+ZkREewQm0jimN7nC7yyvLSNZWc/sIn/vWSAHU9k8uZEUPrB2V1Lm8lOy3c83HIcRW4E16B7lcpLHqZaepDhkwoC/MauQLNo5iEW2eucejmfgaZNLG1lEQS9oGZBMDxhnQgq/jo7nJYxWGhpDFE6SshSNpkc+3ukXngadfiH9N80APXIXvu8qj+74cHLfOlDL7DvzzsOQnK+/bCc4nhA01ksNWPiLjkAb8UtKJq4iNOL+EDEz6rfYna6EDYD7nts/SOLN3S5xUQwFQR/+LTTp7RbugZ2+6bMqAyZqYe8sry0jWVnP7CJ/71kgB1Pb5rOaRwm1Hfgrlcg1ZEg3RUnnOhF0YYByUYXdBODk7pPMl6S1al9SrHfgymTOdIMbXJFbV72BQljwUK96GV3aQohMjk0/I+RKdi089DgoMbwA3+Vc//eHqh776YNeFhwkNq9AdDJ4n/LRD3WtYJXASt3ivC4u9QBTfb/vCmNJi/fzaes4oJAKuSc0Co+au6RZypx5D5jLNmXM3F8YZpg8yVgQXwGow9F53TPtwELhEbCdUJOg+3WvLXRkWcpZalg4K159aEM/vwYwCq34lxkSFhlKyTUg5RsXfRLpaMhm0eZSHduoDHNf4Z1oggZGzikoGop8c/zroWBoN/aVKmn8s4TyE+UBQezv1fLBeUyBGbH8JXA/5u218EZBBQtw3oqEv8yJ2DcVdKNxmztB8LmnH')\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面-登录\",\"path\":\"pwd-login\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar islogin = fetch('hiker://files/rules/bili/islogin.txt', {});\\nif (islogin === \\\"1\\\") {\\n    d.push({\\n        url: \\\"putVar('my_account',input);refreshPage();'toast://你的账号是' + input;\\\",\\n        col_type: 'input',\\n        title: '账号',\\n        extra: {\\n            onChange: \\\"putVar('my_account',input)\\\",\\n            type: 'textarea',\\n            height: 1,\\n            defaultValue: getVar('my_account')\\n        }\\n    });\\n\\n    d.push({\\n        url: \\\"putVar('my_password',input);refreshPage();'toast://你的密码是' + input\\\",\\n        col_type: 'input',\\n        title: '密码',\\n        extra: {\\n            onChange: \\\"putVar('my_password',input)\\\",\\n            type: 'textarea',\\n            height: 1,\\n            defaultValue: getVar('my_password')\\n        }\\n    })\\n    d.push({\\n        title: \\\"““大会员？(先点我)””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"不是大会员别点确认，否则后果自负\\\").confirm(() => {\\n            putVar(\\\"isvip\\\", \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了大会员。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n    d.push({\\n        title: \\\"““登录(再点我)””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认登录？\\\").confirm(() => {\\n            putVar(\\\"logining\\\", \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n    if (getVar(\\\"logining\\\") === \\\"1\\\") {\\n        if (getVar('my_account') != '' && getVar('my_password') != '') {\\n            // TODO 吐佬说这里可以改成 $.require 用法          \\n            evalPrivateJS(\\\"dtd1P3dTEITonsgrNFfoBigi5ljaz0PeGmbmMjjr9H5nfvsnBw7JFp37cn3egqu0y/0wTW2oU7qtMwQIAiLhESVKBlKkRvW0pnPDdHl7PGwwDT5GM1vBsogb7YDpwmwV8rttad0O5YJBvpjX29hUBpSsiao7l3UebzxNAWYij7YwHWht0jVbh5SL7PXVo149fPSTuxl8A+vLUWi+2WxGrOZ+QvtrYIn28BqS8PS7zf0R0yr9hXzjbMOOX2COdVYKPdbGsxzklV5X2LLmKbPgEfQElCgMZpYune0I8OyI55HLK8tI1lZz+wif+9ZIAdT2dTQvCBb+iHjpR6K0Mr0dfc/jrTd/+nmsmWrkjituq8x2h7U3bZmaxkqYrxSoprLiZvnBkSvEoIiqUUOKimCy01f3tRfSQBeR5lgT5A/xqgd28aEqssiPJrXXIGnYsy3MLZRhSLw5kdSU3Y+dyCa6ZcIDxlOGeSFLmI0OCFbpZe9bY7nKUOai3+THsaFiEEqpd/6nUQF4TZRBgVqjYEFwWJyKAK6DAqoRvB2T0if2wUvOlDL7DvzzsOQnK+/bCc4nyZxdDfQXN6RqB+i6NgTbCjNd4TFX5fWBvHa5pHrTSZAhTW9wFA5wsADB95y+Jx2X9Qk4GLCGstgGcmHm96ap1uWq+K8vGEZEbEjkU52tMS5zz6gm7YhXf8eBYBmEaiLuMeU75Ge2qS6uOoj22ITEUcsry0jWVnP7CJ/71kgB1PYZNynXLl1tfoDY3HZgPakf6D+ADzQYqxqRKZCtlNIya9k8C4H7fbhLDXdWA3oV5yUOgaSXK1OM40FxNyNXpA/ZKS6gY3B1/V2+zpz+Q7Cmue5+qaO0XrDP15hjS4bxnWrOlDL7DvzzsOQnK+/bCc4nXxekuoTVURY7eh+dIF4QOaXmbNjYNkiqnAd85FrXKXoegJZC85B4JVqOWcueipNaHy/dwAhKpnK/5JO7Z6ya2ls2/JvPOCP91e6g4HO+YqEpLqBjcHX9Xb7OnP5DsKa5nprbkIP2knDXXqtMYGRdcigeIRz+OHmnKLm/+WCPa0618EqvMsGg9fpvtUo2/tm0RzYYi8kuFGopTyoikDwi3csry0jWVnP7CJ/71kgB1Pa1ADkvivkncEhPWP4wXCaTwwpZ0G6+YTvyp68thFdAL5xx9+nUa5jWmJUyyQ+r1UsD5sMqinY5b/eDUnxRKKBTzpQy+w7887DkJyvv2wnOJydHPM2ah78eAttSahVCEb/l3Zqi2hFkiZJ8gxPC0PY7/qt2N0n8lHD8+72KTUDIquX565CIQncDW5KfXUZLOnZbs6RTqR00LuPHAxPIHhiabjkNvSVQOzv3awerameSO8sry0jWVnP7CJ/71kgB1PbZfAA+7g+YdTNpeu9LRRooiFwV/9cu5HpEgZ2X6waWdooY1g5pCXKpMu/d7c3hdQfLK8tI1lZz+wif+9ZIAdT2Y96skBtNlvNAx6IGpzKN8eN0OJCm2IqsJJnHXJd1fryCMmECFEeaVbpuKG3V09wAC7SYi7j/bCB+DC11BSaZv8B3pQ9ZaBHrAsg+dNR+0WMtZjK4QlfzsMtgGqdnl/D+\\\")\\n        }\\n    }\\n} else if (islogin === \\\"2\\\") {\\n    d.push({\\n        title: \\\"““已登录！””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认重新登录？(请不要尝试多次登录，否则账号异常)\\\").confirm(() => {\\n            putVar(\\\"islogin\\\", \\\"1\\\");\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n} else if (islogin === \\\"3\\\") {\\n    d.push({\\n        title: \\\"““你需要去客户端改下密码才能登录！！！””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认登录？(请不要尝试多次登录，否则账号异常)\\\").confirm(() => {\\n            putVar(\\\"islogin\\\", \\\"1\\\");\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n} else {\\n    d.push({\\n        title: \\\"““点击进入登录页面””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认登录？(请不要尝试多次登录，否则账号异常)\\\").confirm(() => {\\n            putVar(\\\"islogin\\\", \\\"1\\\");\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"登录页面\",\"path\":\"newlogin\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nd.push({\\n    title: \\\"““方法一””\\\",\\n    url: 'hiker://empty@lazyRule=.js:putVar(\\\"l_id\\\",\\\"1\\\");refreshPage();\\\"toast://刷新成功\\\"',\\n    col_type: 'text_2'\\n});\\nd.push({\\n    title: \\\"““方法二””\\\",\\n    url: 'hiker://empty@lazyRule=.js:putVar(\\\"l_id\\\",\\\"2\\\");refreshPage();\\\"toast://刷新成功\\\"',\\n    col_type: 'text_2'\\n});\\nif (getVar(\\\"l_id\\\") == \\\"1\\\") {\\n    d.push({\\n        title: '操作指引 ①先点击下方第一步进去哔哩手机版网页登录账号 ②返回直接点第二步登录然后按提示登录 ““注:方法一不可用再采用方法二””',\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: \\\"““1. 点我去网页登录后自动获取cookie””\\\",\\n        url: \\\"hiker://page/ck\\\",\\n        col_type: 'text_center_1'\\n    });\\n    d.push({\\n        title: \\\"““2. 再点我登录””\\\",\\n        url: \\\"hiker://page/weblogin\\\",\\n        col_type: 'text_center_1'\\n    });\\n}\\nif (getVar(\\\"l_id\\\") == \\\"2\\\") {\\n    d.push({\\n        title: \\\"操作指引 ①先点击下方第一步进去哔哩手机版网页登录账号 ②点击右下角设置→查看源码→原生界面 ③复制最上方输入框里的链接 ④返回首页把链接输入框内 ⑤点击第二步，按提示登录即可\\\",\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: '保存',\\n        url: \\\"var ck = 'SESSDATA'+input.split('SESSDATA')[1].split('sid')[0].replace('；；','; ');writeFile('hiker://files/rules/bili/bilick.txt',ck.replace('；；','; '));refreshPage();'toast://您的cookie是:'+ck\\\",\\n        col_type: 'input',\\n        desc: '请输入链接'\\n    });\\n    d.push({\\n        title: \\\"““1. 点我去网页登录后手动获取cookie””\\\",\\n        url: \\\"https://m.bilibili.com/\\\",\\n        col_type: 'text_center_1'\\n    });\\n    d.push({\\n        title: \\\"““2. 点我登录””\\\",\\n        url: \\\"hiker://page/weblogin\\\",\\n        col_type: 'text_center_1'\\n    });\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"cookie获取\",\"path\":\"ck\",\"rule\":\"js:\\nsetResult([{\\n    col_type: \\\"x5_webview_single\\\",\\n    url: \\\"https://m.bilibili.com/\\\",\\n    desc: \\\"float&&100%\\\",\\n    extra: {\\n        js: $.toString(() => {\\n            fba.log(document.cookie)\\n            fy_bridge_app.writeFile('hiker://files/rules/bili/bilick.txt', fy_bridge_app.getCookie('https://m.bilibili.com/'));\\n        })\\n    }\\n}])\"},{\"col_type\":\"movie_3\",\"name\":\"页面-web登录\",\"path\":\"weblogin\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar ck = fetch(\\\"hiker://files/rules/bili/bilick.txt\\\").replace(/；； /g,'; ');\\nlog(ck)\\nvar login_url = \\\"https://passport.bilibili.com/login/app/third?appkey=27eb53fc9058f8c3&api=http%3A%2F%2Flink.acg.tv%2Fforum.php&sign=67ec798004373253d60114caaad89a8c\\\";\\nvar location = JSON.parse(fetch(login_url, {\\n    headers: {\\n        \\\"user-agent\\\": \\\"Mozilla/5.0 (Linux; Android 10; M2007J3SC Build/QKQ1.200419.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.101 Mobile Safari/537.36\\\",\\n        \\\"cookie\\\": ck\\n    },\\n    method: 'GET'\\n})).data['confirm_uri'];\\n//log(location);\\n\\nvar info = JSON.parse(fetch(location, {\\n    headers: {\\n        \\\"user-agent\\\": \\\"Mozilla/5.0 (Linux; Android 10; M2007J3SC Build/QKQ1.200419.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.101 Mobile Safari/537.36\\\",\\n        \\\"cookie\\\": ck\\n    },\\n    method: 'GET',\\n    onlyHeaders: true,\\n    redirect: false\\n})).headers.location[0].split(\\\"?\\\")[1].split(\\\"&\\\");\\nputVar(\\\"mykey\\\",info[0].split(\\\"=\\\")[1]);\\nputVar(\\\"mymid\\\",info[1].split(\\\"=\\\")[1]);\\n    d.push({\\n        title: info[0],\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: info[1],\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: \\\"““大会员点我””\\\",\\n        col_type: \\\"text_2\\\",\\n        url: $(\\\"不是大会员别点确认，否则后果自负\\\").confirm(() => {\\n            writeFile(\\\"hiker://files/rules/bili/access_key.txt\\\",getVar(\\\"mykey\\\"));\\n            writeFile(\\\"hiker://files/rules/bili/key.txt\\\",getVar(\\\"mykey\\\"));\\n            writeFile(\\\"hiker://files/rules/bili/starid.txt\\\",getVar(\\\"mymid\\\"));\\n            //refreshPage();\\n            return \\\"toast://大会员登录成功\\\"\\n        })\\n    });\\n    d.push({\\n        title: \\\"““无会员点我””\\\",\\n        col_type: \\\"text_2\\\",\\n        url: $(\\\"点击登录\\\").confirm(() => {\\n            writeFile(\\\"hiker://files/rules/bili/access_key.txt\\\",getVar(\\\"mykey\\\"));\\n            writeFile(\\\"hiker://files/rules/bili/starid.txt\\\",getVar(\\\"mymid\\\"));\\n            //refreshPage();\\n            return \\\"toast://登录成功\\\"\\n        })\\n    });\\n    \\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"代码-直播\",\"path\":\"zb\",\"rule\":\"if (MY_URL.split('#')[1] == '1') {\\nvar zbc1 = 'all&2&3&6&1&5&9&10&11';\\nvar zbw1 = '全部&网游&手游&单机&娱乐&电台&虚拟主播&生活&学习';\\nvar zbc2 = '0&33';\\nvar zbw2 = '默认小分类&影音馆（生活）';\\nvar zbword1 = zbw1.split('&');\\nvar zbclass1 = zbc1.split('&');\\nvar zblab1 = getVar('zblab1', '全部');\\nvar zbkey1 = getVar('zbkey1', 'all');\\n\\nvar zbword2 = zbw2.split('&');\\nvar zbclass2 = zbc2.split('&');\\nvar zblab2 = getVar('zblab2', '默认小分类');\\nvar zbkey2 = getVar('zbkey2', '0');\\n\\n    /*for (var i in zbword1) {\\n        var a = zbword1[i];\\n        var b = zbclass1[i];\\n        var c = a + '&' + b;\\n        d.push({\\n            title: a == zblab1 ? getHead(a) : a,\\n            url: $(\\\"#noLoading#\\\").lazyRule((c) => {\\n                putVar(\\\"zblab1\\\", c.split('&')[0]);\\n                putVar(\\\"zbkey1\\\", c.split('&')[1]);\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\"\\n            }, c),\\n            col_type: 'flex_button'\\n        });\\n    }*/\\n    d.push({\\n        title: '搜索',\\n        url: \\\"putVar('zbk',input);refreshPage();'toast://正在搜索';\\\",\\n        col_type: 'blank_block',\\n        desc: '你想看什么直播？'\\n    });\\n\\n    d.push({\\n        col_type: 'big_blank_block'\\n    });\\n\\n    for (var i in zbword1) {\\n        d.push({\\n            title: zbword1[i] == zblab1 ? getHead(zbword1[i]) : zbword1[i],\\n            url: $().lazyRule((name, key) => {\\n                putVar('zblab1', name);\\n                putVar('zbkey1', key);\\n                clearVar('zbk', input);\\n                refreshPage(true);\\n                return 'hiker://empty'\\n            }, zbword1[i], zbclass1[i]),\\n            col_type: 'scroll_button'\\n        });\\n    }\\n    d.push({\\n        col_type: 'blank_block'\\n    });\\n    for (var i in zbword2) {\\n        d.push({\\n            title: zbword2[i] == zblab2 ? getHead(zbword2[i]) : zbword2[i],\\n            url: $().lazyRule((name, key) => {\\n                putVar('zblab2', name);\\n                putVar('zbkey2', key);\\n                clearVar('zbk', input);\\n                refreshPage(true);\\n                return 'hiker://empty'\\n            }, zbword2[i], zbclass2[i]),\\n            col_type: 'scroll_button'\\n        });\\n    }\\n}\\nif (getVar('zbk') != '') {\\n    var zburl = \\\"https://search.bilibili.com/live?keyword=\\\" + getVar('zbk');\\n    log(zburl)\\n    var qz = \\\"https://search.bilibili.com\\\";\\n    var live = qz + parseDomForHtml(fetch(zburl, {\\n        headers: {\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n            \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n        }\\n    }), 'body&&.headline-live&&a&&href');\\n    log(\\\"123:::\\\" + live)\\n    d.push({\\n        title: '主播',\\n        url: \\\"hiker://page/zb2?url=\\\"+live.replace(\\\"?\\\",\\\"？？\\\").replace(\\\"&\\\",\\\"＆＆\\\") + '＆＆page=fypage',\\n        desc: '共有' + parseDomForHtml(fetch(zburl, {\\n            headers: {\\n                \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n                \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n            }\\n        }), 'body&&.flow-loader&&.headline-live&&.num-txt&&span&&Text').replace(\\\"\\\\(\\\", \\\"\\\").replace(\\\"\\\\)\\\", \\\"\\\") + '主播',\\n        col_type: 'text_center_1'\\n    });\\n    try {\\n        d.push({\\n            title: '直播中',\\n            url: \\\"hiker://page/zb2?url=\\\"+live.replace(\\\"?\\\",\\\"？？\\\").replace(\\\"&\\\",\\\"＆＆\\\").replace(\\\"search_type=live_user\\\", \\\"\\\") + 'page=fypage',\\n            desc: '共有' + parseDomForHtml(fetch(zburl, {\\n                headers: {\\n                    \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n                    \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n                }\\n            }), 'body&&.headline-room&&.num-txt&&span&&Text').replace(\\\"\\\\(\\\", \\\"\\\").replace(\\\"\\\\)\\\", \\\"\\\") + '直播间',\\n            col_type: 'text_center_1'\\n        });\\n    } catch (e) {}\\n} else {\\n    var page = MY_URL.split('#')[1];\\n    var url = \\\"https://api.live.bilibili.com/room/v3/area/getRoomList?platform=web&parent_area_id=\\\" + zbkey1 + \\\"&cate_id=0&area_id=\\\" + zbkey2 + \\\"&page=\\\" + page + \\\"&page_size=30&tag_version=1\\\";\\n    var json = JSON.parse(request(url));\\n    for (var i = 0; i < json.data.list.length; i++) {\\n        var r = {};\\n        var j = json.data.list[i];\\n        r.pic_url = j.system_cover + Referer;\\n        r.url = 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + j.roomid + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`;\\n        r.title = j.title;\\n        r.desc = 'UP🐷：' + j.uname;\\n        r.col_type = \\\"movie_2\\\";\\n        d.push(r);\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"页面-直播\",\"path\":\"zb2\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar Referer = \\\"@Referer=https://www.bilibili.com\\\";\\nif (MY_URL.indexOf(\\\"search_type=live_user\\\") != -1) {\\n    var live = parseDomForArray(fetch(MY_URL, {\\n        headers: {\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n            \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n        }\\n    }), 'body&&.live-user-wrap&&li');\\n    for (var i in live) {\\n        d.push({\\n            title: parseDomForHtml(live[i], '.item-right&&P&&Text'),\\n            url: 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + parseDom(live[i], 'a&&href').split(\\\"live.bilibili.com/\\\")[1].split(\\\"?from\\\")[0] + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`,\\n            //img: parseDomForHtml(live[i], '.lazy-img&&img&&src') + Referer,\\n            desc: parseDomForHtml(live[i], '.item-right&&.status&&Text'),\\n            col_type: 'pic_1'\\n        });\\n    }\\n} else {\\n    var live = parseDomForArray(fetch(MY_URL, {\\n        headers: {\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n            \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n        }\\n    }), 'body&&.live-room-wrap&&li');\\n    for (var i in live) {\\n        d.push({\\n            title: parseDomForHtml(live[i], 'p&&Text'),\\n            url: 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + parseDom(live[i], 'a&&href').split(\\\"live.bilibili.com/\\\")[1].split(\\\"?from\\\")[0] + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`,\\n            //img: parseDom(live[i], '.lazy-img&&img&&src') + Referer,\\n            desc: 'UP🐷：' + parseDomForHtml(live[i], '.uname&&span&&Text') + '·人气' + parseDomForHtml(live[i], '.live-num&&span&&Text'),\\n            col_type: 'pic_1'\\n        });\\n    }\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"API\",\"path\":\"api\",\"rule\":\"evalPrivateJS(\\\"F31g54pPpbN3pHPN9NT3D0zQvEjJXwRrfRiJmEBufUQA2HHWtQLRhAwqSMzMUdIARBMKBbPt28jB6tyuYxXOf3C7+VzPD3NJEeYy24OfTmSgsR4SHiPR3J0OifQMmTBLMtf1dX3k1y/8WuoXPMQnCXXDMQ97hwezot52IOyKsG64Oq5aGFN5diqT1tm29Sp/GrtVJX8fyjoNq4TrpfxiHsUW1SYs2hfcs3JjNkNOuQ2pWbP2spo9cUL6ZOhYvWyxBMEg2kPDET6vQuaFQnxRIpAulXJDMufAOvzmN5c0RUiOjpj54y8Sqe6g1/Fcm644WyPFMxW8b4DWfTiX9dDdIBdo2SLnD18oSuOC55weg8+XQSoqmey3Xt33u7S3aKriCUYO2HCwzKu2dfunpe0LOUlv/umd5pdxy/6UMKTHMCY=\\\")\"},{\"col_type\":\"movie_3\",\"name\":\"页面-一级（拓展）\",\"path\":\"newdetial\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar Referer = '@Referer=http://www.bilibili.com';\\nif (!fetch('hiker://files/rules/bili/setting.txt')) {\\n    writeFile('hiker://files/rules/bili/setting.txt', '开启,关闭');\\n}\\nvar s_type = fetch('hiker://files/rules/bili/setting.txt');\\nputVar('reply_type', s_type.split(',')[0]);\\nputVar('like_type', s_type.split(',')[1]);\\n//颜色\\nvar Colors = [\\\"4\\\", \\\"5\\\", \\\"0\\\", \\\"1\\\", \\\"A\\\", \\\"3\\\", \\\"8\\\", \\\"9\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"E\\\", \\\"6\\\", \\\"7\\\", \\\"F\\\"];\\nvar Color = '#';\\nif (getVar('YS') == '随机') {\\n    for (var i = 0; i < 6; i++) {\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\n        var Color = Color + Colors[num];\\n    }\\n} else {\\n    var Color = \\\"#FA7298\\\";\\n}\\n\\nfunction getHead(title) {\\n    return '‘‘’’<strong><font color=\\\"' + Color + '\\\">' + title + '</front></strong>';\\n}\\nvar pagenum = MY_URL.split('#')[1];\\nvar rx = fetch('hiker://files/bili/多合一.txt', {});\\nvar wr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/多合一.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\nvar s_tab = fetch('hiker://files/bili/收藏.txt', {});\\nvar sr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/收藏.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\n\\nif (rx == '排行榜') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/phb\\\")).rule)\\n}\\n\\nif (rx == 'UP主') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/up\\\")).rule)\\n}\\n\\nif (rx == '时光机') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sgj\\\")).rule)\\n}\\n\\nif (rx == '新番') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/newbgm\\\")).rule)\\n}\\n\\nif (rx == '索引') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sy\\\")).rule)\\n}\\n\\nif (rx == '直播') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/zb\\\")).rule)\\n}\\n\\nif (rx == '更多') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/more\\\")).rule)\\n}\\n\\nif (rx == \\\"漫游\\\") {\\n    evalPrivateJS(\\\"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\\\")\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"代码-更多\",\"path\":\"more\",\"rule\":\"if (MY_URL.split('#')[1] == '1') {\\n    var _type = fetch('hiker://files/bili/样式.txt', {});\\n    d.push({\\n        title: rx == '漫游' ? getHead(rx) : '漫游',\\n        url: '漫游' + wr,\\n        col_type: 'text_2'\\n    });\\n    d.push({\\n        title: getVar('YS') == '随机' ? getHead('随机') : getHead('骚粉'),\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('YS', getVar('YS')=='随机'?'骚粉':'随机');refreshPage();'toast://颜色--'+getVar('YS','随机')\\\",\\n        col_type: 'text_2'\\n    });\\n    d.push({\\n        title: _type==\\\"新版\\\"?getHead(\\\"新版\\\"):\\\"新版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','新版');refreshPage();'toast://切换成功'\\\",\\n        col_type: 'text_2'\\n    });\\n    d.push({\\n        title: _type==\\\"旧版\\\"?getHead(\\\"旧版\\\"):\\\"旧版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','旧版');refreshPage();'toast://切换成功'\\\",\\n        col_type: 'text_2'\\n    });\\n    if (rx != '时光机' && rx != '索引') {\\n        d.push({\\n            title: '自定UID',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/starid.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');clearVar('htm');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入UID\\\\n不知道怎么查？b站点开自己的信息，长按uid即可，请填入纯数字\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/starid.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '点赞key',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/access_key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入key(用于点赞投币)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/access_key.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '解析key',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入key(用于解析)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/key.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            col_type: 'blank_block'\\n        });\\n\\n        d.push({\\n            title: '评论区: ““已' + getVar('reply_type'),\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('reply_type', getVar('reply_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('reply_type');\\\",\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '点赞&投币: ““已' + getVar('like_type'),\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('like_type', getVar('like_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('like_type');\\\",\\n            col_type: 'text_2'\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-一级2\",\"path\":\"common2\",\"rule\":\"var res = {};\\nvar d = [];\\nvar pagenum = MY_URL.split('#')[1];\\nvar Referer = '@Referer=http://www.bilibili.com';\\nif (!fetch('hiker://files/rules/bili/setting.txt')) {\\n    writeFile('hiker://files/rules/bili/setting.txt', '开启,关闭');\\n}\\nvar s_type = fetch('hiker://files/rules/bili/setting.txt');\\nputVar('reply_type', s_type.split(',')[0]);\\nputVar('like_type', s_type.split(',')[1]);\\n//颜色\\nvar Colors = [\\\"4\\\", \\\"5\\\", \\\"0\\\", \\\"1\\\", \\\"A\\\", \\\"3\\\", \\\"8\\\", \\\"9\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"E\\\", \\\"6\\\", \\\"7\\\", \\\"F\\\"];\\nvar Color = '#';\\nif (getVar('YS') == '随机') {\\n    for (var i = 0; i < 6; i++) {\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\n        var Color = Color + Colors[num];\\n    }\\n} else {\\n    var Color = \\\"#FA7298\\\";\\n}\\n\\nfunction getHead(title) {\\n    return '‘‘’’<strong><font color=\\\"' + Color + '\\\">' + title + '</front></strong>';\\n}\\n\\nvar c1 = 'all&bangumi&guochan&douga&music&knowledge&tech&car&life&food&kichiku&fashion&cinephile&origin&rookie&game&ent&dance&movie&tv&documentary&animal&guochuang';\\n\\nvar w1 = '全部&番剧&国创&动画&音乐&知识&科技&汽车&生活&美食&鬼畜&时尚&影视&原创&新人&游戏&娱乐&舞蹈&电影&电视剧&纪录片&动物圈&国创相关';\\n\\nvar c2 = '22&212&71&182&138&28&33&185';\\n\\nvar w2 = '鬼畜&美食&综艺&影视&生活&音乐&番剧&电视剧';\\n\\nvar word1 = w1.split('&');\\nvar class1 = c1.split('&');\\nvar lab1 = getVar('lab1', '全部');\\nvar key1 = getVar('key1', 'all');\\n\\nvar word2 = w2.split('&');\\nvar class2 = c2.split('&');\\nvar lab2 = getVar('lab2', '鬼畜');\\nvar key2 = getVar('key2', '22');\\n\\nvar zbc1 = 'all&2&3&6&1&5&9&10&11';\\nvar zbw1 = '全部&网游&手游&单机&娱乐&电台&虚拟主播&生活&学习';\\nvar zbc2 = '0&33';\\nvar zbw2 = '默认小分类&影音馆（生活）';\\nvar zbword1 = zbw1.split('&');\\nvar zbclass1 = zbc1.split('&');\\nvar zblab1 = getVar('zblab1', '全部');\\nvar zbkey1 = getVar('zbkey1', 'all');\\n\\nvar zbword2 = zbw2.split('&');\\nvar zbclass2 = zbc2.split('&');\\nvar zblab2 = getVar('zblab2', '默认小分类');\\nvar zbkey2 = getVar('zbkey2', '0');\\n\\n\\n\\n//三合一\\nvar rx = fetch('hiker://files/bili/多合一.txt', {});\\nvar wr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/多合一.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\nvar s_tab = fetch('hiker://files/bili/收藏.txt', {});\\nvar sr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/收藏.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\n\\nif (MY_URL.split('#')[1] == '1') {\\n    //.replace('m.bilibili.com', 'www.bilibili.com').replace(/\\\\?/g, '？？').replace(/\\\\&/g, '＆＆')\\n    d.push({\\n        title: '解析',\\n        url: \\\"'hiker://page/detail?url='+'https://'+input.split('https://')[1]+'#immersiveTheme#'\\\",\\n        col_type: 'input',\\n        desc: '请输入网址或者b站复制的链接'\\n    });\\n\\n    d.push({\\n        title: rx == 'UP主' ? getHead('首页') : '首页',\\n        url: 'UP主' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '排行榜' ? getHead(rx) : '排行榜',\\n        url: '排行榜' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '新番' ? getHead(rx) : '新番',\\n        url: '新番' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '直播' ? getHead(rx) : '直播',\\n        url: '直播' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '更多' ? getHead(rx) : '更多',\\n        url: '更多' + wr,\\n        col_type: 'text_5'\\n    });\\n    /*\\n        if (rx == '收藏') {\\n            \\n            d.push({\\n                title: s_tab == '追番' ? getHead(s_tab) : '追番',\\n                url: '追番' + sr,\\n                col_type: 'text_3'\\n            });\\n            d.push({\\n                title: s_tab == '追剧' ? getHead(s_tab) : '追剧',\\n                url: '追剧' + sr,\\n                col_type: 'text_3'\\n            });\\n            \\n            if (s_tab == '追番') {\\n                eval(JSON.parse(fetch(\\\"hiker://page/fanju\\\")).rule)\\n            }\\n            if (s_tab == '追剧') {\\n                eval(JSON.parse(fetch(\\\"hiker://page/dsj\\\")).rule)\\n            }\\n        }\\n    */\\n}\\n\\nif (rx == '排行榜') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/phb\\\")).rule)\\n}\\n\\nif (rx == 'UP主') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/up\\\")).rule)\\n}\\n\\nif (rx == '时光机') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sgj\\\")).rule)\\n}\\n\\nif (rx == '新番') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/newbgm\\\")).rule)\\n}\\n\\nif (rx == '索引') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sy\\\")).rule)\\n}\\n\\nif (rx == '直播') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/zb\\\")).rule)\\n}\\n\\nif (rx == '更多') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/more2\\\")).rule)\\n}\\n\\nif (rx == \\\"漫游\\\") {\\n    evalPrivateJS(\\\"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\\\")\\n}\\n//三合一\\n\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"movie_3\",\"name\":\"代码-更多2\",\"path\":\"more2\",\"rule\":\"if (MY_URL.split('#')[1] == '1') {\\n    var _type = fetch('hiker://files/bili/样式.txt', {});\\n    \\n    d.push({\\n        title: rx == '时光机' ? getHead(rx) : '时光🐥',\\n        url: '时光机' + wr,\\n        col_type: 'text_5'\\n    });\\n    /*\\n        d.push({\\n            title: '追番',\\n            url: 'hiker://collection?group=①追番',\\n            col_type: 'text_4'\\n        });\\n    */\\n    d.push({\\n        title: rx == '索引' ? getHead(rx) : '索引',\\n        url: '索引' + wr,\\n        col_type: 'text_5'\\n    });\\n    /*\\n        d.push({\\n            title: rx == '收藏' ? getHead(rx) : '收藏',\\n            url: '收藏' + wr,\\n            col_type: 'text_4'\\n        });\\n    */\\n    d.push({\\n        title: '登录',\\n        url: 'hiker://page/newlogin',\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '漫游' ? getHead(rx) : '漫游',\\n        url: '漫游' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: getVar('YS') == '随机' ? getHead('随机') : getHead('骚粉'),\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('YS', getVar('YS')=='随机'?'骚粉':'随机');refreshPage();'toast://颜色--'+getVar('YS','随机')\\\",\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: _type==\\\"新版\\\"?getHead(\\\"新版\\\"):\\\"新版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','新版');refreshPage();'toast://切换成功'\\\",\\n        col_type: 'text_2'\\n    });\\n    d.push({\\n        title: _type==\\\"旧版\\\"?getHead(\\\"旧版\\\"):\\\"旧版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','旧版');refreshPage();'toast://切换成功'\\\",\\n        col_type: 'text_2'\\n    });\\n    \\n    if (rx != '时光机' && rx != '索引') {\\n\\n        d.push({\\n            title: '自定UID',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/starid.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');clearVar('htm');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入UID\\\\n不知道怎么查？b站点开自己的信息，长按uid即可，请填入纯数字\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/starid.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '点赞key',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/access_key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入key(用于点赞投币)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/access_key.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '解析key',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入key(用于解析)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/key.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            col_type: 'blank_block'\\n        });\\n\\n        d.push({\\n            title: '评论区: ““已' + getVar('reply_type'),\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('reply_type', getVar('reply_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('reply_type');\\\",\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '点赞&投币: ““已' + getVar('like_type'),\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('like_type', getVar('like_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('like_type');\\\",\\n            col_type: 'text_2'\\n        });\\n    }\\n}\"}],\"saved\":false,\"title\":\"哔哩ℛ\",\"version\":0,\"url\":\"https://api.bilibili.com/x/web-interface/view/detail?aid=&bvid=BV1TZ4y167fG#immersiveTheme#\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar res = {};\\nvar d = [];\\n//log(MY_RULE.title)\\nvar Referer = '@Referer=http://www.bilibili.com';\\n//颜色\\nvar Colors = [\\\"4\\\", \\\"5\\\", \\\"0\\\", \\\"1\\\", \\\"A\\\", \\\"3\\\", \\\"8\\\", \\\"9\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"E\\\", \\\"6\\\", \\\"7\\\", \\\"F\\\"];\\nvar Color = '#';\\nif (getVar('YS') == '随机') {\\n    for (var i = 0; i < 6; i++) {\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\n        var Color = Color + Colors[num];\\n    }\\n} else {\\n    var Color = \\\"#FA7298\\\";\\n}\\n\\nfunction getHead(title) {\\n    return '‘‘’’<strong><font color=\\\"' + Color + '\\\">' + title + '</front></strong>';\\n}\\n\\nd.push({\\n    desc: '258&&float',\\n    col_type: 'x5_webview_single'\\n});\\nvar bangumi = getResCode();\\nif (MY_URL.indexOf('api.bili') == -1) {\\n    try {\\n        var a = fetch(MY_URL, {});\\n        var b = JSON.parse(a.split('\\\"epList\\\":')[1].split('}]')[0] + '}]');\\n        //log(b)\\n        var rurl = 'https://api.bilibili.com/x/web-interface/view/detail?aid=&bvid=' + b[0].bvid;\\n    } catch (e) {\\n        var a = fetch(MY_URL, {\\n            redirect: false\\n        });\\n        var b = a.split('video/')[1].split('\\\"')[0].split(\\\"?\\\")[0];\\n        var rurl = 'https://api.bilibili.com/x/web-interface/view/detail?aid=&bvid=' + b;\\n    }\\n    var bangumi = fetch(rurl, {});\\n}\\nvar json = JSON.parse(bangumi);\\nvar v = json.data.View;\\nvar p = v.pages;\\nvar card = json.data.Card.card;\\nvar related = json.data.Related;\\nvar tags = fetch(\\\"hiker://files/cache/bilibili2.txt\\\", {});\\nvar setting1 = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili2.txt',input);refreshPage();'toast://正常页面切换成功👌可能并没有什么变化'`;\\nvar setting2 = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili2.txt',input);refreshPage();'toast://隐藏页面切换成功👌可能并没有什么变化'`;\\nvar ts = new Date().getTime();\\nvar like_url = 'https://app.bilibili.com/x/v2/view/like';\\nvar coin_url = 'https://app.bilibili.com/x/v2/view/coin/add';\\nvar add_url = 'https://api.bilibili.com/pgc/app/follow/add';\\nvar del_url = 'https://api.bilibili.com/pgc/app/follow/del';\\nvar content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\nvar c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\nvar l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\nvar xlxz = \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\";\\nvar jxgl = \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\";\\nif (v['redirect_url']) {\\n    var redirect = v['redirect_url'];\\n    var ym = fetch(redirect, {});\\n\\n}\\n\\nevalPrivateJS(\\\"XUiFT1vXYWrUw+Vhpnqlg0N0vAWgpglh8MhZ+9vPD99NJ5VgeFdHmwaKawIy6C0h6FFQhEQ5RhJmV0EQHnL9xybPHAchAL7hZEZd+hbGHV5jeG+nK5Q3ie78puGDb1TJ4fAI7g6ezLIjQMBxN/2XM92YNNPKDHdhLIMQGV69Mq8cTOWjKpZQp0/vgNuxaPQKEzSdHQJue7tTxdSEvDt3s/txdEh/oGzFCCNWeZCUU53zhEhC06q6ZFjZCM+d8FsZ5cXlNJemtegMgJULdTqaVdRwVhVX+1uBQ9Ny0DpsNGx2LwHgOjls9hw14LhEqthEe73yPBGvSgKEBdSYgG7cK7hYVTENeGTiRAzKPQ7jGEqEJ8aadHOHAeSa25aBbzc81hhxgXtialX8Uqepn7k4g2GksqoG3JVI+qTfWZxPWqNM/0jUXbrUTCRZnrzGVow6NwPQXKq3CDKl9i+aZveWz5If5ENEZGiWlW5z4aJSEcexCDsiZlo1/QJIj2rWonE0u54ah2/ZZ//ZGoMBJ+d19GmepkLBD3n2qogKnjZj2rjWqgPadEee1ZIhZ3SGbmTlJf1A4BYIuuPwv4dGZdRoDW64BhC5juCn6wDm7Ymy7BXf1sQaFimEnrSIiHGhM+WKg3IyWecuh/Gk++MmN6AxxcvNAyp8bC4hzBMvZJ/l5tRyapomdCV5BpiXfjkWRnbopIjI+WKB3fCaYyRdeNLERKnElscDiz7UenLprhYc/a4LsGeMMFVZ8Yo8/wGYH38J\\\")\\n\\nvar purl = 'https://www.bilibili.com/video/' + v.bvid;\\nvar mode = fetch(\\\"hiker://files/cache/bilibili.txt\\\", {});\\nvar mode_url = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili.txt',input);refreshPage();'toast://切换成功, 点个视频试试吧(^_^) '`;\\nvar zl = \\\"hiker://empty@lazyRule=.js:putVar('page', getVar('page')=='直链'?'关闭':'直链');refreshPage();if(getVar('page')=='直链'){'toast://点击下方切换清晰度🤟'}else{'toast://已关闭'}\\\";\\nif (mode == 'yhc') {\\n    var lazy = yhc\\n}\\nd.push({\\n    title: v.title,\\n    desc: '描述: ' + v.desc + '　类型: ' + v.tname,\\n    url: tags == 'up' ? 'fan' + setting2 : 'up' + setting1,\\n    img: v.pic + Referer,\\n    col_type: 'movie_1_vertical_pic_blur'\\n});\\nd.push({\\n    title: '  ' + card.name,\\n    pic_url: card.face + Referer,\\n    //url: 'hiker://page/gz1?url=https://space.bilibili.com/h5/follow？？type=follow＆＆mid=' + card.mid,\\n    url: 'hiker://page/ss?url=https://api.bilibili.com/x/space/arc/search？？mid=' + card.mid + '＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate',\\n    col_type: 'icon_2_round'\\n});\\nd.push({\\n    title: '““⭐️Star””',\\n    url: 'hiker://empty#' + card.name + '&&' + card.mid + `@lazyRule=.js:input=input.split('#')[1];var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+input.split(\\\"&&\\\")[1]+'&jsonp=jsonp',{})).data.face;if(!getVar('lb2').includes(input.split('&&')[1].split('##')[0])){var xr=getVar('lb2')+'\\\\\\\\n'+input+'##'+pic;writeFile(\\\"hiker://files/rules/js/up.js\\\",xr);'toast://关注成功'}else{'toast://年轻人，耗子尾汁'}`,\\n    col_type: 'text_2'\\n});\\n\\nfunction request_bili_api(baseUrl, SecretId, SecretKey) {\\n    if (!SecretId || !SecretKey) return request(baseUrl)\\n    eval(getCryptoJS())\\n    let nowDate = new Date();\\n    let dateTime = nowDate.toUTCString();\\n    let source = 'bili-api';\\n    let auth = \\\"hmac id=\\\\\\\"\\\" + SecretId + \\\"\\\\\\\", algorithm=\\\\\\\"hmac-sha1\\\\\\\", headers=\\\\\\\"x-date source\\\\\\\", signature=\\\\\\\"\\\";\\n    let signStr = \\\"x-date: \\\" + dateTime + \\\"\\\\n\\\" + \\\"source: \\\" + source;\\n    let sign = CryptoJS.HmacSHA1(signStr, SecretKey)\\n    sign = CryptoJS.enc.Base64.stringify(sign)\\n    sign = auth + sign + \\\"\\\\\\\"\\\"\\n    return request(baseUrl, {\\n        headers: {\\n            \\\"Source\\\": source,\\n            \\\"X-Date\\\": dateTime,\\n            \\\"Authorization\\\": sign\\n        }\\n    })\\n}\\n\\neval(JSON.parse(fetch(\\\"hiker://page/api\\\")).rule)\\n\\n//自定义api项\\nvar mApi = {\\n    author: '',\\n    type: '',\\n    id: '',\\n    baseUrl: '',\\n    secretId: '',\\n    secretKey: ''\\n}\\nif (mApi.baseUrl && mApi.secretId && mApi.secretKey) {\\n    putVar('api', JSON.stringify(mApi))\\n}\\n\\nvar apiIndexStr = getVar('apiIndex', '')\\nvar apiIndex = parseInt(apiIndexStr)\\n\\n\\ntry {\\n    for (var i = 0; i < p.length; i++) {\\n        var part = v.videos != 1 ? p[i].part : '当前视频无选集，点击此处播放';\\n        putVar('UA', ';{User-Agent@Mozilla/5.0 (Windows NT 10.0\\\\\\\\；\\\\\\\\； WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36＆＆＆＆Referer@https://www.bilibili.com/video}');\\n        evalPrivateJS(\\\"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\\\")\\n\\n        if (v['redirect_url']) {\\n            var ep = JSON.parse(ym.split('\\\"epList\\\":')[1].split('}]')[0] + '}]');\\n            var season_id = ym.split('\\\"season_id\\\":')[1].split(',')[0];\\n            log(season_id)\\n            putVar('aid', String(ep[0].aid));\\n            d.push({\\n                title: mode == '直链' ? getHead('直链') : '直链',\\n                url: '直链' + mode_url,\\n                col_type: 'text_2'\\n            });\\n            d.push({\\n                title: mode == '断插' ? getHead('断插') : '断插',\\n                url: (mode == '断插' ? xlxz : '断插' + mode_url),\\n                col_type: 'text_2'\\n            });\\n            if (getVar('like_type') === '开启' && getVar('access_key')) {\\n                d.push({\\n                    title: '点赞',\\n                    url: $(like_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\n                        var l_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: l_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(l_code);\\n                        return 'toast://' + l_code.data.toast;\\n                    }, ),\\n                    col_type: 'text_4'\\n                });\\n                d.push({\\n                    title: '投币',\\n                    url: $(coin_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\n                        var c_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: c_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(c_code);\\n                        return 'toast://投了1个币';\\n                    }, ),\\n                    col_type: 'text_4'\\n                });\\n                d.push({\\n                    title: '追番',\\n                    url: $(add_url).lazyRule((season_id) => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var add_body_txt = 'access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&season_id=' + season_id + '&statistics={\\\"appId\\\":1,\\\"platform\\\":3,\\\"version\\\":\\\"6.9.1\\\",\\\"abtest\\\":\\\"\\\"}&ts=' + ts + '&sign=c64b4c50832d29e40a3ddeded3667135';\\n                        var add_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: add_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(add_code);\\n                        return 'toast://' + add_code.result.toast;\\n                    }, season_id),\\n                    col_type: 'text_4'\\n                });\\n                d.push({\\n                    title: '取消',\\n                    url: $(del_url).lazyRule((season_id) => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var del_body_txt = 'access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&season_id=' + season_id + '&statistics={\\\"appId\\\":1,\\\"platform\\\":3,\\\"version\\\":\\\"6.9.1\\\",\\\"abtest\\\":\\\"\\\"}&ts=' + ts + '&sign=c64b4c50832d29e40a3ddeded3667135';\\n                        var del_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: del_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(del_code);\\n                        return 'toast://' + del_code.result.toast;\\n                    }, season_id),\\n                    col_type: 'text_4'\\n                });\\n            }\\n            d.push({\\n                title: '',\\n                col_type: 'blank_block'\\n            });\\n\\n\\n\\n            for (var i = 0; i < ep.length; i++) {\\n                var badgeType = ep[i]['badgeType'] === 0 ? ((ep[i]['badge'] != '') ? '💰' : '🆓') : '📢';\\n                var badge = ep[i]['badge'] ? '[' + ep[i]['badge'] + ']' : ''\\n                if (mode == 'X5') {\\n                    var purl = 'x5Rule://' + jx + 'https://www.bilibili.com/bangumi/play/ep' + ep[i]['id'] + '@';\\n                } else {\\n                    var purl = 'https://www.bilibili.com/bangumi/play/ep' + ep[i]['id'];\\n                }\\n                var pics = (ep[i]['cover'].indexOf(':') != -1) ? ep[i]['cover'] : 'https:' + ep[i]['cover'];\\n                var titles = (ep[i]['titleFormat']) ? ep[i]['titleFormat'] : ep[i]['title'];\\n                var desc = (ep[i]['longTitle']) ? ep[i]['longTitle'] : (ep[i]['long_title'] ? ep[i]['long_title'] : '');\\n                evalPrivateJS(\\\"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\\\")\\n\\n                var dc = $(purl).lazyRule(() => {\\n                    eval(\\\"var config =\\\" + fetch(\\\"hiker://files/rules/DuanNian/MyParse.json\\\"));\\n                    eval(request(config.settings.cj));\\n                    return aytmParse(input);\\n                });\\n                d.push({\\n                    title: titles + badgeType,\\n                    img: pics + Referer,\\n                    desc: badge + desc,\\n                    url: (mode == '直链' ? true_url : (mode == '断插' ? dc : purl + lazy)),\\n                    col_type: 'movie_2'\\n                });\\n\\n            }\\n        } else {\\n            putVar('aid', String(v.aid));\\n\\n            d.push({\\n                title: mode == '直链' ? getHead('直链') : '直链', //'直链播放',\\n                url: '直链' + mode_url, //lazy1,\\n                col_type: 'text_2'\\n            });\\n\\n            d.push({\\n                title: mode == 'yhc' ? getHead('萤火虫') : mode == '断插' ? getHead('断插') : '萤火虫',\\n                url: mode == '断插' ? 'yhc' + mode_url : '断插' + mode_url,\\n                col_type: 'text_2'\\n            });\\n            if (getVar('like_type') === '开启') {\\n                d.push({\\n                    title: '点赞',\\n                    url: $(like_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\n                        var l_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: l_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(l_code);\\n                        return 'toast://' + l_code.data.toast;\\n                    }, ),\\n                    col_type: 'text_2'\\n                });\\n                d.push({\\n                    title: '投币',\\n                    url: $(coin_url).lazyRule(() => {\\n                        var ts = new Date().getTime();\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\n                        var c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\n                        var c_code = JSON.parse(request(input, {\\n                            headers: {\\n                                'Content-Type': content_type\\n                            },\\n                            body: c_body_txt,\\n                            method: 'POST'\\n                        }));\\n                        log(c_code);\\n                        return 'toast://投了1个币';\\n                    }, ),\\n                    col_type: 'text_2'\\n                });\\n            }\\n            d.push({\\n                title: '',\\n                col_type: 'blank_block'\\n            });\\n\\n\\n            if (v.videos != 1) {\\n                var rurl = purl + '?p=' + p[i].page;\\n            } else {\\n                var rurl = purl\\n            }\\n            var dc = $(rurl).lazyRule(() => {\\n                eval(\\\"var config =\\\" + fetch(\\\"hiker://files/rules/DuanNian/MyParse.json\\\"));\\n                eval(request(config.settings.cj));\\n                return aytmParse(input);\\n            });\\n            d.push({\\n                title: part,\\n                pic_url: 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif',\\n                url: /*mode == 'X5' ? 'x5Rule://' + jx + rurl + '@' + lazy : (*/ mode == '直链' ? lazy1 : mode == '断插' ? dc : rurl + lazy,\\n                col_type: v.videos != 1 ? 'text_center_1' : 'avatar'\\n            });\\n\\n\\n        }\\n    }\\n\\n    d.push({\\n        col_type: 'line_blank'\\n    });\\n    if (getVar('reply_type') === '开启') {\\n        d.push({\\n            title: '<strong>' + '““评论区””' + (getVar('label') == '评论' ? '““ ⊙””' : '““ ⊕””') + '</strong>',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('label', getVar('label')=='评论'?'关闭':'评论');refreshPage();'toast://'+getVar('label','评论')\\\",\\n            col_type: 'text_2'\\n        });\\n\\n        d.push({\\n            title: '<strong>' + '““推荐区””' + (getVar('label') == '推荐' ? '““ ⊙””' : '““ ⊕””') + '</strong>',\\n            url: \\\"hiker://empty@lazyRule=.js:putVar('label', getVar('label')=='推荐'?'关闭':'推荐');refreshPage();'toast://'+getVar('label','推荐')\\\",\\n            col_type: 'text_2'\\n        });\\n\\n\\n        if (getVar(\\\"label\\\") == '评论') {\\n            var rely = JSON.parse(fetch('https://api.bilibili.com/x/v2/reply/main?oid=' + v.aid + '&type=1', {}));\\n            var counts = rely['data']['cursor']['all_count'];\\n            var replies = rely.data.replies;\\n            for (var x in replies) {\\n                var repliesx = replies[x];\\n                var message = replies[x].content.message;\\n                var member = replies[x].member;\\n                d.push({\\n                    title: member.uname,\\n                    img: member.avatar,\\n                    col_type: 'avatar'\\n                });\\n                d.push({\\n                    title: '<small><strong>' + message + '</strong></small>',\\n                    col_type: 'rich_text'\\n                });\\n                var reply = replies[x].replies;\\n                for (var z in reply) {\\n                    var mess = reply[z].content.message;\\n                    var mem = reply[z].member.uname;\\n                    d.push({\\n                        title: '<small>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;' + mem + ':' + mess + '</small>',\\n                        col_type: 'rich_text'\\n                    });\\n                }\\n            }\\n        }\\n\\n        if (getVar(\\\"label\\\") == '推荐') {\\n            for (var r in related) {\\n                d.push({\\n                    title: related[r].title,\\n                    img: related[r].pic,\\n                    desc: related[r].desc,\\n                    url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + related[r].bvid + '#immersiveTheme#',\\n                    col_type: 'movie_2'\\n                });\\n            }\\n        }\\n    }\\n} catch (e) {\\n throw e\\n}\\n\\nres.data = d;\\nsetResult(res);\",\"group\":\"①推荐\",\"ua\":\"mobile\",\"preRule\":\"js:\\neval(JSON.parse(fetch(\\\"hiker://page/ycl\\\")).rule);\\n//通过搜索查看自己的uid，然后替换即可\\nif (!fetch('hiker://files/rules/bili/starid.txt',{})){\\nputVar('starid','928123');\\n}else{\\nputVar('starid',fetch('hiker://files/rules/bili/starid.txt',{}));\\n}\\nputVar(\\\"access_key\\\",fetch('hiker://files/rules/bili/access_key.txt'));\\n//自己去b站客户端首页抓包，找到app.bilibili.com开头的链接，然后把access_key的值填入上方'='后面即可\\nif (!fetch('hiker://files/bili/样式.txt', {})){\\n    writeFile('hiker://files/bili/样式.txt',\\\"新版\\\");\\n    }\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-一级\\\",\\\"path\\\":\\\"common\\\",\\\"rule\\\":\\\"var res = {};\\\\nvar d = [];\\\\nif (MY_URL.split('#')[1] == '1') {\\\\n    //.replace('m.bilibili.com', 'www.bilibili.com').replace(/\\\\\\\\?/g, '？？').replace(/\\\\\\\\&/g, '＆＆')\\\\n    d.push({\\\\n        title: '解析',\\\\n        url: \\\\\\\"'hiker://page/detail?url='+'https://'+input.split('https://')[1]+'#immersiveTheme#'\\\\\\\",\\\\n        col_type: 'input',\\\\n        desc: '请输入网址或者b站复制的链接'\\\\n    });\\\\n\\\\n    d.push({\\\\n        url: $(\\\\\\\"更多\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://img0.baidu.com/it/u=1612101423,1145982163&fm=253&app=138&f=JPEG?w=500&h=424',\\\\n        col_type: 'card_pic_1',\\\\n        desc:\\\\\\\"0\\\\\\\"\\\\n    });\\\\n    d.push({\\\\n        title: '排行榜',\\\\n        url: $(\\\\\\\"排行榜\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/50.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n    d.push({\\\\n        title: '直播',\\\\n        url: $(\\\\\\\"直播\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/22.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n    d.push({\\\\n        title: '时光机',\\\\n        url: $(\\\\\\\"时光机\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/56.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n    d.push({\\\\n        title: 'UP',\\\\n        url: $(\\\\\\\"UP主\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/98.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n    d.push({\\\\n        title: '索引',\\\\n        url: $(\\\\\\\"索引\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/47.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n    d.push({\\\\n        title: '新番',\\\\n        url: $(\\\\\\\"新番\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/23.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n    d.push({\\\\n        title: '漫游',\\\\n        url: $(\\\\\\\"漫游\\\\\\\").lazyRule(() => {\\\\n            writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\", input);\\\\n            refreshPage(false);\\\\n            return \\\\\\\"hiker://page/newdetial?url=hiker://empty#fypage\\\\\\\";\\\\n        }, ),\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/83.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n\\\\n    d.push({\\\\n        title: '登录',\\\\n        url: 'hiker://page/newlogin',\\\\n        pic_url: 'https://lanmeiguojiang.com/tubiao/q/2.png',\\\\n        col_type: 'icon_2'\\\\n    });\\\\n}\\\\nres.data = d;\\\\nsetResult(res)\\\"},{\\\"col_type\\\":\\\"pic_1_card\\\",\\\"name\\\":\\\"代码-排行榜\\\",\\\"path\\\":\\\"phb\\\",\\\"rule\\\":\\\"//分类\\\\n\\\\nif (MY_URL.split('#')[1] == '1') {\\\\nvar c1 = 'all&bangumi&guochan&douga&music&knowledge&tech&car&life&food&kichiku&fashion&cinephile&origin&rookie&game&ent&dance&movie&tv&documentary&animal&guochuang';\\\\nvar w1 = '全部&番剧&国创&动画&音乐&知识&科技&汽车&生活&美食&鬼畜&时尚&影视&原创&新人&游戏&娱乐&舞蹈&电影&电视剧&纪录片&动物圈&国创相关';\\\\nvar word1 = w1.split('&');\\\\nvar class1 = c1.split('&');\\\\nvar lab1 = getVar('lab1', '全部');\\\\nvar key1 = getVar('key1', 'all');\\\\n\\\\n    for (var i in word1) {\\\\n        var a = word1[i];\\\\n        var b = class1[i];\\\\n        var c = a + '&' + b;\\\\n        d.push({\\\\n            title:  a == lab1 ? getHead(a) : a,\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((c) => {\\\\n                putVar(\\\\\\\"lab1\\\\\\\", c.split('&')[0]);\\\\n                putVar(\\\\\\\"key1\\\\\\\", c.split('&')[1]);\\\\n                refreshPage(false);\\\\n                return \\\\\\\"hiker://empty\\\\\\\"\\\\n            }, c),\\\\n            col_type: 'scroll_button'\\\\n        });\\\\n    }\\\\n}\\\\n//分类\\\\n//log(MY_PAGE)\\\\n\\\\nvar url = 'https://www.bilibili.com/v/popular/rank/all';\\\\n\\\\nMY_URL = url.replace('all', getVar('key1'));\\\\n\\\\nvar ym = request(MY_URL, {}).replace(/\\\\\\\\\\\\\\\\u002F/g, '/');\\\\nif (ym.includes('rank-tips')) {\\\\n\\\\n    /*提示信息\\\\n      d.push({\\\\n        title:'““'+parseDomForHtml(ym,'.rank-tips&&Text')+'””',\\\\n        col_type:'text_1'\\\\n      });\\\\n    提示信息*/\\\\n\\\\n    var pi = JSON.parse(ym.split('\\\\\\\"rankList\\\\\\\":')[1].split(',\\\\\\\"rankNote\\\\\\\"')[0]);\\\\n    for (var i = 0; pi != null && i < pi.length; i++) {\\\\n        var num = i + 1;\\\\n        var q = JSON.stringify(pi[i]);\\\\n        if (!pi[i].url) {\\\\n            var rurl = 'https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + pi[i].bvid;\\\\n        } else {\\\\n            var rurl = pi[i].url;\\\\n        }\\\\n        \\\\n        d.push({\\\\n            title: pi[i].title,\\\\n            pic_url: pi[i].pic + Referer,\\\\n            desc: (!q.includes('name') ? pi[i].new_ep.index_show : ('up: ' + pi[i].owner.name)),\\\\n            url: 'hiker://page/detail?url=' + rurl + '#immersiveTheme#',\\\\n            col_type: 'pic_1_card'\\\\n        });\\\\n        /*\\\\n        d.push({\\\\n                title:'No.'+num+'\\\\\\\\n\\\\\\\\n‘‘<small>'+pi[i].title+'\\\\\\\\n'+(!q.includes('name')?pi[i].new_ep.index_show:('up: '+pi[i].owner.name))+'</small>',\\\\n                pic_url:pi[i].pic+Referer,\\\\n                desc:'0',\\\\n                url:'hiker://page/detail?url='+rurl+'#immersiveTheme#',\\\\n                col_type:'pic_1_card'\\\\n              });\\\\n        */\\\\n    }\\\\n} else {\\\\n    d.push({\\\\n        title: '““节制一点，休息啦！””',\\\\n        col_type: 'text_center_1'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-up🐷\\\",\\\"path\\\":\\\"up\\\",\\\"rule\\\":\\\"const headColor = \\\\\\\"#358ccd\\\\\\\";\\\\n\\\\n//时间戳转换方法\\\\n/*\\\\nfunction getLocalTime(nS) { \\\\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\\\n     var YMD = sss.split('日')[0].replace('年','-').replace('月','-');\\\\n     return (YMD)\\\\n}\\\\n*/\\\\nfunction getLocalTime(nS) {\\\\n    var date = new Date(nS);\\\\n    var YY = date.getFullYear() + '-';\\\\n    var MM = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';\\\\n    var DD = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate());\\\\n    var time = YY + MM + DD;\\\\n    return time\\\\n}\\\\nvar sr = `@lazyRule=.js:writeFile(\\\\\\\"hiker://files/bili/收藏.txt\\\\\\\",input);putVar('up','');putVar('UP','');putVar('set','');refreshPage(false);\\\\\\\"toast://切换成功\\\\\\\"`;\\\\n//时间戳转换\\\\n\\\\nvar uid = fetch(\\\\\\\"hiker://files/bili/up_cache.txt\\\\\\\", {});\\\\nvar UP_URL = 'https://api.bilibili.com/x/space/arc/search?mid=uid&ps=30&tid=0&keyword=&jsonp=jsonp&pn=' + pagenum + '&order=pubdate';\\\\nvar up_url = UP_URL.replace(\\\\\\\"uid\\\\\\\", uid);\\\\nvar xx = getVar('lb2').split('\\\\\\\\n');\\\\n//更新头像\\\\nfor (var k in xx) {\\\\n    if (!xx[k].split('##')[1]) {\\\\n        try {\\\\n            var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid=' + xx[k].split('&&')[1] + '&jsonp=jsonp', {})).data.face;\\\\n        } catch (e) {\\\\n            var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid=' + xx[k].split('&&')[1] + '&need_top=1', {})).data.cards[0].desc.user_profile.info.face;\\\\n        }\\\\n        var face = xx[k] + '##' + pic;\\\\n        var face = fetch(\\\\\\\"hiker://files/bili/up.txt\\\\\\\", {}).replace(xx[k], face);\\\\n        writeFile(\\\\\\\"hiker://files/bili/up.txt\\\\\\\", face);\\\\n    }\\\\n}\\\\n\\\\n\\\\n\\\\nif (MY_URL.split('#')[1] == '1') {\\\\n    var s_tab = fetch('hiker://files/bili/收藏.txt', {});\\\\n    if (getVar(\\\\\\\"access_key\\\\\\\") && getVar('starid')) {\\\\n        d.push({\\\\n            title: s_tab == '推荐' ? '🔴' + getHead(s_tab) : '⚪️推荐',\\\\n            url: '推荐' + sr,\\\\n            col_type: 'text_4'\\\\n        });\\\\n        d.push({\\\\n            title: s_tab == '收藏' ? '🔴' + getHead(s_tab) : '⚪️收藏',\\\\n            url: '收藏' + sr,\\\\n            col_type: 'text_4'\\\\n        });\\\\n        d.push({\\\\n            title: s_tab == '追番' ? '🔴' + getHead(s_tab) : '⚪️追番',\\\\n            url: '追番' + sr,\\\\n            col_type: 'text_4'\\\\n        });\\\\n        d.push({\\\\n            title: s_tab == '追剧' ? '🔴' + getHead(s_tab) : '⚪️追剧',\\\\n            url: '追剧' + sr,\\\\n            col_type: 'text_4'\\\\n        });\\\\n    }\\\\n    //自己的关注\\\\n    var starjson = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid=' + getVar('starid') + '&jsonp=jsonp', {}));\\\\n    d.push({\\\\n        title: (getVar('UP') == '关注' ? '☺️' : '') + starjson.data.name,\\\\n        pic_url: starjson.data.face + Referer,\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('UP', getVar('UP')=='关注'?'折叠':'关注');putVar('set','');clearVar('htm');writeFile('hiker://files/bili/收藏.txt','');refreshPage(false);'toast://'+getVar('UP','专注')\\\\\\\",\\\\n        col_type: 'icon_2_round'\\\\n    });\\\\n    //自己的关注\\\\n\\\\n    d.push({\\\\n        title: '<strong>' + '‘‘UP’’' + '</strong>' + (getVar('up', '折叠') == '展开' ? '🙉' : '🙈'),\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('up', getVar('up')=='展开'?'折叠':'展开');putVar('set','');writeFile('hiker://files/bili/收藏.txt','');refreshPage(false);'toast://已'+getVar('up','展开');\\\\\\\",\\\\n        col_type: 'text_4'\\\\n    });\\\\n\\\\n    d.push({\\\\n        title: getVar('set') != '' ? (getVar('set') == '置顶' ? '<strong>' + '““置顶' + '</strong>' : '<strong>' + '““取关””' + '</strong>') : '设置',\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('set', getVar('set','展开')=='取关'?'置顶':'取关');putVar('up','');putVar('UP','');writeFile('hiker://files/bili/收藏.txt','');refreshPage(false);'toast://'+getVar('set','展开')+'ing~'\\\\\\\",\\\\n        col_type: 'text_4'\\\\n    });\\\\n\\\\n    if (getVar('UP') == '关注') {\\\\n        if (getVar('htm') == '' || getVar('up') == '展开') {\\\\n            var urls = [];\\\\n            var surl = 'https://space.bilibili.com/h5/follow?type=follow&mid=' + getVar('starid');\\\\n            var id = surl.split('mid=')[1];\\\\n            var code = fetch(surl, {});\\\\n            var starlist = JSON.parse('{\\\\\\\"my' + code.split('{\\\\\\\"my')[1].split('}};')[0] + '}}');\\\\n\\\\n            var starls = starlist['list']['getFollowList-page-mid-' + id]['result'];\\\\n            for (x in starls) {\\\\n                var yurl = 'https://api.bilibili.com/x/space/arc/search?mid=' + starls[x].mid + '&ps=30&tid=0&keyword=&jsonp=jsonp&pn=fypage&order=pubdate';\\\\n                urls.push({\\\\n                    url: yurl.replace(/fypage/g, '1')\\\\n                });\\\\n\\\\n                if (getVar('up') == '展开')\\\\n                    d.push({\\\\n                        title: starls[x].uname,\\\\n                        img: starls[x].face + Referer,\\\\n                        url: 'hiker://page/gz2?url=' + yurl,\\\\n                        col_type: 'icon_round_4'\\\\n                    });\\\\n            }\\\\n        }\\\\n    }\\\\n    //关注列表\\\\n\\\\n    if (getVar('up') == '展开' && getVar('UP') != '关注') {\\\\n        for (var k in xx) {\\\\n            var st = uid == xx[k].split('&&')[1].split('##')[0] ? '✓' : '';\\\\n            var pic = xx[k].split('##')[1];\\\\n            /*头像获取\\\\n                try{\\\\n                 var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+xx[k].split('&&')[1]+'&jsonp=jsonp',{})).data.face;\\\\n                }catch(e){\\\\n                   var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid='+xx[k].split('&&')[1]+'&need_top=1',{})).data.cards[0].desc.user_profile.info.face;\\\\n                }\\\\n            */\\\\n            if (!pic) {\\\\n                var pic = 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif';\\\\n            }\\\\n            d.push({\\\\n                title: st + xx[k].split('&&')[0],\\\\n                url: 'hiker://empty#' + xx[k].split('&&')[1] + `@lazyRule=.js:input=input.split('#')[1];putVar2('uid',input);writeFile(\\\\\\\"hiker://files/bili/up_cache.txt\\\\\\\",input);putVar('up','折叠');refreshPage(false);\\\\\\\"toast://切换成功\\\\\\\";`,\\\\n                pic_url: pic + Referer,\\\\n                col_type: 'icon_round_4'\\\\n            });\\\\n        }\\\\n    }\\\\n\\\\n    //取关相关\\\\n\\\\n    if (getVar('set') == '取关') {\\\\n\\\\n        for (var k in xx) {\\\\n            var st = uid == xx[k].split('&&')[1] ? '✓' : '';\\\\n            var pic = xx[k].split('##')[1];\\\\n            /*头像获取\\\\n                try{\\\\n                 var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+xx[k].split('&&')[1]+'&jsonp=jsonp',{})).data.face;\\\\n                }catch(e){\\\\n                   var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid='+xx[k].split('&&')[1]+'&need_top=1',{})).data.cards[0].desc.user_profile.info.face;\\\\n                }\\\\n            */\\\\n            if (!pic) {\\\\n                var pic = 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif';\\\\n            }\\\\n            d.push({\\\\n                title: '❌' + st + xx[k].split('&&')[0],\\\\n                url: xx[k] + `@lazyRule=.js:var sc=input+'\\\\\\\\\\\\\\\\n';var xr=getVar('lb2')+'\\\\\\\\\\\\\\\\n';var xz=xr.replace(sc,'');writeFile(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\",xz);refreshPage(false);'toast://取关成功！铁子再见🦆'`,\\\\n                pic_url: pic + Referer,\\\\n                col_type: 'icon_round_4'\\\\n            });\\\\n        }\\\\n    }\\\\n\\\\n    //置顶相关\\\\n\\\\n    if (getVar('set') == '置顶') {\\\\n\\\\n        for (var k in xx) {\\\\n            var st = uid == xx[k].split('&&')[1] ? '✓' : '';\\\\n            var pic = xx[k].split('##')[1];\\\\n            /*头像获取\\\\n                try{\\\\n                 var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+xx[k].split('&&')[1]+'&jsonp=jsonp',{})).data.face;\\\\n                }catch(e){\\\\n                   var pic = JSON.parse(fetch('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid='+xx[k].split('&&')[1]+'&need_top=1',{})).data.cards[0].desc.user_profile.info.face;\\\\n                }\\\\n            */\\\\n            if (!pic) {\\\\n                var pic = 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif';\\\\n            }\\\\n            d.push({\\\\n                title: '🔝' + st + xx[k].split('&&')[0],\\\\n                url: xx[k] + `@lazyRule=.js:var sc=input+'\\\\\\\\\\\\\\\\n';var xr=getVar('lb2')+'\\\\\\\\\\\\\\\\n';var xz=xr.replace(sc,'');writeFile(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\",sc+xz);refreshPage(false);'toast://置顶成功🔝'`,\\\\n                pic_url: pic + Referer,\\\\n                col_type: 'icon_round_4'\\\\n            });\\\\n        }\\\\n    }\\\\n\\\\n\\\\n}\\\\n//d.push({title:xx});\\\\nif (s_tab == '推荐') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/feed\\\\\\\")).rule);\\\\n} else if (s_tab == '收藏') {\\\\n    if (MY_URL.split('#')[1] == '1') eval(JSON.parse(fetch(\\\\\\\"hiker://page/video\\\\\\\")).rule);\\\\n} else if (s_tab == '追剧') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/dsj\\\\\\\")).rule)\\\\n} else if (s_tab == '追番') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/fanju\\\\\\\")).rule)\\\\n} else if (getVar('UP') != '关注' && getVar('up') != '展开' && getVar('set') == '') {\\\\n    var json = {};\\\\n    eval('json=' + fetch(up_url, {}));\\\\n    for (var i = 0; i < json.data.list.vlist.length; i++) {\\\\n        var r = {};\\\\n        var j = json.data.list.vlist[i];\\\\n        var t = Number(j.created) * 1000;\\\\n\\\\n\\\\n        var time = getLocalTime(t);\\\\n\\\\n        if (j.play > 10000)\\\\n            var play = (j.play / 10000).toFixed(1) + '万';\\\\n        else\\\\n            var play = j.play;\\\\n\\\\n        var pics = (j.pic.indexOf(':') != -1) ? j.pic : 'https:' + j.pic;\\\\n\\\\n        r.pic_url = pics + Referer;\\\\n        r.url = 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + j.bvid + '#immersiveTheme#';\\\\n        r.title = j.title;\\\\n        r.col_type = 'movie_1_vertical_pic';\\\\n        r.desc = '时长：' + j.length + '  播放量：' + play + '  发布日期：' + time;\\\\n        if (j.length != \\\\\\\"00:00\\\\\\\") {\\\\n            d.push(r)\\\\n        };\\\\n    }\\\\n} else if (getVar('UP') == '关注' && getVar('up') != '展开') {\\\\n\\\\n    if (getVar('htm') == '') {\\\\n        htm = [];\\\\n        var ym = batchFetch(urls).map(function(a) {\\\\n            var h = JSON.parse(a).data.list.vlist;\\\\n            htm = htm.concat(h);\\\\n        });\\\\n        htm = htm.sort(function(a, b) {\\\\n            return b.created - a.created;\\\\n        }).map(function(a) {\\\\n            a.created = getLocalTime(Number(a.created) * 1000);\\\\n            return a\\\\n        });\\\\n        putVar('htm', JSON.stringify(htm));\\\\n    } else htm = JSON.parse(getVar('htm'));\\\\n    var i = 0;\\\\n    var k = 0;\\\\n    var r = new Date();\\\\n    var M = r.getMonth() + 1;\\\\n    var tD = r.getFullYear() + '-' + (M < 10 ? ('0' + M) : M) + '-' + (r.getDate() < 10 ? ('0' + r.getDate()) : r.getDate());\\\\n\\\\n    for (var j = 0; j < htm.length; j++) {\\\\n        try {\\\\n\\\\n            if (j != 0 && htm[j - 1].created != htm[j].created) i++;\\\\n\\\\n            if (i + 1 == MY_URL.split('#')[1]) {\\\\n                if (k == 0) {\\\\n                    var date = htm[j].created;\\\\n                    k++;\\\\n                    if (date == tD) date = '<strong>今天</strong>';\\\\n                    d.push({\\\\n                        title: '““””<font color=\\\\\\\"#358ccd\\\\\\\">' + date + '<\\\\\\\\font>',\\\\n                        col_type: 'text_center_1',\\\\n                        //url:`@lazyRule=.js:clearVar('htm');refreshPage(false);'toast://刷新成功';`\\\\n                    });\\\\n                }\\\\n                if (htm[j].play > 10000)\\\\n                    var play = (htm[j].play / 10000).toFixed(1) + '万';\\\\n                else\\\\n                    var play = htm[j].play;\\\\n                d.push({\\\\n                    title: htm[j].title,\\\\n                    img: ((htm[j].pic.indexOf(':') != -1) ? htm[j].pic : ('https:' + htm[j].pic)) + Referer,\\\\n                    desc: 'UP:' + htm[j].author + '  时长：' + htm[j].length + '\\\\\\\\n播放量：' + play + '  发布日期：' + htm[j].created,\\\\n                    url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + htm[j].bvid + '#immersiveTheme#',\\\\n                    col_type: 'movie_1_vertical_pic'\\\\n                });\\\\n            } else if (i + 1 > MY_URL.split('#')[1]) {\\\\n                break;\\\\n            }\\\\n        } catch (e) {}\\\\n    }\\\\n\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-时光🐔\\\",\\\"path\\\":\\\"sgj\\\",\\\"rule\\\":\\\"//分类\\\\nvar pagenum = MY_URL.split('#')[1];\\\\nif (MY_URL.split('#')[1]=='1'){\\\\nvar c2 = '22&212&71&182&138&28&33&185';\\\\n\\\\nvar w2 = '鬼畜&美食&综艺&影视&生活&音乐&番剧&电视剧';\\\\n\\\\nvar word2 = w2.split('&');\\\\nvar class2 = c2.split('&');\\\\nvar lab2 = getVar('lab2', '鬼畜');\\\\nvar key2 = getVar('key2', '22');\\\\nfor (var i in word2){\\\\n    var a = word2[i];\\\\n    var b = class2[i];\\\\n    var c = a + '&' + b;\\\\n    d.push({\\\\n    title: a==lab2? getHead(a):a,\\\\n    url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((c)=>{\\\\n        putVar(\\\\\\\"lab2\\\\\\\",c.split('&')[0]);\\\\n        putVar(\\\\\\\"key2\\\\\\\",c.split('&')[1]);\\\\n        refreshPage(false);\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }, c),\\\\n    col_type:'scroll_button'\\\\n    });\\\\n}\\\\n}\\\\n//分类\\\\n\\\\nvar m = Number(fetch(\\\\\\\"hiker://files/bili/mouths.txt\\\\\\\",{}));\\\\nvar t = m<0?0:m;\\\\nvar num1 = Number(t)-12;\\\\nvar num2 = Number(t)+12;\\\\nvar num3 = Number(t)-1;\\\\nvar num4 = Number(t)+1;\\\\n//var timestamp = Date.parse(new Date());\\\\nvar timestamp = new Date().getTime();\\\\nvar stamp1 = timestamp - t*30*24*60*60*1000;\\\\nvar stamp2 = timestamp - (t+1)*30*24*60*60*1000;\\\\n/*\\\\nfunction getLocalTime(nS) { \\\\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\\\n     var mm = sss.split('年')[1].split('月')[0];\\\\n     var dd = sss.split('月')[1].split('日')[0];\\\\n     var YY = sss.split('年')[0];\\\\n     var MM = (mm< 10 ? '0' + mm:mm);\\\\n     var DD = (dd< 10 ? '0' + dd:dd);\\\\n     return (YY+MM+DD)\\\\n}\\\\n*/\\\\nfunction getLocalTime(nS) { \\\\nvar date = new Date(nS);\\\\nvar YY = String(date.getFullYear()); \\\\nvar MM = String((date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1)); \\\\nvar DD = String((date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate())); \\\\nvar time = YY + MM + DD;\\\\nreturn time\\\\n}\\\\n//时间戳转换\\\\nvar time1 = getLocalTime(stamp1);\\\\nvar time2 = getLocalTime(stamp2);\\\\nvar SGJ_URL = 'https://s.search.bilibili.com/cate/search?main_ver=v3&search_type=video&view_type=hot_rank&order=click&copy_right=-1&cate_id=22&page='+pagenum+'&pagesize=10&time_from=time2&time_to=time1';\\\\nvar URL = SGJ_URL.replace('time1',time1).replace('time2',time2).replace('22',getVar('key2')!=''?getVar('key2'):'22');\\\\nvar json = JSON.parse(request(URL,{}));\\\\n\\\\nif (MY_URL.split('#')[1]=='1'){\\\\nd.push({\\\\n          title:'+1年',\\\\n          url:\\\\nnum1+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\\\n          col_type:'text_4'\\\\n       });\\\\nd.push({\\\\n          title:'-1年',\\\\n          url:\\\\nnum2+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\\\n          col_type:'text_4'\\\\n       });\\\\nd.push({\\\\n          title:'+1月',\\\\n          url:\\\\nnum3+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\\\n          col_type:'text_4'\\\\n       });\\\\nd.push({\\\\n          title:'-1月',\\\\n          url:\\\\nnum4+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\\\n          col_type:'text_4'\\\\n       });\\\\nd.push({\\\\n          title:getHead(('当前时间线: '+time2+'~'+time1)),\\\\n          \\\\n          col_type:'text_center_1'\\\\n       });\\\\n/*\\\\nd.push({\\\\n          title: getLocalTime(timestamp). split('日')[0],\\\\n          \\\\n          col_type:'text_center_1'\\\\n       });\\\\n*/\\\\n}\\\\n/*\\\\nd.push({\\\\n          title: getLocalTime(sss),\\\\n          \\\\n          col_type:'text_center_1'\\\\n       });\\\\n*/\\\\nfor (var i in json.result)\\\\n{\\\\n var r = {};\\\\n var j = json.result[i];\\\\n if (j.play>10000)\\\\n    var play = (j.play/10000).toFixed(1)+'万';\\\\n else\\\\n    var play = j.play;\\\\n d.push({\\\\n          title:j.title,\\\\n          img:'https:'+j.pic+Referer,\\\\n          desc:'up🐷:'+j.author+'\\\\\\\\n播放量: '+play+'        发布日期: '+j.pubdate/*+'\\\\\\\\n描述:'+j.description*/,\\\\n          url:\\\\n'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + j.bvid+'#immersiveTheme#',\\\\n          col_type:'movie_2'\\\\n       });\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-二级\\\",\\\"path\\\":\\\"detail\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\n//log(MY_RULE.title)\\\\nvar Referer = '@Referer=http://www.bilibili.com';\\\\n//颜色\\\\nvar Colors = [\\\\\\\"4\\\\\\\", \\\\\\\"5\\\\\\\", \\\\\\\"0\\\\\\\", \\\\\\\"1\\\\\\\", \\\\\\\"A\\\\\\\", \\\\\\\"3\\\\\\\", \\\\\\\"8\\\\\\\", \\\\\\\"9\\\\\\\", \\\\\\\"B\\\\\\\", \\\\\\\"C\\\\\\\", \\\\\\\"D\\\\\\\", \\\\\\\"E\\\\\\\", \\\\\\\"6\\\\\\\", \\\\\\\"7\\\\\\\", \\\\\\\"F\\\\\\\"];\\\\nvar Color = '#';\\\\nif (getVar('YS') == '随机') {\\\\n    for (var i = 0; i < 6; i++) {\\\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\\\n        var Color = Color + Colors[num];\\\\n    }\\\\n} else {\\\\n    var Color = \\\\\\\"#FA7298\\\\\\\";\\\\n}\\\\n\\\\nfunction getHead(title) {\\\\n    return '‘‘’’<strong><font color=\\\\\\\"' + Color + '\\\\\\\">' + title + '</front></strong>';\\\\n}\\\\n\\\\nd.push({\\\\n    desc: '258&&float',\\\\n    col_type: 'x5_webview_single'\\\\n});\\\\nvar bangumi = getResCode();\\\\nif (MY_URL.indexOf('api.bili') == -1) {\\\\n    try {\\\\n        var a = fetch(MY_URL, {});\\\\n        var b = JSON.parse(a.split('\\\\\\\"epList\\\\\\\":')[1].split('}]')[0] + '}]');\\\\n        //log(b)\\\\n        var rurl = 'https://api.bilibili.com/x/web-interface/view/detail?aid=&bvid=' + b[0].bvid;\\\\n    } catch (e) {\\\\n        var a = fetch(MY_URL, {\\\\n            redirect: false\\\\n        });\\\\n        var b = a.split('video/')[1].split('\\\\\\\"')[0].split(\\\\\\\"?\\\\\\\")[0];\\\\n        var rurl = 'https://api.bilibili.com/x/web-interface/view/detail?aid=&bvid=' + b;\\\\n    }\\\\n    var bangumi = fetch(rurl, {});\\\\n}\\\\nvar json = JSON.parse(bangumi);\\\\nvar v = json.data.View;\\\\nvar p = v.pages;\\\\nvar card = json.data.Card.card;\\\\nvar related = json.data.Related;\\\\nvar tags = fetch(\\\\\\\"hiker://files/cache/bilibili2.txt\\\\\\\", {});\\\\nvar setting1 = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili2.txt',input);refreshPage();'toast://正常页面切换成功👌可能并没有什么变化'`;\\\\nvar setting2 = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili2.txt',input);refreshPage();'toast://隐藏页面切换成功👌可能并没有什么变化'`;\\\\nvar ts = new Date().getTime();\\\\nvar like_url = 'https://app.bilibili.com/x/v2/view/like';\\\\nvar coin_url = 'https://app.bilibili.com/x/v2/view/coin/add';\\\\nvar add_url = 'https://api.bilibili.com/pgc/app/follow/add';\\\\nvar del_url = 'https://api.bilibili.com/pgc/app/follow/del';\\\\nvar content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\\\nvar c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\\\nvar l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\\\nvar xlxz = \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\\\\\";\\\\nvar jxgl = \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\\\\\";\\\\nif (v['redirect_url']) {\\\\n    var redirect = v['redirect_url'];\\\\n    var ym = fetch(redirect, {});\\\\n\\\\n}\\\\n\\\\nevalPrivateJS(\\\\\\\"XUiFT1vXYWrUw+Vhpnqlg0N0vAWgpglh8MhZ+9vPD99NJ5VgeFdHmwaKawIy6C0h6FFQhEQ5RhJmV0EQHnL9xybPHAchAL7hZEZd+hbGHV5jeG+nK5Q3ie78puGDb1TJ4fAI7g6ezLIjQMBxN/2XM92YNNPKDHdhLIMQGV69Mq8cTOWjKpZQp0/vgNuxaPQKEzSdHQJue7tTxdSEvDt3s/txdEh/oGzFCCNWeZCUU53zhEhC06q6ZFjZCM+d8FsZ5cXlNJemtegMgJULdTqaVdRwVhVX+1uBQ9Ny0DpsNGx2LwHgOjls9hw14LhEqthEe73yPBGvSgKEBdSYgG7cK7hYVTENeGTiRAzKPQ7jGEqEJ8aadHOHAeSa25aBbzc81hhxgXtialX8Uqepn7k4g2GksqoG3JVI+qTfWZxPWqNM/0jUXbrUTCRZnrzGVow6NwPQXKq3CDKl9i+aZveWz5If5ENEZGiWlW5z4aJSEcexCDsiZlo1/QJIj2rWonE0u54ah2/ZZ//ZGoMBJ+d19GmepkLBD3n2qogKnjZj2rjWqgPadEee1ZIhZ3SGbmTlJf1A4BYIuuPwv4dGZdRoDW64BhC5juCn6wDm7Ymy7BXf1sQaFimEnrSIiHGhM+WKg3IyWecuh/Gk++MmN6AxxcvNAyp8bC4hzBMvZJ/l5tRyapomdCV5BpiXfjkWRnbopIjI+WKB3fCaYyRdeNLERKnElscDiz7UenLprhYc/a4LsGeMMFVZ8Yo8/wGYH38J\\\\\\\")\\\\n\\\\nvar purl = 'https://www.bilibili.com/video/' + v.bvid;\\\\nvar mode = fetch(\\\\\\\"hiker://files/cache/bilibili.txt\\\\\\\", {});\\\\nvar mode_url = `@lazyRule=.js:writeFile('hiker://files/cache/bilibili.txt',input);refreshPage();'toast://切换成功, 点个视频试试吧(^_^) '`;\\\\nvar zl = \\\\\\\"hiker://empty@lazyRule=.js:putVar('page', getVar('page')=='直链'?'关闭':'直链');refreshPage();if(getVar('page')=='直链'){'toast://点击下方切换清晰度🤟'}else{'toast://已关闭'}\\\\\\\";\\\\nif (mode == 'yhc') {\\\\n    var lazy = yhc\\\\n}\\\\nd.push({\\\\n    title: v.title,\\\\n    desc: '描述: ' + v.desc + '　类型: ' + v.tname,\\\\n    url: tags == 'up' ? 'fan' + setting2 : 'up' + setting1,\\\\n    img: v.pic + Referer,\\\\n    col_type: 'movie_1_vertical_pic_blur'\\\\n});\\\\nd.push({\\\\n    title: '  ' + card.name,\\\\n    pic_url: card.face + Referer,\\\\n    //url: 'hiker://page/gz1?url=https://space.bilibili.com/h5/follow？？type=follow＆＆mid=' + card.mid,\\\\n    url: 'hiker://page/ss?url=https://api.bilibili.com/x/space/arc/search？？mid=' + card.mid + '＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate',\\\\n    col_type: 'icon_2_round'\\\\n});\\\\nd.push({\\\\n    title: '““⭐️Star””',\\\\n    url: 'hiker://empty#' + card.name + '&&' + card.mid + `@lazyRule=.js:input=input.split('#')[1];var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+input.split(\\\\\\\"&&\\\\\\\")[1]+'&jsonp=jsonp',{})).data.face;if(!getVar('lb2').includes(input.split('&&')[1].split('##')[0])){var xr=getVar('lb2')+'\\\\\\\\\\\\\\\\n'+input+'##'+pic;writeFile(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\",xr);'toast://关注成功'}else{'toast://年轻人，耗子尾汁'}`,\\\\n    col_type: 'text_2'\\\\n});\\\\n\\\\nfunction request_bili_api(baseUrl, SecretId, SecretKey) {\\\\n    if (!SecretId || !SecretKey) return request(baseUrl)\\\\n    eval(getCryptoJS())\\\\n    let nowDate = new Date();\\\\n    let dateTime = nowDate.toUTCString();\\\\n    let source = 'bili-api';\\\\n    let auth = \\\\\\\"hmac id=\\\\\\\\\\\\\\\"\\\\\\\" + SecretId + \\\\\\\"\\\\\\\\\\\\\\\", algorithm=\\\\\\\\\\\\\\\"hmac-sha1\\\\\\\\\\\\\\\", headers=\\\\\\\\\\\\\\\"x-date source\\\\\\\\\\\\\\\", signature=\\\\\\\\\\\\\\\"\\\\\\\";\\\\n    let signStr = \\\\\\\"x-date: \\\\\\\" + dateTime + \\\\\\\"\\\\\\\\n\\\\\\\" + \\\\\\\"source: \\\\\\\" + source;\\\\n    let sign = CryptoJS.HmacSHA1(signStr, SecretKey)\\\\n    sign = CryptoJS.enc.Base64.stringify(sign)\\\\n    sign = auth + sign + \\\\\\\"\\\\\\\\\\\\\\\"\\\\\\\"\\\\n    return request(baseUrl, {\\\\n        headers: {\\\\n            \\\\\\\"Source\\\\\\\": source,\\\\n            \\\\\\\"X-Date\\\\\\\": dateTime,\\\\n            \\\\\\\"Authorization\\\\\\\": sign\\\\n        }\\\\n    })\\\\n}\\\\n\\\\neval(JSON.parse(fetch(\\\\\\\"hiker://page/api\\\\\\\")).rule)\\\\n\\\\n//自定义api项\\\\nvar mApi = {\\\\n    author: '',\\\\n    type: '',\\\\n    id: '',\\\\n    baseUrl: '',\\\\n    secretId: '',\\\\n    secretKey: ''\\\\n}\\\\nif (mApi.baseUrl && mApi.secretId && mApi.secretKey) {\\\\n    putVar('api', JSON.stringify(mApi))\\\\n}\\\\n\\\\nvar apiIndexStr = getVar('apiIndex', '')\\\\nvar apiIndex = parseInt(apiIndexStr)\\\\n\\\\n\\\\ntry {\\\\n    for (var i = 0; i < p.length; i++) {\\\\n        var part = v.videos != 1 ? p[i].part : '当前视频无选集，点击此处播放';\\\\n        putVar('UA', ';{User-Agent@Mozilla/5.0 (Windows NT 10.0\\\\\\\\\\\\\\\\；\\\\\\\\\\\\\\\\； WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36＆＆＆＆Referer@https://www.bilibili.com/video}');\\\\n        evalPrivateJS(\\\\\\\"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\\\\\\\")\\\\n\\\\n        if (v['redirect_url']) {\\\\n            var ep = JSON.parse(ym.split('\\\\\\\"epList\\\\\\\":')[1].split('}]')[0] + '}]');\\\\n            var season_id = ym.split('\\\\\\\"season_id\\\\\\\":')[1].split(',')[0];\\\\n            log(season_id)\\\\n            putVar('aid', String(ep[0].aid));\\\\n            d.push({\\\\n                title: mode == '直链' ? getHead('直链') : '直链',\\\\n                url: '直链' + mode_url,\\\\n                col_type: 'text_2'\\\\n            });\\\\n            d.push({\\\\n                title: mode == '断插' ? getHead('断插') : '断插',\\\\n                url: (mode == '断插' ? xlxz : '断插' + mode_url),\\\\n                col_type: 'text_2'\\\\n            });\\\\n            if (getVar('like_type') === '开启' && getVar('access_key')) {\\\\n                d.push({\\\\n                    title: '点赞',\\\\n                    url: $(like_url).lazyRule(() => {\\\\n                        var ts = new Date().getTime();\\\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\\\n                        var l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\\\n                        var l_code = JSON.parse(request(input, {\\\\n                            headers: {\\\\n                                'Content-Type': content_type\\\\n                            },\\\\n                            body: l_body_txt,\\\\n                            method: 'POST'\\\\n                        }));\\\\n                        log(l_code);\\\\n                        return 'toast://' + l_code.data.toast;\\\\n                    }, ),\\\\n                    col_type: 'text_4'\\\\n                });\\\\n                d.push({\\\\n                    title: '投币',\\\\n                    url: $(coin_url).lazyRule(() => {\\\\n                        var ts = new Date().getTime();\\\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\\\n                        var c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\\\n                        var c_code = JSON.parse(request(input, {\\\\n                            headers: {\\\\n                                'Content-Type': content_type\\\\n                            },\\\\n                            body: c_body_txt,\\\\n                            method: 'POST'\\\\n                        }));\\\\n                        log(c_code);\\\\n                        return 'toast://投了1个币';\\\\n                    }, ),\\\\n                    col_type: 'text_4'\\\\n                });\\\\n                d.push({\\\\n                    title: '追番',\\\\n                    url: $(add_url).lazyRule((season_id) => {\\\\n                        var ts = new Date().getTime();\\\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\\\n                        var add_body_txt = 'access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&season_id=' + season_id + '&statistics={\\\\\\\"appId\\\\\\\":1,\\\\\\\"platform\\\\\\\":3,\\\\\\\"version\\\\\\\":\\\\\\\"6.9.1\\\\\\\",\\\\\\\"abtest\\\\\\\":\\\\\\\"\\\\\\\"}&ts=' + ts + '&sign=c64b4c50832d29e40a3ddeded3667135';\\\\n                        var add_code = JSON.parse(request(input, {\\\\n                            headers: {\\\\n                                'Content-Type': content_type\\\\n                            },\\\\n                            body: add_body_txt,\\\\n                            method: 'POST'\\\\n                        }));\\\\n                        log(add_code);\\\\n                        return 'toast://' + add_code.result.toast;\\\\n                    }, season_id),\\\\n                    col_type: 'text_4'\\\\n                });\\\\n                d.push({\\\\n                    title: '取消',\\\\n                    url: $(del_url).lazyRule((season_id) => {\\\\n                        var ts = new Date().getTime();\\\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\\\n                        var del_body_txt = 'access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&season_id=' + season_id + '&statistics={\\\\\\\"appId\\\\\\\":1,\\\\\\\"platform\\\\\\\":3,\\\\\\\"version\\\\\\\":\\\\\\\"6.9.1\\\\\\\",\\\\\\\"abtest\\\\\\\":\\\\\\\"\\\\\\\"}&ts=' + ts + '&sign=c64b4c50832d29e40a3ddeded3667135';\\\\n                        var del_code = JSON.parse(request(input, {\\\\n                            headers: {\\\\n                                'Content-Type': content_type\\\\n                            },\\\\n                            body: del_body_txt,\\\\n                            method: 'POST'\\\\n                        }));\\\\n                        log(del_code);\\\\n                        return 'toast://' + del_code.result.toast;\\\\n                    }, season_id),\\\\n                    col_type: 'text_4'\\\\n                });\\\\n            }\\\\n            d.push({\\\\n                title: '',\\\\n                col_type: 'blank_block'\\\\n            });\\\\n\\\\n\\\\n\\\\n            for (var i = 0; i < ep.length; i++) {\\\\n                var badgeType = ep[i]['badgeType'] === 0 ? ((ep[i]['badge'] != '') ? '💰' : '🆓') : '📢';\\\\n                var badge = ep[i]['badge'] ? '[' + ep[i]['badge'] + ']' : ''\\\\n                if (mode == 'X5') {\\\\n                    var purl = 'x5Rule://' + jx + 'https://www.bilibili.com/bangumi/play/ep' + ep[i]['id'] + '@';\\\\n                } else {\\\\n                    var purl = 'https://www.bilibili.com/bangumi/play/ep' + ep[i]['id'];\\\\n                }\\\\n                var pics = (ep[i]['cover'].indexOf(':') != -1) ? ep[i]['cover'] : 'https:' + ep[i]['cover'];\\\\n                var titles = (ep[i]['titleFormat']) ? ep[i]['titleFormat'] : ep[i]['title'];\\\\n                var desc = (ep[i]['longTitle']) ? ep[i]['longTitle'] : (ep[i]['long_title'] ? ep[i]['long_title'] : '');\\\\n                evalPrivateJS(\\\\\\\"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\\\\\\\")\\\\n\\\\n                var dc = $(purl).lazyRule(() => {\\\\n                    eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/rules/DuanNian/MyParse.json\\\\\\\"));\\\\n                    eval(request(config.settings.cj));\\\\n                    return aytmParse(input);\\\\n                });\\\\n                d.push({\\\\n                    title: titles + badgeType,\\\\n                    img: pics + Referer,\\\\n                    desc: badge + desc,\\\\n                    url: (mode == '直链' ? true_url : (mode == '断插' ? dc : purl + lazy)),\\\\n                    col_type: 'movie_2'\\\\n                });\\\\n\\\\n            }\\\\n        } else {\\\\n            putVar('aid', String(v.aid));\\\\n\\\\n            d.push({\\\\n                title: mode == '直链' ? getHead('直链') : '直链', //'直链播放',\\\\n                url: '直链' + mode_url, //lazy1,\\\\n                col_type: 'text_2'\\\\n            });\\\\n\\\\n            d.push({\\\\n                title: mode == 'yhc' ? getHead('萤火虫') : mode == '断插' ? getHead('断插') : '萤火虫',\\\\n                url: mode == '断插' ? 'yhc' + mode_url : '断插' + mode_url,\\\\n                col_type: 'text_2'\\\\n            });\\\\n            if (getVar('like_type') === '开启') {\\\\n                d.push({\\\\n                    title: '点赞',\\\\n                    url: $(like_url).lazyRule(() => {\\\\n                        var ts = new Date().getTime();\\\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\\\n                        var l_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&like=0&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&sign=4a08645c2994eb692ac0cfb0bd7569c6';\\\\n                        var l_code = JSON.parse(request(input, {\\\\n                            headers: {\\\\n                                'Content-Type': content_type\\\\n                            },\\\\n                            body: l_body_txt,\\\\n                            method: 'POST'\\\\n                        }));\\\\n                        log(l_code);\\\\n                        return 'toast://' + l_code.data.toast;\\\\n                    }, ),\\\\n                    col_type: 'text_2'\\\\n                });\\\\n                d.push({\\\\n                    title: '投币',\\\\n                    url: $(coin_url).lazyRule(() => {\\\\n                        var ts = new Date().getTime();\\\\n                        var content_type = 'application/x-www-form-urlencoded; charset=utf-8';\\\\n                        var c_body_txt = 'access_key=' + getVar('access_key') + '&aid=' + getVar('aid') + '&appkey=1d8b6e7d45233436&avtype=1&build=6130400&c_locale=zh_CN&channel=master&from=7&from_spmid=tm.recommend.0.0&mobi_app=android&multiply=1&platform=android&s_locale=zh_CN&select_like=1&spmid=main.ugc-video-detail.0.0&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&upid=0&sign=8abbddd87a6bd82e1e42cb3cffd32bb9';\\\\n                        var c_code = JSON.parse(request(input, {\\\\n                            headers: {\\\\n                                'Content-Type': content_type\\\\n                            },\\\\n                            body: c_body_txt,\\\\n                            method: 'POST'\\\\n                        }));\\\\n                        log(c_code);\\\\n                        return 'toast://投了1个币';\\\\n                    }, ),\\\\n                    col_type: 'text_2'\\\\n                });\\\\n            }\\\\n            d.push({\\\\n                title: '',\\\\n                col_type: 'blank_block'\\\\n            });\\\\n\\\\n\\\\n            if (v.videos != 1) {\\\\n                var rurl = purl + '?p=' + p[i].page;\\\\n            } else {\\\\n                var rurl = purl\\\\n            }\\\\n            var dc = $(rurl).lazyRule(() => {\\\\n                eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/rules/DuanNian/MyParse.json\\\\\\\"));\\\\n                eval(request(config.settings.cj));\\\\n                return aytmParse(input);\\\\n            });\\\\n            d.push({\\\\n                title: part,\\\\n                pic_url: 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif',\\\\n                url: /*mode == 'X5' ? 'x5Rule://' + jx + rurl + '@' + lazy : (*/ mode == '直链' ? lazy1 : mode == '断插' ? dc : rurl + lazy,\\\\n                col_type: v.videos != 1 ? 'text_center_1' : 'avatar'\\\\n            });\\\\n\\\\n\\\\n        }\\\\n    }\\\\n\\\\n    d.push({\\\\n        col_type: 'line_blank'\\\\n    });\\\\n    if (getVar('reply_type') === '开启') {\\\\n        d.push({\\\\n            title: '<strong>' + '““评论区””' + (getVar('label') == '评论' ? '““ ⊙””' : '““ ⊕””') + '</strong>',\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('label', getVar('label')=='评论'?'关闭':'评论');refreshPage();'toast://'+getVar('label','评论')\\\\\\\",\\\\n            col_type: 'text_2'\\\\n        });\\\\n\\\\n        d.push({\\\\n            title: '<strong>' + '““推荐区””' + (getVar('label') == '推荐' ? '““ ⊙””' : '““ ⊕””') + '</strong>',\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('label', getVar('label')=='推荐'?'关闭':'推荐');refreshPage();'toast://'+getVar('label','推荐')\\\\\\\",\\\\n            col_type: 'text_2'\\\\n        });\\\\n\\\\n\\\\n        if (getVar(\\\\\\\"label\\\\\\\") == '评论') {\\\\n            var rely = JSON.parse(fetch('https://api.bilibili.com/x/v2/reply/main?oid=' + v.aid + '&type=1', {}));\\\\n            var counts = rely['data']['cursor']['all_count'];\\\\n            var replies = rely.data.replies;\\\\n            for (var x in replies) {\\\\n                var repliesx = replies[x];\\\\n                var message = replies[x].content.message;\\\\n                var member = replies[x].member;\\\\n                d.push({\\\\n                    title: member.uname,\\\\n                    img: member.avatar,\\\\n                    col_type: 'avatar'\\\\n                });\\\\n                d.push({\\\\n                    title: '<small><strong>' + message + '</strong></small>',\\\\n                    col_type: 'rich_text'\\\\n                });\\\\n                var reply = replies[x].replies;\\\\n                for (var z in reply) {\\\\n                    var mess = reply[z].content.message;\\\\n                    var mem = reply[z].member.uname;\\\\n                    d.push({\\\\n                        title: '<small>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;' + mem + ':' + mess + '</small>',\\\\n                        col_type: 'rich_text'\\\\n                    });\\\\n                }\\\\n            }\\\\n        }\\\\n\\\\n        if (getVar(\\\\\\\"label\\\\\\\") == '推荐') {\\\\n            for (var r in related) {\\\\n                d.push({\\\\n                    title: related[r].title,\\\\n                    img: related[r].pic,\\\\n                    desc: related[r].desc,\\\\n                    url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + related[r].bvid + '#immersiveTheme#',\\\\n                    col_type: 'movie_2'\\\\n                });\\\\n            }\\\\n        }\\\\n    }\\\\n} catch (e) {\\\\n throw e\\\\n}\\\\n\\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-关注1\\\",\\\"path\\\":\\\"gz1\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};var d = [];\\\\nvar id = MY_URL.split('mid=')[1];\\\\nvar surl = MY_URL;\\\\nvar code = fetch(surl,{});\\\\nvar ym = JSON.parse('{\\\\\\\"my'+code.split('{\\\\\\\"my')[1].split('}};')[0]+'}}');\\\\n\\\\nvar ep = ym['list']['getFollowList-page-mid-'+id]['result'];\\\\nfor ( x in ep){\\\\n  var yurl = 'https://api.bilibili.com/x/space/arc/search？？mid='+ep[x].mid+'＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate';\\\\n    d.push({\\\\n       title:ep[x].uname,\\\\n       img:ep[x].face,\\\\n       url:'hiker://page/gz2?url='+yurl,\\\\n       col_type:'icon_round_4'\\\\n       });\\\\n}\\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-关注2\\\",\\\"path\\\":\\\"gz2\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};var d = [];\\\\nconst headColor=\\\\\\\"#358ccd\\\\\\\";\\\\nvar json = {};\\\\neval('json=' + fetch(MY_URL,{}));\\\\nfor (var i = 0; i < json.data.list.vlist.length; i++)\\\\n{\\\\n var r = {};\\\\n var j = json.data.list.vlist[i];\\\\n var t = Number(j.created)*1000;\\\\n \\\\n //时间戳转换方法\\\\n /*\\\\nfunction getLocalTime(nS) { \\\\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\\\n     var YMD = sss.split('日')[0].replace('年','-').replace('月','-');\\\\n     return (YMD)\\\\n}\\\\n*/\\\\nfunction getLocalTime(nS) { \\\\nvar date = new Date(nS);\\\\nvar YY = date.getFullYear()+'-'; \\\\nvar MM = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1)+'-'; \\\\nvar DD = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate()); \\\\nvar time = YY + MM + DD;\\\\nreturn time\\\\n}\\\\n//时间戳转换\\\\nvar time = getLocalTime(t);\\\\n\\\\nif (j.play>10000)\\\\n    var play = (j.play/10000).toFixed(1)+'万';\\\\nelse\\\\n    var play = j.play;\\\\n\\\\nvar pics = (j.pic.indexOf(':')!=-1)?j.pic:'https:' + j.pic;\\\\n\\\\n if (j.length!=\\\\\\\"00:00\\\\\\\"){\\\\n    d.push({\\\\n     pic_url : pics,\\\\n     url : 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + j.bvid+'#immersiveTheme#',\\\\n     title : j.title,\\\\n     col_type : 'movie_1_left_pic',\\\\n     desc : '时长：' + j.length + '  播放量：' + play + '  日期：' + time\\\\n    \\\\n    });\\\\n}\\\\n}\\\\nres.data = d;\\\\nsetResult(res)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码块-搜索一级\\\",\\\"path\\\":\\\"s\\\",\\\"rule\\\":\\\"try {\\\\n    var res = {};\\\\n    var d = [];\\\\n    var code = getResCode();\\\\n    var xs = JSON.parse(code.split('video\\\\\\\",\\\\\\\"data\\\\\\\":')[1].split('}]')[0] + '}]');\\\\n    //if(MY_URL.split('page=')[1]=='1&pagesize=20'){\\\\n    var page = MY_URL.split('page=')[1].split('&pagesize=')[0];\\\\n    try {\\\\n        var w =\\\\n            JSON.parse(fetch('https://api.bilibili.com/x/web-interface/search/type?keyword=' + MY_URL.split('keyword=')[1].split('&')[0] + '&page=' + page + '&search_type=bili_user&order=totalrank&pagesize=20', {})).data.result;\\\\n        for (ii = 0; ii < w.length && ii < 2; ii++) {\\\\n            d.push({\\\\n                title: 'up：' + w[ii].uname,\\\\n                img: 'https:' + w[ii].upic,\\\\n                desc: '关注：' + w[ii].fans,\\\\n                content: '视频数：' + w[ii].videos,\\\\n                url: 'hiker://page/ss?url=https://api.bilibili.com/x/space/arc/search？？mid=' + w[ii].mid + '＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate#' + w[ii].uname + '#',\\\\n            });\\\\n        }\\\\n    } catch (e) {\\\\n        d.push({\\\\n            title: '‘‘找不到你想要的啊，要不换个关键词？’’',\\\\n            col_type: 'text_center_1'\\\\n        });\\\\n    }\\\\n    var fan = JSON.parse(code.split('media_bangumi\\\\\\\",\\\\\\\"data\\\\\\\":')[1].split('},{\\\\\\\"result_type')[0]);\\\\n    for (x in fan) {\\\\n        d.push({\\\\n            title: fan[x].title.replace(/<em class=\\\\\\\"keyword\\\\\\\">|<\\\\\\\\/em>/g, ''),\\\\n            img: fan[x].cover,\\\\n            desc: fan[x].desc,\\\\n            content: fan[x].cv.replace(/<em class=\\\\\\\"keyword\\\\\\\">|<\\\\\\\\/em>/g, ''),\\\\n            url: 'hiker://page/detail?url=' + fan[x].goto_url + '#immersiveTheme#',\\\\n            col_type: 'movie_1_left_pic'\\\\n        });\\\\n    }\\\\n    var fan2 = JSON.parse(code.split('media_ft\\\\\\\",\\\\\\\"data\\\\\\\":')[1].split('},{\\\\\\\"result_type')[0]);\\\\n    for (x in fan2) {\\\\n        d.push({\\\\n            title: fan2[x].title.replace(/<em class=\\\\\\\"keyword\\\\\\\">|<\\\\\\\\/em>/g, ''),\\\\n            img: fan2[x].cover,\\\\n            desc: fan2[x].desc,\\\\n            content: fan2[x].cv.replace(/<em class=\\\\\\\"keyword\\\\\\\">|<\\\\\\\\/em>/g, ''),\\\\n            url: 'hiker://page/detail?url=' + fan2[x].goto_url + '#immersiveTheme#',\\\\n            col_type: 'movie_1_left_pic'\\\\n        });\\\\n    }\\\\n    //}\\\\n\\\\n    for (x in xs) {\\\\n        d.push({\\\\n            title: xs[x].title.replace(/<em class=\\\\\\\"keyword\\\\\\\">|<\\\\\\\\/em>/g, ''),\\\\n            img: 'http:' + xs[x].pic,\\\\n            desc: xs[x].description,\\\\n            content: xs[x].author,\\\\n            url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + xs[x].bvid + '#immersiveTheme#',\\\\n            col_type: 'movie_1_left_pic'\\\\n        });\\\\n    }\\\\n\\\\n    res.data = d;\\\\n    setResult(res);\\\\n} catch (e) {\\\\n    var res = {};\\\\n    var d = [];\\\\n    var keyword = MY_URL.split('keyword=')[1].split('&page=')[0];\\\\n    var url = 'https://app.bilibili.com/x/v2/search/type?appkey=1d8b6e7d45233436&build=6270200&c_locale=zh_CN&channel=xiaomi&highlight=1&keyword=' + keyword + '&mobi_app=android&order=totalrank&platform=android&pn=1&ps=20&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.27.0%22%2C%22abtest%22%3A%22%22%7D&ts=1623076140&type=2&user_type=0&sign=5066216febb28a619812e88e5ff1a034';\\\\n    var code = JSON.parse(request(url, {}));\\\\n    var list = code.data.items;\\\\n    for (let x of list) {\\\\n        d.push({\\\\n            title: x.title,\\\\n            img: x.cover,\\\\n            desc: x.sign,\\\\n            url: 'hiker://page/ss?url=https://api.bilibili.com/x/space/arc/search?mid=' + x.param + '＆＆ps=30＆＆tid=0＆＆keyword=＆＆jsonp=jsonp＆＆pn=fypage＆＆order=pubdate#' + x.title + '#' + getVar('ua'),\\\\n            col_type: 'movie_1_left_pic'\\\\n        });\\\\n    }\\\\n    setResult(d);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_1_vertical_pic\\\",\\\"name\\\":\\\"页面-搜索二级\\\",\\\"path\\\":\\\"ss\\\",\\\"rule\\\":\\\"js:\\\\nvar json = {};\\\\neval('json=' + getResCode());\\\\nvar res = {};\\\\nvar d = [];\\\\nif (MY_URL.indexOf('pn=1&')!=-1){\\\\nd.push({\\\\ntitle:'““关注””',\\\\nurl:'hiker://empty#'+MY_URL.split('#')[1]+'&&'+MY_URL.split('mid=')[1].split('&')[0]+`@lazyRule=.js:input=input.split('#')[1];var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid='+input.split(\\\\\\\"&&\\\\\\\")[1]+'&jsonp=jsonp',{})).data.face;if(!getVar('lb2').includes(input.split('&&')[1].split('&&')[0])){var xr=getVar('lb2')+'\\\\\\\\\\\\\\\\n'+input+'##'+pic;writeFile(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\",xr);'toast://关注成功'}else{'toast://年轻人，耗子尾汁'}`,\\\\ncol_type: 'text_center_1'\\\\n});\\\\n}\\\\n\\\\nfor (var i = 0; i < json.data.list.vlist.length; i++)\\\\n{\\\\n var r = {};\\\\n var j = json.data.list.vlist[i];\\\\n var t = Number(j.created)*1000;\\\\n \\\\n //时间戳转换方法\\\\nfunction getLocalTime(nS) { \\\\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\\\n     var YMD = sss.split('日')[0].replace('年','-').replace('月','-');\\\\n     return (YMD)\\\\n}\\\\n\\\\n//时间戳转换\\\\nvar time = getLocalTime(t);\\\\n\\\\nif (j.play>10000)\\\\n    var play = (j.play/10000).toFixed(1)+'万';\\\\nelse\\\\n    var play = j.play;\\\\n\\\\nvar pics = (j.pic.indexOf(':')!=-1)?j.pic:'https:' + j.pic;\\\\n\\\\n r.pic_url = pics;\\\\n r.url = 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid='+j.bvid+'#immersiveTheme#',\\\\n       \\\\n\\\\n r.title = j.title;\\\\n r.desc = '时长：' + j.length + '  播放量：' + play + '  日期：' + time;\\\\n if (j.length!=\\\\\\\"00:00\\\\\\\"){d.push(r)};\\\\n}\\\\nres.data = d;\\\\nsetResult(res)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-预处理\\\",\\\"path\\\":\\\"ycl\\\",\\\"rule\\\":\\\"putVar2('ua',';get;utf-8;{User-Agent@Mozilla/5.0 (Linux；； Android 7.0；； wv lite baiduboxapp) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/78.0.3904.96 Mobile Safari/537.36 T7/10.3 SearchCraft/2.6.2 (Baidu；； P1 7.0)}');\\\\n\\\\nputVar('key',fetch('hiker://files/rules/bili/key.txt'));\\\\n\\\\nputVar('X5',\\\\\\\"@lazyRule=.js:var jx = fetch('hiker://files/bili/up_jxcache.txt',{});refreshX5WebView(jx+input);'toast://播放中'\\\\\\\");\\\\n\\\\nif (!fetch('hiker://files/bili/多合一.txt')) {\\\\n   writeFile('hiker://files/bili/多合一.txt','UP主');\\\\n   }\\\\n\\\\nif (!fetch('hiker://files/bili/收藏.txt')) {\\\\n   writeFile('hiker://files/bili/收藏.txt','视频');\\\\n   }\\\\n\\\\nif (fetch(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\", {})==''){\\\\n    if (fetch(\\\\\\\"hiker://files/bili/up.txt\\\\\\\", {})!=''){\\\\n    writeFile(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\",fetch(\\\\\\\"hiker://files/bili/up.txt\\\\\\\", {}));\\\\n    }\\\\n    else{\\\\n      var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid=103256880&jsonp=jsonp',{})).data.face;\\\\n      writeFile(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\", \\\\\\\"北城&&103256880##\\\\\\\"+pic);\\\\n      }\\\\n}\\\\n\\\\nif (!fetch(\\\\\\\"hiker://files/bili/up_cache.txt\\\\\\\", {})) {\\\\n  writeFile(\\\\\\\"hiker://files/bili/up_cache.txt\\\\\\\", \\\\\\\"103256880\\\\\\\");\\\\n}\\\\n\\\\nputVar2('lb2',fetch(\\\\\\\"hiker://files/rules/js/up.js\\\\\\\",{}));\\\\n\\\\n/*\\\\nputVar(\\\\\\\"解析口\\\\\\\",`hiker://empty#noHistory#@rule=js:var d = [];d.push({desc: '200',url: 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/bili/upjx.html',col_type: 'x5_webview_single'});var titles = fetch(\\\\\\\"hiker://files/bili/upjx.txt\\\\\\\", {}).split(/\\\\\\\\\\\\\\\\n/);for(var i = 0; i < titles.length; i++){var t = titles[i].split(\\\\\\\"&&\\\\\\\");d.push({title:fetch(\\\\\\\"hiker://files/bili/up_jxcache.txt\\\\\\\",{}) == t[1] ? t[0] + \\\\\\\"‘‘（当前）’’\\\\\\\" : t[0],desc:t[1],url:t[1] + '@lazyRule=.js:putVar2(\\\\\\\"uid\\\\\\\",input);writeFile(\\\\\\\"hiker://files/bili/up_jxcache.txt\\\\\\\",input);back();\\\\\\\"toast://修改成功\\\\\\\"',col_type: 'text_1'});}setResult(d);`);\\\\n\\\\nif (!fetch(\\\\\\\"hiker://files/bili/upjx.txt\\\\\\\", {})) {\\\\n  writeFile(\\\\\\\"hiker://files/bili/upjx.txt\\\\\\\", \\\\\\\"全网VIP&&https://jxx.smys8.cn/index.php?url=\\\\\\\\n加速&&https://www.cuan.la/m3u8.php?url=\\\\\\\");\\\\n}\\\\n\\\\n\\\\nlet localHtml2 = fetch(\\\\\\\"hiker://files/bili/upjx.html\\\\\\\", {});\\\\nlet gitHtml2 = fetch(\\\\\\\"https://cdn.jsdelivr.net/gh/Zruiry/hikerview/html/jiexi.html\\\\\\\", {}).replace(/jiexi\\\\\\\\/jiexi/g,\\\\\\\"bili/upjx\\\\\\\");\\\\nif (!localHtml2) {\\\\n  writeFile(\\\\\\\"hiker://files/bili/upjx.html\\\\\\\", gitHtml2);\\\\n  var titles = fetch(\\\\\\\"hiker://files/bili/upjx.txt\\\\\\\", {});\\\\n  var t = titles.split(\\\\\\\"&&\\\\\\\")[1];\\\\n  writeFile(\\\\\\\"hiker://files/bili/up_jxcache.txt\\\\\\\",t);\\\\n}\\\\n*/\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-推荐\\\",\\\"path\\\":\\\"feed\\\",\\\"rule\\\":\\\"var url = 'https://app.bilibili.com/x/intl/feed/index?access_key=' + getVar(\\\\\\\"access_key\\\\\\\") + '&autoplay_card=2&build=6225300&c_locale=zh_CN&channel=master&column=2&device_name=&device_type=0&flush=8&fnval=464&fnver=0&force_host=0&fourk=1&guidance=0&https_url_req=0&mobi_app=android&network=wifi&platform=android&player_net=1&pull=false&qn=80&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.22.5%22%2C%22abtest%22%3A%22%22%7D';\\\\nvar list = JSON.parse(request(url, {})).data.items;\\\\nfor (let x of list) {\\\\n    var url = x.goto == \\\\\\\"bangumi\\\\\\\" ? \\\\\\\"hiker://page/detail?url=\\\\\\\" + x.uri.split(\\\\\\\"?\\\\\\\")[0] + '#immersiveTheme#' : \\\\\\\"hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=\\\\\\\" + x.param + \\\\\\\"＆＆bvid=\\\\\\\" + '#immersiveTheme#';\\\\n    d.push({\\\\n        title: x.goto == \\\\\\\"bangumi\\\\\\\" ? \\\\\\\"💰\\\\\\\" + x.title : x.title,\\\\n        desc: x.cover_left_1_content_description + \\\\\\\" \\\\\\\" + x.cover_left_2_content_description + \\\\\\\"  \\\\\\\" + x.cover_right_text,\\\\n        pic: x.cover + \\\\\\\"@Referer=https://www.bilibili.com/\\\\\\\",\\\\n        url: url,\\\\n        col_type: 'movie_2'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-新番\\\",\\\"path\\\":\\\"newbgm\\\",\\\"rule\\\":\\\"if (MY_URL.split('#')[1]=='1') {\\\\n\\\\n    let url = 'https://api.bilibili.com/pgc/app/timeline?access_key=&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&filter_type=0&mobi_app=android&night_mode=0&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=1635952840&sign=6e4df4542d38eee2fabf212885b90c64';\\\\n    try {\\\\n        var source_code = JSON.parse(request(url, {}));\\\\n        var dateline = [{\\\\n            \\\\\\\"code\\\\\\\": source_code.result.data[4],\\\\n            \\\\\\\"name\\\\\\\": \\\\\\\"前日\\\\\\\",\\\\n            \\\\\\\"id\\\\\\\": \\\\\\\"0\\\\\\\"\\\\n        },{\\\\n            \\\\\\\"code\\\\\\\": source_code.result.data[5],\\\\n            \\\\\\\"name\\\\\\\": \\\\\\\"昨日\\\\\\\",\\\\n            \\\\\\\"id\\\\\\\": \\\\\\\"1\\\\\\\"\\\\n        }, {\\\\n            \\\\\\\"code\\\\\\\": source_code.result.data[6],\\\\n            \\\\\\\"name\\\\\\\": \\\\\\\"今日\\\\\\\",\\\\n            \\\\\\\"id\\\\\\\": \\\\\\\"2\\\\\\\"\\\\n        }, {\\\\n            \\\\\\\"code\\\\\\\": source_code.result.data[7],\\\\n            \\\\\\\"name\\\\\\\": \\\\\\\"明日\\\\\\\",\\\\n            \\\\\\\"id\\\\\\\": \\\\\\\"3\\\\\\\"\\\\n        },{\\\\n            \\\\\\\"code\\\\\\\": source_code.result.data[8],\\\\n            \\\\\\\"name\\\\\\\": \\\\\\\"后日\\\\\\\",\\\\n            \\\\\\\"id\\\\\\\": \\\\\\\"4\\\\\\\"\\\\n        }];\\\\n        if (!getVar('id')) {\\\\n            putVar('id', '2');\\\\n        }\\\\n        let id = getVar('id');\\\\n        d.push({\\\\n            title: id == '0' ? getHead('前日') : '前日',\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('id', '0');refreshPage();'toast://success!'\\\\\\\",\\\\n            col_type: 'text_5'\\\\n        });\\\\n        d.push({\\\\n            title: id == '1' ? getHead('昨日') : '昨日',\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('id', '1');refreshPage();'toast://success!'\\\\\\\",\\\\n            col_type: 'text_5'\\\\n        });\\\\n        d.push({\\\\n            title: id == '2' ? getHead('今日') : '今日',\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('id', '2');refreshPage();'toast://success!'\\\\\\\",\\\\n            col_type: 'text_5'\\\\n        });\\\\n        d.push({\\\\n            title: id == '3' ? getHead('明日') : '明日',\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('id', '3');refreshPage();'toast://success!'\\\\\\\",\\\\n            col_type: 'text_5'\\\\n        });\\\\n        d.push({\\\\n            title: id == '4' ? getHead('后日') : '后日',\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('id', '4');refreshPage();'toast://success!'\\\\\\\",\\\\n            col_type: 'text_5'\\\\n        });\\\\n        let list = dateline[id].code.episodes;\\\\n        for (let x of list) {\\\\n            let type = (x.published == '1' ? '已发布' : '未发布');\\\\n            log(type)\\\\n            d.push({\\\\n                title: x.title,\\\\n                desc: '‘‘' + type + '’’\\\\\\\\n' + x.pub_index + '\\\\\\\\n更新时间：' + getHead(x.pub_time),\\\\n                url: 'hiker://page/detail?url=' + x.url + '#immersiveTheme#',\\\\n                img: x.cover+Referer,\\\\n                col_type:'movie_1_vertical_pic'\\\\n            });\\\\n        }\\\\n    } catch (e) {\\\\n        d.push({\\\\n            title: getHead('链接炸了，等修复'),\\\\n            col_type: 'text_center_1'\\\\n        });\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-番剧索引\\\",\\\"path\\\":\\\"sy\\\",\\\"rule\\\":\\\"const { CategoriesHeader } = $.require(\\\\\\\"hiker://page/categories-header\\\\\\\")\\\\n\\\\n/**\\\\n * 获取分类数据源，可动态可静态，自己根据实际情况处理\\\\n * https://www.bilibili.com/anime/index/\\\\n */\\\\nlet mCategories = {}\\\\nlet catInVar = getVar(MY_RULE.url + \\\\\\\"#categories\\\\\\\", '')\\\\nif (getVar(MY_RULE.url + \\\\\\\"#categories\\\\\\\", '')) {\\\\n    mCategories = JSON.parse(catInVar)\\\\n} else {\\\\n    let catUrl = 'https://www.bilibili.com/anime/index/'\\\\n    let catSrc = request(catUrl)\\\\n    // log(catSrc)\\\\n    let catRegex = /window\\\\\\\\.__INITIAL_STATE__=(.*?);\\\\\\\\(function\\\\\\\\(\\\\\\\\)\\\\\\\\{/\\\\n    if (catRegex.test(catSrc)) {\\\\n        // log(RegExp.$1)\\\\n        let category = JSON.parse(RegExp.$1)\\\\n        let mFilters = category.filters;\\\\n        // log(mFilters)\\\\n        mFilters.map(filter => mCategories[filter.key] = filter.list)\\\\n        let orders = category.orders\\\\n        let mOrders = []\\\\n        orders.map(order => {\\\\n            let mOrder = {}\\\\n            mOrder.name = order.title\\\\n            mOrder.value = order.key\\\\n            mOrders.push(mOrder)\\\\n        })\\\\n        // log(mOrders)\\\\n        mCategories['order'] = mOrders\\\\n    }\\\\n    putVar(MY_RULE.url + \\\\\\\"#categories\\\\\\\", JSON.stringify(mCategories))\\\\n}\\\\nlet keys = Object.keys(mCategories)\\\\n// log(mCategories)\\\\n// log(keys)\\\\n/**\\\\n * 组合当前分类链接\\\\n */\\\\nlet true_url = getVar(MY_RULE.url, MY_URL)\\\\ntrue_url = 'https://api.bilibili.com/pgc/season/index/result?'\\\\nfor (let it of keys) {\\\\n    let cat_url = getVar(MY_RULE.url + \\\\\\\"#\\\\\\\" + it, it === 'orders' ? '3' : '-1')\\\\n    true_url += (cat_url ? '&' + it + '=' + cat_url : '')\\\\n}\\\\n// let page = 1\\\\nconst page = MY_URL.split('#')[1]\\\\nif(page==1){\\\\n    \\\\n}\\\\ntrue_url = true_url +\\\\n    '&st=1&sort=0&season_type=1&pagesize=20&type=1' +\\\\n    '&page=' + page\\\\n// log(true_url)\\\\n\\\\nconst empty = \\\\\\\"hiker://empty\\\\\\\"\\\\n\\\\nCategoriesHeader\\\\n    .setSubCategoriesItemKey('name', 'value')\\\\n    .get(d, mCategories, page)\\\\n/**\\\\n * 获取当前分类页面源码\\\\n */\\\\ntry {\\\\n    var sylist = JSON.parse(request(true_url, {})).data.list;\\\\n\\\\n    /**\\\\n     * 列表数据源\\\\n     */\\\\n    for (let data of sylist) {\\\\n        d.push({\\\\n            title: data.title /*+ '/' + data.index_show*/ ,\\\\n            desc: data.order,\\\\n            img: data.cover+Referer,\\\\n            url: 'hiker://page/detail?url=' + data.link + '#immersiveTheme#',\\\\n            col_type: 'movie_3'\\\\n        });\\\\n    }\\\\n} catch (e) {}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-动态分类模块\\\",\\\"path\\\":\\\"categories-header\\\",\\\"rule\\\":\\\"js:\\\\n/**\\\\n * 使用说明：\\\\n * 1.提前建立好 分类所属类型和分类列表 的对应关系，即 get 函数中的 categories\\\\n * 2.设置子分类数据的 key，调用 setSubCategoriesItemKey(titleKey, urlKey)\\\\n * 3.然后调用 CategoriesHeader.get(layout, categories, page)\\\\n *\\\\n * 支持链式调用，一句话即可调用生成分类，即：\\\\n * CategoriesHeader\\\\n *    .setSubCategoriesItemKey(titleKey, urlKey)\\\\n *    .get(layout, categories, page)\\\\n *\\\\n * @type {{setSubCategoriesItemKey: CategoriesHeader.setSubCategoriesItemKey, get: CategoriesHeader.get, categoriesKey: {title: string, url: string}}}\\\\n */\\\\nlet CategoriesHeader = {\\\\n    categoriesKey: {\\\\n        sub_categories: '',\\\\n        title: '',\\\\n        url: '',\\\\n    },\\\\n    /**\\\\n     * 1.设置从分类列表中拿的子分类的数据 key，\\\\n     *   根据 key 拿到数据后，\\\\n     *   会自动赋值给 scroll_button 的 { title: item[titleKey], url: item[urlKey] }\\\\n     *\\\\n     * @param title_key title 的 key\\\\n     * @param url_key url 的 key\\\\n     */\\\\n    setSubCategoriesItemKey : (title_key, url_key) => {\\\\n        CategoriesHeader.categoriesKey.title = title_key\\\\n        CategoriesHeader.categoriesKey.url = url_key\\\\n        return CategoriesHeader;\\\\n    },\\\\n    setSubCategoriesKey: (sub_categories_key) => {\\\\n        CategoriesHeader.categoriesKey.sub_categories = sub_categories_key\\\\n        return CategoriesHeader;\\\\n    },\\\\n    /**\\\\n     * 2.获取分类头部\\\\n     *\\\\n     * @param layout 当前界面，即常用的 d.push 的 d\\\\n     * @param categories 分类所属类型和分类列表的对应关系表，\\\\n     *        如：\\\\n     *        {\\\\n     *           \\\\\\\"年份\\\\\\\": [{ \\\\\\\"name\\\\\\\": \\\\\\\"2021\\\\\\\", \\\\\\\"value\\\\\\\": \\\\\\\"2021\\\\\\\" }, { \\\\\\\"name\\\\\\\": \\\\\\\"2020\\\\\\\", \\\\\\\"value\\\\\\\": \\\\\\\"2020\\\\\\\" }...],\\\\n     *           \\\\\\\"排序\\\\\\\": [{ \\\\\\\"name\\\\\\\": \\\\\\\"热度\\\\\\\", \\\\\\\"value\\\\\\\": \\\\\\\"hot\\\\\\\" }, { \\\\\\\"name\\\\\\\": \\\\\\\"时间\\\\\\\", \\\\\\\"value\\\\\\\": \\\\\\\"time\\\\\\\" }...],\\\\n     *        }\\\\n     * @param page 页码\\\\n     * @param urlListener 额外处理 button 的 url，需要 return\\\\n     */\\\\n    get: (layout, categories, page, urlListener) => {\\\\n        // log(categories)\\\\n        // 分类所属类型的列表，如：[ \\\\\\\"年份\\\\\\\", \\\\\\\"排序\\\\\\\" ]\\\\n        let category_names = Object.keys(categories)\\\\n        let types = []\\\\n        // 根据对应关系表拿分类列表\\\\n        category_names.map(category_name => {\\\\n            // 这里会拿到 年份 排序... 其中一个\\\\n            types.push(categories[category_name]);\\\\n            // 这里下面对 types 的值进行处理\\\\n        })\\\\n        categories = types;\\\\n        let init_cate = []\\\\n\\\\n        for (let i = 0; i < 20; i++) {\\\\n            init_cate.push(\\\\\\\"0\\\\\\\")\\\\n        }\\\\n\\\\n        const cate_temp_json = getVar(MY_RULE.title, JSON.stringify(init_cate))\\\\n        const cate_temp = JSON.parse(cate_temp_json)\\\\n\\\\n        if (parseInt(page) === 1) {\\\\n            /**\\\\n             * 遍历第 index 层分类\\\\n             */\\\\n            categories.forEach((category, index) => {\\\\n                let sub_category_name = category_names[index]\\\\n                let sub_categories_key = CategoriesHeader.categoriesKey.sub_categories\\\\n                let sub_categories = sub_categories_key ? category[sub_categories_key] : category;\\\\n                // log(category)\\\\n                /**\\\\n                 * 在第 index 层分类中遍历该层所有子分类\\\\n                 */\\\\n                sub_categories.forEach((item, key) => {\\\\n                    let title = item[CategoriesHeader.categoriesKey.title]\\\\n                    let url = escape(item[CategoriesHeader.categoriesKey.url])\\\\n                    if (urlListener) url = urlListener.onDeal(item, sub_category_name, url)\\\\n                    layout.push({\\\\n                        title: key.toString() === cate_temp[index] ? '““””<b><span style=\\\\\\\"color: #098AC1\\\\\\\">' + title + '</span></b>' : title,\\\\n                        url: $(url).lazyRule((params) => {\\\\n                            params.cate_temp[params.index] = params.key.toString()\\\\n\\\\n                            putVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\\\n                            putVar(MY_RULE.url + \\\\\\\"#\\\\\\\" + params.sub_category_name, input)\\\\n                            refreshPage(true)\\\\n                            return \\\\\\\"hiker://empty\\\\\\\"\\\\n                        }, {\\\\n                            cate_temp: cate_temp,\\\\n                            index: index,\\\\n                            key: key,\\\\n                            page: page,\\\\n                            sub_category_name: sub_category_name\\\\n                        }),\\\\n                        col_type: 'scroll_button',\\\\n                    })\\\\n                })\\\\n                layout.push({\\\\n                    col_type: \\\\\\\"blank_block\\\\\\\"\\\\n                });\\\\n            })\\\\n        }\\\\n    }\\\\n}\\\\n$.exports.CategoriesHeader=CategoriesHeader\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"我的收藏-视频\\\",\\\"path\\\":\\\"video\\\",\\\"rule\\\":\\\"var ts = new Date().getTime();\\\\nvar video_url = 'https://api.bilibili.com/x/v3/fav/folder/space?access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts=' + ts + '&up_mid=' + getVar('starid') + '&sign=0a51b772f81dc7812cd66226a8325383';\\\\nvar list = JSON.parse(request(video_url)).data;\\\\nfor (var x of list) {\\\\n    d.push({\\\\n        title: x.name,\\\\n        img: 'https://gitee.com/CherishRx/imagewarehouse/raw/master/image/13096725fe56ce9cf643a0e4cd0c159c.gif',\\\\n        url: \\\\\\\"hiker://empty#\\\\\\\"+x.id+\\\\\\\"@lazyRule=.js:putVar('change',getVar('change')==input.split('#')[1]?'0':input.split('#')[1]);refreshPage();'toast://已刷新'\\\\\\\",\\\\n        col_type: 'avatar'\\\\n    });\\\\n    if (getVar('change') == x.id) {\\\\n        var list2 = x.mediaListResponse.list;\\\\n        log(list2)\\\\n        for (var a in list2) {\\\\n            d.push({\\\\n                title: list2[a].title,\\\\n                img: list2[a].cover+Referer,\\\\n                url:'hiker://page/collection?url=https://api.bilibili.com/x/v3/fav/resource/ids？？access_key='+getVar('access_key')+'＆＆appkey=1d8b6e7d45233436＆＆build=6130400＆＆c_locale=zh_CN＆＆channel=master＆＆media_id='+list2[a].id+'＆＆mid='+getVar('starid')+'＆＆mobi_app=android＆＆platform=android＆＆s_locale=zh_CN＆＆statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D＆＆ts='+ts+'＆＆sign=7e0f1b92f3ef3828b19be66838915007',\\\\n               // desc: a['media_count'],\\\\n                col_type: 'movie_1_vertical_pic'\\\\n            });\\\\n        }\\\\n\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"我的收藏-追番\\\",\\\"path\\\":\\\"fanju\\\",\\\"rule\\\":\\\"var ts = new Date().getTime();\\\\nvar video_url = 'https://api.bilibili.com/pgc/app/follow/v2/bangumi?access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&pn=' + pagenum + '&ps=20&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.9.1%22%2C%22abtest%22%3A%22%22%7D&status=2&ts=' + ts + '&sign=1624f9598dca06eb129534e4765f9b1a';\\\\ntry {\\\\n    var list = JSON.parse(request(video_url)).result.follow_list;\\\\n    for (var x of list) {\\\\n        var 类型 = x.is_finish == 1 ? \\\\\\\"完结\\\\\\\" : \\\\\\\"连载\\\\\\\";\\\\n        var 标识 = x['season_type_name'] + \\\\\\\" | \\\\\\\" + x.badge;\\\\n        var desc = x.progress ? 标识 + \\\\\\\"\\\\\\\\n““\\\\\\\" + x.new_ep.index_show + \\\\\\\"””\\\\\\\\n\\\\\\\" + x.progress.index_show : 标识 + \\\\\\\"\\\\\\\\n““\\\\\\\" + x.new_ep.index_show + \\\\\\\"””\\\\\\\\n\\\\\\\";\\\\n        d.push({\\\\n            title: x.title + \\\\\\\"\\\\\\\\t\\\\\\\" + getHead(类型),\\\\n            img: x.new_ep.cover + Referer,\\\\n            desc: desc,\\\\n            url: \\\\\\\"hiker://page/detail?url=\\\\\\\" + x.url + '#immersiveTheme#',\\\\n            col_type: 'movie_1_vertical_pic'\\\\n        });\\\\n    }\\\\n} catch (e) {}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"我的收藏-追剧\\\",\\\"path\\\":\\\"dsj\\\",\\\"rule\\\":\\\"var ts = new Date().getTime();\\\\nvar video_url = 'https://api.bilibili.com/pgc/app/follow/v2/cinema?access_key=' + getVar('access_key') + '&appkey=1d8b6e7d45233436&build=6091000&c_locale=zh_CN&channel=master&mobi_app=android&platform=android&pn=' + pagenum + '&ps=20&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.9.1%22%2C%22abtest%22%3A%22%22%7D&status=2&ts=' + ts + '&sign=1624f9598dca06eb129534e4765f9b1a';\\\\ntry {\\\\n    var list = JSON.parse(request(video_url)).result.follow_list;\\\\n    for (var x of list) {\\\\n        var 类型 = x.is_finish == 1 ? \\\\\\\"完结\\\\\\\" : \\\\\\\"连载\\\\\\\";\\\\n        var 标识 = x['season_type_name'] + \\\\\\\" | \\\\\\\" + x.areas[0].name;\\\\n        var desc = x.progress ? 标识 + \\\\\\\"\\\\\\\\n““\\\\\\\" + x.new_ep.index_show + \\\\\\\"””\\\\\\\\n\\\\\\\" + x.progress.index_show : 标识 + \\\\\\\"\\\\\\\\n““\\\\\\\" + x.new_ep.index_show + \\\\\\\"””\\\\\\\\n\\\\\\\";\\\\n        d.push({\\\\n            title: x.title + \\\\\\\"\\\\\\\\t\\\\\\\" + getHead(类型),\\\\n            img: x.new_ep.cover + Referer,\\\\n            desc: desc,\\\\n            url: \\\\\\\"hiker://page/detail?url=\\\\\\\" + x.url + '#immersiveTheme#',\\\\n            col_type: 'movie_1_vertical_pic'\\\\n        });\\\\n    }\\\\n} catch (e) {}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"我的收藏-收藏\\\",\\\"path\\\":\\\"collection\\\",\\\"rule\\\":\\\"js:var res = {};var d = [];\\\\nvar ts = new Date().getTime();\\\\nvar code = JSON.parse(request(MY_URL)).data;\\\\nvar resources = '';\\\\nfor (var x of code){\\\\n    var resources = resources + x.id + ':' + x.type + ',';\\\\n}\\\\nvar resources = resources.slice(0,resources.length-1);\\\\nvar url = 'https://api.bilibili.com/x/v3/fav/resource/infos?access_key='+getVar('access_key')+'&appkey=1d8b6e7d45233436&build=6130400&c_locale=zh_CN&channel=maste&mid='+getVar('starid')+'&mobi_app=android&platform=android&resources='+resources+'&s_locale=zh_CN&statistics=%7B%22appId%22%3A1%2C%22platform%22%3A3%2C%22version%22%3A%226.13.0%22%2C%22abtest%22%3A%22%22%7D&ts='+ts+'&sign=7e0f1b92f3ef3828b19be66838915007';\\\\nvar list = JSON.parse(request(url,{})).data;\\\\nfor (var y of list ){\\\\nd.push({\\\\n    title:y.title,\\\\n    img:y.cover,\\\\n    desc:'播放量: '+y.cnt_info.play+'  弹幕: '+y.cnt_info.danmaku,\\\\n    url:'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + y.bvid +'#immersiveTheme#',\\\\n    col_type:'movie_1_vertical_pic'\\\\n    });\\\\n}\\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-登录\\\",\\\"path\\\":\\\"login\\\",\\\"rule\\\":\\\"evalPrivateJS('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')\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-登录\\\",\\\"path\\\":\\\"pwd-login\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar islogin = fetch('hiker://files/rules/bili/islogin.txt', {});\\\\nif (islogin === \\\\\\\"1\\\\\\\") {\\\\n    d.push({\\\\n        url: \\\\\\\"putVar('my_account',input);refreshPage();'toast://你的账号是' + input;\\\\\\\",\\\\n        col_type: 'input',\\\\n        title: '账号',\\\\n        extra: {\\\\n            onChange: \\\\\\\"putVar('my_account',input)\\\\\\\",\\\\n            type: 'textarea',\\\\n            height: 1,\\\\n            defaultValue: getVar('my_account')\\\\n        }\\\\n    });\\\\n\\\\n    d.push({\\\\n        url: \\\\\\\"putVar('my_password',input);refreshPage();'toast://你的密码是' + input\\\\\\\",\\\\n        col_type: 'input',\\\\n        title: '密码',\\\\n        extra: {\\\\n            onChange: \\\\\\\"putVar('my_password',input)\\\\\\\",\\\\n            type: 'textarea',\\\\n            height: 1,\\\\n            defaultValue: getVar('my_password')\\\\n        }\\\\n    })\\\\n    d.push({\\\\n        title: \\\\\\\"““大会员？(先点我)””\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: $(\\\\\\\"不是大会员别点确认，否则后果自负\\\\\\\").confirm(() => {\\\\n            putVar(\\\\\\\"isvip\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://你选择了大会员。祝好运(✪▽✪)\\\\\\\"\\\\n        })\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"““登录(再点我)””\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: $(\\\\\\\"确认登录？\\\\\\\").confirm(() => {\\\\n            putVar(\\\\\\\"logining\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://你选择了登录。祝好运(✪▽✪)\\\\\\\"\\\\n        })\\\\n    });\\\\n    if (getVar(\\\\\\\"logining\\\\\\\") === \\\\\\\"1\\\\\\\") {\\\\n        if (getVar('my_account') != '' && getVar('my_password') != '') {\\\\n            // TODO 吐佬说这里可以改成 $.require 用法          \\\\n            evalPrivateJS(\\\\\\\"dtd1P3dTEITonsgrNFfoBigi5ljaz0PeGmbmMjjr9H5nfvsnBw7JFp37cn3egqu0y/0wTW2oU7qtMwQIAiLhESVKBlKkRvW0pnPDdHl7PGwwDT5GM1vBsogb7YDpwmwV8rttad0O5YJBvpjX29hUBpSsiao7l3UebzxNAWYij7YwHWht0jVbh5SL7PXVo149fPSTuxl8A+vLUWi+2WxGrOZ+QvtrYIn28BqS8PS7zf0R0yr9hXzjbMOOX2COdVYKPdbGsxzklV5X2LLmKbPgEfQElCgMZpYune0I8OyI55HLK8tI1lZz+wif+9ZIAdT2dTQvCBb+iHjpR6K0Mr0dfc/jrTd/+nmsmWrkjituq8x2h7U3bZmaxkqYrxSoprLiZvnBkSvEoIiqUUOKimCy01f3tRfSQBeR5lgT5A/xqgd28aEqssiPJrXXIGnYsy3MLZRhSLw5kdSU3Y+dyCa6ZcIDxlOGeSFLmI0OCFbpZe9bY7nKUOai3+THsaFiEEqpd/6nUQF4TZRBgVqjYEFwWJyKAK6DAqoRvB2T0if2wUvOlDL7DvzzsOQnK+/bCc4nyZxdDfQXN6RqB+i6NgTbCjNd4TFX5fWBvHa5pHrTSZAhTW9wFA5wsADB95y+Jx2X9Qk4GLCGstgGcmHm96ap1uWq+K8vGEZEbEjkU52tMS5zz6gm7YhXf8eBYBmEaiLuMeU75Ge2qS6uOoj22ITEUcsry0jWVnP7CJ/71kgB1PYZNynXLl1tfoDY3HZgPakf6D+ADzQYqxqRKZCtlNIya9k8C4H7fbhLDXdWA3oV5yUOgaSXK1OM40FxNyNXpA/ZKS6gY3B1/V2+zpz+Q7Cmue5+qaO0XrDP15hjS4bxnWrOlDL7DvzzsOQnK+/bCc4nXxekuoTVURY7eh+dIF4QOaXmbNjYNkiqnAd85FrXKXoegJZC85B4JVqOWcueipNaHy/dwAhKpnK/5JO7Z6ya2ls2/JvPOCP91e6g4HO+YqEpLqBjcHX9Xb7OnP5DsKa5nprbkIP2knDXXqtMYGRdcigeIRz+OHmnKLm/+WCPa0618EqvMsGg9fpvtUo2/tm0RzYYi8kuFGopTyoikDwi3csry0jWVnP7CJ/71kgB1Pa1ADkvivkncEhPWP4wXCaTwwpZ0G6+YTvyp68thFdAL5xx9+nUa5jWmJUyyQ+r1UsD5sMqinY5b/eDUnxRKKBTzpQy+w7887DkJyvv2wnOJydHPM2ah78eAttSahVCEb/l3Zqi2hFkiZJ8gxPC0PY7/qt2N0n8lHD8+72KTUDIquX565CIQncDW5KfXUZLOnZbs6RTqR00LuPHAxPIHhiabjkNvSVQOzv3awerameSO8sry0jWVnP7CJ/71kgB1PbZfAA+7g+YdTNpeu9LRRooiFwV/9cu5HpEgZ2X6waWdooY1g5pCXKpMu/d7c3hdQfLK8tI1lZz+wif+9ZIAdT2Y96skBtNlvNAx6IGpzKN8eN0OJCm2IqsJJnHXJd1fryCMmECFEeaVbpuKG3V09wAC7SYi7j/bCB+DC11BSaZv8B3pQ9ZaBHrAsg+dNR+0WMtZjK4QlfzsMtgGqdnl/D+\\\\\\\")\\\\n        }\\\\n    }\\\\n} else if (islogin === \\\\\\\"2\\\\\\\") {\\\\n    d.push({\\\\n        title: \\\\\\\"““已登录！””\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: $(\\\\\\\"确认重新登录？(请不要尝试多次登录，否则账号异常)\\\\\\\").confirm(() => {\\\\n            putVar(\\\\\\\"islogin\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\\\\\"1\\\\\\\");\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://你选择了登录。祝好运(✪▽✪)\\\\\\\"\\\\n        })\\\\n    });\\\\n} else if (islogin === \\\\\\\"3\\\\\\\") {\\\\n    d.push({\\\\n        title: \\\\\\\"““你需要去客户端改下密码才能登录！！！””\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: $(\\\\\\\"确认登录？(请不要尝试多次登录，否则账号异常)\\\\\\\").confirm(() => {\\\\n            putVar(\\\\\\\"islogin\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\\\\\"1\\\\\\\");\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://你选择了登录。祝好运(✪▽✪)\\\\\\\"\\\\n        })\\\\n    });\\\\n} else {\\\\n    d.push({\\\\n        title: \\\\\\\"““点击进入登录页面””\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: $(\\\\\\\"确认登录？(请不要尝试多次登录，否则账号异常)\\\\\\\").confirm(() => {\\\\n            putVar(\\\\\\\"islogin\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\\\\\"1\\\\\\\");\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://你选择了登录。祝好运(✪▽✪)\\\\\\\"\\\\n        })\\\\n    });\\\\n}\\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"登录页面\\\",\\\"path\\\":\\\"newlogin\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nd.push({\\\\n    title: \\\\\\\"““方法一””\\\\\\\",\\\\n    url: 'hiker://empty@lazyRule=.js:putVar(\\\\\\\"l_id\\\\\\\",\\\\\\\"1\\\\\\\");refreshPage();\\\\\\\"toast://刷新成功\\\\\\\"',\\\\n    col_type: 'text_2'\\\\n});\\\\nd.push({\\\\n    title: \\\\\\\"““方法二””\\\\\\\",\\\\n    url: 'hiker://empty@lazyRule=.js:putVar(\\\\\\\"l_id\\\\\\\",\\\\\\\"2\\\\\\\");refreshPage();\\\\\\\"toast://刷新成功\\\\\\\"',\\\\n    col_type: 'text_2'\\\\n});\\\\nif (getVar(\\\\\\\"l_id\\\\\\\") == \\\\\\\"1\\\\\\\") {\\\\n    d.push({\\\\n        title: '操作指引 ①先点击下方第一步进去哔哩手机版网页登录账号 ②返回直接点第二步登录然后按提示登录 ““注:方法一不可用再采用方法二””',\\\\n        col_type: 'rich_text'\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"““1. 点我去网页登录后自动获取cookie””\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/ck\\\\\\\",\\\\n        col_type: 'text_center_1'\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"““2. 再点我登录””\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/weblogin\\\\\\\",\\\\n        col_type: 'text_center_1'\\\\n    });\\\\n}\\\\nif (getVar(\\\\\\\"l_id\\\\\\\") == \\\\\\\"2\\\\\\\") {\\\\n    d.push({\\\\n        title: \\\\\\\"操作指引 ①先点击下方第一步进去哔哩手机版网页登录账号 ②点击右下角设置→查看源码→原生界面 ③复制最上方输入框里的链接 ④返回首页把链接输入框内 ⑤点击第二步，按提示登录即可\\\\\\\",\\\\n        col_type: 'rich_text'\\\\n    });\\\\n    d.push({\\\\n        title: '保存',\\\\n        url: \\\\\\\"var ck = 'SESSDATA'+input.split('SESSDATA')[1].split('sid')[0].replace('；；','; ');writeFile('hiker://files/rules/bili/bilick.txt',ck.replace('；；','; '));refreshPage();'toast://您的cookie是:'+ck\\\\\\\",\\\\n        col_type: 'input',\\\\n        desc: '请输入链接'\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"““1. 点我去网页登录后手动获取cookie””\\\\\\\",\\\\n        url: \\\\\\\"https://m.bilibili.com/\\\\\\\",\\\\n        col_type: 'text_center_1'\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"““2. 点我登录””\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/weblogin\\\\\\\",\\\\n        col_type: 'text_center_1'\\\\n    });\\\\n}\\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"cookie获取\\\",\\\"path\\\":\\\"ck\\\",\\\"rule\\\":\\\"js:\\\\nsetResult([{\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n    url: \\\\\\\"https://m.bilibili.com/\\\\\\\",\\\\n    desc: \\\\\\\"float&&100%\\\\\\\",\\\\n    extra: {\\\\n        js: $.toString(() => {\\\\n            fba.log(document.cookie)\\\\n            fy_bridge_app.writeFile('hiker://files/rules/bili/bilick.txt', fy_bridge_app.getCookie('https://m.bilibili.com/'));\\\\n        })\\\\n    }\\\\n}])\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-web登录\\\",\\\"path\\\":\\\"weblogin\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar ck = fetch(\\\\\\\"hiker://files/rules/bili/bilick.txt\\\\\\\").replace(/；； /g,'; ');\\\\nlog(ck)\\\\nvar login_url = \\\\\\\"https://passport.bilibili.com/login/app/third?appkey=27eb53fc9058f8c3&api=http%3A%2F%2Flink.acg.tv%2Fforum.php&sign=67ec798004373253d60114caaad89a8c\\\\\\\";\\\\nvar location = JSON.parse(fetch(login_url, {\\\\n    headers: {\\\\n        \\\\\\\"user-agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Linux; Android 10; M2007J3SC Build/QKQ1.200419.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.101 Mobile Safari/537.36\\\\\\\",\\\\n        \\\\\\\"cookie\\\\\\\": ck\\\\n    },\\\\n    method: 'GET'\\\\n})).data['confirm_uri'];\\\\n//log(location);\\\\n\\\\nvar info = JSON.parse(fetch(location, {\\\\n    headers: {\\\\n        \\\\\\\"user-agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Linux; Android 10; M2007J3SC Build/QKQ1.200419.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.101 Mobile Safari/537.36\\\\\\\",\\\\n        \\\\\\\"cookie\\\\\\\": ck\\\\n    },\\\\n    method: 'GET',\\\\n    onlyHeaders: true,\\\\n    redirect: false\\\\n})).headers.location[0].split(\\\\\\\"?\\\\\\\")[1].split(\\\\\\\"&\\\\\\\");\\\\nputVar(\\\\\\\"mykey\\\\\\\",info[0].split(\\\\\\\"=\\\\\\\")[1]);\\\\nputVar(\\\\\\\"mymid\\\\\\\",info[1].split(\\\\\\\"=\\\\\\\")[1]);\\\\n    d.push({\\\\n        title: info[0],\\\\n        col_type: 'rich_text'\\\\n    });\\\\n    d.push({\\\\n        title: info[1],\\\\n        col_type: 'rich_text'\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"““大会员点我””\\\\\\\",\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n        url: $(\\\\\\\"不是大会员别点确认，否则后果自负\\\\\\\").confirm(() => {\\\\n            writeFile(\\\\\\\"hiker://files/rules/bili/access_key.txt\\\\\\\",getVar(\\\\\\\"mykey\\\\\\\"));\\\\n            writeFile(\\\\\\\"hiker://files/rules/bili/key.txt\\\\\\\",getVar(\\\\\\\"mykey\\\\\\\"));\\\\n            writeFile(\\\\\\\"hiker://files/rules/bili/starid.txt\\\\\\\",getVar(\\\\\\\"mymid\\\\\\\"));\\\\n            //refreshPage();\\\\n            return \\\\\\\"toast://大会员登录成功\\\\\\\"\\\\n        })\\\\n    });\\\\n    d.push({\\\\n        title: \\\\\\\"““无会员点我””\\\\\\\",\\\\n        col_type: \\\\\\\"text_2\\\\\\\",\\\\n        url: $(\\\\\\\"点击登录\\\\\\\").confirm(() => {\\\\n            writeFile(\\\\\\\"hiker://files/rules/bili/access_key.txt\\\\\\\",getVar(\\\\\\\"mykey\\\\\\\"));\\\\n            writeFile(\\\\\\\"hiker://files/rules/bili/starid.txt\\\\\\\",getVar(\\\\\\\"mymid\\\\\\\"));\\\\n            //refreshPage();\\\\n            return \\\\\\\"toast://登录成功\\\\\\\"\\\\n        })\\\\n    });\\\\n    \\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-直播\\\",\\\"path\\\":\\\"zb\\\",\\\"rule\\\":\\\"if (MY_URL.split('#')[1] == '1') {\\\\nvar zbc1 = 'all&2&3&6&1&5&9&10&11';\\\\nvar zbw1 = '全部&网游&手游&单机&娱乐&电台&虚拟主播&生活&学习';\\\\nvar zbc2 = '0&33';\\\\nvar zbw2 = '默认小分类&影音馆（生活）';\\\\nvar zbword1 = zbw1.split('&');\\\\nvar zbclass1 = zbc1.split('&');\\\\nvar zblab1 = getVar('zblab1', '全部');\\\\nvar zbkey1 = getVar('zbkey1', 'all');\\\\n\\\\nvar zbword2 = zbw2.split('&');\\\\nvar zbclass2 = zbc2.split('&');\\\\nvar zblab2 = getVar('zblab2', '默认小分类');\\\\nvar zbkey2 = getVar('zbkey2', '0');\\\\n\\\\n    /*for (var i in zbword1) {\\\\n        var a = zbword1[i];\\\\n        var b = zbclass1[i];\\\\n        var c = a + '&' + b;\\\\n        d.push({\\\\n            title: a == zblab1 ? getHead(a) : a,\\\\n            url: $(\\\\\\\"#noLoading#\\\\\\\").lazyRule((c) => {\\\\n                putVar(\\\\\\\"zblab1\\\\\\\", c.split('&')[0]);\\\\n                putVar(\\\\\\\"zbkey1\\\\\\\", c.split('&')[1]);\\\\n                refreshPage(false);\\\\n                return \\\\\\\"hiker://empty\\\\\\\"\\\\n            }, c),\\\\n            col_type: 'flex_button'\\\\n        });\\\\n    }*/\\\\n    d.push({\\\\n        title: '搜索',\\\\n        url: \\\\\\\"putVar('zbk',input);refreshPage();'toast://正在搜索';\\\\\\\",\\\\n        col_type: 'blank_block',\\\\n        desc: '你想看什么直播？'\\\\n    });\\\\n\\\\n    d.push({\\\\n        col_type: 'big_blank_block'\\\\n    });\\\\n\\\\n    for (var i in zbword1) {\\\\n        d.push({\\\\n            title: zbword1[i] == zblab1 ? getHead(zbword1[i]) : zbword1[i],\\\\n            url: $().lazyRule((name, key) => {\\\\n                putVar('zblab1', name);\\\\n                putVar('zbkey1', key);\\\\n                clearVar('zbk', input);\\\\n                refreshPage(true);\\\\n                return 'hiker://empty'\\\\n            }, zbword1[i], zbclass1[i]),\\\\n            col_type: 'scroll_button'\\\\n        });\\\\n    }\\\\n    d.push({\\\\n        col_type: 'blank_block'\\\\n    });\\\\n    for (var i in zbword2) {\\\\n        d.push({\\\\n            title: zbword2[i] == zblab2 ? getHead(zbword2[i]) : zbword2[i],\\\\n            url: $().lazyRule((name, key) => {\\\\n                putVar('zblab2', name);\\\\n                putVar('zbkey2', key);\\\\n                clearVar('zbk', input);\\\\n                refreshPage(true);\\\\n                return 'hiker://empty'\\\\n            }, zbword2[i], zbclass2[i]),\\\\n            col_type: 'scroll_button'\\\\n        });\\\\n    }\\\\n}\\\\nif (getVar('zbk') != '') {\\\\n    var zburl = \\\\\\\"https://search.bilibili.com/live?keyword=\\\\\\\" + getVar('zbk');\\\\n    log(zburl)\\\\n    var qz = \\\\\\\"https://search.bilibili.com\\\\\\\";\\\\n    var live = qz + parseDomForHtml(fetch(zburl, {\\\\n        headers: {\\\\n            \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": \\\\\\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\\\\\"\\\\n        }\\\\n    }), 'body&&.headline-live&&a&&href');\\\\n    log(\\\\\\\"123:::\\\\\\\" + live)\\\\n    d.push({\\\\n        title: '主播',\\\\n        url: \\\\\\\"hiker://page/zb2?url=\\\\\\\"+live.replace(\\\\\\\"?\\\\\\\",\\\\\\\"？？\\\\\\\").replace(\\\\\\\"&\\\\\\\",\\\\\\\"＆＆\\\\\\\") + '＆＆page=fypage',\\\\n        desc: '共有' + parseDomForHtml(fetch(zburl, {\\\\n            headers: {\\\\n                \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\\\\\",\\\\n                \\\\\\\"Cookie\\\\\\\": \\\\\\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\\\\\"\\\\n            }\\\\n        }), 'body&&.flow-loader&&.headline-live&&.num-txt&&span&&Text').replace(\\\\\\\"\\\\\\\\(\\\\\\\", \\\\\\\"\\\\\\\").replace(\\\\\\\"\\\\\\\\)\\\\\\\", \\\\\\\"\\\\\\\") + '主播',\\\\n        col_type: 'text_center_1'\\\\n    });\\\\n    try {\\\\n        d.push({\\\\n            title: '直播中',\\\\n            url: \\\\\\\"hiker://page/zb2?url=\\\\\\\"+live.replace(\\\\\\\"?\\\\\\\",\\\\\\\"？？\\\\\\\").replace(\\\\\\\"&\\\\\\\",\\\\\\\"＆＆\\\\\\\").replace(\\\\\\\"search_type=live_user\\\\\\\", \\\\\\\"\\\\\\\") + 'page=fypage',\\\\n            desc: '共有' + parseDomForHtml(fetch(zburl, {\\\\n                headers: {\\\\n                    \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\\\\\",\\\\n                    \\\\\\\"Cookie\\\\\\\": \\\\\\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\\\\\"\\\\n                }\\\\n            }), 'body&&.headline-room&&.num-txt&&span&&Text').replace(\\\\\\\"\\\\\\\\(\\\\\\\", \\\\\\\"\\\\\\\").replace(\\\\\\\"\\\\\\\\)\\\\\\\", \\\\\\\"\\\\\\\") + '直播间',\\\\n            col_type: 'text_center_1'\\\\n        });\\\\n    } catch (e) {}\\\\n} else {\\\\n    var page = MY_URL.split('#')[1];\\\\n    var url = \\\\\\\"https://api.live.bilibili.com/room/v3/area/getRoomList?platform=web&parent_area_id=\\\\\\\" + zbkey1 + \\\\\\\"&cate_id=0&area_id=\\\\\\\" + zbkey2 + \\\\\\\"&page=\\\\\\\" + page + \\\\\\\"&page_size=30&tag_version=1\\\\\\\";\\\\n    var json = JSON.parse(request(url));\\\\n    for (var i = 0; i < json.data.list.length; i++) {\\\\n        var r = {};\\\\n        var j = json.data.list[i];\\\\n        r.pic_url = j.system_cover + Referer;\\\\n        r.url = 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + j.roomid + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`;\\\\n        r.title = j.title;\\\\n        r.desc = 'UP🐷：' + j.uname;\\\\n        r.col_type = \\\\\\\"movie_2\\\\\\\";\\\\n        d.push(r);\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-直播\\\",\\\"path\\\":\\\"zb2\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar Referer = \\\\\\\"@Referer=https://www.bilibili.com\\\\\\\";\\\\nif (MY_URL.indexOf(\\\\\\\"search_type=live_user\\\\\\\") != -1) {\\\\n    var live = parseDomForArray(fetch(MY_URL, {\\\\n        headers: {\\\\n            \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": \\\\\\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\\\\\"\\\\n        }\\\\n    }), 'body&&.live-user-wrap&&li');\\\\n    for (var i in live) {\\\\n        d.push({\\\\n            title: parseDomForHtml(live[i], '.item-right&&P&&Text'),\\\\n            url: 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + parseDom(live[i], 'a&&href').split(\\\\\\\"live.bilibili.com/\\\\\\\")[1].split(\\\\\\\"?from\\\\\\\")[0] + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`,\\\\n            //img: parseDomForHtml(live[i], '.lazy-img&&img&&src') + Referer,\\\\n            desc: parseDomForHtml(live[i], '.item-right&&.status&&Text'),\\\\n            col_type: 'pic_1'\\\\n        });\\\\n    }\\\\n} else {\\\\n    var live = parseDomForArray(fetch(MY_URL, {\\\\n        headers: {\\\\n            \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": \\\\\\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\\\\\"\\\\n        }\\\\n    }), 'body&&.live-room-wrap&&li');\\\\n    for (var i in live) {\\\\n        d.push({\\\\n            title: parseDomForHtml(live[i], 'p&&Text'),\\\\n            url: 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + parseDom(live[i], 'a&&href').split(\\\\\\\"live.bilibili.com/\\\\\\\")[1].split(\\\\\\\"?from\\\\\\\")[0] + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`,\\\\n            //img: parseDom(live[i], '.lazy-img&&img&&src') + Referer,\\\\n            desc: 'UP🐷：' + parseDomForHtml(live[i], '.uname&&span&&Text') + '·人气' + parseDomForHtml(live[i], '.live-num&&span&&Text'),\\\\n            col_type: 'pic_1'\\\\n        });\\\\n    }\\\\n}\\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"API\\\",\\\"path\\\":\\\"api\\\",\\\"rule\\\":\\\"evalPrivateJS(\\\\\\\"F31g54pPpbN3pHPN9NT3D0zQvEjJXwRrfRiJmEBufUQA2HHWtQLRhAwqSMzMUdIARBMKBbPt28jB6tyuYxXOf3C7+VzPD3NJEeYy24OfTmSgsR4SHiPR3J0OifQMmTBLMtf1dX3k1y/8WuoXPMQnCXXDMQ97hwezot52IOyKsG64Oq5aGFN5diqT1tm29Sp/GrtVJX8fyjoNq4TrpfxiHsUW1SYs2hfcs3JjNkNOuQ2pWbP2spo9cUL6ZOhYvWyxBMEg2kPDET6vQuaFQnxRIpAulXJDMufAOvzmN5c0RUiOjpj54y8Sqe6g1/Fcm644WyPFMxW8b4DWfTiX9dDdIBdo2SLnD18oSuOC55weg8+XQSoqmey3Xt33u7S3aKriCUYO2HCwzKu2dfunpe0LOUlv/umd5pdxy/6UMKTHMCY=\\\\\\\")\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-一级（拓展）\\\",\\\"path\\\":\\\"newdetial\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\nvar Referer = '@Referer=http://www.bilibili.com';\\\\nif (!fetch('hiker://files/rules/bili/setting.txt')) {\\\\n    writeFile('hiker://files/rules/bili/setting.txt', '开启,关闭');\\\\n}\\\\nvar s_type = fetch('hiker://files/rules/bili/setting.txt');\\\\nputVar('reply_type', s_type.split(',')[0]);\\\\nputVar('like_type', s_type.split(',')[1]);\\\\n//颜色\\\\nvar Colors = [\\\\\\\"4\\\\\\\", \\\\\\\"5\\\\\\\", \\\\\\\"0\\\\\\\", \\\\\\\"1\\\\\\\", \\\\\\\"A\\\\\\\", \\\\\\\"3\\\\\\\", \\\\\\\"8\\\\\\\", \\\\\\\"9\\\\\\\", \\\\\\\"B\\\\\\\", \\\\\\\"C\\\\\\\", \\\\\\\"D\\\\\\\", \\\\\\\"E\\\\\\\", \\\\\\\"6\\\\\\\", \\\\\\\"7\\\\\\\", \\\\\\\"F\\\\\\\"];\\\\nvar Color = '#';\\\\nif (getVar('YS') == '随机') {\\\\n    for (var i = 0; i < 6; i++) {\\\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\\\n        var Color = Color + Colors[num];\\\\n    }\\\\n} else {\\\\n    var Color = \\\\\\\"#FA7298\\\\\\\";\\\\n}\\\\n\\\\nfunction getHead(title) {\\\\n    return '‘‘’’<strong><font color=\\\\\\\"' + Color + '\\\\\\\">' + title + '</front></strong>';\\\\n}\\\\nvar pagenum = MY_URL.split('#')[1];\\\\nvar rx = fetch('hiker://files/bili/多合一.txt', {});\\\\nvar wr = `@lazyRule=.js:writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\",input);refreshPage(false);\\\\\\\"toast://切换成功\\\\\\\"`;\\\\nvar s_tab = fetch('hiker://files/bili/收藏.txt', {});\\\\nvar sr = `@lazyRule=.js:writeFile(\\\\\\\"hiker://files/bili/收藏.txt\\\\\\\",input);refreshPage(false);\\\\\\\"toast://切换成功\\\\\\\"`;\\\\n\\\\nif (rx == '排行榜') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/phb\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == 'UP主') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/up\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '时光机') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/sgj\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '新番') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/newbgm\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '索引') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/sy\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '直播') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/zb\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '更多') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/more\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == \\\\\\\"漫游\\\\\\\") {\\\\n    evalPrivateJS(\\\\\\\"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\\\\\\\")\\\\n}\\\\nres.data = d;\\\\nsetResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-更多\\\",\\\"path\\\":\\\"more\\\",\\\"rule\\\":\\\"if (MY_URL.split('#')[1] == '1') {\\\\n    var _type = fetch('hiker://files/bili/样式.txt', {});\\\\n    d.push({\\\\n        title: rx == '漫游' ? getHead(rx) : '漫游',\\\\n        url: '漫游' + wr,\\\\n        col_type: 'text_2'\\\\n    });\\\\n    d.push({\\\\n        title: getVar('YS') == '随机' ? getHead('随机') : getHead('骚粉'),\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('YS', getVar('YS')=='随机'?'骚粉':'随机');refreshPage();'toast://颜色--'+getVar('YS','随机')\\\\\\\",\\\\n        col_type: 'text_2'\\\\n    });\\\\n    d.push({\\\\n        title: _type==\\\\\\\"新版\\\\\\\"?getHead(\\\\\\\"新版\\\\\\\"):\\\\\\\"新版\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','新版');refreshPage();'toast://切换成功'\\\\\\\",\\\\n        col_type: 'text_2'\\\\n    });\\\\n    d.push({\\\\n        title: _type==\\\\\\\"旧版\\\\\\\"?getHead(\\\\\\\"旧版\\\\\\\"):\\\\\\\"旧版\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','旧版');refreshPage();'toast://切换成功'\\\\\\\",\\\\n        col_type: 'text_2'\\\\n    });\\\\n    if (rx != '时光机' && rx != '索引') {\\\\n        d.push({\\\\n            title: '自定UID',\\\\n            url: `input://{\\\\\\\"value\\\\\\\":\\\\\\\"\\\\\\\", \\\\\\\"js\\\\\\\": \\\\\\\"writeFile('hiker://files/rules/bili/starid.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');clearVar('htm');refreshPage();'toast://你输入的是'+input\\\\\\\", \\\\\\\"hint\\\\\\\": \\\\\\\"请在下方输入UID\\\\\\\\n不知道怎么查？b站点开自己的信息，长按uid即可，请填入纯数字\\\\\\\"}`,\\\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/starid.txt')),\\\\n            col_type: 'text_1'\\\\n        });\\\\n        d.push({\\\\n            title: '点赞key',\\\\n            url: `input://{\\\\\\\"value\\\\\\\":\\\\\\\"\\\\\\\", \\\\\\\"js\\\\\\\": \\\\\\\"writeFile('hiker://files/rules/bili/access_key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\\\\\", \\\\\\\"hint\\\\\\\": \\\\\\\"请在下方输入key(用于点赞投币)\\\\\\\\n不知道怎么抓？那就算了\\\\\\\"}`,\\\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/access_key.txt')),\\\\n            col_type: 'text_1'\\\\n        });\\\\n        d.push({\\\\n            title: '解析key',\\\\n            url: `input://{\\\\\\\"value\\\\\\\":\\\\\\\"\\\\\\\", \\\\\\\"js\\\\\\\": \\\\\\\"writeFile('hiker://files/rules/bili/key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\\\\\", \\\\\\\"hint\\\\\\\": \\\\\\\"请在下方输入key(用于解析)\\\\\\\\n不知道怎么抓？那就算了\\\\\\\"}`,\\\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/key.txt')),\\\\n            col_type: 'text_1'\\\\n        });\\\\n        d.push({\\\\n            col_type: 'blank_block'\\\\n        });\\\\n\\\\n        d.push({\\\\n            title: '评论区: ““已' + getVar('reply_type'),\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('reply_type', getVar('reply_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('reply_type');\\\\\\\",\\\\n            col_type: 'text_2'\\\\n        });\\\\n        d.push({\\\\n            title: '点赞&投币: ““已' + getVar('like_type'),\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('like_type', getVar('like_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('like_type');\\\\\\\",\\\\n            col_type: 'text_2'\\\\n        });\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-一级2\\\",\\\"path\\\":\\\"common2\\\",\\\"rule\\\":\\\"var res = {};\\\\nvar d = [];\\\\nvar pagenum = MY_URL.split('#')[1];\\\\nvar Referer = '@Referer=http://www.bilibili.com';\\\\nif (!fetch('hiker://files/rules/bili/setting.txt')) {\\\\n    writeFile('hiker://files/rules/bili/setting.txt', '开启,关闭');\\\\n}\\\\nvar s_type = fetch('hiker://files/rules/bili/setting.txt');\\\\nputVar('reply_type', s_type.split(',')[0]);\\\\nputVar('like_type', s_type.split(',')[1]);\\\\n//颜色\\\\nvar Colors = [\\\\\\\"4\\\\\\\", \\\\\\\"5\\\\\\\", \\\\\\\"0\\\\\\\", \\\\\\\"1\\\\\\\", \\\\\\\"A\\\\\\\", \\\\\\\"3\\\\\\\", \\\\\\\"8\\\\\\\", \\\\\\\"9\\\\\\\", \\\\\\\"B\\\\\\\", \\\\\\\"C\\\\\\\", \\\\\\\"D\\\\\\\", \\\\\\\"E\\\\\\\", \\\\\\\"6\\\\\\\", \\\\\\\"7\\\\\\\", \\\\\\\"F\\\\\\\"];\\\\nvar Color = '#';\\\\nif (getVar('YS') == '随机') {\\\\n    for (var i = 0; i < 6; i++) {\\\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\\\n        var Color = Color + Colors[num];\\\\n    }\\\\n} else {\\\\n    var Color = \\\\\\\"#FA7298\\\\\\\";\\\\n}\\\\n\\\\nfunction getHead(title) {\\\\n    return '‘‘’’<strong><font color=\\\\\\\"' + Color + '\\\\\\\">' + title + '</front></strong>';\\\\n}\\\\n\\\\nvar c1 = 'all&bangumi&guochan&douga&music&knowledge&tech&car&life&food&kichiku&fashion&cinephile&origin&rookie&game&ent&dance&movie&tv&documentary&animal&guochuang';\\\\n\\\\nvar w1 = '全部&番剧&国创&动画&音乐&知识&科技&汽车&生活&美食&鬼畜&时尚&影视&原创&新人&游戏&娱乐&舞蹈&电影&电视剧&纪录片&动物圈&国创相关';\\\\n\\\\nvar c2 = '22&212&71&182&138&28&33&185';\\\\n\\\\nvar w2 = '鬼畜&美食&综艺&影视&生活&音乐&番剧&电视剧';\\\\n\\\\nvar word1 = w1.split('&');\\\\nvar class1 = c1.split('&');\\\\nvar lab1 = getVar('lab1', '全部');\\\\nvar key1 = getVar('key1', 'all');\\\\n\\\\nvar word2 = w2.split('&');\\\\nvar class2 = c2.split('&');\\\\nvar lab2 = getVar('lab2', '鬼畜');\\\\nvar key2 = getVar('key2', '22');\\\\n\\\\nvar zbc1 = 'all&2&3&6&1&5&9&10&11';\\\\nvar zbw1 = '全部&网游&手游&单机&娱乐&电台&虚拟主播&生活&学习';\\\\nvar zbc2 = '0&33';\\\\nvar zbw2 = '默认小分类&影音馆（生活）';\\\\nvar zbword1 = zbw1.split('&');\\\\nvar zbclass1 = zbc1.split('&');\\\\nvar zblab1 = getVar('zblab1', '全部');\\\\nvar zbkey1 = getVar('zbkey1', 'all');\\\\n\\\\nvar zbword2 = zbw2.split('&');\\\\nvar zbclass2 = zbc2.split('&');\\\\nvar zblab2 = getVar('zblab2', '默认小分类');\\\\nvar zbkey2 = getVar('zbkey2', '0');\\\\n\\\\n\\\\n\\\\n//三合一\\\\nvar rx = fetch('hiker://files/bili/多合一.txt', {});\\\\nvar wr = `@lazyRule=.js:writeFile(\\\\\\\"hiker://files/bili/多合一.txt\\\\\\\",input);refreshPage(false);\\\\\\\"toast://切换成功\\\\\\\"`;\\\\nvar s_tab = fetch('hiker://files/bili/收藏.txt', {});\\\\nvar sr = `@lazyRule=.js:writeFile(\\\\\\\"hiker://files/bili/收藏.txt\\\\\\\",input);refreshPage(false);\\\\\\\"toast://切换成功\\\\\\\"`;\\\\n\\\\nif (MY_URL.split('#')[1] == '1') {\\\\n    //.replace('m.bilibili.com', 'www.bilibili.com').replace(/\\\\\\\\?/g, '？？').replace(/\\\\\\\\&/g, '＆＆')\\\\n    d.push({\\\\n        title: '解析',\\\\n        url: \\\\\\\"'hiker://page/detail?url='+'https://'+input.split('https://')[1]+'#immersiveTheme#'\\\\\\\",\\\\n        col_type: 'input',\\\\n        desc: '请输入网址或者b站复制的链接'\\\\n    });\\\\n\\\\n    d.push({\\\\n        title: rx == 'UP主' ? getHead('首页') : '首页',\\\\n        url: 'UP主' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '排行榜' ? getHead(rx) : '排行榜',\\\\n        url: '排行榜' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '新番' ? getHead(rx) : '新番',\\\\n        url: '新番' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '直播' ? getHead(rx) : '直播',\\\\n        url: '直播' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '更多' ? getHead(rx) : '更多',\\\\n        url: '更多' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    /*\\\\n        if (rx == '收藏') {\\\\n            \\\\n            d.push({\\\\n                title: s_tab == '追番' ? getHead(s_tab) : '追番',\\\\n                url: '追番' + sr,\\\\n                col_type: 'text_3'\\\\n            });\\\\n            d.push({\\\\n                title: s_tab == '追剧' ? getHead(s_tab) : '追剧',\\\\n                url: '追剧' + sr,\\\\n                col_type: 'text_3'\\\\n            });\\\\n            \\\\n            if (s_tab == '追番') {\\\\n                eval(JSON.parse(fetch(\\\\\\\"hiker://page/fanju\\\\\\\")).rule)\\\\n            }\\\\n            if (s_tab == '追剧') {\\\\n                eval(JSON.parse(fetch(\\\\\\\"hiker://page/dsj\\\\\\\")).rule)\\\\n            }\\\\n        }\\\\n    */\\\\n}\\\\n\\\\nif (rx == '排行榜') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/phb\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == 'UP主') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/up\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '时光机') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/sgj\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '新番') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/newbgm\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '索引') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/sy\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '直播') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/zb\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == '更多') {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/more2\\\\\\\")).rule)\\\\n}\\\\n\\\\nif (rx == \\\\\\\"漫游\\\\\\\") {\\\\n    evalPrivateJS(\\\\\\\"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\\\\\\\")\\\\n}\\\\n//三合一\\\\n\\\\nres.data = d;\\\\nsetResult(res)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-更多2\\\",\\\"path\\\":\\\"more2\\\",\\\"rule\\\":\\\"if (MY_URL.split('#')[1] == '1') {\\\\n    var _type = fetch('hiker://files/bili/样式.txt', {});\\\\n    \\\\n    d.push({\\\\n        title: rx == '时光机' ? getHead(rx) : '时光🐥',\\\\n        url: '时光机' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    /*\\\\n        d.push({\\\\n            title: '追番',\\\\n            url: 'hiker://collection?group=①追番',\\\\n            col_type: 'text_4'\\\\n        });\\\\n    */\\\\n    d.push({\\\\n        title: rx == '索引' ? getHead(rx) : '索引',\\\\n        url: '索引' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    /*\\\\n        d.push({\\\\n            title: rx == '收藏' ? getHead(rx) : '收藏',\\\\n            url: '收藏' + wr,\\\\n            col_type: 'text_4'\\\\n        });\\\\n    */\\\\n    d.push({\\\\n        title: '登录',\\\\n        url: 'hiker://page/newlogin',\\\\n        col_type: 'text_5'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '漫游' ? getHead(rx) : '漫游',\\\\n        url: '漫游' + wr,\\\\n        col_type: 'text_5'\\\\n    });\\\\n    d.push({\\\\n        title: getVar('YS') == '随机' ? getHead('随机') : getHead('骚粉'),\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('YS', getVar('YS')=='随机'?'骚粉':'随机');refreshPage();'toast://颜色--'+getVar('YS','随机')\\\\\\\",\\\\n        col_type: 'text_5'\\\\n    });\\\\n    d.push({\\\\n        title: _type==\\\\\\\"新版\\\\\\\"?getHead(\\\\\\\"新版\\\\\\\"):\\\\\\\"新版\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','新版');refreshPage();'toast://切换成功'\\\\\\\",\\\\n        col_type: 'text_2'\\\\n    });\\\\n    d.push({\\\\n        title: _type==\\\\\\\"旧版\\\\\\\"?getHead(\\\\\\\"旧版\\\\\\\"):\\\\\\\"旧版\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','旧版');refreshPage();'toast://切换成功'\\\\\\\",\\\\n        col_type: 'text_2'\\\\n    });\\\\n    \\\\n    if (rx != '时光机' && rx != '索引') {\\\\n\\\\n        d.push({\\\\n            title: '自定UID',\\\\n            url: `input://{\\\\\\\"value\\\\\\\":\\\\\\\"\\\\\\\", \\\\\\\"js\\\\\\\": \\\\\\\"writeFile('hiker://files/rules/bili/starid.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');clearVar('htm');refreshPage();'toast://你输入的是'+input\\\\\\\", \\\\\\\"hint\\\\\\\": \\\\\\\"请在下方输入UID\\\\\\\\n不知道怎么查？b站点开自己的信息，长按uid即可，请填入纯数字\\\\\\\"}`,\\\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/starid.txt')),\\\\n            col_type: 'text_1'\\\\n        });\\\\n        d.push({\\\\n            title: '点赞key',\\\\n            url: `input://{\\\\\\\"value\\\\\\\":\\\\\\\"\\\\\\\", \\\\\\\"js\\\\\\\": \\\\\\\"writeFile('hiker://files/rules/bili/access_key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\\\\\", \\\\\\\"hint\\\\\\\": \\\\\\\"请在下方输入key(用于点赞投币)\\\\\\\\n不知道怎么抓？那就算了\\\\\\\"}`,\\\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/access_key.txt')),\\\\n            col_type: 'text_1'\\\\n        });\\\\n        d.push({\\\\n            title: '解析key',\\\\n            url: `input://{\\\\\\\"value\\\\\\\":\\\\\\\"\\\\\\\", \\\\\\\"js\\\\\\\": \\\\\\\"writeFile('hiker://files/rules/bili/key.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\\\\\", \\\\\\\"hint\\\\\\\": \\\\\\\"请在下方输入key(用于解析)\\\\\\\\n不知道怎么抓？那就算了\\\\\\\"}`,\\\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/key.txt')),\\\\n            col_type: 'text_1'\\\\n        });\\\\n        d.push({\\\\n            col_type: 'blank_block'\\\\n        });\\\\n\\\\n        d.push({\\\\n            title: '评论区: ““已' + getVar('reply_type'),\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('reply_type', getVar('reply_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('reply_type');\\\\\\\",\\\\n            col_type: 'text_2'\\\\n        });\\\\n        d.push({\\\\n            title: '点赞&投币: ““已' + getVar('like_type'),\\\\n            url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('like_type', getVar('like_type')=='关闭'?'开启':'关闭');refreshPage();writeFile('hiker://files/rules/bili/setting.txt',getVar('reply_type')+','+getVar('like_type'));'toast://已'+getVar('like_type');\\\\\\\",\\\\n            col_type: 'text_2'\\\\n        });\\\\n    }\\\\n}\\\"}]\"}","picUrl":"http://i1.hdslb.com/bfs/archive/7e574a8ff7018a834211ba767354740761e41f64.jpg@Referer=http://www.bilibili.com","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!