Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@Acfunℛ1@{"last_chapter_rule":"","title":"Acfunℛ1","author":"Moon","url":"https://www.acfun.cn/bangumilist?pageNum=fypage","version":0,"col_type":"movie_3","class_name":"","type":"other","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar res = {};\nvar d = [];\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 getUrlParams = (url, baseUrl, name) => {\n    let reg = new RegExp(\"(^|&)\" + name + \"=([^&]*)(&|$)\", \"i\"); //定义正则表达式\n    let r = url.replace(baseUrl, '').substr(1).match(reg);\n    if (r != null) return unescape(r[2]);\n    return null;\n}\n\nvar addUrlPara = (url, name, value) => {\n    let currentUrl = url.split('#')[0];\n    if (/\\?/g.test(currentUrl)) {\n        if (/name=[-\\w]{4,25}/g.test(currentUrl)) {\n            currentUrl = currentUrl.replace(/name=[-\\w]{4,25}/g, name + \"=\" + value);\n        } else {\n            currentUrl += \"&\" + name + \"=\" + value;\n        }\n    } else {\n        currentUrl += \"?\" + name + \"=\" + value;\n    }\n    return currentUrl\n}\n\n//三合一\nif (!fetch('hiker://files/acfun/多合一.txt', {})) {\n    writeFile(\"hiker://files/acfun/多合一.txt\", '排行榜');\n}\nvar label = getVar(\"label\", \"UP主\");\nvar wr = `@lazyRule=.js:putVar(\"label\",input);refreshPage(false);\"toast://切换成功\"`;\n\nif (MY_URL.split('pageNum=')[1] == '1') {\n    d.push({\n        title: label == 'UP主' ? getHead(label) : 'UP主',\n        url: label == 'UP主' ? 'hiker://empty@lazyRule=.js:putVar(\"label1\", getVar(\"label1\")==\"UP主\"?\"折叠\":\"UP主\");refreshPage(false);\"toast://切换成功\"' : 'UP主' + wr,\n        col_type: 'text_4'\n    });\n    d.push({\n        title: label == '排行榜' ? getHead(label) : '排行榜',\n        url: label == '排行榜' ? 'hiker://empty@lazyRule=.js:putVar(\"label1\", getVar(\"label1\")==\"排行榜\"?\"折叠\":\"排行榜\");refreshPage(false);\"toast://切换成功\"' : '排行榜' + wr,\n        col_type: 'text_4'\n    });\n    d.push({\n        title: label == '番剧' ? getHead(label) : '番剧',\n        url: label == '番剧' ? 'hiker://empty@lazyRule=.js:putVar(\"label1\", getVar(\"label1\")==\"番剧\"?\"折叠\":\"番剧\");refreshPage(false);\"toast://切换成功\"' : '番剧' + 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}\n\nif (getVar(\"label1\") == 'UP主') {\n    d.push({\n        title: getVar(\"label2\") == \"UP\" ? getHead(\"UP\") : 'UP',\n        url: 'hiker://empty@lazyRule=.js:putVar(\"label2\",getVar(\"label2\",\"关闭\")==\"UP\"?\"关闭\":\"UP\");refreshPage();\"toast://你在想屁peach\"',\n        col_type: 'text_3'\n    });\n    d.push({\n        title: getVar(\"label2\") == \"置顶\" ? getHead(\"置顶\") : '置顶',\n        url: 'hiker://empty@lazyRule=.js:putVar(\"label2\",getVar(\"label2\",\"关闭\")==\"置顶\"?\"关闭\":\"置顶\");refreshPage();\"toast://你在想屁peach\"',\n        col_type: 'text_3'\n    });\n    d.push({\n        title: getVar(\"label2\") == \"取关\" ? getHead(\"删除\") : '删除',\n        url: 'hiker://empty@lazyRule=.js:putVar(\"label2\",getVar(\"label2\",\"关闭\")==\"取关\"?\"关闭\":\"取关\");refreshPage();\"toast://你在想屁peach\"',\n        col_type: 'text_3'\n    });\n}\n\n\nif (label == '排行榜') {\n    d.push({\n        desc: '0&& float',\n        col_type: \"x5_webview_single\"\n    })\n    var purl = 'https://www.acfun.cn/rest/pc-direct/rank/channel?channelId=分类&subChannelId=&rankLimit=100&rankPeriod=日期';\n\n    var c1 = '1&60&201&58&123&59&70&68&69&125';\n\n    var w1 = '动画&娱乐&生活&音乐&舞蹈·偶像&游戏&科技&影视&体育&鱼塘';\n\n    var c2 = 'DAY&THREE_DAYS&WEEK';\n\n    var w2 = '今日&三日&本周';\n\n    var word1 = w1.split('&');\n    var class1 = c1.split('&');\n    var lab1 = getVar('lab1', '动画');\n    var key1 = getVar('key1', '1');\n\n    var word2 = w2.split('&');\n    var class2 = c2.split('&');\n    var lab2 = getVar('lab2', '今日');\n    var key2 = getVar('key2', 'DAY');\n\n    if (getVar(\"label1\") == '排行榜') {\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: 'flex_button'\n            });\n        }\n        d.push({\n            col_type: 'line'\n        });\n\n        for (var k in word2) {\n            var a = word2[k];\n            var b = class2[k];\n            var c = a + '&' + b;\n            d.push({\n                title: a == lab2 ? getHead(a) : a,\n                url: $(\"#noLoading#\").lazyRule((c) => {\n                    putVar(\"lab2\", c.split('&')[0]);\n                    putVar(\"key2\", c.split('&')[1]);\n                    refreshPage(false);\n                    return \"hiker://empty\"\n                }, c),\n                col_type: 'flex_button'\n            });\n        }\n    }\n    var url = purl.replace('分类', getVar('key1')).replace('日期', getVar('key2'));\n\n    var json = JSON.parse(request(url, {}));\n\n    var list = json.rankList;\n    for (let x of list) {\n        var c = x.shareUrl;\n        d.push({\n            title: x.title,\n            desc: x.description,\n            img: x.videoCover,\n            //url:x.shareUrl,\n            url: $(\"\").lazyRule((c) => {\n                var code = request(c, {\n                    headers: {\n                        \"User-Agent\": PC_UA\n                    }\n                });\n                var vid = code.split('\"currentVideoId\":')[1].split(\",\")[0];\n                log(vid)\n                var dmurl = \"https://m.acfun.cn/rest/mobile-direct/new-danmaku/poll\";\n                var dminfo = JSON.parse(request(dmurl, {\n                    headers: {\n                        \"Cookie\": \"_did=H5_989350549FEF76DE;actoken=KVEOQ1XxuIdXud6grNtlDoxR;safety_id=AAKQvdT6lKQlgtj0EztubXfO;EGG_SESS=LeuVrD7spUl4PQfNroW9BFai5_BOf1S1LJy-fhXtlYl7d7j90mI1bMo3PfTxEpadUvmbJhNh71c8eMCoxFLPwM_Ob8JaE0US8BO_C5h3H4LGxmfbwI_NRSn-cvzoTEh9CA8ratzm7e0MO_dxssHp_g==;webp_supported=%7B%22lossy%22%3Atrue%2C%22lossless%22%3Atrue%2C%22alpha%22%3Atrue%2C%22animation%22%3Atrue%7D;cur_req_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9;cur_group_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9_0\"\n                    },\n                    body: \"videoId=\" + vid,\n                    method: \"POST\"\n                }));\n                //log(dminfo)\n                var danmu = [];\n                for (let i = 0; i < dminfo.added.length; i++) {\n                    //log(json.danmuku[i][4]);\n                    danmu.push({\n                        text: dminfo.added[i].body,\n                        time: dminfo.added[i].position / 1000\n                    });\n                }\n\n                let s = JSON.stringify(danmu)\n                //log(s)\n                writeFile(\"hiker://files/cache/acdanmu.json\", s);\n\n\n                try {\n                    var rurl = code.replace(/\\\\/g, '').split('backupUrl\":[\"')[1].split('\"')[0];\n                } catch (e) {\n                    var rurl = url\n                }\n                return JSON.stringify({\n                    urls: [rurl],\n                    danmu: 'hiker://files/cache/acdanmu.json'\n                });\n            }, c),\n            col_type: 'pic_1_card'\n        });\n    }\n    setResult(d);\n}\n\nif (label == 'UP主') {\n    d.push({\n        desc: '0&& float',\n        col_type: \"x5_webview_single\"\n    })\n    var uid = fetch(\"hiker://files/bili/acfun/up_cache.txt\", {});\n    var xx = getVar('aclb').split('\\n');\n\n    if (getVar(\"label2\") == '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            d.push({\n                title: st + xx[k].split('&&')[0],\n                url: 'hiker://empty#' + xx[k].split('&&')[1].split('$$')[0] + `@lazyRule=.js:input=input.split('#')[1];writeFile(\"hiker://files/bili/acfun/up_cache.txt\",input);putVar('label1','折叠');putVar('label2','关闭');refreshPage(false);\"toast://切换成功\"`,\n                pic_url: pic,\n                col_type: 'icon_round_small_4'\n            });\n        }\n    }\n\n    if (getVar(\"label2\") == '置顶') {\n        for (var k in xx) {\n            var pic = xx[k].split('$$')[1];\n            d.push({\n                title: \"🥇\" + xx[k].split('&&')[0],\n                url: xx[k] + `@lazyRule=.js:var sc=input+'\\\\n';var xr=getVar('aclb')+'\\\\n';var xz=xr.replace(sc,'');writeFile(\"hiker://files/rules/js/acup.js\",sc+xz);refreshPage(false);'toast://置顶成功'`,\n                pic_url: pic,\n                col_type: 'icon_round_small_4'\n            });\n        }\n    }\n\n    if (getVar(\"label2\") == '取关') {\n        for (var k in xx) {\n            var pic = xx[k].split('$$')[1];\n            d.push({\n                title: \"🔘\" + xx[k].split('&&')[0],\n                url: xx[k] + `@lazyRule=.js:var sc=input+'\\\\n';var xr=getVar('aclb')+'\\\\n';var xz=xr.replace(sc,'');writeFile(\"hiker://files/rules/js/acup.js\",xz);refreshPage(false);'toast://取关成功！铁子再见🦆'`,\n                pic_url: pic,\n                col_type: 'icon_round_small_4'\n            });\n        }\n    }\n    var ts = new Date().getTime().toString();\n    var page = MY_URL.split('pageNum=')[1] - 1;\n    var url = 'https://www.acfun.cn/u/' + uid + '?quickViewId=ac-space-video-list&reqID=4&ajaxpipe=1&type=video&order=newest&page=' + page + '&pageSize=20&t=' + ts;\n    try {\n        var code = JSON.parse(fetch(url, {\n            headers: {\n                \"User-Agent\": PC_UA\n            },\n            redirect: false\n        }).split('/*<!--')[0]).html;\n        var list = parseDomForArray(code, \"div#ac-space-video-list&&a\");\n        for (let x of list) {\n            d.push({\n                title: parseDomForHtml(x, \"p.title.line&&Text\"),\n                img: parseDomForHtml(x, \"img&&src\"),\n                //url: parseDom(x, \"a&&href\") + `@lazyRule=.js:var code = request(input,{headers:{\"User-Agent\":PC_UA}});try{var url =code.match(/backupUrl.*?\".*?\"(.*?)\"/)[1];}catch(e){var url = input}url;`,\n                url: $(parseDom(x, \"a&&href\")).lazyRule(() => {\n                    var code = request(input, {\n                        headers: {\n                            \"User-Agent\": PC_UA\n                        }\n                    });\n                    //var vid = JSON.parse(code.split(\"window.videoInfo = \")[1].split(\";\")[0]).currentVideoId;\n                    var vid = code.split('\"currentVideoId\":')[1].split(\",\")[0];\n                    log(vid)\n                    var dmurl = \"https://m.acfun.cn/rest/mobile-direct/new-danmaku/poll\";\n                    var dminfo = JSON.parse(request(dmurl, {\n                        headers: {\n                            \"Cookie\": \"_did=H5_989350549FEF76DE;actoken=KVEOQ1XxuIdXud6grNtlDoxR;safety_id=AAKQvdT6lKQlgtj0EztubXfO;EGG_SESS=LeuVrD7spUl4PQfNroW9BFai5_BOf1S1LJy-fhXtlYl7d7j90mI1bMo3PfTxEpadUvmbJhNh71c8eMCoxFLPwM_Ob8JaE0US8BO_C5h3H4LGxmfbwI_NRSn-cvzoTEh9CA8ratzm7e0MO_dxssHp_g==;webp_supported=%7B%22lossy%22%3Atrue%2C%22lossless%22%3Atrue%2C%22alpha%22%3Atrue%2C%22animation%22%3Atrue%7D;cur_req_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9;cur_group_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9_0\"\n                        },\n                        body: \"videoId=\" + vid,\n                        method: \"POST\"\n                    }));\n                    //log(dminfo)\n                    var danmu = [];\n                    for (let i = 0; i < dminfo.added.length; i++) {\n                        //log(json.danmuku[i][4]);\n                        danmu.push({\n                            text: dminfo.added[i].body,\n                            time: dminfo.added[i].position / 1000\n                        });\n                    }\n\n                    let s = JSON.stringify(danmu)\n                    //log(s)\n                    writeFile(\"hiker://files/cache/acdanmu.json\", s);\n                    try {\n                        var url = code.match(/backupUrl.*?\".*?\"(.*?)\"/)[1];\n                    } catch (e) {\n                        var url = input\n                    }\n                    return JSON.stringify({\n                        urls: [url],\n                        danmu: 'hiker://files/cache/acdanmu.json'\n                    });\n                }, ),\n                desc: parseDomForHtml(x, \"p.play-info&&Text\").split(' • 弹幕')[0] + '  上传日期:' + parseDomForHtml(x, \"p.date&&Text\"),\n                col_type: 'movie_1_left_pic'\n            });\n        }\n    } catch (e) {}\n    setResult(d);\n}\n\nif (label == '番剧') {\n\n    let d = []\n    var category_html = getResCode()\n    var categories = parseDomForArray(category_html, '.ac-menu&&.ac-menu-filter')\n    let category_list = []\n\n    var base_url = MY_URL.split('?')[0]\n\n    var pageNum = getUrlParams(MY_URL, base_url, 'pageNum')\n\n    var true_url = addUrlPara(getVar('tab-url') || MY_URL, 'pageNum', pageNum)\n\n    var filters = getUrlParams(true_url, base_url, 'filters') || ''\n\n    categories.forEach(category => {\n        let sub_list = []\n        let category_sub = parseDomForArray(category, '.ac-menu-filter-content&&.ac-menu-filter-item')\n        category_sub.forEach(sub => {\n            sub_list.push({\n                id: parseDomForHtml(sub, '.ac-menu-filter-item&&data-id'),\n                name: parseDomForHtml(sub, '.ac-menu-filter-item&&Text'),\n            })\n        })\n        category_list.push({\n            name: parseDomForHtml(category, '.ac-menu-filter-title&&Text').slice(0, -1),\n            list: sub_list\n        })\n    })\n\n    putVar('tab-panel', JSON.stringify(category_list))\n\n    if (MY_URL.split('pageNum=')[1] == '1') {\n        d.push({\n            title: label == 'UP主' ? getHead(label) : 'UP主',\n            url: 'UP主' + wr,\n            col_type: 'text_3'\n        });\n        d.push({\n            title: label == '排行榜' ? getHead(label) : '排行榜',\n            url: '排行榜' + wr,\n            col_type: 'text_3'\n        });\n        d.push({\n            title: label == '番剧' ? getHead(label) : '番剧',\n            url: label == '番剧' ? 'hiker://empty@lazyRule=.js:putVar(\"label1\", getVar(\"label1\")==\"番剧\"?\"折叠\":\"番剧\");refreshPage(false);\"toast://切换成功\"' : '番剧' + wr,\n            col_type: 'text_3'\n        });\n    }\n\n    if (getVar(\"label1\") == '番剧') {\n        d.push({\n            desc: '118 && float',\n            url: 'file:///storage/emulated/0/Android/data/com.example.hikerview/files/Documents/TyrantG/public/category.html?filters=' + filters,\n            col_type: \"x5_webview_single\"\n        });\n    } else {\n        d.push({\n            desc: '0&& float',\n            col_type: \"x5_webview_single\"\n        })\n    }\n\n    var list = parseDomForArray(fetch(true_url, {\n        headers: {\n            \"User-Agent\": PC_UA\n        }\n    }), '.ac-mod-ul&&.ac-mod-li')\n\n    list.forEach(item => {\n        d.push({\n            title: parseDomForHtml(item, '.ac-mod-title&&title'),\n            pic_url: parseDomForHtml(item, 'img&&src'),\n            url: parseDomForHtml(item, '.ac-mod-link&&href'),\n        })\n    })\n\n    setResult(d);\n}","search_url":"https://www.acfun.cn/search?type=bgm&keyword=**&pCursor=fypage","group":"①推荐","searchFind":"js:\nvar res = {};\nvar d = [];\nvar code = request(MY_URL, {\n    headers: {\n        \"User-Agent\": PC_UA\n    }\n});\n\nvar bgmcode = '{' + code.split('pagelet_bangumi\",')[1].split('})')[0] + '}';\n\nvar videocode = '{' + code.split('pagelet_video\",')[1].split('})')[0] + '}';\n\nvar upcode = '{' + code.split('pagelet_up\",')[1].split('})')[0] + '}';\n\nvar bgmlist = JSON.parse(bgmcode).html;\n\nvar videolist = JSON.parse(videocode).html;\n\nvar uplist = JSON.parse(upcode).html;\n\nvar bgm = parseDomForArray(bgmlist, \"#bangumi-list&&.search-bangumi\");\n\nvar video = parseDomForArray(videolist, \"#video-list&&.search-video\");\n\nvar up = parseDomForArray(uplist, \"#up-list&&.search-up\");\n\n\nd.push({\n    title: '下面是UP(为空则表示未搜到)',\n    col_type: 'movie_1'\n});\n//UP\nfor (var x of up) {\n    var ts = new Date().getTime().toString();\n    var page = MY_URL.split('pCursor=')[1] - 1;\n    d.push({\n        title: parseDomForHtml(x, \"a&&img&&alt\"),\n        img: parseDomForHtml(x, \"a&&img&&src\"),\n        desc: parseDomForHtml(x, \".up__main&&.up__main__info&&Text\"),\n        content: parseDomForHtml(x, \".up__main&&.up__main__intro&&Text\"),\n        url:'https://www.acfun.cn'+parseDomForHtml(x,\"a&&href\")+'?quickViewId=ac-space-video-list&reqID=4&ajaxpipe=1&type=video&order=newest&page='+page+'&pageSize=20&t='+ts+\"#\"+parseDomForHtml(x,\"a&&img&&alt\")+\"&&\"+parseDomForHtml(x,\"a&&href\").split('/u/')[1]+\"$$\"+parseDomForHtml(x,\"a&&img&&src\"),\n        col_type: 'movie_1_vertical_pic'\n    });\n}\nd.push({\n    title: '下面是番剧(为空则表示未搜到)',\n    col_type: 'movie_1'\n});\n//番剧\nfor (var x of bgm) {\n    d.push({\n        title: parseDomForHtml(x, \"a&&img&&alt\"),\n        img: parseDomForHtml(x, \"a&&img&&src\"),\n        desc: parseDomForHtml(x, \".bangumi__main&&.bangumi__main__info&&Text\"),\n        content: parseDomForHtml(x, \".bangumi__main&&.bangumi__main__intro&&Text\"),\n        url: 'https://www.acfun.cn' + parseDomForHtml(x, \"a&&href\"),\n        col_type: 'movie_1_vertical_pic'\n    });\n}\n\nd.push({\n    title: '下面是视频(为空则表示未搜到)',\n    col_type: 'movie_1'\n});\n//视频\nfor (var x of video) {\n    d.push({\n        title: parseDomForHtml(x, \".video__main&&.video__main__title&&a&&Text\"),\n        img: parseDomForHtml(x, \"a&&img&&src\"),\n        desc: parseDomForHtml(x, \".video__main&&.video__main__info&&Text\"),\n        content: parseDomForHtml(x, \".video__main&&.video__main__intro&&Text\"),\n        //url: \"https://m.acfun.cn/v/?ac=\" + parseDomForHtml(x, \".video__main&&.video__main__title&&a&&href\").split('ac')[1] + `@lazyRule=.js:var code = request(input,{headers:{\"User-Agent\":PC_UA}});try{var url =code.match(/backupUrl.*?\".*?\"(.*?)\"/)[1];}catch(e){var url = input}url;`,\n        url: $('https://www.acfun.cn' + parseDomForHtml(x, \"a&&href\")).lazyRule(() => {\n            var code = request(input, {\n                headers: {\n                    \"User-Agent\": PC_UA\n                }\n            });\n            //var vid = JSON.parse(code.split(\"window.videoInfo = \")[1].split(\";\")[0]).currentVideoId;\n            var vid = code.split('\"currentVideoId\":')[1].split(\",\")[0];\n            log(vid)\n            var dmurl = \"https://m.acfun.cn/rest/mobile-direct/new-danmaku/poll\";\n            var dminfo = JSON.parse(request(dmurl, {\n                headers: {\n                    \"Cookie\": \"_did=H5_989350549FEF76DE;actoken=KVEOQ1XxuIdXud6grNtlDoxR;safety_id=AAKQvdT6lKQlgtj0EztubXfO;EGG_SESS=LeuVrD7spUl4PQfNroW9BFai5_BOf1S1LJy-fhXtlYl7d7j90mI1bMo3PfTxEpadUvmbJhNh71c8eMCoxFLPwM_Ob8JaE0US8BO_C5h3H4LGxmfbwI_NRSn-cvzoTEh9CA8ratzm7e0MO_dxssHp_g==;webp_supported=%7B%22lossy%22%3Atrue%2C%22lossless%22%3Atrue%2C%22alpha%22%3Atrue%2C%22animation%22%3Atrue%7D;cur_req_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9;cur_group_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9_0\"\n                },\n                body: \"videoId=\" + vid,\n                method: \"POST\"\n            }));\n            //log(dminfo)\n            var danmu = [];\n            for (let i = 0; i < dminfo.added.length; i++) {\n                //log(json.danmuku[i][4]);\n                danmu.push({\n                    text: dminfo.added[i].body,\n                    time: dminfo.added[i].position / 1000\n                });\n            }\n\n            let s = JSON.stringify(danmu)\n            //log(s)\n            writeFile(\"hiker://files/cache/acdanmu.json\", s);\n            try {\n                var url = code.match(/backupUrl.*?\".*?\"(.*?)\"/)[1];\n            } catch (e) {\n                var url = input\n            }\n            return JSON.stringify({\n                urls: [url],\n                danmu: 'hiker://files/cache/acdanmu.json'\n            });\n        }, ),\n        col_type: 'movie_1_vertical_pic'\n    });\n}\n\n\nres.data = d;\nsetResult(res);","detail_col_type":"movie_1","detail_find_rule":"js:\nvar res = {};\nvar d = [];\n\nvar url = MY_URL != getVar('url', MY_URL).split('_')[0] ? MY_URL : getVar('url', MY_URL);\nvar title = getVar('title');\n//var desc = getVar('desc');\nvar code = request(url, {\n    headers: {\n        \"User-Agent\": PC_UA\n    }\n});\ntry {\n    var rurl = code.replace(/\\\\/g, '').split('backupUrl\":[\"')[1].split('\"')[0];\n} catch (e) {\n    var rurl = url\n}\nd.push({\n    title: '&nbsp;' + '<small><font color=\"' + 'red\">当前集数:</font></small>' + '<font color=\"' + '#4F9BFA\">' + title + '</font>',\n    col_type: \"rich_text\"\n});\n/*\nd.push({\n    title: title,\n    url:rurl,\n    col_type:\"text_2\"\n});\n\nd.push({\n    title: \"选集\",\n    col_type:\"rich_text\"\n});\n*/\nvar json = code.split('window.bangumiList = ')[1].split('};')[0] + '}';\nvar jsons = JSON.parse(json);\nvar list = jsons.items;\nfor (let x of list) {\n\n    var Colors = [\"4\", \"5\", \"0\", \"1\", \"A\", \"3\", \"8\", \"9\", \"B\", \"C\", \"D\", \"E\", \"6\", \"7\", \"F\"];\n    var Color = '#';\n\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\n    var Color = \"#FA7298\";\n\n    function getHead(title) {\n        return '‘‘’’<strong><font color=\"' + Color + '\">' + title + '</front></strong>';\n    }\n\n    var a = MY_URL + '_36188_' + x.itemId;\n    //var b = x.episodeName;\n    var b = x.title != '' ? x.title : x.episodeName;\n    var c = a + '&&' + b;\n    var vid = x.videoId;\n    var type = (x.paymentType.name == '付费' ? '💰' : '🆓');\n    d.push({\n        title: b == title ? getHead(type + x.episodeName) : (type + x.episodeName),\n        img: x.image,\n        url: $(\"#noLoading#\").lazyRule((c, vid) => {\n            putVar(\"url\", c.split('&&')[0]);\n            putVar(\"title\", c.split('&&')[1]);\n            var url = MY_URL != getVar('url', MY_URL).split('_')[0] ? MY_URL : getVar('url', MY_URL);\n            var title = getVar('title');\n            var code = request(url, {\n                headers: {\n                    \"User-Agent\": PC_UA\n                }\n            });\n\n            log(vid)\n            var dmurl = \"https://m.acfun.cn/rest/mobile-direct/new-danmaku/poll\";\n            var dminfo = JSON.parse(request(dmurl, {\n                headers: {\n                    \"Cookie\": \"_did=H5_989350549FEF76DE;actoken=KVEOQ1XxuIdXud6grNtlDoxR;safety_id=AAKQvdT6lKQlgtj0EztubXfO;EGG_SESS=LeuVrD7spUl4PQfNroW9BFai5_BOf1S1LJy-fhXtlYl7d7j90mI1bMo3PfTxEpadUvmbJhNh71c8eMCoxFLPwM_Ob8JaE0US8BO_C5h3H4LGxmfbwI_NRSn-cvzoTEh9CA8ratzm7e0MO_dxssHp_g==;webp_supported=%7B%22lossy%22%3Atrue%2C%22lossless%22%3Atrue%2C%22alpha%22%3Atrue%2C%22animation%22%3Atrue%7D;cur_req_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9;cur_group_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9_0\"\n                },\n                body: \"videoId=\" + vid,\n                method: \"POST\"\n            }));\n            //log(dminfo)\n            var danmu = [];\n            for (let i = 0; i < dminfo.added.length; i++) {\n                //log(json.danmuku[i][4]);\n                danmu.push({\n                    text: dminfo.added[i].body,\n                    time: dminfo.added[i].position / 1000\n                });\n            }\n\n            let s = JSON.stringify(danmu)\n            //log(s)\n            writeFile(\"hiker://files/cache/acdanmu.json\", s);\n            try {\n                var rurl = code.replace(/\\\\/g, '').split('backupUrl\":[\"')[1].split('\"')[0];\n            } catch (e) {\n                var rurl = url\n            }\n            refreshPage(false);\n            return JSON.stringify({\n                urls: [rurl],\n                danmu: 'hiker://files/cache/acdanmu.json'\n            });\n        }, c, vid),\n        col_type: 'text_3'\n    });\n\n}\nres.data = d;\nsetResult(res);","sdetail_col_type":"movie_1","sdetail_find_rule":"js:\nvar res = {};\nvar d = [];\n\nif (MY_URL.indexOf(\"bangumi/aa\") != \"-1\") {\n    var url = MY_URL != getVar('url', MY_URL).split('_')[0] ? MY_URL : getVar('url', MY_URL);\n    var title = getVar('title');\n    //var desc = getVar('desc');\n    var code = request(url, {\n        headers: {\n            \"User-Agent\": PC_UA\n        }\n    });\n    try {\n        var rurl = code.replace(/\\\\/g, '').split('backupUrl\":[\"')[1].split('\"')[0];\n    } catch (e) {\n        var rurl = url\n    }\n    d.push({\n        title: '&nbsp;' + '<small><font color=\"' + 'red\">当前集数:</font></small>' + '<font color=\"' + '#4F9BFA\">' + title + '</font>',\n        col_type: \"rich_text\"\n    });\n    /*\n    d.push({\n        title: title,\n        url:rurl,\n        col_type:\"text_2\"\n    });\n\n    d.push({\n        title: \"选集\",\n        col_type:\"rich_text\"\n    });\n    */\n    var json = code.split('window.bangumiList = ')[1].split('};')[0] + '}';\n    var jsons = JSON.parse(json);\n    var list = jsons.items;\n    for (let x of list) {\n\n        var Colors = [\"4\", \"5\", \"0\", \"1\", \"A\", \"3\", \"8\", \"9\", \"B\", \"C\", \"D\", \"E\", \"6\", \"7\", \"F\"];\n        var Color = '#';\n\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\n        var Color = \"#FA7298\";\n\n        function getHead(title) {\n            return '‘‘’’<strong><font color=\"' + Color + '\">' + title + '</front></strong>';\n        }\n\n\n        var a = MY_URL + '_36188_' + x.itemId;\n        //var b = x.episodeName;\n        var b = x.title != '' ? x.title : x.episodeName;\n        var c = a + '&&' + b;\n        var vid = x.videoId;\n        /*if(x.name=='免费')\n{\nvar type = '🆓';\n}else{\nvar type = '💰';\n}*/\n        var type = (x.paymentType.name == '付费' ? '💰' : '🆓');\n        d.push({\n            title: b == title ? getHead(type + x.episodeName) : (type + x.episodeName),\n            img: x.image,\n            url: $(\"#noLoading#\").lazyRule((c,vid) => {\n                putVar(\"url\", c.split('&&')[0]);\n                putVar(\"title\", c.split('&&')[1]);\n                var url = MY_URL != getVar('url', MY_URL).split('_')[0] ? MY_URL : getVar('url', MY_URL);\n                var title = getVar('title');\n                var code = request(url, {\n                    headers: {\n                        \"User-Agent\": PC_UA\n                    }\n                });\n\n                var dmurl = \"https://m.acfun.cn/rest/mobile-direct/new-danmaku/poll\";\n                var dminfo = JSON.parse(request(dmurl, {\n                    headers: {\n                        \"Cookie\": \"_did=H5_989350549FEF76DE;actoken=KVEOQ1XxuIdXud6grNtlDoxR;safety_id=AAKQvdT6lKQlgtj0EztubXfO;EGG_SESS=LeuVrD7spUl4PQfNroW9BFai5_BOf1S1LJy-fhXtlYl7d7j90mI1bMo3PfTxEpadUvmbJhNh71c8eMCoxFLPwM_Ob8JaE0US8BO_C5h3H4LGxmfbwI_NRSn-cvzoTEh9CA8ratzm7e0MO_dxssHp_g==;webp_supported=%7B%22lossy%22%3Atrue%2C%22lossless%22%3Atrue%2C%22alpha%22%3Atrue%2C%22animation%22%3Atrue%7D;cur_req_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9;cur_group_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9_0\"\n                    },\n                    body: \"videoId=\" + vid,\n                    method: \"POST\"\n                }));\n                //log(dminfo)\n                var danmu = [];\n                for (let i = 0; i < dminfo.added.length; i++) {\n                    //log(json.danmuku[i][4]);\n                    danmu.push({\n                        text: dminfo.added[i].body,\n                        time: dminfo.added[i].position / 1000\n                    });\n                }\n\n                let s = JSON.stringify(danmu)\n                //log(s)\n                writeFile(\"hiker://files/cache/acdanmu.json\", s);\n                try {\n                    var rurl = code.replace(/\\\\/g, '').split('backupUrl\":[\"')[1].split('\"')[0];\n                } catch (e) {\n                    var rurl = url\n                }\n                refreshPage(false);\n                return JSON.stringify({\n                    urls: [rurl],\n                    danmu: 'hiker://files/cache/acdanmu.json'\n                });\n            }, c,vid),\n            col_type: 'text_3'\n        });\n    }\n}\n\n\nif (MY_URL.indexOf(\"quickViewId=ac-space-video-list\") != \"-1\") {\n\n\n\n\n    if (MY_URL.indexOf('page=0&') != -1) {\n        d.push({\n            title: '““关注””',\n            url: 'hiker://empty#' + MY_URL.split('#')[1] + `@lazyRule=.js:input=input.split('#')[1];if(!getVar('aclb').includes(input.split('&&')[1].split('$$')[0])){var xr=getVar('aclb')+'\\\\n'+input;writeFile(\"hiker://files/rules/js/acup.js\",xr);putVar2('aclb',fetch(\"hiker://files/rules/js/acup.js\",{}));'toast://关注成功';}else{'toast://年轻人，耗子尾汁'}`,\n            col_type: 'text_center_1'\n        });\n    }\n\n\n    try {\n        var code = JSON.parse(fetch(MY_URL, {\n            headers: {\n                \"User-Agent\": PC_UA\n            },\n            redirect: false\n        }).split('/*<!--')[0]).html;\n        var list = parseDomForArray(code, \"div#ac-space-video-list&&a\");\n        for (let x of list) {\n            d.push({\n                title: parseDomForHtml(x, \"p.title.line&&Text\"),\n                img: parseDomForHtml(x, \"img&&src\"),\n                //url: parseDom(x, \"a&&href\") + `@lazyRule=.js:var code = request(input,{headers:{\"User-Agent\":PC_UA}});try{var url =code.match(/backupUrl.*?\".*?\"(.*?)\"/)[1];}catch(e){var url = input}url;`,\n                url: $(parseDom(x, \"a&&href\")).lazyRule(() => {\n                    var code = request(input, {\n                        headers: {\n                            \"User-Agent\": PC_UA\n                        }\n                    });\n                    var vid = JSON.parse(code.split(\"window.videoInfo = \")[1].split(\";\")[0]).currentVideoId;\n                    log(vid)\n                    var dmurl = \"https://m.acfun.cn/rest/mobile-direct/new-danmaku/poll\";\n                    var dminfo = JSON.parse(request(dmurl, {\n                        headers: {\n                            \"Cookie\": \"_did=H5_989350549FEF76DE;actoken=KVEOQ1XxuIdXud6grNtlDoxR;safety_id=AAKQvdT6lKQlgtj0EztubXfO;EGG_SESS=LeuVrD7spUl4PQfNroW9BFai5_BOf1S1LJy-fhXtlYl7d7j90mI1bMo3PfTxEpadUvmbJhNh71c8eMCoxFLPwM_Ob8JaE0US8BO_C5h3H4LGxmfbwI_NRSn-cvzoTEh9CA8ratzm7e0MO_dxssHp_g==;webp_supported=%7B%22lossy%22%3Atrue%2C%22lossless%22%3Atrue%2C%22alpha%22%3Atrue%2C%22animation%22%3Atrue%7D;cur_req_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9;cur_group_id=89116745218A64E4_self_92e11baf95c5e87f2dc60777433407d9_0\"\n                        },\n                        body: \"videoId=\" + vid,\n                        method: \"POST\"\n                    }));\n                    //log(dminfo)\n                    var danmu = [];\n                    for (let i = 0; i < dminfo.added.length; i++) {\n                        //log(json.danmuku[i][4]);\n                        danmu.push({\n                            text: dminfo.added[i].body,\n                            time: dminfo.added[i].position / 1000\n                        });\n                    }\n\n                    let s = JSON.stringify(danmu)\n                    //log(s)\n                    writeFile(\"hiker://files/cache/acdanmu.json\", s);\n                    try {\n                        var url = code.match(/backupUrl.*?\".*?\"(.*?)\"/)[1];\n                    } catch (e) {\n                        var url = input\n                    }\n                    return JSON.stringify({\n                        urls: [url],\n                        danmu: 'hiker://files/cache/acdanmu.json'\n                    });\n                }, ),\n                desc: parseDomForHtml(x, \"p.play-info&&Text\").split(' • 弹幕')[0] + '  上传日期:' + parseDomForHtml(x, \"p.date&&Text\"),\n                col_type: 'movie_1_left_pic'\n            });\n        }\n    } catch (e) {}\n\n}\nres.data = d;\nsetResult(res);","ua":"pc","preRule":"\neval(fetch(\"https://git.tyrantg.com/tyrantgenesis/hikerViewRules/raw/master/God_Plan.js\"))\nacfun();\n\nif (!fetch(\"hiker://files/rules/js/acup.js\",{})){\nwriteFile(\"hiker://files/rules/js/acup.js\",\"Kyokyo沉迷汉堡王&&13215999$$https://tx-free-imgs.acfun.cn/style/image/201907/BzdG5XzRIDSfkcWsiyI4bOELN3E0QtnG.jpg?imageslim\")\n}\nif (!fetch(\"hiker://files/bili/acfun/up_cache.txt\",{})){\nwriteFile(\"hiker://files/bili/acfun/up_cache.txt\",\"13215999\")\n}\n\nputVar2('aclb',fetch(\"hiker://files/rules/js/acup.js\",{}));","pages":"[]","icon":"https://tx-free-imgs2.acfun.cn/kimg/bs2/zt-image-host/ChYwOGQxZmNkZDRiMTBjMWY2YWU4ODA3EJvM1y8.webp"}
Add Comment
Please, Sign In to add comment
