API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：解析

xiaomianao666
Dec 14th, 2021
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 349.06 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 = [];\\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\\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_4'\\n    });\\n    d.push({\\n        title: rx == '排行榜' ? getHead(rx) : '排行榜',\\n        url: '排行榜' + wr,\\n        col_type: 'text_4'\\n    });\\n    d.push({\\n        title: rx == '新番' ? getHead(rx) : '新番',\\n        url: '新番' + wr,\\n        col_type: 'text_4'\\n    });\\n    d.push({\\n        title: rx == '更多' ? getHead(rx) : '更多',\\n        url: '更多' + wr,\\n        col_type: 'text_4'\\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/more\\\")).rule)\\n}\\n\\n\\n//三合一\\n\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"pic_1_card\",\"name\":\"代码-排行榜\",\"path\":\"phb\",\"rule\":\"//分类\\n if (MY_URL.split('#')[1]=='1'){\\nfor (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:'flex_button'\\n    });\\n}\\n}\\n//分类\\n\\nd.push({\\n    desc:'258&&float',\\n   \\t\\tcol_type: 'x5_webview_single'\\n});\\nvar url = 'https://www.bilibili.com/v/popular/rank/all';\\n\\nvar MY_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/*\\nd.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:'card_pic_1'\\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\":\"//分类\\nif (MY_URL.split('#')[1]=='1'){\\n    eval(JSON.parse(fetch(\\\"hiker://page/more\\\")).rule)\\n\\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:'flex_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:'pic_1_card'\\n       });\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面-二级\",\"path\":\"detail\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\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        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';\\n\\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    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\\nevalPrivateJS(\\\"L7AvJ41C++kllBMPG9JRTUzQvEjJXwRrfRiJmEBufUTpLphwhl6m4qEfJGNFcTqvDNoTZi+XWz8Hxu7U2U57ssAoBMfo/eA68zuVDkX8/MVoplTzOqjUO6V5pELXYiFWXRxF2vo3V6q2DCNsXRQ0yz4vh1TqyLGmQaKZRFXpy5AQdKRPk/6Up9vs99bval4eTIYJqYYfYs+rPmxaH8mi324A8FZ7P6FJwe+QoA27YV+W093dHIU/8GhoU/W6kq0L+giDKA4XO3ACCEq9kiqWN/DD5YiuOIWBw1gozUgNKwWQTdFgLsMZNk/j3WA7hKoFg8SGDEztbBDhfgWwAbpQiVq/Kse1SehoCS7ym2M1EahJtxSbmLO4EgwwbM/gsNxClHrd7sp31W+4+mBN6wnpYKoraVlkST5iTSuLa273cM9NnmNffR29QGg+7xOW7nq8y0Jn5/bPL0BSZ5AtRqLrvrs6NX9QaXTiyYCQRU/GRkpso4d6HMvKMLWahxjOnFCRmuMB+kG5AX4RvcrqVxzNeAJuKC5nlEfXjDRXoE5lM8UKbKSuNdRjHTPDpiG08Vnrj4Mfq1aWoDsndPYUiIJ5OSp2ZZLO8+KYIVeGWyIVQa+dikrES7+anEUbOsLCxffdAeTKrcTW58U6ilaKpIGZmAJJI96qK9ZRsMyMuYZnQE5GpKex+2t4w9Y5qFdwiD1dL5aFoj6aefcZGGVw/Y9gU+YvlphbIRP6SEIslV9aH/qNLPrk60VfvLOlM55MvlMZtyNDJBfCVZYvSrAHYHx91V92hmOY+0QeVEUeALl+HAUJNu3WkcmF3OLXYoNMHwzW\\\")\\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: '网页',\\n                url: purl,\\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                d.push({\\n                    title: titles + badgeType,\\n                    img: pics + Referer,\\n                    desc: badge + desc,\\n                    url: mode == '直链' ? true_url : 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('萤火虫') : '萤火虫',\\n                url: 'yhc' + 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            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 : 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') === '开启'&&getVar('access_key')) {\\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\\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){\\nd.push({\\n    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:\\\"hiker://page/detail?rule=哔哩Ⓡ&url=https://api.bilibili.com/x/web-interface/view/detail？？aid=\\\"+x.param+\\\"＆＆bvid=\\\"+'#immersiveTheme#',\\n    col_type:'movie_2'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-更多\",\"path\":\"more\",\"rule\":\"if (MY_URL.split('#')[1]=='1') {\\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://collection?group=①追番',\\n        col_type: 'text_4'\\n    });\\n*/ \\nd.push({\\n        title: rx == '索引' ? getHead(rx) : '索引',\\n        url: '索引' + wr,\\n        col_type: 'text_4'\\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/pwd-login',\\n        col_type: 'text_4'\\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_4'\\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}\"},{\"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    eval(JSON.parse(fetch(\\\"hiker://page/more\\\")).rule)\\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);\"}],\"saved\":false,\"title\":\"哔哩Ⓡ\",\"version\":0,\"url\":\"https://m.bilibili.com/bangumi/play/ep433011#immersiveTheme#\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar res = {};\\nvar d = [];\\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        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';\\n\\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    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\\nevalPrivateJS(\\\"L7AvJ41C++kllBMPG9JRTUzQvEjJXwRrfRiJmEBufUTpLphwhl6m4qEfJGNFcTqvDNoTZi+XWz8Hxu7U2U57ssAoBMfo/eA68zuVDkX8/MVoplTzOqjUO6V5pELXYiFWXRxF2vo3V6q2DCNsXRQ0yz4vh1TqyLGmQaKZRFXpy5AQdKRPk/6Up9vs99bval4eTIYJqYYfYs+rPmxaH8mi324A8FZ7P6FJwe+QoA27YV+W093dHIU/8GhoU/W6kq0L+giDKA4XO3ACCEq9kiqWN/DD5YiuOIWBw1gozUgNKwWQTdFgLsMZNk/j3WA7hKoFg8SGDEztbBDhfgWwAbpQiVq/Kse1SehoCS7ym2M1EahJtxSbmLO4EgwwbM/gsNxClHrd7sp31W+4+mBN6wnpYKoraVlkST5iTSuLa273cM9NnmNffR29QGg+7xOW7nq8y0Jn5/bPL0BSZ5AtRqLrvrs6NX9QaXTiyYCQRU/GRkpso4d6HMvKMLWahxjOnFCRmuMB+kG5AX4RvcrqVxzNeAJuKC5nlEfXjDRXoE5lM8UKbKSuNdRjHTPDpiG08Vnrj4Mfq1aWoDsndPYUiIJ5OSp2ZZLO8+KYIVeGWyIVQa+dikrES7+anEUbOsLCxffdAeTKrcTW58U6ilaKpIGZmAJJI96qK9ZRsMyMuYZnQE5GpKex+2t4w9Y5qFdwiD1dL5aFoj6aefcZGGVw/Y9gU+YvlphbIRP6SEIslV9aH/qNLPrk60VfvLOlM55MvlMZtyNDJBfCVZYvSrAHYHx91V92hmOY+0QeVEUeALl+HAUJNu3WkcmF3OLXYoNMHwzW\\\")\\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: '网页',\\n                url: purl,\\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                d.push({\\n                    title: titles + badgeType,\\n                    img: pics + Referer,\\n                    desc: badge + desc,\\n                    url: mode == '直链' ? true_url : 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('萤火虫') : '萤火虫',\\n                url: 'yhc' + 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            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 : 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') === '开启'&&getVar('access_key')) {\\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\\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{\\n\\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的值填入上方'='后面即可\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-一级\\\",\\\"path\\\":\\\"common\\\",\\\"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\\\\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_4'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '排行榜' ? getHead(rx) : '排行榜',\\\\n        url: '排行榜' + wr,\\\\n        col_type: 'text_4'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '新番' ? getHead(rx) : '新番',\\\\n        url: '新番' + wr,\\\\n        col_type: 'text_4'\\\\n    });\\\\n    d.push({\\\\n        title: rx == '更多' ? getHead(rx) : '更多',\\\\n        url: '更多' + wr,\\\\n        col_type: 'text_4'\\\\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/more\\\\\\\")).rule)\\\\n}\\\\n\\\\n\\\\n//三合一\\\\n\\\\nres.data = d;\\\\nsetResult(res)\\\"},{\\\"col_type\\\":\\\"pic_1_card\\\",\\\"name\\\":\\\"代码-排行榜\\\",\\\"path\\\":\\\"phb\\\",\\\"rule\\\":\\\"//分类\\\\n if (MY_URL.split('#')[1]=='1'){\\\\nfor (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:'flex_button'\\\\n    });\\\\n}\\\\n}\\\\n//分类\\\\n\\\\nd.push({\\\\n    desc:'258&&float',\\\\n   \\\\t\\\\tcol_type: 'x5_webview_single'\\\\n});\\\\nvar url = 'https://www.bilibili.com/v/popular/rank/all';\\\\n\\\\nvar MY_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/*\\\\nd.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:'card_pic_1'\\\\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\\\":\\\"//分类\\\\nif (MY_URL.split('#')[1]=='1'){\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/more\\\\\\\")).rule)\\\\n\\\\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:'flex_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:'pic_1_card'\\\\n       });\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"页面-二级\\\",\\\"path\\\":\\\"detail\\\",\\\"rule\\\":\\\"js:\\\\nvar res = {};\\\\nvar d = [];\\\\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        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';\\\\n\\\\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    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\\\\nevalPrivateJS(\\\\\\\"L7AvJ41C++kllBMPG9JRTUzQvEjJXwRrfRiJmEBufUTpLphwhl6m4qEfJGNFcTqvDNoTZi+XWz8Hxu7U2U57ssAoBMfo/eA68zuVDkX8/MVoplTzOqjUO6V5pELXYiFWXRxF2vo3V6q2DCNsXRQ0yz4vh1TqyLGmQaKZRFXpy5AQdKRPk/6Up9vs99bval4eTIYJqYYfYs+rPmxaH8mi324A8FZ7P6FJwe+QoA27YV+W093dHIU/8GhoU/W6kq0L+giDKA4XO3ACCEq9kiqWN/DD5YiuOIWBw1gozUgNKwWQTdFgLsMZNk/j3WA7hKoFg8SGDEztbBDhfgWwAbpQiVq/Kse1SehoCS7ym2M1EahJtxSbmLO4EgwwbM/gsNxClHrd7sp31W+4+mBN6wnpYKoraVlkST5iTSuLa273cM9NnmNffR29QGg+7xOW7nq8y0Jn5/bPL0BSZ5AtRqLrvrs6NX9QaXTiyYCQRU/GRkpso4d6HMvKMLWahxjOnFCRmuMB+kG5AX4RvcrqVxzNeAJuKC5nlEfXjDRXoE5lM8UKbKSuNdRjHTPDpiG08Vnrj4Mfq1aWoDsndPYUiIJ5OSp2ZZLO8+KYIVeGWyIVQa+dikrES7+anEUbOsLCxffdAeTKrcTW58U6ilaKpIGZmAJJI96qK9ZRsMyMuYZnQE5GpKex+2t4w9Y5qFdwiD1dL5aFoj6aefcZGGVw/Y9gU+YvlphbIRP6SEIslV9aH/qNLPrk60VfvLOlM55MvlMZtyNDJBfCVZYvSrAHYHx91V92hmOY+0QeVEUeALl+HAUJNu3WkcmF3OLXYoNMHwzW\\\\\\\")\\\\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: '网页',\\\\n                url: purl,\\\\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(\\\\\\\"ifnzqaNqNRkN6NqG0fZx5Mey477OsMJOTbTd9SajMkfLK8tI1lZz+wif+9ZIAdT2NKXOxML34tPsJcbFgYq2IweqRWlctnnn46dJHGAoQ6S+TxsWJZ3ELbUAEf1Vv2xoMrkl3KoqWto1u7u9SUvNtj1uxC4enuZIE3IOVJYfulrSIuqnME8+hlV38BStZCkJf0iW3HdF2isBHExTZf4lpC2Kf4uAsPfRqU8N9jbP4+qzPrYrG+YaWt+inw9ZaGNa607FuvLgH+4vZbmf/tGnRzaQvf0rhvPnfBeEyaMAzmmvAMx4u0o42rxHmNKSx/2VZlIq+RqCZxJJ3bKcQH4+F/d0G5YmXyOPZRNYM7RoBz8zeQE/hqBrUbrSdb3Vw8SDsExU2hWOEr/052n74SEdWWdc37k9BLaVPJrdPFq3r+Zh8f6iWg6NXBrB+tUlGSVTjZfsLD2rBfpuPeQQWdAErQJhIFM95Pxh3S4BHtUodZ3F22mitLEf86IPo18yrgHMWVaQa4uQA4ZMDT1ahM85k6+7LTmPtz6ONAxvyIT75sCxSck0XsLlhG9gV8rU0flD3e+iWekjk1XyrmdcKfFHGyvIfqWD6zMRAdFIIyXxN3stbtNi3bQMUZgbYmmr3Qle0jAHoZRMHdl1BrS1sdmLepWxyHC8r6U35HmBQNHpdvzi77WGGr44Q4Mgv5RXbJ9eJOFGzlhrTsDQz3wASWzS7JxG8ck5fV0uTRcjgJPFCI86exD64T8tmskekWXMtZUjlNITP9ROPNKGnwzrhFV2RvVqNG0EFIsW1WubatasiJ6fXmBTF0gtMmBK1as3JHWRhKrgYgFASd+E4KUAuMPLtQb0ftlyQiATVsaRrFzbkpuYlMAs1P9ViUj/ExoXqAMaQ8ZJzotsPvjw+KPFMfnw8B9EQcvZ7cAoKKO6+nDSyHeM1ew/uoWH2XJNGL1PUc9s1TUbaKtUbS26hWNGMrGzG2u16oTlDfxzB7KLjmyIiChB746CO3TnZzXp4s+v1/rfgPYyASGjEjRN9qMaz7Il/mLPiEUDajrN+AU+6UZlSUKZaamzj/4tJtlmpA3i19D7Isw1kDzHwLsYfmHMSkkv/8DJpP2VDPG2FAoRZklRcc9eUdauyL+QhCRzRABqvpze2IYUTMMGkWmW2zUFrd7VSssry0jWVnP7CJ/71kgB1PY5Yo81qi8hXWFG/skVi1YTpc0V65UgZ6JLIB6Kp2Oos83ogiSFMDJisT2OEC6GUxhbVXbqiKUVjJcVn6/sQcTwy+32wKTzWV/03h2RoWdJ2nol0uCMGY9aDCPUbZWUeafLK8tI1lZz+wif+9ZIAdT2ALSZopivMM4HVNF3mY2XL1A3jesIAtxDR/vB8/AIl/WLrGLbkP2SJx8BKm1hSNogWyd4zZ1waJqpNcLb0lpftzj3Bw1kgyMYpS/nF5/4d52ZLkGGzaUMO3KxihPI0vV4/6VemfFOLwzXkRWrxRyhFxPMcsGA6eApHo1hc1k9m1V/CVuWWcygq+R1pz4aWoqJKptvTRugv14hwJT+7rwGWitOFVuK3N10arQKVZ6kT9UCvGK4GRkuZjl/dbJf4Axac8FfM+tO/oKNYB850h6gCbTmL3TW2EuFuSDoY5qkMy22i1u2eKOytR4SRLFL4Lv+pEqfHcsoLmj7/zIUqONCkphSFM6dfydCG9c4V5Asom8qOBouztgBzKUHT0o70bQ3UTit17BZoVcqcbeJeydvW3HCaVZy2whwwN3b16VHl//H4g0giKfF57hJe4ziSVnF2pWsGrR5dzrO0peqwAgZtoBDo/maLXhozmGfYAc7wzWmbXQeJv/QBrou27OKMFDAXP/cjyEEBgDHb1r1VXMCimU0ww2VX0Cj5XV+f0J5W57KUOSeCjbvr+VUxqo16xw9kr8tnQ2Qz5kMIwKkMIPiOJhJ2BAp+JaXlgMXIi6rzt7IcYdbyboc7EjdvM+sq0A5BgTLY6EC9BndHehhv0aj9uNzvojvkgt8d2+5xMYbdXBGXmdyth5pAyn8oLBCWUDbWe80/99et1iH/GDJEfoDLDf9p+k4+0QbuWdEquTO1jCJF51h7TxHl/UYa/mJwud0/Y8D4fEYZX/V3hGpOD9R2Zmjg4IrpPpwefj8w0wgcfyLz9ZMms1PoMn0qCnnM+Vu6n6sxClPb8yWxKkzMh0ewE4nJochWbDk5rcfrE02kykFXFtu+zj8HJgAHMbWVnjnyXI76UgqDRejAHyFmWmVK6WhGk7m6ZsJqjJi2E534eB0jAVYf6Jbs7hAqJPgEleOeAOU4zJMsAVrist63iRJMaEMTjO498+amMOr78WrKDzhw6RgB+O9UhLPK042YE7NfzjCb79987u9wQV4QcrhtlKOXcl8MbZtH0bmbNbAOuXuIF5drJUrjYSwVQBDAaUaLYezeSuvrQwFSCbweTUJGz1j7uBUq3maB4OfK2n7G2N1fCK1eEaw92UnlVDO0Tf1LII08HFtsRIn6Y1p3s9V+LJQ9iUd5ZG0LwU904E75PpuVLROBYHS4mrB3RvrMhAWC6jdtSTFklumv+c2EJRrbUrjr4A+Y40kANN1Ut1rdvMb/0pROJXVsDfc/AyM5n3CflvDVqSgPI9blHFe1mZ75CmILS6KzdF0Yl1MVHiPW0jvodnxKYTps8hJN+aI+h1WRGzrJKZJicAtNdsWVhLfrVxVEPSem9jGzsAaWPkVBGRO6jW2SW7m+bVDvRPbVpb6gSBI8oCUYOo7/Q0Habqm7RPMcsGA6eApHo1hc1k9m1Xw50IRvn7VyPJ+rDB1GadK9qo7IuDv1t/Wjz7dvp4d4RpuGvy4ZQk9PwV5tTtkX2DGAtQ8faivEIH70OhkpuCtnHkbozQC9BYLxUdfILvP8qE97rZYk+Xcqa7hvlBG6n3Jg56s4rqWeZNlB/cG55CStRPEI6RjrADpy/sYnQ4REN6UlAymSres2YXRLTaEcYWkJW982C/sfYsckbizlOsYsKAFp3XsgDQRDaao+yHNJApeVRK1m7h18q/KbQxFcpnDbGX2MRucU5PUPJpkyvClEvRK7k1x2n0zazAQ4gZfDwsM/invMQTKeQetzIr6/ZwTzHLBgOngKR6NYXNZPZtV/qHM5tYU1hwRSrd85KH2Mpdt7MPtWfq4NdOYWbNhPP8xlL6LgHAWlMyBDZsuGyHzE8xywYDp4CkejWFzWT2bVb2WHM1MVPeNP2JzWKnU0HQubao/41PqIh+CWBR3HUFYRxipEBQbKA/mApBN1pHCwBPMcsGA6eApHo1hc1k9m1UCR67hv59em4nVPZmjU5k1B9bIdzIl7WrJ1f/SUmwvq8jyMGm8TJXiKgFEy622enkTzHLBgOngKR6NYXNZPZtVCrlRngTEJBqV2iys6qyLTJ1Cpbn51cKte58eNKRklCDuXFc3GqlY0CeG6F3QMVuqBMEN9pXsmnwKxsE65/a+elqefLKyl7I+OZv+KBHnYX79WjBb32BGhGZnd1Qky2xHPvf4Sx+/tYN2zncmpQqSwxPMcsGA6eApHo1hc1k9m1VUuUGxROZS3KCE96naUF74mRmrdO/jptIHgMjC+G6V7BxZTJitNELst0FCJ+n+AMYTzHLBgOngKR6NYXNZPZtVBCS+LfYqrSBGHkeYlaqgbwIMxEd1OVPyJhuVxAUnDtrKW0Cnvup8zA3CU+iMTlTRf2NfJcxej8dijY5y3f1nRWREOpYmrYXztfsR8R+Y+TeYxAeuu7sgwuiTCGqxcxq8cXF2O+zlaXem5HwHNW9G//3enuk6MK2BttCQBHripYoGA1+vU+dJ/F+LR1iBLt4y/FsPxrJP1xvv00ZFkXgcyGEiauamGwYdln3/8+tFgXRI82r9gcsGXTygIOTF9yiF0goCh4NNyra5SPzSwgon3csn+NhAQRJvSFsLXLH8F/fCSCjwl/pi2GGY4nBUek3wK6cQGW6B+oO3jKSW9QEG0/OgHTbyxbR9EspolmNlB/GqSL4KOMYawNC0vgVZdJB5bHlutgjnTvv7oYyfea+mIO1jGbY+jU8VLx1YZSHENSTji274Qj2KOrFEzpXqiQ2JKZlmDhb9LJ8OxVLx8AHHcP6nyWOhiYcFuQMFwf9URIGHrzrjzppf7gsKnJltTbkll1lsfUHSd5ZSAF6QE3b8ob5x5HmZFUQRkU94PlCHtW5EFwwHqLws1w3GxzGMhtqfE8xywYDp4CkejWFzWT2bVeE7yM7Lxqw771/3nNb78Ovp4ubFciRv6BvXcV91X/wlAb66gDqyxm7C+jDl85PLJwdIRBkeq0UpmKRvljAGUIoLP0oCnjFxPVinqzmAmPylxRfovVZc5RTGczl8tiCIQFKe7hPnz8PUeTxL2GUS9753xP0ugbJNH0ktMFGqXLQrN20hyxjyFKNOy5GQL1dl32V96cjVQeul2k5XIROPaWxl60j5Xz6GPW0vsCIpK+xiyyvLSNZWc/sIn/vWSAHU9uSwBMvPxgj2TWOD91NZl5KoJc+zu3jpVQBEgyHGxti7Sz0OysUtZgLEIW9adSfyi2w/srmTm8H0M6KzGtnSc8a0VVwT2qQonngSR5K6QT2sEZJrBs5B8ZDBkjafQ4sRpREaONnIVwlD9Dpolu/QukTJGfeqmnvm5PfNxtNJFFNWPO9y5cgSuCvUP8+6AWaE5einOI7UAzld8HIS+LU07oLhDuVIasI7AgbfYcbv8yZByyvLSNZWc/sIn/vWSAHU9lsVVgOKaW4I7QAkaSOtdVPm6H6wvlyXECANvhCMGelFyyvLSNZWc/sIn/vWSAHU9t5XbqPfLG5AAUEvrchS4WZhclfN0Vq001EC/+UAXaGS5b0hkJVOUCtCwszVuyAeUMsry0jWVnP7CJ/71kgB1PbLK8tI1lZz+wif+9ZIAdT2pm9Kmm0/Nw+qp/2txpR8hsWpmYER2iter5mRM2p7kwzsxtWlKbxArUQfBDIGqWkFyyvLSNZWc/sIn/vWSAHU9nMyGLIHlB2QRIY6DtAg4lzLK8tI1lZz+wif+9ZIAdT2gDvl4JN/10iqNgZwADWuxTTN56l0xnwwld3n7FsBpcD+4l+waM8jumxBzwmf5+bcwuT40IQXwuxDQ62CUhcv7rcVG/Ibucxx68fiL9dPQHXZREhcdex1KMLc+g4I+jcxyyvLSNZWc/sIn/vWSAHU9gTtVOFF6kwanmsGSdH2iaGc1Yn5K7kH5VXD6ytgq6o3J1Qk6D7da8tdGRZyllqWDs6UMvsO/POw5Ccr79sJzidbk3542mjLRKtyiEeyv1ts6yaep+Cqq2uENopg0DzxTzqH1r83JyuvQs4sVXkr3CfLK8tI1lZz+wif+9ZIAdT2yAIuMwDxvIfUIG9OZuDsI9qAnBW1Fi0udfbT9hg6U4B4llRvuKyS7ZERzEbe/Jfv8gNEd8TSYB9+72vypil2rTb7y6WFlZQa0+fB44TE6qzxkxPoy1ocy/TLt68yMFn/ViW9D16QvR/r7uFbtsZOEQ7LvH0jLJtuj3FTyQZDQjBLKxsfv317J8qeVlld1T+fHhafVrUI/KArXgq2JdN0UCPy0dNrisysKOMuUMP4FpYlIlCxAt9QFaIaIoUtlAaiYCq3QnM+RYwh/6tJw3cSqhmHWk9rBaj71NkACUvOXr4DUX9AZW2m4koiXd1XJuE2Kx7zEjW0amgfzBZDJo/YKR+jSBvpI8ABY62JNNULa3mtqWDO1XgL2UlsdODJlIvTUq3z2lt+inukLllamZefB+Jvqsqv+NeYbOJxxGmtnP7q9pV0rRmf+1Ne+1O+R5UsraJKXPUyYRb0y7ooTkLG1h4hGAgEtRjTOktkXnF5BZTGM9RyQRuawc0bBOmtHX1hcT7rt3tDksXJfflPyysWzhPXLM+Fdx5dCYRyZzC/xiyZrd1RoPZ2u+0QtbsK2ugRpzQ469lndpJhrwaeyh+oHBS8Fyw+s/XB31MH9KJAo0JEAYZK2252iEYHgo3XuN1Z8b9I5booPzvL01Ii+kAahssry0jWVnP7CJ/71kgB1PajruqY/bL6v12002ma60SzZhTnyyQZdX9M52oCAkij2/YNu+HpX679dlZS+WahuQEjjv4/RMaJSfSKDDR6ylxNhMYwgkzFpWQTQ0GqLqfwLIIzVs2gR3NOOwsl9ykaCxifE45OSLQaY+sEB21LXKf2RWIqabKi7VlBWuVqzK/MxbCmjKPWKUFpJza80gMXUnF4Im3yqEft1rfsKU7Sg6e4hZqzRmbQYdvE7cezF+f8xcD6yRckxORdG6rPOBKiDMfg63eHvZiUjulPE5IvJDxoKBNXul0agOe2pIIScmsHKAgTFFjbtbCfe1Tj+ix2GUTNwrHUzqYJ3IqxyHtOar2HF1mL5K/upSY3zT0bKjcHwcsry0jWVnP7CJ/71kgB1PZPxd+zXBhIlh8pv4yUrXbMgosMNiYDBbUZmGvUVB9Y/Uq5QyYR8jBa3T6qqqd9PcDGjrTI6YbhEa4mtivVF1n1J9fUEcSHWvk8fpynw+BkYOezhIYwbhcXrKJN3Xj4XAA/jt6H3254Fc4mRou7dYlYyyvLSNZWc/sIn/vWSAHU9kKArUKVF2OmAEOtRPTLoUrLK8tI1lZz+wif+9ZIAdT2iVSn2X6OK90RfEqjkC/rISYz/7ucp6aM3T19cJpxErHLK8tI1lZz+wif+9ZIAdT2sMidsJ5/8+U+ZLXooktS7/Zna02fvAhJgn9gRjSzwC9dCByoUt9pYXPlNudf7h6Bpz6qwWvMGnr1fZYa07bfr8sry0jWVnP7CJ/71kgB1PajvuczrQQU0I2UAa8UJdPuMjBHzYmWOBmjl8Kh23+T6rlwWRVgF47HGywVnVzpGCbOlDL7DvzzsOQnK+/bCc4nJfjrgt6EnPjXZ/nCJMPvWM6UMvsO/POw5Ccr79sJzidwZ45CXNGx+S8ONRu0cQYyE9csz4V3Hl0JhHJnML/GLJmt3VGg9na77RC1uwra6BGnNDjr2Wd2kmGvBp7KH6gcwy7YmMHADksumN5HrjlV4Msry0jWVnP7CJ/71kgB1PZ96veFf5o06HlFhFkEbjVNaHhVWgH4fTMtkuz5bDn+AHgnjpwyG/hIL50GIPXo+vrYTAaByABQWo5P1pVuKDZc\\\\\\\")\\\\n\\\\n                d.push({\\\\n                    title: titles + badgeType,\\\\n                    img: pics + Referer,\\\\n                    desc: badge + desc,\\\\n                    url: mode == '直链' ? true_url : 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('萤火虫') : '萤火虫',\\\\n                url: 'yhc' + 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            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 : 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') === '开启'&&getVar('access_key')) {\\\\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\\\\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){\\\\nd.push({\\\\n    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:\\\\\\\"hiker://page/detail?rule=哔哩Ⓡ&url=https://api.bilibili.com/x/web-interface/view/detail？？aid=\\\\\\\"+x.param+\\\\\\\"＆＆bvid=\\\\\\\"+'#immersiveTheme#',\\\\n    col_type:'movie_2'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"代码-更多\\\",\\\"path\\\":\\\"more\\\",\\\"rule\\\":\\\"if (MY_URL.split('#')[1]=='1') {\\\\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://collection?group=①追番',\\\\n        col_type: 'text_4'\\\\n    });\\\\n*/ \\\\nd.push({\\\\n        title: rx == '索引' ? getHead(rx) : '索引',\\\\n        url: '索引' + wr,\\\\n        col_type: 'text_4'\\\\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/pwd-login',\\\\n        col_type: 'text_4'\\\\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_4'\\\\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}\\\"},{\\\"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    eval(JSON.parse(fetch(\\\\\\\"hiker://page/more\\\\\\\")).rule)\\\\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);\\\"}]\"}","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!