API tools faq
paste
xiaomianao666

邀您一起看：冰属性男子和酷酷女同事-妹妹登场！滑雪场的圣诞节

xiaomianao666
Feb 25th, 2023
79
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 135.62 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥冰属性男子和酷酷女同事-妹妹登场！滑雪场的圣诞节@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"api\",\"path\":\"api\",\"rule\":\"$.exports.getFeed = function() {\\n    let u = \\\"https://api.bilibili.com/x/web-interface/index/top/feed/rcmd\\\"\\n    let res = JSON.parse(request(u, {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    }))\\n    return res.data.item\\n}\\n$.exports.getUserInfo = function() {\\n    let u = \\\"https://api.bilibili.com/x/web-interface/nav\\\"\\n    let res = request(u, {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n    return JSON.parse(res).data\\n}\\n$.exports.getUrl = function(avid, cid, qn) {\\n    let u = request(buildUrl(\\\"http://api.bilibili.com/x/player/playurl\\\", {\\n        \\\"avid\\\": avid,\\n        \\\"cid\\\": cid,\\n        \\\"qn\\\": qn,\\n        \\\"fourk\\\": 1\\n    }), {\\n        headers: {\\n            Cookie: readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n    return JSON.parse(u).data\\n}\\n$.exports.getHistory = function(page) {\\n    let u = buildUrl(\\\"http://api.bilibili.com/x/v2/history\\\", {\\n        \\\"pn\\\": page,\\n        \\\"ps\\\": 20\\n    })\\n    let res = request(u, {\\n        headers: {\\n            Cookie: readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n    return JSON.parse(res).data\\n}\\n$.exports.reportProcess = function(avid, cid) {\\n    let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n    let res = post(\\\"http://api.bilibili.com/x/v2/history/report\\\", {\\n        body: {\\n            \\\"aid\\\": avid,\\n            \\\"cid\\\": cid,\\n            \\\"csrf\\\": csrf,\\n            \\\"progress\\\": 0\\n        },\\n        headers: {\\n            Cookie: readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n}\\n$.exports.getComments = function(id, sortby, page) {\\n    let u = buildUrl(\\\"http://api.bilibili.com/x/v2/reply\\\", {\\n        \\\"type\\\": 1,\\n        \\\"oid\\\": id,\\n        \\\"pn\\\": page,\\n        \\\"sort\\\": sortby == \\\"热度\\\" ? 1 : 0\\n    })\\n    let res = request(u, {\\n        headers: {\\n            Cookie: readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n    return JSON.parse(res).data.replies\\n}\\n$.exports.upVideos = function(mid, page) {\\n    let videos = request(\\\"https://api.bilibili.com/x/space/arc/search?mid=\\\" + mid + \\\"&pn=\\\" + page, {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n    return JSON.parse(videos)\\n}\\n$.exports.getslist = function() {\\n    return JSON.parse(request(\\\"https://api.bilibili.com/x/relation/tags?jsonp=jsonp\\\", {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data\\n}\\n$.exports.getSubsribes = function(id, page) {\\n    let u = \\\"https://api.bilibili.com/x/relation/tag?pn=\\\" + page + \\\"&ps=20&jsonp=jsonp&tagid=\\\" + id\\n    let res = request(u, {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n    return JSON.parse(res).data\\n}\\n$.exports.getfavteam = function() {\\n    return JSON.parse(request(\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\", {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data\\n}\\n$.exports.getFavour = function(id, page) {\\n    let u = \\\"https://api.bilibili.com/x/v3/fav/resource/list?media_id=\\\" + id + \\\"&pn=\\\" + page + \\\"&ps=20&order=mtime&type=0&tid=0\\\"\\n    let res = request(u, {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })\\n    return JSON.parse(res).data\\n}\\n$.exports.getMovies = function(type, before, after) {\\n    let u = buildUrl(\\\"http://api.bilibili.com/pgc/web/timeline\\\", {\\n        \\\"types\\\": type,\\n        \\\"before\\\": before,\\n        \\\"after\\\": after\\n    })\\n    let res = JSON.parse(request(u, {\\n        headers: {\\n            Cookie: readFile(\\\"Cookie.txt\\\")\\n        }\\n    }))\\n    return res.result\\n}\\n$.exports.lazy = function(id, cid, qn) {\\n    let d = $.require(\\\"hiker://page/api\\\").getUrl(id, cid, qn)\\n    $.require(\\\"hiker://page/api\\\").reportProcess(id, cid)\\n    let u = JSON.stringify({\\n        \\\"urls\\\": [d.durl[0].url + \\\"#isVideo=true#\\\"],\\n        \\\"headers\\\": [{\\n            \\\"Referer\\\": \\\"https://www.bilibili.com\\\",\\n            \\\"User-Agent\\\": PC_UA\\n        }],\\n        \\\"danmu\\\": `https://comment.bilibili.com/${cid}.xml`,\\n        \\\"extra\\\": {\\n            \\\"id\\\": cid\\n        }\\n    })\\n    return u\\n}\"},{\"col_type\":\"movie_1_vertical_pic_blur\",\"name\":\"视频详情\",\"path\":\"detail\",\"rule\":\"js:\\nvar d = [];\\ntry {\\n    var id = MY_PARAMS.id + \\\"\\\"\\n    var cid = MY_PARAMS.cid + \\\"\\\"\\n    var bvid = MY_PARAMS.bvid\\n    //视频信息\\n    var r = request(buildUrl(\\\"http://api.bilibili.com/x/web-interface/view\\\", {\\n        \\\"aid\\\": id\\n    }))\\n    let l = JSON.parse(r).data\\n    d.push({\\n        title: l.title,\\n        img: l.pic,\\n        desc: l.desc,\\n        url: $().rule((info) => {\\n            let stat = info.stat\\n            let infos = `av号：${info.aid}\\\\nbv号：${info.bvid}\\\\n播放量：${stat.view}\\\\n点赞：${stat.like}\\\\n投币：${stat.coin}\\\\n收藏：${stat.favorite}\\\\n\\\\n${info.desc}`\\n            setResult([{\\n                title: infos,\\n                col_type: \\\"long_text\\\"\\n            }])\\n        }, l),\\n        extra: {\\n            gradient: true\\n        }\\n    }, {\\n        title: l.owner.name,\\n        img: l.owner.face,\\n        url: \\\"hiker://page/ups?mid=\\\" + l.owner.mid + \\\"&p=fypage#immersiveTheme#\\\",\\n        col_type: \\\"avatar\\\"\\n    }, {\\n        col_type: \\\"line_blank\\\"\\n    })\\n    //视频操作\\n    function color(text, color) {\\n        text += \\\"\\\";\\n        if (text.indexOf(\\\"““””\\\") === 0) {\\n            text.replace(\\\"““””\\\", \\\"\\\");\\n        }\\n        return \\\"““””<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n    }\\n    let stat = l.stat\\n    let like = stat.like\\n    let coin = stat.coin\\n    let favourite = stat.favorite\\n    let hasLike = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/web-interface/archive/has/like\\\", {\\n        \\\"aid\\\": id\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data == 1\\n    let hasCoin = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/web-interface/archive/coins\\\", {\\n        \\\"aid\\\": id\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data.multiply != 0\\n    let hasFavour = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/v2/fav/video/favoured\\\", {\\n        \\\"aid\\\": id\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data.favoured\\n    d.push({\\n        title: (hasLike ? color(like, \\\"#FA7298\\\") : like),\\n        img: \\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/like.svg\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        url: $().lazyRule((id, hasLike) => {\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            let res = post(\\\"http://api.bilibili.com/x/web-interface/archive/like\\\", {\\n                body: {\\n                    \\\"aid\\\": id,\\n                    \\\"like\\\": (hasLike ? 2 : 1),\\n                    \\\"csrf\\\": csrf\\n                },\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n                }\\n            })\\n            refreshPage()\\n            return \\\"toast://\\\" + (hasLike ? \\\"取消点赞\\\" : \\\"点赞成功\\\")\\n        }, id, hasLike)\\n    }, {\\n        title: (hasCoin ? color(coin, \\\"#FA7298\\\") : coin),\\n        img: \\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/coin.svg\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        url: $([\\\"1\\\", \\\"2\\\"], 2, \\\"投币数量\\\").select((id) => {\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            let res = post(\\\"http://api.bilibili.com/x/web-interface/coin/add\\\", {\\n                body: {\\n                    \\\"aid\\\": id,\\n                    \\\"multiply\\\": input,\\n                    \\\"csrf\\\": csrf\\n                },\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n                }\\n            })\\n            refreshPage()\\n            return \\\"toast://投了\\\" + input + \\\"个币\\\"\\n        }, id)\\n    }, {\\n        title: (hasFavour ? color(favourite, \\\"#FA7298\\\") : favourite),\\n        img: \\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/fav.svg\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        url: $().lazyRule((id, hasFavour) => {\\n            let body = hasFavour ? {\\n                \\\"rid\\\": id,\\n                \\\"type\\\": 2,\\n                \\\"del_media_ids\\\": 0,\\n                \\\"csrf\\\": csrf\\n            } : {\\n                \\\"rid\\\": id,\\n                \\\"type\\\": 2,\\n                \\\"add_media_ids\\\": 0,\\n                \\\"csrf\\\": csrf\\n            }\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            let res = post(\\\"http://api.bilibili.com/medialist/gateway/coll/resource/deal\\\", {\\n                body: body,\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\"),\\n                    \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n                }\\n            })\\n            refreshPage()\\n            return \\\"toast://\\\" + (hasFavour ? \\\"取消收藏\\\" : \\\"收藏成功\\\")\\n        }, id, hasFavour)\\n    }, {\\n        title: \\\"评论\\\",\\n        url: \\\"hiker://page/Comments?p=fypage\\\",\\n        img: \\\"https://lanmeiguojiang.com/tubiao/more/41.png\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        extra: {\\n            \\\"id\\\": id\\n        }\\n    })\\n    //获取视频分P信息\\n    var p = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/player/pagelist\\\", {\\n        \\\"aid\\\": id\\n    }))).data\\n    if (p.length == 1) {\\n        //视频链接\\n        let a = $.require(\\\"hiker://page/api\\\").getUrl(id, cid, 120)\\n        d.push({\\n            title: \\\"智能播放\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: $().lazyRule((id, cid) => {\\n                return $.require(\\\"hiker://page/api\\\").lazy(id, cid, 120).replace(/;/g, \\\"；；\\\")\\n            }, id, cid),\\n            extra: {\\n                \\\"longClick\\\": [{\\n                    title: \\\"推送\\\",\\n                    js: $.toString((id, cid) => {\\n                        require(\\\"https://hikerfans.com/Joe/TVbox.js\\\")\\n                        return 推送tvbox({\\n                            name: \\\"推送 by Joe\\\",\\n                            vod: [{\\n                                name: \\\"bilibili\\\",\\n                                urls: JSON.parse($.require(\\\"hiker://page/api\\\").lazy(id, cid, 120).replace(/;/g, \\\"；；\\\")).url\\n                            }],\\n                            headers: {\\n                                \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n                            }\\n                        })\\n                    }, id, cid)\\n                }],\\n                \\\"id\\\": \\\"qn\\\"\\n            }\\n        })\\n        a.support_formats.forEach(item => {\\n            d.push({\\n                title: item.new_description,\\n                url: $().lazyRule((id, cid, qn) => {\\n                    return $.require(\\\"hiker://page/api\\\").lazy(id, cid, qn).replace(/;/g, \\\"；；\\\")\\n                }, id + \\\"\\\", cid + \\\"\\\", item.quality + \\\"\\\"),\\n                col_type: \\\"text_2\\\"\\n            })\\n        })\\n    } else {\\n        p.forEach(item => {\\n            d.push({\\n                title: item.part,\\n                url: $().lazyRule((id, cid) => {\\n                    return $.require(\\\"hiker://page/api\\\").lazy(id, cid, 120).replace(/;/g, \\\"；；\\\")\\n                }, id, item.cid + \\\"\\\"),\\n                col_type: \\\"text_2\\\",\\n                extra: {\\n                    \\\"cid\\\": item.cid,\\n                    \\\"id\\\": id,\\n                    \\\"bvid\\\": bvid\\n                }\\n            })\\n        })\\n    }\\n} catch (e) {\\n    log(e.message)\\n    toast(\\\"程序出现问题，请打开日志查看\\\")\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"主页\",\"path\":\"homepage\",\"rule\":\"var d = [];\\ntry {\\n    const {\\n        getFeed,\\n        getUserInfo\\n    } = $.require(\\\"hiker://page/api\\\")\\n    if (fileExist(\\\"Cookie.txt\\\")) {\\n        if (MY_PAGE == 1) {\\n            let i = getUserInfo()\\n            d.unshift({\\n                title: i.uname,\\n                img: i.face,\\n                col_type: \\\"avatar\\\",\\n                url: \\\"hiker://page/userInfo\\\",\\n                extra: {\\n                    \\\"data\\\": i\\n                }\\n            })\\n\\n            function color(text, color) {\\n                text += \\\"\\\";\\n                if (text.indexOf(\\\"““””\\\") === 0) {\\n                    text.replace(\\\"““””\\\", \\\"\\\");\\n                }\\n                return \\\"““””<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n            }\\n            let tabs = {\\n                \\\"推荐\\\": \\\"hiker://images/collection\\\",\\n                \\\"分类\\\": \\\"https://lanmeiguojiang.com/tubiao/movie/69.svg\\\",\\n                \\\"新番\\\": \\\"https://lanmeiguojiang.com/tubiao/movie/84.svg\\\",\\n                \\\"我的\\\": \\\"hiker://images/icon3\\\"\\n            }\\n            Object.entries(tabs).forEach(item => {\\n                d.push({\\n                    title: item[0],\\n                    img: item[1],\\n                    url: $().lazyRule((tab) => {\\n                        putMyVar(\\\"mode\\\", tab)\\n                        refreshPage()\\n                        return \\\"hiker://empty\\\"\\n                    }, item[0]),\\n                    col_type: \\\"icon_round_small_4\\\"\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"line\\\"\\n            })\\n        }\\n        let mode = getMyVar(\\\"mode\\\", \\\"推荐\\\")\\n        if (mode == \\\"推荐\\\") {\\n            getFeed().forEach(item => {\\n                let data = JSON.stringify(item)\\n                d.push({\\n                    title: item.title,\\n                    img: item.pic,\\n                    desc: item.stat.view + \\\"播放※\\\" + item.stat.like + \\\"点赞\\\",\\n                    url: \\\"hiker://page/detail#gameTheme#\\\",\\n                    extra: {\\n                        \\\"id\\\": item.id,\\n                        \\\"bvid\\\": item.bvid,\\n                        \\\"cid\\\": item.cid\\n                    }\\n                })\\n            })\\n        } else if (mode == \\\"我的\\\") {\\n            if (MY_PAGE == 1) {\\n                d.push({\\n                    title: getMyVar(\\\"wd\\\", \\\"history\\\") == \\\"history\\\" ? color(\\\"观看历史\\\", \\\"red\\\") : \\\"观看历史\\\",\\n                    url: $().lazyRule(() => {\\n                        putMyVar(\\\"wd\\\", \\\"history\\\")\\n                        refreshPage()\\n                        return \\\"hiker://empty\\\"\\n                    }),\\n                    col_type: \\\"text_3\\\"\\n                }, {\\n                    title: getMyVar(\\\"wd\\\", \\\"history\\\") == \\\"fav\\\" ? color(\\\"收藏\\\", \\\"red\\\") : \\\"收藏\\\",\\n                    url: $().lazyRule(() => {\\n                        putMyVar(\\\"wd\\\", \\\"fav\\\")\\n                        refreshPage()\\n                        return \\\"hiker://empty\\\"\\n                    }),\\n                    col_type: \\\"text_3\\\"\\n                }, {\\n                    title: getMyVar(\\\"wd\\\", \\\"history\\\") == \\\"sub\\\" ? color(\\\"关注\\\", \\\"red\\\") : \\\"关注\\\",\\n                    url: $().lazyRule(() => {\\n                        putMyVar(\\\"wd\\\", \\\"sub\\\")\\n                        refreshPage()\\n                        return \\\"hiker://empty\\\"\\n                    }),\\n                    col_type: \\\"text_3\\\"\\n                })\\n            }\\n            if (getMyVar(\\\"wd\\\", \\\"history\\\") == \\\"history\\\") {\\n                const {\\n                    getHistory\\n                } = $.require(\\\"hiker://page/api\\\")\\n                getHistory(MY_PAGE).forEach(item => {\\n                    d.push({\\n                        title: item.title,\\n                        img: item.pic,\\n                        url: \\\"hiker://page/detail#immersiveTheme#\\\",\\n                        extra: {\\n                            \\\"id\\\": item.aid,\\n                            \\\"bvid\\\": item.bvid,\\n                            \\\"cid\\\": item.cid\\n                        }\\n                    })\\n                })\\n            } else if (getMyVar(\\\"wd\\\", \\\"history\\\") == \\\"fav\\\") {\\n                var teams = $.require(\\\"hiker://page/api\\\").getfavteam()[0].mediaListResponse.list\\n                if (MY_PAGE == 1) {\\n                    teams.forEach(item => {\\n                        d.push({\\n                            title: (getMyVar(\\\"favo\\\", teams[0].id + \\\"\\\") == item.id ? color(item.title, \\\"red\\\") : item.title),\\n                            col_type: \\\"scroll_button\\\",\\n                            url: $().lazyRule((id) => {\\n                                putMyVar(\\\"favo\\\", id + \\\"\\\")\\n                                refreshPage()\\n                                return \\\"hiker://empty\\\"\\n                            }, item.id)\\n                        })\\n                    })\\n                }\\n                $.require(\\\"hiker://page/api\\\").getFavour(getMyVar(\\\"favo\\\", teams[0].id + \\\"\\\"), MY_PAGE).medias.forEach(item => {\\n                    d.push({\\n                        title: item.title,\\n                        img: item.cover,\\n                        url: \\\"hiker://page/detail#gameTheme#\\\",\\n                        extra: {\\n                            \\\"id\\\": item.id,\\n                            \\\"cid\\\": item.ugc.first_cid,\\n                            \\\"bvid\\\": item.bvid\\n                        }\\n                    })\\n                })\\n            } else {\\n                if (MY_PAGE == 1) {\\n                    $.require(\\\"hiker://page/api\\\").getslist().forEach(item => {\\n                        d.push({\\n                            title: (getMyVar(\\\"sub\\\", \\\"0\\\") == item.tagid ? color(item.name, \\\"red\\\") : item.name),\\n                            url: $().lazyRule((id) => {\\n                                putMyVar(\\\"sub\\\", id)\\n                                refreshPage()\\n                                return \\\"hiker://empty\\\"\\n                            }, item.tagid),\\n                            col_type: \\\"scroll_button\\\"\\n                        })\\n                    })\\n                }\\n                $.require(\\\"hiker://page/api\\\").getSubsribes(getMyVar(\\\"sub\\\", \\\"0\\\"), MY_PAGE).forEach(item => {\\n                    d.push({\\n                        title: item.uname,\\n                        img: item.face,\\n                        url: \\\"hiker://page/ups?mid=\\\" + item.mid + \\\"&p=fypage#immersiveTheme#\\\",\\n                        col_type: \\\"avatar\\\"\\n                    })\\n                })\\n            }\\n        } else if (mode == \\\"新番\\\") {\\n            var tabs = {\\n                \\\"番剧\\\": 1,\\n                \\\"电影\\\": 3,\\n                \\\"国创\\\": 4\\n            }\\n            if (MY_PAGE == 1) {\\n                Object.keys(tabs).forEach(item => {\\n                    d.push({\\n                        title: (getMyVar(\\\"juji\\\", \\\"番剧\\\") == item ? color(item, \\\"red\\\") : item),\\n                        url: $().lazyRule((a) => {\\n                            putMyVar(\\\"juji\\\", a)\\n                            refreshPage()\\n                            return \\\"toast://切换成功\\\"\\n                        }, item),\\n                        col_type: \\\"scroll_button\\\"\\n                    })\\n                })\\n                d.push({\\n                    col_type: \\\"line\\\"\\n                })\\n                let days = 7\\n                for (let i = 1; i < days + 1; i++) {\\n                    d.push({\\n                        title: (getMyVar(\\\"from\\\", \\\"1\\\") == i + \\\"\\\" ? color(i + \\\"天前\\\", \\\"red\\\") : i + \\\"天前\\\"),\\n                        url: $().lazyRule((i) => {\\n                            putMyVar(\\\"from\\\", i + \\\"\\\")\\n                            refreshPage()\\n                            return \\\"hiker://empty\\\"\\n                        }, i),\\n                        col_type: \\\"scroll_button\\\"\\n                    })\\n                }\\n                d.push({\\n                    col_type: \\\"line\\\"\\n                })\\n                for (let i = 1; i < days; i++) {\\n                    d.push({\\n                        title: (getMyVar(\\\"to\\\", \\\"1\\\") == i + \\\"\\\" ? color(i + \\\"天后\\\", \\\"red\\\") : i + \\\"天后\\\"),\\n                        url: $().lazyRule((i) => {\\n                            putMyVar(\\\"to\\\", i + \\\"\\\")\\n                            refreshPage()\\n                            return \\\"hiker://empty\\\"\\n                        }, i),\\n                        col_type: \\\"scroll_button\\\"\\n                    })\\n                }\\n\\n                $.require(\\\"hiker://page/api\\\").getMovies(tabs[getMyVar(\\\"juji\\\", \\\"番剧\\\")], getMyVar(\\\"from\\\", \\\"1\\\"), getMyVar(\\\"to\\\", \\\"1\\\")).forEach(item => {\\n                    d.push({\\n                        title: item.date + \\\" 周\\\" + item.day_of_week,\\n                        col_type: \\\"text_1\\\",\\n                        url: \\\"hiker://empty\\\"\\n                    })\\n                    item.episodes.forEach(i => {\\n                        d.push({\\n                            title: i.title,\\n                            img: i.cover,\\n                            url: \\\"hiker://page/detaila#gameTheme#\\\",\\n                            extra: {\\n                                \\\"ssid\\\": i.season_id,\\n                                \\\"epid\\\": i.episode_id\\n                            }\\n                        })\\n                    })\\n                })\\n            }\\n        } else if (mode = \\\"分类\\\") {\\n            eval(JSON.parse(fetch(\\\"hiker://page/cat\\\")).rule)\\n        }\\n    } else {\\n        if (getItem(\\\"fs\\\", \\\"0\\\") == \\\"0\\\") {\\n            let a = []\\n            let time = 10\\n            a.push({\\n                title: `                     使用前须知\\n本规则调用https://github.com/SocialSisterYi/bilibili-API-collect的api，所有代码全部开源，并且不存在上传用户信息的行为\\n本规则为学习目的，请于导入24小时内删除！！！                        \\n开始使用本规则即代表遵守规则                       \\n            `,\\n                \\\"col_type\\\": \\\"long_text\\\",\\n                extra: {\\n                    id: \\\"text\\\"\\n                }\\n            }, {\\n                title: time + \\\"秒后继续\\\",\\n                col_type: \\\"text_1\\\",\\n                extra: {\\n                    id: \\\"timer\\\"\\n                }\\n            })\\n            setResult(a)\\n            while (time != 0) {\\n                java.lang.Thread.sleep(1000)\\n                time -= 1\\n                updateItem(\\\"timer\\\", {\\n                    title: time + \\\"秒后继续\\\"\\n                })\\n            }\\n            updateItem(\\\"timer\\\", {\\n                title: \\\"我已知晓\\\",\\n                url: $().lazyRule(() => {\\n                    setItem(\\\"fs\\\", \\\"1\\\")\\n                    refreshPage()\\n                    return \\\"toast://你已确认\\\"\\n                })\\n            })\\n        } else {\\n            $.require(\\\"hiker://page/login\\\")\\n        }\\n    }\\n} catch (e) {\\n    log(e.message)\\n    d.push({\\n        title: '““””<center><small><span style=\\\"color: #999999\\\">～～～我是有底线的～～～</span></small></center>',\\n        col_type: \\\"text_center_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n            lineVisible: false\\n        }\\n    })\\n}\\nsetResult(d);\"},{\"col_type\":\"icon_2_round\",\"name\":\"用户详情\",\"path\":\"userInfo\",\"rule\":\"js:\\nvar d = [];\\nlet info = MY_PARAMS.data\\nd.push({\\n    title: info.uname,\\n    img: info.face,\\n    url: \\\"hiker://empty\\\"\\n}, {\\n    title: \\\"注销\\\",\\n    url: $(\\\"确认注销登陆？\\\").confirm(() => {\\n        deleteFile(\\\"Cookie.txt\\\")\\n        back()\\n        return \\\"hiker://empty\\\"\\n    }),\\n    img: \\\"hiker://images/开关\\\"\\n})\\nif (info.isLogin != false) {\\n    let level = info.level_info\\n    d.push({\\n        title: `当前${level.current_level}级，经验${level.current_exp}\\\\n距离${level.current_level+1}级，还差${level.next_exp-level.current_exp}\\\\n硬币：${info.money}个`,\\n        col_type: \\\"long_text\\\"\\n    })\\n}\\nsetResult(d);\"},{\"col_type\":\"text_2\",\"name\":\"登陆\",\"path\":\"login\",\"rule\":\"let d = []\\nlet k = JSON.parse(request(\\\"http://passport.bilibili.com/x/passport-login/web/qrcode/generate\\\")).data\\nlet key = k.qrcode_key\\nd.push({\\n    title: \\\"点我登陆\\\",\\n    url: k.url,\\n    col_type: \\\"text_2\\\"\\n}, {\\n    title: \\\"输入Cookie登陆\\\",\\n    url: $(\\\"\\\", \\\"输入抓取到的Cookie\\\").input(() => {\\n        if (input.includes(\\\"SESSDATA\\\") && input.includes(\\\"bili_jct\\\")) {\\n            saveFile(\\\"Cookie.txt\\\", input)\\n            refreshPage()\\n        } else {\\n            toast(\\\"请输入正确cookie！\\\")\\n        }\\n    }),\\n    col_type: \\\"text_2\\\"\\n})\\nsetResult(d)\\nlet noLogin = true\\nvar Cookie = \\\"\\\"\\nwhile (noLogin) {\\n    let sta = fetchCookie(buildUrl(\\\"http://passport.bilibili.com/x/passport-login/web/qrcode/poll\\\", {\\n        \\\"qrcode_key\\\": key\\n    }))\\n    if (sta.length > 0) {\\n        JSON.parse(sta).forEach(item => {\\n            Cookie += item.split(\\\";\\\")[0] + \\\";\\\"\\n        })\\n        saveFile(\\\"Cookie.txt\\\", Cookie)\\n        toast(\\\"登陆成功，返回刷新即可\\\")\\n        refreshPage()\\n        break\\n    }\\n    java.lang.Thread.sleep(3000)\\n}\"},{\"col_type\":\"text_1\",\"name\":\"评论\",\"path\":\"Comments\",\"rule\":\"js:\\nvar d = [];\\nlet id = MY_PARAMS.id\\nif (MY_PAGE == 1) {\\n    d.unshift({\\n        title: \\\"发条评论吧\\\",\\n        col_type: \\\"input\\\",\\n        url: $.toString((id) => {\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            post(\\\"http://api.bilibili.com/x/v2/reply/add\\\", {\\n                body: {\\n                    \\\"type\\\": 1,\\n                    \\\"oid\\\": id,\\n                    \\\"csrf\\\": csrf,\\n                    \\\"message\\\": input\\n                },\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n                }\\n            })\\n            refreshPage()\\n        }, id)\\n    })\\n}\\nvar tabs = [\\\"热度\\\", \\\"时间\\\"]\\ntabs.forEach(item => {\\n    d.push({\\n        title: item,\\n        url: $().lazyRule((i) => {\\n            putMyVar(\\\"sortby\\\", i)\\n            refreshPage()\\n            return \\\"hiker://empty\\\"\\n        }, item),\\n        col_type: \\\"scroll_button\\\"\\n    })\\n})\\nlet data = $.require(\\\"hiker://page/api\\\").getComments(id, getMyVar(\\\"sortby\\\", \\\"热度\\\"), MY_PAGE)\\ndata.forEach(item => {\\n    d.push({\\n        title: item.member.uname,\\n        img: item.member.avatar,\\n        url: \\\"hiker://page/ups?mid=\\\" + item.member.mid + \\\"#immersiveTheme#\\\",\\n        col_type: \\\"avatar\\\"\\n    })\\n    d.push({\\n        title: item.content.message,\\n        desc: item.reply_control.location + \\\" \\\" + item.reply_control.time_desc,\\n        url: $().rule((text, oid, rpid) => {\\n            let d = [{\\n                title: text,\\n                col_type: \\\"long_text\\\"\\n            }]\\n            let reply = request(buildUrl(\\\"http://api.bilibili.com/x/v2/reply/reply\\\", {\\n                \\\"type\\\": 1,\\n                \\\"oid\\\": oid,\\n                \\\"root\\\": rpid\\n            }), {\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n                }\\n            })\\n            d.push({\\n                col_type: \\\"line\\\"\\n            })\\n            try {\\n                JSON.parse(reply).data.replies.forEach(item => {\\n\\n                    d.push({\\n                        title: item.member.uname,\\n                        img: item.member.avatar,\\n                        url: \\\"hiker://page/ups?mid=\\\" + item.member.mid + \\\"#immersiveTheme#\\\",\\n                        col_type: \\\"avatar\\\"\\n                    }, {\\n                        title: item.content.message,\\n                        desc: item.reply_control.location + \\\" \\\" + item.reply_control.time_desc,\\n                        col_type: \\\"text_1\\\"\\n                    })\\n                })\\n            } catch (e) {}\\n            setResult(d)\\n        }, item.content.message, id, item.rpid + \\\"\\\")\\n    })\\n})\\nsetResult(d);\"},{\"col_type\":\"movie_2\",\"name\":\"UP主页\",\"path\":\"ups\",\"rule\":\"js:\\nvar d = [];\\nvar mid = getParam(\\\"mid\\\")\\nif (MY_PAGE == 1) {\\n    var info = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/space/acc/info\\\", {\\n        \\\"mid\\\": mid\\n    }), {\\n        headers: {\\n            Cookie: readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data\\n    d.push({\\n        title: info.name,\\n        img: info.face,\\n        desc: info.sign,\\n        url: $().rule((info) => {\\n            setResult([{\\n                title: info,\\n                col_type: \\\"long_text\\\"\\n            }])\\n        }, info.sign),\\n        col_type: \\\"movie_1_vertical_pic_blur\\\"\\n    }, {\\n        title: (info.is_followed ? \\\"取消关注\\\" : \\\"关注\\\"),\\n        col_type: \\\"text_center_1\\\",\\n        url: $().lazyRule((is_followed, mid) => {\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            post(\\\"https://api.bilibili.com/x/relation/modify\\\", {\\n                body: {\\n                    \\\"fid\\\": mid,\\n                    \\\"act\\\": is_followed ? 2 : 1,\\n                    \\\"csrf\\\": csrf\\n                },\\n                headers: {\\n                    Cookie: readFile(\\\"Cookie.txt\\\")\\n                }\\n            })\\n            refreshPage()\\n            return \\\"hiker://empty\\\"\\n        }, info.is_followed, mid)\\n    })\\n}\\n$.require(\\\"hiker://page/api\\\").upVideos(mid, MY_PAGE).data.list.vlist.forEach(item => {\\n    let id = item.aid + \\\"\\\"\\n    let bvid = item.bvid\\n    let p = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/player/pagelist\\\", {\\n        \\\"aid\\\": id\\n    }))).data\\n    d.push({\\n        url: \\\"hiker://page/detail#gameTheme#\\\",\\n        title: item.title,\\n        img: item.pic,\\n        extra: {\\n            \\\"id\\\": id,\\n            \\\"cid\\\": p[0].cid,\\n            \\\"bvid\\\": bvid\\n        }\\n    })\\n})\\nsetResult(d);\"},{\"col_type\":\"movie_2\",\"name\":\"搜索\",\"path\":\"search\",\"rule\":\"js:\\ntry {\\n    var d = [];\\n    var kw = getParam(\\\"kw\\\")\\n    var type = getParam(\\\"type\\\")\\n    var cookie = JSON.parse(fetchCookie(\\\"https://bilibili.com\\\")).join(\\\";\\\")\\n    let res = JSON.parse(request(\\\"http://api.bilibili.com/x/web-interface/search/type?search_type=\\\" + type + \\\"&keyword=\\\" + kw + \\\"&page=\\\" + MY_PAGE, {\\n        headers: {\\n            \\\"Cookie\\\": cookie\\n        }\\n    })).data.result\\n    if (type == \\\"bili_user\\\") {\\n        res.forEach(item => {\\n            d.push({\\n                title: item.uname,\\n                img: \\\"https:\\\" + item.upic,\\n                url: \\\"hiker://page/ups?mid=\\\" + item.mid + \\\"#gameTheme#\\\",\\n                col_type: \\\"avatar\\\"\\n            })\\n        })\\n    } else {\\n        res.forEach(item => {\\n            if (item.is_avid != false) {\\n                var p = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/player/pagelist\\\", {\\n                    \\\"aid\\\": item.aid\\n                }))).data\\n                d.push({\\n                    title: item.title.replace(/<[^>]*>|<\\\\/[^>]*>/gm, \\\"\\\"),\\n                    img: \\\"https:\\\" + item.pic,\\n                    url: \\\"hiker://page/detail#gameTheme#\\\",\\n                    extra: {\\n                        \\\"id\\\": item.aid,\\n                        \\\"bvid\\\": item.bvid,\\n                        \\\"cid\\\": p[0].cid\\n                    }\\n                })\\n            } else {\\n                d.push({\\n                    title: item.title.replace(/<[^>]*>|<\\\\/[^>]*>/gm, \\\"\\\"),\\n                    img: item.cover,\\n                    url: \\\"hiker://page/detaila#gameTheme#\\\",\\n                    extra: {\\n                        \\\"ssid\\\": item.season_id\\n                    }\\n                })\\n            }\\n        })\\n    }\\n} catch (e) {\\n    log(e.message)\\n    setResult([{\\n        title: '““””<center><small><span style=\\\"color: #999999\\\">～～～我是有底线的～～～</span></small></center>',\\n        col_type: \\\"text_center_1\\\",\\n        url: \\\"hiker://empty\\\",\\n        extra: {\\n            lineVisible: false\\n        }\\n    }])\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_2\",\"name\":\"剧集详情\",\"path\":\"detaila\",\"rule\":\"js:\\nvar d = [];\\nvar season_id = MY_PARAMS.ssid + \\\"\\\"\\nvar episode_id = MY_PARAMS.epid + \\\"\\\"\\nlet info = JSON.parse(request(\\\"http://api.bilibili.com/pgc/view/web/season?season_id=\\\" + season_id)).result\\nd.push({\\n    title: info.season_title,\\n    img: info.cover,\\n    desc: info.evaluate,\\n    url: $().rule((text) => {\\n        setResult([{\\n            title: text,\\n            col_type: \\\"long_text\\\"\\n        }])\\n    }, info.evaluate),\\n    col_type: \\\"movie_1_vertical_pic_blur\\\"\\n})\\ninfo.episodes.forEach(item => {\\n    d.push({\\n        title: item.long_title ? item.long_title : item.title,\\n        img: item.cover,\\n        url: \\\"hiker://page/detail#gameTheme#\\\",\\n        extra: {\\n            \\\"id\\\": item.aid,\\n            \\\"cid\\\": item.cid,\\n            \\\"bvid\\\": item.bvid\\n        }\\n    })\\n})\\nsetResult(d);\"},{\"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: #FA7298\\\">' + 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\":\"分类 By Rx\",\"path\":\"cat\",\"rule\":\"const {\\n    CategoriesHeader\\n} = $.require(\\\"hiker://page/categories-header\\\")\\nlet mCategories = {}\\nlet catUrl = 'https://www.bilibili.com/anime/index/'\\nlet catSrc = request(catUrl)\\n// log(catSrc)\\nlet catRegex = /window\\\\.__INITIAL_STATE__=(.*?);\\\\(function\\\\(\\\\)\\\\{/\\nif (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}\\nputVar(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_PAGE\\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,\\n            url: 'hiker://page/detaila#gameTheme#',\\n            col_type: 'movie_3',\\n            extra: {\\n                \\\"media_id\\\": data.media_id,\\n                \\\"ssid\\\": data.season_id\\n            }\\n        });\\n    }\\n} catch (e) {\\n    log(e.message)\\n}\"}],\"params\":\"{\\\"bvid\\\":\\\"BV1kT411R7gX\\\",\\\"cid\\\":1001306746,\\\"id\\\":479196968}\",\"saved\":false,\"title\":\"bilibili\",\"version\":0,\"url\":\"hiker://page/detail#gameTheme#\",\"col_type\":\"movie_1_vertical_pic_blur\",\"find_rule\":\"js:\\nvar d = [];\\ntry {\\n    var id = MY_PARAMS.id + \\\"\\\"\\n    var cid = MY_PARAMS.cid + \\\"\\\"\\n    var bvid = MY_PARAMS.bvid\\n    //视频信息\\n    var r = request(buildUrl(\\\"http://api.bilibili.com/x/web-interface/view\\\", {\\n        \\\"aid\\\": id\\n    }))\\n    let l = JSON.parse(r).data\\n    d.push({\\n        title: l.title,\\n        img: l.pic,\\n        desc: l.desc,\\n        url: $().rule((info) => {\\n            let stat = info.stat\\n            let infos = `av号：${info.aid}\\\\nbv号：${info.bvid}\\\\n播放量：${stat.view}\\\\n点赞：${stat.like}\\\\n投币：${stat.coin}\\\\n收藏：${stat.favorite}\\\\n\\\\n${info.desc}`\\n            setResult([{\\n                title: infos,\\n                col_type: \\\"long_text\\\"\\n            }])\\n        }, l),\\n        extra: {\\n            gradient: true\\n        }\\n    }, {\\n        title: l.owner.name,\\n        img: l.owner.face,\\n        url: \\\"hiker://page/ups?mid=\\\" + l.owner.mid + \\\"&p=fypage#immersiveTheme#\\\",\\n        col_type: \\\"avatar\\\"\\n    }, {\\n        col_type: \\\"line_blank\\\"\\n    })\\n    //视频操作\\n    function color(text, color) {\\n        text += \\\"\\\";\\n        if (text.indexOf(\\\"““””\\\") === 0) {\\n            text.replace(\\\"““””\\\", \\\"\\\");\\n        }\\n        return \\\"““””<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n    }\\n    let stat = l.stat\\n    let like = stat.like\\n    let coin = stat.coin\\n    let favourite = stat.favorite\\n    let hasLike = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/web-interface/archive/has/like\\\", {\\n        \\\"aid\\\": id\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data == 1\\n    let hasCoin = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/web-interface/archive/coins\\\", {\\n        \\\"aid\\\": id\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data.multiply != 0\\n    let hasFavour = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/v2/fav/video/favoured\\\", {\\n        \\\"aid\\\": id\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n        }\\n    })).data.favoured\\n    d.push({\\n        title: (hasLike ? color(like, \\\"#FA7298\\\") : like),\\n        img: \\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/like.svg\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        url: $().lazyRule((id, hasLike) => {\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            let res = post(\\\"http://api.bilibili.com/x/web-interface/archive/like\\\", {\\n                body: {\\n                    \\\"aid\\\": id,\\n                    \\\"like\\\": (hasLike ? 2 : 1),\\n                    \\\"csrf\\\": csrf\\n                },\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n                }\\n            })\\n            refreshPage()\\n            return \\\"toast://\\\" + (hasLike ? \\\"取消点赞\\\" : \\\"点赞成功\\\")\\n        }, id, hasLike)\\n    }, {\\n        title: (hasCoin ? color(coin, \\\"#FA7298\\\") : coin),\\n        img: \\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/coin.svg\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        url: $([\\\"1\\\", \\\"2\\\"], 2, \\\"投币数量\\\").select((id) => {\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            let res = post(\\\"http://api.bilibili.com/x/web-interface/coin/add\\\", {\\n                body: {\\n                    \\\"aid\\\": id,\\n                    \\\"multiply\\\": input,\\n                    \\\"csrf\\\": csrf\\n                },\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\")\\n                }\\n            })\\n            refreshPage()\\n            return \\\"toast://投了\\\" + input + \\\"个币\\\"\\n        }, id)\\n    }, {\\n        title: (hasFavour ? color(favourite, \\\"#FA7298\\\") : favourite),\\n        img: \\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/fav.svg\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        url: $().lazyRule((id, hasFavour) => {\\n            let body = hasFavour ? {\\n                \\\"rid\\\": id,\\n                \\\"type\\\": 2,\\n                \\\"del_media_ids\\\": 0,\\n                \\\"csrf\\\": csrf\\n            } : {\\n                \\\"rid\\\": id,\\n                \\\"type\\\": 2,\\n                \\\"add_media_ids\\\": 0,\\n                \\\"csrf\\\": csrf\\n            }\\n            let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n            let res = post(\\\"http://api.bilibili.com/medialist/gateway/coll/resource/deal\\\", {\\n                body: body,\\n                headers: {\\n                    \\\"Cookie\\\": readFile(\\\"Cookie.txt\\\"),\\n                    \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n                }\\n            })\\n            refreshPage()\\n            return \\\"toast://\\\" + (hasFavour ? \\\"取消收藏\\\" : \\\"收藏成功\\\")\\n        }, id, hasFavour)\\n    }, {\\n        title: \\\"评论\\\",\\n        url: \\\"hiker://page/Comments?p=fypage\\\",\\n        img: \\\"https://lanmeiguojiang.com/tubiao/more/41.png\\\",\\n        col_type: \\\"icon_small_4\\\",\\n        extra: {\\n            \\\"id\\\": id\\n        }\\n    })\\n    //获取视频分P信息\\n    var p = JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/player/pagelist\\\", {\\n        \\\"aid\\\": id\\n    }))).data\\n    if (p.length == 1) {\\n        //视频链接\\n        let a = $.require(\\\"hiker://page/api\\\").getUrl(id, cid, 120)\\n        d.push({\\n            title: \\\"智能播放\\\",\\n            col_type: \\\"text_center_1\\\",\\n            url: $().lazyRule((id, cid) => {\\n                return $.require(\\\"hiker://page/api\\\").lazy(id, cid, 120).replace(/;/g, \\\"；；\\\")\\n            }, id, cid),\\n            extra: {\\n                \\\"longClick\\\": [{\\n                    title: \\\"推送\\\",\\n                    js: $.toString((id, cid) => {\\n                        require(\\\"https://hikerfans.com/Joe/TVbox.js\\\")\\n                        return 推送tvbox({\\n                            name: \\\"推送 by Joe\\\",\\n                            vod: [{\\n                                name: \\\"bilibili\\\",\\n                                urls: JSON.parse($.require(\\\"hiker://page/api\\\").lazy(id, cid, 120).replace(/;/g, \\\"；；\\\")).url\\n                            }],\\n                            headers: {\\n                                \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n                            }\\n                        })\\n                    }, id, cid)\\n                }],\\n                \\\"id\\\": \\\"qn\\\"\\n            }\\n        })\\n        a.support_formats.forEach(item => {\\n            d.push({\\n                title: item.new_description,\\n                url: $().lazyRule((id, cid, qn) => {\\n                    return $.require(\\\"hiker://page/api\\\").lazy(id, cid, qn).replace(/;/g, \\\"；；\\\")\\n                }, id + \\\"\\\", cid + \\\"\\\", item.quality + \\\"\\\"),\\n                col_type: \\\"text_2\\\"\\n            })\\n        })\\n    } else {\\n        p.forEach(item => {\\n            d.push({\\n                title: item.part,\\n                url: $().lazyRule((id, cid) => {\\n                    return $.require(\\\"hiker://page/api\\\").lazy(id, cid, 120).replace(/;/g, \\\"；；\\\")\\n                }, id, item.cid + \\\"\\\"),\\n                col_type: \\\"text_2\\\",\\n                extra: {\\n                    \\\"cid\\\": item.cid,\\n                    \\\"id\\\": id,\\n                    \\\"bvid\\\": bvid\\n                }\\n            })\\n        })\\n    }\\n} catch (e) {\\n    log(e.message)\\n    toast(\\\"程序出现问题，请打开日志查看\\\")\\n}\\nsetResult(d);\",\"group\":\"视频\",\"ua\":\"pc\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"api\\\",\\\"path\\\":\\\"api\\\",\\\"rule\\\":\\\"$.exports.getFeed = function() {\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/web-interface/index/top/feed/rcmd\\\\\\\"\\\\n    let res = JSON.parse(request(u, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    }))\\\\n    return res.data.item\\\\n}\\\\n$.exports.getUserInfo = function() {\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/web-interface/nav\\\\\\\"\\\\n    let res = request(u, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).data\\\\n}\\\\n$.exports.getUrl = function(avid, cid, qn) {\\\\n    let u = request(buildUrl(\\\\\\\"http://api.bilibili.com/x/player/playurl\\\\\\\", {\\\\n        \\\\\\\"avid\\\\\\\": avid,\\\\n        \\\\\\\"cid\\\\\\\": cid,\\\\n        \\\\\\\"qn\\\\\\\": qn,\\\\n        \\\\\\\"fourk\\\\\\\": 1\\\\n    }), {\\\\n        headers: {\\\\n            Cookie: readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n    return JSON.parse(u).data\\\\n}\\\\n$.exports.getHistory = function(page) {\\\\n    let u = buildUrl(\\\\\\\"http://api.bilibili.com/x/v2/history\\\\\\\", {\\\\n        \\\\\\\"pn\\\\\\\": page,\\\\n        \\\\\\\"ps\\\\\\\": 20\\\\n    })\\\\n    let res = request(u, {\\\\n        headers: {\\\\n            Cookie: readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).data\\\\n}\\\\n$.exports.reportProcess = function(avid, cid) {\\\\n    let csrf = readFile(\\\\\\\"Cookie.txt\\\\\\\").match(/bili_jct=(.*?);/)[1]\\\\n    let res = post(\\\\\\\"http://api.bilibili.com/x/v2/history/report\\\\\\\", {\\\\n        body: {\\\\n            \\\\\\\"aid\\\\\\\": avid,\\\\n            \\\\\\\"cid\\\\\\\": cid,\\\\n            \\\\\\\"csrf\\\\\\\": csrf,\\\\n            \\\\\\\"progress\\\\\\\": 0\\\\n        },\\\\n        headers: {\\\\n            Cookie: readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n}\\\\n$.exports.getComments = function(id, sortby, page) {\\\\n    let u = buildUrl(\\\\\\\"http://api.bilibili.com/x/v2/reply\\\\\\\", {\\\\n        \\\\\\\"type\\\\\\\": 1,\\\\n        \\\\\\\"oid\\\\\\\": id,\\\\n        \\\\\\\"pn\\\\\\\": page,\\\\n        \\\\\\\"sort\\\\\\\": sortby == \\\\\\\"热度\\\\\\\" ? 1 : 0\\\\n    })\\\\n    let res = request(u, {\\\\n        headers: {\\\\n            Cookie: readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).data.replies\\\\n}\\\\n$.exports.upVideos = function(mid, page) {\\\\n    let videos = request(\\\\\\\"https://api.bilibili.com/x/space/arc/search?mid=\\\\\\\" + mid + \\\\\\\"&pn=\\\\\\\" + page, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n    return JSON.parse(videos)\\\\n}\\\\n$.exports.getslist = function() {\\\\n    return JSON.parse(request(\\\\\\\"https://api.bilibili.com/x/relation/tags?jsonp=jsonp\\\\\\\", {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })).data\\\\n}\\\\n$.exports.getSubsribes = function(id, page) {\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/relation/tag?pn=\\\\\\\" + page + \\\\\\\"&ps=20&jsonp=jsonp&tagid=\\\\\\\" + id\\\\n    let res = request(u, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).data\\\\n}\\\\n$.exports.getfavteam = function() {\\\\n    return JSON.parse(request(\\\\\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\\\\\", {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })).data\\\\n}\\\\n$.exports.getFavour = function(id, page) {\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/v3/fav/resource/list?media_id=\\\\\\\" + id + \\\\\\\"&pn=\\\\\\\" + page + \\\\\\\"&ps=20&order=mtime&type=0&tid=0\\\\\\\"\\\\n    let res = request(u, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).data\\\\n}\\\\n$.exports.getMovies = function(type, before, after) {\\\\n    let u = buildUrl(\\\\\\\"http://api.bilibili.com/pgc/web/timeline\\\\\\\", {\\\\n        \\\\\\\"types\\\\\\\": type,\\\\n        \\\\\\\"before\\\\\\\": before,\\\\n        \\\\\\\"after\\\\\\\": after\\\\n    })\\\\n    let res = JSON.parse(request(u, {\\\\n        headers: {\\\\n            Cookie: readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    }))\\\\n    return res.result\\\\n}\\\\n$.exports.lazy = function(id, cid, qn) {\\\\n    let d = $.require(\\\\\\\"hiker://page/api\\\\\\\").getUrl(id, cid, qn)\\\\n    $.require(\\\\\\\"hiker://page/api\\\\\\\").reportProcess(id, cid)\\\\n    let u = JSON.stringify({\\\\n        \\\\\\\"urls\\\\\\\": [d.durl[0].url + \\\\\\\"#isVideo=true#\\\\\\\"],\\\\n        \\\\\\\"headers\\\\\\\": [{\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com\\\\\\\",\\\\n            \\\\\\\"User-Agent\\\\\\\": PC_UA\\\\n        }],\\\\n        \\\\\\\"danmu\\\\\\\": `https://comment.bilibili.com/${cid}.xml`,\\\\n        \\\\\\\"extra\\\\\\\": {\\\\n            \\\\\\\"id\\\\\\\": cid\\\\n        }\\\\n    })\\\\n    return u\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_1_vertical_pic_blur\\\",\\\"name\\\":\\\"视频详情\\\",\\\"path\\\":\\\"detail\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\ntry {\\\\n    var id = MY_PARAMS.id + \\\\\\\"\\\\\\\"\\\\n    var cid = MY_PARAMS.cid + \\\\\\\"\\\\\\\"\\\\n    var bvid = MY_PARAMS.bvid\\\\n    //视频信息\\\\n    var r = request(buildUrl(\\\\\\\"http://api.bilibili.com/x/web-interface/view\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": id\\\\n    }))\\\\n    let l = JSON.parse(r).data\\\\n    d.push({\\\\n        title: l.title,\\\\n        img: l.pic,\\\\n        desc: l.desc,\\\\n        url: $().rule((info) => {\\\\n            let stat = info.stat\\\\n            let infos = `av号：${info.aid}\\\\\\\\nbv号：${info.bvid}\\\\\\\\n播放量：${stat.view}\\\\\\\\n点赞：${stat.like}\\\\\\\\n投币：${stat.coin}\\\\\\\\n收藏：${stat.favorite}\\\\\\\\n\\\\\\\\n${info.desc}`\\\\n            setResult([{\\\\n                title: infos,\\\\n                col_type: \\\\\\\"long_text\\\\\\\"\\\\n            }])\\\\n        }, l),\\\\n        extra: {\\\\n            gradient: true\\\\n        }\\\\n    }, {\\\\n        title: l.owner.name,\\\\n        img: l.owner.face,\\\\n        url: \\\\\\\"hiker://page/ups?mid=\\\\\\\" + l.owner.mid + \\\\\\\"&p=fypage#immersiveTheme#\\\\\\\",\\\\n        col_type: \\\\\\\"avatar\\\\\\\"\\\\n    }, {\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\n    })\\\\n    //视频操作\\\\n    function color(text, color) {\\\\n        text += \\\\\\\"\\\\\\\";\\\\n        if (text.indexOf(\\\\\\\"““””\\\\\\\") === 0) {\\\\n            text.replace(\\\\\\\"““””\\\\\\\", \\\\\\\"\\\\\\\");\\\\n        }\\\\n        return \\\\\\\"““””<font color='\\\\\\\" + color + \\\\\\\"'>\\\\\\\" + text + \\\\\\\"</font>\\\\\\\";\\\\n    }\\\\n    let stat = l.stat\\\\n    let like = stat.like\\\\n    let coin = stat.coin\\\\n    let favourite = stat.favorite\\\\n    let hasLike = JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/web-interface/archive/has/like\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": id\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })).data == 1\\\\n    let hasCoin = JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/web-interface/archive/coins\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": id\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })).data.multiply != 0\\\\n    let hasFavour = JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/v2/fav/video/favoured\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": id\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })).data.favoured\\\\n    d.push({\\\\n        title: (hasLike ? color(like, \\\\\\\"#FA7298\\\\\\\") : like),\\\\n        img: \\\\\\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/like.svg\\\\\\\",\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n        url: $().lazyRule((id, hasLike) => {\\\\n            let csrf = readFile(\\\\\\\"Cookie.txt\\\\\\\").match(/bili_jct=(.*?);/)[1]\\\\n            let res = post(\\\\\\\"http://api.bilibili.com/x/web-interface/archive/like\\\\\\\", {\\\\n                body: {\\\\n                    \\\\\\\"aid\\\\\\\": id,\\\\n                    \\\\\\\"like\\\\\\\": (hasLike ? 2 : 1),\\\\n                    \\\\\\\"csrf\\\\\\\": csrf\\\\n                },\\\\n                headers: {\\\\n                    \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n                }\\\\n            })\\\\n            refreshPage()\\\\n            return \\\\\\\"toast://\\\\\\\" + (hasLike ? \\\\\\\"取消点赞\\\\\\\" : \\\\\\\"点赞成功\\\\\\\")\\\\n        }, id, hasLike)\\\\n    }, {\\\\n        title: (hasCoin ? color(coin, \\\\\\\"#FA7298\\\\\\\") : coin),\\\\n        img: \\\\\\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/coin.svg\\\\\\\",\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n        url: $([\\\\\\\"1\\\\\\\", \\\\\\\"2\\\\\\\"], 2, \\\\\\\"投币数量\\\\\\\").select((id) => {\\\\n            let csrf = readFile(\\\\\\\"Cookie.txt\\\\\\\").match(/bili_jct=(.*?);/)[1]\\\\n            let res = post(\\\\\\\"http://api.bilibili.com/x/web-interface/coin/add\\\\\\\", {\\\\n                body: {\\\\n                    \\\\\\\"aid\\\\\\\": id,\\\\n                    \\\\\\\"multiply\\\\\\\": input,\\\\n                    \\\\\\\"csrf\\\\\\\": csrf\\\\n                },\\\\n                headers: {\\\\n                    \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n                }\\\\n            })\\\\n            refreshPage()\\\\n            return \\\\\\\"toast://投了\\\\\\\" + input + \\\\\\\"个币\\\\\\\"\\\\n        }, id)\\\\n    }, {\\\\n        title: (hasFavour ? color(favourite, \\\\\\\"#FA7298\\\\\\\") : favourite),\\\\n        img: \\\\\\\"https://ghproxy.com/https://raw.githubusercontent.com/SocialSisterYi/bilibili-API-collect/master/imgs/fav.svg\\\\\\\",\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n        url: $().lazyRule((id, hasFavour) => {\\\\n            let body = hasFavour ? {\\\\n                \\\\\\\"rid\\\\\\\": id,\\\\n                \\\\\\\"type\\\\\\\": 2,\\\\n                \\\\\\\"del_media_ids\\\\\\\": 0,\\\\n                \\\\\\\"csrf\\\\\\\": csrf\\\\n            } : {\\\\n                \\\\\\\"rid\\\\\\\": id,\\\\n                \\\\\\\"type\\\\\\\": 2,\\\\n                \\\\\\\"add_media_ids\\\\\\\": 0,\\\\n                \\\\\\\"csrf\\\\\\\": csrf\\\\n            }\\\\n            let csrf = readFile(\\\\\\\"Cookie.txt\\\\\\\").match(/bili_jct=(.*?);/)[1]\\\\n            let res = post(\\\\\\\"http://api.bilibili.com/medialist/gateway/coll/resource/deal\\\\\\\", {\\\\n                body: body,\\\\n                headers: {\\\\n                    \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\"),\\\\n                    \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com\\\\\\\"\\\\n                }\\\\n            })\\\\n            refreshPage()\\\\n            return \\\\\\\"toast://\\\\\\\" + (hasFavour ? \\\\\\\"取消收藏\\\\\\\" : \\\\\\\"收藏成功\\\\\\\")\\\\n        }, id, hasFavour)\\\\n    }, {\\\\n        title: \\\\\\\"评论\\\\\\\",\\\\n        url: \\\\\\\"hiker://page/Comments?p=fypage\\\\\\\",\\\\n        img: \\\\\\\"https://lanmeiguojiang.com/tubiao/more/41.png\\\\\\\",\\\\n        col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n        extra: {\\\\n            \\\\\\\"id\\\\\\\": id\\\\n        }\\\\n    })\\\\n    //获取视频分P信息\\\\n    var p = JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/player/pagelist\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": id\\\\n    }))).data\\\\n    if (p.length == 1) {\\\\n        //视频链接\\\\n        let a = $.require(\\\\\\\"hiker://page/api\\\\\\\").getUrl(id, cid, 120)\\\\n        d.push({\\\\n            title: \\\\\\\"智能播放\\\\\\\",\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n            url: $().lazyRule((id, cid) => {\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").lazy(id, cid, 120).replace(/;/g, \\\\\\\"；；\\\\\\\")\\\\n            }, id, cid),\\\\n            extra: {\\\\n                \\\\\\\"longClick\\\\\\\": [{\\\\n                    title: \\\\\\\"推送\\\\\\\",\\\\n                    js: $.toString((id, cid) => {\\\\n                        require(\\\\\\\"https://hikerfans.com/Joe/TVbox.js\\\\\\\")\\\\n                        return 推送tvbox({\\\\n                            name: \\\\\\\"推送 by Joe\\\\\\\",\\\\n                            vod: [{\\\\n                                name: \\\\\\\"bilibili\\\\\\\",\\\\n                                urls: JSON.parse($.require(\\\\\\\"hiker://page/api\\\\\\\").lazy(id, cid, 120).replace(/;/g, \\\\\\\"；；\\\\\\\")).url\\\\n                            }],\\\\n                            headers: {\\\\n                                \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com\\\\\\\"\\\\n                            }\\\\n                        })\\\\n                    }, id, cid)\\\\n                }],\\\\n                \\\\\\\"id\\\\\\\": \\\\\\\"qn\\\\\\\"\\\\n            }\\\\n        })\\\\n        a.support_formats.forEach(item => {\\\\n            d.push({\\\\n                title: item.new_description,\\\\n                url: $().lazyRule((id, cid, qn) => {\\\\n                    return $.require(\\\\\\\"hiker://page/api\\\\\\\").lazy(id, cid, qn).replace(/;/g, \\\\\\\"；；\\\\\\\")\\\\n                }, id + \\\\\\\"\\\\\\\", cid + \\\\\\\"\\\\\\\", item.quality + \\\\\\\"\\\\\\\"),\\\\n                col_type: \\\\\\\"text_2\\\\\\\"\\\\n            })\\\\n        })\\\\n    } else {\\\\n        p.forEach(item => {\\\\n            d.push({\\\\n                title: item.part,\\\\n                url: $().lazyRule((id, cid) => {\\\\n                    return $.require(\\\\\\\"hiker://page/api\\\\\\\").lazy(id, cid, 120).replace(/;/g, \\\\\\\"；；\\\\\\\")\\\\n                }, id, item.cid + \\\\\\\"\\\\\\\"),\\\\n                col_type: \\\\\\\"text_2\\\\\\\",\\\\n                extra: {\\\\n                    \\\\\\\"cid\\\\\\\": item.cid,\\\\n                    \\\\\\\"id\\\\\\\": id,\\\\n                    \\\\\\\"bvid\\\\\\\": bvid\\\\n                }\\\\n            })\\\\n        })\\\\n    }\\\\n} catch (e) {\\\\n    log(e.message)\\\\n    toast(\\\\\\\"程序出现问题，请打开日志查看\\\\\\\")\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"主页\\\",\\\"path\\\":\\\"homepage\\\",\\\"rule\\\":\\\"var d = [];\\\\ntry {\\\\n    const {\\\\n        getFeed,\\\\n        getUserInfo\\\\n    } = $.require(\\\\\\\"hiker://page/api\\\\\\\")\\\\n    if (fileExist(\\\\\\\"Cookie.txt\\\\\\\")) {\\\\n        if (MY_PAGE == 1) {\\\\n            let i = getUserInfo()\\\\n            d.unshift({\\\\n                title: i.uname,\\\\n                img: i.face,\\\\n                col_type: \\\\\\\"avatar\\\\\\\",\\\\n                url: \\\\\\\"hiker://page/userInfo\\\\\\\",\\\\n                extra: {\\\\n                    \\\\\\\"data\\\\\\\": i\\\\n                }\\\\n            })\\\\n\\\\n            function color(text, color) {\\\\n                text += \\\\\\\"\\\\\\\";\\\\n                if (text.indexOf(\\\\\\\"““””\\\\\\\") === 0) {\\\\n                    text.replace(\\\\\\\"““””\\\\\\\", \\\\\\\"\\\\\\\");\\\\n                }\\\\n                return \\\\\\\"““””<font color='\\\\\\\" + color + \\\\\\\"'>\\\\\\\" + text + \\\\\\\"</font>\\\\\\\";\\\\n            }\\\\n            let tabs = {\\\\n                \\\\\\\"推荐\\\\\\\": \\\\\\\"hiker://images/collection\\\\\\\",\\\\n                \\\\\\\"分类\\\\\\\": \\\\\\\"https://lanmeiguojiang.com/tubiao/movie/69.svg\\\\\\\",\\\\n                \\\\\\\"新番\\\\\\\": \\\\\\\"https://lanmeiguojiang.com/tubiao/movie/84.svg\\\\\\\",\\\\n                \\\\\\\"我的\\\\\\\": \\\\\\\"hiker://images/icon3\\\\\\\"\\\\n            }\\\\n            Object.entries(tabs).forEach(item => {\\\\n                d.push({\\\\n                    title: item[0],\\\\n                    img: item[1],\\\\n                    url: $().lazyRule((tab) => {\\\\n                        putMyVar(\\\\\\\"mode\\\\\\\", tab)\\\\n                        refreshPage()\\\\n                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                    }, item[0]),\\\\n                    col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\n                })\\\\n            })\\\\n            d.push({\\\\n                col_type: \\\\\\\"line\\\\\\\"\\\\n            })\\\\n        }\\\\n        let mode = getMyVar(\\\\\\\"mode\\\\\\\", \\\\\\\"推荐\\\\\\\")\\\\n        if (mode == \\\\\\\"推荐\\\\\\\") {\\\\n            getFeed().forEach(item => {\\\\n                let data = JSON.stringify(item)\\\\n                d.push({\\\\n                    title: item.title,\\\\n                    img: item.pic,\\\\n                    desc: item.stat.view + \\\\\\\"播放※\\\\\\\" + item.stat.like + \\\\\\\"点赞\\\\\\\",\\\\n                    url: \\\\\\\"hiker://page/detail#gameTheme#\\\\\\\",\\\\n                    extra: {\\\\n                        \\\\\\\"id\\\\\\\": item.id,\\\\n                        \\\\\\\"bvid\\\\\\\": item.bvid,\\\\n                        \\\\\\\"cid\\\\\\\": item.cid\\\\n                    }\\\\n                })\\\\n            })\\\\n        } else if (mode == \\\\\\\"我的\\\\\\\") {\\\\n            if (MY_PAGE == 1) {\\\\n                d.push({\\\\n                    title: getMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"history\\\\\\\") == \\\\\\\"history\\\\\\\" ? color(\\\\\\\"观看历史\\\\\\\", \\\\\\\"red\\\\\\\") : \\\\\\\"观看历史\\\\\\\",\\\\n                    url: $().lazyRule(() => {\\\\n                        putMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"history\\\\\\\")\\\\n                        refreshPage()\\\\n                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                    }),\\\\n                    col_type: \\\\\\\"text_3\\\\\\\"\\\\n                }, {\\\\n                    title: getMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"history\\\\\\\") == \\\\\\\"fav\\\\\\\" ? color(\\\\\\\"收藏\\\\\\\", \\\\\\\"red\\\\\\\") : \\\\\\\"收藏\\\\\\\",\\\\n                    url: $().lazyRule(() => {\\\\n                        putMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"fav\\\\\\\")\\\\n                        refreshPage()\\\\n                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                    }),\\\\n                    col_type: \\\\\\\"text_3\\\\\\\"\\\\n                }, {\\\\n                    title: getMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"history\\\\\\\") == \\\\\\\"sub\\\\\\\" ? color(\\\\\\\"关注\\\\\\\", \\\\\\\"red\\\\\\\") : \\\\\\\"关注\\\\\\\",\\\\n                    url: $().lazyRule(() => {\\\\n                        putMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"sub\\\\\\\")\\\\n                        refreshPage()\\\\n                        return \\\\\\\"hiker://empty\\\\\\\"\\\\n                    }),\\\\n                    col_type: \\\\\\\"text_3\\\\\\\"\\\\n                })\\\\n            }\\\\n            if (getMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"history\\\\\\\") == \\\\\\\"history\\\\\\\") {\\\\n                const {\\\\n                    getHistory\\\\n                } = $.require(\\\\\\\"hiker://page/api\\\\\\\")\\\\n                getHistory(MY_PAGE).forEach(item => {\\\\n                    d.push({\\\\n                        title: item.title,\\\\n                        img: item.pic,\\\\n                        url: \\\\\\\"hiker://page/detail#immersiveTheme#\\\\\\\",\\\\n                        extra: {\\\\n                            \\\\\\\"id\\\\\\\": item.aid,\\\\n                            \\\\\\\"bvid\\\\\\\": item.bvid,\\\\n                            \\\\\\\"cid\\\\\\\": item.cid\\\\n                        }\\\\n                    })\\\\n                })\\\\n            } else if (getMyVar(\\\\\\\"wd\\\\\\\", \\\\\\\"history\\\\\\\") == \\\\\\\"fav\\\\\\\") {\\\\n                var teams = $.require(\\\\\\\"hiker://page/api\\\\\\\").getfavteam()[0].mediaListResponse.list\\\\n                if (MY_PAGE == 1) {\\\\n                    teams.forEach(item => {\\\\n                        d.push({\\\\n                            title: (getMyVar(\\\\\\\"favo\\\\\\\", teams[0].id + \\\\\\\"\\\\\\\") == item.id ? color(item.title, \\\\\\\"red\\\\\\\") : item.title),\\\\n                            col_type: \\\\\\\"scroll_button\\\\\\\",\\\\n                            url: $().lazyRule((id) => {\\\\n                                putMyVar(\\\\\\\"favo\\\\\\\", id + \\\\\\\"\\\\\\\")\\\\n                                refreshPage()\\\\n                                return \\\\\\\"hiker://empty\\\\\\\"\\\\n                            }, item.id)\\\\n                        })\\\\n                    })\\\\n                }\\\\n                $.require(\\\\\\\"hiker://page/api\\\\\\\").getFavour(getMyVar(\\\\\\\"favo\\\\\\\", teams[0].id + \\\\\\\"\\\\\\\"), MY_PAGE).medias.forEach(item => {\\\\n                    d.push({\\\\n                        title: item.title,\\\\n                        img: item.cover,\\\\n                        url: \\\\\\\"hiker://page/detail#gameTheme#\\\\\\\",\\\\n                        extra: {\\\\n                            \\\\\\\"id\\\\\\\": item.id,\\\\n                            \\\\\\\"cid\\\\\\\": item.ugc.first_cid,\\\\n                            \\\\\\\"bvid\\\\\\\": item.bvid\\\\n                        }\\\\n                    })\\\\n                })\\\\n            } else {\\\\n                if (MY_PAGE == 1) {\\\\n                    $.require(\\\\\\\"hiker://page/api\\\\\\\").getslist().forEach(item => {\\\\n                        d.push({\\\\n                            title: (getMyVar(\\\\\\\"sub\\\\\\\", \\\\\\\"0\\\\\\\") == item.tagid ? color(item.name, \\\\\\\"red\\\\\\\") : item.name),\\\\n                            url: $().lazyRule((id) => {\\\\n                                putMyVar(\\\\\\\"sub\\\\\\\", id)\\\\n                                refreshPage()\\\\n                                return \\\\\\\"hiker://empty\\\\\\\"\\\\n                            }, item.tagid),\\\\n                            col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n                        })\\\\n                    })\\\\n                }\\\\n                $.require(\\\\\\\"hiker://page/api\\\\\\\").getSubsribes(getMyVar(\\\\\\\"sub\\\\\\\", \\\\\\\"0\\\\\\\"), MY_PAGE).forEach(item => {\\\\n                    d.push({\\\\n                        title: item.uname,\\\\n                        img: item.face,\\\\n                        url: \\\\\\\"hiker://page/ups?mid=\\\\\\\" + item.mid + \\\\\\\"&p=fypage#immersiveTheme#\\\\\\\",\\\\n                        col_type: \\\\\\\"avatar\\\\\\\"\\\\n                    })\\\\n                })\\\\n            }\\\\n        } else if (mode == \\\\\\\"新番\\\\\\\") {\\\\n            var tabs = {\\\\n                \\\\\\\"番剧\\\\\\\": 1,\\\\n                \\\\\\\"电影\\\\\\\": 3,\\\\n                \\\\\\\"国创\\\\\\\": 4\\\\n            }\\\\n            if (MY_PAGE == 1) {\\\\n                Object.keys(tabs).forEach(item => {\\\\n                    d.push({\\\\n                        title: (getMyVar(\\\\\\\"juji\\\\\\\", \\\\\\\"番剧\\\\\\\") == item ? color(item, \\\\\\\"red\\\\\\\") : item),\\\\n                        url: $().lazyRule((a) => {\\\\n                            putMyVar(\\\\\\\"juji\\\\\\\", a)\\\\n                            refreshPage()\\\\n                            return \\\\\\\"toast://切换成功\\\\\\\"\\\\n                        }, item),\\\\n                        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n                    })\\\\n                })\\\\n                d.push({\\\\n                    col_type: \\\\\\\"line\\\\\\\"\\\\n                })\\\\n                let days = 7\\\\n                for (let i = 1; i < days + 1; i++) {\\\\n                    d.push({\\\\n                        title: (getMyVar(\\\\\\\"from\\\\\\\", \\\\\\\"1\\\\\\\") == i + \\\\\\\"\\\\\\\" ? color(i + \\\\\\\"天前\\\\\\\", \\\\\\\"red\\\\\\\") : i + \\\\\\\"天前\\\\\\\"),\\\\n                        url: $().lazyRule((i) => {\\\\n                            putMyVar(\\\\\\\"from\\\\\\\", i + \\\\\\\"\\\\\\\")\\\\n                            refreshPage()\\\\n                            return \\\\\\\"hiker://empty\\\\\\\"\\\\n                        }, i),\\\\n                        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n                    })\\\\n                }\\\\n                d.push({\\\\n                    col_type: \\\\\\\"line\\\\\\\"\\\\n                })\\\\n                for (let i = 1; i < days; i++) {\\\\n                    d.push({\\\\n                        title: (getMyVar(\\\\\\\"to\\\\\\\", \\\\\\\"1\\\\\\\") == i + \\\\\\\"\\\\\\\" ? color(i + \\\\\\\"天后\\\\\\\", \\\\\\\"red\\\\\\\") : i + \\\\\\\"天后\\\\\\\"),\\\\n                        url: $().lazyRule((i) => {\\\\n                            putMyVar(\\\\\\\"to\\\\\\\", i + \\\\\\\"\\\\\\\")\\\\n                            refreshPage()\\\\n                            return \\\\\\\"hiker://empty\\\\\\\"\\\\n                        }, i),\\\\n                        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n                    })\\\\n                }\\\\n\\\\n                $.require(\\\\\\\"hiker://page/api\\\\\\\").getMovies(tabs[getMyVar(\\\\\\\"juji\\\\\\\", \\\\\\\"番剧\\\\\\\")], getMyVar(\\\\\\\"from\\\\\\\", \\\\\\\"1\\\\\\\"), getMyVar(\\\\\\\"to\\\\\\\", \\\\\\\"1\\\\\\\")).forEach(item => {\\\\n                    d.push({\\\\n                        title: item.date + \\\\\\\" 周\\\\\\\" + item.day_of_week,\\\\n                        col_type: \\\\\\\"text_1\\\\\\\",\\\\n                        url: \\\\\\\"hiker://empty\\\\\\\"\\\\n                    })\\\\n                    item.episodes.forEach(i => {\\\\n                        d.push({\\\\n                            title: i.title,\\\\n                            img: i.cover,\\\\n                            url: \\\\\\\"hiker://page/detaila#gameTheme#\\\\\\\",\\\\n                            extra: {\\\\n                                \\\\\\\"ssid\\\\\\\": i.season_id,\\\\n                                \\\\\\\"epid\\\\\\\": i.episode_id\\\\n                            }\\\\n                        })\\\\n                    })\\\\n                })\\\\n            }\\\\n        } else if (mode = \\\\\\\"分类\\\\\\\") {\\\\n            eval(JSON.parse(fetch(\\\\\\\"hiker://page/cat\\\\\\\")).rule)\\\\n        }\\\\n    } else {\\\\n        if (getItem(\\\\\\\"fs\\\\\\\", \\\\\\\"0\\\\\\\") == \\\\\\\"0\\\\\\\") {\\\\n            let a = []\\\\n            let time = 10\\\\n            a.push({\\\\n                title: `                     使用前须知\\\\n本规则调用https://github.com/SocialSisterYi/bilibili-API-collect的api，所有代码全部开源，并且不存在上传用户信息的行为\\\\n本规则为学习目的，请于导入24小时内删除！！！                        \\\\n开始使用本规则即代表遵守规则                       \\\\n            `,\\\\n                \\\\\\\"col_type\\\\\\\": \\\\\\\"long_text\\\\\\\",\\\\n                extra: {\\\\n                    id: \\\\\\\"text\\\\\\\"\\\\n                }\\\\n            }, {\\\\n                title: time + \\\\\\\"秒后继续\\\\\\\",\\\\n                col_type: \\\\\\\"text_1\\\\\\\",\\\\n                extra: {\\\\n                    id: \\\\\\\"timer\\\\\\\"\\\\n                }\\\\n            })\\\\n            setResult(a)\\\\n            while (time != 0) {\\\\n                java.lang.Thread.sleep(1000)\\\\n                time -= 1\\\\n                updateItem(\\\\\\\"timer\\\\\\\", {\\\\n                    title: time + \\\\\\\"秒后继续\\\\\\\"\\\\n                })\\\\n            }\\\\n            updateItem(\\\\\\\"timer\\\\\\\", {\\\\n                title: \\\\\\\"我已知晓\\\\\\\",\\\\n                url: $().lazyRule(() => {\\\\n                    setItem(\\\\\\\"fs\\\\\\\", \\\\\\\"1\\\\\\\")\\\\n                    refreshPage()\\\\n                    return \\\\\\\"toast://你已确认\\\\\\\"\\\\n                })\\\\n            })\\\\n        } else {\\\\n            $.require(\\\\\\\"hiker://page/login\\\\\\\")\\\\n        }\\\\n    }\\\\n} catch (e) {\\\\n    log(e.message)\\\\n    d.push({\\\\n        title: '““””<center><small><span style=\\\\\\\"color: #999999\\\\\\\">～～～我是有底线的～～～</span></small></center>',\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        extra: {\\\\n            lineVisible: false\\\\n        }\\\\n    })\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"icon_2_round\\\",\\\"name\\\":\\\"用户详情\\\",\\\"path\\\":\\\"userInfo\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet info = MY_PARAMS.data\\\\nd.push({\\\\n    title: info.uname,\\\\n    img: info.face,\\\\n    url: \\\\\\\"hiker://empty\\\\\\\"\\\\n}, {\\\\n    title: \\\\\\\"注销\\\\\\\",\\\\n    url: $(\\\\\\\"确认注销登陆？\\\\\\\").confirm(() => {\\\\n        deleteFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        back()\\\\n        return \\\\\\\"hiker://empty\\\\\\\"\\\\n    }),\\\\n    img: \\\\\\\"hiker://images/开关\\\\\\\"\\\\n})\\\\nif (info.isLogin != false) {\\\\n    let level = info.level_info\\\\n    d.push({\\\\n        title: `当前${level.current_level}级，经验${level.current_exp}\\\\\\\\n距离${level.current_level+1}级，还差${level.next_exp-level.current_exp}\\\\\\\\n硬币：${info.money}个`,\\\\n        col_type: \\\\\\\"long_text\\\\\\\"\\\\n    })\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"text_2\\\",\\\"name\\\":\\\"登陆\\\",\\\"path\\\":\\\"login\\\",\\\"rule\\\":\\\"let d = []\\\\nlet k = JSON.parse(request(\\\\\\\"http://passport.bilibili.com/x/passport-login/web/qrcode/generate\\\\\\\")).data\\\\nlet key = k.qrcode_key\\\\nd.push({\\\\n    title: \\\\\\\"点我登陆\\\\\\\",\\\\n    url: k.url,\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n}, {\\\\n    title: \\\\\\\"输入Cookie登陆\\\\\\\",\\\\n    url: $(\\\\\\\"\\\\\\\", \\\\\\\"输入抓取到的Cookie\\\\\\\").input(() => {\\\\n        if (input.includes(\\\\\\\"SESSDATA\\\\\\\") && input.includes(\\\\\\\"bili_jct\\\\\\\")) {\\\\n            saveFile(\\\\\\\"Cookie.txt\\\\\\\", input)\\\\n            refreshPage()\\\\n        } else {\\\\n            toast(\\\\\\\"请输入正确cookie！\\\\\\\")\\\\n        }\\\\n    }),\\\\n    col_type: \\\\\\\"text_2\\\\\\\"\\\\n})\\\\nsetResult(d)\\\\nlet noLogin = true\\\\nvar Cookie = \\\\\\\"\\\\\\\"\\\\nwhile (noLogin) {\\\\n    let sta = fetchCookie(buildUrl(\\\\\\\"http://passport.bilibili.com/x/passport-login/web/qrcode/poll\\\\\\\", {\\\\n        \\\\\\\"qrcode_key\\\\\\\": key\\\\n    }))\\\\n    if (sta.length > 0) {\\\\n        JSON.parse(sta).forEach(item => {\\\\n            Cookie += item.split(\\\\\\\";\\\\\\\")[0] + \\\\\\\";\\\\\\\"\\\\n        })\\\\n        saveFile(\\\\\\\"Cookie.txt\\\\\\\", Cookie)\\\\n        toast(\\\\\\\"登陆成功，返回刷新即可\\\\\\\")\\\\n        refreshPage()\\\\n        break\\\\n    }\\\\n    java.lang.Thread.sleep(3000)\\\\n}\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"评论\\\",\\\"path\\\":\\\"Comments\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nlet id = MY_PARAMS.id\\\\nif (MY_PAGE == 1) {\\\\n    d.unshift({\\\\n        title: \\\\\\\"发条评论吧\\\\\\\",\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n        url: $.toString((id) => {\\\\n            let csrf = readFile(\\\\\\\"Cookie.txt\\\\\\\").match(/bili_jct=(.*?);/)[1]\\\\n            post(\\\\\\\"http://api.bilibili.com/x/v2/reply/add\\\\\\\", {\\\\n                body: {\\\\n                    \\\\\\\"type\\\\\\\": 1,\\\\n                    \\\\\\\"oid\\\\\\\": id,\\\\n                    \\\\\\\"csrf\\\\\\\": csrf,\\\\n                    \\\\\\\"message\\\\\\\": input\\\\n                },\\\\n                headers: {\\\\n                    \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n                }\\\\n            })\\\\n            refreshPage()\\\\n        }, id)\\\\n    })\\\\n}\\\\nvar tabs = [\\\\\\\"热度\\\\\\\", \\\\\\\"时间\\\\\\\"]\\\\ntabs.forEach(item => {\\\\n    d.push({\\\\n        title: item,\\\\n        url: $().lazyRule((i) => {\\\\n            putMyVar(\\\\\\\"sortby\\\\\\\", i)\\\\n            refreshPage()\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, item),\\\\n        col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n    })\\\\n})\\\\nlet data = $.require(\\\\\\\"hiker://page/api\\\\\\\").getComments(id, getMyVar(\\\\\\\"sortby\\\\\\\", \\\\\\\"热度\\\\\\\"), MY_PAGE)\\\\ndata.forEach(item => {\\\\n    d.push({\\\\n        title: item.member.uname,\\\\n        img: item.member.avatar,\\\\n        url: \\\\\\\"hiker://page/ups?mid=\\\\\\\" + item.member.mid + \\\\\\\"#immersiveTheme#\\\\\\\",\\\\n        col_type: \\\\\\\"avatar\\\\\\\"\\\\n    })\\\\n    d.push({\\\\n        title: item.content.message,\\\\n        desc: item.reply_control.location + \\\\\\\" \\\\\\\" + item.reply_control.time_desc,\\\\n        url: $().rule((text, oid, rpid) => {\\\\n            let d = [{\\\\n                title: text,\\\\n                col_type: \\\\\\\"long_text\\\\\\\"\\\\n            }]\\\\n            let reply = request(buildUrl(\\\\\\\"http://api.bilibili.com/x/v2/reply/reply\\\\\\\", {\\\\n                \\\\\\\"type\\\\\\\": 1,\\\\n                \\\\\\\"oid\\\\\\\": oid,\\\\n                \\\\\\\"root\\\\\\\": rpid\\\\n            }), {\\\\n                headers: {\\\\n                    \\\\\\\"Cookie\\\\\\\": readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n                }\\\\n            })\\\\n            d.push({\\\\n                col_type: \\\\\\\"line\\\\\\\"\\\\n            })\\\\n            try {\\\\n                JSON.parse(reply).data.replies.forEach(item => {\\\\n\\\\n                    d.push({\\\\n                        title: item.member.uname,\\\\n                        img: item.member.avatar,\\\\n                        url: \\\\\\\"hiker://page/ups?mid=\\\\\\\" + item.member.mid + \\\\\\\"#immersiveTheme#\\\\\\\",\\\\n                        col_type: \\\\\\\"avatar\\\\\\\"\\\\n                    }, {\\\\n                        title: item.content.message,\\\\n                        desc: item.reply_control.location + \\\\\\\" \\\\\\\" + item.reply_control.time_desc,\\\\n                        col_type: \\\\\\\"text_1\\\\\\\"\\\\n                    })\\\\n                })\\\\n            } catch (e) {}\\\\n            setResult(d)\\\\n        }, item.content.message, id, item.rpid + \\\\\\\"\\\\\\\")\\\\n    })\\\\n})\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"UP主页\\\",\\\"path\\\":\\\"ups\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar mid = getParam(\\\\\\\"mid\\\\\\\")\\\\nif (MY_PAGE == 1) {\\\\n    var info = JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/space/acc/info\\\\\\\", {\\\\n        \\\\\\\"mid\\\\\\\": mid\\\\n    }), {\\\\n        headers: {\\\\n            Cookie: readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n        }\\\\n    })).data\\\\n    d.push({\\\\n        title: info.name,\\\\n        img: info.face,\\\\n        desc: info.sign,\\\\n        url: $().rule((info) => {\\\\n            setResult([{\\\\n                title: info,\\\\n                col_type: \\\\\\\"long_text\\\\\\\"\\\\n            }])\\\\n        }, info.sign),\\\\n        col_type: \\\\\\\"movie_1_vertical_pic_blur\\\\\\\"\\\\n    }, {\\\\n        title: (info.is_followed ? \\\\\\\"取消关注\\\\\\\" : \\\\\\\"关注\\\\\\\"),\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: $().lazyRule((is_followed, mid) => {\\\\n            let csrf = readFile(\\\\\\\"Cookie.txt\\\\\\\").match(/bili_jct=(.*?);/)[1]\\\\n            post(\\\\\\\"https://api.bilibili.com/x/relation/modify\\\\\\\", {\\\\n                body: {\\\\n                    \\\\\\\"fid\\\\\\\": mid,\\\\n                    \\\\\\\"act\\\\\\\": is_followed ? 2 : 1,\\\\n                    \\\\\\\"csrf\\\\\\\": csrf\\\\n                },\\\\n                headers: {\\\\n                    Cookie: readFile(\\\\\\\"Cookie.txt\\\\\\\")\\\\n                }\\\\n            })\\\\n            refreshPage()\\\\n            return \\\\\\\"hiker://empty\\\\\\\"\\\\n        }, info.is_followed, mid)\\\\n    })\\\\n}\\\\n$.require(\\\\\\\"hiker://page/api\\\\\\\").upVideos(mid, MY_PAGE).data.list.vlist.forEach(item => {\\\\n    let id = item.aid + \\\\\\\"\\\\\\\"\\\\n    let bvid = item.bvid\\\\n    let p = JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/player/pagelist\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": id\\\\n    }))).data\\\\n    d.push({\\\\n        url: \\\\\\\"hiker://page/detail#gameTheme#\\\\\\\",\\\\n        title: item.title,\\\\n        img: item.pic,\\\\n        extra: {\\\\n            \\\\\\\"id\\\\\\\": id,\\\\n            \\\\\\\"cid\\\\\\\": p[0].cid,\\\\n            \\\\\\\"bvid\\\\\\\": bvid\\\\n        }\\\\n    })\\\\n})\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"搜索\\\",\\\"path\\\":\\\"search\\\",\\\"rule\\\":\\\"js:\\\\ntry {\\\\n    var d = [];\\\\n    var kw = getParam(\\\\\\\"kw\\\\\\\")\\\\n    var type = getParam(\\\\\\\"type\\\\\\\")\\\\n    var cookie = JSON.parse(fetchCookie(\\\\\\\"https://bilibili.com\\\\\\\")).join(\\\\\\\";\\\\\\\")\\\\n    let res = JSON.parse(request(\\\\\\\"http://api.bilibili.com/x/web-interface/search/type?search_type=\\\\\\\" + type + \\\\\\\"&keyword=\\\\\\\" + kw + \\\\\\\"&page=\\\\\\\" + MY_PAGE, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": cookie\\\\n        }\\\\n    })).data.result\\\\n    if (type == \\\\\\\"bili_user\\\\\\\") {\\\\n        res.forEach(item => {\\\\n            d.push({\\\\n                title: item.uname,\\\\n                img: \\\\\\\"https:\\\\\\\" + item.upic,\\\\n                url: \\\\\\\"hiker://page/ups?mid=\\\\\\\" + item.mid + \\\\\\\"#gameTheme#\\\\\\\",\\\\n                col_type: \\\\\\\"avatar\\\\\\\"\\\\n            })\\\\n        })\\\\n    } else {\\\\n        res.forEach(item => {\\\\n            if (item.is_avid != false) {\\\\n                var p = JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/player/pagelist\\\\\\\", {\\\\n                    \\\\\\\"aid\\\\\\\": item.aid\\\\n                }))).data\\\\n                d.push({\\\\n                    title: item.title.replace(/<[^>]*>|<\\\\\\\\/[^>]*>/gm, \\\\\\\"\\\\\\\"),\\\\n                    img: \\\\\\\"https:\\\\\\\" + item.pic,\\\\n                    url: \\\\\\\"hiker://page/detail#gameTheme#\\\\\\\",\\\\n                    extra: {\\\\n                        \\\\\\\"id\\\\\\\": item.aid,\\\\n                        \\\\\\\"bvid\\\\\\\": item.bvid,\\\\n                        \\\\\\\"cid\\\\\\\": p[0].cid\\\\n                    }\\\\n                })\\\\n            } else {\\\\n                d.push({\\\\n                    title: item.title.replace(/<[^>]*>|<\\\\\\\\/[^>]*>/gm, \\\\\\\"\\\\\\\"),\\\\n                    img: item.cover,\\\\n                    url: \\\\\\\"hiker://page/detaila#gameTheme#\\\\\\\",\\\\n                    extra: {\\\\n                        \\\\\\\"ssid\\\\\\\": item.season_id\\\\n                    }\\\\n                })\\\\n            }\\\\n        })\\\\n    }\\\\n} catch (e) {\\\\n    log(e.message)\\\\n    setResult([{\\\\n        title: '““””<center><small><span style=\\\\\\\"color: #999999\\\\\\\">～～～我是有底线的～～～</span></small></center>',\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n        extra: {\\\\n            lineVisible: false\\\\n        }\\\\n    }])\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"剧集详情\\\",\\\"path\\\":\\\"detaila\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\nvar season_id = MY_PARAMS.ssid + \\\\\\\"\\\\\\\"\\\\nvar episode_id = MY_PARAMS.epid + \\\\\\\"\\\\\\\"\\\\nlet info = JSON.parse(request(\\\\\\\"http://api.bilibili.com/pgc/view/web/season?season_id=\\\\\\\" + season_id)).result\\\\nd.push({\\\\n    title: info.season_title,\\\\n    img: info.cover,\\\\n    desc: info.evaluate,\\\\n    url: $().rule((text) => {\\\\n        setResult([{\\\\n            title: text,\\\\n            col_type: \\\\\\\"long_text\\\\\\\"\\\\n        }])\\\\n    }, info.evaluate),\\\\n    col_type: \\\\\\\"movie_1_vertical_pic_blur\\\\\\\"\\\\n})\\\\ninfo.episodes.forEach(item => {\\\\n    d.push({\\\\n        title: item.long_title ? item.long_title : item.title,\\\\n        img: item.cover,\\\\n        url: \\\\\\\"hiker://page/detail#gameTheme#\\\\\\\",\\\\n        extra: {\\\\n            \\\\\\\"id\\\\\\\": item.aid,\\\\n            \\\\\\\"cid\\\\\\\": item.cid,\\\\n            \\\\\\\"bvid\\\\\\\": item.bvid\\\\n        }\\\\n    })\\\\n})\\\\nsetResult(d);\\\"},{\\\"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: #FA7298\\\\\\\">' + 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\\\":\\\"分类 By Rx\\\",\\\"path\\\":\\\"cat\\\",\\\"rule\\\":\\\"const {\\\\n    CategoriesHeader\\\\n} = $.require(\\\\\\\"hiker://page/categories-header\\\\\\\")\\\\nlet mCategories = {}\\\\nlet catUrl = 'https://www.bilibili.com/anime/index/'\\\\nlet catSrc = request(catUrl)\\\\n// log(catSrc)\\\\nlet catRegex = /window\\\\\\\\.__INITIAL_STATE__=(.*?);\\\\\\\\(function\\\\\\\\(\\\\\\\\)\\\\\\\\{/\\\\nif (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}\\\\nputVar(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_PAGE\\\\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,\\\\n            url: 'hiker://page/detaila#gameTheme#',\\\\n            col_type: 'movie_3',\\\\n            extra: {\\\\n                \\\\\\\"media_id\\\\\\\": data.media_id,\\\\n                \\\\\\\"ssid\\\\\\\": data.season_id\\\\n            }\\\\n        });\\\\n    }\\\\n} catch (e) {\\\\n    log(e.message)\\\\n}\\\"}]\",\"proxy\":\"\"}","picUrl":"http://i0.hdslb.com/bfs/archive/acd5eb7a323b44bed5cabcc17e48700fa9ac4f9c.png","title":"冰属性男子和酷酷女同事-妹妹登场！滑雪场的圣诞节"}
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!