API tools faq
paste
xiaomianao666

小程序：哔哩Ⓡ

xiaomianao666
Aug 2nd, 2023
165
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 239.82 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@哔哩Ⓡ@{"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}","title":"哔哩Ⓡ","author":"1606142&Rx&Reborn","url":"hiker://empty#fypage","version":23031402,"col_type":"movie_1","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar _type = fetch('hiker://files/bili/样式.txt', {});\nif (_type == \"新版\") {\n    eval(JSON.parse(fetch(\"hiker://page/common\")).rule);\n} else if (_type == \"旧版\"){\n    eval(JSON.parse(fetch(\"hiker://page/common2\")).rule);\n}","search_url":"hiker://empty##fypage&keyword=**","group":"②爱优腾","searchFind":"js:\neval(JSON.parse(fetch(\"hiker://page/s\")).rule);","detail_col_type":"movie_2","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"js:\neval(JSON.parse(fetch(\"hiker://page/ycl\")).rule);","pages":"[{\"col_type\":\"movie_3\",\"name\":\"代码-①一级新页面\",\"path\":\"common\",\"rule\":\"var res = {};\\nvar d = [];\\nif (MY_URL.split('#')[1] == '1') {\\n    d.push({\\n        url: $(\\\"更多\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        //pic_url: 'https://img0.baidu.com/it/u=1612101423,1145982163&fm=253&app=138&f=JPEG?w=500&h=424',\\n        img:\\\"https://www.helloimg.com/images/2022/07/21/ZvYCES.png\\\",\\n        col_type: 'card_pic_1',\\n        desc:\\\"0\\\"\\n    });d.push({\\n        title: \\\"🔍\\\",\\n        url: \\\"'hiker://search?rule=\\\" + MY_RULE.title + \\\"&s='+input\\\",\\n        desc: \\\"搜你想看...\\\",\\n        col_type: \\\"input\\\"\\n    });\\n    d.push({\\n        title: '排行榜',\\n        url: $(\\\"排行榜\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://hikerfans.com/tubiao/q/50.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '直播',\\n        url: $(\\\"直播\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://hikerfans.com/tubiao/q/22.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '时光机',\\n        url: $(\\\"时光机\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://hikerfans.com/tubiao/q/56.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: 'UP',\\n        url: $(\\\"UP主\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://hikerfans.com/tubiao/q/98.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '索引',\\n        url: $(\\\"索引\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://hikerfans.com/tubiao/q/47.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '新番',\\n        url: $(\\\"新番\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://hikerfans.com/tubiao/q/23.png',\\n        col_type: 'icon_2'\\n    });\\n    d.push({\\n        title: '漫游',\\n        url: $(\\\"漫游\\\").lazyRule(() => {\\n            writeFile(\\\"hiker://files/bili/多合一.txt\\\", input);\\n            refreshPage(false);\\n            return \\\"hiker://page/newdetial?url=hiker://empty#fypage\\\";\\n        }, ),\\n        pic_url: 'https://hikerfans.com/tubiao/q/83.png',\\n        col_type: 'icon_2'\\n    });\\n\\n    d.push({\\n        title: '登录',\\n        url: 'hiker://page/newlogin',\\n        pic_url: 'https://hikerfans.com/tubiao/q/2.png',\\n        col_type: 'icon_2'\\n    });\\n}\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"pic_1_card\",\"name\":\"代码-②排行榜\",\"path\":\"phb\",\"rule\":\"//分类\\n\\nif (MY_URL.split('#')[1] == '1') {\\nvar c1 = 'all&bangumi&guochan&douga&music&knowledge&tech&car&life&food&kichiku&fashion&cinephile&origin&rookie&game&ent&dance&movie&tv&documentary&animal&guochuang';\\nvar w1 = '全部&番剧&国创&动画&音乐&知识&科技&汽车&生活&美食&鬼畜&时尚&影视&原创&新人&游戏&娱乐&舞蹈&电影&电视剧&纪录片&动物圈&国创相关';\\nvar word1 = w1.split('&');\\nvar class1 = c1.split('&');\\nvar lab1 = getVar('lab1', '全部');\\nvar key1 = getVar('key1', 'all');\\n\\n    for (var i in word1) {\\n        var a = word1[i];\\n        var b = class1[i];\\n        var c = a + '&' + b;\\n        d.push({\\n            title:  a == lab1 ? getHead(a) : a,\\n            url: $(\\\"#noLoading#\\\").lazyRule((c) => {\\n                putVar(\\\"lab1\\\", c.split('&')[0]);\\n                putVar(\\\"key1\\\", c.split('&')[1]);\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\"\\n            }, c),\\n            col_type: 'scroll_button'\\n        });\\n    }\\n}\\n//分类\\n//log(MY_PAGE)\\n\\nvar url = 'https://www.bilibili.com/v/popular/rank/all';\\n\\nMY_URL = url.replace('all', getVar('key1'));\\n\\nvar ym = request(MY_URL, {}).replace(/\\\\\\\\u002F/g, '/');\\nif (ym.includes('rank-tips')) {\\n\\n    /*提示信息\\n      d.push({\\n        title:'““'+parseDomForHtml(ym,'.rank-tips&&Text')+'””',\\n        col_type:'text_1'\\n      });\\n    提示信息*/\\n\\n    var pi = JSON.parse(ym.split('\\\"rankList\\\":')[1].split(',\\\"rankNote\\\"')[0]);\\n    for (var i = 0; pi != null && i < pi.length; i++) {\\n        var num = i + 1;\\n        var q = JSON.stringify(pi[i]);\\n        if (!pi[i].url) {\\n            var rurl = 'https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + pi[i].bvid;\\n        } else {\\n            var rurl = pi[i].url;\\n        }\\n        try {\\n            var des = 'up: ' + pi[i].owner.name;\\n        } catch (e) {\\n            var des = pi[i].new_ep.index_show;\\n        }\\n        d.push({\\n            title: pi[i].title,\\n            pic_url: pi[i].pic + Referer,\\n            //desc: (pi[i].new_ep.index_show ? pi[i].new_ep.index_show : ('up: ' + pi[i].owner.name)),\\n            desc:des,\\n            url: 'hiker://page/detail?url=' + rurl + '#immersiveTheme#',\\n            col_type: 'pic_1_card'\\n        });\\n        /*\\n        d.push({\\n                title:'No.'+num+'\\\\n\\\\n‘‘<small>'+pi[i].title+'\\\\n'+(!q.includes('name')?pi[i].new_ep.index_show:('up: '+pi[i].owner.name))+'</small>',\\n                pic_url:pi[i].pic+Referer,\\n                desc:'0',\\n                url:'hiker://page/detail?url='+rurl+'#immersiveTheme#',\\n                col_type:'pic_1_card'\\n              });\\n        */\\n    }\\n} else {\\n    d.push({\\n        title: '““节制一点，休息啦！””',\\n        col_type: 'text_center_1'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-②up🐷\",\"path\":\"up\",\"rule\":\"const headColor = \\\"#358ccd\\\";\\n\\n//时间戳转换方法\\n/*\\nfunction getLocalTime(nS) { \\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\n     var YMD = sss.split('日')[0].replace('年','-').replace('月','-');\\n     return (YMD)\\n}\\n*/\\nfunction getLocalTime(nS) {\\n    var date = new Date(nS);\\n    var YY = date.getFullYear() + '-';\\n    var MM = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';\\n    var DD = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate());\\n    var time = YY + MM + DD;\\n    return time\\n}\\nvar sr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/收藏.txt\\\",input);putVar('up','');putVar('UP','');putVar('set','');refreshPage(false);\\\"toast://切换成功\\\"`;\\n//时间戳转换\\n\\nvar uid = request(\\\"hiker://files/bili/up_cache.txt\\\", {});\\nif (MY_PAGE == 1) {\\n    putMyVar(\\\"param\\\", \\\"\\\");\\n}\\nvar UP_URL = 'hiker://empty/fypage##https://app.bilibili.com/x/v2/space/archive/cursor?aid=' + getMyVar(\\\"param\\\") + '&appkey=27eb53fc9058f8c3&vmid=uid';\\nvar up_url = UP_URL.split(\\\"##\\\")[1].replace(\\\"uid\\\", uid);\\nvar xx = getVar('lb2').split('\\\\n');\\n\\n//去除关注里的空白元素\\nvar xx = xx.filter(function(s) {\\n    return s && s.trim();\\n});\\n\\n//更新头像\\nfor (var k in xx) {\\n    if (!xx[k].split('##')[1]) {\\n        try {\\n            var pic = JSON.parse(request('https://api.bilibili.com/x/space/acc/info?mid=' + xx[k].split('&&')[1] + '&access_key=' + getVar(\\\"access_key\\\") ? getVar(\\\"access_key\\\") : \\\"d5af5513acb9294539ecdf7ffd55bf51\\\", {\\n                headers: {\\n                    \\\"user-agent\\\": getMyVar(\\\"UA\\\")\\n                }\\n            })).data.face;\\n        } catch (e) {\\n            var pic = JSON.parse(request('https://api.vc.bilibili.com/dynamic_svr/v1/dynamic_svr/space_history?host_uid=' + xx[k].split('&&')[1] + '&need_top=1', {\\n                headers: {\\n                    \\\"user-agent\\\": getMyVar(\\\"UA\\\")\\n                }\\n            })).data.cards[0].desc.user_profile.info.face;\\n        }\\n        var face = xx[k] + '##' + pic;\\n        var face = request(\\\"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 = request('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    try {\\n        let access_key = getVar(\\\"access_key\\\", \\\"\\\");\\n        let mid = getVar('starid');\\n        let ts = String(new Date().getTime()).slice(0, 10);\\n        let aaa = \\\"access_key=\\\" + access_key + \\\"&appkey=4409e2ce8ffd12b8&build=5520400&mid=\\\" + mid + \\\"&mobi_app=android&platform=android&ts=\\\" + ts + \\\"&vmid=\\\" + mid;\\n        let bbb = \\\"59b43e04ad6965f34319062b478f83dd\\\";\\n        let sign = md5(aaa + bbb);\\n        let url = 'https://app.bilibili.com/x/v2/space?' + aaa + '&sign=' + sign;\\n        var starjson = JSON.parse(request(url, {\\n            headers: {\\n                \\\"User-Agent\\\": getMyVar(\\\"UA\\\")\\n            },\\n            method: \\\"GET\\\"\\n        }));\\n        d.push({\\n            title: (getVar('UP') == '关注' ? '☺️' : '') + starjson.data.card.name,\\n            pic_url: starjson.data.card.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    } catch (e) {\\n        d.push({\\n            title: (getVar('UP') == '关注' ? '☺️' : '') + \\\"我也不知道你是谁啊\\\",\\n            pic_url: \\\"\\\" + 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: 'text_2'\\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 = request(surl, {});\\n            var starlist = JSON.parse('{\\\"my' + code.split('{\\\"my')[1].split('}};')[0] + '}}');\\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&access_key=' + getVar(\\\"access_key\\\");\\n\\n                var yurl = 'hiker://empty/fypage##https://app.bilibili.com/x/v2/space/archive/cursor?aid=&appkey=27eb53fc9058f8c3&vmid=' + starls[x].mid;\\n\\n                urls.push({\\n                    url: yurl.split(\\\"##\\\")[1].replace(/fypage/g, '1'),\\n                    options: {\\n                        headers: {\\n                            \\\"User-Agent\\\": getMyVar(\\\"UA\\\")\\n                        }\\n                    }\\n                });\\n                yurl = yurl.replace(/\\\\&/g, \\\"＆＆\\\").replace(/\\\\?/g, \\\"？？\\\");\\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\\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(request('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(request('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);putMyVar(\\\"param\\\",\\\"\\\");\\\"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(request('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(request('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                url: $().lazyRule((mid, line) => {\\n                    var sc = line + '\\\\n';\\n                    var xr = getVar('lb2') + '\\\\n';\\n                    var xz = xr.replace(sc, '');\\n                    writeFile(\\\"hiker://files/rules/js/up.js\\\", xz);\\n                    putVar('lb2', request(\\\"hiker://files/rules/js/up.js\\\", {}));\\n                    if (getVar(\\\"access_key\\\")) {\\n                        let modify = JSON.parse(post(\\\"https://api.bilibili.com/x/relation/modify\\\", {\\n                            body: {\\n                                access_key: getVar(\\\"access_key\\\"),\\n                                fid: mid,\\n                                act: \\\"2\\\"\\n                            }\\n                        })).code;\\n                        if (modify == 0) {\\n                            refreshPage()\\n                            return \\\"toast://取关成功(本地&云端)\\\"\\n                        } else {\\n                            refreshPage()\\n                            return \\\"toast://本地取关成功，云端应该g了\\\"\\n                        }\\n                    }\\n                    putMyVar(\\\"param\\\", \\\"\\\");\\n                    refreshPage();\\n                    return 'toast://取关成功！铁子再见🦆'\\n                }, xx[k].split('&&')[1].split(\\\"##\\\")[0], xx[k]),\\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(request('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(request('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);putMyVar(\\\"param\\\",\\\"\\\");'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(request(\\\"hiker://page/feed\\\")).rule);\\n} else if (s_tab == '收藏') {\\n    if (MY_URL.split('#')[1] == '1') eval(JSON.parse(request(\\\"hiker://page/video\\\")).rule);\\n} else if (s_tab == '追剧') {\\n    eval(JSON.parse(request(\\\"hiker://page/dsj\\\")).rule)\\n} else if (s_tab == '追番') {\\n    eval(JSON.parse(request(\\\"hiker://page/fanju\\\")).rule)\\n} else if (getVar('UP') != '关注' && getVar('up') != '展开' && getVar('set') == '') {\\n    var json = {};\\n    eval('json=' + request(up_url, {}));\\n    for (var i = 0; i < json.data.item.length; i++) {\\n        var r = {};\\n        var j = json.data.item[i];\\n        var t = Number(j.ctime) * 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.cover.indexOf(':') != -1) ? j.cover : 'https:' + j.cover;\\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        putMyVar(\\\"param\\\", j.param)\\n        //log(j.param)\\n    }\\n} else if (getVar('UP') == '关注' && getVar('up') != '展开') {\\n    try {\\n\\n        if (getVar('htm') == '') {\\n            htm = [];\\n            var ym = batchFetch(urls).map(function(a) {\\n                var h = JSON.parse(a).data.item;\\n                htm = htm.concat(h);\\n            });\\n            htm = htm.sort(function(a, b) {\\n                return b.ctime - a.ctime;\\n            }).map(function(a) {\\n                a.ctime = getLocalTime(Number(a.ctime) * 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].ctime != htm[j].ctime) i++;\\n\\n                if (i + 1 == MY_URL.split('#')[1]) {\\n                    if (k == 0) {\\n                        var date = htm[j].ctime;\\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].cover.indexOf(':') != -1) ? htm[j].cover : ('https:' + htm[j].cover)) + Referer,\\n                        desc: 'UP:' + htm[j].author + '  时长：' + htm[j].length + '\\\\n播放量：' + play + '  发布日期：' + htm[j].ctime,\\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    } catch (e) {\\n        d.push({\\n            title: \\\"炸了（不用反馈，暂时不修）\\\",\\n            col_type: \\\"text_center_1\\\"\\n        })\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-②时光🐔\",\"path\":\"sgj\",\"rule\":\"//分类\\nvar pagenum = MY_URL.split('#')[1];\\nif (MY_URL.split('#')[1]=='1'){\\nvar c2 = '22&212&71&182&138&28&33&185';\\n\\nvar w2 = '鬼畜&美食&综艺&影视&生活&音乐&番剧&电视剧';\\n\\nvar word2 = w2.split('&');\\nvar class2 = c2.split('&');\\nvar lab2 = getVar('lab2', '鬼畜');\\nvar key2 = getVar('key2', '22');\\nfor (var i in word2){\\n    var a = word2[i];\\n    var b = class2[i];\\n    var c = a + '&' + b;\\n    d.push({\\n    title: a==lab2? getHead(a):a,\\n    url: $(\\\"#noLoading#\\\").lazyRule((c)=>{\\n        putVar(\\\"lab2\\\",c.split('&')[0]);\\n        putVar(\\\"key2\\\",c.split('&')[1]);\\n        refreshPage(false);\\n        return \\\"hiker://empty\\\"\\n    }, c),\\n    col_type:'scroll_button'\\n    });\\n}\\n}\\n//分类\\n\\nvar m = Number(fetch(\\\"hiker://files/bili/mouths.txt\\\",{}));\\nvar t = m<0?0:m;\\nvar num1 = Number(t)-12;\\nvar num2 = Number(t)+12;\\nvar num3 = Number(t)-1;\\nvar num4 = Number(t)+1;\\n//var timestamp = Date.parse(new Date());\\nvar timestamp = new Date().getTime();\\nvar stamp1 = timestamp - t*30*24*60*60*1000;\\nvar stamp2 = timestamp - (t+1)*30*24*60*60*1000;\\n/*\\nfunction getLocalTime(nS) { \\n     var sss = new Date(parseInt(nS)).toLocaleString().substr(0,17);\\n     var mm = sss.split('年')[1].split('月')[0];\\n     var dd = sss.split('月')[1].split('日')[0];\\n     var YY = sss.split('年')[0];\\n     var MM = (mm< 10 ? '0' + mm:mm);\\n     var DD = (dd< 10 ? '0' + dd:dd);\\n     return (YY+MM+DD)\\n}\\n*/\\nfunction getLocalTime(nS) { \\nvar date = new Date(nS);\\nvar YY = String(date.getFullYear()); \\nvar MM = String((date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1)); \\nvar DD = String((date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate())); \\nvar time = YY + MM + DD;\\nreturn time\\n}\\n//时间戳转换\\nvar time1 = getLocalTime(stamp1);\\nvar time2 = getLocalTime(stamp2);\\nvar SGJ_URL = 'https://s.search.bilibili.com/cate/search?main_ver=v3&search_type=video&view_type=hot_rank&order=click&copy_right=-1&cate_id=22&page='+pagenum+'&pagesize=10&time_from=time2&time_to=time1';\\nvar URL = SGJ_URL.replace('time1',time1).replace('time2',time2).replace('22',getVar('key2')!=''?getVar('key2'):'22');\\nvar json = JSON.parse(request(URL,{}));\\n\\nif (MY_URL.split('#')[1]=='1'){\\nd.push({\\n          title:'+1年',\\n          url:\\nnum1+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:'-1年',\\n          url:\\nnum2+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:'+1月',\\n          url:\\nnum3+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:'-1月',\\n          url:\\nnum4+`@lazyRule=.js:writeFile('hiker://files/bili/mouths.txt',input);refreshPage();'toast://切换成功 '`,\\n          col_type:'text_4'\\n       });\\nd.push({\\n          title:getHead(('当前时间线: '+time2+'~'+time1)),\\n          \\n          col_type:'text_center_1'\\n       });\\n/*\\nd.push({\\n          title: getLocalTime(timestamp). split('日')[0],\\n          \\n          col_type:'text_center_1'\\n       });\\n*/\\n}\\n/*\\nd.push({\\n          title: getLocalTime(sss),\\n          \\n          col_type:'text_center_1'\\n       });\\n*/\\nfor (var i in json.result)\\n{\\n var r = {};\\n var j = json.result[i];\\n if (j.play>10000)\\n    var play = (j.play/10000).toFixed(1)+'万';\\n else\\n    var play = j.play;\\n d.push({\\n          title:j.title,\\n          img:'https:'+j.pic+Referer,\\n          desc:'up🐷:'+j.author+'\\\\n播放量: '+play+'        发布日期: '+j.pubdate/*+'\\\\n描述:'+j.description*/,\\n          url:\\n'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + j.bvid+'#immersiveTheme#',\\n          col_type:'movie_2'\\n       });\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面-二级\",\"path\":\"detail\",\"rule\":\"js:evalPrivateJS(\\\"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\\\")\"},{\"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 = {};\\nvar d = [];\\nconst headColor = \\\"#358ccd\\\";\\nif (MY_PAGE == 1) {\\n    putMyVar(\\\"param2\\\", \\\"\\\");\\n}\\nvar Referer = '@Referer=http://www.bilibili.com';\\nvar json = {};\\neval('json=' + request(MY_URL.split(\\\"##\\\")[1].replace(\\\"aid=\\\",\\\"aid=\\\"+getMyVar(\\\"param2\\\")), {}));\\nfor (var i = 0; i < json.data.item.length; i++) {\\n    var r = {};\\n    var j = json.data.item[i];\\n    var t = Number(j.ctime) * 1000;\\n\\n    function 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    }\\n    var time = getLocalTime(t);\\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.cover.indexOf(':') != -1) ? j.cover : 'https:' + j.cover;\\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    putMyVar(\\\"param2\\\", j.param)\\n    //log(j.param)\\n}\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"movie_3\",\"name\":\"代码块-搜索一级\",\"path\":\"s\",\"rule\":\"var res = {};\\nvar d = [];\\nvar b = [];\\nvar Referer = '@Referer=http://www.bilibili.com';\\nvar keyword = MY_URL.split('&keyword=')[1];\\nvar page = MY_PAGE;\\n//var url = 'https://app.bilibili.com/x/v2/search/type?appkey=27eb53fc9058f8c3&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';\\nvar video_url = \\\"https://app.bilibili.com/x/v2/search?appkey=27eb53fc9058f8c3&build=6400300&keyword=\\\" + keyword + \\\"&pn=\\\" + page;\\nvar bangumi_url = \\\"https://app.bilibili.com/x/v2/search/type?appkey=27eb53fc9058f8c3&build=6400400&keyword=\\\" + keyword + \\\"&pn=\\\" + page + \\\"&type=7\\\";\\nvar live_url = \\\"https://app.bilibili.com/x/v2/search/live?appkey=27eb53fc9058f8c3&build=6400400&keyword=\\\" + keyword + \\\"&pn=\\\" + page + \\\"&type=4\\\";\\nvar user_url = \\\"https://app.bilibili.com/x/v2/search/type?appkey=27eb53fc9058f8c3&build=6400400&keyword=\\\" + keyword + \\\"&pn=\\\" + page + \\\"&type=2\\\";\\nvar yingshi_url = \\\"https://app.bilibili.com/x/v2/search/type?appkey=27eb53fc9058f8c3&build=6400400&keyword=\\\" + keyword + \\\"&pn=\\\" + page + \\\"&type=8\\\";\\nlet v_list = JSON.parse(request(video_url, {})).data.item;\\nlet b_list = JSON.parse(request(bangumi_url, {})).data.items;\\nlet l_list = JSON.parse(request(live_url, {})).data.live_room.items;\\nlet u_list = JSON.parse(request(user_url, {})).data.items;\\nlet y_list = JSON.parse(request(yingshi_url, {})).data.items;\\ntry {\\n    b_list.forEach((b) => {\\n        d.push({\\n            title: b.title,\\n            img: b.cover + Referer,\\n            content: b.styles + \\\"\\\\n\\\" + b.style,\\n            desc: b.badge,\\n            url: 'hiker://page/detail?url=' + b.uri + '#immersiveTheme#',\\n            col_type: 'movie_1_left_pic'\\n        });\\n    })\\n} catch (e) {}\\ntry {\\n    v_list.forEach((v) => {\\n        if (v.linktype == \\\"video\\\") {\\n            if (v.play > 10000)\\n                var play = (v.play / 10000).toFixed(1) + '万';\\n            else\\n                var play = v.play;\\n            d.push({\\n                title: v.title,\\n                img: v.cover + Referer,\\n                content: \\\"播放量: \\\" + play + \\\"  时长: \\\" + v.duration + \\\"\\\\n发布日期\\\" + v.show_card_desc_2 + \\\"\\\\nUP: \\\" + v.author,\\n                desc: \\\"视频\\\",\\n                url: 'hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=＆＆bvid=' + v.share.video.bvid + '#immersiveTheme#',\\n                col_type: 'movie_1_left_pic'\\n            });\\n        }\\n    })\\n} catch (e) {}\\ntry {\\n    u_list.forEach((u) => {\\n        if (u.fans > 10000)\\n            var fans = (u.fans / 10000).toFixed(1) + '万';\\n        else\\n            var fans = u.fans;\\n        d.push({\\n            title: u.title,\\n            img: u.cover + Referer,\\n            content: \\\"粉丝: \\\" + fans + \\\"  视频: \\\" + u.archives + \\\"  等级: LV\\\" + u.level,\\n            desc: \\\"UP主(\\\" + u.mid + \\\")\\\",\\n            url: 'hiker://page/ss?url=hiker://empty##fypage',\\n            col_type: 'movie_1_left_pic',\\n            extra: {\\n                mid: u.mid,\\n                name: u.title\\n            }\\n        });\\n    })\\n} catch (e) {}\\ntry {\\n    y_list.forEach((y) => {\\n        d.push({\\n            title: y.title,\\n            img: y.cover + Referer,\\n            content: y.styles + \\\"\\\\n\\\" + y.style,\\n            desc: y.badge,\\n            url: 'hiker://page/detail?url=' + y.uri + '#immersiveTheme#',\\n            col_type: 'movie_1_left_pic'\\n        });\\n    })\\n} catch (e) {}\\ntry {\\n    l_list.forEach((l) => {\\n        d.push({\\n            title: l.title,\\n            img: l.cover + Referer,\\n            content: l.name,\\n            desc: l.badge,\\n            url: $(\\\"\\\").lazyRule((id) => {\\n                try {\\n                    //蓝光\\n                    var baseurl = \\\"https://api.live.bilibili.com/xlive/app-room/v2/index/getRoomPlayInfo?access_key=\\\" + getVar(\\\"access_key\\\") + \\\"&qn=10000&room_id=\\\" + id + \\\"&platform=android&build=6400300&device_name=M2007J3SC&format=0,2&codec=0,1&http=1&c_locale=zh_CN&protocol=0,1\\\"\\n                    var codec = JSON.parse(request(baseurl)).data[\\\"playurl_info\\\"][\\\"playurl\\\"][\\\"stream\\\"][0][\\\"format\\\"][0][\\\"codec\\\"][0]\\n                    return codec.url_info[0].host + codec.base_url + codec.url_info[0].extra\\n                } catch (e) {\\n                    var burl = 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + id + '&platform=h5&otype=json&quality=0'\\n                    return JSON.parse(request(burl)).data.durl[0].url\\n                }\\n            }, l.roomid),\\n            col_type: \\\"movie_1_left_pic\\\"\\n        })\\n    })\\n} catch (e) {}\\nsetResult(d);\"},{\"col_type\":\"movie_1_vertical_pic\",\"name\":\"页面-搜索二级\",\"path\":\"ss\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nif (MY_PAGE == 1) {\\n    /*\\n    d.push({\\n    title:'““关注””',\\n    url:'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://年轻人，耗子尾汁'}`,\\n    col_type: 'text_center_1'\\n    });\\n    */\\n    putMyVar(\\\"param2\\\", \\\"\\\")\\n    d.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        url: $().lazyRule((mid, name) => {\\n            //var pic = JSON.parse(request('https://api.bilibili.com/x/space/acc/info?mid=' + mid + '&jsonp=jsonp&access_key=' + getVar(\\\"access_key\\\"), {})).data.face;\\n            let access_key = getVar(\\\"access_key\\\", \\\"\\\");\\n            let mymid = getVar('starid');\\n            let ts = String(new Date().getTime()).slice(0, 10);\\n            let aaa = \\\"access_key=\\\" + access_key + \\\"&appkey=4409e2ce8ffd12b8&build=5520400&mid=\\\" + mymid + \\\"&mobi_app=android&platform=android&ts=\\\" + ts + \\\"&vmid=\\\" + mymid;\\n            let bbb = \\\"59b43e04ad6965f34319062b478f83dd\\\";\\n            let sign = md5(aaa + bbb);\\n            let url = 'https://app.bilibili.com/x/v2/space?' + aaa + '&sign=' + sign;\\n            var pic = JSON.parse(request(url, {\\n                headers: {\\n                    \\\"User-Agent\\\": getMyVar(\\\"UA\\\")\\n                },\\n                method: \\\"GET\\\"\\n            })).data.card.face;\\n\\n            if (!getVar('lb2').includes(mid)) {\\n                var xr = getVar('lb2') + '\\\\n' + name + \\\"&&\\\" + mid + '##' + pic;\\n                writeFile(\\\"hiker://files/rules/js/up.js\\\", xr);\\n                putVar('lb2', fetch(\\\"hiker://files/rules/js/up.js\\\", {}));\\n                if (getVar(\\\"access_key\\\")) {\\n                    refreshPage()\\n                    return $(\\\"是否同步云端\\\\n(点击取消表示仅本地关注)\\\").confirm((mid) => {\\n                        let modify = JSON.parse(post(\\\"https://api.bilibili.com/x/relation/modify\\\", {\\n                            body: {\\n                                access_key: getVar(\\\"access_key\\\"),\\n                                fid: mid,\\n                                act: \\\"1\\\"\\n                            }\\n                        })).code;\\n                        if (modify == 0) {\\n                            return \\\"toast://关注成功(本地&云端)\\\"\\n                        } else {\\n                            return \\\"toast://本地关注成功，云端应该g了\\\"\\n                        }\\n                    }, mid)\\n                }\\n                refreshPage();\\n                return 'toast://关注成功(仅本地)'\\n            } else {\\n                var xx = getVar('lb2').split('\\\\n');\\n                //去除关注里的空白元素\\n                var xx = xx.filter(function(s) {\\n                    return s && s.trim();\\n                });\\n                for (var k in xx) {\\n                    if (xx[k].includes(mid)) {\\n                        var sc = xx[k] + '\\\\n';\\n                        var xr = getVar('lb2') + '\\\\n';\\n                        var xz = xr.replace(sc, '');\\n                        writeFile(\\\"hiker://files/rules/js/up.js\\\", xz);\\n                        putVar('lb2', fetch(\\\"hiker://files/rules/js/up.js\\\", {}));\\n                        if (getVar(\\\"access_key\\\")) {\\n                            let modify = JSON.parse(post(\\\"https://api.bilibili.com/x/relation/modify\\\", {\\n                                body: {\\n                                    access_key: getVar(\\\"access_key\\\"),\\n                                    fid: mid,\\n                                    act: \\\"2\\\"\\n                                }\\n                            })).code;\\n                            if (modify == 0) {\\n                                return \\\"toast://取关成功(本地&云端)\\\"\\n                            } else {\\n                                return \\\"toast://本地取关成功，云端应该g了\\\"\\n                            }\\n                        }\\n                        refreshPage();\\n                        return 'toast://取关成功！铁子再见🦆'\\n                    }\\n                }\\n                return \\\"toast://耗子尾汁\\\"\\n            }\\n        }, MY_PARAMS.mid, MY_PARAMS.name),\\n        col_type: 'text_center_1'\\n    });\\n}\\nlet url = \\\"https://app.bilibili.com/x/v2/space/archive/cursor?aid=\\\" + getMyVar(\\\"param2\\\") + \\\"&appkey=27eb53fc9058f8c3&vmid=\\\" + MY_PARAMS.mid;\\nvar json = JSON.parse(request(url));\\nfor (var i = 0; i < json.data.item.length; i++) {\\n    var r = {};\\n    var j = json.data.item[i];\\n    var t = Number(j.ctime) * 1000;\\n    //时间戳转换方法\\n    /*\\n    function 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    function 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    }\\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.cover.indexOf(':') != -1) ? j.cover : 'https:' + j.cover;\\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        r.title = j.title;\\n    r.desc = '时长：' + j.length + '  播放量：' + play + '  日期：' + time;\\n    if (j.length != \\\"00:00\\\") {\\n        d.push(r)\\n    };\\n    putMyVar(\\\"param2\\\", j.param)\\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\\nputMyVar(\\\"UA\\\", \\\"Mozilla/5.0 BiliDroid/6.40.0 (bbcallen@gmail.com) os/android model/M2007J3SC mobi_app/android build/6400300 channel/master innerVer/6400300 osVer/10 network/1\\\");\\n\\nputVar('access_key', fetch('hiker://files/rules/bili/access_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    } else {\\n        var pic = JSON.parse(fetch('https://api.bilibili.com/x/space/acc/info?mid=103256880&access_key=d5af5513acb9294539ecdf7ffd55bf51', {\\n            headers: {\\n                \\\"User-Agent\\\": getMyVar(\\\"UA\\\")\\n            }\\n        })).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*/\\n//通过搜索查看自己的uid，然后替换即可\\nif (!fetch('hiker://files/rules/bili/starid.txt', {})) {\\n    putVar('starid', '928123');\\n} else {\\n    putVar('starid', fetch('hiker://files/rules/bili/starid.txt', {}));\\n}\\n\\nif (!fetch('hiker://files/rules/bili/key.txt')) {\\n    putVar(\\\"key\\\", \\\"d5af5513acb9294539ecdf7ffd55bf51\\\")\\n} else {\\n    putVar(\\\"key\\\", fetch('hiker://files/rules/bili/key.txt'));\\n}\\n//自己去b站客户端首页抓包，找到app.bilibili.com开头的链接，然后把access_key的值填入上方'='后面即可\\nif (!fetch('hiker://files/bili/样式.txt', {})) {\\n    writeFile('hiker://files/bili/样式.txt', \\\"新版\\\");\\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';\\ntry {\\n    var url = \\\"https://app.bilibili.com/x/v2/feed/index?access_key=\\\" + getVar(\\\"access_key\\\") + \\\"&appkey=27eb53fc9058f8c3\\\";\\n    var list = JSON.parse(request(url, {\\n        headers: {\\n            \\\"app-key\\\": \\\"android\\\"\\n        }\\n    })).data.items;\\n    for (let x of list) {\\n        var url = x.goto == \\\"bangumi\\\" ? \\\"hiker://page/detail?url=\\\" + x.uri.split(\\\"?\\\")[0] + '#immersiveTheme#' : \\\"hiker://page/detail?url=https://api.bilibili.com/x/web-interface/view/detail？？aid=\\\" + x.param + \\\"＆＆bvid=\\\" + '#immersiveTheme#';\\n        d.push({\\n            title: x.goto == \\\"bangumi\\\" ? \\\"💰\\\" + x.title : x.title,\\n            desc: x.cover_left_1_content_description + \\\" \\\" + x.cover_left_2_content_description + \\\"  \\\" + x.cover_right_text,\\n            pic: x.cover + \\\"@Referer=https://www.bilibili.com/\\\",\\n            url: url,\\n            col_type: 'movie_2'\\n        });\\n    }\\n} catch (e) {\\n    d.push({\\n        title: \\\"看见我意味着你要重新登录了，靓仔\\\",\\n        col_type: \\\"text_center_1\\\"\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-②新番\",\"path\":\"newbgm\",\"rule\":\"if (MY_URL.split('#')[1]=='1') {\\n    let access_key = getVar(\\\"access_key\\\",\\\"\\\")\\n    let ts = new Date().getTime();\\n    let aaa = 'access_key=' +access_key + '&appkey=27eb53fc9058f8c3&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='+ts;\\n    let bbb = \\\"c2ed53a74eeefe3cf99fbd01d8c9c375\\\";\\n    let sign = md5(aaa + bbb);\\n    let url = 'https://api.bilibili.com/pgc/app/timeline?'+aaa+'&sign='+sign;\\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            let follow = (x.follow == '1' ? getHead('•已追番') : '');\\n            //log(type)\\n            d.push({\\n                title: x.title,\\n                desc: '‘‘' + type + '’’\\\\n' + x.pub_index + follow + '\\\\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//const { CategoriesHeader } = $.require(\\\"https://rx319.coding.net/p/bili/d/bili_R/git/raw/master/categories-header.js?download=false\\\")\\n\\n/**\\n * 获取分类数据源，可动态可静态，自己根据实际情况处理\\n * https://www.bilibili.com/anime/index/\\n */\\nlet mCategories = {}\\nlet catInVar = getVar(MY_RULE.url + \\\"#categories\\\", '')\\nif (getVar(MY_RULE.url + \\\"#categories\\\", '')) {\\n    mCategories = JSON.parse(catInVar)\\n} else {\\n    let catUrl = 'https://www.bilibili.com/anime/index/'\\n    let catSrc = request(catUrl)\\n    // log(catSrc)\\n    let catRegex = /window\\\\.__INITIAL_STATE__=(.*?);\\\\(function\\\\(\\\\)\\\\{/\\n    if (catRegex.test(catSrc)) {\\n        // log(RegExp.$1)\\n        let category = JSON.parse(RegExp.$1)\\n        let mFilters = category.filters;\\n        // log(mFilters)\\n        mFilters.map(filter => mCategories[filter.key] = filter.list)\\n        let orders = category.orders\\n        let mOrders = []\\n        orders.map(order => {\\n            let mOrder = {}\\n            mOrder.name = order.title\\n            mOrder.value = order.key\\n            mOrders.push(mOrder)\\n        })\\n        // log(mOrders)\\n        mCategories['order'] = mOrders\\n    }\\n    putVar(MY_RULE.url + \\\"#categories\\\", JSON.stringify(mCategories))\\n}\\nlet keys = Object.keys(mCategories)\\n// log(mCategories)\\n// log(keys)\\n/**\\n * 组合当前分类链接\\n */\\nlet true_url = getVar(MY_RULE.url, MY_URL)\\ntrue_url = 'https://api.bilibili.com/pgc/season/index/result?'\\nfor (let it of keys) {\\n    let cat_url = getVar(MY_RULE.url + \\\"#\\\" + it, it === 'orders' ? '3' : '-1')\\n    true_url += (cat_url ? '&' + it + '=' + cat_url : '')\\n}\\n// let page = 1\\nconst page = MY_URL.split('#')[1]\\nif(page==1){\\n    \\n}\\ntrue_url = true_url +\\n    '&st=1&sort=0&season_type=1&pagesize=20&type=1' +\\n    '&page=' + page\\n// log(true_url)\\n\\nconst empty = \\\"hiker://empty\\\"\\n\\nCategoriesHeader\\n    .setSubCategoriesItemKey('name', 'value')\\n    .get(d, mCategories, page)\\n/**\\n * 获取当前分类页面源码\\n */\\ntry {\\n    var sylist = JSON.parse(request(true_url, {})).data.list;\\n\\n    /**\\n     * 列表数据源\\n     */\\n    for (let data of sylist) {\\n        d.push({\\n            title: data.title /*+ '/' + data.index_show*/ ,\\n            desc: data.order,\\n            img: data.cover+Referer,\\n            url: 'hiker://page/detail?url=' + data.link + '#immersiveTheme#',\\n            col_type: 'movie_3'\\n        });\\n    }\\n} catch (e) {}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-③动态分类模块\",\"path\":\"categories-header\",\"rule\":\"js:\\n/**\\n * 使用说明：\\n * 1.提前建立好 分类所属类型和分类列表 的对应关系，即 get 函数中的 categories\\n * 2.设置子分类数据的 key，调用 setSubCategoriesItemKey(titleKey, urlKey)\\n * 3.然后调用 CategoriesHeader.get(layout, categories, page)\\n *\\n * 支持链式调用，一句话即可调用生成分类，即：\\n * CategoriesHeader\\n *    .setSubCategoriesItemKey(titleKey, urlKey)\\n *    .get(layout, categories, page)\\n *\\n * @type {{setSubCategoriesItemKey: CategoriesHeader.setSubCategoriesItemKey, get: CategoriesHeader.get, categoriesKey: {title: string, url: string}}}\\n */\\nlet CategoriesHeader = {\\n    categoriesKey: {\\n        sub_categories: '',\\n        title: '',\\n        url: '',\\n    },\\n    /**\\n     * 1.设置从分类列表中拿的子分类的数据 key，\\n     *   根据 key 拿到数据后，\\n     *   会自动赋值给 scroll_button 的 { title: item[titleKey], url: item[urlKey] }\\n     *\\n     * @param title_key title 的 key\\n     * @param url_key url 的 key\\n     */\\n    setSubCategoriesItemKey : (title_key, url_key) => {\\n        CategoriesHeader.categoriesKey.title = title_key\\n        CategoriesHeader.categoriesKey.url = url_key\\n        return CategoriesHeader;\\n    },\\n    setSubCategoriesKey: (sub_categories_key) => {\\n        CategoriesHeader.categoriesKey.sub_categories = sub_categories_key\\n        return CategoriesHeader;\\n    },\\n    /**\\n     * 2.获取分类头部\\n     *\\n     * @param layout 当前界面，即常用的 d.push 的 d\\n     * @param categories 分类所属类型和分类列表的对应关系表，\\n     *        如：\\n     *        {\\n     *           \\\"年份\\\": [{ \\\"name\\\": \\\"2021\\\", \\\"value\\\": \\\"2021\\\" }, { \\\"name\\\": \\\"2020\\\", \\\"value\\\": \\\"2020\\\" }...],\\n     *           \\\"排序\\\": [{ \\\"name\\\": \\\"热度\\\", \\\"value\\\": \\\"hot\\\" }, { \\\"name\\\": \\\"时间\\\", \\\"value\\\": \\\"time\\\" }...],\\n     *        }\\n     * @param page 页码\\n     * @param urlListener 额外处理 button 的 url，需要 return\\n     */\\n    get: (layout, categories, page, urlListener) => {\\n        // log(categories)\\n        // 分类所属类型的列表，如：[ \\\"年份\\\", \\\"排序\\\" ]\\n        let category_names = Object.keys(categories)\\n        let types = []\\n        // 根据对应关系表拿分类列表\\n        category_names.map(category_name => {\\n            // 这里会拿到 年份 排序... 其中一个\\n            types.push(categories[category_name]);\\n            // 这里下面对 types 的值进行处理\\n        })\\n        categories = types;\\n        let init_cate = []\\n\\n        for (let i = 0; i < 20; i++) {\\n            init_cate.push(\\\"0\\\")\\n        }\\n\\n        const cate_temp_json = getVar(MY_RULE.title, JSON.stringify(init_cate))\\n        const cate_temp = JSON.parse(cate_temp_json)\\n\\n        if (parseInt(page) === 1) {\\n            /**\\n             * 遍历第 index 层分类\\n             */\\n            categories.forEach((category, index) => {\\n                let sub_category_name = category_names[index]\\n                let sub_categories_key = CategoriesHeader.categoriesKey.sub_categories\\n                let sub_categories = sub_categories_key ? category[sub_categories_key] : category;\\n                // log(category)\\n                /**\\n                 * 在第 index 层分类中遍历该层所有子分类\\n                 */\\n                sub_categories.forEach((item, key) => {\\n                    let title = item[CategoriesHeader.categoriesKey.title]\\n                    let url = escape(item[CategoriesHeader.categoriesKey.url])\\n                    if (urlListener) url = urlListener.onDeal(item, sub_category_name, url)\\n                    layout.push({\\n                        title: key.toString() === cate_temp[index] ? '““””<b><span style=\\\"color: #098AC1\\\">' + title + '</span></b>' : title,\\n                        url: $(url).lazyRule((params) => {\\n                            params.cate_temp[params.index] = params.key.toString()\\n\\n                            putVar(MY_RULE.title, JSON.stringify(params.cate_temp))\\n                            putVar(MY_RULE.url + \\\"#\\\" + params.sub_category_name, input)\\n                            refreshPage(true)\\n                            return \\\"hiker://empty\\\"\\n                        }, {\\n                            cate_temp: cate_temp,\\n                            index: index,\\n                            key: key,\\n                            page: page,\\n                            sub_category_name: sub_category_name\\n                        }),\\n                        col_type: 'scroll_button',\\n                    })\\n                })\\n                layout.push({\\n                    col_type: \\\"blank_block\\\"\\n                });\\n            })\\n        }\\n    }\\n}\\n$.exports.CategoriesHeader=CategoriesHeader\"},{\"col_type\":\"movie_3\",\"name\":\"我的收藏-视频\",\"path\":\"video\",\"rule\":\"var ts = new Date().getTime();\\nvar video_url = 'https://api.bilibili.com/x/v3/fav/folder/space?access_key=' + getVar('access_key') + '&appkey=27eb53fc9058f8c3&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=27eb53fc9058f8c3＆＆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_3'\\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=27eb53fc9058f8c3&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=27eb53fc9058f8c3&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=27eb53fc9058f8c3&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_3'\\n    });\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"代码-③登录（废弃）\",\"path\":\"login\",\"rule\":\"evalPrivateJS('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')\\n\"},{\"col_type\":\"movie_3\",\"name\":\"页面-登录（废弃）\",\"path\":\"pwd-login\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar islogin = fetch('hiker://files/rules/bili/islogin.txt', {});\\nif (islogin === \\\"1\\\") {\\n    d.push({\\n        url: \\\"putVar('my_account',input);refreshPage();'toast://你的账号是' + input;\\\",\\n        col_type: 'input',\\n        title: '账号',\\n        extra: {\\n            onChange: \\\"putVar('my_account',input)\\\",\\n            type: 'textarea',\\n            height: 1,\\n            defaultValue: getVar('my_account')\\n        }\\n    });\\n\\n    d.push({\\n        url: \\\"putVar('my_password',input);refreshPage();'toast://你的密码是' + input\\\",\\n        col_type: 'input',\\n        title: '密码',\\n        extra: {\\n            onChange: \\\"putVar('my_password',input)\\\",\\n            type: 'textarea',\\n            height: 1,\\n            defaultValue: getVar('my_password')\\n        }\\n    })\\n    d.push({\\n        title: \\\"““大会员？(先点我)””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"不是大会员别点确认，否则后果自负\\\").confirm(() => {\\n            putVar(\\\"isvip\\\", \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了大会员。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n    d.push({\\n        title: \\\"““登录(再点我)””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认登录？\\\").confirm(() => {\\n            putVar(\\\"logining\\\", \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n    if (getVar(\\\"logining\\\") === \\\"1\\\") {\\n        if (getVar('my_account') != '' && getVar('my_password') != '') {\\n            // TODO 吐佬说这里可以改成 $.require 用法          \\n            evalPrivateJS(\\\"dtd1P3dTEITonsgrNFfoBigi5ljaz0PeGmbmMjjr9H5nfvsnBw7JFp37cn3egqu0y/0wTW2oU7qtMwQIAiLhESVKBlKkRvW0pnPDdHl7PGwwDT5GM1vBsogb7YDpwmwV8rttad0O5YJBvpjX29hUBpSsiao7l3UebzxNAWYij7YwHWht0jVbh5SL7PXVo149fPSTuxl8A+vLUWi+2WxGrOZ+QvtrYIn28BqS8PS7zf0R0yr9hXzjbMOOX2COdVYKPdbGsxzklV5X2LLmKbPgEfQElCgMZpYune0I8OyI55HLK8tI1lZz+wif+9ZIAdT2dTQvCBb+iHjpR6K0Mr0dfc/jrTd/+nmsmWrkjituq8x2h7U3bZmaxkqYrxSoprLiZvnBkSvEoIiqUUOKimCy01f3tRfSQBeR5lgT5A/xqgd28aEqssiPJrXXIGnYsy3MLZRhSLw5kdSU3Y+dyCa6ZcIDxlOGeSFLmI0OCFbpZe9bY7nKUOai3+THsaFiEEqpd/6nUQF4TZRBgVqjYEFwWJyKAK6DAqoRvB2T0if2wUvOlDL7DvzzsOQnK+/bCc4nyZxdDfQXN6RqB+i6NgTbCjNd4TFX5fWBvHa5pHrTSZAhTW9wFA5wsADB95y+Jx2X9Qk4GLCGstgGcmHm96ap1uWq+K8vGEZEbEjkU52tMS5zz6gm7YhXf8eBYBmEaiLuMeU75Ge2qS6uOoj22ITEUcsry0jWVnP7CJ/71kgB1PYZNynXLl1tfoDY3HZgPakf6D+ADzQYqxqRKZCtlNIya9k8C4H7fbhLDXdWA3oV5yUOgaSXK1OM40FxNyNXpA/ZKS6gY3B1/V2+zpz+Q7Cmue5+qaO0XrDP15hjS4bxnWrOlDL7DvzzsOQnK+/bCc4nXxekuoTVURY7eh+dIF4QOaXmbNjYNkiqnAd85FrXKXoegJZC85B4JVqOWcueipNaHy/dwAhKpnK/5JO7Z6ya2ls2/JvPOCP91e6g4HO+YqEpLqBjcHX9Xb7OnP5DsKa5nprbkIP2knDXXqtMYGRdcigeIRz+OHmnKLm/+WCPa0618EqvMsGg9fpvtUo2/tm0RzYYi8kuFGopTyoikDwi3csry0jWVnP7CJ/71kgB1Pa1ADkvivkncEhPWP4wXCaTwwpZ0G6+YTvyp68thFdAL5xx9+nUa5jWmJUyyQ+r1UsD5sMqinY5b/eDUnxRKKBTzpQy+w7887DkJyvv2wnOJydHPM2ah78eAttSahVCEb/l3Zqi2hFkiZJ8gxPC0PY7/qt2N0n8lHD8+72KTUDIquX565CIQncDW5KfXUZLOnZbs6RTqR00LuPHAxPIHhiabjkNvSVQOzv3awerameSO8sry0jWVnP7CJ/71kgB1PbZfAA+7g+YdTNpeu9LRRooiFwV/9cu5HpEgZ2X6waWdooY1g5pCXKpMu/d7c3hdQfLK8tI1lZz+wif+9ZIAdT2Y96skBtNlvNAx6IGpzKN8eN0OJCm2IqsJJnHXJd1fryCMmECFEeaVbpuKG3V09wAC7SYi7j/bCB+DC11BSaZv8B3pQ9ZaBHrAsg+dNR+0WMtZjK4QlfzsMtgGqdnl/D+\\\")\\n        }\\n    }\\n} else if (islogin === \\\"2\\\") {\\n    d.push({\\n        title: \\\"““已登录！””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认重新登录？(请不要尝试多次登录，否则账号异常)\\\").confirm(() => {\\n            putVar(\\\"islogin\\\", \\\"1\\\");\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n} else if (islogin === \\\"3\\\") {\\n    d.push({\\n        title: \\\"““你需要去客户端改下密码才能登录！！！””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认登录？(请不要尝试多次登录，否则账号异常)\\\").confirm(() => {\\n            putVar(\\\"islogin\\\", \\\"1\\\");\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n} else {\\n    d.push({\\n        title: \\\"““点击进入登录页面””\\\",\\n        col_type: \\\"text_center_1\\\",\\n        url: $(\\\"确认登录？(请不要尝试多次登录，否则账号异常)\\\").confirm(() => {\\n            putVar(\\\"islogin\\\", \\\"1\\\");\\n            writeFile('hiker://files/rules/bili/islogin.txt', \\\"1\\\");\\n            refreshPage();\\n            return \\\"toast://你选择了登录。祝好运(✪▽✪)\\\"\\n        })\\n    });\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"登录页面\",\"path\":\"newlogin\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nd.push({\\n    title: \\\"““方法一””\\\",\\n    url: 'hiker://empty@lazyRule=.js:putVar(\\\"l_id\\\",\\\"1\\\");refreshPage();\\\"toast://刷新成功\\\"',\\n    col_type: 'text_2'\\n});\\nd.push({\\n    title: \\\"““方法二””\\\",\\n    url: 'hiker://empty@lazyRule=.js:putVar(\\\"l_id\\\",\\\"2\\\");refreshPage();\\\"toast://刷新成功\\\"',\\n    col_type: 'text_2'\\n});\\n\\nif (getVar(\\\"l_id\\\") == \\\"1\\\") {\\n    writeFile(\\\"hiker://files/rules/bili/APP-KEY.txt\\\", \\\"iphone\\\");\\n    d.push({\\n        title: '操作指引 ①先点击下方第一步进去哔哩手机版网页登录账号 ②返回直接点第二步登录然后按提示登录 ““注:方法一不可用再采用方法二””',\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: \\\"““1. 点我去网页登录后自动获取cookie””\\\",\\n        url: \\\"hiker://page/ck\\\",\\n        col_type: 'text_center_1'\\n    });\\n    d.push({\\n        title: \\\"““2. 再点我登录””\\\",\\n        url: \\\"hiker://page/weblogin\\\",\\n        col_type: 'text_center_1'\\n    });\\n}\\nif (getVar(\\\"l_id\\\") == \\\"2\\\") {\\n    writeFile(\\\"hiker://files/rules/bili/APP-KEY.txt\\\", \\\"iphone\\\");\\n    d.push({\\n        title: \\\"操作指引 ①先点击下方第一步进去哔哩手机版网页登录账号 ②点击右下角设置→查看源码→原生界面 ③复制最上方输入框里的链接 ④返回首页把链接输入框内 ⑤点击第二步，按提示登录即可\\\",\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: '保存',\\n        url: \\\"var ck = 'SESSDATA'+input.split('SESSDATA')[1].split('sid')[0].replace('；；','; ');writeFile('hiker://files/rules/bili/bilick.txt',ck.replace('；；','; '));refreshPage();'toast://您的cookie是:'+ck\\\",\\n        col_type: 'input',\\n        desc: '请输入链接'\\n    });\\n    d.push({\\n        title: \\\"““1. 点我去网页登录后手动获取cookie””\\\",\\n        url: \\\"https://m.bilibili.com/\\\",\\n        col_type: 'text_center_1'\\n    });\\n    d.push({\\n        title: \\\"““2. 点我登录””\\\",\\n        url: \\\"hiker://page/weblogin\\\",\\n        col_type: 'text_center_1'\\n    });\\n}\\nres.data = d;\\nsetResult(res);\\n\"},{\"col_type\":\"movie_3\",\"name\":\"cookie获取（登录方式一）\",\"path\":\"ck\",\"rule\":\"js:\\nsetResult([{\\n    col_type: \\\"x5_webview_single\\\",\\n    url: \\\"https://m.bilibili.com/\\\",\\n    desc: \\\"float&&100%\\\",\\n    extra: {\\n        js: $.toString(() => {\\n            fba.log(document.cookie)\\n            fy_bridge_app.writeFile('hiker://files/rules/bili/bilick.txt', fy_bridge_app.getCookie('https://m.bilibili.com/'));\\n            alert(\\\"cookie获取完毕，请返回继续\\\")\\n        })\\n    }\\n}])\"},{\"col_type\":\"movie_3\",\"name\":\"页面-web登录（方式二）\",\"path\":\"weblogin\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar ck = fetch(\\\"hiker://files/rules/bili/bilick.txt\\\").replace(/；； /g,'; ');\\nlog(ck)\\nvar login_url = \\\"https://passport.bilibili.com/login/app/third?appkey=27eb53fc9058f8c3&api=http%3A%2F%2Flink.acg.tv%2Fforum.php&sign=67ec798004373253d60114caaad89a8c\\\";\\nvar location = JSON.parse(fetch(login_url, {\\n    headers: {\\n        \\\"user-agent\\\": \\\"Mozilla/5.0 (Linux; Android 10; M2007J3SC Build/QKQ1.200419.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.101 Mobile Safari/537.36\\\",\\n        \\\"cookie\\\": ck\\n    },\\n    method: 'GET'\\n})).data['confirm_uri'];\\n//log(location);\\n\\nvar info = JSON.parse(fetch(location, {\\n    headers: {\\n        \\\"user-agent\\\": \\\"Mozilla/5.0 (Linux; Android 10; M2007J3SC Build/QKQ1.200419.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/83.0.4103.101 Mobile Safari/537.36\\\",\\n        \\\"cookie\\\": ck\\n    },\\n    method: 'GET',\\n    onlyHeaders: true,\\n    redirect: false\\n})).headers.location[0].split(\\\"?\\\")[1].split(\\\"&\\\");\\nputVar(\\\"mykey\\\",info[0].split(\\\"=\\\")[1]);\\nputVar(\\\"mymid\\\",info[1].split(\\\"=\\\")[1]);\\n    d.push({\\n        title: info[0],\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: info[1],\\n        col_type: 'rich_text'\\n    });\\n    d.push({\\n        title: \\\"““大会员点我””\\\",\\n        col_type: \\\"text_2\\\",\\n        url: $(\\\"不是大会员别点确认，否则后果自负\\\").confirm(() => {\\n            writeFile(\\\"hiker://files/rules/bili/access_key.txt\\\",getVar(\\\"mykey\\\"));\\n            writeFile(\\\"hiker://files/rules/bili/key.txt\\\",getVar(\\\"mykey\\\"));\\n            writeFile(\\\"hiker://files/rules/bili/starid.txt\\\",getVar(\\\"mymid\\\"));\\n            //refreshPage();\\n            return \\\"toast://大会员登录成功\\\"\\n        })\\n    });\\n    d.push({\\n        title: \\\"““无会员点我””\\\",\\n        col_type: \\\"text_2\\\",\\n        url: $(\\\"点击登录\\\").confirm(() => {\\n            writeFile(\\\"hiker://files/rules/bili/access_key.txt\\\",getVar(\\\"mykey\\\"));\\n            writeFile(\\\"hiker://files/rules/bili/starid.txt\\\",getVar(\\\"mymid\\\"));\\n            //refreshPage();\\n            return \\\"toast://登录成功\\\"\\n        })\\n    });\\n    \\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"代码-②直播\",\"path\":\"zb\",\"rule\":\"if (MY_URL.split('#')[1] == '1') {\\nvar zbc1 = 'all&2&3&6&1&5&9&10&11';\\nvar zbw1 = '全部&网游&手游&单机&娱乐&电台&虚拟主播&生活&学习';\\nvar zbc2 = '0&33';\\nvar zbw2 = '默认小分类&影音馆（生活）';\\nvar zbword1 = zbw1.split('&');\\nvar zbclass1 = zbc1.split('&');\\nvar zblab1 = getVar('zblab1', '全部');\\nvar zbkey1 = getVar('zbkey1', 'all');\\n\\nvar zbword2 = zbw2.split('&');\\nvar zbclass2 = zbc2.split('&');\\nvar zblab2 = getVar('zblab2', '默认小分类');\\nvar zbkey2 = getVar('zbkey2', '0');\\n\\n    /*for (var i in zbword1) {\\n        var a = zbword1[i];\\n        var b = zbclass1[i];\\n        var c = a + '&' + b;\\n        d.push({\\n            title: a == zblab1 ? getHead(a) : a,\\n            url: $(\\\"#noLoading#\\\").lazyRule((c) => {\\n                putVar(\\\"zblab1\\\", c.split('&')[0]);\\n                putVar(\\\"zbkey1\\\", c.split('&')[1]);\\n                refreshPage(false);\\n                return \\\"hiker://empty\\\"\\n            }, c),\\n            col_type: 'flex_button'\\n        });\\n    }*/\\n    d.push({\\n        title: '搜索',\\n        url: \\\"putVar('zbk',input);refreshPage();'toast://正在搜索';\\\",\\n        col_type: 'input',\\n        desc: '你想看什么直播？'\\n    });\\n\\n    d.push({\\n        col_type: 'big_blank_block'\\n    });\\n\\n    for (var i in zbword1) {\\n        d.push({\\n            title: zbword1[i] == zblab1 ? getHead(zbword1[i]) : zbword1[i],\\n            url: $().lazyRule((name, key) => {\\n                putVar('zblab1', name);\\n                putVar('zbkey1', key);\\n                clearVar('zbk', input);\\n                refreshPage(true);\\n                return 'hiker://empty'\\n            }, zbword1[i], zbclass1[i]),\\n            col_type: 'scroll_button'\\n        });\\n    }\\n    d.push({\\n        col_type: 'blank_block'\\n    });\\n    for (var i in zbword2) {\\n        d.push({\\n            title: zbword2[i] == zblab2 ? getHead(zbword2[i]) : zbword2[i],\\n            url: $().lazyRule((name, key) => {\\n                putVar('zblab2', name);\\n                putVar('zbkey2', key);\\n                clearVar('zbk', input);\\n                refreshPage(true);\\n                return 'hiker://empty'\\n            }, zbword2[i], zbclass2[i]),\\n            col_type: 'scroll_button'\\n        });\\n    }\\n}\\nif (getVar('zbk') != '') {\\n    var zburl = \\\"https://search.bilibili.com/live?keyword=\\\" + getVar('zbk');\\n    log(zburl)\\n    var qz = \\\"https://search.bilibili.com\\\";\\n    var live = qz + parseDomForHtml(fetch(zburl, {\\n        headers: {\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n            \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n        }\\n    }), 'body&&.headline-live&&a&&href');\\n    log(\\\"123:::\\\" + live)\\n    d.push({\\n        title: '主播',\\n        url: \\\"hiker://page/zb2?url=\\\"+live.replace(\\\"?\\\",\\\"？？\\\").replace(\\\"&\\\",\\\"＆＆\\\") + '＆＆page=fypage',\\n        desc: '共有' + parseDomForHtml(fetch(zburl, {\\n            headers: {\\n                \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n                \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n            }\\n        }), 'body&&.flow-loader&&.headline-live&&.num-txt&&span&&Text').replace(\\\"\\\\(\\\", \\\"\\\").replace(\\\"\\\\)\\\", \\\"\\\") + '主播',\\n        col_type: 'text_center_1'\\n    });\\n    try {\\n        d.push({\\n            title: '直播中',\\n            url: \\\"hiker://page/zb2?url=\\\"+live.replace(\\\"?\\\",\\\"？？\\\").replace(\\\"&\\\",\\\"＆＆\\\").replace(\\\"search_type=live_user\\\", \\\"\\\") + 'page=fypage',\\n            desc: '共有' + parseDomForHtml(fetch(zburl, {\\n                headers: {\\n                    \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n                    \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n                }\\n            }), 'body&&.headline-room&&.num-txt&&span&&Text').replace(\\\"\\\\(\\\", \\\"\\\").replace(\\\"\\\\)\\\", \\\"\\\") + '直播间',\\n            col_type: 'text_center_1'\\n        });\\n    } catch (e) {}\\n} else {\\n    var page = MY_URL.split('#')[1];\\n    var url = \\\"https://api.live.bilibili.com/room/v3/area/getRoomList?platform=web&parent_area_id=\\\" + zbkey1 + \\\"&cate_id=0&area_id=\\\" + zbkey2 + \\\"&page=\\\" + page + \\\"&page_size=30&tag_version=1\\\";\\n    var json = JSON.parse(request(url));\\n    for (var i = 0; i < json.data.list.length; i++) {\\n        var r = {};\\n        var j = json.data.list[i];\\n        r.pic_url = j.system_cover + Referer;\\n        r.url = 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + j.roomid + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`;\\n        r.title = j.title;\\n        r.desc = 'UP🐷：' + j.uname;\\n        r.col_type = \\\"movie_2\\\";\\n        d.push({\\n            title: j.title,\\n            desc: 'UP🐷：' + j.uname,\\n            col_type: \\\"movie_2\\\",\\n            pic_url: j.system_cover + Referer,\\n            url: $().lazyRule((id) => {\\n                try {\\n                    //蓝光\\n                    var baseurl = \\\"https://api.live.bilibili.com/xlive/app-room/v2/index/getRoomPlayInfo?access_key=\\\"+getVar(\\\"access_key\\\")+\\\"&appkey=27eb53fc9058f8c3&qn=10000&room_id=\\\" + id + \\\"&platform=android&build=6400300&device_name=M2007J3SC&format=0,2&codec=0,1&http=1&c_locale=zh_CN&protocol=0,1\\\"\\n                    var codec = JSON.parse(request(baseurl)).data[\\\"playurl_info\\\"][\\\"playurl\\\"][\\\"stream\\\"][0][\\\"format\\\"][0][\\\"codec\\\"][0]\\n                    return codec.url_info[0].host + codec.base_url + codec.url_info[0].extra\\n                } catch (e) {\\n                    var burl = 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + id + '&platform=h5&otype=json&quality=0'\\n                    return JSON.parse(request(burl)).data.durl[0].url\\n                }\\n            }, j.roomid)\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"页面-直播（搜索拓展）\",\"path\":\"zb2\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar Referer = \\\"@Referer=https://www.bilibili.com\\\";\\nif (MY_URL.indexOf(\\\"search_type=live_user\\\") != -1) {\\n    var live = parseDomForArray(fetch(MY_URL, {\\n        headers: {\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n            \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n        }\\n    }), 'body&&.live-user-wrap&&li');\\n    for (var i in live) {\\n        d.push({\\n            title: parseDomForHtml(live[i], '.item-right&&P&&Text'),\\n            //url: 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + parseDom(live[i], 'a&&href').split(\\\"live.bilibili.com/\\\")[1].split(\\\"?from\\\")[0] + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`,\\n            url:$().lazyRule((id) => {\\n                try {\\n                    //蓝光\\n                    var baseurl = \\\"https://api.live.bilibili.com/xlive/app-room/v2/index/getRoomPlayInfo?access_key=\\\"+getVar(\\\"access_key\\\")+\\\"&appkey=27eb53fc9058f8c3&qn=10000&room_id=\\\" + id + \\\"&platform=android&build=6400300&device_name=M2007J3SC&format=0,2&codec=0,1&http=1&c_locale=zh_CN&protocol=0,1\\\"\\n                    var codec = JSON.parse(request(baseurl)).data[\\\"playurl_info\\\"][\\\"playurl\\\"][\\\"stream\\\"][0][\\\"format\\\"][0][\\\"codec\\\"][0]\\n                    return codec.url_info[0].host + codec.base_url + codec.url_info[0].extra\\n                } catch (e) {\\n                    var burl = 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + id + '&platform=h5&otype=json&quality=0'\\n                    return JSON.parse(request(burl)).data.durl[0].url\\n                }\\n            }, parseDom(live[i], 'a&&href').split(\\\"live.bilibili.com/\\\")[1].split(\\\"?\\\")[0]),\\n            //img: parseDomForHtml(live[i], '.lazy-img&&img&&src') + Referer,\\n            desc: parseDomForHtml(live[i], '.item-right&&.status&&Text'),\\n            col_type: 'pic_1'\\n        });\\n    }\\n} else {\\n    var live = parseDomForArray(fetch(MY_URL, {\\n        headers: {\\n            \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.87 Safari/537.36\\\",\\n            \\\"Cookie\\\": \\\"_uuid=82467373-C6A1-57BA-AE02-A9A6D177C88797248infoc; buvid3=17C9A2CB-850B-4C73-B9DE-64DB0E6DBABB143105infoc; sid=cy961fq7; rpdid=|(u|JJ)|k~l|0J'uY|Y|ukum); LIVE_BUVID=AUTO8816061022193420; bsource=search_baidu; PVID=23; finger=1984989501; arrange=matrix\\\"\\n        }\\n    }), 'body&&.live-room-wrap&&li');\\n    for (var i in live) {\\n        d.push({\\n            title: parseDomForHtml(live[i], 'p&&Text'),\\n            //url: 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + parseDom(live[i], 'a&&href').split(\\\"live.bilibili.com/\\\")[1].split(\\\"?from\\\")[0] + '&platform=h5&otype=json&quality=0' + `@lazyRule=Text.js:JSON.parse(input).data.durl[0].url`,\\n            url:$().lazyRule((id) => {\\n                try {\\n                    //蓝光\\n                    var baseurl = \\\"https://api.live.bilibili.com/xlive/app-room/v2/index/getRoomPlayInfo?access_key=\\\"+getVar(\\\"access_key\\\")+\\\"&appkey=27eb53fc9058f8c3&qn=10000&room_id=\\\" + id + \\\"&platform=android&build=6400300&device_name=M2007J3SC&format=0,2&codec=0,1&http=1&c_locale=zh_CN&protocol=0,1\\\"\\n                    var codec = JSON.parse(request(baseurl)).data[\\\"playurl_info\\\"][\\\"playurl\\\"][\\\"stream\\\"][0][\\\"format\\\"][0][\\\"codec\\\"][0]\\n                    return codec.url_info[0].host + codec.base_url + codec.url_info[0].extra\\n                } catch (e) {\\n                    var burl = 'https://api.live.bilibili.com/xlive/web-room/v1/playUrl/playUrl?cid=' + id + '&platform=h5&otype=json&quality=0'\\n                    return JSON.parse(request(burl)).data.durl[0].url\\n                }\\n            }, parseDom(live[i], 'a&&href').split(\\\"live.bilibili.com/\\\")[1].split(\\\"?\\\")[0]),\\n            //img: parseDom(live[i], '.lazy-img&&img&&src') + Referer,\\n            desc: 'UP🐷：' + parseDomForHtml(live[i], '.uname&&span&&Text') + '·人气' + parseDomForHtml(live[i], '.live-num&&span&&Text'),\\n            col_type: 'pic_1'\\n        });\\n    }\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"API\",\"path\":\"api\",\"rule\":\"evalPrivateJS(\\\"L7AvJ41C++kllBMPG9JRTUzQvEjJXwRrfRiJmEBufUQA2HHWtQLRhAwqSMzMUdIArWuWFTN471Q7vukhXbPbeRwhdfiQM+fdtKG3NKhQzKdd7rSBwipY9t0mJ0qO9Dx3Mtf1dX3k1y/8WuoXPMQnCXXDMQ97hwezot52IOyKsG64Oq5aGFN5diqT1tm29Sp/GrtVJX8fyjoNq4TrpfxiHg8YHSBlAPDkElZj/tmj/aC7KRzIcnwtOoLjeB+Akiom/SZus/+1RrnYpymbtkJNrY72PzOtdYNL1jOoQ5/4YkT2ZYZplLmI0cVgW6KBSQjqJ1NIawQg0h4qRNW0aYMWDU3/FGjuc5DBSsh0W6mK8GE34SYlR4DgkmMRmyGvqyhcRyoFeDaHd7jIihdjcyVg4k/+dfqvw7frWZWuI1vc9YM=\\\")\"},{\"col_type\":\"movie_3\",\"name\":\"页面-一级新页面（拓展）\",\"path\":\"newdetial\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nvar Referer = '@Referer=http://www.bilibili.com';\\nif (!fetch('hiker://files/rules/bili/setting.txt')) {\\n    writeFile('hiker://files/rules/bili/setting.txt', '开启,关闭');\\n}\\nvar s_type = fetch('hiker://files/rules/bili/setting.txt');\\nputVar('reply_type', s_type.split(',')[0]);\\nputVar('like_type', s_type.split(',')[1]);\\n//颜色\\nvar Colors = [\\\"4\\\", \\\"5\\\", \\\"0\\\", \\\"1\\\", \\\"A\\\", \\\"3\\\", \\\"8\\\", \\\"9\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"E\\\", \\\"6\\\", \\\"7\\\", \\\"F\\\"];\\nvar Color = '#';\\nif (getVar('YS') == '随机') {\\n    for (var i = 0; i < 6; i++) {\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\n        var Color = Color + Colors[num];\\n    }\\n} else {\\n    var Color = \\\"#FA7298\\\";\\n}\\n\\nfunction getHead(title) {\\n    return '‘‘’’<strong><font color=\\\"' + Color + '\\\">' + title + '</front></strong>';\\n}\\nvar pagenum = MY_URL.split('#')[1];\\nvar rx = fetch('hiker://files/bili/多合一.txt', {});\\nvar wr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/多合一.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\nvar s_tab = fetch('hiker://files/bili/收藏.txt', {});\\nvar sr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/收藏.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\n\\nif (rx == '排行榜') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/phb\\\")).rule)\\n}\\n\\nif (rx == 'UP主') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/up\\\")).rule)\\n}\\n\\nif (rx == '时光机') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sgj\\\")).rule)\\n}\\n\\nif (rx == '新番') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/newbgm\\\")).rule)\\n}\\n\\nif (rx == '索引') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sy\\\")).rule)\\n}\\n\\nif (rx == '直播') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/zb\\\")).rule)\\n}\\n\\nif (rx == '更多') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/more\\\")).rule)\\n}\\n\\nif (rx == \\\"漫游\\\") {\\n    eval(JSON.parse(fetch(\\\"hiker://page/my\\\")).rule)\\n}\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"代码-④更多（新页面）\",\"path\":\"more\",\"rule\":\"if (MY_URL.split('#')[1] == '1') {\\n    var _type = fetch('hiker://files/bili/样式.txt', {});\\n    d.push({\\n        title: '解析',\\n        url: \\\"'hiker://page/detail?url='+'https://'+input.split('https://')[1]+'#immersiveTheme#'\\\",\\n        col_type: 'input',\\n        desc: '请输入网址或者b站复制的链接'\\n    });\\n    d.push({\\n        title: \\\"美食\\\",\\n        url: \\\"hiker://page/food\\\",\\n        col_type: 'text_2'\\n    });\\n    d.push({\\n        title: getVar('YS') == '随机' ? getHead('随机') : getHead('骚粉'),\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('YS', getVar('YS')=='随机'?'骚粉':'随机');refreshPage();'toast://颜色--'+getVar('YS','随机')\\\",\\n        col_type: 'text_2'\\n    });\\n    d.push({\\n        title: _type == \\\"新版\\\" ? getHead(\\\"新版\\\") : \\\"新版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','新版');refreshPage();back(true);'toast://切换成功';\\\",\\n        col_type: 'text_2'\\n    });\\n    d.push({\\n        title: _type == \\\"旧版\\\" ? getHead(\\\"旧版\\\") : \\\"旧版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','旧版');refreshPage();back(true);'toast://切换成功';\\\",\\n        col_type: 'text_2'\\n    });\\n    if (rx != '时光机' && rx != '索引') {\\n        d.push({\\n            title: '自定UID',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/starid.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');clearVar('htm');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入UID\\\\n不知道怎么查？b站点开自己的信息，长按uid即可，请填入纯数字\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/starid.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '点赞ck',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"refreshPage();'toast://这个不支持自定义啊，骚年'\\\", \\\"hint\\\": \\\"请在下方输入ck(用于点赞投币)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/bilick.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '解析ck',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/bilick2.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入ck(用于解析)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/bilick2.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '点赞key',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"refreshPage();'toast://这个不支持自定义啊，骚年'\\\", \\\"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            title: '复制点赞ck',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/bilick.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '复制解析ck',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/bilick2.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '复制点赞key',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/access_key.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '复制解析key',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/key.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            col_type: 'blank_block'\\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        d.push({\\n            title: \\\"使用帮助\\\",\\n            url: \\\"hiker://page/help\\\",\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: \\\"““一键重置\\\",\\n            url: $().lazyRule(() => {\\n                eval(JSON.parse(fetch(\\\"hiker://page/file\\\")).rule)\\n                let path = getPath('hiker://files/bili').slice(6);\\n                let filelist = getFilePath(path, \\\"file\\\", \\\"\\\");\\n                let path2 = getPath('hiker://files/rules/bili').slice(6);\\n                let filelist2 = getFilePath(path2, \\\"file\\\", \\\"\\\");\\n                //log(filelist);\\n                filelist.forEach((it) => {\\n                    //log(it.path)\\n                    deleteFile(it.path);\\n                })\\n                filelist2.forEach((it) => {\\n                    //log(it.path)\\n                    deleteFile(it.path);\\n                })\\n                deleteFile(\\\"/storage/emulated/0/Android/data/com.example.hikerview/files/Documents/rules/js/up.js\\\");\\n                back();\\n                return \\\"toast://重置完毕，请返回首页刷新\\\"\\n            }, ),\\n            col_type: 'text_2'\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-①一级旧页面\",\"path\":\"common2\",\"rule\":\"var res = {};\\nvar d = [];\\nvar pagenum = MY_URL.split('#')[1];\\nvar Referer = '@Referer=http://www.bilibili.com';\\nif (!fetch('hiker://files/rules/bili/setting.txt')) {\\n    writeFile('hiker://files/rules/bili/setting.txt', '开启,关闭');\\n}\\nvar s_type = fetch('hiker://files/rules/bili/setting.txt');\\nputVar('reply_type', s_type.split(',')[0]);\\nputVar('like_type', s_type.split(',')[1]);\\n//颜色\\nvar Colors = [\\\"4\\\", \\\"5\\\", \\\"0\\\", \\\"1\\\", \\\"A\\\", \\\"3\\\", \\\"8\\\", \\\"9\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"E\\\", \\\"6\\\", \\\"7\\\", \\\"F\\\"];\\nvar Color = '#';\\nif (getVar('YS') == '随机') {\\n    for (var i = 0; i < 6; i++) {\\n        var num = Math.ceil((Math.random() * 15)) - 1;\\n        var Color = Color + Colors[num];\\n    }\\n} else {\\n    var Color = \\\"#FA7298\\\";\\n}\\n\\nfunction getHead(title) {\\n    return '‘‘’’<strong><font color=\\\"' + Color + '\\\">' + title + '</front></strong>';\\n}\\n\\nvar c1 = 'all&bangumi&guochan&douga&music&knowledge&tech&car&life&food&kichiku&fashion&cinephile&origin&rookie&game&ent&dance&movie&tv&documentary&animal&guochuang';\\n\\nvar w1 = '全部&番剧&国创&动画&音乐&知识&科技&汽车&生活&美食&鬼畜&时尚&影视&原创&新人&游戏&娱乐&舞蹈&电影&电视剧&纪录片&动物圈&国创相关';\\n\\nvar c2 = '22&212&71&182&138&28&33&185';\\n\\nvar w2 = '鬼畜&美食&综艺&影视&生活&音乐&番剧&电视剧';\\n\\nvar word1 = w1.split('&');\\nvar class1 = c1.split('&');\\nvar lab1 = getVar('lab1', '全部');\\nvar key1 = getVar('key1', 'all');\\n\\nvar word2 = w2.split('&');\\nvar class2 = c2.split('&');\\nvar lab2 = getVar('lab2', '鬼畜');\\nvar key2 = getVar('key2', '22');\\n\\nvar zbc1 = 'all&2&3&6&1&5&9&10&11';\\nvar zbw1 = '全部&网游&手游&单机&娱乐&电台&虚拟主播&生活&学习';\\nvar zbc2 = '0&33';\\nvar zbw2 = '默认小分类&影音馆（生活）';\\nvar zbword1 = zbw1.split('&');\\nvar zbclass1 = zbc1.split('&');\\nvar zblab1 = getVar('zblab1', '全部');\\nvar zbkey1 = getVar('zbkey1', 'all');\\n\\nvar zbword2 = zbw2.split('&');\\nvar zbclass2 = zbc2.split('&');\\nvar zblab2 = getVar('zblab2', '默认小分类');\\nvar zbkey2 = getVar('zbkey2', '0');\\n\\n\\n\\n//三合一\\nvar rx = fetch('hiker://files/bili/多合一.txt', {});\\nvar wr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/多合一.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\nvar s_tab = fetch('hiker://files/bili/收藏.txt', {});\\nvar sr = `@lazyRule=.js:writeFile(\\\"hiker://files/bili/收藏.txt\\\",input);refreshPage(false);\\\"toast://切换成功\\\"`;\\n\\nif (MY_URL.split('#')[1] == '1') {\\n    //.replace('m.bilibili.com', 'www.bilibili.com').replace(/\\\\?/g, '？？').replace(/\\\\&/g, '＆＆')\\n    /*\\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: \\\"🔍\\\",\\n        url: \\\"'hiker://search?rule=\\\" + MY_RULE.title + \\\"&s='+input\\\",\\n        desc: \\\"搜你想看...\\\",\\n        col_type: \\\"input\\\"\\n    });\\n    d.push({\\n        title: rx == 'UP主' ? getHead('首页') : '首页',\\n        url: 'UP主' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '排行榜' ? getHead(rx) : '排行榜',\\n        url: '排行榜' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '新番' ? getHead(rx) : '新番',\\n        url: '新番' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '直播' ? getHead(rx) : '直播',\\n        url: '直播' + wr,\\n        col_type: 'text_5'\\n    });\\n    d.push({\\n        title: rx == '更多' ? getHead(rx) : '更多',\\n        url: '更多' + wr,\\n        col_type: 'text_5'\\n    });\\n    /*\\n        if (rx == '收藏') {\\n            \\n            d.push({\\n                title: s_tab == '追番' ? getHead(s_tab) : '追番',\\n                url: '追番' + sr,\\n                col_type: 'text_3'\\n            });\\n            d.push({\\n                title: s_tab == '追剧' ? getHead(s_tab) : '追剧',\\n                url: '追剧' + sr,\\n                col_type: 'text_3'\\n            });\\n            \\n            if (s_tab == '追番') {\\n                eval(JSON.parse(fetch(\\\"hiker://page/fanju\\\")).rule)\\n            }\\n            if (s_tab == '追剧') {\\n                eval(JSON.parse(fetch(\\\"hiker://page/dsj\\\")).rule)\\n            }\\n        }\\n    */\\n}\\n\\nif (rx == '排行榜') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/phb\\\")).rule)\\n}\\n\\nif (rx == 'UP主') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/up\\\")).rule)\\n}\\n\\nif (rx == '时光机') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sgj\\\")).rule)\\n}\\n\\nif (rx == '新番') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/newbgm\\\")).rule)\\n}\\n\\nif (rx == '索引') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/sy\\\")).rule)\\n}\\n\\nif (rx == '直播') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/zb\\\")).rule)\\n}\\n\\nif (rx == '更多') {\\n    eval(JSON.parse(fetch(\\\"hiker://page/more2\\\")).rule)\\n}\\n\\nif (rx == \\\"漫游\\\") {\\n    eval(JSON.parse(fetch(\\\"hiker://page/my\\\")).rule)\\n}\\n//三合一\\n\\nres.data = d;\\nsetResult(res)\"},{\"col_type\":\"movie_3\",\"name\":\"代码-④更多（旧页面）\",\"path\":\"more2\",\"rule\":\"if (MY_URL.split('#')[1] == '1') {\\n    var _type = fetch('hiker://files/bili/样式.txt', {});\\n    d.push({\\n        title: rx == '时光机' ? getHead(rx) : '时光🐥',\\n        url: '时光机' + wr,\\n        col_type: 'text_4'\\n    });\\n    d.push({\\n        title: rx == '索引' ? getHead(rx) : '索引',\\n        url: '索引' + wr,\\n        col_type: 'text_4'\\n    });\\n    d.push({\\n        title: '登录',\\n        url: 'hiker://page/newlogin',\\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: 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    d.push({\\n        title: \\\"美食\\\",\\n        url: \\\"hiker://page/food\\\",\\n        col_type: 'text_4'\\n    });\\n    d.push({\\n        title: _type == \\\"新版\\\" ? getHead(\\\"新版\\\") : \\\"新版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','新版');refreshPage();back(true);'toast://切换成功';\\\",\\n        col_type: 'text_4'\\n    });\\n    d.push({\\n        title: _type == \\\"旧版\\\" ? getHead(\\\"旧版\\\") : \\\"旧版\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:writeFile('hiker://files/bili/样式.txt','旧版');refreshPage();back(true);'toast://切换成功';\\\",\\n        col_type: 'text_4'\\n    });\\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    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: '点赞ck',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"refreshPage();'toast://这个不支持自定义啊，骚年'\\\", \\\"hint\\\": \\\"请在下方输入ck(用于点赞投币)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/bilick.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '解析ck',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"writeFile('hiker://files/rules/bili/bilick2.txt',input);writeFile('hiker://files/bili/多合一.txt','UP主');refreshPage();'toast://你输入的是'+input\\\", \\\"hint\\\": \\\"请在下方输入ck(用于解析)\\\\n不知道怎么抓？那就算了\\\"}`,\\n            desc: '‘‘已输入: ’’' + getHead(fetch('hiker://files/rules/bili/bilick2.txt')),\\n            col_type: 'text_1'\\n        });\\n        d.push({\\n            title: '点赞key',\\n            url: `input://{\\\"value\\\":\\\"\\\", \\\"js\\\": \\\"refreshPage();'toast://这个不支持自定义啊，骚年'\\\", \\\"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            title: '复制点赞ck',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/bilick.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '复制解析ck',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/bilick2.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '复制点赞key',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/access_key.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: '复制解析key',\\n            url: \\\"copy://\\\" + fetch('hiker://files/rules/bili/key.txt'),\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            col_type: 'blank_block'\\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        d.push({\\n            title: \\\"使用帮助\\\",\\n            url: \\\"hiker://page/help\\\",\\n            col_type: 'text_2'\\n        });\\n        d.push({\\n            title: \\\"““一键重置\\\",\\n            url: $().lazyRule(() => {\\n                eval(JSON.parse(fetch(\\\"hiker://page/file\\\")).rule)\\n                let path = getPath('hiker://files/bili').slice(6);\\n                let filelist = getFilePath(path, \\\"file\\\", \\\"\\\");\\n                let path2 = getPath('hiker://files/rules/bili').slice(6);\\n                let filelist2 = getFilePath(path2, \\\"file\\\", \\\"\\\");\\n                //log(filelist);\\n                filelist.forEach((it) => {\\n                    //log(it.path)\\n                    deleteFile(it.path);\\n                })\\n                filelist2.forEach((it) => {\\n                    //log(it.path)\\n                    deleteFile(it.path);\\n                })\\n                deleteFile(\\\"/storage/emulated/0/Android/data/com.example.hikerview/files/Documents/rules/js/up.js\\\");\\n                back();\\n                return \\\"toast://重置完毕，请返回首页刷新\\\"\\n            }, ),\\n            col_type: 'text_2'\\n        });\\n        /*\\n        d.push({\\n            title: \\\"““版本\\\"+getItem('Version','0'),\\n            url: $(\\\"是否更新依赖\\\").confirm(()=>{\\n                deleteCache();\\n                eval(fetch('https://rx319.coding.net/p/bili/d/bili_R/git/raw/master/version.js?download=false'))\\n                putVar('Version', '-V'+newVersion.ver);\\n                setItem('Version', '-V'+newVersion.ver);\\n                fetchCache('https://rx319.coding.net/p/bili/d/bili_R/git/raw/master/more.js?download=false', 24)\\n                refreshPage();\\n                log('版本'+getItem('Version')+'\\\\n'+newVersion.desc)\\n                return \\\"toast://更新成功，更新内容看log\\\"\\n            }),\\n            col_type: 'text_center_1'\\n        });\\n        */\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"代码-②漫游\",\"path\":\"my\",\"rule\":\"d.push({\\n        title: \\\"什么也没有诶\\\",\\n        url: \\\"toast://真的什么也没有\\\",\\n        col_type: \\\"text_center_1\\\"\\n    });\"},{\"col_type\":\"movie_3\",\"name\":\"页面-帮助\",\"path\":\"help\",\"rule\":\"js:\\nvar res = {};\\nvar d = [];\\nd.push({\\n    title: \\\"1.登录解锁完整功能<br>1.1登录问题汇总<br>登录方法有两种，一种自动获取cookie一种手动获取。都需要进行网页登录。<br>如果遇到无法获取验证码或者点击后没有反应的问题请禁用所有网页插件。<br>登录的时候不管是不是大会员请都选择“大会员点我”这一项。由于内置线路取消，所以不登录无法使用直链。直链解析取决于你的账号，大会员可以看会员视频，反之则不能。<br>2.如果遇见奇奇怪怪的问题，比如\\\\\\\"vlist\\\\\\\",\\\\\\\"0\\\\\\\",\\\\\\\"null\\\\\\\"什么的，请尝试“更多”里面的“一键重置”。一键重置会将小程序初始化，关注的up之类的也会重置。所以请谨慎使用。\\\",\\n    col_type: 'rich_text'\\n});\\nres.data = d;\\nsetResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"页面-美食\",\"path\":\"food\",\"rule\":\"js:\\nvar d = [];\\r\\nd.push({\\r\\n    col_type: \\\"x5_webview_single\\\",\\r\\n    url: \\\"https://cook.yunyoujun.cn/?www.hiquer.com\\\",\\r\\n    desc: \\\"float&&100%\\\",\\r\\n    extra: {\\r\\n        canBack: true,\\r\\n        urlInterceptor: $.toString((MY_RULE) => {\\r\\n            if (input.match(/video/)) {\\r\\n                return $.toString((url, MY_RULE) => {\\r\\n                    fba.log(MY_RULE.title)\\r\\n                    fba.open(JSON.stringify({\\r\\n                        rule: MY_RULE.title,\\r\\n                        title: \\\"\\\",\\r\\n                        group: \\\"\\\",\\r\\n                        preRule: \\\"\\\",\\r\\n                        url: \\\"hiker://page/detail?rule=\\\" + MY_RULE.title + \\\"&url=\\\" + url + '#immersiveTheme#',\\r\\n                    }));\\r\\n                }, input, MY_RULE)\\r\\n            }\\r\\n            // 拦截app下载页面——非网页代码\\r\\n            if (input.includes('download')) return true;\\r\\n        }, MY_RULE),\\r\\n        blockRules: [''],\\r\\n        ua: MOBILE_UA\\r\\n    }\\r\\n});\\r\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"文件操作\",\"path\":\"file\",\"rule\":\"const File = java.io.File;\\nconst {\\n    Files,\\n    Paths,\\n    StandardCopyOption,\\n    StandardOpenOption\\n} = java.nio.file;\\nconst javaString = java.lang.String;\\nlet javaScope = new JavaImporter(java.io, java.lang, java.lang.reflect, java.util.Vector);\\n\\nfunction deleteFlies(fileName) {\\n    let file = new File(fileName);\\n    if (!file.exists()) {\\n        //log(\\\"删除文件失败：\\\" + fileName + \\\"文件不存在\\\");\\n        return false;\\n    } else {\\n        if (file.isFile()) {\\n            return deleteFile(fileName);\\n        } else {\\n            return deleteDirectory(fileName);\\n        }\\n\\n    }\\n\\n}\\n/**\\n * 删除单个文件\\n * \\n * @param fileName\\n *            被删除文件的文件名\\n * @return 单个文件删除成功返回true,否则返回false\\n */\\nfunction deleteFile(fileName) {\\n    let file = new File(fileName);\\n    if (file.isFile() && file.exists()) {\\n        file.delete();\\n        //log(\\\"删除单个文件\\\" + fileName + \\\"成功！\\\");\\n        return true;\\n    } else {\\n        //log(\\\"删除单个文件\\\" + fileName + \\\"失败！\\\");\\n        return false;\\n    }\\n\\n}\\n/**\\n * 删除目录（文件夹）以及目录下的文件\\n * \\n * @param dir\\n *            被删除目录的文件路径\\n * @return 目录删除成功返回true,否则返回false\\n */\\nfunction deleteDirectory(dir) {\\n    // 如果dir不以文件分隔符结尾，自动添加文件分隔符\\n    if (!dir.endsWith(File.separator)) {\\n        dir = dir + File.separator;\\n    }\\n    let dirFile = new File(dir);\\n    // 如果dir对应的文件不存在，或者不是一个目录，则退出\\n    if (!dirFile.exists() || !dirFile.isDirectory()) {\\n        //log(\\\"删除目录失败\\\" + dir + \\\"目录不存在！\\\");\\n        return false;\\n    }\\n    let flag = true;\\n    // 删除文件夹下的所有文件(包括子目录)\\n    let files = dirFile.listFiles();\\n    for (let i = 0; i < files.length; i++) {\\n        // 删除子文件\\n        if (files[i].isFile()) {\\n            flag = deleteFile(files[i].getAbsolutePath());\\n            if (!flag) {\\n                break;\\n            }\\n        } else { // 删除子目录\\n            flag = deleteDirectory(files[i].getAbsolutePath());\\n            if (!flag) {\\n                break;\\n            }\\n        }\\n    }\\n    if (!flag) {\\n        //log(\\\"删除目录失败\\\");\\n        return false;\\n    }\\n    // 删除当前目录\\n    if (dirFile.delete()) {\\n        //log(\\\"删除目录\\\" + dir + \\\"成功！\\\");\\n        return true;\\n    } else {\\n        //log(\\\"删除目录\\\" + dir + \\\"失败！\\\");\\n        return false;\\n    }\\n}\\n\\nfunction getFileTime(path) {\\n    let file = new File(path);\\n    let lastModified = file.lastModified();\\n    let date = new Date(lastModified);\\n    return date.getTime();\\n}\\n\\nfunction getName(path) {\\n    return new File(path).getName() + \\\"\\\";\\n}\\n\\nfunction getFilePath(path, type, expand) {\\n    type = type || \\\"file\\\";\\n    if (![\\\"file\\\", \\\"dir\\\"].includes(type)) throw new Error(\\\"类型错误\\\");\\n    let fileType = type === \\\"file\\\" ? \\\"isFile\\\" : \\\"isDirectory\\\";\\n    let file = new File(path);\\n    let array = file.listFiles() || [];\\n    let pathList = [];\\n    for (let i = 0; i < array.length; i++) {\\n        if (array[i][fileType]()) {\\n            pathList.push({\\n                name: array[i].getName() + \\\"\\\",\\n                path: array[i].getPath() + \\\"\\\"\\n            });\\n        }\\n    }\\n    if (expand) {\\n        pathList = pathList.filter(it => it.name.endsWith(expand));\\n    }\\n    return pathList;\\n}\\n\\nfunction renameFile(fromPath, name) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(fromFile.getParent() + \\\"/\\\" + name);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!deleteFlies(toPath)) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction moveFiles(fromPath, toPath) {\\n    let fromFile = new File(fromPath);\\n    let toFile = new File(toPath);\\n    try {\\n        if (!fromFile.exists()) {\\n            return false;\\n        }\\n        if (toFile.exists()) {\\n            if (!deleteFlies(toPath)) {\\n                return false;\\n            }\\n        }\\n        Files.move(fromFile.toPath(), toFile.toPath(), StandardCopyOption.REPLACE_EXISTING);\\n        return true;\\n    } catch (e) {\\n        log(e.toString());\\n        return false;\\n    }\\n}\\n\\nfunction fileWrite(path, content) {\\n    writeFile(\\\"file://\\\" + path, content)\\n}\\n\\nfunction fileWriteAppend(path, content) {\\n    let file = new File(path);\\n    let paths = file.toPath();\\n    if (file.exists()) {\\n        Files.write(paths, new javaString(content).getBytes(), StandardOpenOption.APPEND);\\n    } else {\\n        writeFile(\\\"file://\\\" + path, content);\\n    }\\n}\\n\\nfunction getTotalSizeOfFilesInDir(file) {\\n    if (file.isFile()) {\\n        return file.length();\\n    }\\n    let children = file.listFiles();\\n    let total = 0;\\n    if (children != null) {\\n        for (let child of children) {\\n            total += getTotalSizeOfFilesInDir(child);\\n        }\\n    }\\n    return total;\\n}\\n\\nfunction getFileSize(filePath) {\\n    //Byte\\n    let size = getTotalSizeOfFilesInDir(new File(filePath));\\n    if (size < 0) {\\n        return null;\\n    }\\n    let unitForm = [\\\"Byte\\\", \\\"KB\\\", \\\"MB\\\", \\\"GB\\\", \\\"TB\\\"];\\n    for (let i = 0, len = unitForm.length; i < len; i++) {\\n        if (size > 1024) {\\n            size /= 1024;\\n            continue;\\n        } else {\\n            return Math.ceil(size) + unitForm[i];\\n        }\\n    }\\n    return \\\"ERROR:数值过大\\\";\\n}\\n//完整合并\\n/*\\nfunction fileCombine(filesInput, fileOut, extension, intercept) {\\n    with(javaScope) {\\n        const TMP_BUFFER_SIZE = 0x30000;\\n        const BUFFER_SIZE = 0x300000;\\n        //合并临时文件\\n        let inputFile = new File(filesInput);\\n        let tmpFile = new File(fileOut + \\\".tmp\\\");\\n        let tos = new BufferedOutputStream(new FileOutputStream(tmpFile));\\n        let inputFiles = inputFile.listFiles();\\n        let tbys = Array.newInstance(Byte.TYPE, TMP_BUFFER_SIZE);\\n        for (let file of inputFiles) {\\n            if (file.getName().endsWith(extension)) {\\n                let is = new FileInputStream(file);\\n                let len = 0;\\n                while ((len = is.read(tbys)) != -1) {\\n                    tos.write(tbys, 0, len);\\n                }\\n                is.close();\\n            }\\n        }\\n        tos.close();\\n        //规则替换规则;\\n        let outFile = new File(fileOut);\\n        if (typeof intercept === \\\"function\\\") {\\n            let tis = new FileInputStream(tmpFile);\\n            let os = new BufferedOutputStream(new FileOutputStream(outFile));\\n            let len = 0;\\n            let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\n            while ((len = tis.read(bys)) != -1) {\\n                let nbys = intercept(new String(bys,0,len));\\n                os.write(nbys, 0, nbys.length);\\n            }\\n            tmpFile.delete();\\n            tis.close();\\n            os.close();\\n        } else {\\n            if (outFile.exists()) {\\n                outFile.delete();\\n            }\\n            tmpFile.renameTo(outFile);\\n        }\\n    }\\n}*/\\n//残\\nfunction fileRule(filesInput, fileOut, intercept) {\\n    with(javaScope) {\\n        const BUFFER_SIZE = 0x300000;\\n        let tmpFile = new File(filesInput);\\n        if(!(tmpFile.exists()&&tmpFile.isFile())){\\n            return false;\\n        }\\n        let outFile = new File(fileOut);\\n\\n        let tis = new FileInputStream(tmpFile);\\n        let os = new BufferedOutputStream(new FileOutputStream(outFile));\\n        let len = 0;\\n        let bys = Array.newInstance(Byte.TYPE, BUFFER_SIZE);\\n        while ((len = tis.read(bys)) != -1) {\\n            let nbys = intercept(new String(bys,0,len));\\n            os.write(nbys, 0, nbys.length);\\n        }\\n        tmpFile.delete();\\n        tis.close();\\n        os.close();\\n        return true;\\n    }\\n}\\n\\n$.exports = {\\n    getFileTime: (path) => getFileTime(path),\\n    getFilePath: (path, type, expand) => getFilePath(path, type, expand),\\n    deleteFlies: (path) => deleteFlies(path),\\n    renameFile: (path, name) => renameFile(path, name),\\n    moveFiles: (fromPath, toPath) => moveFiles(fromPath, toPath),\\n    fileWrite: (path, content) => fileWrite(path, content),\\n    fileWriteAppend: (path, content) => fileWriteAppend(path, content),\\n    getName: (path) => getName(path),\\n    getFileSize: (filePath) => getFileSize(filePath),\\n    fileRule: (filesInput, fileOut, intercept) => fileRule(filesInput, fileOut, intercept)\\n}\"}]","icon":"hiker://files/rules/bili/tubiao.gif","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
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!