API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：【封茗囧菌】今晚月色，扑朔迷离般《朦胧》

xiaomianao666
Oct 3rd, 2022
94
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 495.14 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥【封茗囧菌】今晚月色，扑朔迷离般《朦胧》@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"分类片库\",\"path\":\"vault\",\"rule\":\"顶部大类 = ['国创', '电视', '纪录片', '综艺', '番剧', '电影']\\n\\nif (page == 1) {\\n\\n    // 折叠开关\\n\\n    d.push({\\n\\n        title: getMyVar('折叠', '关') == '关' ? '““””<b><span style=\\\"color: #FF0000\\\">∨</span></b>' : '““””<b><span style=\\\"color: #1aad19\\\">∧</span></b>',\\n\\n        url: $('#noLoading#').lazyRule(() => {\\n\\n            if (getMyVar('折叠', '关') == '开') {\\n\\n                putMyVar('折叠', '关');\\n\\n            } else {\\n\\n                putMyVar('折叠', '开');\\n\\n            }\\n\\n            refreshPage(true);\\n\\n            return \\\"hiker://empty\\\";\\n\\n        }),\\n\\n        col_type: 'scroll_button',\\n\\n    })\\n\\n    顶部大类.forEach(li => {\\n\\n        d.push({\\n\\n            title: li == getMyVar('大类', '国创') ? '““””<b><font color=#1aad19>' + li + '</font></b>' : li,\\n\\n            url: $('#noLoading#').lazyRule((li) => {\\n\\n                putMyVar('大类', li);\\n\\n                refreshPage(true);\\n\\n                return \\\"hiker://empty\\\";\\n\\n            }, li),\\n\\n            col_type: 'scroll_button',\\n\\n        })\\n\\n    });\\n\\n    d.push({\\n\\n        col_type: 'blank_block'\\n\\n    })\\n\\n}\\n\\n// 顶部分类参数映射\\n\\nswitch (getMyVar('大类', '国创')) {\\n\\n    case '国创':\\n\\n        seasonType = 4;\\n\\n        if (getMyVar('折叠', '关') == '开') {\\n\\n            if (page == 1) {\\n\\n                html = fetch('https://www.bilibili.com/guochuang/index');\\n\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\n\\n                分类列表.forEach(ul => {\\n\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\n\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\n\\n                    子分类列表.forEach(li => {\\n\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\n\\n                            return;\\n\\n                        }\\n\\n                        d.push({\\n\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\n\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\n\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, li, 筛选条件),\\n\\n                            col_type: 'scroll_button'\\n\\n                        })\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'blank_block'\\n\\n                    })\\n\\n                });\\n\\n            }\\n\\n        }\\n\\n        break;\\n\\n    case '电视':\\n\\n        seasonType = 5;\\n\\n        if (getMyVar('折叠', '关') == '开') {\\n\\n            if (page == 1) {\\n\\n                html = fetch('https://www.bilibili.com/tv/index');\\n\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\n\\n                分类列表.forEach(ul => {\\n\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\n\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\n\\n                    子分类列表.forEach(li => {\\n\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\n\\n                            return;\\n\\n                        }\\n\\n                        d.push({\\n\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\n\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\n\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, li, 筛选条件),\\n\\n                            col_type: 'scroll_button'\\n\\n                        })\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'blank_block'\\n\\n                    })\\n\\n                });\\n\\n            }\\n\\n        }\\n\\n        break;\\n\\n    case '纪录片':\\n\\n        seasonType = 3;\\n\\n        if (getMyVar('折叠', '关') == '开') {\\n\\n            if (page == 1) {\\n\\n                html = fetch('https://www.bilibili.com/documentary/index/');\\n\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\n\\n                分类列表.forEach(ul => {\\n\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\n\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\n\\n                    子分类列表.forEach(li => {\\n\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\n\\n                            return;\\n\\n                        }\\n\\n                        d.push({\\n\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\n\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\n\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, li, 筛选条件),\\n\\n                            col_type: 'scroll_button'\\n\\n                        })\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'blank_block'\\n\\n                    })\\n\\n                });\\n\\n            }\\n\\n        }\\n\\n        break;\\n\\n    case '综艺':\\n\\n        seasonType = 7;\\n\\n        if (getMyVar('折叠', '关') == '开') {\\n\\n            if (page == 1) {\\n\\n                html = fetch('https://www.bilibili.com/variety/index');\\n\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\n\\n                分类列表.forEach(ul => {\\n\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\n\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\n\\n                    子分类列表.forEach(li => {\\n\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\n\\n                            return;\\n\\n                        }\\n\\n                        d.push({\\n\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\n\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\n\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, li, 筛选条件),\\n\\n                            col_type: 'scroll_button'\\n\\n                        })\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'blank_block'\\n\\n                    })\\n\\n                });\\n\\n            }\\n\\n        }\\n\\n        break;\\n\\n    case '番剧':\\n\\n        seasonType = 1;\\n\\n        if (getMyVar('折叠', '关') == '开') {\\n\\n            if (page == 1) {\\n\\n                html = fetch('https://www.bilibili.com/anime/index');\\n\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\n\\n                分类列表.forEach(ul => {\\n\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\n\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\n\\n                    子分类列表.forEach(li => {\\n\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\n\\n                            return;\\n\\n                        }\\n\\n                        d.push({\\n\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\n\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\n\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, li, 筛选条件),\\n\\n                            col_type: 'scroll_button'\\n\\n                        })\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'blank_block'\\n\\n                    })\\n\\n                });\\n\\n            }\\n\\n        }\\n\\n        break;\\n\\n    case '电影':\\n\\n        seasonType = 2;\\n\\n        if (getMyVar('折叠', '关') == '开') {\\n\\n            if (page == 1) {\\n\\n                html = fetch('https://www.bilibili.com/movie/index');\\n\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\n\\n                分类列表.forEach(ul => {\\n\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\n\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\n\\n                    子分类列表.forEach(li => {\\n\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\n\\n                            return;\\n\\n                        }\\n\\n                        d.push({\\n\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\n\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\n\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, li, 筛选条件),\\n\\n                            col_type: 'scroll_button'\\n\\n                        })\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'blank_block'\\n\\n                    })\\n\\n                });\\n\\n            }\\n\\n        }\\n\\n        break;\\n\\n    default:\\n\\n        seasonType = 4;\\n\\n        if (getMyVar('折叠', '关') == '开') {\\n\\n            if (page == 1) {\\n\\n                html = fetch('https://www.bilibili.com/anime/index');\\n\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\n\\n                分类列表.forEach(ul => {\\n\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\n\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\n\\n                    子分类列表.forEach(li => {\\n\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\n\\n                            return;\\n\\n                        }\\n\\n                        d.push({\\n\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\n\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\n\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, li, 筛选条件),\\n\\n                            col_type: 'scroll_button'\\n\\n                        })\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'blank_block'\\n\\n                    })\\n\\n                });\\n\\n            }\\n\\n        }\\n\\n        break;\\n\\n}\\n\\n// 子分类参数映射\\n\\nswitch (getMyVar('类型', '全部')) {\\n\\n    case '正片':\\n\\n        season_version = 1;\\n\\n        break;\\n\\n    case '电影':\\n\\n        season_version = 2;\\n\\n        break;\\n\\n    case '其他':\\n\\n        season_version = 3;\\n\\n        break;\\n\\n    default:\\n\\n        season_version = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('配音', '全部')) {\\n\\n    case '原声':\\n\\n        spoken_language_type = 1;\\n\\n        break;\\n\\n    case '中文配音':\\n\\n        spoken_language_type = 2;\\n\\n        break;\\n\\n    default:\\n\\n        spoken_language_type = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('地区', '全部')) {\\n\\n    case '中国大陆':\\n\\n        area = 1;\\n\\n        break;\\n\\n    case '日本':\\n\\n        area = 2;\\n\\n        break;\\n\\n    case '美国':\\n\\n        area = 3;\\n\\n        break;\\n\\n    case '英国':\\n\\n        area = 4;\\n\\n        break;\\n\\n    case '中国港台':\\n\\n        area = [6, 7];\\n\\n        break;\\n\\n    case '韩国':\\n\\n        area = 8;\\n\\n        break;\\n\\n    case '法国':\\n\\n        area = 9;\\n\\n        break;\\n\\n    case '泰国':\\n\\n        area = 10;\\n\\n        break;\\n\\n    case '西班牙':\\n\\n        area = 13;\\n\\n        break;\\n\\n    case '德国':\\n\\n        area = 15;\\n\\n        break;\\n\\n    case '意大利':\\n\\n        area = 35;\\n\\n        break;\\n\\n    case '其他':\\n\\n        // 只是番剧的情况_共55，要减去出现的——算了，直接在动态分类的时候去掉了\\n\\n        area = [1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55];\\n\\n        break;\\n\\n    default:\\n\\n        area = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('状态', '全部')) {\\n\\n    case '完结':\\n\\n        is_finish = 1;\\n\\n        break;\\n\\n    case '连载':\\n\\n        is_finish = 0;\\n\\n        break;\\n\\n    default:\\n\\n        is_finish = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('出品', '全部')) {\\n\\n    case '央视':\\n\\n        producer_id = 4;\\n\\n        break;\\n\\n    case 'BBC':\\n\\n        producer_id = 1;\\n\\n        break;\\n\\n    case '探索频道':\\n\\n        producer_id = 7;\\n\\n        break;\\n\\n    case '国家地理':\\n\\n        producer_id = 14;\\n\\n        break;\\n\\n    case 'NHK':\\n\\n        producer_id = 2;\\n\\n        break;\\n\\n    case '历史频道':\\n\\n        producer_id = 6;\\n\\n        break;\\n\\n    case '卫视':\\n\\n        producer_id = 8;\\n\\n        break;\\n\\n    case '自制':\\n\\n        producer_id = 9;\\n\\n        break;\\n\\n    case 'ITV':\\n\\n        producer_id = 5;\\n\\n        break;\\n\\n    case 'SKY':\\n\\n        producer_id = 3;\\n\\n        break;\\n\\n    case 'ZDF':\\n\\n        producer_id = 10;\\n\\n        break;\\n\\n    case '合作机构':\\n\\n        producer_id = 11;\\n\\n        break;\\n\\n    case '国内其他':\\n\\n        producer_id = 12;\\n\\n        break;\\n\\n    case '国外其它':\\n\\n        producer_id = 13;\\n\\n        break;\\n\\n    default:\\n\\n        producer_id = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('版权', '全部')) {\\n\\n    case '独家':\\n\\n        copyright = 3;\\n\\n        break;\\n\\n    case '其他':\\n\\n        copyright = [1, 2, 4];\\n\\n        break;\\n\\n    default:\\n\\n        copyright = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('付费', '全部')) {\\n\\n    case '免费':\\n\\n        season_status = 1;\\n\\n        break;\\n\\n    case '付费':\\n\\n        season_status = [2, 6];\\n\\n        break;\\n\\n    case '大会员':\\n\\n        season_status = [4, 6];\\n\\n        break;\\n\\n    default:\\n\\n        season_status = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('季度', '全部')) {\\n\\n    case '1月':\\n\\n        season_month = 1;\\n\\n        break;\\n\\n    case '4月':\\n\\n        season_month = 4;\\n\\n        break;\\n\\n    case '7月':\\n\\n        season_month = 7;\\n\\n        break;\\n\\n    case '10月':\\n\\n        season_month = 10;\\n\\n        break;\\n\\n    default:\\n\\n        season_month = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('时间', '全部')) {\\n\\n    case '2022':\\n\\n        year = '[2022,2023)';\\n\\n        break;\\n\\n    case '2021':\\n\\n        year = '[2021,2022)';\\n\\n        break;\\n\\n    case '2020':\\n\\n        year = '[2020,2021)';\\n\\n        break;\\n\\n    case '2019':\\n\\n        year = '[2019,2020)';\\n\\n        break;\\n\\n    case '2018':\\n\\n        year = '[2018,2019)';\\n\\n        break;\\n\\n    case '2017':\\n\\n        year = '[2017,2018)';\\n\\n        break;\\n\\n    case '2016':\\n\\n        year = '[2016,2017)';\\n\\n        break;\\n\\n    case '2015':\\n\\n        year = '[2015,2016)';\\n\\n        break;\\n\\n    case '2014-2010':\\n\\n        year = '[2010,2015)';\\n\\n        break;\\n\\n    case '2009-2005':\\n\\n        year = '[2005,2010)';\\n\\n        break;\\n\\n    case '2004-2000':\\n\\n        year = '[2000,2005)';\\n\\n        break;\\n\\n    case '90年代':\\n\\n        year = '[1990,2000)';\\n\\n        break;\\n\\n    case '80年代':\\n\\n        year = '[1980,1990)';\\n\\n        break;\\n\\n    case '更早':\\n\\n        year = '[,1980)';\\n\\n        break;\\n\\n    default:\\n\\n        year = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('年份', '全部')) {\\n\\n    case '2022':\\n\\n        release_date = '[2022-01-01 00:00:00,2023-01-01 00:00:00)';\\n\\n        break;\\n\\n    case '2021':\\n\\n        release_date = '[2021-01-01 00:00:00,2022-01-01 00:00:00)';\\n\\n        break;\\n\\n    case '2020':\\n\\n        release_date = '[2020-01-01 00:00:00,2021-01-01 00:00:00)';\\n\\n        break;\\n\\n    case '2019':\\n\\n        release_date = '[2019-01-01 00:00:00,2020-01-01 00:00:00)';\\n\\n        break;\\n\\n    case '2018':\\n\\n        release_date = '[2018-01-01 00:00:00,2019-01-01 00:00:00)';\\n\\n        break;\\n\\n    case '2017':\\n\\n        release_date = '[2017-01-01 00:00:00,2018-01-01 00:00:00)';\\n\\n        break;\\n\\n    case '2016':\\n\\n        release_date = '[2016-01-01 00:00:00,2017-01-01 00:00:00)';\\n\\n        break;\\n\\n    case '2015-2010':\\n\\n        release_date = '[2010-01-01 00:00:00,2016-01-01 00:00:00)'\\n\\n        break;\\n\\n    case '2009-2005':\\n\\n        release_date = '[2005-01-01 00:00:00,2010-01-01 00:00:00)'\\n\\n        break;\\n\\n    case '2004-2000':\\n\\n        release_date = '[2000-01-01 00:00:00,2005-01-01 00:00:00)'\\n\\n        break;\\n\\n    case '90年代':\\n\\n        release_date = '[1990-01-01 00:00:00,2000-01-01 00:00:00)'\\n\\n        break;\\n\\n    case '80年代':\\n\\n        release_date = '[1980-01-01 00:00:00,1990-01-01 00:00:00)'\\n\\n        break;\\n\\n    case '更早':\\n\\n        release_date = '[,1980-01-01 00:00:00)';\\n\\n        break;\\n\\n    default:\\n\\n        release_date = -1;\\n\\n        break;\\n\\n}\\n\\nswitch (getMyVar('风格', '全部')) {\\n\\n    case '电影':\\n\\n        style_id = -10;\\n\\n        break;\\n\\n        // 番剧栏目\\n\\n    case '原创':\\n\\n        style_id = 10010;\\n\\n        break;\\n\\n    case '漫画改':\\n\\n        style_id = 10011;\\n\\n        break;\\n\\n    case '小说改':\\n\\n        style_id = 10012;\\n\\n        break;\\n\\n    case '游戏改':\\n\\n        style_id = 10013;\\n\\n        break;\\n\\n    case '特摄':\\n\\n        style_id = 10014;\\n\\n        break;\\n\\n    case '布袋戏':\\n\\n        style_id = 10015;\\n\\n        break;\\n\\n    case '热血':\\n\\n        style_id = 10016;\\n\\n        break;\\n\\n    case '穿越':\\n\\n        style_id = 10017;\\n\\n        break;\\n\\n    case '奇幻':\\n\\n        style_id = 10018;\\n\\n        break;\\n\\n        // 咋跳了一个捏~\\n\\n    case '战斗':\\n\\n        style_id = 10020;\\n\\n        break;\\n\\n    case '搞笑':\\n\\n        style_id = 10021;\\n\\n        break;\\n\\n    case '日常':\\n\\n        style_id = 10022;\\n\\n        break;\\n\\n    case '科幻':\\n\\n        style_id = 10023;\\n\\n        break;\\n\\n    case '萌系':\\n\\n        style_id = 10024;\\n\\n        break;\\n\\n    case '治愈':\\n\\n        style_id = 10025;\\n\\n        break;\\n\\n    case '校园':\\n\\n        style_id = 10026;\\n\\n        break;\\n\\n    case '少儿':\\n\\n        style_id = 10027;\\n\\n        break;\\n\\n    case '泡面':\\n\\n        style_id = 10028;\\n\\n        break;\\n\\n    case '恋爱':\\n\\n        style_id = 10029;\\n\\n        break;\\n\\n    case '少女':\\n\\n        style_id = 10030;\\n\\n        break;\\n\\n    case '魔法':\\n\\n        style_id = 10031;\\n\\n        break;\\n\\n    case '冒险':\\n\\n        style_id = 10032;\\n\\n        break;\\n\\n    case '历史':\\n\\n        style_id = 10033;\\n\\n        break;\\n\\n    case '架空':\\n\\n        style_id = 10034;\\n\\n        break;\\n\\n    case '机战':\\n\\n        style_id = 10035;\\n\\n        break;\\n\\n    case '神魔':\\n\\n        style_id = 10036;\\n\\n        break;\\n\\n    case '声控':\\n\\n        style_id = 10037;\\n\\n        break;\\n\\n    case '运动':\\n\\n        style_id = 10038;\\n\\n        break;\\n\\n    case '励志':\\n\\n        style_id = 10039;\\n\\n        break;\\n\\n    case '音乐':\\n\\n        style_id = 10040;\\n\\n        break;\\n\\n    case '推理':\\n\\n        style_id = 10041;\\n\\n        break;\\n\\n    case '社团':\\n\\n        style_id = 10042;\\n\\n        break;\\n\\n    case '智斗':\\n\\n        style_id = 10043;\\n\\n        break;\\n\\n    case '催泪':\\n\\n        style_id = 10044;\\n\\n        break;\\n\\n    case '美食':\\n\\n        style_id = 10045;\\n\\n        break;\\n\\n    case '偶像':\\n\\n        style_id = 10046;\\n\\n        break;\\n\\n    case '乙女':\\n\\n        style_id = 10047;\\n\\n        break;\\n\\n    case '职场':\\n\\n        style_id = 10048;\\n\\n        break;\\n\\n\\n        // 综艺栏目、电影\\n\\n    case '剧情':\\n\\n        style_id = 10050;\\n\\n        break;\\n\\n    case '喜剧':\\n\\n        style_id = 10051;\\n\\n        break;\\n\\n    case '爱情':\\n\\n        style_id = 10052;\\n\\n        break;\\n\\n    case '动作':\\n\\n        style_id = 10053;\\n\\n        break;\\n\\n    case '恐怖':\\n\\n        style_id = 10054;\\n\\n        break;\\n\\n    case '犯罪':\\n\\n        style_id = 10055;\\n\\n        break;\\n\\n    case '惊悚':\\n\\n        style_id = 10056;\\n\\n        break;\\n\\n    case '悬疑':\\n\\n        style_id = 10057;\\n\\n        break;\\n\\n    case '战争':\\n\\n        style_id = 10058;\\n\\n        break;\\n\\n    case '动画':\\n\\n        style_id = 10059;\\n\\n        break;\\n\\n    case '传记':\\n\\n        style_id = 10060;\\n\\n        break;\\n\\n    case '家庭':\\n\\n        style_id = 10061;\\n\\n        break;\\n\\n    case '歌舞':\\n\\n        style_id = 10062;\\n\\n        break;\\n\\n    case '纪实':\\n\\n        style_id = 10063;\\n\\n        break;\\n\\n    case '灾难':\\n\\n        style_id = 10064;\\n\\n        break;\\n\\n    case '人文':\\n\\n        style_id = 10065;\\n\\n        break;\\n\\n    case '科技':\\n\\n        style_id = 10066;\\n\\n        break;\\n\\n    case '宇宙':\\n\\n        style_id = 10068;\\n\\n        break;\\n\\n    case '萌宠':\\n\\n        style_id = 10069;\\n\\n        break;\\n\\n    case '社会':\\n\\n        style_id = 10070;\\n\\n        break;\\n\\n    case '动物':\\n\\n        style_id = 10071;\\n\\n        break;\\n\\n    case '自然':\\n\\n        style_id = 10072;\\n\\n        break;\\n\\n    case '医疗':\\n\\n        style_id = 10073;\\n\\n        break;\\n\\n    case '军事':\\n\\n        style_id = 10074;\\n\\n        break;\\n\\n    case '罪案':\\n\\n        style_id = 10075;\\n\\n        break;\\n\\n    case '神秘':\\n\\n        style_id = 10076;\\n\\n        break;\\n\\n    case '旅行':\\n\\n        style_id = 10077;\\n\\n        break;\\n\\n    case '武侠':\\n\\n        style_id = 10078;\\n\\n        break;\\n\\n    case '青春':\\n\\n        style_id = 10079;\\n\\n        break;\\n\\n    case '都市':\\n\\n        style_id = 10080;\\n\\n        break;\\n\\n    case '古装':\\n\\n        style_id = 10081;\\n\\n        break;\\n\\n    case '谍战':\\n\\n        style_id = 10082;\\n\\n        break;\\n\\n    case '经典':\\n\\n        style_id = 10083;\\n\\n        break;\\n\\n    case '情感':\\n\\n        style_id = 10084;\\n\\n        break;\\n\\n    case '神话':\\n\\n        style_id = 10085;\\n\\n        break;\\n\\n    case '年代':\\n\\n        style_id = 10086;\\n\\n        break;\\n\\n    case '农村':\\n\\n        style_id = 10087;\\n\\n        break;\\n\\n    case '刑侦':\\n\\n        style_id = 10088;\\n\\n        break;\\n\\n    case '军旅':\\n\\n        style_id = 10089;\\n\\n        break;\\n\\n    case '访谈':\\n\\n        style_id = 10090;\\n\\n        break;\\n\\n    case '脱口秀':\\n\\n        style_id = 10091;\\n\\n        break;\\n\\n    case '真人秀':\\n\\n        style_id = 10092;\\n\\n        break;\\n\\n    case '选秀':\\n\\n        style_id = 10094;\\n\\n        break;\\n\\n    case '旅游':\\n\\n        style_id = 10095;\\n\\n        break;\\n\\n    case '晚会':\\n\\n        style_id = 10098;\\n\\n        break;\\n\\n    case '演唱会':\\n\\n        style_id = 10096;\\n\\n        break;\\n\\n    case '亲子':\\n\\n        style_id = 10097;\\n\\n        break;\\n\\n    case '养成':\\n\\n        style_id = 10099;\\n\\n        break;\\n\\n    case '文化':\\n\\n        style_id = 10100;\\n\\n        break;\\n\\n        // 电影栏目\\n\\n    case '短片':\\n\\n        style_id = 10104;\\n\\n        break;\\n\\n    default:\\n\\n        style_id = -1;\\n\\n        break;\\n\\n}\\n\\n// 映射真实请求地址\\n\\nswitch (seasonType) {\\n\\n    case 4:\\n\\n        // 国创\\n\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?season_version=' + season_version + '&is_finish=' + is_finish + '&copyright=&s' + copyright + 'eason_status=' + season_status + '&year=' + year + '&style_id=' + style_id + '&order=3&st=4&sort=0&page=' + page + '&season_type=4&pagesize=20&type=1'\\n\\n        break;\\n\\n    case 5:\\n\\n        // 电视剧\\n\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?area=' + area + '&style_id=' + style_id + '&release_date=' + release_date + '&season_status=' + season_status + '&order=2&st=5&sort=0&page=' + page + '&season_type=5&pagesize=20&type=1'\\n\\n        break;\\n\\n    case 7:\\n\\n        // 综艺\\n\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?season_status=' + season_status + '&style_id=' + style_id + '&order=2&st=7&sort=0&page=' + page + '&season_type=7&pagesize=20&type=1';\\n\\n        break;\\n\\n    case 1:\\n\\n        // 番剧\\n\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?season_version=' + season_version + '&spoken_language_type=' + spoken_language_type + '&area=' + area + '&is_finish=' + is_finish + '&copyright=' + copyright + '&season_status=' + season_status + '&season_month=' + season_month + '&year=' + year + '&style_id=' + style_id + '&order=3&st=1&sort=0&page=' + page + '&season_type=1&pagesize=20&type=1';\\n\\n        break;\\n\\n    case 3:\\n\\n        // 纪录片\\n\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?style_id=' + style_id + '&producer_id=' + producer_id + '&release_date=' + release_date + '&season_status=' + season_status + '&order=2&st=3&sort=0&page=' + page + '&season_type=3&pagesize=20&type=1'\\n\\n        break;\\n\\n    case 2:\\n\\n        // 电影\\n\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?area=' + area + '&style_id=' + style_id + '&release_date=' + release_date + '&season_status=' + season_status + '&order=2&st=2&sort=0&page=' + page + '&season_type=2&pagesize=20&type=1'\\n\\n        break;\\n\\n}\\n\\ntrue_url = encodeURI(true_url);\\n\\nlist = JSON.parse(fetch(true_url)).data.list;\\n\\ntry {\\n\\n    list.forEach(movie => {\\n\\n        d.push({\\n\\n            title: movie.title,\\n\\n            url: \\\"hiker://page/filmerji#immersiveTheme#\\\",\\n\\n            img: movie.cover + \\\"@Referer=\\\",\\n\\n            desc: movie.order,\\n\\n            col_type: 'movie_3',\\n\\n            extra: {\\n\\n                season_id: movie.season_id\\n\\n            }\\n\\n        });\\n\\n    });\\n\\n} catch (e) {\\n\\n    log('已经抵达页底' + MY_PAGE);\\n\\n}\\n\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"热映时间表\",\"path\":\"UpdateTables\",\"rule\":\"function color(text, color) {\\n\\n    text += \\\"\\\";\\n\\n    if (text.indexOf(\\\"““””\\\") === 0) {\\n\\n        text.replace(\\\"““””\\\", \\\"\\\");\\n\\n    }\\n\\n    return \\\"““””<font color='\\\" + color + \\\"'>\\\" + text + \\\"</font>\\\";\\n\\n}\\n\\nvar tabs = {\\n\\n    \\\"番剧\\\": 1,\\n\\n    \\\"纪录片\\\": 3,\\n\\n    \\\"国创\\\": 4\\n\\n}\\n\\nif (MY_PAGE == 1) {\\n\\n    Object.keys(tabs).forEach(item => {\\n\\n        d.push({\\n\\n            title: (getMyVar(\\\"juji\\\", \\\"国创\\\") == item ? color(item, \\\"red\\\") : item),\\n\\n            url: $().lazyRule((a) => {\\n\\n                putMyVar(\\\"juji\\\", a)\\n\\n                refreshPage()\\n\\n                return \\\"toast://切换成功\\\"\\n\\n            }, item),\\n\\n            col_type: \\\"scroll_button\\\"\\n\\n        })\\n\\n    })\\n\\n    d.push({\\n\\n        col_type: \\\"line\\\"\\n\\n    })\\n\\n    let days = 7\\n\\n    for (let i = 1; i < days; i++) {\\n\\n        d.push({\\n\\n            title: (getMyVar(\\\"from\\\", \\\"1\\\") == i + \\\"\\\" ? color(i + \\\"天前\\\", \\\"red\\\") : i + \\\"天前\\\"),\\n\\n            url: $().lazyRule((i) => {\\n\\n                putMyVar(\\\"from\\\", i + \\\"\\\")\\n\\n                refreshPage()\\n\\n                return \\\"hiker://empty\\\"\\n\\n            }, i),\\n\\n            col_type: \\\"scroll_button\\\"\\n\\n        })\\n\\n    }\\n\\n    d.push({\\n\\n        col_type: \\\"line\\\"\\n\\n    })\\n\\n    for (let i = 1; i < days; i++) {\\n\\n        d.push({\\n\\n            title: (getMyVar(\\\"to\\\", \\\"1\\\") == i + \\\"\\\" ? color(i + \\\"天后\\\", \\\"red\\\") : i + \\\"天后\\\"),\\n\\n            url: $().lazyRule((i) => {\\n\\n                putMyVar(\\\"to\\\", i + \\\"\\\")\\n\\n                refreshPage()\\n\\n                return \\\"hiker://empty\\\"\\n\\n            }, i),\\n\\n            col_type: \\\"scroll_button\\\"\\n\\n        })\\n\\n    }\\n\\n\\n    $.require(\\\"hiker://page/api\\\").getMovies(tabs[getMyVar(\\\"juji\\\", \\\"国创\\\")], getMyVar(\\\"from\\\", \\\"1\\\"), getMyVar(\\\"to\\\", \\\"1\\\")).forEach(item => {\\n\\n        d.push({\\n\\n            title: item.date + \\\" 周\\\" + item.day_of_week,\\n\\n            col_type: \\\"text_1\\\",\\n\\n            url: \\\"hiker://empty\\\"\\n\\n        })\\n\\n        item.episodes.forEach(i => {\\n\\n            d.push({\\n\\n                title: i.title,\\n\\n                img: i.cover+'@Referer=',\\n\\n                desc:i.pub_index.match(/即将/)?'‘‘’’<font color=\\\"red\\\">'+i.pub_index+'\\\\n'+i.pub_time+'</font>': i.pub_index+ '\\\\n' + i.pub_time,\\n\\n                url: \\\"hiker://page/filmerji#immersiveTheme#\\\",\\n\\n                extra: {\\n\\n                    \\\"season_id\\\": i.season_id\\n\\n                }\\n\\n            })\\n\\n        })\\n\\n    })\\n\\n}\\n\\n\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"个人主页\",\"path\":\"userHome\",\"rule\":\"if (MY_PAGE == 1) {\\n\\n    d.push({\\n\\n        col_type: 'line'\\n\\n    })\\n\\n    try {\\n\\n        if (isLogin.type === true) {\\n\\n            d.push({\\n\\n                title: '订阅' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\"red\\\">订阅</font></big>' : '订阅',\\n\\n                url: $('#noLoading#').lazyRule(() => {\\n\\n                    setItem('主页展示', '订阅');\\n\\n                    selection = ['追番', '追剧'];\\n\\n                    selection = selection.map((it) => {\\n\\n                        if (it == '追番') {\\n\\n                            typeId = '1';\\n\\n                        } else {\\n\\n                            typeId = '2';\\n\\n                        }\\n\\n                        return typeId === getItem('订阅类型', '追番') ? '👉' + it : it;\\n\\n                    });\\n\\n                    return $(selection, 1).select(() => {\\n\\n                        input = input.replace(/👉/g, '');\\n\\n                        if (input == '追番') {\\n\\n                            setItem('订阅类型', '1');\\n\\n                        } else {\\n\\n                            setItem('订阅类型', '2');\\n\\n                        }\\n\\n                        refreshPage(true);\\n\\n                        return \\\"toast://切换订阅为:\\\" + input;\\n\\n                    })\\n\\n                }),\\n\\n                col_type: 'text_4',\\n\\n            });\\n\\n            d.push({\\n\\n                title: '关注' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\"red\\\">关注</font></big>' : '关注',\\n\\n                url: $('#noLoading#').lazyRule(() => {\\n\\n                    setItem('主页展示', '关注');\\n\\n                    refreshPage(true);\\n\\n                    return \\\"hiker://empty\\\";\\n\\n                }),\\n\\n                col_type: 'text_4',\\n\\n            });\\n\\n            d.push({\\n\\n                title: '收藏' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\"red\\\">收藏</font></big>' : '收藏',\\n\\n                url: $('#noLoading#').lazyRule(() => {\\n\\n                    setItem('主页展示', '收藏');\\n\\n                    selection = ['我创建的收藏夹', '稍后在看'];\\n\\n                    selection = selection.map((it) => {\\n\\n                        return it === getItem('收藏类型', '我创建的收藏夹') ? '👉' + it : it;\\n\\n                    });\\n\\n                    return $(selection, 1).select(() => {\\n\\n                        input = input.replace(/👉/g, '');\\n\\n                        setItem('收藏类型', input);\\n\\n                        refreshPage(true);\\n\\n                        return \\\"toast://切换订阅为:\\\" + input;\\n\\n                    })\\n\\n                }),\\n\\n                col_type: 'text_4',\\n\\n            });\\n\\n            d.push({\\n\\n                title: '历史' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\"red\\\">历史</font></big>' : '历史',\\n\\n                url: $('#noLoading#').lazyRule(() => {\\n\\n                    setItem('主页展示', '历史');\\n\\n                    refreshPage(true);\\n\\n                    return \\\"hiker://empty\\\";\\n\\n                }),\\n\\n                col_type: 'text_4',\\n\\n            });\\n\\n            d.push({\\n\\n                col_type: 'line'\\n\\n            })\\n\\n        } else {\\n\\n            d.push({\\n\\n                title: \\\"登陆\\\",\\n\\n                url: \\\"hiker://page/login\\\",\\n\\n                col_type: \\\"text_center_1\\\"\\n\\n            })\\n\\n        }\\n\\n    } catch (e) {\\n\\n        log(e.message)\\n\\n    }\\n\\n}\\n\\n// 主页展示区\\n\\nif (isLogin.type === true) {\\n\\n    biliDate = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\"));\\n\\n    cookie = biliDate.cookie;\\n\\n    mid = biliDate.userMid;\\n\\n    switch (getItem('主页展示', '订阅')) {\\n\\n        case '关注':\\n\\n            if (MY_PAGE == 1) {\\n\\n                d.push({\\n\\n                    col_type: 'scroll_button',\\n\\n                    url: 'hiker://empty',\\n\\n                    title: '∷',\\n\\n                    extra: {\\n\\n                        id: '占位符',\\n\\n                    }\\n\\n                });\\n\\n                focusGroups = JSON.parse(fetch(\\\"https://api.bilibili.com/x/relation/tags?jsonp=jsonp\\\", {\\n\\n                    headers: {\\n\\n                        \\\"Cookie\\\": cookie,\\n\\n                        \\\"User-Agent\\\": PC_UA,\\n\\n                        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n\\n                    }\\n\\n                })).data;\\n\\n                putMyVar('tempId', JSON.stringify(focusGroups[1].tagid));\\n\\n                focusGroups.forEach(list => {\\n\\n                    d.push({\\n\\n                        title: list.tagid == getItem('关注分组', JSON.stringify(focusGroups[1].id)) ? \\\"““””<font color='red'>\\\" + list.name + list.count + \\\"</font>\\\" : list.name + list.count,\\n\\n                        url: $('#noLoading##noHistory#').lazyRule((list) => {\\n\\n                            setItem('关注分组', JSON.stringify(list.tagid));\\n\\n                            refreshPage(true);\\n\\n                            return \\\"toast://切换关注分组为:\\\" + list.name;\\n\\n                        }, list),\\n\\n                        col_type: 'scroll_button',\\n\\n                    });\\n\\n                });\\n\\n                d.push({\\n\\n                    col_type: 'line'\\n\\n                });\\n\\n                groupContent = JSON.parse(fetch(\\\"https://api.bilibili.com/x/relation/tag?mid=\\\" + mid + \\\"&tagid=\\\" + getItem('关注分组', getMyVar('tempId')) + \\\"&pn=\\\" + page + \\\"&ps=20&jsonp=jsonp\\\", {\\n\\n                    headers: {\\n\\n                        \\\"Cookie\\\": cookie\\n\\n                    }\\n\\n                })).data;\\n\\n                groupContent.forEach(list => {\\n\\n                    d.push({\\n\\n                        title: \\\"<big><font color='blue'>\\\" + list.uname + \\\"</font></big><small>\\\" + list.sign + \\\"</small>\\\",\\n\\n                        img: list.face + \\\"@Referer=\\\",\\n\\n                        col_type: 'avatar',\\n\\n                        url: \\\"hiker://page/upHome\\\",\\n\\n                        extra: {\\n\\n                            mid: list.mid,\\n\\n                            title: list.uname,\\n\\n                            face: list.face\\n\\n                        }\\n\\n                    });\\n\\n                });\\n\\n            }\\n\\n            break;\\n\\n        case '收藏':\\n\\n            if (page == 1) {\\n\\n                if (getItem('收藏类型', '我创建的收藏夹') == '我创建的收藏夹') {\\n\\n                    d.push({\\n\\n                        col_type: 'scroll_button',\\n\\n                        url: 'hiker://empty',\\n\\n                        title: '∷',\\n\\n                        extra: {\\n\\n                            id: '占位符',\\n\\n                        }\\n\\n                    });\\n\\n                    collections = JSON.parse(fetch(\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\", {\\n\\n                        headers: {\\n\\n                            \\\"Cookie\\\": cookie\\n\\n                        }\\n\\n                    })).data;\\n\\n                    groups = collections[0].mediaListResponse.list;\\n\\n                    putMyVar('tempId', JSON.stringify(groups[0].id));\\n\\n                    groups.forEach(list => {\\n\\n                        d.push({\\n\\n                            title: list.id == getItem('收藏夹', JSON.stringify(groups[0].id)) ? \\\"““””<font color='red'>\\\" + list.title + \\\"</font>\\\" : list.title,\\n\\n                            url: $('#noLoading##noHistory#').lazyRule((list) => {\\n\\n                                setItem('收藏夹', JSON.stringify(list.id));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"toast://切换收藏夹为:\\\" + list.title;\\n\\n                            }, list),\\n\\n                            col_type: 'scroll_button',\\n\\n                        });\\n\\n                    });\\n\\n                    d.push({\\n\\n                        col_type: 'line'\\n\\n                    });\\n\\n                    groupContent = JSON.parse(fetch(\\\"https://api.bilibili.com/x/v3/fav/resource/list?media_id=\\\" + getItem('收藏夹', getMyVar('tempId')) + \\\"&pn=\\\" + page + \\\"&ps=20&keyword=&order=mtime&type=0&tid=0&platform=web&jsonp=jsonp\\\", {\\n\\n                        headers: {\\n\\n                            \\\"Cookie\\\": cookie\\n\\n                        }\\n\\n                    })).data.medias;\\n\\n                    groupContent.forEach(list => {\\n\\n                        d.push({\\n\\n                            title: list.title,\\n\\n                            img: list.cover + \\\"@Referer=\\\",\\n\\n                            col_type: 'movie_1_left_pic',\\n\\n                            url: \\\"hiker://page/video\\\",\\n\\n                            desc: 'UP:' + list.upper.name + '\\\\n' + list.intro,\\n\\n                            extra: {\\n\\n                                aid: list.id\\n\\n                            }\\n\\n                        });\\n\\n                    });\\n\\n                } else {\\n\\n                    laterViews = JSON.parse(fetch(\\\"https://api.bilibili.com/x/v2/history/toview/web?jsonp=jsonp\\\", {\\n\\n                        headers: {\\n\\n                            \\\"Cookie\\\": cookie\\n\\n                        }\\n\\n                    })).data;\\n\\n                    count = laterViews.count;\\n\\n                    d.push({\\n\\n                        title: \\\"共有\\\" + count + \\\"条待看视频记录\\\",\\n\\n                        url: \\\"hiker://empty\\\",\\n\\n                        col_type: \\\"text_center_1\\\"\\n\\n                    });\\n\\n                    laterViews.list.forEach(list => {\\n\\n                        d.push({\\n\\n                            title: list.title,\\n\\n                            img: list.pic + \\\"@Referer=\\\",\\n\\n                            col_type: 'movie_1_left_pic',\\n\\n                            url: \\\"hiker://page/video\\\",\\n\\n                            desc: 'UP:' + list.owner.name + '\\\\n' + list.desc,\\n\\n                            extra: {\\n\\n                                aid: list.aid\\n\\n                            }\\n\\n                        });\\n\\n                    });\\n\\n                }\\n\\n            }\\n\\n            break;\\n\\n        case '订阅':\\n\\n            subscriptions = JSON.parse(fetch(\\\"https://api.bilibili.com/x/space/bangumi/follow/list?type=\\\" + getItem('订阅类型', '1') + \\\"&follow_status=0&pn=\\\" + page + \\\"&ps=15&vmid=\\\" + mid, {\\n\\n                headers: {\\n\\n                    \\\"Cookie\\\": cookie\\n\\n                }\\n\\n            })).data;\\n\\n            if (getItem('订阅类型', '1') == '1') {\\n\\n                typerName = '追番';\\n\\n            } else {\\n\\n                typerName = '追剧';\\n\\n            }\\n\\n            if (page == 1) {\\n\\n                d.push({\\n\\n                    title: \\\"当前\\\" + typerName + \\\"数量:\\\" + subscriptions.total,\\n\\n                    url: \\\"hiker://empty\\\",\\n\\n                    col_type: \\\"text_center_1\\\"\\n\\n                })\\n\\n            }\\n\\n            subscriptions.list.forEach(list => {\\n\\n                d.push({\\n\\n                    title: list.title,\\n\\n                    img: list.cover + \\\"@Referer=\\\",\\n\\n                    url: \\\"hiker://page/filmerji#immersiveTheme#\\\",\\n\\n                    desc: list.evaluate.substring(0, 12) + '‘‘’’…<font color=\\\"#1C1C1C\\\">详情</font>' + '\\\\n' + list.season_type_name + '|' + list.areas[0].name + '\\\\n' + (list.progress == '' ? '尚未观看' : list.progress) + '|' + (list.new_ep.index_show.match(/更新/) ? '‘‘’’<font color=\\\"red\\\">' + list.new_ep.index_show + '</font>' : list.new_ep.index_show),\\n\\n                    col_type: 'movie_1_vertical_pic',\\n\\n                    extra: {\\n\\n                        season_id: list.season_id\\n\\n                    }\\n\\n                });\\n\\n            });\\n\\n            break;\\n\\n        case '历史':\\n\\n            var nextInfo = {};\\n\\n            if (page == 1) {\\n\\n                histories = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=0&view_at=0&business=\\\", {\\n\\n                    headers: {\\n\\n                        \\\"Cookie\\\": cookie\\n\\n                    }\\n\\n                })).data;\\n\\n                nextInfo.max = histories.cursor.max;\\n\\n                nextInfo.view_at = histories.cursor.view_at;\\n\\n                nextInfo.business = histories.cursor.business;\\n\\n            } else {\\n\\n                histories = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=\\\" + storage0.getMyVar(JSON.stringify(page)).max + \\\"&view_at=\\\" + storage0.getMyVar(JSON.stringify(page)).view_at + \\\"&business=\\\" + storage0.getMyVar(JSON.stringify(page)).business, {\\n\\n                    headers: {\\n\\n                        \\\"Cookie\\\": cookie\\n\\n                    }\\n\\n                })).data;\\n\\n                nextInfo.max = histories.cursor.max;\\n\\n                nextInfo.view_at = histories.cursor.view_at;\\n\\n                nextInfo.business = histories.cursor.business;\\n\\n            }\\n\\n            storage0.putMyVar(JSON.stringify(page + 1), nextInfo);\\n\\n            histories.list.forEach(list => {\\n\\n                // 还有要判断番剧影视类型\\n\\n                if (list.badge == '专栏') {\\n\\n                    // 后续处理\\n\\n                    d.push({\\n\\n                        title: list.show_title,\\n\\n                        img: list.covers[0] + \\\"@Referer=\\\",\\n\\n                        col_type: 'movie_1_left_pic',\\n\\n                        url: \\\"hiker://page/note#immersiveTheme#\\\",\\n\\n                        desc: 'UP:' + list.author_name + '\\\\n' + list.tag_name,\\n\\n                        extra: {\\n\\n                            aid: list.history.oid,\\n\\n                        }\\n\\n                    });\\n\\n                } else {\\n\\n                    d.push({\\n\\n                        title: list.show_title,\\n\\n                        img: list.cover + \\\"@Referer=\\\",\\n\\n                        col_type: 'movie_1_left_pic',\\n\\n                        url: \\\"hiker://page/video#immersiveTheme#\\\",\\n\\n                        desc: 'UP:' + list.author_name + '\\\\n' + list.tag_name,\\n\\n                        extra: {\\n\\n                            aid: list.history.oid,\\n\\n                        }\\n\\n                    });\\n\\n                }\\n\\n            });\\n\\n            break;\\n\\n        default:\\n\\n            log('出错了~');\\n\\n            break;\\n\\n    }\\n\\n}\\n\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"登录\",\"path\":\"login\",\"rule\":\"js:\\n\\nvar d = [];\\n\\n// 如果获取失败就再试一次~\\n\\nd.push({\\n\\n    url: \\\"https://www.bilibili.com/\\\",\\n\\n    col_type: \\\"x5_webview_single\\\",\\n\\n    desc: \\\"100%&&float\\\",\\n\\n    extra: {\\n\\n        js: $.toString(() => {\\n\\n            fba.setAppBarColor(\\\"pink\\\");\\n\\n            var token_timer = function () {\\n\\n                var timer = setInterval(() => {\\n\\n                    // if (document.getElementsByClassName(\\\"header-login-entry\\\")[0] === undefined) {\\n\\n                    if (document.getElementsByClassName(\\\"unlogin-avatar\\\")[0] === undefined) {\\n\\n                        settings = JSON.stringify({\\n\\n                            cookie: fba.getCookie(\\\"https://www.bilibili.com/\\\"),\\n\\n                            face: 'https://lanmeiguojiang.com/tubiao/movie/20.svg'\\n\\n                        });\\n\\n                        fba.writeFile(\\\"hiker://files/rules/cy/bili.txt\\\", settings);\\n\\n                        alert(\\\"已获取到cookie\\\");\\n\\n                        fba.back()\\n\\n                    }\\n\\n                }, 100)\\n\\n            };\\n\\n            token_timer();\\n\\n        }),\\n\\n        ua: PC_UA,\\n\\n        canBack: true\\n\\n    }\\n\\n})\\n\\nsetResult(d);\\n\\n\\njs:\\n\\nvar d = [];\\n\\n// 如果获取失败就再试一次~\\n\\nd.push({\\n\\n    url: \\\"https://www.bilibili.com/\\\",\\n\\n    col_type: \\\"x5_webview_single\\\",\\n\\n    desc: \\\"100%&&float\\\",\\n\\n    extra: {\\n\\n        js: $.toString(() => {\\n\\n            fba.setAppBarColor(\\\"pink\\\");\\n\\n            var token_timer = function () {\\n\\n                var timer = setInterval(() => {\\n\\n                    // if (document.getElementsByClassName(\\\"header-login-entry\\\")[0] === undefined) {\\n\\n                    if (document.getElementsByClassName(\\\"unlogin-avatar\\\")[0] === undefined) {\\n\\n                        settings = JSON.stringify({\\n\\n                            cookie: fba.getCookie(\\\"https://www.bilibili.com/\\\"),\\n\\n                            face: 'https://lanmeiguojiang.com/tubiao/movie/20.svg'\\n\\n                        });\\n\\n                        fba.writeFile(\\\"hiker://files/rules/cy/bili.txt\\\", settings);\\n\\n                        alert(\\\"已获取到cookie\\\");\\n\\n                        fba.back()\\n\\n                    }\\n\\n                }, 100)\\n\\n            };\\n\\n            token_timer();\\n\\n        }),\\n\\n        ua: PC_UA,\\n\\n        canBack: true\\n\\n    }\\n\\n})\\n\\nsetResult(d);\\n\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"影视二级\",\"path\":\"filmerji\",\"rule\":\"js:\\n// 数据定位\\nvar d = [];\\nif (MY_PARAMS.season_id) {\\n    season_id = MY_PARAMS.season_id + \\\"\\\";\\n    Data = JSON.parse(fetch('https://api.bilibili.com/pgc/view/web/season?season_id=' + season_id)).result;\\n} else {\\n    Data = JSON.parse(fetch('https://api.bilibili.com/pgc/view/web/season?ep_id=' + MY_PARAMS.ep_id)).result;\\n}\\n封面 = Data.cover + \\\"@Referer=\\\";\\n地区 = Data.areas[0].name;\\n简介 = Data.evaluate;\\n// 正片\\n类型 = Data.positive.title;\\n上映时间 = Data.publish.pub_time;\\ntry {\\n    得分 = Data.rating.score;\\n} catch (e) {\\n    得分 = '暂无得';\\n}\\n追剧日历 = Data.new_ep.desc;\\n更新进度 = Data.new_ep.title;\\n影片名称 = Data.title;\\n第二标题 = Data.share_sub_title;\\n剧集列表 = Data.episodes;\\n短讯 = \\\"⭐\\\" + 类型 + \\\"⭐\\\" + 第二标题 + '\\\\n' + 地区 + '-' + 得分 + '分\\\\n-' + 上映时间 + '-';\\n// 重定义二级页面数据\\nsetPageTitle(影片名称);\\nsetPagePicUrl(封面);\\n// 前置参数和预处理---\\nimgLink = storage0.getMyVar('图标');\\n// 全局lazy——直链+断插\\nvar lazy = $('').lazyRule(() => {\\n    videoParms = findItem(input);\\n    aid = videoParms.extra.aid;\\n    bvid = videoParms.extra.bvid;\\n    cid = videoParms.extra.cid;\\n    badge = videoParms.extra.badge;\\n    // 提交历史记录\\n    $.require(\\\"hiker://page/api\\\").reportProcess(aid, cid);\\n    if (getMyVar('authority', 'normal') == 'SVIP') {\\n        return $.require(\\\"hiker://page/api\\\").biliLazy(aid, cid, 116).replace(/;/g, \\\"；；\\\");\\n    } else {\\n        if (badge.match(/会员|付费/)) {\\n            eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n            eval(fetch('hiker://files/cache/Parse_Dn.js', {}));\\n            return aytmParse(input);\\n        } else {\\n            return $.require(\\\"hiker://page/api\\\").biliLazy(aid, cid, 116).replace(/;/g, \\\"；；\\\");\\n        }\\n    }\\n});\\nvar Color = \\\"#19B89D\\\";\\nvar 每页集数 = 30;\\nvar 搜索模式 = '分组';\\nvar 调用名称 = '简影';\\nputMyVar('折叠', '关');\\nputMyVar('日历', '关');\\nputMyVar('Data', Data);\\nputMyVar('lazy', lazy);\\n// 清除变量\\naddListener('onClose', $.toString(() => {\\n    clearMyVar('分集起');\\n    clearMyVar('分集终');\\n    clearMyVar('折叠');\\n    clearMyVar('日历');\\n    clearMyVar('Data');\\n    clearMyVar('lazy');\\n    clearMyVar('剧集列表');\\n}))\\n// 设置动态最新章节\\nsetLastChapterRule('js:' + $.toString((MY_URL) => {\\n    html = fetch(MY_URL);\\n    Data = JSON.parse(html.match(/\\\"mediaInfo\\\"[\\\\S\\\\s]+(?=,\\\"initEpList\\\")/)[0].replace('\\\"mediaInfo\\\":', '').replace('\\\\u002F', '/'));\\n    追剧日历 = Data.new_ep.desc;\\n    更新进度 = Data.new_ep.title;\\n    更新状态 = 追剧日历.match(/完结|期待/) ? 追剧日历 : '更新至' + (更新进度.match(/[\\\\u4e00-\\\\u9fa5]/) ? 更新进度 : ('第' + (更新进度 == '' ? 0 : 更新进度)) + '话')\\n    setResult(更新状态);\\n}, MY_URL));\\n// 页面内容正文---\\n// 基本信息模块\\nd.push({\\n    title: 短讯,\\n    desc: 简介 == '' ? '暂无简介' : 简介.substring(0, 45) + '‘‘’’…<font color=\\\"#1C1C1C\\\">详情</font>',\\n    img: 封面,\\n    url: $().rule((简介) => {\\n        res = {};\\n        var d = [];\\n        d.push({\\n            title: '影片简介：' + '\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t' + 简介,\\n            col_type: 'long_text'\\n        });\\n        res.data = d;\\n        setHomeResult(res);\\n    }, 简介),\\n    col_type: 'movie_1_vertical_pic_blur',\\n});\\n// 更新日历模块\\nd.push({\\n    title: '日历',\\n    img: imgLink.日历,\\n    url: $('#noLoading#').lazyRule((追剧日历, 更新进度) => {\\n        if (getMyVar('日历', '关') == '开') {\\n            deleteItem('追剧日历');\\n            putMyVar('日历', '关');\\n        } else {\\n            addItemAfter('显示模式', {\\n                title: 追剧日历.match(/完结|期待/) ? 追剧日历 : 追剧日历 + '<br><font color=\\\"red\\\">更新至' + (更新进度.match(/[\\\\u4e00-\\\\u9fa5]/) ? 更新进度 : ('第' + (更新进度 == '' ? 0 : 更新进度) + '话')) + '</font>',\\n                col_type: \\\"rich_text\\\",\\n                extra: {\\n                    id: '追剧日历'\\n                }\\n            });\\n            putMyVar('日历', '开');\\n        }\\n        return 'toast://已切换日历为:' + getMyVar('日历', '开')\\n    }, 追剧日历, 更新进度),\\n    col_type: 'icon_5'\\n});\\n// 订阅模块\\nd.push({\\n    title: '订阅',\\n    img: imgLink.订阅,\\n    url: $('#noLoading#').lazyRule(() => {\\n        selectionList = ['订阅', '取消订阅'];\\n        return $(selectionList, 2).select(() => {\\n            season_id = JSON.parse(getMyVar('Data')).season_id;\\n            if (input == '订阅') {\\n                res = $.require(\\\"hiker://page/api\\\").subscribeFilm(season_id);\\n            } else {\\n                res = $.require(\\\"hiker://page/api\\\").cancelSubscribeFilm(season_id);\\n            }\\n            return 'toast://' + res;\\n        });\\n    }),\\n    col_type: 'icon_5'\\n});\\n// 评论模块\\nd.push({\\n    title: '评论',\\n    img: imgLink.查看评论,\\n    url: $('#noLoading#').lazyRule(() => {\\n        return $('hiker://empty').rule(() => {\\n            var d = [];\\n            List = JSON.parse(getMyVar('Data')).episodes;\\n            List.forEach(item => {\\n                d.push({\\n                    title: item.share_copy + '<font color=\\\"#33cccc\\\">\\t➮</font>',\\n                    img: item.cover + '@Referer=',\\n                    url: 'hiker://page/Comments?p=fypage',\\n                    col_type: \\\"avatar\\\",\\n                    extra: {\\n                        \\\"id\\\": item.aid,\\n                        \\\"type\\\": 1\\n                    }\\n                });\\n            });\\n            setResult(d);\\n        });\\n    }),\\n    col_type: 'icon_5'\\n});\\n\\n// 精彩继续模块\\nd.push({\\n    title: '周边',\\n    img: imgLink.周边,\\n    url: $('#noLoading#').lazyRule(() => {\\n        Data = JSON.parse(getMyVar('Data'));\\n        // 有些没有直接去掉懒得处理~\\n        if (Data.section) {\\n            周边数组 = [\\\"🏷️相关系列\\\", \\\"🤣PV&花絮\\\", \\\"🍉竖屏也精彩\\\", \\\"🔥精彩二创\\\"];\\n        } else {\\n            周边数组 = [\\\"🏷️相关系列\\\"];\\n        }\\n        // 周边数组 = [\\\"🏷️相关系列\\\", \\\"🤣PV&花絮\\\", \\\"竖屏也精彩\\\", \\\"精彩二创\\\"];\\n        return $(周边数组, 1, 'ღ精彩继续').select(() => {\\n            Data = JSON.parse(getMyVar('Data'));\\n            lazy = getMyVar('lazy');\\n            if (input === '🏷️相关系列') {\\n                系列名称 = Data.season_title\\n                系列数据 = Data.seasons;\\n                return $().rule((系列数据) => {\\n                    d = [];\\n                    setPageTitle('🏷️相关系列');\\n                    if (系列数据 == [] || 系列数据 == '') {\\n                        d.push({\\n                            title: '‘‘’’<big><font color=\\\"red\\\">⭐该影片没有相关系列哦~⭐</font></big>',\\n                            url: 'toast://都没有，，你点啥呀~',\\n                            desc: '敬请期待~',\\n                            col_type: 'text_center_1'\\n                        });\\n                    }\\n                    系列数据.forEach(list => {\\n                        d.push({\\n                            title: list.season_title,\\n                            img: (list.horizontal_cover_1610 == '' ? (list.horizontal_cover_169 == '' ? list.cover : list.horizontal_cover_169) : list.horizontal_cover_1610) + \\\"@Referer=\\\",\\n                            url: 'hiker://page/filmerji#immersiveTheme#',\\n                            desc: list.new_ep.index_show,\\n                            col_type: 'movie_1_left_pic',\\n                            extra: {\\n                                \\\"ep_id\\\": list.new_ep.id\\n                            }\\n                        });\\n                    });\\n                    setHomeResult(d);\\n                }, 系列数据)\\n            } else if (input === '🤣PV&花絮') {\\n                try {\\n                    PV和花絮数据 = Data.section[0].episodes;\\n                    return $().rule((PV和花絮数据, lazy) => {\\n                        d = [];\\n                        setPageTitle('🤣PV&花絮');\\n                        if (PV和花絮数据 == [] || PV和花絮数据 == '') {\\n                            d.push({\\n                                title: '‘‘’’<big><font color=\\\"red\\\">⭐该影片/视频没有相关PV和花絮哦~⭐</font></big>',\\n                                url: 'toast://都没有，，你点啥呀~',\\n                                desc: '敬请期待~',\\n                                col_type: 'text_center_1'\\n                            });\\n                        }\\n                        PV和花絮数据.forEach(list => {\\n                            d.push({\\n                                title: list.title,\\n                                img: list.cover + \\\"@Referer=\\\",\\n                                url: list.link + lazy,\\n                                desc: list.subtitle + '\\\\n' + list.long_title,\\n                                col_type: 'movie_1_left_pic',\\n                                extra: {\\n                                    id: list.link,\\n                                    aid: list.aid,\\n                                    bvid: list.bvid,\\n                                    cid: list.cid,\\n                                    badge: list.badge\\n                                }\\n                            });\\n                        });\\n                        setHomeResult(d);\\n                    }, PV和花絮数据, lazy)\\n                } catch (e) {\\n                    return 'toast://没有数据哦~'\\n                }\\n            } else if (input === '🍉竖屏也精彩') {\\n                try {\\n                    竖屏也精彩数据 = Data.section[1].episodes;\\n                    return $().rule((竖屏也精彩数据, lazy) => {\\n                        d = [];\\n                        setPageTitle('🍉竖屏也精彩');\\n                        if (竖屏也精彩数据 == [] || 竖屏也精彩数据 == '') {\\n                            d.push({\\n                                title: '‘‘’’<big><font color=\\\"red\\\">⭐该影片/视频没有相关竖屏短视频哦~⭐</font></big>',\\n                                url: 'toast://都没有，，你点啥呀~',\\n                                desc: '敬请期待~',\\n                                col_type: 'text_center_1'\\n                            });\\n                        }\\n                        竖屏也精彩数据.forEach(list => {\\n                            d.push({\\n                                title: list.title,\\n                                img: list.cover + \\\"@Referer=\\\",\\n                                url: list.link + lazy,\\n                                desc: list.subtitle + '\\\\n' + list.long_title,\\n                                col_type: 'movie_1_left_pic',\\n                                extra: {\\n                                    id: list.link,\\n                                    aid: list.aid,\\n                                    bvid: list.bvid,\\n                                    cid: list.cid,\\n                                    badge: list.badge\\n                                }\\n                            });\\n                        });\\n                        setHomeResult(d);\\n                    }, 竖屏也精彩数据, lazy)\\n                } catch (e) {\\n                    return 'toast://没有数据哦~'\\n                }\\n            } else if (input === '🔥精彩二创') {\\n                try {\\n                    精彩二创数据 = Data.section[2].episodes;\\n                    return $().rule((精彩二创数据, lazy) => {\\n                        d = [];\\n                        setPageTitle('🔥精彩二创');\\n                        if (精彩二创数据 == [] || 精彩二创数据 == '') {\\n                            d.push({\\n                                title: '‘‘’’<big><font color=\\\"red\\\">⭐该影片/视频没有二创作品哦~⭐</font></big>',\\n                                url: 'toast://都没有，，你点啥呀~',\\n                                desc: '敬请期待~',\\n                                col_type: 'text_center_1'\\n                            });\\n                        }\\n                        精彩二创数据.forEach(list => {\\n                            // 针对部分参数缺失的情况如凡人修仙传写的，，\\n                            if (list.aid == 0 || list.cid == 0) {\\n                                viedeoData = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\" + list.link.split('av')[1], {\\n                                    headers: {\\n                                        \\\"User-Agent\\\": PC_UA,\\n                                        \\\"Referer\\\": 'https://www.bilibili.com/'\\n                                    },\\n                                    method: \\\"GET\\\"\\n                                })).data;\\n                                aid = viedeoData.aid;\\n                                bvid = viedeoData.bvid;\\n                                cid = viedeoData.cid;\\n                            } else {\\n                                aid = list.aid;\\n                                bvid = list.bvid;\\n                                cid = list.cid;\\n                            }\\n                            d.push({\\n                                title: list.title,\\n                                img: list.cover + \\\"@Referer=\\\",\\n                                url: list.link + lazy,\\n                                desc: list.subtitle + '\\\\n' + list.long_title,\\n                                col_type: 'movie_1_left_pic',\\n                                extra: {\\n                                    id: list.link,\\n                                    aid: aid,\\n                                    bvid: bvid,\\n                                    cid: cid,\\n                                    badge: list.badge\\n                                }\\n                            });\\n                        });\\n                        setHomeResult(d);\\n                    }, 精彩二创数据, lazy)\\n                } catch (e) {\\n                    return 'toast://没有数据哦~'\\n                }\\n            }\\n            return \\\"toast://正在进入\\\" + input + \\\"界面...\\\";\\n        })\\n    }),\\n    col_type: \\\"icon_5\\\",\\n    extra: {\\n        id: '精彩继续'\\n    }\\n});\\n// 显示模式更改模块\\nd.push({\\n    title: getItem('模式', '双边'),\\n    img: getItem('模式', '双边') == '列表' ? imgLink.列表 : imgLink.双边,\\n    url: $('#noLoading#').lazyRule(() => {\\n        显示的剧集列表 = JSON.parse(getMyVar('显示的剧集列表'));\\n        if (getItem('模式', '双边') == '列表') {\\n            显示的剧集列表.forEach(el => {\\n                updateItem(el.link, {\\n                    col_type: 'movie_2',\\n                });\\n            });\\n            setItem('模式', '双边')\\n        } else {\\n            显示的剧集列表.forEach(el => {\\n                updateItem(el.link, {\\n                    col_type: 'movie_1_left_pic',\\n                });\\n            });\\n            setItem('模式', '列表')\\n        }\\n        imgLink = storage0.getMyVar('图标');\\n        updateItem('显示模式', {\\n            title: getItem('模式', '双边'),\\n            img: getItem('模式', '双边') == '列表' ? imgLink.列表 : imgLink.双边,\\n        });\\n        return 'toast://已切换模式为:' + getItem('模式', '双边')\\n    }),\\n    col_type: 'icon_5',\\n    extra: {\\n        id: '显示模式'\\n    }\\n}, {\\n    col_type: 'line_blank',\\n});\\n// 选插模块——局部刷新版\\n来源 = 'bl';\\nputMyVar('简插', $.toString(() => {\\n    let titleArr = []\\n    setFile = readFile('hiker://files/rules/DuanNian/MyParse.json');\\n    try {\\n        eval('json=' + setFile);\\n    } catch (e) {\\n        log('Json解析发生了错误:' + e.message);\\n    }\\n    titleArr = json.title;\\n    let barry1 = ['📝'];\\n    let barry2 = ['🔍'];\\n    titleArr = barry2.concat(titleArr);\\n    titleArr = barry1.concat(titleArr);\\n    eval('op=json.settings.' + 来源);\\n    titleArr = titleArr.map((it) => {\\n        return it === op ? '👉' + it : it;\\n    });\\n    putMyVar('解析数组', titleArr);\\n    putMyVar('setFile', setFile);\\n}))\\neval(getMyVar('简插'));\\nd.push({\\n    title: '解析：🔘<font color=\\\"' + Color + '\\\">' + op + '</font>\\\\t\\\\t页码：<font color=\\\"' + Color + '\\\">' + ((getMyVar('分集起', '首页') == '首页') ? '首页' : (getMyVar('分集起') + '-' + getMyVar('分集终'))) + '</font>',\\n    url: $('#noLoading#').lazyRule((json, 来源, Color, op, 影片名称, 搜索模式, 调用名称) => {\\n        eval(getMyVar('简插'));\\n        return $(eval(getMyVar('解析数组')), 3).select((json, 来源, Color, op, 影片名称, 搜索模式, 调用名称) => {\\n            setFile = getMyVar('setFile');\\n            input = input.replace(/👉/g, '');\\n            if (input === '📝') {\\n                return \\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=编辑#noHistory#\\\";\\n            } else if (input === '🔍') {\\n                if (搜索模式 == '分组') {\\n                    return \\\"hiker://search?s=\\\" + 影片名称 + \\\"&group=\\\" + 调用名称;\\n                } else {\\n                    return \\\"hiker://search?s=\\\" + 影片名称 + \\\"&rule=\\\" + 调用名称;\\n                }\\n            }\\n            // 原先的配置\\n            originSettings = JSON.stringify(json.settings);\\n            // 修改配置\\n            eval('json.settings.' + 来源 + '=input;');\\n            setFile = setFile.replace(originSettings, JSON.stringify(json.settings));\\n            saveFile('hiker://files/rules/DuanNian/MyParse.json', setFile);\\n            // 刷新元素\\n            eval(getMyVar('简插'));\\n            updateItem('op', {\\n                title: '解析：🔘<font color=\\\"' + Color + '\\\">' + op + '</font>\\\\t\\\\t页码：<font color=\\\"' + Color + '\\\">' + ((getMyVar('分集起', '首页') == '首页') ? '首页' : (getMyVar('分集起') + '-' + getMyVar('分集终'))) + '</font>',\\n            });\\n            return \\\"toast://切换解析口为:\\\" + input;\\n        }, json, 来源, Color, op, 影片名称, 搜索模式, 调用名称)\\n    }, json, 来源, Color, op, 影片名称, 搜索模式, 调用名称),\\n    img: 'https://lanmeiguojiang.com/tubiao/movie/20.svg',\\n    col_type: \\\"avatar\\\",\\n    extra: {\\n        id: 'op'\\n    }\\n});\\n// 滚动剧集条栏\\n剧集长度 = 剧集列表.length;\\nif (剧集长度 > 每页集数) {\\n    putMyVar('刷新选集', $.toString(() => {\\n        putMyVar('分集起', start);\\n        putMyVar('分集终', end);\\n        eval(getMyVar('简插'));\\n        updateItem('op', {\\n            title: '解析：🔘<font color=\\\"' + Color + '\\\">' + op + '</font>\\\\t\\\\t页码：<font color=\\\"' + Color + '\\\">' + ((getMyVar('分集起', '首页') == '首页') ? '首页' : (getMyVar('分集起') + '-' + getMyVar('分集终'))) + '</font>',\\n        })\\n        // 删除\\n        显示的剧集列表 = JSON.parse(getMyVar('显示的剧集列表'));\\n        显示的剧集列表.forEach(el => {\\n            deleteItem(el.link);\\n        });\\n        // 添加\\n        lazy = getMyVar('lazy');\\n        剧集列表 = JSON.parse(getMyVar('剧集列表'));\\n        显示的剧集列表 = 剧集列表.slice(start - 1, end);\\n        newArray = [];\\n        index = 1;\\n        显示的剧集列表.forEach(list => {\\n            if (getItem('模式', '双边') == '列表') {\\n                newArray.push({\\n                    title: list.long_title,\\n                    img: list.cover + \\\"@Referer=\\\",\\n                    url: list.link + lazy,\\n                    desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\n                    col_type: 'movie_1_left_pic',\\n                    extra: {\\n                        id: list.link,\\n                        aid: list.aid,\\n                        bvid: list.bvid,\\n                        cid: list.cid,\\n                        badge: list.badge\\n                    }\\n                });\\n            } else {\\n                newArray.push({\\n                    title: list.long_title,\\n                    img: list.cover + \\\"@Referer=\\\",\\n                    url: list.link + lazy,\\n                    desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\n                    col_type: 'movie_2',\\n                    extra: {\\n                        id: list.link,\\n                        aid: list.aid,\\n                        bvid: list.bvid,\\n                        cid: list.cid,\\n                        badge: list.badge\\n                    }\\n                });\\n            }\\n            index += 1;\\n        });\\n        addItemAfter(getMyVar('末页'), newArray);\\n        putMyVar('显示的剧集列表', 显示的剧集列表);\\n    }));\\n    d.push({\\n        col_type: 'scroll_button',\\n        url: 'hiker://empty',\\n        title: '∷',\\n        extra: {\\n            id: '占位符',\\n        }\\n    })\\n    putMyVar('分集起', 1);\\n    putMyVar('分集终', 每页集数);\\n    putMyVar('剧集列表', 剧集列表);\\n    总页数 = Math.ceil(剧集长度 / 每页集数);\\n    start = 1;\\n    end = 每页集数;\\n    for (let page = 1; page <= 总页数; page++) {\\n        if (end > 剧集长度) {\\n            end = 剧集长度;\\n        }\\n        d.push({\\n            title: start + '-' + end,\\n            url: $('#noLoading##noHistory#').lazyRule((start, end, Color, 来源) => {\\n                eval(getMyVar('刷新选集'));\\n                return \\\"hiker://empty\\\";\\n            }, start, end, Color, 来源),\\n            col_type: 'scroll_button',\\n            extra: {\\n                id: start + '-' + end\\n            }\\n        });\\n        if (end < 剧集长度) {\\n            start += 每页集数;\\n            end += 每页集数;\\n        }\\n    }\\n    // 记录末页的id\\n    putMyVar('末页', start + '-' + end);\\n} else {\\n    putMyVar('分集起', 1);\\n    putMyVar('分集终', 剧集长度);\\n}\\n// 展示剧集:\\n显示的剧集列表 = 剧集列表.slice(0, getMyVar('分集终'));\\nputMyVar('显示的剧集列表', 显示的剧集列表);\\nindex = 1;\\n显示的剧集列表.forEach(list => {\\n    if (getItem('模式', '双边') == '列表') {\\n        d.push({\\n            title: list.long_title,\\n            img: list.cover + \\\"@Referer=\\\",\\n            url: list.link + lazy,\\n            desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\n            col_type: 'movie_1_left_pic',\\n            extra: {\\n                id: list.link,\\n                aid: list.aid,\\n                bvid: list.bvid,\\n                cid: list.cid,\\n                badge: list.badge\\n            }\\n        });\\n    } else {\\n        d.push({\\n            title: list.long_title,\\n            img: list.cover + \\\"@Referer=\\\",\\n            url: list.link + lazy,\\n            desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\n            col_type: 'movie_2',\\n            extra: {\\n                id: list.link,\\n                aid: list.aid,\\n                bvid: list.bvid,\\n                cid: list.cid,\\n                badge: list.badge\\n            }\\n        });\\n    }\\n    index += 1;\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"up主页\",\"path\":\"upHome\",\"rule\":\"js:\\n\\nvar d = [];\\n\\n// 预处理\\n\\nputMyVar('upInfo', '关');\\n\\nsetPageTitle(MY_PARAMS.title);\\n\\nimgLink=storage0.getMyVar('图标');\\n\\n// 防止反爬虫，从上一个页面传递数据——反爬虫严重\\n\\nupMid = MY_PARAMS.mid + \\\"\\\";\\n\\nupName = MY_PARAMS.title;\\n\\nupFace = MY_PARAMS.face;\\n\\nrelation=$.require(\\\"hiker://page/api\\\").userMapping(upMid);\\n\\n// 头像栏\\n\\nd.push({\\n\\n    title: '<font color=\\\"blue\\\">' + upName + '</font>',\\n\\n    url: $('#noLoading#').lazyRule((upMid) => {\\n\\n        if (getMyVar('upInfo', '关') == '开') {\\n\\n            deleteItem('upInfo');\\n\\n            putMyVar('upInfo', '关');\\n\\n        } else {\\n\\n            // 用户基本信息——因为直接使用接口经常触发反爬虫机制故使用网页源码获取信息，而且只能fetchCodeByWebView\\n\\n            let u = \\\"https://m.bilibili.com/space/\\\" + upMid;\\n\\n            html = fetchCodeByWebView(u, {\\n\\n                blockRules: ['.png', '.jpg'],\\n\\n                timeout: 5000\\n\\n            });\\n\\n            infoCard = pdfa(html, '.info-card&&tr');\\n\\n            // 垃圾定位，我直接匹配处理字符串得了~\\n\\n            info='';\\n\\n            // 排除up封面数据\\n\\n            for (let i = 1; i < infoCard.length; i++) {\\n\\n                if (i==infoCard.length-1) {\\n\\n                    data=infoCard[i].replace('<tr>\\\\n <td>','').replace('</td>\\\\n</tr>','').replace('</td> \\\\n <td>',':')\\n\\n                }else{\\n\\n                    data=infoCard[i].replace('<tr>\\\\n <td>','').replace('</td>\\\\n</tr>','').replace('</td> \\\\n <td>',':')+'\\\\n'\\n\\n                }\\n\\n                info+=data;\\n\\n            }\\n\\n            addItemAfter('currentUp', {\\n\\n                title: info,\\n\\n                url: 'hiker://empty',\\n\\n                col_type: 'long_text',\\n\\n                extra: {\\n\\n                    id: 'upInfo'\\n\\n                }\\n\\n            });\\n\\n            putMyVar('upInfo', '开');\\n\\n        }\\n\\n        return 'toast://信息折叠:' + getMyVar('upInfo', '开')\\n\\n    }, upMid),\\n\\n    img: upFace + \\\"@Referer=\\\",\\n\\n    col_type: \\\"avatar\\\",\\n\\n    extra: {\\n\\n        id: 'currentUp'\\n\\n    }\\n\\n},{\\n\\n    col_type: 'line'\\n\\n});\\n\\n// 公告\\n\\nnoticeText = JSON.parse(fetch('https://api.bilibili.com/x/space/notice?mid=' + upMid + '&jsonp=jsonp', {\\n\\n    headers: {\\n\\n        \\\"User-Agent\\\": PC_UA,\\n\\n        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n\\n    }\\n\\n})).data;\\n\\nif (noticeText != '') {\\n\\n    d.push({\\n\\n        title: '公告',\\n\\n        url: $().rule((noticeText) => {\\n\\n            var d = [];\\n\\n            d.push({\\n\\n                title: '公告：' + '\\\\n\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t\\\\t' + noticeText,\\n\\n                col_type: 'long_text'\\n\\n            });\\n\\n            setHomeResult(d);\\n\\n        }, noticeText),\\n\\n        desc: noticeText == '' ? '暂无公告' : noticeText,\\n\\n        col_type: 'text_1',\\n\\n    });\\n\\n}\\n\\nd.push({\\n\\n    col_type: 'line'\\n\\n}, {\\n\\n    title: relation,\\n\\n    img: relation=='未关注'?imgLink.添加关注:imgLink.已关注,\\n\\n    url: $('#noLoading##noHistory#').lazyRule((upMid) => {\\n\\n        return $.require(\\\"hiker://page/api\\\").changeUserRelation(upMid, 11)\\n\\n    }, upMid),\\n\\n    col_type: \\\"icon_small_4\\\",\\n\\n    extra:{\\n\\n        id:'relation'\\n\\n    }\\n\\n}, {\\n\\n    title: '动态',\\n\\n    img: imgLink.动态,\\n\\n    url: $('#noLoading##noHistory#').lazyRule((upMid) => {\\n\\n        return $('hiker://empty?p=fypage').rule((upMid)=>{\\n\\n            let d=[];\\n\\n            latenews=$.require(\\\"hiker://page/api\\\").getDynamicData('upSpace',upMid);\\n\\n            eval($.require(\\\"hiker://page/api\\\").showDynamicData());\\n\\n            setResult(d);\\n\\n        },upMid)\\n\\n    }, upMid),\\n\\n    col_type: \\\"icon_small_4\\\",\\n\\n},{\\n\\n    title: '专栏',\\n\\n    img: imgLink.专栏,\\n\\n    url: \\\"hiker://page/acticleList?p=fypage\\\",\\n\\n    col_type: \\\"icon_small_4\\\",\\n\\n    extra: {\\n\\n        mid: upMid\\n\\n    }\\n\\n})\\n\\n// 用户视频-合集、系列\\n\\nupVideo = JSON.parse(fetch('https://api.bilibili.com/x/polymer/space/seasons_series_list?mid=' + upMid + '&page_num=1&page_size=10', {\\n\\n    headers: {\\n\\n        \\\"User-Agent\\\": PC_UA,\\n\\n        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n\\n    }\\n\\n})).data.items_lists;\\n\\n// 视频合集、系列\\n\\ntry {\\n\\n    upVideo.seasons_list.forEach(list => {\\n\\n        season_id = list.meta.season_id;\\n\\n        // 标题-跳转更多\\n\\n        d.push({\\n\\n            title: '<font color=\\\"#33cccc\\\">' + list.meta.name.substring(0, 30) + '</font>\\\\t\\\\t<font color=\\\"red\\\">' + list.meta.total + '</font>    ➮',\\n\\n            img: 'https://lanmeiguojiang.com/tubiao/more/137.png@Referer=',\\n\\n            // img: list.meta.cover+'@Referer=',\\n\\n            col_type: 'avatar',\\n\\n            url: $('#noLoading##noHistory#').lazyRule((upMid, season_id) => {\\n\\n                return $('hiker://empty?fypage').rule((upMid, season_id) => {\\n\\n                    var d = [];\\n\\n                    let u = 'https://api.bilibili.com/x/polymer/space/seasons_archives_list?mid=' + upMid + '&season_id=' + season_id + '&sort_reverse=false&page_num=' + MY_PAGE + '&page_size=30';\\n\\n                    Video = JSON.parse(fetch(u, {\\n\\n                        headers: {\\n\\n                            \\\"User-Agent\\\": PC_UA,\\n\\n                            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n\\n                        }\\n\\n                    })).data;\\n\\n                    maxPage = Math.ceil(Video.page.total / Video.page.page_size);\\n\\n                    if (MY_PAGE <= maxPage) {\\n\\n                        d.push({\\n\\n                            title: '当前:第' + Video.page.page_num + '页\\\\t\\\\t\\\\t共有' + maxPage + '页,' + Video.page.total + '条数据',\\n\\n                            url: \\\"hiker://empty\\\",\\n\\n                            col_type: \\\"text_center_1\\\",\\n\\n                        });\\n\\n                        Video.archives.forEach(list => {\\n\\n                            d.push({\\n\\n                                title: list.title,\\n\\n                                img: list.pic + '@Referer=',\\n\\n                                desc: '播放量：' + list.stat.view,\\n\\n                                col_type: 'movie_1_left_pic',\\n\\n                                url: \\\"hiker://page/video\\\",\\n\\n                                extra: {\\n\\n                                    aid: list.aid\\n\\n                                }\\n\\n                            });\\n\\n                        });\\n\\n                    }\\n\\n                    setHomeResult(d);\\n\\n                }, upMid, season_id)\\n\\n            }, upMid, season_id)\\n\\n        });\\n\\n        if (list.archives === undefined) {\\n\\n            log(list.meta.name + '为空');\\n\\n        } else {\\n\\n            if (list.archives.length < 2) {\\n\\n                list.archives.forEach(list => {\\n\\n                    d.push({\\n\\n                        title: list.title,\\n\\n                        img: list.pic + '@Referer=',\\n\\n                        desc: '播放量：' + list.stat.view,\\n\\n                        col_type: 'movie_1_left_pic',\\n\\n                        url: \\\"hiker://page/video\\\",\\n\\n                        extra: {\\n\\n                            aid: list.aid\\n\\n                        }\\n\\n                    });\\n\\n                });\\n\\n            } else if (list.archives.length == 0) {\\n\\n                d.push({\\n\\n                    title: \\\"好家伙，这家伙没有合集视频！\\\",\\n\\n                    desc: \\\"要不去点击全部视频看看~\\\",\\n\\n                    col_type: 'text_center_1',\\n\\n                    url: \\\"hiker://empty\\\",\\n\\n                });\\n\\n            } else {\\n\\n                for (let i = 0; i < 2; i++) {\\n\\n                    d.push({\\n\\n                        title: list.archives[i].title,\\n\\n                        img: list.archives[i].pic + '@Referer=',\\n\\n                        desc: '播放量：' + list.archives[i].stat.view,\\n\\n                        col_type: 'movie_1_left_pic',\\n\\n                        url: \\\"hiker://page/video\\\",\\n\\n                        extra: {\\n\\n                            aid: list.archives[i].aid\\n\\n                        }\\n\\n                    });\\n\\n                }\\n\\n            }\\n\\n        }\\n\\n    });\\n\\n} catch (e) {\\n\\n    d.push({\\n\\n        title: '合集为空',\\n\\n        url: 'hiker://empty',\\n\\n        desc: 'Sorry,没有数据呢~',\\n\\n        col_type: 'text_center_1',\\n\\n    });\\n\\n}\\n\\ntry {\\n\\n    upVideo.series_list.forEach(list => {\\n\\n        series_id = list.meta.series_id;\\n\\n        // 标题-跳转更多\\n\\n        d.push({\\n\\n            title: '<font color=\\\"#33cccc\\\">' + list.meta.name.substring(0, 30) + '</font>\\\\t\\\\t<font color=\\\"red\\\">' + list.meta.total + '</font>    ➮',\\n\\n            img: 'https://lanmeiguojiang.com/tubiao/more/137.png@Referer=',\\n\\n            // img: list.meta.cover+'@Referer=',\\n\\n            col_type: 'avatar',\\n\\n            url: $('#noLoading##noHistory#').lazyRule((upMid, series_id) => {\\n\\n                return $('hiker://empty?fypage').rule((upMid, series_id) => {\\n\\n                    var d = [];\\n\\n                    let u = 'https://api.bilibili.com/x/series/archives?mid=' + upMid + '&series_id=' + series_id + '&only_normal=true&sort=desc&pn=' + MY_PAGE + '&ps=30';\\n\\n                    Video = JSON.parse(fetch(u, {\\n\\n                        headers: {\\n\\n                            \\\"User-Agent\\\": PC_UA,\\n\\n                            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n\\n                        }\\n\\n                    })).data;\\n\\n                    maxPage = Math.ceil(Video.page.total / Video.page.size);\\n\\n                    if (MY_PAGE <= maxPage) {\\n\\n                        d.push({\\n\\n                            title: '当前:第' + Video.page.num + '页\\\\t\\\\t\\\\t共有' + maxPage + '页,' + Video.page.total + '条数据',\\n\\n                            url: \\\"hiker://empty\\\",\\n\\n                            col_type: \\\"text_center_1\\\",\\n\\n                        });\\n\\n                        Video.archives.forEach(list => {\\n\\n                            d.push({\\n\\n                                title: list.title,\\n\\n                                img: list.pic + '@Referer=',\\n\\n                                desc: '播放量：' + list.stat.view,\\n\\n                                col_type: 'movie_1_left_pic',\\n\\n                                url: \\\"hiker://page/video\\\",\\n\\n                                extra: {\\n\\n                                    aid: list.aid\\n\\n                                }\\n\\n                            });\\n\\n                        });\\n\\n                    }\\n\\n                    setHomeResult(d);\\n\\n                }, upMid, series_id)\\n\\n            }, upMid, series_id)\\n\\n        });\\n\\n        if (list.archives === undefined) {\\n\\n            log(list.meta.name + '为空');\\n\\n        } else {\\n\\n            if (list.archives.length < 2) {\\n\\n                list.archives.forEach(list => {\\n\\n                    d.push({\\n\\n                        title: list.title,\\n\\n                        img: list.pic + '@Referer=',\\n\\n                        desc: '播放量：' + list.stat.view,\\n\\n                        col_type: 'movie_1_left_pic',\\n\\n                        url: \\\"hiker://page/video\\\",\\n\\n                        extra: {\\n\\n                            aid: list.aid\\n\\n                        }\\n\\n                    });\\n\\n                });\\n\\n            } else if (list.archives.length == 0) {\\n\\n                d.push({\\n\\n                    title: \\\"好家伙，这家伙没有合集视频！\\\",\\n\\n                    desc: \\\"要不去点击全部视频看看~\\\",\\n\\n                    col_type: 'text_center_1',\\n\\n                    url: \\\"hiker://empty\\\",\\n\\n                });\\n\\n            } else {\\n\\n                for (let i = 0; i < 2; i++) {\\n\\n                    d.push({\\n\\n                        title: list.archives[i].title,\\n\\n                        img: list.archives[i].pic + '@Referer=',\\n\\n                        desc: '播放量：' + list.archives[i].stat.view,\\n\\n                        col_type: 'movie_1_left_pic',\\n\\n                        url: \\\"hiker://page/video\\\",\\n\\n                        extra: {\\n\\n                            aid: list.archives[i].aid\\n\\n                        }\\n\\n                    });\\n\\n                }\\n\\n            }\\n\\n        }\\n\\n    });\\n\\n} catch (e) {\\n\\n    d.push({\\n\\n        title: '系列为空',\\n\\n        url: 'hiker://empty',\\n\\n        desc: 'Sorry,没有数据呢~',\\n\\n        col_type: 'text_center_1',\\n\\n    });\\n\\n}\\n\\n// up投稿\\n\\nd.push({\\n\\n    title: 'TA的视频,点击展开全部',\\n\\n    col_type: 'text_center_1',\\n\\n    url: $('#noLoading##noHistory#').lazyRule((upMid) => {\\n\\n        return $().rule((upMid) => {\\n\\n            var d = [];\\n\\n            try {\\n\\n                upTotalVideoInfo = JSON.parse(fetch('https://api.bilibili.com/x/space/arc/search?mid=' + upMid + '&pn=' + getMyVar('_page', '1') + '&ps=25&index=1&jsonp=jsonp', {\\n\\n                    headers: {\\n\\n                        \\\"User-Agent\\\": PC_UA,\\n\\n                        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n\\n                    }\\n\\n                }));\\n\\n                if (upTotalVideoInfo.message == '啥都木有') {\\n\\n                    d.push({\\n\\n                        title: '啥都木有...',\\n\\n                        img: 'https://pic.imgdb.cn/item/632c204e16f2c2beb13652aa.jpg@Referer=',\\n\\n                        url: 'hiker://empty',\\n\\n                        desc: '不小心来到了真空的世界~',\\n\\n                        col_type: \\\"pic_1\\\"\\n\\n                    });\\n\\n                } else {\\n\\n                    upTotalVideo = upTotalVideoInfo.data;\\n\\n                    maxPage = Math.ceil(upTotalVideo.page.count / upTotalVideo.page.ps);\\n\\n                    for (let page = 1; page <= maxPage; page++) {\\n\\n                        d.push({\\n\\n                            title: (page + \\\"\\\") == getMyVar('_page', '1') ? '‘‘’’<font color=\\\"red\\\">' + (page + \\\"\\\") + '</font>' : (page + \\\"\\\"),\\n\\n                            url: $('#noLoading##noHistory#').lazyRule((page) => {\\n\\n                                putMyVar('_page', (page + \\\"\\\"));\\n\\n                                refreshPage(true);\\n\\n                                return \\\"hiker://empty\\\";\\n\\n                            }, page),\\n\\n                            col_type: 'scroll_button',\\n\\n                        });\\n\\n                    }\\n\\n                    upTotalVideo.list.vlist.forEach(list => {\\n\\n                        d.push({\\n\\n                            title: list.title,\\n\\n                            img: list.pic + '@Referer=',\\n\\n                            desc: '播放量：' + list.play,\\n\\n                            col_type: 'movie_1_left_pic',\\n\\n                            url: \\\"hiker://page/video\\\",\\n\\n                            extra: {\\n\\n                                aid: list.aid\\n\\n                            }\\n\\n                        });\\n\\n                    });\\n\\n                }\\n\\n            } catch (e) {\\n\\n                d.push({\\n\\n                    title: '页面走丢了...',\\n\\n                    img: 'https://i0.hdslb.com/bfs/general/f7b667011a46615732c701f4bb1d07f793f8d1df.png@Referer=',\\n\\n                    url: 'hiker://empty',\\n\\n                    desc: '太频繁了！稍后再试~',\\n\\n                    col_type: \\\"pic_1\\\"\\n\\n                });\\n\\n            }\\n\\n            setHomeResult(d);\\n\\n        }, upMid)\\n\\n    }, upMid)\\n\\n});\\n\\nsetResult(d);\\n\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"up搜索\",\"path\":\"upSearch\",\"rule\":\"js:\\n\\nseaword = MY_PARAMS.seaword;\\n\\nvar d = [];\\n\\ncookie = JSON.parse(fetchCookie('https://www.bilibili.com/', {\\n\\n    headers: {\\n\\n        \\\"User-Agent\\\": PC_UA,\\n\\n        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n\\n    },\\n\\n    method: \\\"GET\\\"\\n\\n}))[1];\\n\\nresultData = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/search/type?__refresh__=true&_extra=&context=&page=\\\" + MY_PAGE + \\\"&page_size=36&order=&duration=&from_source=&from_spmid=333.337&platform=pc&highlight=1&single_column=0&keyword=\\\" + seaword + \\\"&qv_id=R2IhBDb0XZ8EM69clo2rwesz9L4wRgZy&category_id=&search_type=bili_user&order_sort=0&user_type=0&dynamic_offset=0&preload=true&com2co=true\\\", {\\n\\n    headers: {\\n\\n        \\\"User-Agent\\\": PC_UA,\\n\\n        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n\\n        \\\"Cookie\\\": cookie\\n\\n    },\\n\\n    method: \\\"GET\\\"\\n\\n})).data;\\n\\nif (MY_PAGE <= resultData.numPages) {\\n\\n    d.push({\\n\\n        title: '当前:第' + resultData.page + '页\\\\t\\\\t\\\\t共有' + resultData.numPages + '页,' + resultData.numResults + '条数据',\\n\\n        url: \\\"hiker://empty\\\",\\n\\n        col_type: \\\"text_center_1\\\",\\n\\n    });\\n\\n    resultData.result.forEach(list => {\\n\\n        d.push({\\n\\n            title: \\\"<big><font color='blue'>\\\" + list.uname + \\\"</font></big><small>\\\" + list.usign + \\\"</small>\\\",\\n\\n            img: 'https://' + list.upic + \\\"@Referer=\\\",\\n\\n            col_type: 'avatar',\\n\\n            url: \\\"hiker://page/upHome\\\",\\n\\n            extra: {\\n\\n                mid: list.mid,\\n\\n                title: list.uname,\\n\\n                face: 'https://' + list.upic\\n\\n            }\\n\\n        });\\n\\n    });\\n\\n}\\n\\nsetSearchResult(d);\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"video搜索\",\"path\":\"videoSearch\",\"rule\":\"js:\\n\\nseaword = MY_PARAMS.seaword;\\n\\nvar d = [];\\n\\ncookie = JSON.parse(fetchCookie('https://www.bilibili.com/', {\\n\\n    headers: {\\n\\n        \\\"User-Agent\\\": PC_UA,\\n\\n        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n\\n    },\\n\\n    method: \\\"GET\\\"\\n\\n}))[1];\\n\\nresultData = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/search/type?__refresh__=true&_extra=&context=&page=\\\" + MY_PAGE + \\\"&page_size=42&from_source=&from_spmid=333.337&platform=pc&highlight=1&single_column=0&keyword=\\\" + seaword + \\\"&qv_id=vTtUT4Rfhzt2pPz9p5Wu3ZI9QQgUfxsA&category_id=&search_type=video&dynamic_offset=0&preload=true&com2co=true\\\", {\\n\\n    headers: {\\n\\n        \\\"User-Agent\\\": PC_UA,\\n\\n        \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n\\n        \\\"Cookie\\\": cookie\\n\\n    },\\n\\n    method: \\\"GET\\\"\\n\\n})).data;\\n\\nif (MY_PAGE <= resultData.numPages) {\\n\\n    d.push({\\n\\n        title: '当前:第' + resultData.page + '页\\\\t\\\\t\\\\t共有' + resultData.numPages + '页,' + resultData.numResults + '条数据',\\n\\n        url: \\\"hiker://empty\\\",\\n\\n        col_type: \\\"text_center_1\\\",\\n\\n    });\\n\\n    resultData.result.forEach(list => {\\n\\n        // title=list.title.replace('<em class=\\\\\\\"keyword\\\\\\\">','<font color=\\\"red\\\">').replace('</em>','</font>')\\n\\n        title = list.title.replace(/<em class=\\\\\\\"keyword\\\\\\\">/g, '').replace(/<\\\\/em>/g, '')\\n\\n        d.push({\\n\\n            title: title,\\n\\n            img: 'https://' + list.pic + \\\"@Referer=\\\",\\n\\n            desc: list.description,\\n\\n            col_type: 'movie_1_left_pic',\\n\\n            url: \\\"hiker://page/video\\\",\\n\\n            extra: {\\n\\n                // 视频标识\\n\\n                aid: list.aid,\\n\\n                title: title\\n\\n            }\\n\\n        });\\n\\n    });\\n\\n}\\n\\nsetSearchResult(d);\\n\\n\"},{\"col_type\":\"movie_1_left_pic\",\"name\":\"推送\",\"path\":\"feed\",\"rule\":\"$.require(\\\"hiker://page/api\\\").getFeed().forEach(item => {\\n\\n    d.push({\\n\\n        title: item.title,\\n\\n        img: item.pic+'@Referer=',\\n\\n        desc: 'up:' + item.owner.name + '\\\\n' + item.stat.view + \\\"播放※\\\" + item.stat.like + \\\"点赞\\\",\\n\\n        url: \\\"hiker://page/video\\\",\\n\\n        col_type: 'movie_1_left_pic',\\n\\n        extra: {\\n\\n            // id其实是aid\\n\\n            aid: item.id,\\n\\n            cid: item.cid,\\n\\n        }\\n\\n    })\\n\\n})\\n\\n\\n\"},{\"col_type\":\"text_1\",\"name\":\"API\",\"path\":\"api\",\"rule\":\"// part1:聚合函数----------------\\n// 登录验证\\n$.exports.isLoggedIn = function () {\\n    if (fileExist(\\\"hiker://files/rules/cy/bili.txt\\\")) {\\n        biliDate = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\"));\\n        var cookie = biliDate.cookie;\\n        let userinfo = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/nav\\\", {\\n            headers: {\\n                \\\"Cookie\\\": cookie\\n            }\\n        })).data;\\n        if (userinfo.isLogin === false) {\\n            return JSON.stringify({\\n                \\\"userName\\\": '未登录',\\n                \\\"userMid\\\": '',\\n                \\\"userFace\\\": '',\\n                \\\"type\\\": false\\n            })\\n        } else {\\n            biliDate.userName = userinfo.uname;\\n            biliDate.userMid = userinfo.mid;\\n            biliDate.face = userinfo.face + \\\"@Referer=\\\";\\n            saveFile('hiker://files/rules/cy/bili.txt', JSON.stringify(biliDate));\\n            // return true;\\n            return JSON.stringify({\\n                \\\"userName\\\": biliDate.userName,\\n                \\\"userMid\\\": biliDate.userMid,\\n                \\\"userFace\\\": biliDate.face,\\n                \\\"type\\\": true\\n            });\\n        }\\n    } else {\\n        return JSON.stringify({\\n            \\\"userName\\\": '未登录',\\n            \\\"userMid\\\": '',\\n            \\\"userFace\\\": '',\\n            \\\"type\\\": false\\n        });\\n    }\\n}\\n// 哔哩视频解析：获取播放地址+提交播放记录\\n$.exports.biliLazy = function (id, cid, qn) {\\n    var dash = $.require(\\\"hiker://page/api\\\").getUrl(id, cid, qn);\\n    // 提交历史记录\\n    $.require(\\\"hiker://page/api\\\").reportProcess(id, cid);\\n    // qualityNum=dash.audio.length;不需要了，找到了更好的判断方法，虽然我并不知道这些参数的含义是什么\\n    videoList = [];\\n    audioList = [];\\n    nameList = [];\\n    heraders = [];\\n    dash.audio.forEach(item => {\\n        audioList.push(item.baseUrl);\\n        heraders.push({\\n            \\\"User-Agent\\\": PC_UA,\\n            \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n        });\\n    });\\n    dash.video.forEach(item => {\\n        if (item.codecid == 7) {\\n            videoList.push(item.baseUrl + \\\"#isVideo=true#\\\");\\n            if (item.id == 126) {\\n                nameList.push('杜比视界');\\n            }else if (item.id == 125) {\\n                nameList.push('HDR 真彩色');\\n            }else if (item.id == 120) {\\n                nameList.push('4K超清');\\n            } else if (item.id == 116) {\\n                nameList.push('1080P60高帧率');\\n            } else if (item.id == 112) {\\n                nameList.push('1080P+高码率');\\n            }else if (item.id == 80) {\\n                nameList.push('1080P高清');\\n            }else if (item.id == 74) {\\n                nameList.push('720P60高帧率');\\n            }else if (item.id == 64) {\\n                nameList.push('720P高清');\\n            }else if (item.id == 32) {\\n                nameList.push('480P清晰');\\n            }else if (item.id == 16) {\\n                nameList.push('360P流畅');\\n            }else if (item.id == 6) {\\n                nameList.push('240P极速');\\n            }\\n        }\\n    });\\n    return JSON.stringify({\\n        urls: videoList,\\n        audioUrls: audioList,\\n        danmu: 'https://comment.bilibili.com/' + cid + '.xml',\\n        names: nameList,\\n        headers: heraders\\n    })\\n}\\n// 稍后在看——总操作判断\\n$.exports.judgeToview = function (aid) {\\n    selection = ['添加', '移除'];\\n    return $(selection, 1).select((aid) => {\\n        if (input == '添加') {\\n            res = $.require(\\\"hiker://page/api\\\").addToview(aid);\\n            if (res == 0) {\\n                return \\\"toast://添加成功\\\"\\n            } else if (res == -101) {\\n                return \\\"toast://账号未登录\\\"\\n            } else if (res == -111) {\\n                return \\\"toast://csrf校验失败\\\"\\n            } else if (res == -400) {\\n                return \\\"toast://请求错误\\\"\\n            } else if (res == 90001) {\\n                return \\\"toast://列表已满\\\"\\n            } else if (res == 90003) {\\n                return \\\"toast://稿件已经被删除\\\"\\n            } else {\\n                return \\\"toast://未知错误\\\"\\n            }\\n        } else {\\n            res = $.require(\\\"hiker://page/api\\\").delToview(aid);\\n            if (res == 0) {\\n                return \\\"toast://移除成功\\\"\\n            } else if (res == -101) {\\n                return \\\"toast://账号未登录\\\"\\n            } else if (res == -111) {\\n                return \\\"toast://csrf校验失败\\\"\\n            } else if (res == -400) {\\n                return \\\"toast://请求错误\\\"\\n            } else {\\n                return \\\"toast://未知错误\\\"\\n            }\\n        }\\n    }, aid)\\n}\\n// 操作用户关系\\n$.exports.changeUserRelation = function (mid, re_src) {\\n    selection = ['关注', '取关', '悄悄关注', '取消悄悄关注', '拉黑', '取消拉黑', '踢出粉丝', '移动分组'];\\n    return $(selection, 2).select((mid, re_src) => {\\n        if (input == '移动分组') {\\n            beforeTagids = [];\\n            groups = $.require(\\\"hiker://page/api\\\").getUserGroup(mid);\\n            if (JSON.stringify(groups) == '{}') {\\n                beforeTagids.push(0);\\n            } else {\\n                for (var prop in groups) {\\n                    beforeTagids.push(parseInt(prop));\\n                }\\n            }\\n            // 获取我的分组\\n            focusGroupList = [];\\n            $.require(\\\"hiker://page/api\\\").getMyAttentionGroupList().forEach(list => {\\n                focusGroupList.push(list.name + ' ' + list.tagid);\\n            });\\n            return $(focusGroupList, 1).select((beforeTagids, mid) => {\\n                afterTagids = [];\\n                afterTagids.push(parseInt(input.split(' ')[1]));\\n                fids = [];\\n                fids.push(Number(mid));\\n                res = $.require(\\\"hiker://page/api\\\").moveUsers(beforeTagids, afterTagids, fids);\\n                if (res == 0) {\\n                    return \\\"toast://移动用户到\\\" + input.split(' ')[0] + \\\"分组成功\\\"\\n                } else if (res == -101) {\\n                    return \\\"toast://账号未登录\\\"\\n                } else if (res == -111) {\\n                    return \\\"toast://csrf校验失败\\\"\\n                } else if (res == -400) {\\n                    return \\\"toast://请求错误\\\"\\n                } else if (res == 22104) {\\n                    return \\\"toast://无权限\\\"\\n                } else if (res == 22105) {\\n                    return \\\"toast://未关注\\\"\\n                } else {\\n                    return \\\"toast://未知错误\\\"\\n                }\\n            }, beforeTagids, mid);\\n        } else {\\n            if (input == '关注') {\\n                var act = 1;\\n            } else if (input == '取关') {\\n                var act = 2;\\n            } else if (input == '悄悄关注') {\\n                var act = 3;\\n            } else if (input == '取消悄悄关注') {\\n                var act = 4;\\n            } else if (input == '拉黑') {\\n                var act = 5;\\n            } else if (input == '取消拉黑') {\\n                var act = 6;\\n            } else if (input == '踢出粉丝') {\\n                var act = 7;\\n            }\\n            res = $.require(\\\"hiker://page/api\\\").addAttention(mid, act, re_src);\\n            relation = $.require(\\\"hiker://page/api\\\").userMapping(mid);\\n            updateItem('relation', {\\n                title: relation,\\n                img: relation == '未关注' ? storage0.getMyVar('图标').添加关注 : storage0.getMyVar('图标').已关注\\n            });\\n            if (res == 0) {\\n                return \\\"toast://\\\" + input + \\\"成功\\\"\\n            } else if (res == -101) {\\n                return \\\"toast://账号未登录\\\"\\n            } else if (res == -111) {\\n                return \\\"toast://csrf校验失败\\\"\\n            } else if (res == -400) {\\n                return \\\"toast://请求错误\\\"\\n            } else if (res == 22001) {\\n                return \\\"toast://不能对自己进行此操作\\\"\\n            } else if (res == 22003) {\\n                return \\\"toast://用户位于黑名单\\\"\\n            } else {\\n                return \\\"toast://未知错误\\\"\\n            }\\n        }\\n    }, mid, re_src)\\n}\\n// 映射用户关系\\n$.exports.userMapping = function (mid) {\\n    relationRes = $.require(\\\"hiker://page/api\\\").getRelation(mid);\\n    if (relationRes.relation.attribute == 0) {\\n        relation = '未关注'\\n    } else if (relationRes.relation.attribute == 1) {\\n        relation = '悄悄关注'\\n    } else if (relationRes.relation.attribute == 2) {\\n        relation = '已关注'\\n    } else if (relationRes.relation.attribute == 6) {\\n        relation = '已互粉'\\n    } else if (relationRes.relation.attribute == 128) {\\n        relation = '已拉黑'\\n    }\\n    return relation;\\n}\\n// 点赞操作逻辑\\n$.exports.likeLogic = function (aid) {\\n    hasLike = $.require(\\\"hiker://page/api\\\").hasLike(aid);\\n    if (hasLike == 0) {\\n        res = $.require(\\\"hiker://page/api\\\").setLike(aid, 1);\\n        if (res == 0) {\\n            like = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\" + aid)).data.stat.like;\\n            updateItem('setLike', {\\n                title: (like + 1) + '',\\n                img: storage0.getMyVar('图标').已点赞\\n            });\\n            return \\\"toast://点赞成功\\\";\\n        } else {\\n            return \\\"toast://点赞出错了~\\\";\\n        }\\n    } else {\\n        res = $.require(\\\"hiker://page/api\\\").setLike(aid, 2);\\n        if (res == 0) {\\n            like = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\" + aid)).data.stat.like;\\n            updateItem('setLike', {\\n                title: (like - 1) + '',\\n                img: storage0.getMyVar('图标').未点赞\\n            });\\n            return \\\"toast://取消点赞成功\\\";\\n        } else {\\n            return \\\"toast://取消点赞出错了~\\\";\\n        }\\n    }\\n}\\n// 收藏操作逻辑\\n$.exports.favourLogic = function (aid, mid) {\\n    hasFavour = $.require(\\\"hiker://page/api\\\").hasFavour(aid);\\n    if (hasFavour) {\\n        // 移出收藏\\n        favourIdList = $.require(\\\"hiker://page/api\\\").getFavourIdList(aid, mid);\\n        res = $.require(\\\"hiker://page/api\\\").setFavour(aid, '', favourIdList);\\n        if (res == 0) {\\n            like = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\" + aid)).data.stat.favorite;\\n            updateItem('setFavour', {\\n                title: (like - 1) + '',\\n                img: storage0.getMyVar('图标').未收藏\\n            });\\n            return \\\"toast://取消收藏成功\\\";\\n        } else {\\n            return \\\"toast://取消收藏出错了~\\\";\\n        }\\n    } else {\\n        // 选择收藏\\n        res = $.require(\\\"hiker://page/api\\\").getCollectionGroupList()[0].mediaListResponse.list;\\n        GroupList = [];\\n        res.forEach(item => {\\n            GroupList.push(item.title + ' ' + item.id);\\n        });\\n        return $(GroupList, 1).select((aid) => {\\n            selectId = parseInt(input.split(' ')[1])\\n            res = $.require(\\\"hiker://page/api\\\").setFavour(aid, selectId, '');\\n            if (res == 0) {\\n                like = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\" + aid)).data.stat.favorite;\\n                updateItem('setFavour', {\\n                    title: (like + 1) + '',\\n                    img: storage0.getMyVar('图标').已收藏\\n                });\\n                return \\\"toast://收藏成功\\\";\\n            } else {\\n                return \\\"toast://收藏出错了~\\\";\\n            }\\n        }, aid);\\n    }\\n}\\n\\n\\n\\n// part2:散装API----------------\\n// 视频推荐\\n$.exports.getFeed = function () {\\n    let u = \\\"https://api.bilibili.com/x/web-interface/index/top/feed/rcmd\\\";\\n    var res = JSON.parse(fetch(u, {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    }));\\n    return res.data.item\\n}\\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        \\\"fnver\\\": 0,\\n        \\\"fnval\\\": 4048,\\n        \\\"fourk\\\": 1\\n    }), {\\n        headers: {\\n            Cookie: JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })\\n    return JSON.parse(u).data.dash\\n}\\n// 提交播放记录\\n$.exports.reportProcess = function (avid, cid) {\\n    // let csrf = readFile(\\\"Cookie.txt\\\").match(/bili_jct=(.*?);/)[1]\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.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: JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })\\n}\\n\\n// 获取评论\\n$.exports.getComments = function (id, type, page) {\\n    let u = buildUrl(\\\"http://api.bilibili.com/x/v2/reply\\\", {\\n        \\\"type\\\": type,\\n        \\\"oid\\\": id,\\n        \\\"pn\\\": page\\n    });\\n    let res = request(u, {\\n        headers: {\\n            Cookie: JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })\\n    return JSON.parse(res).data.replies\\n}\\n// 添加稍后在看——真的麻了，为什么fetch就错呢~\\n$.exports.addToview = function (aid) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let u = \\\"https://api.bilibili.com/x/v2/history/toview/add\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"aid\\\": aid,\\n        \\\"csrf\\\": csrf,\\n    }), {\\n        headers: {\\n            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        },\\n        method: \\\"POST\\\"\\n    })\\n    return JSON.parse(res).code;\\n}\\n// 删除稍后在看\\n$.exports.delToview = function (aid) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let u = \\\"http://api.bilibili.com/x/v2/history/toview/del\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"aid\\\": aid,\\n        \\\"csrf\\\": csrf,\\n    }), {\\n        headers: {\\n            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        },\\n        method: \\\"POST\\\"\\n    })\\n    return JSON.parse(res).code;\\n}\\n// 订阅影视(追番、追剧)\\n$.exports.subscribeFilm = function (season_id) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let u = \\\"https://api.bilibili.com/pgc/web/follow/add\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"season_id\\\": season_id,\\n        \\\"csrf\\\": csrf,\\n    }), {\\n        headers: {\\n            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        },\\n        method: \\\"POST\\\"\\n    })\\n    return JSON.parse(res).result.toast;\\n}\\n// 取消订阅\\n$.exports.cancelSubscribeFilm = function (season_id) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let u = \\\"https://api.bilibili.com/pgc/web/follow/del\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"season_id\\\": season_id,\\n        \\\"csrf\\\": csrf,\\n    }), {\\n        headers: {\\n            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        },\\n        method: \\\"POST\\\"\\n    })\\n    return JSON.parse(res).result.toast;\\n}\\n/*操作用户关系\\nfid:用户mid\\nact:操作代码\\nre_src：关注来源\\n*/\\n$.exports.addAttention = function (mid, act, re_src) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let u = \\\"https://api.bilibili.com/x/relation/modify\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"fid\\\": mid,\\n        \\\"act\\\": act,\\n        \\\"re_src\\\": re_src,\\n        \\\"csrf\\\": csrf\\n    }), {\\n        headers: {\\n            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        },\\n        method: \\\"POST\\\"\\n    })\\n    return JSON.parse(res).code;\\n}\\n// 移动关注用户分组\\n$.exports.moveUsers = function (beforeTagids, afterTagids, fids) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let u = \\\"https://api.bilibili.com/x/relation/tags/moveUsers\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"beforeTagids\\\": beforeTagids.toString(),\\n        \\\"afterTagids\\\": afterTagids.toString(),\\n        \\\"fids\\\": fids.toString(),\\n        \\\"csrf\\\": csrf\\n    }), {\\n        headers: {\\n            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\",\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        },\\n        method: \\\"POST\\\"\\n    })\\n    return JSON.parse(res).code;\\n}\\n// 获取用户关系\\n$.exports.getRelation = function (mid) {\\n    return JSON.parse(request(\\\"https://api.bilibili.com/x/space/acc/relation?mid=\\\" + mid, {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })).data\\n}\\n// 查询目标用户所在的分组\\n$.exports.getUserGroup = function (mid) {\\n    return JSON.parse(request(\\\"https://api.bilibili.com/x/relation/tag/user?fid=\\\" + mid, {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })).data\\n}\\n// 获取关注分组\\n$.exports.getMyAttentionGroupList = function () {\\n    return JSON.parse(fetch(\\\"https://api.bilibili.com/x/relation/tags?jsonp=jsonp\\\", {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie,\\n            \\\"User-Agent\\\": PC_UA,\\n            \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n        }\\n    })).data;\\n}\\n// 是否点赞\\n$.exports.hasLike = function (aid) {\\n    return JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/web-interface/archive/has/like\\\", {\\n        \\\"aid\\\": aid\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })).data\\n}\\n// 是否收藏\\n$.exports.hasFavour = function (aid) {\\n    return JSON.parse(request(buildUrl(\\\"http://api.bilibili.com/x/v2/fav/video/favoured\\\", {\\n        \\\"aid\\\": aid\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })).data.favoured\\n}\\n// 视频点赞\\n$.exports.setLike = function (aid, dealWay) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let res = post(\\\"http://api.bilibili.com/x/web-interface/archive/like\\\", {\\n        body: {\\n            \\\"aid\\\": aid,\\n            \\\"like\\\": dealWay,\\n            \\\"csrf\\\": csrf\\n        },\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    })\\n    return JSON.parse(res).code;\\n}\\n// 获取收藏列表\\n$.exports.getCollectionGroupList = function () {\\n    return collections = JSON.parse(fetch(\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\", {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie,\\n        }\\n    })).data;\\n}\\n// 收藏/取消视频API\\n$.exports.setFavour = function (aid, add_media_ids, del_media_ids) {\\n    let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n    let res = post(\\\"http://api.bilibili.com/medialist/gateway/coll/resource/deal\\\", {\\n        body: {\\n            \\\"rid\\\": aid,\\n            \\\"type\\\": 2,\\n            \\\"add_media_ids\\\": add_media_ids.toString(),\\n            \\\"del_media_ids\\\": del_media_ids.toString(),\\n            \\\"csrf\\\": csrf\\n        },\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie,\\n            \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n        }\\n    })\\n    return JSON.parse(res).code;\\n}\\n// 获取视频所在收藏夹\\n$.exports.getFavourIdList = function (aid, userMid) {\\n    let u = \\\"https://api.bilibili.com/x/v3/fav/folder/created/list-all\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"type\\\": 2,\\n        \\\"rid\\\": aid,\\n        \\\"up_mid\\\": userMid,\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie,\\n            \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n        }\\n    });\\n    favourIdList = [];\\n    JSON.parse(res).data.list.forEach((item) => {\\n        if (item.fav_state == 1) {\\n            favourIdList.push(item.id);\\n        }\\n    })\\n    return favourIdList;\\n}\\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\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n        }\\n    }))\\n    return res.result\\n}\\n// 获取专栏文章\\n$.exports.getUserArticle = function (upMid, page) {\\n    let u = \\\"https://api.bilibili.com/x/space/article\\\";\\n    let res = request(buildUrl(u, {\\n        \\\"mid\\\": upMid,\\n        \\\"pn\\\": page,\\n        \\\"ps\\\": 12,\\n        \\\"sort\\\": 'publish_time'\\n    }), {\\n        headers: {\\n            \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie,\\n            \\\"Referer\\\": \\\"https://www.bilibili.com\\\"\\n        }\\n    });\\n    return JSON.parse(res).data;\\n}\\n// 获取动态数据\\n$.exports.getDynamicData = function (from, upMid) {\\n    var nextInfo = {};\\n    if (MY_PAGE == 1) {\\n        if (from == 'upSpace') {\\n            var u = \\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space?offset=&host_mid=\\\" + upMid + \\\"&timezone_offset=-480\\\";\\n        } else {\\n            var u = \\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/all?timezone_offset=-480&type=all\\\";\\n        }\\n        latenews = JSON.parse(fetch(u, {\\n            headers: {\\n                \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie,\\n                \\\"User-Agent\\\": PC_UA,\\n                \\\"Referer\\\": \\\"https://www.bilibili.com/\\\"\\n            }\\n        })).data;\\n        nextInfo.offset = latenews.offset;\\n    } else {\\n        if (from == 'upSpace') {\\n            var u = \\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space?offset=\\\" + storage0.getMyVar(JSON.stringify(MY_PAGE)).offset + \\\"&host_mid=\\\" + upMid + \\\"&timezone_offset=-480\\\";\\n        } else {\\n            var u = \\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/all?timezone_offset=-480&type=all&offset=\\\" + storage0.getMyVar(JSON.stringify(MY_PAGE)).offset;\\n        }\\n        latenews = JSON.parse(fetch(u, {\\n            headers: {\\n                \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n            }\\n        })).data;\\n        nextInfo.offset = latenews.offset;\\n    }\\n    storage0.putMyVar(JSON.stringify(MY_PAGE + 1), nextInfo);\\n    return latenews;\\n}\\n\\n// ——特别的行为、工具函数——\\n// 展示动态数据(返回函数方法的可执行字符串)\\n$.exports.showDynamicData = function () {\\n    return $.toString(() => {\\n        latenews.items.forEach(list => {\\n            if (list.type == 'DYNAMIC_TYPE_AV') {\\n                // 投稿视频（当前发布）√\\n                d.push({\\n                    title: list.modules.module_author.name + '\\\\t\\\\t\\\\t<small><small><font color=\\\"grey\\\">' + list.modules.module_author.pub_time + '-' + list.modules.module_author.pub_action + '</font></small></small>',\\n                    img: list.modules.module_author.face + \\\"@Referer=\\\",\\n                    url: 'hiker://page/upHome',\\n                    col_type: 'avatar',\\n                    extra: {\\n                        mid: list.modules.module_author.mid,\\n                        title: list.modules.module_author.name,\\n                        face: list.modules.module_author.face\\n                    }\\n                }, {\\n                    col_type: 'line'\\n                }, {\\n                    // 不一定有文字啊\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\"grey\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text) + '<br><a href=\\\"hiker://page/Comments?p=fypage\\\">查看评论</a>',\\n                    url: 'hiker://page/Comments?p=fypage',\\n                    // 这个不能用long_text\\n                    col_type: 'rich_text',\\n                    extra: {\\n                        id: list.basic.comment_id_str,\\n                        type: 1\\n                    }\\n                }, {\\n                    title: list.modules.module_dynamic.major.archive.title,\\n                    img: list.modules.module_dynamic.major.archive.cover + \\\"@Referer=\\\",\\n                    col_type: 'movie_1_left_pic',\\n                    url: \\\"hiker://page/video\\\",\\n                    desc: list.modules.module_dynamic.major.archive.desc,\\n                    extra: {\\n                        aid: list.modules.module_dynamic.major.archive.aid\\n                    }\\n                }, {\\n                    title: '<small><small><font color=\\\"grey\\\">留言:' + list.modules.module_stat.comment.count + '\\\\t\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\t\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\n                    col_type: 'rich_text'\\n                }, {\\n                    col_type: 'line_blank'\\n                });\\n            } else if (list.type == 'DYNAMIC_TYPE_FORWARD') {\\n                // 视频引用，多出了orig指向一个(过去)已发布的视频,准确的说是引用之前的帖子不一定是视频√\\n                d.push({\\n                    title: list.modules.module_author.name + '\\\\t\\\\t\\\\t<small><small><font color=\\\"grey\\\">' + list.modules.module_author.pub_time + '</font></small></small>',\\n                    img: list.modules.module_author.face + \\\"@Referer=\\\",\\n                    url: 'hiker://page/upHome',\\n                    col_type: 'avatar',\\n                    extra: {\\n                        mid: list.modules.module_author.mid,\\n                        title: list.modules.module_author.name,\\n                        face: list.modules.module_author.face\\n                    }\\n                }, {\\n                    col_type: 'line'\\n                }, {\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\"grey\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text).replace(/\\\\\\\\n/g, '<br>') + '<br><a href=\\\"hiker://page/Comments?p=fypage\\\">查看评论</a>',\\n                    url: 'hiker://page/Comments?p=fypage',\\n                    col_type: 'rich_text',\\n                    extra: {\\n                        id: list.basic.comment_id_str,\\n                        // 也是纯文字，因为只是文字+引用早已投稿的视频\\n                        type: 17\\n                    }\\n                });\\n                // 引用的内容——截断（根据不同的引用类型进行处理）\\n                d.push({\\n                    title: '<small><small>下面内容来自引用的帖子,up是:' + list.orig.modules.module_author.name + '</small></small>',\\n                    col_type: \\\"rich_text\\\"\\n                }, {\\n                    col_type: \\\"line\\\"\\n                });\\n                if (list.orig.type == 'DYNAMIC_TYPE_AV') {\\n                    // 引用视频说说\\n                    d.push({\\n                        title: list.orig.modules.module_dynamic.major.archive.title,\\n                        img: list.orig.modules.module_dynamic.major.archive.cover + \\\"@Referer=\\\",\\n                        col_type: 'movie_1_left_pic',\\n                        url: \\\"hiker://page/video\\\",\\n                        desc: list.orig.modules.module_dynamic.major.archive.desc,\\n                        extra: {\\n                            aid: list.orig.modules.module_dynamic.major.archive.aid\\n                        }\\n                    });\\n                } else if (list.orig.type == 'DYNAMIC_TYPE_WORD') {\\n                    // 引用文字说说\\n                    d.push({\\n                        title: (list.orig.modules.module_dynamic.desc.text === null ? '<font color=\\\"grey\\\">up太懒了，连文案都不想配...</font>' : list.orig.modules.module_dynamic.desc.text).replace(/\\\\\\\\n/g, '<br>') + '<br><a href=\\\"hiker://page/Comments?p=fypage\\\">查看评论</a>',\\n                        url: 'hiker://page/Comments?p=fypage',\\n                        col_type: 'rich_text',\\n                        extra: {\\n                            // 评论id来源都不一样\\n                            id: list.orig.id_str,\\n                            // 纯文字\\n                            type: 17\\n                        }\\n                    });\\n\\n                } else if (list.orig.type == 'DYNAMIC_TYPE_DRAW') {\\n                    // 引用图片说说\\n                    d.push({\\n                        title: (list.orig.modules.module_dynamic.desc.text === null ? '<font color=\\\"grey\\\">up太懒了，连文案都不想配...</font>' : list.orig.modules.module_dynamic.desc.text).replace(/\\\\\\\\n/g, '<br>') + '<br><a href=\\\"hiker://page/Comments?p=fypage\\\">查看评论</a>',\\n                        col_type: 'rich_text',\\n                        url: \\\"hiker://page/Comments?p=fypage\\\",\\n                        extra: {\\n                            id: list.orig.modules.module_dynamic.major.draw.id,\\n                            type: 11\\n                        }\\n                    });\\n                    list.orig.modules.module_dynamic.major.draw.items.forEach(item => {\\n                        d.push({\\n                            img: item.src + \\\"@Referer=\\\",\\n                            col_type: 'pic_3_square',\\n                            url: item.src + \\\"@Referer=\\\",\\n                        });\\n                    });\\n                } else {\\n                    log('可能还有未适配的说说类型');\\n                }\\n                // 分割\\n                d.push({\\n                    title: '<small><small><font color=\\\"grey\\\">留言:' + list.modules.module_stat.comment.count + '\\\\t\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\t\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\n                    col_type: 'rich_text'\\n                }, {\\n                    col_type: 'line_blank'\\n                });\\n            } else if (list.type == 'DYNAMIC_TYPE_WORD') {\\n                // 纯文字\\n                d.push({\\n                    title: list.modules.module_author.name + '\\\\t\\\\t\\\\t<small><small><font color=\\\"grey\\\">' + list.modules.module_author.pub_time + '</font></small></small>',\\n                    img: list.modules.module_author.face + \\\"@Referer=\\\",\\n                    url: 'hiker://page/upHome',\\n                    col_type: 'avatar',\\n                    extra: {\\n                        mid: list.modules.module_author.mid,\\n                        title: list.modules.module_author.name,\\n                        face: list.modules.module_author.face\\n                    }\\n                }, {\\n                    col_type: 'line'\\n                }, {\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\"grey\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text).replace(/\\\\\\\\n/g, '<br>') + '<br><a href=\\\"hiker://page/Comments?p=fypage\\\">查看评论</a>',\\n                    url: 'hiker://page/Comments?p=fypage',\\n                    col_type: 'rich_text',\\n                    extra: {\\n                        id: list.basic.comment_id_str,\\n                        // 纯文字\\n                        type: 17\\n                    }\\n                }, {\\n                    title: '<small><small><font color=\\\"grey\\\">留言:' + list.modules.module_stat.comment.count + '\\\\t\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\t\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\n                    col_type: 'rich_text'\\n                }, {\\n                    col_type: 'line_blank'\\n                });\\n            } else if (list.type == 'DYNAMIC_TYPE_DRAW') {\\n                // 图片说说\\n                d.push({\\n                    title: list.modules.module_author.name + '\\\\t\\\\t\\\\t<small><small><font color=\\\"grey\\\">' + list.modules.module_author.pub_time + '</font></small></small>',\\n                    img: list.modules.module_author.face + \\\"@Referer=\\\",\\n                    url: 'hiker://page/upHome',\\n                    col_type: 'avatar',\\n                    extra: {\\n                        mid: list.modules.module_author.mid,\\n                        title: list.modules.module_author.name,\\n                        face: list.modules.module_author.face\\n                    }\\n                }, {\\n                    col_type: 'line'\\n                }, {\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\"grey\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text).replace(/\\\\\\\\n/g, '<br>') + '<br><a href=\\\"hiker://page/Comments?p=fypage\\\">查看评论</a>',\\n                    url: 'hiker://page/Comments?p=fypage',\\n                    col_type: 'rich_text',\\n                    extra: {\\n                        id: list.basic.comment_id_str,\\n                        // 相簿（图片动态）\\n                        type: 11\\n                    }\\n                });\\n                list.modules.module_dynamic.major.draw.items.forEach(item => {\\n                    d.push({\\n                        img: item.src + \\\"@Referer=\\\",\\n                        col_type: 'pic_3_square',\\n                        url: item.src + \\\"@Referer=\\\",\\n                    });\\n                });\\n                d.push({\\n                    title: '<small><small><font color=\\\"grey\\\">留言:' + list.modules.module_stat.comment.count + '\\\\t\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\t\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\n                    col_type: 'rich_text'\\n                }, {\\n                    col_type: 'line_blank'\\n                });\\n            }\\n        });\\n    })\\n}\\n// 时间转换函数\\n$.exports.timeConvert = function (time) {\\n    function formatDate(e, t) {\\n        e = new Date(e * 1000); //时间戳为10位需*1000，时间戳为13位的话不需乘1000\\n        return t.replace(/yyyy|YYYY/, e.getFullYear())\\n            .replace(/yy|YY/, r(e.getFullYear() % 100, 2))\\n            .replace(/mm|MM/, r(e.getMonth() + 1, 2))\\n            .replace(/m|M/g, e.getMonth() + 1)\\n            .replace(/dd|DD/, r(e.getDate(), 2))\\n            .replace(/d|D/g, e.getDate())\\n            .replace(/hh|HH/, r(e.getHours(), 2))\\n            .replace(/h|H/g, e.getHours())\\n            .replace(/ii|II/, r(e.getMinutes(), 2))\\n            .replace(/i|I/g, e.getMinutes())\\n            .replace(/ss|SS/, r(e.getSeconds(), 2))\\n            .replace(/s|S/g, e.getSeconds())\\n            .replace(/w/g, e.getDay())\\n            .replace(/W/g, [\\\"日\\\", \\\"一\\\", \\\"二\\\", \\\"三\\\", \\\"四\\\", \\\"五\\\", \\\"六\\\"][e.getDay()])\\n    }\\n\\n    function r(e, t) {\\n        for (var r = 0, n = t - (e + \\\"\\\").length; r < n; r++) e = \\\"0\\\" + e;\\n        return e + \\\"\\\"\\n    }\\n    return formatDate(time, 'YYYY-MM-DD hh:ii:ss');\\n    // console.log(formatDate(1664089532, 'YYYY-MM-DD hh:ii:ss'));\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"videoPage\",\"path\":\"video\",\"rule\":\"js:\\n\\nvar d = [];\\n\\n// 预处理\\n\\nputMyVar('功能折叠', '关');\\n\\nimgLink=storage0.getMyVar('图标');\\n\\naid = MY_PARAMS.aid + \\\"\\\";\\n\\nmid = MY_PARAMS.mid + \\\"\\\";\\n\\ntry {\\n\\n    //获取视频分P信息\\n\\n    var p = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\" + aid)).data;\\n\\n    hasLike=$.require(\\\"hiker://page/api\\\").hasLike(aid);\\n\\n    hasFavour=$.require(\\\"hiker://page/api\\\").hasFavour(aid);\\n\\n    if (p.pages.length == 1) {\\n\\n        cid = p.pages[0].cid;\\n\\n        d.push({\\n\\n            title: p.title,\\n\\n            img: p.pic + '@Referer=',\\n\\n            url: $().lazyRule((aid, cid, qn) => {\\n\\n                // 真离了个大谱，明明替换掉了，ua字符串又变回来了，又要处理一次\\n\\n                return $.require(\\\"hiker://page/api\\\").biliLazy(aid, cid, qn).replace(/;/g, \\\"；；\\\");\\n\\n            }, aid + \\\"\\\", cid + \\\"\\\", '112'),\\n\\n            col_type: \\\"pic_1\\\"\\n\\n        });\\n\\n        d.push({\\n\\n            title: '<font color=\\\"blue\\\">' + p.owner.name + '</font>',\\n\\n            url: \\\"hiker://page/upHome\\\",\\n\\n            img: p.owner.face + \\\"@Referer=\\\",\\n\\n            col_type: \\\"avatar\\\",\\n\\n            extra: {\\n\\n                mid: p.owner.mid,\\n\\n                title: p.owner.name,\\n\\n                face: p.owner.face\\n\\n            }\\n\\n        },{\\n\\n            col_type: 'line'\\n\\n        },{\\n\\n            title: p.stat.like,\\n\\n            img: hasLike==1?imgLink.已点赞:imgLink.未点赞,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").likeLogic(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setLike'\\n\\n            }\\n\\n        },{\\n\\n            title:  p.stat.favorite,\\n\\n            img: hasFavour?imgLink.已收藏:imgLink.未收藏,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                upMid=JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).userMid;\\n\\n                return $.require(\\\"hiker://page/api\\\").favourLogic(aid,upMid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setFavour'\\n\\n            }\\n\\n        },{\\n\\n            title: '稍后再看',\\n\\n            img: imgLink.稍后再看,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").judgeToview(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n        }, {\\n\\n            title: '查看评论',\\n\\n            url: 'hiker://page/Comments?p=fypage',\\n\\n            img: imgLink.查看评论,\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra: {\\n\\n                \\\"id\\\": aid,\\n\\n                \\\"type\\\":1\\n\\n            }\\n\\n        },{\\n\\n            col_type: 'line_blank'\\n\\n        },{\\n\\n            title: p.desc,\\n\\n            col_type: \\\"long_text\\\",\\n\\n        });\\n\\n    } else {\\n\\n        d.push({\\n\\n            title: p.title,\\n\\n            img:p.pic + '@Referer=',\\n\\n            url: $('#noLoading##noHistory#').lazyRule((p) => {\\n\\n                return $('hiker://empty?fypage').rule((p) => {\\n\\n                    d = [];\\n\\n                    d.push({\\n\\n                        title: p.desc,\\n\\n                        col_type: \\\"long_text\\\",\\n\\n                    })\\n\\n                    setResult(d);\\n\\n                }, p)\\n\\n            }, p),\\n\\n            col_type: \\\"pic_1\\\"\\n\\n        },{\\n\\n            title: '<font color=\\\"blue\\\">' + p.owner.name + '</font>',\\n\\n            url: \\\"hiker://page/upHome\\\",\\n\\n            img: p.owner.face + \\\"@Referer=\\\",\\n\\n            col_type: \\\"avatar\\\",\\n\\n            extra: {\\n\\n                mid: p.owner.mid,\\n\\n                title: p.owner.name,\\n\\n                face: p.owner.face\\n\\n            }\\n\\n        },{\\n\\n            col_type: 'line'\\n\\n        },{\\n\\n            title: p.stat.like,\\n\\n            img: hasLike==1?imgLink.已点赞:imgLink.未点赞,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").likeLogic(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setLike'\\n\\n            }\\n\\n        },{\\n\\n            title: p.stat.favorite,\\n\\n            img: hasFavour?imgLink.已收藏:imgLink.未收藏,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                upMid=JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).userMid;\\n\\n                return $.require(\\\"hiker://page/api\\\").favourLogic(aid,upMid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setFavour'\\n\\n            }\\n\\n        },{\\n\\n            title: '稍后再看',\\n\\n            img: imgLink.稍后再看,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").judgeToview(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n        }, {\\n\\n            title: '查看评论',\\n\\n            url: 'hiker://page/Comments?p=fypage',\\n\\n            img: imgLink.查看评论,\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra: {\\n\\n                \\\"id\\\": aid,\\n\\n                \\\"type\\\":1\\n\\n            }\\n\\n        })\\n\\n        d.push({\\n\\n            col_type: 'line_blank'\\n\\n        },{\\n\\n            title: '选集列表\\\\t\\\\t\\\\t<small><small>共'+p.videos+'条视频</small></small>',\\n\\n            url: \\\"hiker://empty\\\",\\n\\n            img: imgLink.列表,\\n\\n            col_type: \\\"avatar\\\",\\n\\n        },{\\n\\n            col_type: 'line'\\n\\n        });\\n\\n        p.pages.forEach(item => {\\n\\n            cid = item.cid;\\n\\n            d.push({\\n\\n                title: item.part,\\n\\n                url: $().lazyRule((aid, cid, qn) => {\\n\\n                    return $.require(\\\"hiker://page/api\\\").biliLazy(aid, cid, qn).replace(/;/g, \\\"；；\\\");\\n\\n                }, aid + \\\"\\\", cid + \\\"\\\", '112'),\\n\\n                col_type: \\\"text_1\\\"\\n\\n            })\\n\\n        })\\n\\n    }\\n\\n} catch (e) {\\n\\n    d.push({\\n\\n        title: '页面走丢了...',\\n\\n        img: 'https://i0.hdslb.com/bfs/general/f7b667011a46615732c701f4bb1d07f793f8d1df.png@Referer=',\\n\\n        url: 'hiker://empty',\\n\\n        desc: '大概率视频被封禁，或者up已跑路~',\\n\\n        col_type: \\\"pic_1\\\"\\n\\n    });\\n\\n}\\n\\nsetResult(d);\\n\\n\\n\"},{\"col_type\":\"long_text\",\"name\":\"评论\",\"path\":\"Comments\",\"rule\":\"js:\\n\\nvar d = [];\\n\\nvar id = MY_PARAMS.id;\\n\\nvar type = MY_PARAMS.type;\\n\\nlog(id);\\n\\nif (MY_PAGE == 1) {\\n\\n    // 貌似暂时只能文字+数字\\n\\n    d.unshift({\\n\\n        title: \\\"发条评论吧\\\",\\n\\n        col_type: \\\"input\\\",\\n\\n        url: $.toString((id,type) => {\\n\\n            let csrf = JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\n\\n            post(\\\"http://api.bilibili.com/x/v2/reply/add\\\", {\\n\\n                body: {\\n\\n                    \\\"type\\\": type,\\n\\n                    \\\"oid\\\": id,\\n\\n                    \\\"csrf\\\": csrf,\\n\\n                    \\\"message\\\": input\\n\\n                },\\n\\n                headers: {\\n\\n                    \\\"Cookie\\\": JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n\\n                }\\n\\n            })\\n\\n            refreshPage()\\n\\n        }, id,type)\\n\\n    })\\n\\n}\\n\\nlet data = $.require(\\\"hiker://page/api\\\").getComments(id,type,MY_PAGE)\\n\\ndata.forEach(item => {\\n\\n    d.push({\\n\\n        title: item.member.uname+'\\\\t\\\\t\\\\t<small><small><font color=\\\"grey\\\">'+item.reply_control.location + \\\" \\\" + item.reply_control.time_desc+'</font></small></small>',\\n\\n        img: item.member.avatar+'@Referer=',\\n\\n        url:'hiker://page/upHome',\\n\\n        col_type: \\\"avatar\\\",\\n\\n        extra: {\\n\\n            mid: item.member.mid,\\n\\n            title: item.member.uname,\\n\\n            face: item.member.avatar\\n\\n        }\\n\\n    })\\n\\n    d.push({\\n\\n        title: item.content.message,\\n\\n    })\\n\\n})\\n\\nsetResult(d);\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"订阅列表\",\"path\":\"subscription\",\"rule\":\"if (getItem('订阅类型', '1') == '1') {\\n\\n    typerName = '追番';\\n\\n} else {\\n\\n    typerName = '追剧';\\n\\n}\\n\\nd.push({\\n\\n    title: '追番' == typerName ? '‘‘’’<font color=\\\"red\\\">追番</font>' : '追番',\\n\\n    url: $('#noLoading##noHistory#').lazyRule(() => {\\n\\n        setItem('订阅类型', '1')\\n\\n        refreshPage(true);\\n\\n        return \\\"hiker://empty\\\";\\n\\n    }),\\n\\n    col_type: 'scroll_button'\\n\\n},{\\n\\n    title: '追剧' == typerName ? '‘‘’’<font color=\\\"red\\\">追剧</font>' : '追剧',\\n\\n    url: $('#noLoading##noHistory#').lazyRule(() => {\\n\\n        setItem('订阅类型', '2')\\n\\n        refreshPage(true);\\n\\n        return \\\"hiker://empty\\\";\\n\\n    }),\\n\\n    col_type: 'scroll_button'\\n\\n});\\n\\nsubscriptions = JSON.parse(fetch(\\\"https://api.bilibili.com/x/space/bangumi/follow/list?type=\\\" + getItem('订阅类型', '1') + \\\"&follow_status=0&pn=\\\" + page + \\\"&ps=15&vmid=\\\" + mid, {\\n\\n    headers: {\\n\\n        \\\"Cookie\\\": cookie\\n\\n    }\\n\\n})).data;\\n\\nif (page == 1) {\\n\\n    d.push({\\n\\n        title: \\\"当前\\\" + typerName + \\\"数量:\\\" + subscriptions.total,\\n\\n        url: \\\"hiker://empty\\\",\\n\\n        col_type: \\\"text_center_1\\\"\\n\\n    })\\n\\n}\\n\\nsubscriptions.list.forEach(list => {\\n\\n    d.push({\\n\\n        title: list.title,\\n\\n        img: list.cover + \\\"@Referer=\\\",\\n\\n        url: \\\"hiker://page/filmerji#immersiveTheme#\\\",\\n\\n        desc: list.evaluate.substring(0, 12) + '‘‘’’…<font color=\\\"#1C1C1C\\\">详情</font>' + '\\\\n' + list.season_type_name + '|' + (list.areas===undefined?'':list.areas[0].name + '\\\\n') + (list.progress == '' ? '尚未观看' : list.progress) + (list.new_ep.index_show===undefined?'':'|'+(list.new_ep.index_show.match(/更新|即将/) ? '‘‘’’<font color=\\\"red\\\">' + list.new_ep.index_show + '</font>': list.new_ep.index_show)),\\n\\n        col_type: 'movie_1_vertical_pic',\\n\\n        extra: {\\n\\n            season_id: list.season_id\\n\\n        }\\n\\n    });\\n\\n});\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"关注列表\",\"path\":\"attention\",\"rule\":\"if (MY_PAGE == 1) {\\n\\n    focusGroups=$.require(\\\"hiker://page/api\\\").getMyAttentionGroupList();\\n\\n    putMyVar('tempId', JSON.stringify(focusGroups[1].tagid));\\n\\n    focusGroups.forEach(list => {\\n\\n        d.push({\\n\\n            title: list.tagid == getItem('关注分组', JSON.stringify(focusGroups[1].id)) ? \\\"““””<font color='red'>\\\" + list.name + list.count + \\\"</font>\\\" : list.name + list.count,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((list) => {\\n\\n                setItem('关注分组', JSON.stringify(list.tagid));\\n\\n                refreshPage(true);\\n\\n                return \\\"toast://切换关注分组为:\\\" + list.name;\\n\\n            }, list),\\n\\n            col_type: 'scroll_button',\\n\\n        });\\n\\n    });\\n\\n    // 末尾补充悄悄关注分组\\n\\n    d.push({\\n\\n        title: '悄悄关注' == getItem('关注分组', JSON.stringify(focusGroups[0].id)) ? \\\"““””<font color='red'>悄悄关注</font>\\\" : \\\"悄悄关注\\\",\\n\\n        url: $('#noLoading##noHistory#').lazyRule(() => {\\n\\n            setItem('关注分组', \\\"悄悄关注\\\");\\n\\n            refreshPage(true);\\n\\n            return \\\"toast://切换关注分组为:\\\" + \\\"悄悄关注\\\";\\n\\n        }),\\n\\n        col_type: 'scroll_button',\\n\\n    },{\\n\\n        col_type: 'line'\\n\\n    });\\n\\n}\\n\\nif (getItem('关注分组')=='悄悄关注') {\\n\\n    groupContent = JSON.parse(fetch(\\\"https://api.bilibili.com/x/relation/whispers?pn=\\\"+page+\\\"&ps=20&jsonp=jsonp\\\", {\\n\\n        headers: {\\n\\n            \\\"Cookie\\\": cookie\\n\\n        }\\n\\n    })).data.list;\\n\\n    groupContent.forEach(list => {\\n\\n        d.push({\\n\\n            title: \\\"<big><font color='blue'>\\\" + list.uname + \\\"</font></big><small>\\\" + list.sign + \\\"</small>\\\",\\n\\n            img: list.face + \\\"@Referer=\\\",\\n\\n            col_type: 'avatar',\\n\\n            url: \\\"hiker://page/upHome\\\",\\n\\n            extra: {\\n\\n                mid: list.mid,\\n\\n                title: list.uname,\\n\\n                face: list.face\\n\\n            }\\n\\n        });\\n\\n    });\\n\\n}else{\\n\\n    groupContent = JSON.parse(fetch(\\\"https://api.bilibili.com/x/relation/tag?mid=\\\" + mid + \\\"&tagid=\\\" + getItem('关注分组', getMyVar('tempId')) + \\\"&pn=\\\" + page + \\\"&ps=20&jsonp=jsonp\\\", {\\n\\n        headers: {\\n\\n            \\\"Cookie\\\": cookie\\n\\n        }\\n\\n    })).data;\\n\\n    groupContent.forEach(list => {\\n\\n        d.push({\\n\\n            title: \\\"<big><font color='blue'>\\\" + list.uname + \\\"</font></big><small>\\\" + list.sign + \\\"</small>\\\",\\n\\n            img: list.face + \\\"@Referer=\\\",\\n\\n            col_type: 'avatar',\\n\\n            url: \\\"hiker://page/upHome\\\",\\n\\n            extra: {\\n\\n                mid: list.mid,\\n\\n                title: list.uname,\\n\\n                face: list.face\\n\\n            }\\n\\n        });\\n\\n    });\\n\\n}\\n\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"收藏列表\",\"path\":\"colection\",\"rule\":\"if (page == 1) {\\r\\n    d.push({\\r\\n        title: '我创建的收藏夹' == getItem('收藏类型', '我创建的收藏夹') ? '‘‘’’<font color=\\\"red\\\">我创建的收藏夹</font>' : '我创建的收藏夹',\\r\\n        url: $('#noLoading##noHistory#').lazyRule(() => {\\r\\n            setItem('收藏类型', '我创建的收藏夹')\\r\\n            refreshPage(true);\\r\\n            return \\\"hiker://empty\\\";\\r\\n        }),\\r\\n        col_type: 'scroll_button'\\r\\n    }, {\\r\\n        title: '稍后在看' == getItem('收藏类型', '我创建的收藏夹') ? '‘‘’’<font color=\\\"red\\\">稍后在看</font>' : '稍后在看',\\r\\n        url: $('#noLoading##noHistory#').lazyRule(() => {\\r\\n            setItem('收藏类型', '稍后在看')\\r\\n            refreshPage(true);\\r\\n            return \\\"hiker://empty\\\";\\r\\n        }),\\r\\n        col_type: 'scroll_button'\\r\\n    });\\r\\n}\\r\\nif (getItem('收藏类型', '我创建的收藏夹') == '我创建的收藏夹') {\\r\\n    try {\\r\\n        if (page == 1) {\\r\\n            d.push({\\r\\n                // col_type: 'blank_block'\\r\\n                col_type: 'line'\\r\\n            }, );\\r\\n        }\\r\\n        collections = JSON.parse(fetch(\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\", {\\r\\n            headers: {\\r\\n                \\\"Cookie\\\": cookie\\r\\n            }\\r\\n        })).data;\\r\\n        groups = collections[0].mediaListResponse.list;\\r\\n        putMyVar('tempId', JSON.stringify(groups[0].id));\\r\\n        groups.forEach(list => {\\r\\n            d.push({\\r\\n                title: list.id == getItem('收藏夹', JSON.stringify(groups[0].id)) ? \\\"““””<font color='red'>\\\" + list.title + \\\"</font>\\\" : list.title,\\r\\n                url: $('#noLoading##noHistory#').lazyRule((list) => {\\r\\n                    setItem('收藏夹', JSON.stringify(list.id));\\r\\n                    refreshPage(true);\\r\\n                    return \\\"toast://切换收藏夹为:\\\" + list.title;\\r\\n                }, list),\\r\\n                col_type: 'scroll_button',\\r\\n            });\\r\\n        });\\r\\n        d.push({\\r\\n            col_type: 'line'\\r\\n        });\\r\\n        groupContent = JSON.parse(fetch(\\\"https://api.bilibili.com/x/v3/fav/resource/list?media_id=\\\" + getItem('收藏夹', getMyVar('tempId')) + \\\"&pn=\\\" + page + \\\"&ps=20&keyword=&order=mtime&type=0&tid=0&platform=web&jsonp=jsonp\\\", {\\r\\n            headers: {\\r\\n                \\\"Cookie\\\": cookie\\r\\n            }\\r\\n        })).data.medias;\\r\\n        groupContent.forEach(list => {\\r\\n            d.push({\\r\\n                title: list.title,\\r\\n                img: list.cover + \\\"@Referer=\\\",\\r\\n                col_type: 'movie_1_left_pic',\\r\\n                url: \\\"hiker://page/video\\\",\\r\\n                desc: 'UP:' + list.upper.name + '\\\\n' + list.intro,\\r\\n                extra: {\\r\\n                    aid: list.id,\\r\\n                    mid: list.upper.mid\\r\\n                }\\r\\n            });\\r\\n        });\\r\\n    } catch (e) {\\r\\n        showLoading('兄弟，你确认你有收藏吗，快去收藏一个视频~');\\r\\n    }\\r\\n} else {\\r\\n    laterViews = JSON.parse(fetch(\\\"https://api.bilibili.com/x/v2/history/toview/web?jsonp=jsonp\\\", {\\r\\n        headers: {\\r\\n            \\\"Cookie\\\": cookie\\r\\n        }\\r\\n    })).data;\\r\\n    count = laterViews.count;\\r\\n    d.push({\\r\\n        title: \\\"共有\\\" + count + \\\"条待看视频记录\\\",\\r\\n        url: \\\"hiker://empty\\\",\\r\\n        col_type: \\\"text_center_1\\\"\\r\\n    });\\r\\n    laterViews.list.forEach(list => {\\r\\n        d.push({\\r\\n            title: list.title,\\r\\n            img: list.pic + \\\"@Referer=\\\",\\r\\n            col_type: 'movie_1_left_pic',\\r\\n            url: \\\"hiker://page/video\\\",\\r\\n            desc: 'UP:' + list.owner.name + '\\\\n' + list.desc,\\r\\n            extra: {\\r\\n                aid: list.aid,\\r\\n                mid: list.owner.mid\\r\\n            }\\r\\n        });\\r\\n    });\\r\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"足迹\",\"path\":\"track\",\"rule\":\"var nextInfo = {};\\n\\nif (page == 1) {\\n\\n    histories = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=0&view_at=0&business=\\\", {\\n\\n        headers: {\\n\\n            \\\"Cookie\\\": cookie\\n\\n        }\\n\\n    })).data;\\n\\n    nextInfo.max = histories.cursor.max;\\n\\n    nextInfo.view_at = histories.cursor.view_at;\\n\\n    nextInfo.business = histories.cursor.business;\\n\\n} else {\\n\\n    histories = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=\\\" + storage0.getMyVar(JSON.stringify(page)).max + \\\"&view_at=\\\" + storage0.getMyVar(JSON.stringify(page)).view_at + \\\"&business=\\\" + storage0.getMyVar(JSON.stringify(page)).business, {\\n\\n        headers: {\\n\\n            \\\"Cookie\\\": cookie\\n\\n        }\\n\\n    })).data;\\n\\n    nextInfo.max = histories.cursor.max;\\n\\n    nextInfo.view_at = histories.cursor.view_at;\\n\\n    nextInfo.business = histories.cursor.business;\\n\\n}\\n\\nstorage0.putMyVar(JSON.stringify(page + 1), nextInfo);\\n\\nhistories.list.forEach(list => {\\n\\n    viewTime=pbtime = $.require(\\\"hiker://page/api\\\").timeConvert(list.view_at);\\n\\n    if (list.history.business == 'article') {\\n\\n        // 专栏文章\\n\\n        d.push({\\n\\n            title: list.show_title==''?list.title:list.show_title,\\n\\n            img: list.covers[0] + \\\"@Referer=\\\",\\n\\n            col_type: 'movie_1_left_pic',\\n\\n            url: \\\"hiker://page/articleDetail\\\",\\n\\n            desc: (list.author_name==''?viewTime:'UP:' + list.author_name+'\\\\n' )+ viewTime,\\n\\n            extra: {\\n\\n                id: list.history.oid,\\n\\n            }\\n\\n        });\\n\\n    } else if(list.history.business == 'article-list'){\\n\\n        // 文章列表？（反正id存放位置不一样）\\n\\n        d.push({\\n\\n            title: list.show_title==''?list.title:list.show_title,\\n\\n            img: list.covers[0] + \\\"@Referer=\\\",\\n\\n            col_type: 'movie_1_left_pic',\\n\\n            url: \\\"hiker://page/articleDetail\\\",\\n\\n            desc: (list.author_name==''?viewTime:'UP:' + list.author_name+'\\\\n' )+ viewTime,\\n\\n            extra: {\\n\\n                id: list.history.cid,\\n\\n            }\\n\\n        });\\n\\n    }else if(list.history.business == 'pgc'){\\n\\n        // 系列剧集（单集）\\n\\n        d.push({\\n\\n            title: list.show_title==''?list.title:list.show_title,\\n\\n            img: list.cover + \\\"@Referer=\\\",\\n\\n            col_type: 'movie_1_left_pic',\\n\\n            url: \\\"hiker://page/filmerji#immersiveTheme#\\\",\\n\\n            desc: (list.author_name==''?list.tag_name+'\\\\t\\\\t'+list.new_desc+'\\\\n'+viewTime:'UP:' + list.author_name+'\\\\n'+viewTime),\\n\\n            extra: {\\n\\n                ep_id:list.history.epid\\n\\n            }\\n\\n        });\\n\\n    }else {\\n\\n        // 普通video\\n\\n        d.push({\\n\\n            title: list.show_title==''?list.title:list.show_title,\\n\\n            img: list.cover + \\\"@Referer=\\\",\\n\\n            col_type: 'movie_1_left_pic',\\n\\n            url: \\\"hiker://page/video\\\",\\n\\n            desc: (list.author_name==''?list.tag_name+'\\\\t\\\\t'+list.new_desc+'\\\\n'+viewTime:'UP:' + list.author_name+'\\\\n'+viewTime),\\n\\n            extra: {\\n\\n                aid: list.history.oid,\\n\\n            }\\n\\n        });\\n\\n    }\\n\\n});\\n\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"动态\",\"path\":\"latetNews\",\"rule\":\"d.push({\\n\\n    col_type: 'line_blank'\\n\\n});\\n\\nlatenews=$.require(\\\"hiker://page/api\\\").getDynamicData('myHome');\\n\\neval($.require(\\\"hiker://page/api\\\").showDynamicData());\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"专栏列表\",\"path\":\"acticleList\",\"rule\":\"js:\\n\\nvar d=[];\\n\\npage=MY_PAGE;\\n\\nupMid = MY_PARAMS.mid + \\\"\\\";\\n\\narticleList=$.require(\\\"hiker://page/api\\\").getUserArticle(upMid,page);\\n\\narticleNum=articleList.count;\\n\\nif (articleNum==undefined) {\\n\\n    d.push({\\n\\n        title: '这up没有专栏文章',\\n\\n        url: \\\"hiker://empty\\\",\\n\\n        col_type: \\\"text_center_1\\\",\\n\\n    });\\n\\n}else{\\n\\n    maxPage = Math.ceil(articleNum / articleList.ps);\\n\\n    if (page <= maxPage) {\\n\\n        d.push({\\n\\n            title: '当前:第' + articleList.pn + '页\\\\t\\\\t\\\\t共有' + maxPage + '页,' + articleNum + '条数据',\\n\\n            url: \\\"hiker://empty\\\",\\n\\n            col_type: \\\"text_center_1\\\",\\n\\n        });\\n\\n        articleList.articles.forEach(list => {\\n\\n            pbtime=$.require(\\\"hiker://page/api\\\").timeConvert(list.publish_time);\\n\\n            d.push({\\n\\n                title: list.title,\\n\\n                img: list.banner_url==''? (list.image_urls+ '@Referer='):(list.banner_url+ '@Referer='),\\n\\n                desc: '‘‘’’<small>'+list.stats.view+'看过\\\\t\\\\t'+list.stats.like+'喜欢\\\\t\\\\t'+list.stats.favorite+'收藏\\\\n' + pbtime+'</small>',\\n\\n                col_type: 'movie_1_left_pic',\\n\\n                url: \\\"hiker://page/articleDetail\\\",\\n\\n                extra: {\\n\\n                    // 专栏文章id\\n\\n                    id: list.id\\n\\n                }\\n\\n            });\\n\\n        });\\n\\n    }\\n\\n}\\n\\nsetResult(d);\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"专栏文章X5\",\"path\":\"articleDetail\",\"rule\":\"js:\\n\\nvar d = [];\\n\\npage = MY_PAGE;\\n\\ncvid = MY_PARAMS.id + \\\"\\\";\\n\\nd.push({\\n\\n    url: \\\"https://www.bilibili.com/read/cv\\\"+cvid,\\n\\n    col_type: \\\"x5_webview_single\\\",\\n\\n    desc: \\\"100%&&float\\\",\\n\\n    extra: {\\n\\n        canBack: true\\n\\n    }\\n\\n})\\n\\nsetResult(d);\\n\\n\"},{\"col_type\":\"movie_3\",\"name\":\"综合热门\",\"path\":\"hotVideo\",\"rule\":\"let res = JSON.parse(request(\\\"https://api.bilibili.com/x/web-interface/popular?pn=\\\" + MY_PAGE, {\\n\\n    headers: {\\n\\n        Cookie: JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).cookie\\n\\n    }\\n\\n})).data\\n\\nres.list.forEach(item => {\\n\\n    d.push({\\n\\n        title: item.title,\\n\\n        img: item.pic+ \\\"@Referer=\\\",\\n\\n        url: \\\"hiker://page/video\\\",\\n\\n        desc: item.pub_location,\\n\\n        col_type: \\\"movie_2\\\",\\n\\n        extra: {\\n\\n            \\\"aid\\\": item.aid,\\n\\n            \\\"cid\\\": item.cid,\\n\\n        }\\n\\n    })\\n\\n})\\n\\n\\n\"}],\"params\":\"{\\\"aid\\\":985257570,\\\"cid\\\":825356574}\",\"saved\":false,\"title\":\"哔哩哔哩\",\"version\":0,\"url\":\"hiker://page/video\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\n\\nvar d = [];\\n\\n// 预处理\\n\\nputMyVar('功能折叠', '关');\\n\\nimgLink=storage0.getMyVar('图标');\\n\\naid = MY_PARAMS.aid + \\\"\\\";\\n\\nmid = MY_PARAMS.mid + \\\"\\\";\\n\\ntry {\\n\\n    //获取视频分P信息\\n\\n    var p = JSON.parse(fetch(\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\" + aid)).data;\\n\\n    hasLike=$.require(\\\"hiker://page/api\\\").hasLike(aid);\\n\\n    hasFavour=$.require(\\\"hiker://page/api\\\").hasFavour(aid);\\n\\n    if (p.pages.length == 1) {\\n\\n        cid = p.pages[0].cid;\\n\\n        d.push({\\n\\n            title: p.title,\\n\\n            img: p.pic + '@Referer=',\\n\\n            url: $().lazyRule((aid, cid, qn) => {\\n\\n                // 真离了个大谱，明明替换掉了，ua字符串又变回来了，又要处理一次\\n\\n                return $.require(\\\"hiker://page/api\\\").biliLazy(aid, cid, qn).replace(/;/g, \\\"；；\\\");\\n\\n            }, aid + \\\"\\\", cid + \\\"\\\", '112'),\\n\\n            col_type: \\\"pic_1\\\"\\n\\n        });\\n\\n        d.push({\\n\\n            title: '<font color=\\\"blue\\\">' + p.owner.name + '</font>',\\n\\n            url: \\\"hiker://page/upHome\\\",\\n\\n            img: p.owner.face + \\\"@Referer=\\\",\\n\\n            col_type: \\\"avatar\\\",\\n\\n            extra: {\\n\\n                mid: p.owner.mid,\\n\\n                title: p.owner.name,\\n\\n                face: p.owner.face\\n\\n            }\\n\\n        },{\\n\\n            col_type: 'line'\\n\\n        },{\\n\\n            title: p.stat.like,\\n\\n            img: hasLike==1?imgLink.已点赞:imgLink.未点赞,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").likeLogic(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setLike'\\n\\n            }\\n\\n        },{\\n\\n            title:  p.stat.favorite,\\n\\n            img: hasFavour?imgLink.已收藏:imgLink.未收藏,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                upMid=JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).userMid;\\n\\n                return $.require(\\\"hiker://page/api\\\").favourLogic(aid,upMid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setFavour'\\n\\n            }\\n\\n        },{\\n\\n            title: '稍后再看',\\n\\n            img: imgLink.稍后再看,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").judgeToview(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n        }, {\\n\\n            title: '查看评论',\\n\\n            url: 'hiker://page/Comments?p=fypage',\\n\\n            img: imgLink.查看评论,\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra: {\\n\\n                \\\"id\\\": aid,\\n\\n                \\\"type\\\":1\\n\\n            }\\n\\n        },{\\n\\n            col_type: 'line_blank'\\n\\n        },{\\n\\n            title: p.desc,\\n\\n            col_type: \\\"long_text\\\",\\n\\n        });\\n\\n    } else {\\n\\n        d.push({\\n\\n            title: p.title,\\n\\n            img:p.pic + '@Referer=',\\n\\n            url: $('#noLoading##noHistory#').lazyRule((p) => {\\n\\n                return $('hiker://empty?fypage').rule((p) => {\\n\\n                    d = [];\\n\\n                    d.push({\\n\\n                        title: p.desc,\\n\\n                        col_type: \\\"long_text\\\",\\n\\n                    })\\n\\n                    setResult(d);\\n\\n                }, p)\\n\\n            }, p),\\n\\n            col_type: \\\"pic_1\\\"\\n\\n        },{\\n\\n            title: '<font color=\\\"blue\\\">' + p.owner.name + '</font>',\\n\\n            url: \\\"hiker://page/upHome\\\",\\n\\n            img: p.owner.face + \\\"@Referer=\\\",\\n\\n            col_type: \\\"avatar\\\",\\n\\n            extra: {\\n\\n                mid: p.owner.mid,\\n\\n                title: p.owner.name,\\n\\n                face: p.owner.face\\n\\n            }\\n\\n        },{\\n\\n            col_type: 'line'\\n\\n        },{\\n\\n            title: p.stat.like,\\n\\n            img: hasLike==1?imgLink.已点赞:imgLink.未点赞,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").likeLogic(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setLike'\\n\\n            }\\n\\n        },{\\n\\n            title: p.stat.favorite,\\n\\n            img: hasFavour?imgLink.已收藏:imgLink.未收藏,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                upMid=JSON.parse(request(\\\"hiker://files/rules/cy/bili.txt\\\")).userMid;\\n\\n                return $.require(\\\"hiker://page/api\\\").favourLogic(aid,upMid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra:{\\n\\n                id:'setFavour'\\n\\n            }\\n\\n        },{\\n\\n            title: '稍后再看',\\n\\n            img: imgLink.稍后再看,\\n\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\n\\n                return $.require(\\\"hiker://page/api\\\").judgeToview(aid)\\n\\n            }, aid),\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n        }, {\\n\\n            title: '查看评论',\\n\\n            url: 'hiker://page/Comments?p=fypage',\\n\\n            img: imgLink.查看评论,\\n\\n            col_type: \\\"icon_small_4\\\",\\n\\n            extra: {\\n\\n                \\\"id\\\": aid,\\n\\n                \\\"type\\\":1\\n\\n            }\\n\\n        })\\n\\n        d.push({\\n\\n            col_type: 'line_blank'\\n\\n        },{\\n\\n            title: '选集列表\\\\t\\\\t\\\\t<small><small>共'+p.videos+'条视频</small></small>',\\n\\n            url: \\\"hiker://empty\\\",\\n\\n            img: imgLink.列表,\\n\\n            col_type: \\\"avatar\\\",\\n\\n        },{\\n\\n            col_type: 'line'\\n\\n        });\\n\\n        p.pages.forEach(item => {\\n\\n            cid = item.cid;\\n\\n            d.push({\\n\\n                title: item.part,\\n\\n                url: $().lazyRule((aid, cid, qn) => {\\n\\n                    return $.require(\\\"hiker://page/api\\\").biliLazy(aid, cid, qn).replace(/;/g, \\\"；；\\\");\\n\\n                }, aid + \\\"\\\", cid + \\\"\\\", '112'),\\n\\n                col_type: \\\"text_1\\\"\\n\\n            })\\n\\n        })\\n\\n    }\\n\\n} catch (e) {\\n\\n    d.push({\\n\\n        title: '页面走丢了...',\\n\\n        img: 'https://i0.hdslb.com/bfs/general/f7b667011a46615732c701f4bb1d07f793f8d1df.png@Referer=',\\n\\n        url: 'hiker://empty',\\n\\n        desc: '大概率视频被封禁，或者up已跑路~',\\n\\n        col_type: \\\"pic_1\\\"\\n\\n    });\\n\\n}\\n\\nsetResult(d);\\n\\n\\n\",\"group\":\"\",\"ua\":\"pc\",\"preRule\":\"js:\\n\\n// 图片预处理\\n\\nimgLocation = {\\n\\n    \\\"已收藏\\\": 'https://s1.328888.xyz/2022/09/26/VpTfy.png@Referer=',\\n\\n    \\\"未收藏\\\": 'https://s1.328888.xyz/2022/09/26/VqpK7.png@Referer=',\\n\\n    \\\"稍后再看\\\": 'https://s1.328888.xyz/2022/09/26/VphnC.png@Referer=',\\n\\n    \\\"未点赞\\\": 'https://s1.328888.xyz/2022/09/26/Vpb2U.png@Referer=',\\n\\n    \\\"已点赞\\\": 'https://s1.328888.xyz/2022/09/26/Vp0d5.png@Referer=',\\n\\n    \\\"添加关注\\\": 'https://s1.328888.xyz/2022/09/26/VpCmR.png@Referer=',\\n\\n    \\\"已关注\\\": 'https://s1.328888.xyz/2022/09/26/VqYNE.png@Referer=',\\n\\n    \\\"专栏\\\": 'https://s1.328888.xyz/2022/09/26/VpwrB.png@Referer=',\\n\\n    \\\"查看评论\\\": 'https://s1.328888.xyz/2022/09/26/VpzIs.png@Referer=',\\n\\n    \\\"周边\\\": 'https://s1.328888.xyz/2022/09/26/VphnC.png@Referer=',\\n\\n    \\\"双边\\\": 'https://s1.328888.xyz/2022/09/26/Vpqw5.png@Referer=',\\n\\n    \\\"列表\\\": 'https://s1.328888.xyz/2022/09/26/VpHvS.png@Referer=',\\n\\n    \\\"订阅\\\": 'https://s1.328888.xyz/2022/09/26/VpX8N.png@Referer=',\\n\\n    \\\"日历\\\": 'https://s1.328888.xyz/2022/09/26/Vq3Gw.png@Referer=',\\n\\n    \\\"动态\\\": 'https://s1.328888.xyz/2022/09/26/VAKuy.png@Referer='\\n\\n}\\n\\nstorage0.putMyVar('图标', imgLocation);\\n\\n// 大会员可以尝试改为SVIP\\n\\nputMyVar('authority','normal');\\n\\n\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"分类片库\\\",\\\"path\\\":\\\"vault\\\",\\\"rule\\\":\\\"顶部大类 = ['国创', '电视', '纪录片', '综艺', '番剧', '电影']\\\\n\\\\nif (page == 1) {\\\\n\\\\n    // 折叠开关\\\\n\\\\n    d.push({\\\\n\\\\n        title: getMyVar('折叠', '关') == '关' ? '““””<b><span style=\\\\\\\"color: #FF0000\\\\\\\">∨</span></b>' : '““””<b><span style=\\\\\\\"color: #1aad19\\\\\\\">∧</span></b>',\\\\n\\\\n        url: $('#noLoading#').lazyRule(() => {\\\\n\\\\n            if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n                putMyVar('折叠', '关');\\\\n\\\\n            } else {\\\\n\\\\n                putMyVar('折叠', '开');\\\\n\\\\n            }\\\\n\\\\n            refreshPage(true);\\\\n\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n        }),\\\\n\\\\n        col_type: 'scroll_button',\\\\n\\\\n    })\\\\n\\\\n    顶部大类.forEach(li => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: li == getMyVar('大类', '国创') ? '““””<b><font color=#1aad19>' + li + '</font></b>' : li,\\\\n\\\\n            url: $('#noLoading#').lazyRule((li) => {\\\\n\\\\n                putMyVar('大类', li);\\\\n\\\\n                refreshPage(true);\\\\n\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n            }, li),\\\\n\\\\n            col_type: 'scroll_button',\\\\n\\\\n        })\\\\n\\\\n    });\\\\n\\\\n    d.push({\\\\n\\\\n        col_type: 'blank_block'\\\\n\\\\n    })\\\\n\\\\n}\\\\n\\\\n// 顶部分类参数映射\\\\n\\\\nswitch (getMyVar('大类', '国创')) {\\\\n\\\\n    case '国创':\\\\n\\\\n        seasonType = 4;\\\\n\\\\n        if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                html = fetch('https://www.bilibili.com/guochuang/index');\\\\n\\\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\\\n\\\\n                分类列表.forEach(ul => {\\\\n\\\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\\\n\\\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\\\n\\\\n                    子分类列表.forEach(li => {\\\\n\\\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\\\n\\\\n                            return;\\\\n\\\\n                        }\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\\\n\\\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\\\n\\\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, li, 筛选条件),\\\\n\\\\n                            col_type: 'scroll_button'\\\\n\\\\n                        })\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'blank_block'\\\\n\\\\n                    })\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n        break;\\\\n\\\\n    case '电视':\\\\n\\\\n        seasonType = 5;\\\\n\\\\n        if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                html = fetch('https://www.bilibili.com/tv/index');\\\\n\\\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\\\n\\\\n                分类列表.forEach(ul => {\\\\n\\\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\\\n\\\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\\\n\\\\n                    子分类列表.forEach(li => {\\\\n\\\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\\\n\\\\n                            return;\\\\n\\\\n                        }\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\\\n\\\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\\\n\\\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, li, 筛选条件),\\\\n\\\\n                            col_type: 'scroll_button'\\\\n\\\\n                        })\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'blank_block'\\\\n\\\\n                    })\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n        break;\\\\n\\\\n    case '纪录片':\\\\n\\\\n        seasonType = 3;\\\\n\\\\n        if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                html = fetch('https://www.bilibili.com/documentary/index/');\\\\n\\\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\\\n\\\\n                分类列表.forEach(ul => {\\\\n\\\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\\\n\\\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\\\n\\\\n                    子分类列表.forEach(li => {\\\\n\\\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\\\n\\\\n                            return;\\\\n\\\\n                        }\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\\\n\\\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\\\n\\\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, li, 筛选条件),\\\\n\\\\n                            col_type: 'scroll_button'\\\\n\\\\n                        })\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'blank_block'\\\\n\\\\n                    })\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n        break;\\\\n\\\\n    case '综艺':\\\\n\\\\n        seasonType = 7;\\\\n\\\\n        if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                html = fetch('https://www.bilibili.com/variety/index');\\\\n\\\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\\\n\\\\n                分类列表.forEach(ul => {\\\\n\\\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\\\n\\\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\\\n\\\\n                    子分类列表.forEach(li => {\\\\n\\\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\\\n\\\\n                            return;\\\\n\\\\n                        }\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\\\n\\\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\\\n\\\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, li, 筛选条件),\\\\n\\\\n                            col_type: 'scroll_button'\\\\n\\\\n                        })\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'blank_block'\\\\n\\\\n                    })\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n        break;\\\\n\\\\n    case '番剧':\\\\n\\\\n        seasonType = 1;\\\\n\\\\n        if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                html = fetch('https://www.bilibili.com/anime/index');\\\\n\\\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\\\n\\\\n                分类列表.forEach(ul => {\\\\n\\\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\\\n\\\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\\\n\\\\n                    子分类列表.forEach(li => {\\\\n\\\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\\\n\\\\n                            return;\\\\n\\\\n                        }\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\\\n\\\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\\\n\\\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, li, 筛选条件),\\\\n\\\\n                            col_type: 'scroll_button'\\\\n\\\\n                        })\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'blank_block'\\\\n\\\\n                    })\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n        break;\\\\n\\\\n    case '电影':\\\\n\\\\n        seasonType = 2;\\\\n\\\\n        if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                html = fetch('https://www.bilibili.com/movie/index');\\\\n\\\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\\\n\\\\n                分类列表.forEach(ul => {\\\\n\\\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\\\n\\\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\\\n\\\\n                    子分类列表.forEach(li => {\\\\n\\\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\\\n\\\\n                            return;\\\\n\\\\n                        }\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\\\n\\\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\\\n\\\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, li, 筛选条件),\\\\n\\\\n                            col_type: 'scroll_button'\\\\n\\\\n                        })\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'blank_block'\\\\n\\\\n                    })\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        seasonType = 4;\\\\n\\\\n        if (getMyVar('折叠', '关') == '开') {\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                html = fetch('https://www.bilibili.com/anime/index');\\\\n\\\\n                分类列表 = pdfa(html, '.filter-list&&.filter-block');\\\\n\\\\n                分类列表.forEach(ul => {\\\\n\\\\n                    筛选条件 = pdfh(ul, '.filter-name&&Text');\\\\n\\\\n                    子分类列表 = pdfa(ul, 'ul&&li');\\\\n\\\\n                    子分类列表.forEach(li => {\\\\n\\\\n                        if (pdfh(li, 'li&&Text') == '其他') {\\\\n\\\\n                            return;\\\\n\\\\n                        }\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: getMyVar(筛选条件, '全部') == pdfh(li, 'li&&Text') ? '““””<b><font color=#1aad19>' + pdfh(li, 'li&&Text') + '</font></b>' : pdfh(li, 'li&&Text'),\\\\n\\\\n                            url: $('#noLoading#').lazyRule((li, 筛选条件) => {\\\\n\\\\n                                putMyVar(筛选条件, pdfh(li, 'li&&Text'));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, li, 筛选条件),\\\\n\\\\n                            col_type: 'scroll_button'\\\\n\\\\n                        })\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'blank_block'\\\\n\\\\n                    })\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\n// 子分类参数映射\\\\n\\\\nswitch (getMyVar('类型', '全部')) {\\\\n\\\\n    case '正片':\\\\n\\\\n        season_version = 1;\\\\n\\\\n        break;\\\\n\\\\n    case '电影':\\\\n\\\\n        season_version = 2;\\\\n\\\\n        break;\\\\n\\\\n    case '其他':\\\\n\\\\n        season_version = 3;\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        season_version = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('配音', '全部')) {\\\\n\\\\n    case '原声':\\\\n\\\\n        spoken_language_type = 1;\\\\n\\\\n        break;\\\\n\\\\n    case '中文配音':\\\\n\\\\n        spoken_language_type = 2;\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        spoken_language_type = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('地区', '全部')) {\\\\n\\\\n    case '中国大陆':\\\\n\\\\n        area = 1;\\\\n\\\\n        break;\\\\n\\\\n    case '日本':\\\\n\\\\n        area = 2;\\\\n\\\\n        break;\\\\n\\\\n    case '美国':\\\\n\\\\n        area = 3;\\\\n\\\\n        break;\\\\n\\\\n    case '英国':\\\\n\\\\n        area = 4;\\\\n\\\\n        break;\\\\n\\\\n    case '中国港台':\\\\n\\\\n        area = [6, 7];\\\\n\\\\n        break;\\\\n\\\\n    case '韩国':\\\\n\\\\n        area = 8;\\\\n\\\\n        break;\\\\n\\\\n    case '法国':\\\\n\\\\n        area = 9;\\\\n\\\\n        break;\\\\n\\\\n    case '泰国':\\\\n\\\\n        area = 10;\\\\n\\\\n        break;\\\\n\\\\n    case '西班牙':\\\\n\\\\n        area = 13;\\\\n\\\\n        break;\\\\n\\\\n    case '德国':\\\\n\\\\n        area = 15;\\\\n\\\\n        break;\\\\n\\\\n    case '意大利':\\\\n\\\\n        area = 35;\\\\n\\\\n        break;\\\\n\\\\n    case '其他':\\\\n\\\\n        // 只是番剧的情况_共55，要减去出现的——算了，直接在动态分类的时候去掉了\\\\n\\\\n        area = [1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55];\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        area = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('状态', '全部')) {\\\\n\\\\n    case '完结':\\\\n\\\\n        is_finish = 1;\\\\n\\\\n        break;\\\\n\\\\n    case '连载':\\\\n\\\\n        is_finish = 0;\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        is_finish = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('出品', '全部')) {\\\\n\\\\n    case '央视':\\\\n\\\\n        producer_id = 4;\\\\n\\\\n        break;\\\\n\\\\n    case 'BBC':\\\\n\\\\n        producer_id = 1;\\\\n\\\\n        break;\\\\n\\\\n    case '探索频道':\\\\n\\\\n        producer_id = 7;\\\\n\\\\n        break;\\\\n\\\\n    case '国家地理':\\\\n\\\\n        producer_id = 14;\\\\n\\\\n        break;\\\\n\\\\n    case 'NHK':\\\\n\\\\n        producer_id = 2;\\\\n\\\\n        break;\\\\n\\\\n    case '历史频道':\\\\n\\\\n        producer_id = 6;\\\\n\\\\n        break;\\\\n\\\\n    case '卫视':\\\\n\\\\n        producer_id = 8;\\\\n\\\\n        break;\\\\n\\\\n    case '自制':\\\\n\\\\n        producer_id = 9;\\\\n\\\\n        break;\\\\n\\\\n    case 'ITV':\\\\n\\\\n        producer_id = 5;\\\\n\\\\n        break;\\\\n\\\\n    case 'SKY':\\\\n\\\\n        producer_id = 3;\\\\n\\\\n        break;\\\\n\\\\n    case 'ZDF':\\\\n\\\\n        producer_id = 10;\\\\n\\\\n        break;\\\\n\\\\n    case '合作机构':\\\\n\\\\n        producer_id = 11;\\\\n\\\\n        break;\\\\n\\\\n    case '国内其他':\\\\n\\\\n        producer_id = 12;\\\\n\\\\n        break;\\\\n\\\\n    case '国外其它':\\\\n\\\\n        producer_id = 13;\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        producer_id = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('版权', '全部')) {\\\\n\\\\n    case '独家':\\\\n\\\\n        copyright = 3;\\\\n\\\\n        break;\\\\n\\\\n    case '其他':\\\\n\\\\n        copyright = [1, 2, 4];\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        copyright = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('付费', '全部')) {\\\\n\\\\n    case '免费':\\\\n\\\\n        season_status = 1;\\\\n\\\\n        break;\\\\n\\\\n    case '付费':\\\\n\\\\n        season_status = [2, 6];\\\\n\\\\n        break;\\\\n\\\\n    case '大会员':\\\\n\\\\n        season_status = [4, 6];\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        season_status = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('季度', '全部')) {\\\\n\\\\n    case '1月':\\\\n\\\\n        season_month = 1;\\\\n\\\\n        break;\\\\n\\\\n    case '4月':\\\\n\\\\n        season_month = 4;\\\\n\\\\n        break;\\\\n\\\\n    case '7月':\\\\n\\\\n        season_month = 7;\\\\n\\\\n        break;\\\\n\\\\n    case '10月':\\\\n\\\\n        season_month = 10;\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        season_month = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('时间', '全部')) {\\\\n\\\\n    case '2022':\\\\n\\\\n        year = '[2022,2023)';\\\\n\\\\n        break;\\\\n\\\\n    case '2021':\\\\n\\\\n        year = '[2021,2022)';\\\\n\\\\n        break;\\\\n\\\\n    case '2020':\\\\n\\\\n        year = '[2020,2021)';\\\\n\\\\n        break;\\\\n\\\\n    case '2019':\\\\n\\\\n        year = '[2019,2020)';\\\\n\\\\n        break;\\\\n\\\\n    case '2018':\\\\n\\\\n        year = '[2018,2019)';\\\\n\\\\n        break;\\\\n\\\\n    case '2017':\\\\n\\\\n        year = '[2017,2018)';\\\\n\\\\n        break;\\\\n\\\\n    case '2016':\\\\n\\\\n        year = '[2016,2017)';\\\\n\\\\n        break;\\\\n\\\\n    case '2015':\\\\n\\\\n        year = '[2015,2016)';\\\\n\\\\n        break;\\\\n\\\\n    case '2014-2010':\\\\n\\\\n        year = '[2010,2015)';\\\\n\\\\n        break;\\\\n\\\\n    case '2009-2005':\\\\n\\\\n        year = '[2005,2010)';\\\\n\\\\n        break;\\\\n\\\\n    case '2004-2000':\\\\n\\\\n        year = '[2000,2005)';\\\\n\\\\n        break;\\\\n\\\\n    case '90年代':\\\\n\\\\n        year = '[1990,2000)';\\\\n\\\\n        break;\\\\n\\\\n    case '80年代':\\\\n\\\\n        year = '[1980,1990)';\\\\n\\\\n        break;\\\\n\\\\n    case '更早':\\\\n\\\\n        year = '[,1980)';\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        year = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('年份', '全部')) {\\\\n\\\\n    case '2022':\\\\n\\\\n        release_date = '[2022-01-01 00:00:00,2023-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    case '2021':\\\\n\\\\n        release_date = '[2021-01-01 00:00:00,2022-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    case '2020':\\\\n\\\\n        release_date = '[2020-01-01 00:00:00,2021-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    case '2019':\\\\n\\\\n        release_date = '[2019-01-01 00:00:00,2020-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    case '2018':\\\\n\\\\n        release_date = '[2018-01-01 00:00:00,2019-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    case '2017':\\\\n\\\\n        release_date = '[2017-01-01 00:00:00,2018-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    case '2016':\\\\n\\\\n        release_date = '[2016-01-01 00:00:00,2017-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    case '2015-2010':\\\\n\\\\n        release_date = '[2010-01-01 00:00:00,2016-01-01 00:00:00)'\\\\n\\\\n        break;\\\\n\\\\n    case '2009-2005':\\\\n\\\\n        release_date = '[2005-01-01 00:00:00,2010-01-01 00:00:00)'\\\\n\\\\n        break;\\\\n\\\\n    case '2004-2000':\\\\n\\\\n        release_date = '[2000-01-01 00:00:00,2005-01-01 00:00:00)'\\\\n\\\\n        break;\\\\n\\\\n    case '90年代':\\\\n\\\\n        release_date = '[1990-01-01 00:00:00,2000-01-01 00:00:00)'\\\\n\\\\n        break;\\\\n\\\\n    case '80年代':\\\\n\\\\n        release_date = '[1980-01-01 00:00:00,1990-01-01 00:00:00)'\\\\n\\\\n        break;\\\\n\\\\n    case '更早':\\\\n\\\\n        release_date = '[,1980-01-01 00:00:00)';\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        release_date = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\nswitch (getMyVar('风格', '全部')) {\\\\n\\\\n    case '电影':\\\\n\\\\n        style_id = -10;\\\\n\\\\n        break;\\\\n\\\\n        // 番剧栏目\\\\n\\\\n    case '原创':\\\\n\\\\n        style_id = 10010;\\\\n\\\\n        break;\\\\n\\\\n    case '漫画改':\\\\n\\\\n        style_id = 10011;\\\\n\\\\n        break;\\\\n\\\\n    case '小说改':\\\\n\\\\n        style_id = 10012;\\\\n\\\\n        break;\\\\n\\\\n    case '游戏改':\\\\n\\\\n        style_id = 10013;\\\\n\\\\n        break;\\\\n\\\\n    case '特摄':\\\\n\\\\n        style_id = 10014;\\\\n\\\\n        break;\\\\n\\\\n    case '布袋戏':\\\\n\\\\n        style_id = 10015;\\\\n\\\\n        break;\\\\n\\\\n    case '热血':\\\\n\\\\n        style_id = 10016;\\\\n\\\\n        break;\\\\n\\\\n    case '穿越':\\\\n\\\\n        style_id = 10017;\\\\n\\\\n        break;\\\\n\\\\n    case '奇幻':\\\\n\\\\n        style_id = 10018;\\\\n\\\\n        break;\\\\n\\\\n        // 咋跳了一个捏~\\\\n\\\\n    case '战斗':\\\\n\\\\n        style_id = 10020;\\\\n\\\\n        break;\\\\n\\\\n    case '搞笑':\\\\n\\\\n        style_id = 10021;\\\\n\\\\n        break;\\\\n\\\\n    case '日常':\\\\n\\\\n        style_id = 10022;\\\\n\\\\n        break;\\\\n\\\\n    case '科幻':\\\\n\\\\n        style_id = 10023;\\\\n\\\\n        break;\\\\n\\\\n    case '萌系':\\\\n\\\\n        style_id = 10024;\\\\n\\\\n        break;\\\\n\\\\n    case '治愈':\\\\n\\\\n        style_id = 10025;\\\\n\\\\n        break;\\\\n\\\\n    case '校园':\\\\n\\\\n        style_id = 10026;\\\\n\\\\n        break;\\\\n\\\\n    case '少儿':\\\\n\\\\n        style_id = 10027;\\\\n\\\\n        break;\\\\n\\\\n    case '泡面':\\\\n\\\\n        style_id = 10028;\\\\n\\\\n        break;\\\\n\\\\n    case '恋爱':\\\\n\\\\n        style_id = 10029;\\\\n\\\\n        break;\\\\n\\\\n    case '少女':\\\\n\\\\n        style_id = 10030;\\\\n\\\\n        break;\\\\n\\\\n    case '魔法':\\\\n\\\\n        style_id = 10031;\\\\n\\\\n        break;\\\\n\\\\n    case '冒险':\\\\n\\\\n        style_id = 10032;\\\\n\\\\n        break;\\\\n\\\\n    case '历史':\\\\n\\\\n        style_id = 10033;\\\\n\\\\n        break;\\\\n\\\\n    case '架空':\\\\n\\\\n        style_id = 10034;\\\\n\\\\n        break;\\\\n\\\\n    case '机战':\\\\n\\\\n        style_id = 10035;\\\\n\\\\n        break;\\\\n\\\\n    case '神魔':\\\\n\\\\n        style_id = 10036;\\\\n\\\\n        break;\\\\n\\\\n    case '声控':\\\\n\\\\n        style_id = 10037;\\\\n\\\\n        break;\\\\n\\\\n    case '运动':\\\\n\\\\n        style_id = 10038;\\\\n\\\\n        break;\\\\n\\\\n    case '励志':\\\\n\\\\n        style_id = 10039;\\\\n\\\\n        break;\\\\n\\\\n    case '音乐':\\\\n\\\\n        style_id = 10040;\\\\n\\\\n        break;\\\\n\\\\n    case '推理':\\\\n\\\\n        style_id = 10041;\\\\n\\\\n        break;\\\\n\\\\n    case '社团':\\\\n\\\\n        style_id = 10042;\\\\n\\\\n        break;\\\\n\\\\n    case '智斗':\\\\n\\\\n        style_id = 10043;\\\\n\\\\n        break;\\\\n\\\\n    case '催泪':\\\\n\\\\n        style_id = 10044;\\\\n\\\\n        break;\\\\n\\\\n    case '美食':\\\\n\\\\n        style_id = 10045;\\\\n\\\\n        break;\\\\n\\\\n    case '偶像':\\\\n\\\\n        style_id = 10046;\\\\n\\\\n        break;\\\\n\\\\n    case '乙女':\\\\n\\\\n        style_id = 10047;\\\\n\\\\n        break;\\\\n\\\\n    case '职场':\\\\n\\\\n        style_id = 10048;\\\\n\\\\n        break;\\\\n\\\\n\\\\n        // 综艺栏目、电影\\\\n\\\\n    case '剧情':\\\\n\\\\n        style_id = 10050;\\\\n\\\\n        break;\\\\n\\\\n    case '喜剧':\\\\n\\\\n        style_id = 10051;\\\\n\\\\n        break;\\\\n\\\\n    case '爱情':\\\\n\\\\n        style_id = 10052;\\\\n\\\\n        break;\\\\n\\\\n    case '动作':\\\\n\\\\n        style_id = 10053;\\\\n\\\\n        break;\\\\n\\\\n    case '恐怖':\\\\n\\\\n        style_id = 10054;\\\\n\\\\n        break;\\\\n\\\\n    case '犯罪':\\\\n\\\\n        style_id = 10055;\\\\n\\\\n        break;\\\\n\\\\n    case '惊悚':\\\\n\\\\n        style_id = 10056;\\\\n\\\\n        break;\\\\n\\\\n    case '悬疑':\\\\n\\\\n        style_id = 10057;\\\\n\\\\n        break;\\\\n\\\\n    case '战争':\\\\n\\\\n        style_id = 10058;\\\\n\\\\n        break;\\\\n\\\\n    case '动画':\\\\n\\\\n        style_id = 10059;\\\\n\\\\n        break;\\\\n\\\\n    case '传记':\\\\n\\\\n        style_id = 10060;\\\\n\\\\n        break;\\\\n\\\\n    case '家庭':\\\\n\\\\n        style_id = 10061;\\\\n\\\\n        break;\\\\n\\\\n    case '歌舞':\\\\n\\\\n        style_id = 10062;\\\\n\\\\n        break;\\\\n\\\\n    case '纪实':\\\\n\\\\n        style_id = 10063;\\\\n\\\\n        break;\\\\n\\\\n    case '灾难':\\\\n\\\\n        style_id = 10064;\\\\n\\\\n        break;\\\\n\\\\n    case '人文':\\\\n\\\\n        style_id = 10065;\\\\n\\\\n        break;\\\\n\\\\n    case '科技':\\\\n\\\\n        style_id = 10066;\\\\n\\\\n        break;\\\\n\\\\n    case '宇宙':\\\\n\\\\n        style_id = 10068;\\\\n\\\\n        break;\\\\n\\\\n    case '萌宠':\\\\n\\\\n        style_id = 10069;\\\\n\\\\n        break;\\\\n\\\\n    case '社会':\\\\n\\\\n        style_id = 10070;\\\\n\\\\n        break;\\\\n\\\\n    case '动物':\\\\n\\\\n        style_id = 10071;\\\\n\\\\n        break;\\\\n\\\\n    case '自然':\\\\n\\\\n        style_id = 10072;\\\\n\\\\n        break;\\\\n\\\\n    case '医疗':\\\\n\\\\n        style_id = 10073;\\\\n\\\\n        break;\\\\n\\\\n    case '军事':\\\\n\\\\n        style_id = 10074;\\\\n\\\\n        break;\\\\n\\\\n    case '罪案':\\\\n\\\\n        style_id = 10075;\\\\n\\\\n        break;\\\\n\\\\n    case '神秘':\\\\n\\\\n        style_id = 10076;\\\\n\\\\n        break;\\\\n\\\\n    case '旅行':\\\\n\\\\n        style_id = 10077;\\\\n\\\\n        break;\\\\n\\\\n    case '武侠':\\\\n\\\\n        style_id = 10078;\\\\n\\\\n        break;\\\\n\\\\n    case '青春':\\\\n\\\\n        style_id = 10079;\\\\n\\\\n        break;\\\\n\\\\n    case '都市':\\\\n\\\\n        style_id = 10080;\\\\n\\\\n        break;\\\\n\\\\n    case '古装':\\\\n\\\\n        style_id = 10081;\\\\n\\\\n        break;\\\\n\\\\n    case '谍战':\\\\n\\\\n        style_id = 10082;\\\\n\\\\n        break;\\\\n\\\\n    case '经典':\\\\n\\\\n        style_id = 10083;\\\\n\\\\n        break;\\\\n\\\\n    case '情感':\\\\n\\\\n        style_id = 10084;\\\\n\\\\n        break;\\\\n\\\\n    case '神话':\\\\n\\\\n        style_id = 10085;\\\\n\\\\n        break;\\\\n\\\\n    case '年代':\\\\n\\\\n        style_id = 10086;\\\\n\\\\n        break;\\\\n\\\\n    case '农村':\\\\n\\\\n        style_id = 10087;\\\\n\\\\n        break;\\\\n\\\\n    case '刑侦':\\\\n\\\\n        style_id = 10088;\\\\n\\\\n        break;\\\\n\\\\n    case '军旅':\\\\n\\\\n        style_id = 10089;\\\\n\\\\n        break;\\\\n\\\\n    case '访谈':\\\\n\\\\n        style_id = 10090;\\\\n\\\\n        break;\\\\n\\\\n    case '脱口秀':\\\\n\\\\n        style_id = 10091;\\\\n\\\\n        break;\\\\n\\\\n    case '真人秀':\\\\n\\\\n        style_id = 10092;\\\\n\\\\n        break;\\\\n\\\\n    case '选秀':\\\\n\\\\n        style_id = 10094;\\\\n\\\\n        break;\\\\n\\\\n    case '旅游':\\\\n\\\\n        style_id = 10095;\\\\n\\\\n        break;\\\\n\\\\n    case '晚会':\\\\n\\\\n        style_id = 10098;\\\\n\\\\n        break;\\\\n\\\\n    case '演唱会':\\\\n\\\\n        style_id = 10096;\\\\n\\\\n        break;\\\\n\\\\n    case '亲子':\\\\n\\\\n        style_id = 10097;\\\\n\\\\n        break;\\\\n\\\\n    case '养成':\\\\n\\\\n        style_id = 10099;\\\\n\\\\n        break;\\\\n\\\\n    case '文化':\\\\n\\\\n        style_id = 10100;\\\\n\\\\n        break;\\\\n\\\\n        // 电影栏目\\\\n\\\\n    case '短片':\\\\n\\\\n        style_id = 10104;\\\\n\\\\n        break;\\\\n\\\\n    default:\\\\n\\\\n        style_id = -1;\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\n// 映射真实请求地址\\\\n\\\\nswitch (seasonType) {\\\\n\\\\n    case 4:\\\\n\\\\n        // 国创\\\\n\\\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?season_version=' + season_version + '&is_finish=' + is_finish + '&copyright=&s' + copyright + 'eason_status=' + season_status + '&year=' + year + '&style_id=' + style_id + '&order=3&st=4&sort=0&page=' + page + '&season_type=4&pagesize=20&type=1'\\\\n\\\\n        break;\\\\n\\\\n    case 5:\\\\n\\\\n        // 电视剧\\\\n\\\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?area=' + area + '&style_id=' + style_id + '&release_date=' + release_date + '&season_status=' + season_status + '&order=2&st=5&sort=0&page=' + page + '&season_type=5&pagesize=20&type=1'\\\\n\\\\n        break;\\\\n\\\\n    case 7:\\\\n\\\\n        // 综艺\\\\n\\\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?season_status=' + season_status + '&style_id=' + style_id + '&order=2&st=7&sort=0&page=' + page + '&season_type=7&pagesize=20&type=1';\\\\n\\\\n        break;\\\\n\\\\n    case 1:\\\\n\\\\n        // 番剧\\\\n\\\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?season_version=' + season_version + '&spoken_language_type=' + spoken_language_type + '&area=' + area + '&is_finish=' + is_finish + '&copyright=' + copyright + '&season_status=' + season_status + '&season_month=' + season_month + '&year=' + year + '&style_id=' + style_id + '&order=3&st=1&sort=0&page=' + page + '&season_type=1&pagesize=20&type=1';\\\\n\\\\n        break;\\\\n\\\\n    case 3:\\\\n\\\\n        // 纪录片\\\\n\\\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?style_id=' + style_id + '&producer_id=' + producer_id + '&release_date=' + release_date + '&season_status=' + season_status + '&order=2&st=3&sort=0&page=' + page + '&season_type=3&pagesize=20&type=1'\\\\n\\\\n        break;\\\\n\\\\n    case 2:\\\\n\\\\n        // 电影\\\\n\\\\n        true_url = 'https://api.bilibili.com/pgc/season/index/result?area=' + area + '&style_id=' + style_id + '&release_date=' + release_date + '&season_status=' + season_status + '&order=2&st=2&sort=0&page=' + page + '&season_type=2&pagesize=20&type=1'\\\\n\\\\n        break;\\\\n\\\\n}\\\\n\\\\ntrue_url = encodeURI(true_url);\\\\n\\\\nlist = JSON.parse(fetch(true_url)).data.list;\\\\n\\\\ntry {\\\\n\\\\n    list.forEach(movie => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: movie.title,\\\\n\\\\n            url: \\\\\\\"hiker://page/filmerji#immersiveTheme#\\\\\\\",\\\\n\\\\n            img: movie.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            desc: movie.order,\\\\n\\\\n            col_type: 'movie_3',\\\\n\\\\n            extra: {\\\\n\\\\n                season_id: movie.season_id\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    });\\\\n\\\\n} catch (e) {\\\\n\\\\n    log('已经抵达页底' + MY_PAGE);\\\\n\\\\n}\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"热映时间表\\\",\\\"path\\\":\\\"UpdateTables\\\",\\\"rule\\\":\\\"function color(text, color) {\\\\n\\\\n    text += \\\\\\\"\\\\\\\";\\\\n\\\\n    if (text.indexOf(\\\\\\\"““””\\\\\\\") === 0) {\\\\n\\\\n        text.replace(\\\\\\\"““””\\\\\\\", \\\\\\\"\\\\\\\");\\\\n\\\\n    }\\\\n\\\\n    return \\\\\\\"““””<font color='\\\\\\\" + color + \\\\\\\"'>\\\\\\\" + text + \\\\\\\"</font>\\\\\\\";\\\\n\\\\n}\\\\n\\\\nvar tabs = {\\\\n\\\\n    \\\\\\\"番剧\\\\\\\": 1,\\\\n\\\\n    \\\\\\\"纪录片\\\\\\\": 3,\\\\n\\\\n    \\\\\\\"国创\\\\\\\": 4\\\\n\\\\n}\\\\n\\\\nif (MY_PAGE == 1) {\\\\n\\\\n    Object.keys(tabs).forEach(item => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: (getMyVar(\\\\\\\"juji\\\\\\\", \\\\\\\"国创\\\\\\\") == item ? color(item, \\\\\\\"red\\\\\\\") : item),\\\\n\\\\n            url: $().lazyRule((a) => {\\\\n\\\\n                putMyVar(\\\\\\\"juji\\\\\\\", a)\\\\n\\\\n                refreshPage()\\\\n\\\\n                return \\\\\\\"toast://切换成功\\\\\\\"\\\\n\\\\n            }, item),\\\\n\\\\n            col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n\\\\n        })\\\\n\\\\n    })\\\\n\\\\n    d.push({\\\\n\\\\n        col_type: \\\\\\\"line\\\\\\\"\\\\n\\\\n    })\\\\n\\\\n    let days = 7\\\\n\\\\n    for (let i = 1; i < days; i++) {\\\\n\\\\n        d.push({\\\\n\\\\n            title: (getMyVar(\\\\\\\"from\\\\\\\", \\\\\\\"1\\\\\\\") == i + \\\\\\\"\\\\\\\" ? color(i + \\\\\\\"天前\\\\\\\", \\\\\\\"red\\\\\\\") : i + \\\\\\\"天前\\\\\\\"),\\\\n\\\\n            url: $().lazyRule((i) => {\\\\n\\\\n                putMyVar(\\\\\\\"from\\\\\\\", i + \\\\\\\"\\\\\\\")\\\\n\\\\n                refreshPage()\\\\n\\\\n                return \\\\\\\"hiker://empty\\\\\\\"\\\\n\\\\n            }, i),\\\\n\\\\n            col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n\\\\n        })\\\\n\\\\n    }\\\\n\\\\n    d.push({\\\\n\\\\n        col_type: \\\\\\\"line\\\\\\\"\\\\n\\\\n    })\\\\n\\\\n    for (let i = 1; i < days; i++) {\\\\n\\\\n        d.push({\\\\n\\\\n            title: (getMyVar(\\\\\\\"to\\\\\\\", \\\\\\\"1\\\\\\\") == i + \\\\\\\"\\\\\\\" ? color(i + \\\\\\\"天后\\\\\\\", \\\\\\\"red\\\\\\\") : i + \\\\\\\"天后\\\\\\\"),\\\\n\\\\n            url: $().lazyRule((i) => {\\\\n\\\\n                putMyVar(\\\\\\\"to\\\\\\\", i + \\\\\\\"\\\\\\\")\\\\n\\\\n                refreshPage()\\\\n\\\\n                return \\\\\\\"hiker://empty\\\\\\\"\\\\n\\\\n            }, i),\\\\n\\\\n            col_type: \\\\\\\"scroll_button\\\\\\\"\\\\n\\\\n        })\\\\n\\\\n    }\\\\n\\\\n\\\\n    $.require(\\\\\\\"hiker://page/api\\\\\\\").getMovies(tabs[getMyVar(\\\\\\\"juji\\\\\\\", \\\\\\\"国创\\\\\\\")], getMyVar(\\\\\\\"from\\\\\\\", \\\\\\\"1\\\\\\\"), getMyVar(\\\\\\\"to\\\\\\\", \\\\\\\"1\\\\\\\")).forEach(item => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: item.date + \\\\\\\" 周\\\\\\\" + item.day_of_week,\\\\n\\\\n            col_type: \\\\\\\"text_1\\\\\\\",\\\\n\\\\n            url: \\\\\\\"hiker://empty\\\\\\\"\\\\n\\\\n        })\\\\n\\\\n        item.episodes.forEach(i => {\\\\n\\\\n            d.push({\\\\n\\\\n                title: i.title,\\\\n\\\\n                img: i.cover+'@Referer=',\\\\n\\\\n                desc:i.pub_index.match(/即将/)?'‘‘’’<font color=\\\\\\\"red\\\\\\\">'+i.pub_index+'\\\\\\\\n'+i.pub_time+'</font>': i.pub_index+ '\\\\\\\\n' + i.pub_time,\\\\n\\\\n                url: \\\\\\\"hiker://page/filmerji#immersiveTheme#\\\\\\\",\\\\n\\\\n                extra: {\\\\n\\\\n                    \\\\\\\"season_id\\\\\\\": i.season_id\\\\n\\\\n                }\\\\n\\\\n            })\\\\n\\\\n        })\\\\n\\\\n    })\\\\n\\\\n}\\\\n\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"个人主页\\\",\\\"path\\\":\\\"userHome\\\",\\\"rule\\\":\\\"if (MY_PAGE == 1) {\\\\n\\\\n    d.push({\\\\n\\\\n        col_type: 'line'\\\\n\\\\n    })\\\\n\\\\n    try {\\\\n\\\\n        if (isLogin.type === true) {\\\\n\\\\n            d.push({\\\\n\\\\n                title: '订阅' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">订阅</font></big>' : '订阅',\\\\n\\\\n                url: $('#noLoading#').lazyRule(() => {\\\\n\\\\n                    setItem('主页展示', '订阅');\\\\n\\\\n                    selection = ['追番', '追剧'];\\\\n\\\\n                    selection = selection.map((it) => {\\\\n\\\\n                        if (it == '追番') {\\\\n\\\\n                            typeId = '1';\\\\n\\\\n                        } else {\\\\n\\\\n                            typeId = '2';\\\\n\\\\n                        }\\\\n\\\\n                        return typeId === getItem('订阅类型', '追番') ? '👉' + it : it;\\\\n\\\\n                    });\\\\n\\\\n                    return $(selection, 1).select(() => {\\\\n\\\\n                        input = input.replace(/👉/g, '');\\\\n\\\\n                        if (input == '追番') {\\\\n\\\\n                            setItem('订阅类型', '1');\\\\n\\\\n                        } else {\\\\n\\\\n                            setItem('订阅类型', '2');\\\\n\\\\n                        }\\\\n\\\\n                        refreshPage(true);\\\\n\\\\n                        return \\\\\\\"toast://切换订阅为:\\\\\\\" + input;\\\\n\\\\n                    })\\\\n\\\\n                }),\\\\n\\\\n                col_type: 'text_4',\\\\n\\\\n            });\\\\n\\\\n            d.push({\\\\n\\\\n                title: '关注' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">关注</font></big>' : '关注',\\\\n\\\\n                url: $('#noLoading#').lazyRule(() => {\\\\n\\\\n                    setItem('主页展示', '关注');\\\\n\\\\n                    refreshPage(true);\\\\n\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                }),\\\\n\\\\n                col_type: 'text_4',\\\\n\\\\n            });\\\\n\\\\n            d.push({\\\\n\\\\n                title: '收藏' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">收藏</font></big>' : '收藏',\\\\n\\\\n                url: $('#noLoading#').lazyRule(() => {\\\\n\\\\n                    setItem('主页展示', '收藏');\\\\n\\\\n                    selection = ['我创建的收藏夹', '稍后在看'];\\\\n\\\\n                    selection = selection.map((it) => {\\\\n\\\\n                        return it === getItem('收藏类型', '我创建的收藏夹') ? '👉' + it : it;\\\\n\\\\n                    });\\\\n\\\\n                    return $(selection, 1).select(() => {\\\\n\\\\n                        input = input.replace(/👉/g, '');\\\\n\\\\n                        setItem('收藏类型', input);\\\\n\\\\n                        refreshPage(true);\\\\n\\\\n                        return \\\\\\\"toast://切换订阅为:\\\\\\\" + input;\\\\n\\\\n                    })\\\\n\\\\n                }),\\\\n\\\\n                col_type: 'text_4',\\\\n\\\\n            });\\\\n\\\\n            d.push({\\\\n\\\\n                title: '历史' == getItem('主页展示', '订阅') ? '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">历史</font></big>' : '历史',\\\\n\\\\n                url: $('#noLoading#').lazyRule(() => {\\\\n\\\\n                    setItem('主页展示', '历史');\\\\n\\\\n                    refreshPage(true);\\\\n\\\\n                    return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                }),\\\\n\\\\n                col_type: 'text_4',\\\\n\\\\n            });\\\\n\\\\n            d.push({\\\\n\\\\n                col_type: 'line'\\\\n\\\\n            })\\\\n\\\\n        } else {\\\\n\\\\n            d.push({\\\\n\\\\n                title: \\\\\\\"登陆\\\\\\\",\\\\n\\\\n                url: \\\\\\\"hiker://page/login\\\\\\\",\\\\n\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n\\\\n            })\\\\n\\\\n        }\\\\n\\\\n    } catch (e) {\\\\n\\\\n        log(e.message)\\\\n\\\\n    }\\\\n\\\\n}\\\\n\\\\n// 主页展示区\\\\n\\\\nif (isLogin.type === true) {\\\\n\\\\n    biliDate = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\"));\\\\n\\\\n    cookie = biliDate.cookie;\\\\n\\\\n    mid = biliDate.userMid;\\\\n\\\\n    switch (getItem('主页展示', '订阅')) {\\\\n\\\\n        case '关注':\\\\n\\\\n            if (MY_PAGE == 1) {\\\\n\\\\n                d.push({\\\\n\\\\n                    col_type: 'scroll_button',\\\\n\\\\n                    url: 'hiker://empty',\\\\n\\\\n                    title: '∷',\\\\n\\\\n                    extra: {\\\\n\\\\n                        id: '占位符',\\\\n\\\\n                    }\\\\n\\\\n                });\\\\n\\\\n                focusGroups = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/relation/tags?jsonp=jsonp\\\\\\\", {\\\\n\\\\n                    headers: {\\\\n\\\\n                        \\\\\\\"Cookie\\\\\\\": cookie,\\\\n\\\\n                        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n                        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n\\\\n                    }\\\\n\\\\n                })).data;\\\\n\\\\n                putMyVar('tempId', JSON.stringify(focusGroups[1].tagid));\\\\n\\\\n                focusGroups.forEach(list => {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: list.tagid == getItem('关注分组', JSON.stringify(focusGroups[1].id)) ? \\\\\\\"““””<font color='red'>\\\\\\\" + list.name + list.count + \\\\\\\"</font>\\\\\\\" : list.name + list.count,\\\\n\\\\n                        url: $('#noLoading##noHistory#').lazyRule((list) => {\\\\n\\\\n                            setItem('关注分组', JSON.stringify(list.tagid));\\\\n\\\\n                            refreshPage(true);\\\\n\\\\n                            return \\\\\\\"toast://切换关注分组为:\\\\\\\" + list.name;\\\\n\\\\n                        }, list),\\\\n\\\\n                        col_type: 'scroll_button',\\\\n\\\\n                    });\\\\n\\\\n                });\\\\n\\\\n                d.push({\\\\n\\\\n                    col_type: 'line'\\\\n\\\\n                });\\\\n\\\\n                groupContent = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/relation/tag?mid=\\\\\\\" + mid + \\\\\\\"&tagid=\\\\\\\" + getItem('关注分组', getMyVar('tempId')) + \\\\\\\"&pn=\\\\\\\" + page + \\\\\\\"&ps=20&jsonp=jsonp\\\\\\\", {\\\\n\\\\n                    headers: {\\\\n\\\\n                        \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n                    }\\\\n\\\\n                })).data;\\\\n\\\\n                groupContent.forEach(list => {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: \\\\\\\"<big><font color='blue'>\\\\\\\" + list.uname + \\\\\\\"</font></big><small>\\\\\\\" + list.sign + \\\\\\\"</small>\\\\\\\",\\\\n\\\\n                        img: list.face + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n                        col_type: 'avatar',\\\\n\\\\n                        url: \\\\\\\"hiker://page/upHome\\\\\\\",\\\\n\\\\n                        extra: {\\\\n\\\\n                            mid: list.mid,\\\\n\\\\n                            title: list.uname,\\\\n\\\\n                            face: list.face\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n            break;\\\\n\\\\n        case '收藏':\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                if (getItem('收藏类型', '我创建的收藏夹') == '我创建的收藏夹') {\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'scroll_button',\\\\n\\\\n                        url: 'hiker://empty',\\\\n\\\\n                        title: '∷',\\\\n\\\\n                        extra: {\\\\n\\\\n                            id: '占位符',\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                    collections = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\\\\\", {\\\\n\\\\n                        headers: {\\\\n\\\\n                            \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n                        }\\\\n\\\\n                    })).data;\\\\n\\\\n                    groups = collections[0].mediaListResponse.list;\\\\n\\\\n                    putMyVar('tempId', JSON.stringify(groups[0].id));\\\\n\\\\n                    groups.forEach(list => {\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: list.id == getItem('收藏夹', JSON.stringify(groups[0].id)) ? \\\\\\\"““””<font color='red'>\\\\\\\" + list.title + \\\\\\\"</font>\\\\\\\" : list.title,\\\\n\\\\n                            url: $('#noLoading##noHistory#').lazyRule((list) => {\\\\n\\\\n                                setItem('收藏夹', JSON.stringify(list.id));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"toast://切换收藏夹为:\\\\\\\" + list.title;\\\\n\\\\n                            }, list),\\\\n\\\\n                            col_type: 'scroll_button',\\\\n\\\\n                        });\\\\n\\\\n                    });\\\\n\\\\n                    d.push({\\\\n\\\\n                        col_type: 'line'\\\\n\\\\n                    });\\\\n\\\\n                    groupContent = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/v3/fav/resource/list?media_id=\\\\\\\" + getItem('收藏夹', getMyVar('tempId')) + \\\\\\\"&pn=\\\\\\\" + page + \\\\\\\"&ps=20&keyword=&order=mtime&type=0&tid=0&platform=web&jsonp=jsonp\\\\\\\", {\\\\n\\\\n                        headers: {\\\\n\\\\n                            \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n                        }\\\\n\\\\n                    })).data.medias;\\\\n\\\\n                    groupContent.forEach(list => {\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: list.title,\\\\n\\\\n                            img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n                            col_type: 'movie_1_left_pic',\\\\n\\\\n                            url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                            desc: 'UP:' + list.upper.name + '\\\\\\\\n' + list.intro,\\\\n\\\\n                            extra: {\\\\n\\\\n                                aid: list.id\\\\n\\\\n                            }\\\\n\\\\n                        });\\\\n\\\\n                    });\\\\n\\\\n                } else {\\\\n\\\\n                    laterViews = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/v2/history/toview/web?jsonp=jsonp\\\\\\\", {\\\\n\\\\n                        headers: {\\\\n\\\\n                            \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n                        }\\\\n\\\\n                    })).data;\\\\n\\\\n                    count = laterViews.count;\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: \\\\\\\"共有\\\\\\\" + count + \\\\\\\"条待看视频记录\\\\\\\",\\\\n\\\\n                        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n                        col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n\\\\n                    });\\\\n\\\\n                    laterViews.list.forEach(list => {\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: list.title,\\\\n\\\\n                            img: list.pic + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n                            col_type: 'movie_1_left_pic',\\\\n\\\\n                            url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                            desc: 'UP:' + list.owner.name + '\\\\\\\\n' + list.desc,\\\\n\\\\n                            extra: {\\\\n\\\\n                                aid: list.aid\\\\n\\\\n                            }\\\\n\\\\n                        });\\\\n\\\\n                    });\\\\n\\\\n                }\\\\n\\\\n            }\\\\n\\\\n            break;\\\\n\\\\n        case '订阅':\\\\n\\\\n            subscriptions = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/space/bangumi/follow/list?type=\\\\\\\" + getItem('订阅类型', '1') + \\\\\\\"&follow_status=0&pn=\\\\\\\" + page + \\\\\\\"&ps=15&vmid=\\\\\\\" + mid, {\\\\n\\\\n                headers: {\\\\n\\\\n                    \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n                }\\\\n\\\\n            })).data;\\\\n\\\\n            if (getItem('订阅类型', '1') == '1') {\\\\n\\\\n                typerName = '追番';\\\\n\\\\n            } else {\\\\n\\\\n                typerName = '追剧';\\\\n\\\\n            }\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                d.push({\\\\n\\\\n                    title: \\\\\\\"当前\\\\\\\" + typerName + \\\\\\\"数量:\\\\\\\" + subscriptions.total,\\\\n\\\\n                    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n                    col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n\\\\n                })\\\\n\\\\n            }\\\\n\\\\n            subscriptions.list.forEach(list => {\\\\n\\\\n                d.push({\\\\n\\\\n                    title: list.title,\\\\n\\\\n                    img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n                    url: \\\\\\\"hiker://page/filmerji#immersiveTheme#\\\\\\\",\\\\n\\\\n                    desc: list.evaluate.substring(0, 12) + '‘‘’’…<font color=\\\\\\\"#1C1C1C\\\\\\\">详情</font>' + '\\\\\\\\n' + list.season_type_name + '|' + list.areas[0].name + '\\\\\\\\n' + (list.progress == '' ? '尚未观看' : list.progress) + '|' + (list.new_ep.index_show.match(/更新/) ? '‘‘’’<font color=\\\\\\\"red\\\\\\\">' + list.new_ep.index_show + '</font>' : list.new_ep.index_show),\\\\n\\\\n                    col_type: 'movie_1_vertical_pic',\\\\n\\\\n                    extra: {\\\\n\\\\n                        season_id: list.season_id\\\\n\\\\n                    }\\\\n\\\\n                });\\\\n\\\\n            });\\\\n\\\\n            break;\\\\n\\\\n        case '历史':\\\\n\\\\n            var nextInfo = {};\\\\n\\\\n            if (page == 1) {\\\\n\\\\n                histories = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=0&view_at=0&business=\\\\\\\", {\\\\n\\\\n                    headers: {\\\\n\\\\n                        \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n                    }\\\\n\\\\n                })).data;\\\\n\\\\n                nextInfo.max = histories.cursor.max;\\\\n\\\\n                nextInfo.view_at = histories.cursor.view_at;\\\\n\\\\n                nextInfo.business = histories.cursor.business;\\\\n\\\\n            } else {\\\\n\\\\n                histories = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=\\\\\\\" + storage0.getMyVar(JSON.stringify(page)).max + \\\\\\\"&view_at=\\\\\\\" + storage0.getMyVar(JSON.stringify(page)).view_at + \\\\\\\"&business=\\\\\\\" + storage0.getMyVar(JSON.stringify(page)).business, {\\\\n\\\\n                    headers: {\\\\n\\\\n                        \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n                    }\\\\n\\\\n                })).data;\\\\n\\\\n                nextInfo.max = histories.cursor.max;\\\\n\\\\n                nextInfo.view_at = histories.cursor.view_at;\\\\n\\\\n                nextInfo.business = histories.cursor.business;\\\\n\\\\n            }\\\\n\\\\n            storage0.putMyVar(JSON.stringify(page + 1), nextInfo);\\\\n\\\\n            histories.list.forEach(list => {\\\\n\\\\n                // 还有要判断番剧影视类型\\\\n\\\\n                if (list.badge == '专栏') {\\\\n\\\\n                    // 后续处理\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: list.show_title,\\\\n\\\\n                        img: list.covers[0] + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n                        col_type: 'movie_1_left_pic',\\\\n\\\\n                        url: \\\\\\\"hiker://page/note#immersiveTheme#\\\\\\\",\\\\n\\\\n                        desc: 'UP:' + list.author_name + '\\\\\\\\n' + list.tag_name,\\\\n\\\\n                        extra: {\\\\n\\\\n                            aid: list.history.oid,\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                } else {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: list.show_title,\\\\n\\\\n                        img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n                        col_type: 'movie_1_left_pic',\\\\n\\\\n                        url: \\\\\\\"hiker://page/video#immersiveTheme#\\\\\\\",\\\\n\\\\n                        desc: 'UP:' + list.author_name + '\\\\\\\\n' + list.tag_name,\\\\n\\\\n                        extra: {\\\\n\\\\n                            aid: list.history.oid,\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                }\\\\n\\\\n            });\\\\n\\\\n            break;\\\\n\\\\n        default:\\\\n\\\\n            log('出错了~');\\\\n\\\\n            break;\\\\n\\\\n    }\\\\n\\\\n}\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"登录\\\",\\\"path\\\":\\\"login\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nvar d = [];\\\\n\\\\n// 如果获取失败就再试一次~\\\\n\\\\nd.push({\\\\n\\\\n    url: \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n\\\\n    desc: \\\\\\\"100%&&float\\\\\\\",\\\\n\\\\n    extra: {\\\\n\\\\n        js: $.toString(() => {\\\\n\\\\n            fba.setAppBarColor(\\\\\\\"pink\\\\\\\");\\\\n\\\\n            var token_timer = function () {\\\\n\\\\n                var timer = setInterval(() => {\\\\n\\\\n                    // if (document.getElementsByClassName(\\\\\\\"header-login-entry\\\\\\\")[0] === undefined) {\\\\n\\\\n                    if (document.getElementsByClassName(\\\\\\\"unlogin-avatar\\\\\\\")[0] === undefined) {\\\\n\\\\n                        settings = JSON.stringify({\\\\n\\\\n                            cookie: fba.getCookie(\\\\\\\"https://www.bilibili.com/\\\\\\\"),\\\\n\\\\n                            face: 'https://lanmeiguojiang.com/tubiao/movie/20.svg'\\\\n\\\\n                        });\\\\n\\\\n                        fba.writeFile(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\", settings);\\\\n\\\\n                        alert(\\\\\\\"已获取到cookie\\\\\\\");\\\\n\\\\n                        fba.back()\\\\n\\\\n                    }\\\\n\\\\n                }, 100)\\\\n\\\\n            };\\\\n\\\\n            token_timer();\\\\n\\\\n        }),\\\\n\\\\n        ua: PC_UA,\\\\n\\\\n        canBack: true\\\\n\\\\n    }\\\\n\\\\n})\\\\n\\\\nsetResult(d);\\\\n\\\\n\\\\njs:\\\\n\\\\nvar d = [];\\\\n\\\\n// 如果获取失败就再试一次~\\\\n\\\\nd.push({\\\\n\\\\n    url: \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n\\\\n    desc: \\\\\\\"100%&&float\\\\\\\",\\\\n\\\\n    extra: {\\\\n\\\\n        js: $.toString(() => {\\\\n\\\\n            fba.setAppBarColor(\\\\\\\"pink\\\\\\\");\\\\n\\\\n            var token_timer = function () {\\\\n\\\\n                var timer = setInterval(() => {\\\\n\\\\n                    // if (document.getElementsByClassName(\\\\\\\"header-login-entry\\\\\\\")[0] === undefined) {\\\\n\\\\n                    if (document.getElementsByClassName(\\\\\\\"unlogin-avatar\\\\\\\")[0] === undefined) {\\\\n\\\\n                        settings = JSON.stringify({\\\\n\\\\n                            cookie: fba.getCookie(\\\\\\\"https://www.bilibili.com/\\\\\\\"),\\\\n\\\\n                            face: 'https://lanmeiguojiang.com/tubiao/movie/20.svg'\\\\n\\\\n                        });\\\\n\\\\n                        fba.writeFile(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\", settings);\\\\n\\\\n                        alert(\\\\\\\"已获取到cookie\\\\\\\");\\\\n\\\\n                        fba.back()\\\\n\\\\n                    }\\\\n\\\\n                }, 100)\\\\n\\\\n            };\\\\n\\\\n            token_timer();\\\\n\\\\n        }),\\\\n\\\\n        ua: PC_UA,\\\\n\\\\n        canBack: true\\\\n\\\\n    }\\\\n\\\\n})\\\\n\\\\nsetResult(d);\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"影视二级\\\",\\\"path\\\":\\\"filmerji\\\",\\\"rule\\\":\\\"js:\\\\n// 数据定位\\\\nvar d = [];\\\\nif (MY_PARAMS.season_id) {\\\\n    season_id = MY_PARAMS.season_id + \\\\\\\"\\\\\\\";\\\\n    Data = JSON.parse(fetch('https://api.bilibili.com/pgc/view/web/season?season_id=' + season_id)).result;\\\\n} else {\\\\n    Data = JSON.parse(fetch('https://api.bilibili.com/pgc/view/web/season?ep_id=' + MY_PARAMS.ep_id)).result;\\\\n}\\\\n封面 = Data.cover + \\\\\\\"@Referer=\\\\\\\";\\\\n地区 = Data.areas[0].name;\\\\n简介 = Data.evaluate;\\\\n// 正片\\\\n类型 = Data.positive.title;\\\\n上映时间 = Data.publish.pub_time;\\\\ntry {\\\\n    得分 = Data.rating.score;\\\\n} catch (e) {\\\\n    得分 = '暂无得';\\\\n}\\\\n追剧日历 = Data.new_ep.desc;\\\\n更新进度 = Data.new_ep.title;\\\\n影片名称 = Data.title;\\\\n第二标题 = Data.share_sub_title;\\\\n剧集列表 = Data.episodes;\\\\n短讯 = \\\\\\\"⭐\\\\\\\" + 类型 + \\\\\\\"⭐\\\\\\\" + 第二标题 + '\\\\\\\\n' + 地区 + '-' + 得分 + '分\\\\\\\\n-' + 上映时间 + '-';\\\\n// 重定义二级页面数据\\\\nsetPageTitle(影片名称);\\\\nsetPagePicUrl(封面);\\\\n// 前置参数和预处理---\\\\nimgLink = storage0.getMyVar('图标');\\\\n// 全局lazy——直链+断插\\\\nvar lazy = $('').lazyRule(() => {\\\\n    videoParms = findItem(input);\\\\n    aid = videoParms.extra.aid;\\\\n    bvid = videoParms.extra.bvid;\\\\n    cid = videoParms.extra.cid;\\\\n    badge = videoParms.extra.badge;\\\\n    // 提交历史记录\\\\n    $.require(\\\\\\\"hiker://page/api\\\\\\\").reportProcess(aid, cid);\\\\n    if (getMyVar('authority', 'normal') == 'SVIP') {\\\\n        return $.require(\\\\\\\"hiker://page/api\\\\\\\").biliLazy(aid, cid, 116).replace(/;/g, \\\\\\\"；；\\\\\\\");\\\\n    } else {\\\\n        if (badge.match(/会员|付费/)) {\\\\n            eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n            eval(fetch('hiker://files/cache/Parse_Dn.js', {}));\\\\n            return aytmParse(input);\\\\n        } else {\\\\n            return $.require(\\\\\\\"hiker://page/api\\\\\\\").biliLazy(aid, cid, 116).replace(/;/g, \\\\\\\"；；\\\\\\\");\\\\n        }\\\\n    }\\\\n});\\\\nvar Color = \\\\\\\"#19B89D\\\\\\\";\\\\nvar 每页集数 = 30;\\\\nvar 搜索模式 = '分组';\\\\nvar 调用名称 = '简影';\\\\nputMyVar('折叠', '关');\\\\nputMyVar('日历', '关');\\\\nputMyVar('Data', Data);\\\\nputMyVar('lazy', lazy);\\\\n// 清除变量\\\\naddListener('onClose', $.toString(() => {\\\\n    clearMyVar('分集起');\\\\n    clearMyVar('分集终');\\\\n    clearMyVar('折叠');\\\\n    clearMyVar('日历');\\\\n    clearMyVar('Data');\\\\n    clearMyVar('lazy');\\\\n    clearMyVar('剧集列表');\\\\n}))\\\\n// 设置动态最新章节\\\\nsetLastChapterRule('js:' + $.toString((MY_URL) => {\\\\n    html = fetch(MY_URL);\\\\n    Data = JSON.parse(html.match(/\\\\\\\"mediaInfo\\\\\\\"[\\\\\\\\S\\\\\\\\s]+(?=,\\\\\\\"initEpList\\\\\\\")/)[0].replace('\\\\\\\"mediaInfo\\\\\\\":', '').replace('\\\\\\\\u002F', '/'));\\\\n    追剧日历 = Data.new_ep.desc;\\\\n    更新进度 = Data.new_ep.title;\\\\n    更新状态 = 追剧日历.match(/完结|期待/) ? 追剧日历 : '更新至' + (更新进度.match(/[\\\\\\\\u4e00-\\\\\\\\u9fa5]/) ? 更新进度 : ('第' + (更新进度 == '' ? 0 : 更新进度)) + '话')\\\\n    setResult(更新状态);\\\\n}, MY_URL));\\\\n// 页面内容正文---\\\\n// 基本信息模块\\\\nd.push({\\\\n    title: 短讯,\\\\n    desc: 简介 == '' ? '暂无简介' : 简介.substring(0, 45) + '‘‘’’…<font color=\\\\\\\"#1C1C1C\\\\\\\">详情</font>',\\\\n    img: 封面,\\\\n    url: $().rule((简介) => {\\\\n        res = {};\\\\n        var d = [];\\\\n        d.push({\\\\n            title: '影片简介：' + '\\\\\\\\n\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t' + 简介,\\\\n            col_type: 'long_text'\\\\n        });\\\\n        res.data = d;\\\\n        setHomeResult(res);\\\\n    }, 简介),\\\\n    col_type: 'movie_1_vertical_pic_blur',\\\\n});\\\\n// 更新日历模块\\\\nd.push({\\\\n    title: '日历',\\\\n    img: imgLink.日历,\\\\n    url: $('#noLoading#').lazyRule((追剧日历, 更新进度) => {\\\\n        if (getMyVar('日历', '关') == '开') {\\\\n            deleteItem('追剧日历');\\\\n            putMyVar('日历', '关');\\\\n        } else {\\\\n            addItemAfter('显示模式', {\\\\n                title: 追剧日历.match(/完结|期待/) ? 追剧日历 : 追剧日历 + '<br><font color=\\\\\\\"red\\\\\\\">更新至' + (更新进度.match(/[\\\\\\\\u4e00-\\\\\\\\u9fa5]/) ? 更新进度 : ('第' + (更新进度 == '' ? 0 : 更新进度) + '话')) + '</font>',\\\\n                col_type: \\\\\\\"rich_text\\\\\\\",\\\\n                extra: {\\\\n                    id: '追剧日历'\\\\n                }\\\\n            });\\\\n            putMyVar('日历', '开');\\\\n        }\\\\n        return 'toast://已切换日历为:' + getMyVar('日历', '开')\\\\n    }, 追剧日历, 更新进度),\\\\n    col_type: 'icon_5'\\\\n});\\\\n// 订阅模块\\\\nd.push({\\\\n    title: '订阅',\\\\n    img: imgLink.订阅,\\\\n    url: $('#noLoading#').lazyRule(() => {\\\\n        selectionList = ['订阅', '取消订阅'];\\\\n        return $(selectionList, 2).select(() => {\\\\n            season_id = JSON.parse(getMyVar('Data')).season_id;\\\\n            if (input == '订阅') {\\\\n                res = $.require(\\\\\\\"hiker://page/api\\\\\\\").subscribeFilm(season_id);\\\\n            } else {\\\\n                res = $.require(\\\\\\\"hiker://page/api\\\\\\\").cancelSubscribeFilm(season_id);\\\\n            }\\\\n            return 'toast://' + res;\\\\n        });\\\\n    }),\\\\n    col_type: 'icon_5'\\\\n});\\\\n// 评论模块\\\\nd.push({\\\\n    title: '评论',\\\\n    img: imgLink.查看评论,\\\\n    url: $('#noLoading#').lazyRule(() => {\\\\n        return $('hiker://empty').rule(() => {\\\\n            var d = [];\\\\n            List = JSON.parse(getMyVar('Data')).episodes;\\\\n            List.forEach(item => {\\\\n                d.push({\\\\n                    title: item.share_copy + '<font color=\\\\\\\"#33cccc\\\\\\\">\\\\t➮</font>',\\\\n                    img: item.cover + '@Referer=',\\\\n                    url: 'hiker://page/Comments?p=fypage',\\\\n                    col_type: \\\\\\\"avatar\\\\\\\",\\\\n                    extra: {\\\\n                        \\\\\\\"id\\\\\\\": item.aid,\\\\n                        \\\\\\\"type\\\\\\\": 1\\\\n                    }\\\\n                });\\\\n            });\\\\n            setResult(d);\\\\n        });\\\\n    }),\\\\n    col_type: 'icon_5'\\\\n});\\\\n\\\\n// 精彩继续模块\\\\nd.push({\\\\n    title: '周边',\\\\n    img: imgLink.周边,\\\\n    url: $('#noLoading#').lazyRule(() => {\\\\n        Data = JSON.parse(getMyVar('Data'));\\\\n        // 有些没有直接去掉懒得处理~\\\\n        if (Data.section) {\\\\n            周边数组 = [\\\\\\\"🏷️相关系列\\\\\\\", \\\\\\\"🤣PV&花絮\\\\\\\", \\\\\\\"🍉竖屏也精彩\\\\\\\", \\\\\\\"🔥精彩二创\\\\\\\"];\\\\n        } else {\\\\n            周边数组 = [\\\\\\\"🏷️相关系列\\\\\\\"];\\\\n        }\\\\n        // 周边数组 = [\\\\\\\"🏷️相关系列\\\\\\\", \\\\\\\"🤣PV&花絮\\\\\\\", \\\\\\\"竖屏也精彩\\\\\\\", \\\\\\\"精彩二创\\\\\\\"];\\\\n        return $(周边数组, 1, 'ღ精彩继续').select(() => {\\\\n            Data = JSON.parse(getMyVar('Data'));\\\\n            lazy = getMyVar('lazy');\\\\n            if (input === '🏷️相关系列') {\\\\n                系列名称 = Data.season_title\\\\n                系列数据 = Data.seasons;\\\\n                return $().rule((系列数据) => {\\\\n                    d = [];\\\\n                    setPageTitle('🏷️相关系列');\\\\n                    if (系列数据 == [] || 系列数据 == '') {\\\\n                        d.push({\\\\n                            title: '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">⭐该影片没有相关系列哦~⭐</font></big>',\\\\n                            url: 'toast://都没有，，你点啥呀~',\\\\n                            desc: '敬请期待~',\\\\n                            col_type: 'text_center_1'\\\\n                        });\\\\n                    }\\\\n                    系列数据.forEach(list => {\\\\n                        d.push({\\\\n                            title: list.season_title,\\\\n                            img: (list.horizontal_cover_1610 == '' ? (list.horizontal_cover_169 == '' ? list.cover : list.horizontal_cover_169) : list.horizontal_cover_1610) + \\\\\\\"@Referer=\\\\\\\",\\\\n                            url: 'hiker://page/filmerji#immersiveTheme#',\\\\n                            desc: list.new_ep.index_show,\\\\n                            col_type: 'movie_1_left_pic',\\\\n                            extra: {\\\\n                                \\\\\\\"ep_id\\\\\\\": list.new_ep.id\\\\n                            }\\\\n                        });\\\\n                    });\\\\n                    setHomeResult(d);\\\\n                }, 系列数据)\\\\n            } else if (input === '🤣PV&花絮') {\\\\n                try {\\\\n                    PV和花絮数据 = Data.section[0].episodes;\\\\n                    return $().rule((PV和花絮数据, lazy) => {\\\\n                        d = [];\\\\n                        setPageTitle('🤣PV&花絮');\\\\n                        if (PV和花絮数据 == [] || PV和花絮数据 == '') {\\\\n                            d.push({\\\\n                                title: '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">⭐该影片/视频没有相关PV和花絮哦~⭐</font></big>',\\\\n                                url: 'toast://都没有，，你点啥呀~',\\\\n                                desc: '敬请期待~',\\\\n                                col_type: 'text_center_1'\\\\n                            });\\\\n                        }\\\\n                        PV和花絮数据.forEach(list => {\\\\n                            d.push({\\\\n                                title: list.title,\\\\n                                img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n                                url: list.link + lazy,\\\\n                                desc: list.subtitle + '\\\\\\\\n' + list.long_title,\\\\n                                col_type: 'movie_1_left_pic',\\\\n                                extra: {\\\\n                                    id: list.link,\\\\n                                    aid: list.aid,\\\\n                                    bvid: list.bvid,\\\\n                                    cid: list.cid,\\\\n                                    badge: list.badge\\\\n                                }\\\\n                            });\\\\n                        });\\\\n                        setHomeResult(d);\\\\n                    }, PV和花絮数据, lazy)\\\\n                } catch (e) {\\\\n                    return 'toast://没有数据哦~'\\\\n                }\\\\n            } else if (input === '🍉竖屏也精彩') {\\\\n                try {\\\\n                    竖屏也精彩数据 = Data.section[1].episodes;\\\\n                    return $().rule((竖屏也精彩数据, lazy) => {\\\\n                        d = [];\\\\n                        setPageTitle('🍉竖屏也精彩');\\\\n                        if (竖屏也精彩数据 == [] || 竖屏也精彩数据 == '') {\\\\n                            d.push({\\\\n                                title: '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">⭐该影片/视频没有相关竖屏短视频哦~⭐</font></big>',\\\\n                                url: 'toast://都没有，，你点啥呀~',\\\\n                                desc: '敬请期待~',\\\\n                                col_type: 'text_center_1'\\\\n                            });\\\\n                        }\\\\n                        竖屏也精彩数据.forEach(list => {\\\\n                            d.push({\\\\n                                title: list.title,\\\\n                                img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n                                url: list.link + lazy,\\\\n                                desc: list.subtitle + '\\\\\\\\n' + list.long_title,\\\\n                                col_type: 'movie_1_left_pic',\\\\n                                extra: {\\\\n                                    id: list.link,\\\\n                                    aid: list.aid,\\\\n                                    bvid: list.bvid,\\\\n                                    cid: list.cid,\\\\n                                    badge: list.badge\\\\n                                }\\\\n                            });\\\\n                        });\\\\n                        setHomeResult(d);\\\\n                    }, 竖屏也精彩数据, lazy)\\\\n                } catch (e) {\\\\n                    return 'toast://没有数据哦~'\\\\n                }\\\\n            } else if (input === '🔥精彩二创') {\\\\n                try {\\\\n                    精彩二创数据 = Data.section[2].episodes;\\\\n                    return $().rule((精彩二创数据, lazy) => {\\\\n                        d = [];\\\\n                        setPageTitle('🔥精彩二创');\\\\n                        if (精彩二创数据 == [] || 精彩二创数据 == '') {\\\\n                            d.push({\\\\n                                title: '‘‘’’<big><font color=\\\\\\\"red\\\\\\\">⭐该影片/视频没有二创作品哦~⭐</font></big>',\\\\n                                url: 'toast://都没有，，你点啥呀~',\\\\n                                desc: '敬请期待~',\\\\n                                col_type: 'text_center_1'\\\\n                            });\\\\n                        }\\\\n                        精彩二创数据.forEach(list => {\\\\n                            // 针对部分参数缺失的情况如凡人修仙传写的，，\\\\n                            if (list.aid == 0 || list.cid == 0) {\\\\n                                viedeoData = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\\\\\" + list.link.split('av')[1], {\\\\n                                    headers: {\\\\n                                        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n                                        \\\\\\\"Referer\\\\\\\": 'https://www.bilibili.com/'\\\\n                                    },\\\\n                                    method: \\\\\\\"GET\\\\\\\"\\\\n                                })).data;\\\\n                                aid = viedeoData.aid;\\\\n                                bvid = viedeoData.bvid;\\\\n                                cid = viedeoData.cid;\\\\n                            } else {\\\\n                                aid = list.aid;\\\\n                                bvid = list.bvid;\\\\n                                cid = list.cid;\\\\n                            }\\\\n                            d.push({\\\\n                                title: list.title,\\\\n                                img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n                                url: list.link + lazy,\\\\n                                desc: list.subtitle + '\\\\\\\\n' + list.long_title,\\\\n                                col_type: 'movie_1_left_pic',\\\\n                                extra: {\\\\n                                    id: list.link,\\\\n                                    aid: aid,\\\\n                                    bvid: bvid,\\\\n                                    cid: cid,\\\\n                                    badge: list.badge\\\\n                                }\\\\n                            });\\\\n                        });\\\\n                        setHomeResult(d);\\\\n                    }, 精彩二创数据, lazy)\\\\n                } catch (e) {\\\\n                    return 'toast://没有数据哦~'\\\\n                }\\\\n            }\\\\n            return \\\\\\\"toast://正在进入\\\\\\\" + input + \\\\\\\"界面...\\\\\\\";\\\\n        })\\\\n    }),\\\\n    col_type: \\\\\\\"icon_5\\\\\\\",\\\\n    extra: {\\\\n        id: '精彩继续'\\\\n    }\\\\n});\\\\n// 显示模式更改模块\\\\nd.push({\\\\n    title: getItem('模式', '双边'),\\\\n    img: getItem('模式', '双边') == '列表' ? imgLink.列表 : imgLink.双边,\\\\n    url: $('#noLoading#').lazyRule(() => {\\\\n        显示的剧集列表 = JSON.parse(getMyVar('显示的剧集列表'));\\\\n        if (getItem('模式', '双边') == '列表') {\\\\n            显示的剧集列表.forEach(el => {\\\\n                updateItem(el.link, {\\\\n                    col_type: 'movie_2',\\\\n                });\\\\n            });\\\\n            setItem('模式', '双边')\\\\n        } else {\\\\n            显示的剧集列表.forEach(el => {\\\\n                updateItem(el.link, {\\\\n                    col_type: 'movie_1_left_pic',\\\\n                });\\\\n            });\\\\n            setItem('模式', '列表')\\\\n        }\\\\n        imgLink = storage0.getMyVar('图标');\\\\n        updateItem('显示模式', {\\\\n            title: getItem('模式', '双边'),\\\\n            img: getItem('模式', '双边') == '列表' ? imgLink.列表 : imgLink.双边,\\\\n        });\\\\n        return 'toast://已切换模式为:' + getItem('模式', '双边')\\\\n    }),\\\\n    col_type: 'icon_5',\\\\n    extra: {\\\\n        id: '显示模式'\\\\n    }\\\\n}, {\\\\n    col_type: 'line_blank',\\\\n});\\\\n// 选插模块——局部刷新版\\\\n来源 = 'bl';\\\\nputMyVar('简插', $.toString(() => {\\\\n    let titleArr = []\\\\n    setFile = readFile('hiker://files/rules/DuanNian/MyParse.json');\\\\n    try {\\\\n        eval('json=' + setFile);\\\\n    } catch (e) {\\\\n        log('Json解析发生了错误:' + e.message);\\\\n    }\\\\n    titleArr = json.title;\\\\n    let barry1 = ['📝'];\\\\n    let barry2 = ['🔍'];\\\\n    titleArr = barry2.concat(titleArr);\\\\n    titleArr = barry1.concat(titleArr);\\\\n    eval('op=json.settings.' + 来源);\\\\n    titleArr = titleArr.map((it) => {\\\\n        return it === op ? '👉' + it : it;\\\\n    });\\\\n    putMyVar('解析数组', titleArr);\\\\n    putMyVar('setFile', setFile);\\\\n}))\\\\neval(getMyVar('简插'));\\\\nd.push({\\\\n    title: '解析：🔘<font color=\\\\\\\"' + Color + '\\\\\\\">' + op + '</font>\\\\\\\\t\\\\\\\\t页码：<font color=\\\\\\\"' + Color + '\\\\\\\">' + ((getMyVar('分集起', '首页') == '首页') ? '首页' : (getMyVar('分集起') + '-' + getMyVar('分集终'))) + '</font>',\\\\n    url: $('#noLoading#').lazyRule((json, 来源, Color, op, 影片名称, 搜索模式, 调用名称) => {\\\\n        eval(getMyVar('简插'));\\\\n        return $(eval(getMyVar('解析数组')), 3).select((json, 来源, Color, op, 影片名称, 搜索模式, 调用名称) => {\\\\n            setFile = getMyVar('setFile');\\\\n            input = input.replace(/👉/g, '');\\\\n            if (input === '📝') {\\\\n                return \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=编辑#noHistory#\\\\\\\";\\\\n            } else if (input === '🔍') {\\\\n                if (搜索模式 == '分组') {\\\\n                    return \\\\\\\"hiker://search?s=\\\\\\\" + 影片名称 + \\\\\\\"&group=\\\\\\\" + 调用名称;\\\\n                } else {\\\\n                    return \\\\\\\"hiker://search?s=\\\\\\\" + 影片名称 + \\\\\\\"&rule=\\\\\\\" + 调用名称;\\\\n                }\\\\n            }\\\\n            // 原先的配置\\\\n            originSettings = JSON.stringify(json.settings);\\\\n            // 修改配置\\\\n            eval('json.settings.' + 来源 + '=input;');\\\\n            setFile = setFile.replace(originSettings, JSON.stringify(json.settings));\\\\n            saveFile('hiker://files/rules/DuanNian/MyParse.json', setFile);\\\\n            // 刷新元素\\\\n            eval(getMyVar('简插'));\\\\n            updateItem('op', {\\\\n                title: '解析：🔘<font color=\\\\\\\"' + Color + '\\\\\\\">' + op + '</font>\\\\\\\\t\\\\\\\\t页码：<font color=\\\\\\\"' + Color + '\\\\\\\">' + ((getMyVar('分集起', '首页') == '首页') ? '首页' : (getMyVar('分集起') + '-' + getMyVar('分集终'))) + '</font>',\\\\n            });\\\\n            return \\\\\\\"toast://切换解析口为:\\\\\\\" + input;\\\\n        }, json, 来源, Color, op, 影片名称, 搜索模式, 调用名称)\\\\n    }, json, 来源, Color, op, 影片名称, 搜索模式, 调用名称),\\\\n    img: 'https://lanmeiguojiang.com/tubiao/movie/20.svg',\\\\n    col_type: \\\\\\\"avatar\\\\\\\",\\\\n    extra: {\\\\n        id: 'op'\\\\n    }\\\\n});\\\\n// 滚动剧集条栏\\\\n剧集长度 = 剧集列表.length;\\\\nif (剧集长度 > 每页集数) {\\\\n    putMyVar('刷新选集', $.toString(() => {\\\\n        putMyVar('分集起', start);\\\\n        putMyVar('分集终', end);\\\\n        eval(getMyVar('简插'));\\\\n        updateItem('op', {\\\\n            title: '解析：🔘<font color=\\\\\\\"' + Color + '\\\\\\\">' + op + '</font>\\\\\\\\t\\\\\\\\t页码：<font color=\\\\\\\"' + Color + '\\\\\\\">' + ((getMyVar('分集起', '首页') == '首页') ? '首页' : (getMyVar('分集起') + '-' + getMyVar('分集终'))) + '</font>',\\\\n        })\\\\n        // 删除\\\\n        显示的剧集列表 = JSON.parse(getMyVar('显示的剧集列表'));\\\\n        显示的剧集列表.forEach(el => {\\\\n            deleteItem(el.link);\\\\n        });\\\\n        // 添加\\\\n        lazy = getMyVar('lazy');\\\\n        剧集列表 = JSON.parse(getMyVar('剧集列表'));\\\\n        显示的剧集列表 = 剧集列表.slice(start - 1, end);\\\\n        newArray = [];\\\\n        index = 1;\\\\n        显示的剧集列表.forEach(list => {\\\\n            if (getItem('模式', '双边') == '列表') {\\\\n                newArray.push({\\\\n                    title: list.long_title,\\\\n                    img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n                    url: list.link + lazy,\\\\n                    desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\\\n                    col_type: 'movie_1_left_pic',\\\\n                    extra: {\\\\n                        id: list.link,\\\\n                        aid: list.aid,\\\\n                        bvid: list.bvid,\\\\n                        cid: list.cid,\\\\n                        badge: list.badge\\\\n                    }\\\\n                });\\\\n            } else {\\\\n                newArray.push({\\\\n                    title: list.long_title,\\\\n                    img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n                    url: list.link + lazy,\\\\n                    desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\\\n                    col_type: 'movie_2',\\\\n                    extra: {\\\\n                        id: list.link,\\\\n                        aid: list.aid,\\\\n                        bvid: list.bvid,\\\\n                        cid: list.cid,\\\\n                        badge: list.badge\\\\n                    }\\\\n                });\\\\n            }\\\\n            index += 1;\\\\n        });\\\\n        addItemAfter(getMyVar('末页'), newArray);\\\\n        putMyVar('显示的剧集列表', 显示的剧集列表);\\\\n    }));\\\\n    d.push({\\\\n        col_type: 'scroll_button',\\\\n        url: 'hiker://empty',\\\\n        title: '∷',\\\\n        extra: {\\\\n            id: '占位符',\\\\n        }\\\\n    })\\\\n    putMyVar('分集起', 1);\\\\n    putMyVar('分集终', 每页集数);\\\\n    putMyVar('剧集列表', 剧集列表);\\\\n    总页数 = Math.ceil(剧集长度 / 每页集数);\\\\n    start = 1;\\\\n    end = 每页集数;\\\\n    for (let page = 1; page <= 总页数; page++) {\\\\n        if (end > 剧集长度) {\\\\n            end = 剧集长度;\\\\n        }\\\\n        d.push({\\\\n            title: start + '-' + end,\\\\n            url: $('#noLoading##noHistory#').lazyRule((start, end, Color, 来源) => {\\\\n                eval(getMyVar('刷新选集'));\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n            }, start, end, Color, 来源),\\\\n            col_type: 'scroll_button',\\\\n            extra: {\\\\n                id: start + '-' + end\\\\n            }\\\\n        });\\\\n        if (end < 剧集长度) {\\\\n            start += 每页集数;\\\\n            end += 每页集数;\\\\n        }\\\\n    }\\\\n    // 记录末页的id\\\\n    putMyVar('末页', start + '-' + end);\\\\n} else {\\\\n    putMyVar('分集起', 1);\\\\n    putMyVar('分集终', 剧集长度);\\\\n}\\\\n// 展示剧集:\\\\n显示的剧集列表 = 剧集列表.slice(0, getMyVar('分集终'));\\\\nputMyVar('显示的剧集列表', 显示的剧集列表);\\\\nindex = 1;\\\\n显示的剧集列表.forEach(list => {\\\\n    if (getItem('模式', '双边') == '列表') {\\\\n        d.push({\\\\n            title: list.long_title,\\\\n            img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n            url: list.link + lazy,\\\\n            desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\\\n            col_type: 'movie_1_left_pic',\\\\n            extra: {\\\\n                id: list.link,\\\\n                aid: list.aid,\\\\n                bvid: list.bvid,\\\\n                cid: list.cid,\\\\n                badge: list.badge\\\\n            }\\\\n        });\\\\n    } else {\\\\n        d.push({\\\\n            title: list.long_title,\\\\n            img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n            url: list.link + lazy,\\\\n            desc: list.title.match(/[0-9]/) ? (list.badge + '第' + list.title + '话') : list.title,\\\\n            col_type: 'movie_2',\\\\n            extra: {\\\\n                id: list.link,\\\\n                aid: list.aid,\\\\n                bvid: list.bvid,\\\\n                cid: list.cid,\\\\n                badge: list.badge\\\\n            }\\\\n        });\\\\n    }\\\\n    index += 1;\\\\n});\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"up主页\\\",\\\"path\\\":\\\"upHome\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nvar d = [];\\\\n\\\\n// 预处理\\\\n\\\\nputMyVar('upInfo', '关');\\\\n\\\\nsetPageTitle(MY_PARAMS.title);\\\\n\\\\nimgLink=storage0.getMyVar('图标');\\\\n\\\\n// 防止反爬虫，从上一个页面传递数据——反爬虫严重\\\\n\\\\nupMid = MY_PARAMS.mid + \\\\\\\"\\\\\\\";\\\\n\\\\nupName = MY_PARAMS.title;\\\\n\\\\nupFace = MY_PARAMS.face;\\\\n\\\\nrelation=$.require(\\\\\\\"hiker://page/api\\\\\\\").userMapping(upMid);\\\\n\\\\n// 头像栏\\\\n\\\\nd.push({\\\\n\\\\n    title: '<font color=\\\\\\\"blue\\\\\\\">' + upName + '</font>',\\\\n\\\\n    url: $('#noLoading#').lazyRule((upMid) => {\\\\n\\\\n        if (getMyVar('upInfo', '关') == '开') {\\\\n\\\\n            deleteItem('upInfo');\\\\n\\\\n            putMyVar('upInfo', '关');\\\\n\\\\n        } else {\\\\n\\\\n            // 用户基本信息——因为直接使用接口经常触发反爬虫机制故使用网页源码获取信息，而且只能fetchCodeByWebView\\\\n\\\\n            let u = \\\\\\\"https://m.bilibili.com/space/\\\\\\\" + upMid;\\\\n\\\\n            html = fetchCodeByWebView(u, {\\\\n\\\\n                blockRules: ['.png', '.jpg'],\\\\n\\\\n                timeout: 5000\\\\n\\\\n            });\\\\n\\\\n            infoCard = pdfa(html, '.info-card&&tr');\\\\n\\\\n            // 垃圾定位，我直接匹配处理字符串得了~\\\\n\\\\n            info='';\\\\n\\\\n            // 排除up封面数据\\\\n\\\\n            for (let i = 1; i < infoCard.length; i++) {\\\\n\\\\n                if (i==infoCard.length-1) {\\\\n\\\\n                    data=infoCard[i].replace('<tr>\\\\\\\\n <td>','').replace('</td>\\\\\\\\n</tr>','').replace('</td> \\\\\\\\n <td>',':')\\\\n\\\\n                }else{\\\\n\\\\n                    data=infoCard[i].replace('<tr>\\\\\\\\n <td>','').replace('</td>\\\\\\\\n</tr>','').replace('</td> \\\\\\\\n <td>',':')+'\\\\\\\\n'\\\\n\\\\n                }\\\\n\\\\n                info+=data;\\\\n\\\\n            }\\\\n\\\\n            addItemAfter('currentUp', {\\\\n\\\\n                title: info,\\\\n\\\\n                url: 'hiker://empty',\\\\n\\\\n                col_type: 'long_text',\\\\n\\\\n                extra: {\\\\n\\\\n                    id: 'upInfo'\\\\n\\\\n                }\\\\n\\\\n            });\\\\n\\\\n            putMyVar('upInfo', '开');\\\\n\\\\n        }\\\\n\\\\n        return 'toast://信息折叠:' + getMyVar('upInfo', '开')\\\\n\\\\n    }, upMid),\\\\n\\\\n    img: upFace + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n    col_type: \\\\\\\"avatar\\\\\\\",\\\\n\\\\n    extra: {\\\\n\\\\n        id: 'currentUp'\\\\n\\\\n    }\\\\n\\\\n},{\\\\n\\\\n    col_type: 'line'\\\\n\\\\n});\\\\n\\\\n// 公告\\\\n\\\\nnoticeText = JSON.parse(fetch('https://api.bilibili.com/x/space/notice?mid=' + upMid + '&jsonp=jsonp', {\\\\n\\\\n    headers: {\\\\n\\\\n        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n\\\\n    }\\\\n\\\\n})).data;\\\\n\\\\nif (noticeText != '') {\\\\n\\\\n    d.push({\\\\n\\\\n        title: '公告',\\\\n\\\\n        url: $().rule((noticeText) => {\\\\n\\\\n            var d = [];\\\\n\\\\n            d.push({\\\\n\\\\n                title: '公告：' + '\\\\\\\\n\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t' + noticeText,\\\\n\\\\n                col_type: 'long_text'\\\\n\\\\n            });\\\\n\\\\n            setHomeResult(d);\\\\n\\\\n        }, noticeText),\\\\n\\\\n        desc: noticeText == '' ? '暂无公告' : noticeText,\\\\n\\\\n        col_type: 'text_1',\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\nd.push({\\\\n\\\\n    col_type: 'line'\\\\n\\\\n}, {\\\\n\\\\n    title: relation,\\\\n\\\\n    img: relation=='未关注'?imgLink.添加关注:imgLink.已关注,\\\\n\\\\n    url: $('#noLoading##noHistory#').lazyRule((upMid) => {\\\\n\\\\n        return $.require(\\\\\\\"hiker://page/api\\\\\\\").changeUserRelation(upMid, 11)\\\\n\\\\n    }, upMid),\\\\n\\\\n    col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n    extra:{\\\\n\\\\n        id:'relation'\\\\n\\\\n    }\\\\n\\\\n}, {\\\\n\\\\n    title: '动态',\\\\n\\\\n    img: imgLink.动态,\\\\n\\\\n    url: $('#noLoading##noHistory#').lazyRule((upMid) => {\\\\n\\\\n        return $('hiker://empty?p=fypage').rule((upMid)=>{\\\\n\\\\n            let d=[];\\\\n\\\\n            latenews=$.require(\\\\\\\"hiker://page/api\\\\\\\").getDynamicData('upSpace',upMid);\\\\n\\\\n            eval($.require(\\\\\\\"hiker://page/api\\\\\\\").showDynamicData());\\\\n\\\\n            setResult(d);\\\\n\\\\n        },upMid)\\\\n\\\\n    }, upMid),\\\\n\\\\n    col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n},{\\\\n\\\\n    title: '专栏',\\\\n\\\\n    img: imgLink.专栏,\\\\n\\\\n    url: \\\\\\\"hiker://page/acticleList?p=fypage\\\\\\\",\\\\n\\\\n    col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n    extra: {\\\\n\\\\n        mid: upMid\\\\n\\\\n    }\\\\n\\\\n})\\\\n\\\\n// 用户视频-合集、系列\\\\n\\\\nupVideo = JSON.parse(fetch('https://api.bilibili.com/x/polymer/space/seasons_series_list?mid=' + upMid + '&page_num=1&page_size=10', {\\\\n\\\\n    headers: {\\\\n\\\\n        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n\\\\n    }\\\\n\\\\n})).data.items_lists;\\\\n\\\\n// 视频合集、系列\\\\n\\\\ntry {\\\\n\\\\n    upVideo.seasons_list.forEach(list => {\\\\n\\\\n        season_id = list.meta.season_id;\\\\n\\\\n        // 标题-跳转更多\\\\n\\\\n        d.push({\\\\n\\\\n            title: '<font color=\\\\\\\"#33cccc\\\\\\\">' + list.meta.name.substring(0, 30) + '</font>\\\\\\\\t\\\\\\\\t<font color=\\\\\\\"red\\\\\\\">' + list.meta.total + '</font>    ➮',\\\\n\\\\n            img: 'https://lanmeiguojiang.com/tubiao/more/137.png@Referer=',\\\\n\\\\n            // img: list.meta.cover+'@Referer=',\\\\n\\\\n            col_type: 'avatar',\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((upMid, season_id) => {\\\\n\\\\n                return $('hiker://empty?fypage').rule((upMid, season_id) => {\\\\n\\\\n                    var d = [];\\\\n\\\\n                    let u = 'https://api.bilibili.com/x/polymer/space/seasons_archives_list?mid=' + upMid + '&season_id=' + season_id + '&sort_reverse=false&page_num=' + MY_PAGE + '&page_size=30';\\\\n\\\\n                    Video = JSON.parse(fetch(u, {\\\\n\\\\n                        headers: {\\\\n\\\\n                            \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n                            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n\\\\n                        }\\\\n\\\\n                    })).data;\\\\n\\\\n                    maxPage = Math.ceil(Video.page.total / Video.page.page_size);\\\\n\\\\n                    if (MY_PAGE <= maxPage) {\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: '当前:第' + Video.page.page_num + '页\\\\\\\\t\\\\\\\\t\\\\\\\\t共有' + maxPage + '页,' + Video.page.total + '条数据',\\\\n\\\\n                            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n                            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n\\\\n                        });\\\\n\\\\n                        Video.archives.forEach(list => {\\\\n\\\\n                            d.push({\\\\n\\\\n                                title: list.title,\\\\n\\\\n                                img: list.pic + '@Referer=',\\\\n\\\\n                                desc: '播放量：' + list.stat.view,\\\\n\\\\n                                col_type: 'movie_1_left_pic',\\\\n\\\\n                                url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                                extra: {\\\\n\\\\n                                    aid: list.aid\\\\n\\\\n                                }\\\\n\\\\n                            });\\\\n\\\\n                        });\\\\n\\\\n                    }\\\\n\\\\n                    setHomeResult(d);\\\\n\\\\n                }, upMid, season_id)\\\\n\\\\n            }, upMid, season_id)\\\\n\\\\n        });\\\\n\\\\n        if (list.archives === undefined) {\\\\n\\\\n            log(list.meta.name + '为空');\\\\n\\\\n        } else {\\\\n\\\\n            if (list.archives.length < 2) {\\\\n\\\\n                list.archives.forEach(list => {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: list.title,\\\\n\\\\n                        img: list.pic + '@Referer=',\\\\n\\\\n                        desc: '播放量：' + list.stat.view,\\\\n\\\\n                        col_type: 'movie_1_left_pic',\\\\n\\\\n                        url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                        extra: {\\\\n\\\\n                            aid: list.aid\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                });\\\\n\\\\n            } else if (list.archives.length == 0) {\\\\n\\\\n                d.push({\\\\n\\\\n                    title: \\\\\\\"好家伙，这家伙没有合集视频！\\\\\\\",\\\\n\\\\n                    desc: \\\\\\\"要不去点击全部视频看看~\\\\\\\",\\\\n\\\\n                    col_type: 'text_center_1',\\\\n\\\\n                    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n                });\\\\n\\\\n            } else {\\\\n\\\\n                for (let i = 0; i < 2; i++) {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: list.archives[i].title,\\\\n\\\\n                        img: list.archives[i].pic + '@Referer=',\\\\n\\\\n                        desc: '播放量：' + list.archives[i].stat.view,\\\\n\\\\n                        col_type: 'movie_1_left_pic',\\\\n\\\\n                        url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                        extra: {\\\\n\\\\n                            aid: list.archives[i].aid\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                }\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n    });\\\\n\\\\n} catch (e) {\\\\n\\\\n    d.push({\\\\n\\\\n        title: '合集为空',\\\\n\\\\n        url: 'hiker://empty',\\\\n\\\\n        desc: 'Sorry,没有数据呢~',\\\\n\\\\n        col_type: 'text_center_1',\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\ntry {\\\\n\\\\n    upVideo.series_list.forEach(list => {\\\\n\\\\n        series_id = list.meta.series_id;\\\\n\\\\n        // 标题-跳转更多\\\\n\\\\n        d.push({\\\\n\\\\n            title: '<font color=\\\\\\\"#33cccc\\\\\\\">' + list.meta.name.substring(0, 30) + '</font>\\\\\\\\t\\\\\\\\t<font color=\\\\\\\"red\\\\\\\">' + list.meta.total + '</font>    ➮',\\\\n\\\\n            img: 'https://lanmeiguojiang.com/tubiao/more/137.png@Referer=',\\\\n\\\\n            // img: list.meta.cover+'@Referer=',\\\\n\\\\n            col_type: 'avatar',\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((upMid, series_id) => {\\\\n\\\\n                return $('hiker://empty?fypage').rule((upMid, series_id) => {\\\\n\\\\n                    var d = [];\\\\n\\\\n                    let u = 'https://api.bilibili.com/x/series/archives?mid=' + upMid + '&series_id=' + series_id + '&only_normal=true&sort=desc&pn=' + MY_PAGE + '&ps=30';\\\\n\\\\n                    Video = JSON.parse(fetch(u, {\\\\n\\\\n                        headers: {\\\\n\\\\n                            \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n                            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n\\\\n                        }\\\\n\\\\n                    })).data;\\\\n\\\\n                    maxPage = Math.ceil(Video.page.total / Video.page.size);\\\\n\\\\n                    if (MY_PAGE <= maxPage) {\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: '当前:第' + Video.page.num + '页\\\\\\\\t\\\\\\\\t\\\\\\\\t共有' + maxPage + '页,' + Video.page.total + '条数据',\\\\n\\\\n                            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n                            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n\\\\n                        });\\\\n\\\\n                        Video.archives.forEach(list => {\\\\n\\\\n                            d.push({\\\\n\\\\n                                title: list.title,\\\\n\\\\n                                img: list.pic + '@Referer=',\\\\n\\\\n                                desc: '播放量：' + list.stat.view,\\\\n\\\\n                                col_type: 'movie_1_left_pic',\\\\n\\\\n                                url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                                extra: {\\\\n\\\\n                                    aid: list.aid\\\\n\\\\n                                }\\\\n\\\\n                            });\\\\n\\\\n                        });\\\\n\\\\n                    }\\\\n\\\\n                    setHomeResult(d);\\\\n\\\\n                }, upMid, series_id)\\\\n\\\\n            }, upMid, series_id)\\\\n\\\\n        });\\\\n\\\\n        if (list.archives === undefined) {\\\\n\\\\n            log(list.meta.name + '为空');\\\\n\\\\n        } else {\\\\n\\\\n            if (list.archives.length < 2) {\\\\n\\\\n                list.archives.forEach(list => {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: list.title,\\\\n\\\\n                        img: list.pic + '@Referer=',\\\\n\\\\n                        desc: '播放量：' + list.stat.view,\\\\n\\\\n                        col_type: 'movie_1_left_pic',\\\\n\\\\n                        url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                        extra: {\\\\n\\\\n                            aid: list.aid\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                });\\\\n\\\\n            } else if (list.archives.length == 0) {\\\\n\\\\n                d.push({\\\\n\\\\n                    title: \\\\\\\"好家伙，这家伙没有合集视频！\\\\\\\",\\\\n\\\\n                    desc: \\\\\\\"要不去点击全部视频看看~\\\\\\\",\\\\n\\\\n                    col_type: 'text_center_1',\\\\n\\\\n                    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n                });\\\\n\\\\n            } else {\\\\n\\\\n                for (let i = 0; i < 2; i++) {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: list.archives[i].title,\\\\n\\\\n                        img: list.archives[i].pic + '@Referer=',\\\\n\\\\n                        desc: '播放量：' + list.archives[i].stat.view,\\\\n\\\\n                        col_type: 'movie_1_left_pic',\\\\n\\\\n                        url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                        extra: {\\\\n\\\\n                            aid: list.archives[i].aid\\\\n\\\\n                        }\\\\n\\\\n                    });\\\\n\\\\n                }\\\\n\\\\n            }\\\\n\\\\n        }\\\\n\\\\n    });\\\\n\\\\n} catch (e) {\\\\n\\\\n    d.push({\\\\n\\\\n        title: '系列为空',\\\\n\\\\n        url: 'hiker://empty',\\\\n\\\\n        desc: 'Sorry,没有数据呢~',\\\\n\\\\n        col_type: 'text_center_1',\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\n// up投稿\\\\n\\\\nd.push({\\\\n\\\\n    title: 'TA的视频,点击展开全部',\\\\n\\\\n    col_type: 'text_center_1',\\\\n\\\\n    url: $('#noLoading##noHistory#').lazyRule((upMid) => {\\\\n\\\\n        return $().rule((upMid) => {\\\\n\\\\n            var d = [];\\\\n\\\\n            try {\\\\n\\\\n                upTotalVideoInfo = JSON.parse(fetch('https://api.bilibili.com/x/space/arc/search?mid=' + upMid + '&pn=' + getMyVar('_page', '1') + '&ps=25&index=1&jsonp=jsonp', {\\\\n\\\\n                    headers: {\\\\n\\\\n                        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n                        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n\\\\n                    }\\\\n\\\\n                }));\\\\n\\\\n                if (upTotalVideoInfo.message == '啥都木有') {\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: '啥都木有...',\\\\n\\\\n                        img: 'https://pic.imgdb.cn/item/632c204e16f2c2beb13652aa.jpg@Referer=',\\\\n\\\\n                        url: 'hiker://empty',\\\\n\\\\n                        desc: '不小心来到了真空的世界~',\\\\n\\\\n                        col_type: \\\\\\\"pic_1\\\\\\\"\\\\n\\\\n                    });\\\\n\\\\n                } else {\\\\n\\\\n                    upTotalVideo = upTotalVideoInfo.data;\\\\n\\\\n                    maxPage = Math.ceil(upTotalVideo.page.count / upTotalVideo.page.ps);\\\\n\\\\n                    for (let page = 1; page <= maxPage; page++) {\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: (page + \\\\\\\"\\\\\\\") == getMyVar('_page', '1') ? '‘‘’’<font color=\\\\\\\"red\\\\\\\">' + (page + \\\\\\\"\\\\\\\") + '</font>' : (page + \\\\\\\"\\\\\\\"),\\\\n\\\\n                            url: $('#noLoading##noHistory#').lazyRule((page) => {\\\\n\\\\n                                putMyVar('_page', (page + \\\\\\\"\\\\\\\"));\\\\n\\\\n                                refreshPage(true);\\\\n\\\\n                                return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n                            }, page),\\\\n\\\\n                            col_type: 'scroll_button',\\\\n\\\\n                        });\\\\n\\\\n                    }\\\\n\\\\n                    upTotalVideo.list.vlist.forEach(list => {\\\\n\\\\n                        d.push({\\\\n\\\\n                            title: list.title,\\\\n\\\\n                            img: list.pic + '@Referer=',\\\\n\\\\n                            desc: '播放量：' + list.play,\\\\n\\\\n                            col_type: 'movie_1_left_pic',\\\\n\\\\n                            url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n                            extra: {\\\\n\\\\n                                aid: list.aid\\\\n\\\\n                            }\\\\n\\\\n                        });\\\\n\\\\n                    });\\\\n\\\\n                }\\\\n\\\\n            } catch (e) {\\\\n\\\\n                d.push({\\\\n\\\\n                    title: '页面走丢了...',\\\\n\\\\n                    img: 'https://i0.hdslb.com/bfs/general/f7b667011a46615732c701f4bb1d07f793f8d1df.png@Referer=',\\\\n\\\\n                    url: 'hiker://empty',\\\\n\\\\n                    desc: '太频繁了！稍后再试~',\\\\n\\\\n                    col_type: \\\\\\\"pic_1\\\\\\\"\\\\n\\\\n                });\\\\n\\\\n            }\\\\n\\\\n            setHomeResult(d);\\\\n\\\\n        }, upMid)\\\\n\\\\n    }, upMid)\\\\n\\\\n});\\\\n\\\\nsetResult(d);\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"up搜索\\\",\\\"path\\\":\\\"upSearch\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nseaword = MY_PARAMS.seaword;\\\\n\\\\nvar d = [];\\\\n\\\\ncookie = JSON.parse(fetchCookie('https://www.bilibili.com/', {\\\\n\\\\n    headers: {\\\\n\\\\n        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n\\\\n    },\\\\n\\\\n    method: \\\\\\\"GET\\\\\\\"\\\\n\\\\n}))[1];\\\\n\\\\nresultData = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/search/type?__refresh__=true&_extra=&context=&page=\\\\\\\" + MY_PAGE + \\\\\\\"&page_size=36&order=&duration=&from_source=&from_spmid=333.337&platform=pc&highlight=1&single_column=0&keyword=\\\\\\\" + seaword + \\\\\\\"&qv_id=R2IhBDb0XZ8EM69clo2rwesz9L4wRgZy&category_id=&search_type=bili_user&order_sort=0&user_type=0&dynamic_offset=0&preload=true&com2co=true\\\\\\\", {\\\\n\\\\n    headers: {\\\\n\\\\n        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n\\\\n        \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n    },\\\\n\\\\n    method: \\\\\\\"GET\\\\\\\"\\\\n\\\\n})).data;\\\\n\\\\nif (MY_PAGE <= resultData.numPages) {\\\\n\\\\n    d.push({\\\\n\\\\n        title: '当前:第' + resultData.page + '页\\\\\\\\t\\\\\\\\t\\\\\\\\t共有' + resultData.numPages + '页,' + resultData.numResults + '条数据',\\\\n\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n\\\\n    });\\\\n\\\\n    resultData.result.forEach(list => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: \\\\\\\"<big><font color='blue'>\\\\\\\" + list.uname + \\\\\\\"</font></big><small>\\\\\\\" + list.usign + \\\\\\\"</small>\\\\\\\",\\\\n\\\\n            img: 'https://' + list.upic + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: 'avatar',\\\\n\\\\n            url: \\\\\\\"hiker://page/upHome\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                mid: list.mid,\\\\n\\\\n                title: list.uname,\\\\n\\\\n                face: 'https://' + list.upic\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\nsetSearchResult(d);\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"video搜索\\\",\\\"path\\\":\\\"videoSearch\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nseaword = MY_PARAMS.seaword;\\\\n\\\\nvar d = [];\\\\n\\\\ncookie = JSON.parse(fetchCookie('https://www.bilibili.com/', {\\\\n\\\\n    headers: {\\\\n\\\\n        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n\\\\n    },\\\\n\\\\n    method: \\\\\\\"GET\\\\\\\"\\\\n\\\\n}))[1];\\\\n\\\\nresultData = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/search/type?__refresh__=true&_extra=&context=&page=\\\\\\\" + MY_PAGE + \\\\\\\"&page_size=42&from_source=&from_spmid=333.337&platform=pc&highlight=1&single_column=0&keyword=\\\\\\\" + seaword + \\\\\\\"&qv_id=vTtUT4Rfhzt2pPz9p5Wu3ZI9QQgUfxsA&category_id=&search_type=video&dynamic_offset=0&preload=true&com2co=true\\\\\\\", {\\\\n\\\\n    headers: {\\\\n\\\\n        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n\\\\n        \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n\\\\n        \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n    },\\\\n\\\\n    method: \\\\\\\"GET\\\\\\\"\\\\n\\\\n})).data;\\\\n\\\\nif (MY_PAGE <= resultData.numPages) {\\\\n\\\\n    d.push({\\\\n\\\\n        title: '当前:第' + resultData.page + '页\\\\\\\\t\\\\\\\\t\\\\\\\\t共有' + resultData.numPages + '页,' + resultData.numResults + '条数据',\\\\n\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n\\\\n    });\\\\n\\\\n    resultData.result.forEach(list => {\\\\n\\\\n        // title=list.title.replace('<em class=\\\\\\\\\\\\\\\"keyword\\\\\\\\\\\\\\\">','<font color=\\\\\\\"red\\\\\\\">').replace('</em>','</font>')\\\\n\\\\n        title = list.title.replace(/<em class=\\\\\\\\\\\\\\\"keyword\\\\\\\\\\\\\\\">/g, '').replace(/<\\\\\\\\/em>/g, '')\\\\n\\\\n        d.push({\\\\n\\\\n            title: title,\\\\n\\\\n            img: 'https://' + list.pic + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            desc: list.description,\\\\n\\\\n            col_type: 'movie_1_left_pic',\\\\n\\\\n            url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                // 视频标识\\\\n\\\\n                aid: list.aid,\\\\n\\\\n                title: title\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\nsetSearchResult(d);\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_1_left_pic\\\",\\\"name\\\":\\\"推送\\\",\\\"path\\\":\\\"feed\\\",\\\"rule\\\":\\\"$.require(\\\\\\\"hiker://page/api\\\\\\\").getFeed().forEach(item => {\\\\n\\\\n    d.push({\\\\n\\\\n        title: item.title,\\\\n\\\\n        img: item.pic+'@Referer=',\\\\n\\\\n        desc: 'up:' + item.owner.name + '\\\\\\\\n' + item.stat.view + \\\\\\\"播放※\\\\\\\" + item.stat.like + \\\\\\\"点赞\\\\\\\",\\\\n\\\\n        url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n        col_type: 'movie_1_left_pic',\\\\n\\\\n        extra: {\\\\n\\\\n            // id其实是aid\\\\n\\\\n            aid: item.id,\\\\n\\\\n            cid: item.cid,\\\\n\\\\n        }\\\\n\\\\n    })\\\\n\\\\n})\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"text_1\\\",\\\"name\\\":\\\"API\\\",\\\"path\\\":\\\"api\\\",\\\"rule\\\":\\\"// part1:聚合函数----------------\\\\n// 登录验证\\\\n$.exports.isLoggedIn = function () {\\\\n    if (fileExist(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")) {\\\\n        biliDate = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\"));\\\\n        var cookie = biliDate.cookie;\\\\n        let userinfo = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/nav\\\\\\\", {\\\\n            headers: {\\\\n                \\\\\\\"Cookie\\\\\\\": cookie\\\\n            }\\\\n        })).data;\\\\n        if (userinfo.isLogin === false) {\\\\n            return JSON.stringify({\\\\n                \\\\\\\"userName\\\\\\\": '未登录',\\\\n                \\\\\\\"userMid\\\\\\\": '',\\\\n                \\\\\\\"userFace\\\\\\\": '',\\\\n                \\\\\\\"type\\\\\\\": false\\\\n            })\\\\n        } else {\\\\n            biliDate.userName = userinfo.uname;\\\\n            biliDate.userMid = userinfo.mid;\\\\n            biliDate.face = userinfo.face + \\\\\\\"@Referer=\\\\\\\";\\\\n            saveFile('hiker://files/rules/cy/bili.txt', JSON.stringify(biliDate));\\\\n            // return true;\\\\n            return JSON.stringify({\\\\n                \\\\\\\"userName\\\\\\\": biliDate.userName,\\\\n                \\\\\\\"userMid\\\\\\\": biliDate.userMid,\\\\n                \\\\\\\"userFace\\\\\\\": biliDate.face,\\\\n                \\\\\\\"type\\\\\\\": true\\\\n            });\\\\n        }\\\\n    } else {\\\\n        return JSON.stringify({\\\\n            \\\\\\\"userName\\\\\\\": '未登录',\\\\n            \\\\\\\"userMid\\\\\\\": '',\\\\n            \\\\\\\"userFace\\\\\\\": '',\\\\n            \\\\\\\"type\\\\\\\": false\\\\n        });\\\\n    }\\\\n}\\\\n// 哔哩视频解析：获取播放地址+提交播放记录\\\\n$.exports.biliLazy = function (id, cid, qn) {\\\\n    var dash = $.require(\\\\\\\"hiker://page/api\\\\\\\").getUrl(id, cid, qn);\\\\n    // 提交历史记录\\\\n    $.require(\\\\\\\"hiker://page/api\\\\\\\").reportProcess(id, cid);\\\\n    // qualityNum=dash.audio.length;不需要了，找到了更好的判断方法，虽然我并不知道这些参数的含义是什么\\\\n    videoList = [];\\\\n    audioList = [];\\\\n    nameList = [];\\\\n    heraders = [];\\\\n    dash.audio.forEach(item => {\\\\n        audioList.push(item.baseUrl);\\\\n        heraders.push({\\\\n            \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com\\\\\\\"\\\\n        });\\\\n    });\\\\n    dash.video.forEach(item => {\\\\n        if (item.codecid == 7) {\\\\n            videoList.push(item.baseUrl + \\\\\\\"#isVideo=true#\\\\\\\");\\\\n            if (item.id == 126) {\\\\n                nameList.push('杜比视界');\\\\n            }else if (item.id == 125) {\\\\n                nameList.push('HDR 真彩色');\\\\n            }else if (item.id == 120) {\\\\n                nameList.push('4K超清');\\\\n            } else if (item.id == 116) {\\\\n                nameList.push('1080P60高帧率');\\\\n            } else if (item.id == 112) {\\\\n                nameList.push('1080P+高码率');\\\\n            }else if (item.id == 80) {\\\\n                nameList.push('1080P高清');\\\\n            }else if (item.id == 74) {\\\\n                nameList.push('720P60高帧率');\\\\n            }else if (item.id == 64) {\\\\n                nameList.push('720P高清');\\\\n            }else if (item.id == 32) {\\\\n                nameList.push('480P清晰');\\\\n            }else if (item.id == 16) {\\\\n                nameList.push('360P流畅');\\\\n            }else if (item.id == 6) {\\\\n                nameList.push('240P极速');\\\\n            }\\\\n        }\\\\n    });\\\\n    return JSON.stringify({\\\\n        urls: videoList,\\\\n        audioUrls: audioList,\\\\n        danmu: 'https://comment.bilibili.com/' + cid + '.xml',\\\\n        names: nameList,\\\\n        headers: heraders\\\\n    })\\\\n}\\\\n// 稍后在看——总操作判断\\\\n$.exports.judgeToview = function (aid) {\\\\n    selection = ['添加', '移除'];\\\\n    return $(selection, 1).select((aid) => {\\\\n        if (input == '添加') {\\\\n            res = $.require(\\\\\\\"hiker://page/api\\\\\\\").addToview(aid);\\\\n            if (res == 0) {\\\\n                return \\\\\\\"toast://添加成功\\\\\\\"\\\\n            } else if (res == -101) {\\\\n                return \\\\\\\"toast://账号未登录\\\\\\\"\\\\n            } else if (res == -111) {\\\\n                return \\\\\\\"toast://csrf校验失败\\\\\\\"\\\\n            } else if (res == -400) {\\\\n                return \\\\\\\"toast://请求错误\\\\\\\"\\\\n            } else if (res == 90001) {\\\\n                return \\\\\\\"toast://列表已满\\\\\\\"\\\\n            } else if (res == 90003) {\\\\n                return \\\\\\\"toast://稿件已经被删除\\\\\\\"\\\\n            } else {\\\\n                return \\\\\\\"toast://未知错误\\\\\\\"\\\\n            }\\\\n        } else {\\\\n            res = $.require(\\\\\\\"hiker://page/api\\\\\\\").delToview(aid);\\\\n            if (res == 0) {\\\\n                return \\\\\\\"toast://移除成功\\\\\\\"\\\\n            } else if (res == -101) {\\\\n                return \\\\\\\"toast://账号未登录\\\\\\\"\\\\n            } else if (res == -111) {\\\\n                return \\\\\\\"toast://csrf校验失败\\\\\\\"\\\\n            } else if (res == -400) {\\\\n                return \\\\\\\"toast://请求错误\\\\\\\"\\\\n            } else {\\\\n                return \\\\\\\"toast://未知错误\\\\\\\"\\\\n            }\\\\n        }\\\\n    }, aid)\\\\n}\\\\n// 操作用户关系\\\\n$.exports.changeUserRelation = function (mid, re_src) {\\\\n    selection = ['关注', '取关', '悄悄关注', '取消悄悄关注', '拉黑', '取消拉黑', '踢出粉丝', '移动分组'];\\\\n    return $(selection, 2).select((mid, re_src) => {\\\\n        if (input == '移动分组') {\\\\n            beforeTagids = [];\\\\n            groups = $.require(\\\\\\\"hiker://page/api\\\\\\\").getUserGroup(mid);\\\\n            if (JSON.stringify(groups) == '{}') {\\\\n                beforeTagids.push(0);\\\\n            } else {\\\\n                for (var prop in groups) {\\\\n                    beforeTagids.push(parseInt(prop));\\\\n                }\\\\n            }\\\\n            // 获取我的分组\\\\n            focusGroupList = [];\\\\n            $.require(\\\\\\\"hiker://page/api\\\\\\\").getMyAttentionGroupList().forEach(list => {\\\\n                focusGroupList.push(list.name + ' ' + list.tagid);\\\\n            });\\\\n            return $(focusGroupList, 1).select((beforeTagids, mid) => {\\\\n                afterTagids = [];\\\\n                afterTagids.push(parseInt(input.split(' ')[1]));\\\\n                fids = [];\\\\n                fids.push(Number(mid));\\\\n                res = $.require(\\\\\\\"hiker://page/api\\\\\\\").moveUsers(beforeTagids, afterTagids, fids);\\\\n                if (res == 0) {\\\\n                    return \\\\\\\"toast://移动用户到\\\\\\\" + input.split(' ')[0] + \\\\\\\"分组成功\\\\\\\"\\\\n                } else if (res == -101) {\\\\n                    return \\\\\\\"toast://账号未登录\\\\\\\"\\\\n                } else if (res == -111) {\\\\n                    return \\\\\\\"toast://csrf校验失败\\\\\\\"\\\\n                } else if (res == -400) {\\\\n                    return \\\\\\\"toast://请求错误\\\\\\\"\\\\n                } else if (res == 22104) {\\\\n                    return \\\\\\\"toast://无权限\\\\\\\"\\\\n                } else if (res == 22105) {\\\\n                    return \\\\\\\"toast://未关注\\\\\\\"\\\\n                } else {\\\\n                    return \\\\\\\"toast://未知错误\\\\\\\"\\\\n                }\\\\n            }, beforeTagids, mid);\\\\n        } else {\\\\n            if (input == '关注') {\\\\n                var act = 1;\\\\n            } else if (input == '取关') {\\\\n                var act = 2;\\\\n            } else if (input == '悄悄关注') {\\\\n                var act = 3;\\\\n            } else if (input == '取消悄悄关注') {\\\\n                var act = 4;\\\\n            } else if (input == '拉黑') {\\\\n                var act = 5;\\\\n            } else if (input == '取消拉黑') {\\\\n                var act = 6;\\\\n            } else if (input == '踢出粉丝') {\\\\n                var act = 7;\\\\n            }\\\\n            res = $.require(\\\\\\\"hiker://page/api\\\\\\\").addAttention(mid, act, re_src);\\\\n            relation = $.require(\\\\\\\"hiker://page/api\\\\\\\").userMapping(mid);\\\\n            updateItem('relation', {\\\\n                title: relation,\\\\n                img: relation == '未关注' ? storage0.getMyVar('图标').添加关注 : storage0.getMyVar('图标').已关注\\\\n            });\\\\n            if (res == 0) {\\\\n                return \\\\\\\"toast://\\\\\\\" + input + \\\\\\\"成功\\\\\\\"\\\\n            } else if (res == -101) {\\\\n                return \\\\\\\"toast://账号未登录\\\\\\\"\\\\n            } else if (res == -111) {\\\\n                return \\\\\\\"toast://csrf校验失败\\\\\\\"\\\\n            } else if (res == -400) {\\\\n                return \\\\\\\"toast://请求错误\\\\\\\"\\\\n            } else if (res == 22001) {\\\\n                return \\\\\\\"toast://不能对自己进行此操作\\\\\\\"\\\\n            } else if (res == 22003) {\\\\n                return \\\\\\\"toast://用户位于黑名单\\\\\\\"\\\\n            } else {\\\\n                return \\\\\\\"toast://未知错误\\\\\\\"\\\\n            }\\\\n        }\\\\n    }, mid, re_src)\\\\n}\\\\n// 映射用户关系\\\\n$.exports.userMapping = function (mid) {\\\\n    relationRes = $.require(\\\\\\\"hiker://page/api\\\\\\\").getRelation(mid);\\\\n    if (relationRes.relation.attribute == 0) {\\\\n        relation = '未关注'\\\\n    } else if (relationRes.relation.attribute == 1) {\\\\n        relation = '悄悄关注'\\\\n    } else if (relationRes.relation.attribute == 2) {\\\\n        relation = '已关注'\\\\n    } else if (relationRes.relation.attribute == 6) {\\\\n        relation = '已互粉'\\\\n    } else if (relationRes.relation.attribute == 128) {\\\\n        relation = '已拉黑'\\\\n    }\\\\n    return relation;\\\\n}\\\\n// 点赞操作逻辑\\\\n$.exports.likeLogic = function (aid) {\\\\n    hasLike = $.require(\\\\\\\"hiker://page/api\\\\\\\").hasLike(aid);\\\\n    if (hasLike == 0) {\\\\n        res = $.require(\\\\\\\"hiker://page/api\\\\\\\").setLike(aid, 1);\\\\n        if (res == 0) {\\\\n            like = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\\\\\" + aid)).data.stat.like;\\\\n            updateItem('setLike', {\\\\n                title: (like + 1) + '',\\\\n                img: storage0.getMyVar('图标').已点赞\\\\n            });\\\\n            return \\\\\\\"toast://点赞成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://点赞出错了~\\\\\\\";\\\\n        }\\\\n    } else {\\\\n        res = $.require(\\\\\\\"hiker://page/api\\\\\\\").setLike(aid, 2);\\\\n        if (res == 0) {\\\\n            like = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\\\\\" + aid)).data.stat.like;\\\\n            updateItem('setLike', {\\\\n                title: (like - 1) + '',\\\\n                img: storage0.getMyVar('图标').未点赞\\\\n            });\\\\n            return \\\\\\\"toast://取消点赞成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://取消点赞出错了~\\\\\\\";\\\\n        }\\\\n    }\\\\n}\\\\n// 收藏操作逻辑\\\\n$.exports.favourLogic = function (aid, mid) {\\\\n    hasFavour = $.require(\\\\\\\"hiker://page/api\\\\\\\").hasFavour(aid);\\\\n    if (hasFavour) {\\\\n        // 移出收藏\\\\n        favourIdList = $.require(\\\\\\\"hiker://page/api\\\\\\\").getFavourIdList(aid, mid);\\\\n        res = $.require(\\\\\\\"hiker://page/api\\\\\\\").setFavour(aid, '', favourIdList);\\\\n        if (res == 0) {\\\\n            like = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\\\\\" + aid)).data.stat.favorite;\\\\n            updateItem('setFavour', {\\\\n                title: (like - 1) + '',\\\\n                img: storage0.getMyVar('图标').未收藏\\\\n            });\\\\n            return \\\\\\\"toast://取消收藏成功\\\\\\\";\\\\n        } else {\\\\n            return \\\\\\\"toast://取消收藏出错了~\\\\\\\";\\\\n        }\\\\n    } else {\\\\n        // 选择收藏\\\\n        res = $.require(\\\\\\\"hiker://page/api\\\\\\\").getCollectionGroupList()[0].mediaListResponse.list;\\\\n        GroupList = [];\\\\n        res.forEach(item => {\\\\n            GroupList.push(item.title + ' ' + item.id);\\\\n        });\\\\n        return $(GroupList, 1).select((aid) => {\\\\n            selectId = parseInt(input.split(' ')[1])\\\\n            res = $.require(\\\\\\\"hiker://page/api\\\\\\\").setFavour(aid, selectId, '');\\\\n            if (res == 0) {\\\\n                like = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\\\\\" + aid)).data.stat.favorite;\\\\n                updateItem('setFavour', {\\\\n                    title: (like + 1) + '',\\\\n                    img: storage0.getMyVar('图标').已收藏\\\\n                });\\\\n                return \\\\\\\"toast://收藏成功\\\\\\\";\\\\n            } else {\\\\n                return \\\\\\\"toast://收藏出错了~\\\\\\\";\\\\n            }\\\\n        }, aid);\\\\n    }\\\\n}\\\\n\\\\n\\\\n\\\\n// part2:散装API----------------\\\\n// 视频推荐\\\\n$.exports.getFeed = function () {\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/web-interface/index/top/feed/rcmd\\\\\\\";\\\\n    var res = JSON.parse(fetch(u, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    }));\\\\n    return res.data.item\\\\n}\\\\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        \\\\\\\"fnver\\\\\\\": 0,\\\\n        \\\\\\\"fnval\\\\\\\": 4048,\\\\n        \\\\\\\"fourk\\\\\\\": 1\\\\n    }), {\\\\n        headers: {\\\\n            Cookie: JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })\\\\n    return JSON.parse(u).data.dash\\\\n}\\\\n// 提交播放记录\\\\n$.exports.reportProcess = function (avid, cid) {\\\\n    // let csrf = readFile(\\\\\\\"Cookie.txt\\\\\\\").match(/bili_jct=(.*?);/)[1]\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.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: JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })\\\\n}\\\\n\\\\n// 获取评论\\\\n$.exports.getComments = function (id, type, page) {\\\\n    let u = buildUrl(\\\\\\\"http://api.bilibili.com/x/v2/reply\\\\\\\", {\\\\n        \\\\\\\"type\\\\\\\": type,\\\\n        \\\\\\\"oid\\\\\\\": id,\\\\n        \\\\\\\"pn\\\\\\\": page\\\\n    });\\\\n    let res = request(u, {\\\\n        headers: {\\\\n            Cookie: JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).data.replies\\\\n}\\\\n// 添加稍后在看——真的麻了，为什么fetch就错呢~\\\\n$.exports.addToview = function (aid) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/v2/history/toview/add\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"aid\\\\\\\": aid,\\\\n        \\\\\\\"csrf\\\\\\\": csrf,\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        },\\\\n        method: \\\\\\\"POST\\\\\\\"\\\\n    })\\\\n    return JSON.parse(res).code;\\\\n}\\\\n// 删除稍后在看\\\\n$.exports.delToview = function (aid) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let u = \\\\\\\"http://api.bilibili.com/x/v2/history/toview/del\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"aid\\\\\\\": aid,\\\\n        \\\\\\\"csrf\\\\\\\": csrf,\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        },\\\\n        method: \\\\\\\"POST\\\\\\\"\\\\n    })\\\\n    return JSON.parse(res).code;\\\\n}\\\\n// 订阅影视(追番、追剧)\\\\n$.exports.subscribeFilm = function (season_id) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let u = \\\\\\\"https://api.bilibili.com/pgc/web/follow/add\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"season_id\\\\\\\": season_id,\\\\n        \\\\\\\"csrf\\\\\\\": csrf,\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        },\\\\n        method: \\\\\\\"POST\\\\\\\"\\\\n    })\\\\n    return JSON.parse(res).result.toast;\\\\n}\\\\n// 取消订阅\\\\n$.exports.cancelSubscribeFilm = function (season_id) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let u = \\\\\\\"https://api.bilibili.com/pgc/web/follow/del\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"season_id\\\\\\\": season_id,\\\\n        \\\\\\\"csrf\\\\\\\": csrf,\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        },\\\\n        method: \\\\\\\"POST\\\\\\\"\\\\n    })\\\\n    return JSON.parse(res).result.toast;\\\\n}\\\\n/*操作用户关系\\\\nfid:用户mid\\\\nact:操作代码\\\\nre_src：关注来源\\\\n*/\\\\n$.exports.addAttention = function (mid, act, re_src) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/relation/modify\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"fid\\\\\\\": mid,\\\\n        \\\\\\\"act\\\\\\\": act,\\\\n        \\\\\\\"re_src\\\\\\\": re_src,\\\\n        \\\\\\\"csrf\\\\\\\": csrf\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        },\\\\n        method: \\\\\\\"POST\\\\\\\"\\\\n    })\\\\n    return JSON.parse(res).code;\\\\n}\\\\n// 移动关注用户分组\\\\n$.exports.moveUsers = function (beforeTagids, afterTagids, fids) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/relation/tags/moveUsers\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"beforeTagids\\\\\\\": beforeTagids.toString(),\\\\n        \\\\\\\"afterTagids\\\\\\\": afterTagids.toString(),\\\\n        \\\\\\\"fids\\\\\\\": fids.toString(),\\\\n        \\\\\\\"csrf\\\\\\\": csrf\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\",\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        },\\\\n        method: \\\\\\\"POST\\\\\\\"\\\\n    })\\\\n    return JSON.parse(res).code;\\\\n}\\\\n// 获取用户关系\\\\n$.exports.getRelation = function (mid) {\\\\n    return JSON.parse(request(\\\\\\\"https://api.bilibili.com/x/space/acc/relation?mid=\\\\\\\" + mid, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })).data\\\\n}\\\\n// 查询目标用户所在的分组\\\\n$.exports.getUserGroup = function (mid) {\\\\n    return JSON.parse(request(\\\\\\\"https://api.bilibili.com/x/relation/tag/user?fid=\\\\\\\" + mid, {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })).data\\\\n}\\\\n// 获取关注分组\\\\n$.exports.getMyAttentionGroupList = function () {\\\\n    return JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/relation/tags?jsonp=jsonp\\\\\\\", {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie,\\\\n            \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n        }\\\\n    })).data;\\\\n}\\\\n// 是否点赞\\\\n$.exports.hasLike = function (aid) {\\\\n    return JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/web-interface/archive/has/like\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": aid\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })).data\\\\n}\\\\n// 是否收藏\\\\n$.exports.hasFavour = function (aid) {\\\\n    return JSON.parse(request(buildUrl(\\\\\\\"http://api.bilibili.com/x/v2/fav/video/favoured\\\\\\\", {\\\\n        \\\\\\\"aid\\\\\\\": aid\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })).data.favoured\\\\n}\\\\n// 视频点赞\\\\n$.exports.setLike = function (aid, dealWay) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let res = post(\\\\\\\"http://api.bilibili.com/x/web-interface/archive/like\\\\\\\", {\\\\n        body: {\\\\n            \\\\\\\"aid\\\\\\\": aid,\\\\n            \\\\\\\"like\\\\\\\": dealWay,\\\\n            \\\\\\\"csrf\\\\\\\": csrf\\\\n        },\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).code;\\\\n}\\\\n// 获取收藏列表\\\\n$.exports.getCollectionGroupList = function () {\\\\n    return collections = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\\\\\", {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie,\\\\n        }\\\\n    })).data;\\\\n}\\\\n// 收藏/取消视频API\\\\n$.exports.setFavour = function (aid, add_media_ids, del_media_ids) {\\\\n    let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n    let res = post(\\\\\\\"http://api.bilibili.com/medialist/gateway/coll/resource/deal\\\\\\\", {\\\\n        body: {\\\\n            \\\\\\\"rid\\\\\\\": aid,\\\\n            \\\\\\\"type\\\\\\\": 2,\\\\n            \\\\\\\"add_media_ids\\\\\\\": add_media_ids.toString(),\\\\n            \\\\\\\"del_media_ids\\\\\\\": del_media_ids.toString(),\\\\n            \\\\\\\"csrf\\\\\\\": csrf\\\\n        },\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie,\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com\\\\\\\"\\\\n        }\\\\n    })\\\\n    return JSON.parse(res).code;\\\\n}\\\\n// 获取视频所在收藏夹\\\\n$.exports.getFavourIdList = function (aid, userMid) {\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/v3/fav/folder/created/list-all\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"type\\\\\\\": 2,\\\\n        \\\\\\\"rid\\\\\\\": aid,\\\\n        \\\\\\\"up_mid\\\\\\\": userMid,\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie,\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com\\\\\\\"\\\\n        }\\\\n    });\\\\n    favourIdList = [];\\\\n    JSON.parse(res).data.list.forEach((item) => {\\\\n        if (item.fav_state == 1) {\\\\n            favourIdList.push(item.id);\\\\n        }\\\\n    })\\\\n    return favourIdList;\\\\n}\\\\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\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n        }\\\\n    }))\\\\n    return res.result\\\\n}\\\\n// 获取专栏文章\\\\n$.exports.getUserArticle = function (upMid, page) {\\\\n    let u = \\\\\\\"https://api.bilibili.com/x/space/article\\\\\\\";\\\\n    let res = request(buildUrl(u, {\\\\n        \\\\\\\"mid\\\\\\\": upMid,\\\\n        \\\\\\\"pn\\\\\\\": page,\\\\n        \\\\\\\"ps\\\\\\\": 12,\\\\n        \\\\\\\"sort\\\\\\\": 'publish_time'\\\\n    }), {\\\\n        headers: {\\\\n            \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie,\\\\n            \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com\\\\\\\"\\\\n        }\\\\n    });\\\\n    return JSON.parse(res).data;\\\\n}\\\\n// 获取动态数据\\\\n$.exports.getDynamicData = function (from, upMid) {\\\\n    var nextInfo = {};\\\\n    if (MY_PAGE == 1) {\\\\n        if (from == 'upSpace') {\\\\n            var u = \\\\\\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space?offset=&host_mid=\\\\\\\" + upMid + \\\\\\\"&timezone_offset=-480\\\\\\\";\\\\n        } else {\\\\n            var u = \\\\\\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/all?timezone_offset=-480&type=all\\\\\\\";\\\\n        }\\\\n        latenews = JSON.parse(fetch(u, {\\\\n            headers: {\\\\n                \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie,\\\\n                \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\n                \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.bilibili.com/\\\\\\\"\\\\n            }\\\\n        })).data;\\\\n        nextInfo.offset = latenews.offset;\\\\n    } else {\\\\n        if (from == 'upSpace') {\\\\n            var u = \\\\\\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/space?offset=\\\\\\\" + storage0.getMyVar(JSON.stringify(MY_PAGE)).offset + \\\\\\\"&host_mid=\\\\\\\" + upMid + \\\\\\\"&timezone_offset=-480\\\\\\\";\\\\n        } else {\\\\n            var u = \\\\\\\"https://api.bilibili.com/x/polymer/web-dynamic/v1/feed/all?timezone_offset=-480&type=all&offset=\\\\\\\" + storage0.getMyVar(JSON.stringify(MY_PAGE)).offset;\\\\n        }\\\\n        latenews = JSON.parse(fetch(u, {\\\\n            headers: {\\\\n                \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n            }\\\\n        })).data;\\\\n        nextInfo.offset = latenews.offset;\\\\n    }\\\\n    storage0.putMyVar(JSON.stringify(MY_PAGE + 1), nextInfo);\\\\n    return latenews;\\\\n}\\\\n\\\\n// ——特别的行为、工具函数——\\\\n// 展示动态数据(返回函数方法的可执行字符串)\\\\n$.exports.showDynamicData = function () {\\\\n    return $.toString(() => {\\\\n        latenews.items.forEach(list => {\\\\n            if (list.type == 'DYNAMIC_TYPE_AV') {\\\\n                // 投稿视频（当前发布）√\\\\n                d.push({\\\\n                    title: list.modules.module_author.name + '\\\\\\\\t\\\\\\\\t\\\\\\\\t<small><small><font color=\\\\\\\"grey\\\\\\\">' + list.modules.module_author.pub_time + '-' + list.modules.module_author.pub_action + '</font></small></small>',\\\\n                    img: list.modules.module_author.face + \\\\\\\"@Referer=\\\\\\\",\\\\n                    url: 'hiker://page/upHome',\\\\n                    col_type: 'avatar',\\\\n                    extra: {\\\\n                        mid: list.modules.module_author.mid,\\\\n                        title: list.modules.module_author.name,\\\\n                        face: list.modules.module_author.face\\\\n                    }\\\\n                }, {\\\\n                    col_type: 'line'\\\\n                }, {\\\\n                    // 不一定有文字啊\\\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\\\\\"grey\\\\\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text) + '<br><a href=\\\\\\\"hiker://page/Comments?p=fypage\\\\\\\">查看评论</a>',\\\\n                    url: 'hiker://page/Comments?p=fypage',\\\\n                    // 这个不能用long_text\\\\n                    col_type: 'rich_text',\\\\n                    extra: {\\\\n                        id: list.basic.comment_id_str,\\\\n                        type: 1\\\\n                    }\\\\n                }, {\\\\n                    title: list.modules.module_dynamic.major.archive.title,\\\\n                    img: list.modules.module_dynamic.major.archive.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n                    col_type: 'movie_1_left_pic',\\\\n                    url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n                    desc: list.modules.module_dynamic.major.archive.desc,\\\\n                    extra: {\\\\n                        aid: list.modules.module_dynamic.major.archive.aid\\\\n                    }\\\\n                }, {\\\\n                    title: '<small><small><font color=\\\\\\\"grey\\\\\\\">留言:' + list.modules.module_stat.comment.count + '\\\\\\\\t\\\\\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\\\\\t\\\\\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\\\n                    col_type: 'rich_text'\\\\n                }, {\\\\n                    col_type: 'line_blank'\\\\n                });\\\\n            } else if (list.type == 'DYNAMIC_TYPE_FORWARD') {\\\\n                // 视频引用，多出了orig指向一个(过去)已发布的视频,准确的说是引用之前的帖子不一定是视频√\\\\n                d.push({\\\\n                    title: list.modules.module_author.name + '\\\\\\\\t\\\\\\\\t\\\\\\\\t<small><small><font color=\\\\\\\"grey\\\\\\\">' + list.modules.module_author.pub_time + '</font></small></small>',\\\\n                    img: list.modules.module_author.face + \\\\\\\"@Referer=\\\\\\\",\\\\n                    url: 'hiker://page/upHome',\\\\n                    col_type: 'avatar',\\\\n                    extra: {\\\\n                        mid: list.modules.module_author.mid,\\\\n                        title: list.modules.module_author.name,\\\\n                        face: list.modules.module_author.face\\\\n                    }\\\\n                }, {\\\\n                    col_type: 'line'\\\\n                }, {\\\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\\\\\"grey\\\\\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text).replace(/\\\\\\\\\\\\\\\\n/g, '<br>') + '<br><a href=\\\\\\\"hiker://page/Comments?p=fypage\\\\\\\">查看评论</a>',\\\\n                    url: 'hiker://page/Comments?p=fypage',\\\\n                    col_type: 'rich_text',\\\\n                    extra: {\\\\n                        id: list.basic.comment_id_str,\\\\n                        // 也是纯文字，因为只是文字+引用早已投稿的视频\\\\n                        type: 17\\\\n                    }\\\\n                });\\\\n                // 引用的内容——截断（根据不同的引用类型进行处理）\\\\n                d.push({\\\\n                    title: '<small><small>下面内容来自引用的帖子,up是:' + list.orig.modules.module_author.name + '</small></small>',\\\\n                    col_type: \\\\\\\"rich_text\\\\\\\"\\\\n                }, {\\\\n                    col_type: \\\\\\\"line\\\\\\\"\\\\n                });\\\\n                if (list.orig.type == 'DYNAMIC_TYPE_AV') {\\\\n                    // 引用视频说说\\\\n                    d.push({\\\\n                        title: list.orig.modules.module_dynamic.major.archive.title,\\\\n                        img: list.orig.modules.module_dynamic.major.archive.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n                        col_type: 'movie_1_left_pic',\\\\n                        url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n                        desc: list.orig.modules.module_dynamic.major.archive.desc,\\\\n                        extra: {\\\\n                            aid: list.orig.modules.module_dynamic.major.archive.aid\\\\n                        }\\\\n                    });\\\\n                } else if (list.orig.type == 'DYNAMIC_TYPE_WORD') {\\\\n                    // 引用文字说说\\\\n                    d.push({\\\\n                        title: (list.orig.modules.module_dynamic.desc.text === null ? '<font color=\\\\\\\"grey\\\\\\\">up太懒了，连文案都不想配...</font>' : list.orig.modules.module_dynamic.desc.text).replace(/\\\\\\\\\\\\\\\\n/g, '<br>') + '<br><a href=\\\\\\\"hiker://page/Comments?p=fypage\\\\\\\">查看评论</a>',\\\\n                        url: 'hiker://page/Comments?p=fypage',\\\\n                        col_type: 'rich_text',\\\\n                        extra: {\\\\n                            // 评论id来源都不一样\\\\n                            id: list.orig.id_str,\\\\n                            // 纯文字\\\\n                            type: 17\\\\n                        }\\\\n                    });\\\\n\\\\n                } else if (list.orig.type == 'DYNAMIC_TYPE_DRAW') {\\\\n                    // 引用图片说说\\\\n                    d.push({\\\\n                        title: (list.orig.modules.module_dynamic.desc.text === null ? '<font color=\\\\\\\"grey\\\\\\\">up太懒了，连文案都不想配...</font>' : list.orig.modules.module_dynamic.desc.text).replace(/\\\\\\\\\\\\\\\\n/g, '<br>') + '<br><a href=\\\\\\\"hiker://page/Comments?p=fypage\\\\\\\">查看评论</a>',\\\\n                        col_type: 'rich_text',\\\\n                        url: \\\\\\\"hiker://page/Comments?p=fypage\\\\\\\",\\\\n                        extra: {\\\\n                            id: list.orig.modules.module_dynamic.major.draw.id,\\\\n                            type: 11\\\\n                        }\\\\n                    });\\\\n                    list.orig.modules.module_dynamic.major.draw.items.forEach(item => {\\\\n                        d.push({\\\\n                            img: item.src + \\\\\\\"@Referer=\\\\\\\",\\\\n                            col_type: 'pic_3_square',\\\\n                            url: item.src + \\\\\\\"@Referer=\\\\\\\",\\\\n                        });\\\\n                    });\\\\n                } else {\\\\n                    log('可能还有未适配的说说类型');\\\\n                }\\\\n                // 分割\\\\n                d.push({\\\\n                    title: '<small><small><font color=\\\\\\\"grey\\\\\\\">留言:' + list.modules.module_stat.comment.count + '\\\\\\\\t\\\\\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\\\\\t\\\\\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\\\n                    col_type: 'rich_text'\\\\n                }, {\\\\n                    col_type: 'line_blank'\\\\n                });\\\\n            } else if (list.type == 'DYNAMIC_TYPE_WORD') {\\\\n                // 纯文字\\\\n                d.push({\\\\n                    title: list.modules.module_author.name + '\\\\\\\\t\\\\\\\\t\\\\\\\\t<small><small><font color=\\\\\\\"grey\\\\\\\">' + list.modules.module_author.pub_time + '</font></small></small>',\\\\n                    img: list.modules.module_author.face + \\\\\\\"@Referer=\\\\\\\",\\\\n                    url: 'hiker://page/upHome',\\\\n                    col_type: 'avatar',\\\\n                    extra: {\\\\n                        mid: list.modules.module_author.mid,\\\\n                        title: list.modules.module_author.name,\\\\n                        face: list.modules.module_author.face\\\\n                    }\\\\n                }, {\\\\n                    col_type: 'line'\\\\n                }, {\\\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\\\\\"grey\\\\\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text).replace(/\\\\\\\\\\\\\\\\n/g, '<br>') + '<br><a href=\\\\\\\"hiker://page/Comments?p=fypage\\\\\\\">查看评论</a>',\\\\n                    url: 'hiker://page/Comments?p=fypage',\\\\n                    col_type: 'rich_text',\\\\n                    extra: {\\\\n                        id: list.basic.comment_id_str,\\\\n                        // 纯文字\\\\n                        type: 17\\\\n                    }\\\\n                }, {\\\\n                    title: '<small><small><font color=\\\\\\\"grey\\\\\\\">留言:' + list.modules.module_stat.comment.count + '\\\\\\\\t\\\\\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\\\\\t\\\\\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\\\n                    col_type: 'rich_text'\\\\n                }, {\\\\n                    col_type: 'line_blank'\\\\n                });\\\\n            } else if (list.type == 'DYNAMIC_TYPE_DRAW') {\\\\n                // 图片说说\\\\n                d.push({\\\\n                    title: list.modules.module_author.name + '\\\\\\\\t\\\\\\\\t\\\\\\\\t<small><small><font color=\\\\\\\"grey\\\\\\\">' + list.modules.module_author.pub_time + '</font></small></small>',\\\\n                    img: list.modules.module_author.face + \\\\\\\"@Referer=\\\\\\\",\\\\n                    url: 'hiker://page/upHome',\\\\n                    col_type: 'avatar',\\\\n                    extra: {\\\\n                        mid: list.modules.module_author.mid,\\\\n                        title: list.modules.module_author.name,\\\\n                        face: list.modules.module_author.face\\\\n                    }\\\\n                }, {\\\\n                    col_type: 'line'\\\\n                }, {\\\\n                    title: (list.modules.module_dynamic.desc === null ? '<font color=\\\\\\\"grey\\\\\\\">up太懒了，连文案都不想配...</font>' : list.modules.module_dynamic.desc.text).replace(/\\\\\\\\\\\\\\\\n/g, '<br>') + '<br><a href=\\\\\\\"hiker://page/Comments?p=fypage\\\\\\\">查看评论</a>',\\\\n                    url: 'hiker://page/Comments?p=fypage',\\\\n                    col_type: 'rich_text',\\\\n                    extra: {\\\\n                        id: list.basic.comment_id_str,\\\\n                        // 相簿（图片动态）\\\\n                        type: 11\\\\n                    }\\\\n                });\\\\n                list.modules.module_dynamic.major.draw.items.forEach(item => {\\\\n                    d.push({\\\\n                        img: item.src + \\\\\\\"@Referer=\\\\\\\",\\\\n                        col_type: 'pic_3_square',\\\\n                        url: item.src + \\\\\\\"@Referer=\\\\\\\",\\\\n                    });\\\\n                });\\\\n                d.push({\\\\n                    title: '<small><small><font color=\\\\\\\"grey\\\\\\\">留言:' + list.modules.module_stat.comment.count + '\\\\\\\\t\\\\\\\\t分享:' + list.modules.module_stat.forward.count + '\\\\\\\\t\\\\\\\\t喜欢:' + list.modules.module_stat.like.count + '</font></small></small>',\\\\n                    col_type: 'rich_text'\\\\n                }, {\\\\n                    col_type: 'line_blank'\\\\n                });\\\\n            }\\\\n        });\\\\n    })\\\\n}\\\\n// 时间转换函数\\\\n$.exports.timeConvert = function (time) {\\\\n    function formatDate(e, t) {\\\\n        e = new Date(e * 1000); //时间戳为10位需*1000，时间戳为13位的话不需乘1000\\\\n        return t.replace(/yyyy|YYYY/, e.getFullYear())\\\\n            .replace(/yy|YY/, r(e.getFullYear() % 100, 2))\\\\n            .replace(/mm|MM/, r(e.getMonth() + 1, 2))\\\\n            .replace(/m|M/g, e.getMonth() + 1)\\\\n            .replace(/dd|DD/, r(e.getDate(), 2))\\\\n            .replace(/d|D/g, e.getDate())\\\\n            .replace(/hh|HH/, r(e.getHours(), 2))\\\\n            .replace(/h|H/g, e.getHours())\\\\n            .replace(/ii|II/, r(e.getMinutes(), 2))\\\\n            .replace(/i|I/g, e.getMinutes())\\\\n            .replace(/ss|SS/, r(e.getSeconds(), 2))\\\\n            .replace(/s|S/g, e.getSeconds())\\\\n            .replace(/w/g, e.getDay())\\\\n            .replace(/W/g, [\\\\\\\"日\\\\\\\", \\\\\\\"一\\\\\\\", \\\\\\\"二\\\\\\\", \\\\\\\"三\\\\\\\", \\\\\\\"四\\\\\\\", \\\\\\\"五\\\\\\\", \\\\\\\"六\\\\\\\"][e.getDay()])\\\\n    }\\\\n\\\\n    function r(e, t) {\\\\n        for (var r = 0, n = t - (e + \\\\\\\"\\\\\\\").length; r < n; r++) e = \\\\\\\"0\\\\\\\" + e;\\\\n        return e + \\\\\\\"\\\\\\\"\\\\n    }\\\\n    return formatDate(time, 'YYYY-MM-DD hh:ii:ss');\\\\n    // console.log(formatDate(1664089532, 'YYYY-MM-DD hh:ii:ss'));\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"videoPage\\\",\\\"path\\\":\\\"video\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nvar d = [];\\\\n\\\\n// 预处理\\\\n\\\\nputMyVar('功能折叠', '关');\\\\n\\\\nimgLink=storage0.getMyVar('图标');\\\\n\\\\naid = MY_PARAMS.aid + \\\\\\\"\\\\\\\";\\\\n\\\\nmid = MY_PARAMS.mid + \\\\\\\"\\\\\\\";\\\\n\\\\ntry {\\\\n\\\\n    //获取视频分P信息\\\\n\\\\n    var p = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/view?aid=\\\\\\\" + aid)).data;\\\\n\\\\n    hasLike=$.require(\\\\\\\"hiker://page/api\\\\\\\").hasLike(aid);\\\\n\\\\n    hasFavour=$.require(\\\\\\\"hiker://page/api\\\\\\\").hasFavour(aid);\\\\n\\\\n    if (p.pages.length == 1) {\\\\n\\\\n        cid = p.pages[0].cid;\\\\n\\\\n        d.push({\\\\n\\\\n            title: p.title,\\\\n\\\\n            img: p.pic + '@Referer=',\\\\n\\\\n            url: $().lazyRule((aid, cid, qn) => {\\\\n\\\\n                // 真离了个大谱，明明替换掉了，ua字符串又变回来了，又要处理一次\\\\n\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").biliLazy(aid, cid, qn).replace(/;/g, \\\\\\\"；；\\\\\\\");\\\\n\\\\n            }, aid + \\\\\\\"\\\\\\\", cid + \\\\\\\"\\\\\\\", '112'),\\\\n\\\\n            col_type: \\\\\\\"pic_1\\\\\\\"\\\\n\\\\n        });\\\\n\\\\n        d.push({\\\\n\\\\n            title: '<font color=\\\\\\\"blue\\\\\\\">' + p.owner.name + '</font>',\\\\n\\\\n            url: \\\\\\\"hiker://page/upHome\\\\\\\",\\\\n\\\\n            img: p.owner.face + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: \\\\\\\"avatar\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                mid: p.owner.mid,\\\\n\\\\n                title: p.owner.name,\\\\n\\\\n                face: p.owner.face\\\\n\\\\n            }\\\\n\\\\n        },{\\\\n\\\\n            col_type: 'line'\\\\n\\\\n        },{\\\\n\\\\n            title: p.stat.like,\\\\n\\\\n            img: hasLike==1?imgLink.已点赞:imgLink.未点赞,\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\\\n\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").likeLogic(aid)\\\\n\\\\n            }, aid),\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n            extra:{\\\\n\\\\n                id:'setLike'\\\\n\\\\n            }\\\\n\\\\n        },{\\\\n\\\\n            title:  p.stat.favorite,\\\\n\\\\n            img: hasFavour?imgLink.已收藏:imgLink.未收藏,\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\\\n\\\\n                upMid=JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).userMid;\\\\n\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").favourLogic(aid,upMid)\\\\n\\\\n            }, aid),\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n            extra:{\\\\n\\\\n                id:'setFavour'\\\\n\\\\n            }\\\\n\\\\n        },{\\\\n\\\\n            title: '稍后再看',\\\\n\\\\n            img: imgLink.稍后再看,\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\\\n\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").judgeToview(aid)\\\\n\\\\n            }, aid),\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n        }, {\\\\n\\\\n            title: '查看评论',\\\\n\\\\n            url: 'hiker://page/Comments?p=fypage',\\\\n\\\\n            img: imgLink.查看评论,\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                \\\\\\\"id\\\\\\\": aid,\\\\n\\\\n                \\\\\\\"type\\\\\\\":1\\\\n\\\\n            }\\\\n\\\\n        },{\\\\n\\\\n            col_type: 'line_blank'\\\\n\\\\n        },{\\\\n\\\\n            title: p.desc,\\\\n\\\\n            col_type: \\\\\\\"long_text\\\\\\\",\\\\n\\\\n        });\\\\n\\\\n    } else {\\\\n\\\\n        d.push({\\\\n\\\\n            title: p.title,\\\\n\\\\n            img:p.pic + '@Referer=',\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((p) => {\\\\n\\\\n                return $('hiker://empty?fypage').rule((p) => {\\\\n\\\\n                    d = [];\\\\n\\\\n                    d.push({\\\\n\\\\n                        title: p.desc,\\\\n\\\\n                        col_type: \\\\\\\"long_text\\\\\\\",\\\\n\\\\n                    })\\\\n\\\\n                    setResult(d);\\\\n\\\\n                }, p)\\\\n\\\\n            }, p),\\\\n\\\\n            col_type: \\\\\\\"pic_1\\\\\\\"\\\\n\\\\n        },{\\\\n\\\\n            title: '<font color=\\\\\\\"blue\\\\\\\">' + p.owner.name + '</font>',\\\\n\\\\n            url: \\\\\\\"hiker://page/upHome\\\\\\\",\\\\n\\\\n            img: p.owner.face + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: \\\\\\\"avatar\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                mid: p.owner.mid,\\\\n\\\\n                title: p.owner.name,\\\\n\\\\n                face: p.owner.face\\\\n\\\\n            }\\\\n\\\\n        },{\\\\n\\\\n            col_type: 'line'\\\\n\\\\n        },{\\\\n\\\\n            title: p.stat.like,\\\\n\\\\n            img: hasLike==1?imgLink.已点赞:imgLink.未点赞,\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\\\n\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").likeLogic(aid)\\\\n\\\\n            }, aid),\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n            extra:{\\\\n\\\\n                id:'setLike'\\\\n\\\\n            }\\\\n\\\\n        },{\\\\n\\\\n            title: p.stat.favorite,\\\\n\\\\n            img: hasFavour?imgLink.已收藏:imgLink.未收藏,\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\\\n\\\\n                upMid=JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).userMid;\\\\n\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").favourLogic(aid,upMid)\\\\n\\\\n            }, aid),\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n            extra:{\\\\n\\\\n                id:'setFavour'\\\\n\\\\n            }\\\\n\\\\n        },{\\\\n\\\\n            title: '稍后再看',\\\\n\\\\n            img: imgLink.稍后再看,\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((aid) => {\\\\n\\\\n                return $.require(\\\\\\\"hiker://page/api\\\\\\\").judgeToview(aid)\\\\n\\\\n            }, aid),\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n        }, {\\\\n\\\\n            title: '查看评论',\\\\n\\\\n            url: 'hiker://page/Comments?p=fypage',\\\\n\\\\n            img: imgLink.查看评论,\\\\n\\\\n            col_type: \\\\\\\"icon_small_4\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                \\\\\\\"id\\\\\\\": aid,\\\\n\\\\n                \\\\\\\"type\\\\\\\":1\\\\n\\\\n            }\\\\n\\\\n        })\\\\n\\\\n        d.push({\\\\n\\\\n            col_type: 'line_blank'\\\\n\\\\n        },{\\\\n\\\\n            title: '选集列表\\\\\\\\t\\\\\\\\t\\\\\\\\t<small><small>共'+p.videos+'条视频</small></small>',\\\\n\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n            img: imgLink.列表,\\\\n\\\\n            col_type: \\\\\\\"avatar\\\\\\\",\\\\n\\\\n        },{\\\\n\\\\n            col_type: 'line'\\\\n\\\\n        });\\\\n\\\\n        p.pages.forEach(item => {\\\\n\\\\n            cid = item.cid;\\\\n\\\\n            d.push({\\\\n\\\\n                title: item.part,\\\\n\\\\n                url: $().lazyRule((aid, cid, qn) => {\\\\n\\\\n                    return $.require(\\\\\\\"hiker://page/api\\\\\\\").biliLazy(aid, cid, qn).replace(/;/g, \\\\\\\"；；\\\\\\\");\\\\n\\\\n                }, aid + \\\\\\\"\\\\\\\", cid + \\\\\\\"\\\\\\\", '112'),\\\\n\\\\n                col_type: \\\\\\\"text_1\\\\\\\"\\\\n\\\\n            })\\\\n\\\\n        })\\\\n\\\\n    }\\\\n\\\\n} catch (e) {\\\\n\\\\n    d.push({\\\\n\\\\n        title: '页面走丢了...',\\\\n\\\\n        img: 'https://i0.hdslb.com/bfs/general/f7b667011a46615732c701f4bb1d07f793f8d1df.png@Referer=',\\\\n\\\\n        url: 'hiker://empty',\\\\n\\\\n        desc: '大概率视频被封禁，或者up已跑路~',\\\\n\\\\n        col_type: \\\\\\\"pic_1\\\\\\\"\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\nsetResult(d);\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"long_text\\\",\\\"name\\\":\\\"评论\\\",\\\"path\\\":\\\"Comments\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nvar d = [];\\\\n\\\\nvar id = MY_PARAMS.id;\\\\n\\\\nvar type = MY_PARAMS.type;\\\\n\\\\nlog(id);\\\\n\\\\nif (MY_PAGE == 1) {\\\\n\\\\n    // 貌似暂时只能文字+数字\\\\n\\\\n    d.unshift({\\\\n\\\\n        title: \\\\\\\"发条评论吧\\\\\\\",\\\\n\\\\n        col_type: \\\\\\\"input\\\\\\\",\\\\n\\\\n        url: $.toString((id,type) => {\\\\n\\\\n            let csrf = JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie.match(/bili_jct=(.*?);/)[1];\\\\n\\\\n            post(\\\\\\\"http://api.bilibili.com/x/v2/reply/add\\\\\\\", {\\\\n\\\\n                body: {\\\\n\\\\n                    \\\\\\\"type\\\\\\\": type,\\\\n\\\\n                    \\\\\\\"oid\\\\\\\": id,\\\\n\\\\n                    \\\\\\\"csrf\\\\\\\": csrf,\\\\n\\\\n                    \\\\\\\"message\\\\\\\": input\\\\n\\\\n                },\\\\n\\\\n                headers: {\\\\n\\\\n                    \\\\\\\"Cookie\\\\\\\": JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n\\\\n                }\\\\n\\\\n            })\\\\n\\\\n            refreshPage()\\\\n\\\\n        }, id,type)\\\\n\\\\n    })\\\\n\\\\n}\\\\n\\\\nlet data = $.require(\\\\\\\"hiker://page/api\\\\\\\").getComments(id,type,MY_PAGE)\\\\n\\\\ndata.forEach(item => {\\\\n\\\\n    d.push({\\\\n\\\\n        title: item.member.uname+'\\\\\\\\t\\\\\\\\t\\\\\\\\t<small><small><font color=\\\\\\\"grey\\\\\\\">'+item.reply_control.location + \\\\\\\" \\\\\\\" + item.reply_control.time_desc+'</font></small></small>',\\\\n\\\\n        img: item.member.avatar+'@Referer=',\\\\n\\\\n        url:'hiker://page/upHome',\\\\n\\\\n        col_type: \\\\\\\"avatar\\\\\\\",\\\\n\\\\n        extra: {\\\\n\\\\n            mid: item.member.mid,\\\\n\\\\n            title: item.member.uname,\\\\n\\\\n            face: item.member.avatar\\\\n\\\\n        }\\\\n\\\\n    })\\\\n\\\\n    d.push({\\\\n\\\\n        title: item.content.message,\\\\n\\\\n    })\\\\n\\\\n})\\\\n\\\\nsetResult(d);\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"订阅列表\\\",\\\"path\\\":\\\"subscription\\\",\\\"rule\\\":\\\"if (getItem('订阅类型', '1') == '1') {\\\\n\\\\n    typerName = '追番';\\\\n\\\\n} else {\\\\n\\\\n    typerName = '追剧';\\\\n\\\\n}\\\\n\\\\nd.push({\\\\n\\\\n    title: '追番' == typerName ? '‘‘’’<font color=\\\\\\\"red\\\\\\\">追番</font>' : '追番',\\\\n\\\\n    url: $('#noLoading##noHistory#').lazyRule(() => {\\\\n\\\\n        setItem('订阅类型', '1')\\\\n\\\\n        refreshPage(true);\\\\n\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n    }),\\\\n\\\\n    col_type: 'scroll_button'\\\\n\\\\n},{\\\\n\\\\n    title: '追剧' == typerName ? '‘‘’’<font color=\\\\\\\"red\\\\\\\">追剧</font>' : '追剧',\\\\n\\\\n    url: $('#noLoading##noHistory#').lazyRule(() => {\\\\n\\\\n        setItem('订阅类型', '2')\\\\n\\\\n        refreshPage(true);\\\\n\\\\n        return \\\\\\\"hiker://empty\\\\\\\";\\\\n\\\\n    }),\\\\n\\\\n    col_type: 'scroll_button'\\\\n\\\\n});\\\\n\\\\nsubscriptions = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/space/bangumi/follow/list?type=\\\\\\\" + getItem('订阅类型', '1') + \\\\\\\"&follow_status=0&pn=\\\\\\\" + page + \\\\\\\"&ps=15&vmid=\\\\\\\" + mid, {\\\\n\\\\n    headers: {\\\\n\\\\n        \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n    }\\\\n\\\\n})).data;\\\\n\\\\nif (page == 1) {\\\\n\\\\n    d.push({\\\\n\\\\n        title: \\\\\\\"当前\\\\\\\" + typerName + \\\\\\\"数量:\\\\\\\" + subscriptions.total,\\\\n\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\"\\\\n\\\\n    })\\\\n\\\\n}\\\\n\\\\nsubscriptions.list.forEach(list => {\\\\n\\\\n    d.push({\\\\n\\\\n        title: list.title,\\\\n\\\\n        img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n        url: \\\\\\\"hiker://page/filmerji#immersiveTheme#\\\\\\\",\\\\n\\\\n        desc: list.evaluate.substring(0, 12) + '‘‘’’…<font color=\\\\\\\"#1C1C1C\\\\\\\">详情</font>' + '\\\\\\\\n' + list.season_type_name + '|' + (list.areas===undefined?'':list.areas[0].name + '\\\\\\\\n') + (list.progress == '' ? '尚未观看' : list.progress) + (list.new_ep.index_show===undefined?'':'|'+(list.new_ep.index_show.match(/更新|即将/) ? '‘‘’’<font color=\\\\\\\"red\\\\\\\">' + list.new_ep.index_show + '</font>': list.new_ep.index_show)),\\\\n\\\\n        col_type: 'movie_1_vertical_pic',\\\\n\\\\n        extra: {\\\\n\\\\n            season_id: list.season_id\\\\n\\\\n        }\\\\n\\\\n    });\\\\n\\\\n});\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"关注列表\\\",\\\"path\\\":\\\"attention\\\",\\\"rule\\\":\\\"if (MY_PAGE == 1) {\\\\n\\\\n    focusGroups=$.require(\\\\\\\"hiker://page/api\\\\\\\").getMyAttentionGroupList();\\\\n\\\\n    putMyVar('tempId', JSON.stringify(focusGroups[1].tagid));\\\\n\\\\n    focusGroups.forEach(list => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: list.tagid == getItem('关注分组', JSON.stringify(focusGroups[1].id)) ? \\\\\\\"““””<font color='red'>\\\\\\\" + list.name + list.count + \\\\\\\"</font>\\\\\\\" : list.name + list.count,\\\\n\\\\n            url: $('#noLoading##noHistory#').lazyRule((list) => {\\\\n\\\\n                setItem('关注分组', JSON.stringify(list.tagid));\\\\n\\\\n                refreshPage(true);\\\\n\\\\n                return \\\\\\\"toast://切换关注分组为:\\\\\\\" + list.name;\\\\n\\\\n            }, list),\\\\n\\\\n            col_type: 'scroll_button',\\\\n\\\\n        });\\\\n\\\\n    });\\\\n\\\\n    // 末尾补充悄悄关注分组\\\\n\\\\n    d.push({\\\\n\\\\n        title: '悄悄关注' == getItem('关注分组', JSON.stringify(focusGroups[0].id)) ? \\\\\\\"““””<font color='red'>悄悄关注</font>\\\\\\\" : \\\\\\\"悄悄关注\\\\\\\",\\\\n\\\\n        url: $('#noLoading##noHistory#').lazyRule(() => {\\\\n\\\\n            setItem('关注分组', \\\\\\\"悄悄关注\\\\\\\");\\\\n\\\\n            refreshPage(true);\\\\n\\\\n            return \\\\\\\"toast://切换关注分组为:\\\\\\\" + \\\\\\\"悄悄关注\\\\\\\";\\\\n\\\\n        }),\\\\n\\\\n        col_type: 'scroll_button',\\\\n\\\\n    },{\\\\n\\\\n        col_type: 'line'\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\nif (getItem('关注分组')=='悄悄关注') {\\\\n\\\\n    groupContent = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/relation/whispers?pn=\\\\\\\"+page+\\\\\\\"&ps=20&jsonp=jsonp\\\\\\\", {\\\\n\\\\n        headers: {\\\\n\\\\n            \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n        }\\\\n\\\\n    })).data.list;\\\\n\\\\n    groupContent.forEach(list => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: \\\\\\\"<big><font color='blue'>\\\\\\\" + list.uname + \\\\\\\"</font></big><small>\\\\\\\" + list.sign + \\\\\\\"</small>\\\\\\\",\\\\n\\\\n            img: list.face + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: 'avatar',\\\\n\\\\n            url: \\\\\\\"hiker://page/upHome\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                mid: list.mid,\\\\n\\\\n                title: list.uname,\\\\n\\\\n                face: list.face\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    });\\\\n\\\\n}else{\\\\n\\\\n    groupContent = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/relation/tag?mid=\\\\\\\" + mid + \\\\\\\"&tagid=\\\\\\\" + getItem('关注分组', getMyVar('tempId')) + \\\\\\\"&pn=\\\\\\\" + page + \\\\\\\"&ps=20&jsonp=jsonp\\\\\\\", {\\\\n\\\\n        headers: {\\\\n\\\\n            \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n        }\\\\n\\\\n    })).data;\\\\n\\\\n    groupContent.forEach(list => {\\\\n\\\\n        d.push({\\\\n\\\\n            title: \\\\\\\"<big><font color='blue'>\\\\\\\" + list.uname + \\\\\\\"</font></big><small>\\\\\\\" + list.sign + \\\\\\\"</small>\\\\\\\",\\\\n\\\\n            img: list.face + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: 'avatar',\\\\n\\\\n            url: \\\\\\\"hiker://page/upHome\\\\\\\",\\\\n\\\\n            extra: {\\\\n\\\\n                mid: list.mid,\\\\n\\\\n                title: list.uname,\\\\n\\\\n                face: list.face\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    });\\\\n\\\\n}\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"收藏列表\\\",\\\"path\\\":\\\"colection\\\",\\\"rule\\\":\\\"if (page == 1) {\\\\r\\\\n    d.push({\\\\r\\\\n        title: '我创建的收藏夹' == getItem('收藏类型', '我创建的收藏夹') ? '‘‘’’<font color=\\\\\\\"red\\\\\\\">我创建的收藏夹</font>' : '我创建的收藏夹',\\\\r\\\\n        url: $('#noLoading##noHistory#').lazyRule(() => {\\\\r\\\\n            setItem('收藏类型', '我创建的收藏夹')\\\\r\\\\n            refreshPage(true);\\\\r\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\r\\\\n        }),\\\\r\\\\n        col_type: 'scroll_button'\\\\r\\\\n    }, {\\\\r\\\\n        title: '稍后在看' == getItem('收藏类型', '我创建的收藏夹') ? '‘‘’’<font color=\\\\\\\"red\\\\\\\">稍后在看</font>' : '稍后在看',\\\\r\\\\n        url: $('#noLoading##noHistory#').lazyRule(() => {\\\\r\\\\n            setItem('收藏类型', '稍后在看')\\\\r\\\\n            refreshPage(true);\\\\r\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\r\\\\n        }),\\\\r\\\\n        col_type: 'scroll_button'\\\\r\\\\n    });\\\\r\\\\n}\\\\r\\\\nif (getItem('收藏类型', '我创建的收藏夹') == '我创建的收藏夹') {\\\\r\\\\n    try {\\\\r\\\\n        if (page == 1) {\\\\r\\\\n            d.push({\\\\r\\\\n                // col_type: 'blank_block'\\\\r\\\\n                col_type: 'line'\\\\r\\\\n            }, );\\\\r\\\\n        }\\\\r\\\\n        collections = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/v3/fav/folder/list4navigate\\\\\\\", {\\\\r\\\\n            headers: {\\\\r\\\\n                \\\\\\\"Cookie\\\\\\\": cookie\\\\r\\\\n            }\\\\r\\\\n        })).data;\\\\r\\\\n        groups = collections[0].mediaListResponse.list;\\\\r\\\\n        putMyVar('tempId', JSON.stringify(groups[0].id));\\\\r\\\\n        groups.forEach(list => {\\\\r\\\\n            d.push({\\\\r\\\\n                title: list.id == getItem('收藏夹', JSON.stringify(groups[0].id)) ? \\\\\\\"““””<font color='red'>\\\\\\\" + list.title + \\\\\\\"</font>\\\\\\\" : list.title,\\\\r\\\\n                url: $('#noLoading##noHistory#').lazyRule((list) => {\\\\r\\\\n                    setItem('收藏夹', JSON.stringify(list.id));\\\\r\\\\n                    refreshPage(true);\\\\r\\\\n                    return \\\\\\\"toast://切换收藏夹为:\\\\\\\" + list.title;\\\\r\\\\n                }, list),\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n            });\\\\r\\\\n        });\\\\r\\\\n        d.push({\\\\r\\\\n            col_type: 'line'\\\\r\\\\n        });\\\\r\\\\n        groupContent = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/v3/fav/resource/list?media_id=\\\\\\\" + getItem('收藏夹', getMyVar('tempId')) + \\\\\\\"&pn=\\\\\\\" + page + \\\\\\\"&ps=20&keyword=&order=mtime&type=0&tid=0&platform=web&jsonp=jsonp\\\\\\\", {\\\\r\\\\n            headers: {\\\\r\\\\n                \\\\\\\"Cookie\\\\\\\": cookie\\\\r\\\\n            }\\\\r\\\\n        })).data.medias;\\\\r\\\\n        groupContent.forEach(list => {\\\\r\\\\n            d.push({\\\\r\\\\n                title: list.title,\\\\r\\\\n                img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\r\\\\n                col_type: 'movie_1_left_pic',\\\\r\\\\n                url: \\\\\\\"hiker://page/video\\\\\\\",\\\\r\\\\n                desc: 'UP:' + list.upper.name + '\\\\\\\\n' + list.intro,\\\\r\\\\n                extra: {\\\\r\\\\n                    aid: list.id,\\\\r\\\\n                    mid: list.upper.mid\\\\r\\\\n                }\\\\r\\\\n            });\\\\r\\\\n        });\\\\r\\\\n    } catch (e) {\\\\r\\\\n        showLoading('兄弟，你确认你有收藏吗，快去收藏一个视频~');\\\\r\\\\n    }\\\\r\\\\n} else {\\\\r\\\\n    laterViews = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/v2/history/toview/web?jsonp=jsonp\\\\\\\", {\\\\r\\\\n        headers: {\\\\r\\\\n            \\\\\\\"Cookie\\\\\\\": cookie\\\\r\\\\n        }\\\\r\\\\n    })).data;\\\\r\\\\n    count = laterViews.count;\\\\r\\\\n    d.push({\\\\r\\\\n        title: \\\\\\\"共有\\\\\\\" + count + \\\\\\\"条待看视频记录\\\\\\\",\\\\r\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\r\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\"\\\\r\\\\n    });\\\\r\\\\n    laterViews.list.forEach(list => {\\\\r\\\\n        d.push({\\\\r\\\\n            title: list.title,\\\\r\\\\n            img: list.pic + \\\\\\\"@Referer=\\\\\\\",\\\\r\\\\n            col_type: 'movie_1_left_pic',\\\\r\\\\n            url: \\\\\\\"hiker://page/video\\\\\\\",\\\\r\\\\n            desc: 'UP:' + list.owner.name + '\\\\\\\\n' + list.desc,\\\\r\\\\n            extra: {\\\\r\\\\n                aid: list.aid,\\\\r\\\\n                mid: list.owner.mid\\\\r\\\\n            }\\\\r\\\\n        });\\\\r\\\\n    });\\\\r\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"足迹\\\",\\\"path\\\":\\\"track\\\",\\\"rule\\\":\\\"var nextInfo = {};\\\\n\\\\nif (page == 1) {\\\\n\\\\n    histories = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=0&view_at=0&business=\\\\\\\", {\\\\n\\\\n        headers: {\\\\n\\\\n            \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n        }\\\\n\\\\n    })).data;\\\\n\\\\n    nextInfo.max = histories.cursor.max;\\\\n\\\\n    nextInfo.view_at = histories.cursor.view_at;\\\\n\\\\n    nextInfo.business = histories.cursor.business;\\\\n\\\\n} else {\\\\n\\\\n    histories = JSON.parse(fetch(\\\\\\\"https://api.bilibili.com/x/web-interface/history/cursor?max=\\\\\\\" + storage0.getMyVar(JSON.stringify(page)).max + \\\\\\\"&view_at=\\\\\\\" + storage0.getMyVar(JSON.stringify(page)).view_at + \\\\\\\"&business=\\\\\\\" + storage0.getMyVar(JSON.stringify(page)).business, {\\\\n\\\\n        headers: {\\\\n\\\\n            \\\\\\\"Cookie\\\\\\\": cookie\\\\n\\\\n        }\\\\n\\\\n    })).data;\\\\n\\\\n    nextInfo.max = histories.cursor.max;\\\\n\\\\n    nextInfo.view_at = histories.cursor.view_at;\\\\n\\\\n    nextInfo.business = histories.cursor.business;\\\\n\\\\n}\\\\n\\\\nstorage0.putMyVar(JSON.stringify(page + 1), nextInfo);\\\\n\\\\nhistories.list.forEach(list => {\\\\n\\\\n    viewTime=pbtime = $.require(\\\\\\\"hiker://page/api\\\\\\\").timeConvert(list.view_at);\\\\n\\\\n    if (list.history.business == 'article') {\\\\n\\\\n        // 专栏文章\\\\n\\\\n        d.push({\\\\n\\\\n            title: list.show_title==''?list.title:list.show_title,\\\\n\\\\n            img: list.covers[0] + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: 'movie_1_left_pic',\\\\n\\\\n            url: \\\\\\\"hiker://page/articleDetail\\\\\\\",\\\\n\\\\n            desc: (list.author_name==''?viewTime:'UP:' + list.author_name+'\\\\\\\\n' )+ viewTime,\\\\n\\\\n            extra: {\\\\n\\\\n                id: list.history.oid,\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    } else if(list.history.business == 'article-list'){\\\\n\\\\n        // 文章列表？（反正id存放位置不一样）\\\\n\\\\n        d.push({\\\\n\\\\n            title: list.show_title==''?list.title:list.show_title,\\\\n\\\\n            img: list.covers[0] + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: 'movie_1_left_pic',\\\\n\\\\n            url: \\\\\\\"hiker://page/articleDetail\\\\\\\",\\\\n\\\\n            desc: (list.author_name==''?viewTime:'UP:' + list.author_name+'\\\\\\\\n' )+ viewTime,\\\\n\\\\n            extra: {\\\\n\\\\n                id: list.history.cid,\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    }else if(list.history.business == 'pgc'){\\\\n\\\\n        // 系列剧集（单集）\\\\n\\\\n        d.push({\\\\n\\\\n            title: list.show_title==''?list.title:list.show_title,\\\\n\\\\n            img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: 'movie_1_left_pic',\\\\n\\\\n            url: \\\\\\\"hiker://page/filmerji#immersiveTheme#\\\\\\\",\\\\n\\\\n            desc: (list.author_name==''?list.tag_name+'\\\\\\\\t\\\\\\\\t'+list.new_desc+'\\\\\\\\n'+viewTime:'UP:' + list.author_name+'\\\\\\\\n'+viewTime),\\\\n\\\\n            extra: {\\\\n\\\\n                ep_id:list.history.epid\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    }else {\\\\n\\\\n        // 普通video\\\\n\\\\n        d.push({\\\\n\\\\n            title: list.show_title==''?list.title:list.show_title,\\\\n\\\\n            img: list.cover + \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n            col_type: 'movie_1_left_pic',\\\\n\\\\n            url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n            desc: (list.author_name==''?list.tag_name+'\\\\\\\\t\\\\\\\\t'+list.new_desc+'\\\\\\\\n'+viewTime:'UP:' + list.author_name+'\\\\\\\\n'+viewTime),\\\\n\\\\n            extra: {\\\\n\\\\n                aid: list.history.oid,\\\\n\\\\n            }\\\\n\\\\n        });\\\\n\\\\n    }\\\\n\\\\n});\\\\n\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"动态\\\",\\\"path\\\":\\\"latetNews\\\",\\\"rule\\\":\\\"d.push({\\\\n\\\\n    col_type: 'line_blank'\\\\n\\\\n});\\\\n\\\\nlatenews=$.require(\\\\\\\"hiker://page/api\\\\\\\").getDynamicData('myHome');\\\\n\\\\neval($.require(\\\\\\\"hiker://page/api\\\\\\\").showDynamicData());\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"专栏列表\\\",\\\"path\\\":\\\"acticleList\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nvar d=[];\\\\n\\\\npage=MY_PAGE;\\\\n\\\\nupMid = MY_PARAMS.mid + \\\\\\\"\\\\\\\";\\\\n\\\\narticleList=$.require(\\\\\\\"hiker://page/api\\\\\\\").getUserArticle(upMid,page);\\\\n\\\\narticleNum=articleList.count;\\\\n\\\\nif (articleNum==undefined) {\\\\n\\\\n    d.push({\\\\n\\\\n        title: '这up没有专栏文章',\\\\n\\\\n        url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n\\\\n    });\\\\n\\\\n}else{\\\\n\\\\n    maxPage = Math.ceil(articleNum / articleList.ps);\\\\n\\\\n    if (page <= maxPage) {\\\\n\\\\n        d.push({\\\\n\\\\n            title: '当前:第' + articleList.pn + '页\\\\\\\\t\\\\\\\\t\\\\\\\\t共有' + maxPage + '页,' + articleNum + '条数据',\\\\n\\\\n            url: \\\\\\\"hiker://empty\\\\\\\",\\\\n\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n\\\\n        });\\\\n\\\\n        articleList.articles.forEach(list => {\\\\n\\\\n            pbtime=$.require(\\\\\\\"hiker://page/api\\\\\\\").timeConvert(list.publish_time);\\\\n\\\\n            d.push({\\\\n\\\\n                title: list.title,\\\\n\\\\n                img: list.banner_url==''? (list.image_urls+ '@Referer='):(list.banner_url+ '@Referer='),\\\\n\\\\n                desc: '‘‘’’<small>'+list.stats.view+'看过\\\\\\\\t\\\\\\\\t'+list.stats.like+'喜欢\\\\\\\\t\\\\\\\\t'+list.stats.favorite+'收藏\\\\\\\\n' + pbtime+'</small>',\\\\n\\\\n                col_type: 'movie_1_left_pic',\\\\n\\\\n                url: \\\\\\\"hiker://page/articleDetail\\\\\\\",\\\\n\\\\n                extra: {\\\\n\\\\n                    // 专栏文章id\\\\n\\\\n                    id: list.id\\\\n\\\\n                }\\\\n\\\\n            });\\\\n\\\\n        });\\\\n\\\\n    }\\\\n\\\\n}\\\\n\\\\nsetResult(d);\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"专栏文章X5\\\",\\\"path\\\":\\\"articleDetail\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nvar d = [];\\\\n\\\\npage = MY_PAGE;\\\\n\\\\ncvid = MY_PARAMS.id + \\\\\\\"\\\\\\\";\\\\n\\\\nd.push({\\\\n\\\\n    url: \\\\\\\"https://www.bilibili.com/read/cv\\\\\\\"+cvid,\\\\n\\\\n    col_type: \\\\\\\"x5_webview_single\\\\\\\",\\\\n\\\\n    desc: \\\\\\\"100%&&float\\\\\\\",\\\\n\\\\n    extra: {\\\\n\\\\n        canBack: true\\\\n\\\\n    }\\\\n\\\\n})\\\\n\\\\nsetResult(d);\\\\n\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"综合热门\\\",\\\"path\\\":\\\"hotVideo\\\",\\\"rule\\\":\\\"let res = JSON.parse(request(\\\\\\\"https://api.bilibili.com/x/web-interface/popular?pn=\\\\\\\" + MY_PAGE, {\\\\n\\\\n    headers: {\\\\n\\\\n        Cookie: JSON.parse(request(\\\\\\\"hiker://files/rules/cy/bili.txt\\\\\\\")).cookie\\\\n\\\\n    }\\\\n\\\\n})).data\\\\n\\\\nres.list.forEach(item => {\\\\n\\\\n    d.push({\\\\n\\\\n        title: item.title,\\\\n\\\\n        img: item.pic+ \\\\\\\"@Referer=\\\\\\\",\\\\n\\\\n        url: \\\\\\\"hiker://page/video\\\\\\\",\\\\n\\\\n        desc: item.pub_location,\\\\n\\\\n        col_type: \\\\\\\"movie_2\\\\\\\",\\\\n\\\\n        extra: {\\\\n\\\\n            \\\\\\\"aid\\\\\\\": item.aid,\\\\n\\\\n            \\\\\\\"cid\\\\\\\": item.cid,\\\\n\\\\n        }\\\\n\\\\n    })\\\\n\\\\n})\\\\n\\\\n\\\\n\\\"}]\",\"proxy\":\"\"}","picUrl":"http://i0.hdslb.com/bfs/archive/f349ad6dc795ecb00d5e9c0bf5c3679e0d4b46c8.jpg@Referer=","title":"【封茗囧菌】今晚月色，扑朔迷离般《朦胧》"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!