API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：热辣滚烫

xiaomianao666
Apr 23rd, 2024
449
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 462.05 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥热辣滚烫@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"js:\\neval(JSON.parse(request(\\\"hiker://page/main\\\")).rule);\\nlet type = getParam('type', ''),\\n    id = getParam('id', ''),\\n    title = getParam('title', '');\\nlet res = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id);\\nlet update = \\\"\\\";\\nif (title == '') {\\n    let length = res.vendors.length;\\n    update += length > 0 ? '共' + length + '个片源' : '暂无片源';\\n    if (length > 0) {\\n        let e = res.vendors[0];\\n        update += e.episodes_info ? \\\"|\\\" + e.episodes_info : \\\"\\\";\\n    }\\n} else {\\n    for (let e of res.vendors) {\\n        if (e.title == title) {\\n            update += e.episodes_info ? e.episodes_info : \\\"\\\";\\n            break;\\n        }\\n    }\\n}\\nsetResult(update);\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"配置编辑界面\",\"path\":\"setting-editor\",\"rule\":\"js:\\n/**\\n * 通过传入 params 对象生成编辑界面\\n * @param d 视界 setResult 用的列表\\n * @param configKey config 的 key 值，比如我要拿 config.detailsViewConfigs，configKey 就传 \\\"detailsViewConfigs\\\"\\n * @param params 编辑界面的配置\\n *\\n * 【params对象数据示例】\\n * {\\n        key: \\\"input_name\\\",\\n        desc: \\\"请输入名称\\\",\\n        type: 'textarea',\\n        data: {\\n            config: {\\n                key: \\\"input_code\\\",\\n                desc: \\\"请输入输入配置\\\",\\n                type: 'textarea'\\n            },\\n        }\\n    }\\n */\\nfunction modeEditPage(d, configKey, params) {\\n    addListener('onClose', $.toString((params) => {\\n        clearMyVar(params.key)\\n        let datas = params.data;\\n        let dataKeys = Object.keys(datas);\\n        for (let i in dataKeys) {\\n            let dataKey = dataKeys[i]\\n            clearMyVar(datas[dataKey].key)\\n        }\\n    }, params))\\n    d.push({\\n        title: \\\"保存\\\",\\n        desc: params.desc,\\n        col_type: 'input',\\n        extra: {\\n            titleVisible: false,\\n            defaultValue: getMyVar(params.key, \\\"\\\"),\\n            type: params.type ? params.type : '',\\n            onChange: 'putMyVar(\\\"' + params.key + '\\\", input)'\\n        }\\n    })\\n    let datas = params.data;\\n    let dataKeys = Object.keys(datas);\\n    for (let dataKey of dataKeys) {\\n        let data = datas[dataKey]\\n        d.push({\\n            title: \\\"保存\\\",\\n            desc: data.desc,\\n            col_type: 'input',\\n            extra: {\\n                titleVisible: false,\\n                defaultValue: getMyVar(data.key, \\\"\\\"),\\n                type: data.type ? data.type : '',\\n                height: 5,\\n                highlight: true,\\n                onChange: 'putMyVar(\\\"' + data.key + '\\\", input)'\\n            }\\n        })\\n    }\\n    d.push({\\n        title: '保存',\\n        col_type: 'text_center_1',\\n        url: $('hiker://empty#noLoading#').lazyRule((configKey, params) => {\\n            let config = JSON.parse(request(getMyVar('qdb_config')))\\n            let name = getMyVar(params.key, \\\"\\\");\\n            if(name == '默认') return 'toast://默认配置无法编辑'\\n            config[configKey].use = name\\n            if (!config[configKey][name]) config[configKey][name] = {}\\n            let datas = params.data;\\n            let dataKeys = Object.keys(datas);\\n            for (let i in dataKeys) {\\n                let dataKey = dataKeys[i]\\n                let data = datas[dataKey]\\n                config[configKey][name][dataKey] = getMyVar(data.key, \\\"\\\");\\n            }\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n            back();\\n            return 'toast://保存成功'\\n        }, configKey, params)\\n    })\\n}\\n\\n//自定义首页-配置编辑页面\\nfunction homePageModeEditPage(d) {\\n    d.push({\\n        title: '<font color=\\\"red\\\">' + '返回数组,供setResult使用' + '</font>' + '<font color=\\\"#808080\\\"><br>' + '【内置函数】' + '<br>&nbsp;&nbsp;&nbsp;hiker://page/settingPage: 设置页(默认首页有使用示例)' + '</font>',\\n        col_type: 'rich_text'\\n    })\\n    modeEditPage(d, \\\"homePageConfigs\\\", {\\n        key: \\\"input_name\\\",\\n        desc: \\\"请输入名称\\\",\\n        // type: 'input'\\n        data: {\\n            config: {\\n                key: \\\"input_code\\\",\\n                desc: \\\"请输入配置代码\\\",\\n                type: 'textarea'\\n            }\\n        }\\n    })\\n}\\n\\n//自定义详情页面-配置编辑页面\\nfunction detailViewModeEditPage(d) {\\n    d.push({\\n        title: '<font color=\\\"#808080\\\">' + '【内置变量】' + '<br>&nbsp;&nbsp;&nbsp;id: 片单id' + '<br>&nbsp;&nbsp;&nbsp;type: 片单类型' + '<br>&nbsp;&nbsp;&nbsp;title: 片单标题' + '</font>',\\n        col_type: 'rich_text'\\n    })\\n    modeEditPage(d, \\\"detailsViewConfigs\\\", {\\n        key: \\\"input_name\\\",\\n        desc: \\\"请输入名称\\\",\\n        // type: 'input'\\n        data: {\\n            config: {\\n                key: \\\"input_code\\\",\\n                desc: \\\"请输入配置代码\\\",\\n                type: 'textarea'\\n            },\\n            setting: {\\n                key: \\\"input_setting_code\\\",\\n                desc: \\\"请输入设置页面代码\\\",\\n                type: 'textarea'\\n            }\\n        }\\n    })\\n}\\n\\n//自定义解析-编辑页面\\nfunction analysisModeEditPage(d) {\\n    d.push({\\n        title: '<font color=\\\"#808080\\\">' + '【解析代码内置变量】' + '<br>&nbsp;&nbsp;&nbsp;input: 视频链接' + '</font>',\\n        col_type: 'rich_text'\\n    })\\n    modeEditPage(d, \\\"analysisConfigs\\\", {\\n        key: \\\"input_name\\\",\\n        desc: \\\"请输入名称\\\",\\n        // type: 'input'\\n        data: {\\n            config: {\\n                key: \\\"input_code\\\",\\n                desc: \\\"请输入解析代码\\\",\\n                type: 'textarea'\\n            },\\n            extra: {\\n                key: 'input_extra',\\n                desc: '请输入extra属性值',\\n                type: 'textarea'\\n            },\\n            setting: {\\n                key: \\\"input_setting_code\\\",\\n                desc: \\\"请输入设置页面代码\\\",\\n                type: 'textarea'\\n            }\\n        }\\n    })\\n}\\n\\nlet d = [];\\nlet view = getParam(\\\"view\\\",\\\"\\\");\\nif(view==\\\"analysisModeEditPage\\\"){\\n    setPageTitle(\\\"自定义解析编辑\\\")\\n    analysisModeEditPage(d);\\n}else if(view==\\\"detailViewModeEditPage\\\"){\\n    setPageTitle(\\\"自定义详情页编辑\\\")\\n    detailViewModeEditPage(d);\\n}else if(view==\\\"homePageModeEditPage\\\"){\\n    setPageTitle(\\\"自定义首页编辑\\\")\\n    homePageModeEditPage(d);\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"解除被封ip\",\"path\":\"releaseIP\",\"rule\":\"js:\\nlet id = getParam('id');\\nlet d = [];\\nd.push({\\n    title: '您已被封禁IP地址或触发了人机验证，请按照以下步骤处理(如不处理您将在一段时间内无法正常获取剧集列表)',\\n    url: 'hiker://empty',\\n    col_type: 'text_1'\\n});\\nd.push({\\n    title: '1.点击此处导入自动获取Cookie插件',\\n    url: $()\\n        .lazyRule(() => {\\n            let getDoubanCookie = \\\"(function(){if(window['location']['host']=='www.douban.com'){fy_bridge_app['writeFile']('hiker://files/cache/doubancookie.txt',fy_bridge_app['getCookie']('https://www.douban.com/'));}if(window['location']['host']=='m.douban.com'){fy_bridge_app['writeFile']('hiker://files/cache/doubancookie.txt',fy_bridge_app['getCookie']('https://m.douban.com/'));}}());\\\"\\n            if (!fileExist('hiker://files/cache/global_getDoubanCookie.js')) {\\n                writeFile('hiker://files/cache/global_getDoubanCookie.js', getDoubanCookie);\\n            };\\n            return 'rule://' + base64Encode('海阔视界，网页插件￥js_url￥global_getDoubanCookie@hiker://files/cache/global_getDoubanCookie.js');\\n        }),\\n    col_type: 'text_1'\\n});\\nd.push({\\n    title: '2.点击此处进入网页进行登录或人机验证，完成后返回此页面',\\n    url: 'https://movie.douban.com/subject/' + id + '/',\\n    col_type: 'text_1'\\n});\\nd.push({\\n    title: '3.完成登录或人机验证后返回影片详情页面重新进入',\\n    url: 'hiker://empty',\\n    col_type: 'text_1'\\n});\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"抢救页面\",\"path\":\"urgencyMode\",\"rule\":\"js:\\nlet d = [];\\n\\nd.push({\\n  title: '很明显,出了一些小问题,建议查看设置',\\n  desc: \\\"出错位置:\\\" + (typeof(pos) == 'undefined' ? '未知' : pos),\\n  col_type: 'text_center_1',\\n  url: 'hiker://empty',\\n});\\n\\nd.push({\\n    title: '点我进入设置页',\\n    col_type: 'text_1',\\n    url: \\\"hiker://page/settingPage\\\"\\n})\\n\\nd.push({\\n  title: '若修改设置不起作用,点我复制错误信息提交给开发者',\\n  desc: e.toString(),\\n  col_type: 'text_1',\\n  url: 'copy://' + e.toString(),\\n});\\n\\nsetResult(d);\\n\"},{\"col_type\":\"movie_3\",\"name\":\"顺佬专用详情页\",\"path\":\"Sdetail\",\"rule\":\"js:\\neval(MY_RULE.preRule);\\neval(JSON.parse(request(\\\"hiker://page/main\\\")).rule);\\nlet type = getParam('type', ''),\\n    id = getParam('id', '');\\ndetailsView(type, id);\"},{\"col_type\":\"movie_3\",\"name\":\"主代码\",\"path\":\"main\",\"rule\":\"let version = 202402170001;\\r\\neval(JSON.parse(request('hiker://page/utils')).rule);\\r\\n\\r\\nlet parseVideoUrlLazy = $.toString(() => {\\r\\n    eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n    let analysisConfigs = getConfig('analysisConfigs');\\r\\n    let analysisConfig = analysisConfigs[analysisConfigs.use].config;\\r\\n    let result = \\\"toast://解析失败\\\";\\r\\n    try {\\r\\n        if (analysisConfig.startsWith(\\\"(\\\")) {\\r\\n            eval('result = ' + analysisConfig);\\r\\n        } else {\\r\\n            eval('result = ' + '(() => {' + analysisConfig + '})()');\\r\\n        }\\r\\n    } catch (e) {}\\r\\n    return result;\\r\\n})\\r\\n\\r\\n//首页\\r\\nfunction home() {\\r\\n    if (getItem(\\\"start\\\", \\\"\\\") == \\\"\\\") {\\r\\n        setItem(\\\"start\\\", \\\"1\\\");\\r\\n        setItem('update', String(version));\\r\\n        confirm({\\r\\n            title: '温馨提示',\\r\\n            content: '此规则仅限学习交流使用\\\\n请于导入后24小时内删除!\\\\n\\\\n任何组织或个人不得以任何方式方法\\\\n传播此规则的整体或部分!!\\\\n\\\\n感谢大佬们提供的技术支持!!!',\\r\\n            confirm: '',\\r\\n            cancel: ''\\r\\n        })\\r\\n    } else {\\r\\n        let updateInfo = getItem('update', '');\\r\\n        if (updateInfo == '' || parseInt(updateInfo) < version) {\\r\\n            setItem('update', String(version));\\r\\n            confirm({\\r\\n                title: '本次更新内容',\\r\\n                content: '降低配置文件出错概率',\\r\\n                confirm: '',\\r\\n                cancel: ''\\r\\n            })\\r\\n        }\\r\\n    }\\r\\n    addListener(\\\"onClose\\\", $.toString(() => {\\r\\n        clearMyVar(\\\"qdb_config\\\");\\r\\n    }))\\r\\n    let homePageConfigs = getConfig('homePageConfigs');\\r\\n    let homePageConfig = homePageConfigs[homePageConfigs.use].config;\\r\\n    if (homePageConfig.startsWith(\\\"(\\\")) {\\r\\n        eval('d = ' + homePageConfig)\\r\\n    } else {\\r\\n        eval('d = ' + '(() => {' + homePageConfig + '})()')\\r\\n    }\\r\\n    setResult(d);\\r\\n}\\r\\n\\r\\n//海阔搜索\\r\\nfunction search() {\\r\\n    let wd = MY_URL.split(\\\"/#/\\\")[1];\\r\\n    let page = MY_PAGE;\\r\\n    let s = getDoubanRes('https://frodo.douban.com/api/v2/search/subjects?type=movie&q=' + wd + (page ? '&start=' + (page - 1) * 20 : '&start=0') + '&count=20');\\r\\n\\r\\n    let list = s.items;\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n\\r\\n    let items = [];\\r\\n    list.forEach(data => {\\r\\n        if (data.target_type == 'doulist_cards') {\\r\\n            data.target.doulists.forEach(e => {\\r\\n                items.push({\\r\\n                    title: e.title,\\r\\n                    url: $('hiker://empty/$page{fypage}#noHistory#')\\r\\n                        .rule((type, id) => {\\r\\n                            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                            if (type === \\\"playlist\\\") {\\r\\n                                douList(id, MY_PAGE, 50);\\r\\n                            } else if (type == \\\"collection\\\" || type == \\\"chart\\\") {\\r\\n                                subjectCollectionList(MY_PAGE, 50, id);\\r\\n                            }\\r\\n                        }, e.target_type, e.id),\\r\\n                    img: e.cover_url + \\\"@Referer=\\\" + e.cover_url\\r\\n                })\\r\\n            })\\r\\n        } else if (data.target_type == 'chart') {\\r\\n            let e = data.target;\\r\\n            items.push({\\r\\n                title: e.title,\\r\\n                url: $('hiker://empty/$page{fypage}#noHistory#')\\r\\n                    .rule((type, id) => {\\r\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                        if (type === \\\"playlist\\\") {\\r\\n                            douList(id, MY_PAGE, 50);\\r\\n                        } else if (type == \\\"collection\\\" || type == \\\"chart\\\") {\\r\\n                            subjectCollectionList(MY_PAGE, 50, id);\\r\\n                        }\\r\\n                    }, data.target_type, e.id),\\r\\n                img: e.cover_url + \\\"@Referer=\\\" + e.cover_url\\r\\n            })\\r\\n        } else {\\r\\n            let type = data.target_type,\\r\\n                id = data.target.id,\\r\\n                title = data.target.title;\\r\\n            let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n            let urlParams = {};\\r\\n            if (useConfig.startsWith('{')) {\\r\\n                eval('urlParams = ' + useConfig);\\r\\n            } else {\\r\\n                urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id)\\r\\n                    .rule((type, id, title, useConfig) => {\\r\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                        if (type === \\\"playlist\\\") {\\r\\n                            douList(id, MY_PAGE, 50);\\r\\n                        } else {\\r\\n                            eval(useConfig);\\r\\n                        }\\r\\n                    }, type, id, title, useConfig);\\r\\n            }\\r\\n            items.push({\\r\\n                title: title,\\r\\n                img: data.target.cover_url + \\\"@Referer=\\\" + data.target.cover_url,\\r\\n                desc: data.type_name,\\r\\n                content: data.target.card_subtitle,\\r\\n                url: urlParams.url,\\r\\n                extra: urlParams.extra\\r\\n            });\\r\\n        }\\r\\n\\r\\n    });\\r\\n\\r\\n    setSearchResult({\\r\\n        data: items\\r\\n    });\\r\\n}\\r\\n\\r\\n//二级页面\\r\\nfunction erji() {\\r\\n    addListener(\\\"onClose\\\", $.toString(() => {\\r\\n        clearMyVar(\\\"findList\\\");\\r\\n        clearMyVar(\\\"hotList\\\");\\r\\n        clearMyVar(\\\"classlist\\\");\\r\\n        clearMyVar(\\\"playlist\\\");\\r\\n        clearMyVar(\\\"rankList\\\");\\r\\n        clearMyVar(\\\"ranking\\\");\\r\\n        clearMyVar(\\\"coming\\\");\\r\\n        clearMyVar(\\\"analysis\\\");\\r\\n    }))\\r\\n\\r\\n    let choice = MY_URL.split('/#/')[1].split('#')[0];\\r\\n    let d = [];\\r\\n    switch (choice) {\\r\\n        case \\\"推荐\\\":\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            d = findList(MY_PAGE, 10);\\r\\n            break;\\r\\n        case \\\"热门\\\":\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            d = hotList(MY_PAGE, 10);\\r\\n            break;\\r\\n        case \\\"分类\\\":\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            d = classList(MY_PAGE, 15);\\r\\n            break;\\r\\n        case \\\"片单\\\":\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            d = playList(MY_PAGE, 10);\\r\\n            break;\\r\\n        case \\\"榜单\\\":\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            d = rankList(MY_PAGE, 10);\\r\\n            break;\\r\\n        case \\\"将上映\\\":\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            d = comingList(MY_PAGE, 10);\\r\\n            break;\\r\\n    }\\r\\n    setResult(d);\\r\\n}\\r\\n\\r\\n//获取豆瓣资源,返回json数据\\r\\nfunction getDoubanRes(url) {\\n    //log(url)\\r\\n    var cc =null;\\r\\n    if($.type(url)=='object'){\\r\\n         cc=url.cc;\\r\\n         url = url.url;\\r\\n    }\\r\\n    var _url = url;\\r\\n    if (url.indexOf('apikey') === -1) {\\r\\n        _url += (url.indexOf('?') === -1 ? '?' : '&') + \\\"apikey=0dad551ec0f84ed02907ff5c42e8ec70\\\"\\r\\n    }\\r\\n    let _ts = parseInt(Date.now()/1000).toString();\\r\\n    let m = 'GET&' + encodeURIComponent(url.split('douban.com')[1].split('?')[0]) + '&' + _ts;\\r\\n    eval(getCryptoJS());\\r\\n    let _sig = hexToBase64(CryptoJS.HmacSHA1(m,'bf7dddc7c9cfe6f7').toString());\\r\\n    _url += '&_sig=' + _sig +'&_ts=' + _ts;\\r\\n    //let cookieCache = 'hiker://files/cache/doubancookie.txt';\\r\\n    let s = fetch(_url, {\\r\\n        headers: {\\r\\n            //'Cookie': fetch(cookieCache),\\r\\n            \\\"User-Agent\\\": \\\"Rexxar-Core/0.1.3 api-client/1 com.douban.frodo/7.9.0.beta2(215) Android/25 product/TAS-AL00 vendor/HUAWEI model/TAS-AL00  rom/android  network/wifi  platform/mobile com.douban.frodo/7.9.0.beta2(215) Rexxar/1.2.151  platform/mobile 1.2.151\\\"\\r\\n        },\\r\\n        method: 'GET'\\r\\n        //body: 'host=frodo.douban.com'\\r\\n    });\\r\\n    let json = JSON.parse(s);\\r\\n    if(json.localized_message){\\r\\n        cc= cc==null ? 1 : cc+1;\\r\\n        log('重试次数:'+cc);\\r\\n        if(cc>5){throw new Error('超时')}\\r\\n        java.lang.Thread.sleep(1000);\\r\\n        return getDoubanRes({url:url,cc:cc});\\r\\n    }else{\\r\\n        return json;\\r\\n    }\\r\\n}\\r\\n\\r\\n//根据评分信息获取评分星星样式\\r\\nfunction computeRating(e, t) {\\r\\n    let i = \\\"\\\";\\r\\n    for (let r = 0; r < 5; r++) r < Math.round(t / (e / 5)) ? i += \\\"★\\\" : i += \\\"☆\\\";\\r\\n    return i;\\r\\n}\\r\\n\\r\\n//评分详情页面\\r\\nfunction rating(type, id, ratingCount) {\\r\\n    setPageTitle('影片信息');\\r\\n    //评分统计\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/rating\\\");\\r\\n\\r\\n    let r = \\\"<h2>评分统计</h2>\\\";\\r\\n\\r\\n    r += '<small><font color=\\\"grey\\\">' + ratingCount + '人评分' + '</font></small><br/>';\\r\\n\\r\\n    let starColor = getConfig('starColor');\\r\\n    if (i.stats.length == 0) {\\r\\n        i.stats = [0, 0, 0, 0, 0];\\r\\n    }\\r\\n    i.stats.reverse().forEach(((value, index) => {\\r\\n        r += '<font color=' + starColor + '>' + [\\\"★★★★★\\\", \\\"★★★★☆\\\", \\\"★★★☆☆\\\", \\\"★★☆☆☆\\\", \\\"★☆☆☆☆\\\"][index] + \\\"</font>&nbsp;\\\";\\r\\n\\r\\n        r += function(e) {\\r\\n            let t1 = '';\\r\\n            for (let i = 0; i < e; i++) t1 += \\\"▇\\\";\\r\\n            let t2 = '';\\r\\n            for (let i = 0; i < 10 - e; i++) t2 += \\\"▇\\\";\\r\\n            return t1.fontcolor('#ffac2d') + t2.fontcolor('#e5e1e4');\\r\\n        }((10 * value).toFixed(0));\\r\\n\\r\\n        r += '&nbsp;<small><font color=\\\"grey\\\">' + (100 * value)\\r\\n            .toFixed(1) + \\\"%</font></small><br/>\\\";\\r\\n    }));\\r\\n\\r\\n    r += [i.done_count ? i.done_count + \\\"人看过\\\" : \\\"\\\", i.doing_count ? i.doing_count + \\\"人在看\\\" : \\\"\\\", i.wish_count ? i.wish_count + \\\"人想看\\\" : \\\"\\\"].join(\\\"&nbsp;&nbsp;\\\")\\r\\n        .small()\\r\\n        .fontcolor('grey');\\r\\n    //影片信息\\r\\n    i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/desc\\\");\\r\\n    let l = i.html.replace(/[\\\\n\\\\t\\\\r]/g, \\\"\\\")\\r\\n        .replace(/<td\\\\s*[^>]*>(.*?)<\\\\/td>/g, \\\"<span>$1</span>\\\")\\r\\n        .replace(/<tr\\\\s*[^>]*>(.*?)<\\\\/tr>/g, \\\"<teng>$1</teng><br/>\\\");\\r\\n    parseDomForArray(l, \\\"section&&teng\\\").forEach((e => {\\r\\n        let t = parseDomForArray(e, \\\"span\\\");\\r\\n        l = l.replace(t[0], '<font color=\\\"grey\\\">' + t[0].replace(/<span\\\\s*[^>]*>(.*?)<\\\\/span>/g, \\\"$1\\\") + \\\"：</font>\\\")\\r\\n    }));\\r\\n    r += l;\\r\\n    //获奖记录\\r\\n    let page = MY_PAGE;\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/awards?start=\\\" + 20 * (page - 1) + \\\"&count=20\\\");\\r\\n    r += \\\"<h2>获奖记录\\\" + '<small><font color=\\\"grey\\\">' + (s.total != 0 ? '(共' + s.total + '项)' : '(暂无)') + '</font></small>' + \\\"</h2>\\\";\\r\\n    //r += '<font color=\\\"grey\\\">' + (s.total != 0 ? '共' + s.total + '项' : '暂无') + '</font><br/>';\\r\\n    let r2 = '';\\r\\n    s.awards.forEach(e => {\\r\\n        r2 += (e.ceremony.title + '(' + e.ceremony.year + ')').big().bold() + '<small>(<a href=\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);awardView(`' + e.ceremony.id + '`,`' + e.ceremony.title + '`);\\\">查看详情</a>)</small>' + '<br/>';\\r\\n        e.categories.forEach(item => {\\r\\n            r2 += (item.category.title + (item.is_won ? '' : '(提名)') + '&nbsp;').fontcolor(\\\"grey\\\");\\r\\n            r2 += item.celebrities.map(celebrity => celebrity.name).join('&nbsp;/&nbsp;');\\r\\n            r2 += '<br/>';\\r\\n        })\\r\\n        r2 += '<br/>';\\r\\n    })\\r\\n\\r\\n    if (page == 1) {\\r\\n        setHomeResult({\\r\\n            data: [{\\r\\n                title: r + r2,\\r\\n                col_type: \\\"rich_text\\\"\\r\\n            }]\\r\\n        })\\r\\n    } else if(s.awards.length == 0){\\r\\n        setResult([]);\\r\\n    } else{\\r\\n        setHomeResult({\\r\\n            data: [{\\r\\n                title: r2,\\r\\n                col_type: \\\"rich_text\\\"\\r\\n            }]\\r\\n        })\\r\\n    }\\r\\n}\\r\\n\\r\\n//奖项详情页面\\r\\nfunction awardView(id, name) {\\r\\n    setPageTitle(name);\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/ceremony/\\\" + id);\\r\\n    let a = [];\\r\\n    a.push({\\r\\n        title: '““””' + (s.title + '(' + s.year + ')').big().bold(),\\r\\n        col_type: 'text_1',\\r\\n        extra: {\\r\\n            lineVisible: false\\r\\n        }\\r\\n    })\\r\\n    s.playlists.forEach(e => {\\r\\n        a.push({\\r\\n            title: e.title,\\r\\n            desc: '共' + e.items_count + '部',\\r\\n            img: e.cover_url + '@Referer=' + e.cover_url,\\r\\n            url: $('hiker://empty#noHistory#').rule((id) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                douList(id);\\r\\n            }, e.id)\\r\\n        })\\r\\n    })\\r\\n\\r\\n    let r = '';\\r\\n    s.prizes.forEach(e => {\\r\\n        r += '<h4>获奖名单(' + e.title + ')</h4>';\\r\\n        e.categories.forEach(t => {\\r\\n            r += (t.title + '&nbsp;&nbsp;&nbsp;&nbsp;').fontcolor(\\\"grey\\\").bold();\\r\\n            r += t.results.map(item => !!item.info ? item.info + ('&nbsp;-&nbsp;' + item.title + '&nbsp;&nbsp;').fontcolor(\\\"grey\\\") : item.title).join('&nbsp;/&nbsp;').bold();\\r\\n            r += '<br/>';\\r\\n        })\\r\\n    })\\r\\n    a.push({\\r\\n        title: r,\\r\\n        col_type: 'rich_text'\\r\\n    })\\r\\n\\r\\n    let i = [];\\r\\n    s.ceremonies.forEach(e => {\\r\\n        i.push({\\r\\n            title: e.title,\\r\\n            desc: e.year + '年',\\r\\n            col_type: 'movie_3',\\r\\n            img: e.pic.normal + '@Referer=' + e.pic.normal,\\r\\n            url: $('hiker://empty#noHistory#').rule((id, name) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                awardView(id, name);\\r\\n            }, e.id, e.title)\\r\\n        })\\r\\n    })\\r\\n    if (i.length > 0) {\\r\\n        i.unshift({\\r\\n            title: '““””' + '历届回顾'.big().bold(),\\r\\n            col_type: 'text_1',\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            }\\r\\n        })\\r\\n    }\\r\\n\\r\\n    setResult(a.concat(i));\\r\\n}\\r\\n\\r\\n//剧照页面\\r\\nfunction stillsList(type, id) {\\r\\n    addListener('onClose', 'clearMyVar(\\\"photo\\\")');\\r\\n    let page = MY_PAGE;\\r\\n    let items = {\\r\\n        剧照: 'photos',\\r\\n        海报: 'covers'\\r\\n    };\\r\\n    let a = [];\\r\\n    let temp = getMyVar('photo', 'photos');\\r\\n    let color = getConfig('chooseColor');\\r\\n    for (let i in items) {\\r\\n        a.push({\\r\\n            title: temp == items[i] ? '““””' + i.fontcolor(color) : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker://empty').lazyRule((t) => {\\r\\n                putMyVar('photo', t);\\r\\n                refreshPage();\\r\\n                return 'hiker://empty';\\r\\n            }, items[i])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    let r = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/\\\" + temp + \\\"?start=\\\" + 30 * (page - 1) + \\\"&count=30\\\");\\r\\n    let l = r.photos.map((e => ({\\r\\n        title: e.create_time,\\r\\n        img: e.image.small.url + \\\"@Referer=\\\" + e.image.small.url,\\r\\n        url: e.image.large.url + \\\"?type=.jpg@Referer=\\\" + e.image.large.url + \\\"?type=.jpg\\\",\\r\\n        col_type: \\\"pic_2\\\"\\r\\n    })));\\r\\n\\r\\n    if (page == 1) {\\r\\n        l.unshift({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        });\\r\\n        if (temp == 'photos') {\\r\\n            l.unshift({\\r\\n                title: \\\"<big>共<strong> \\\" + r.total + ' </strong>张剧照</big><br/><small><font color=\\\"grey\\\">官方剧照：' + r.o + \\\"张&nbsp;截图：\\\" + r.c + \\\"张&nbsp;工作照：\\\" + r.w + \\\"张&nbsp;新闻图片：\\\" + r.n + \\\"张&nbsp;粉丝图片：\\\" + r.f + \\\"张</font></small>\\\",\\r\\n                col_type: \\\"rich_text\\\"\\r\\n            })\\r\\n        } else {\\r\\n            l.unshift({\\r\\n                title: \\\"<big>共<strong> \\\" + r.total + \\\"</strong>张海报</big>\\\",\\r\\n                col_type: \\\"rich_text\\\"\\r\\n            })\\r\\n        }\\r\\n        l = a.concat(l);\\r\\n    }\\r\\n    setHomeResult({\\r\\n        data: l\\r\\n    })\\r\\n}\\r\\n\\r\\n//演职人员页面\\r\\nfunction credits(type, id) {\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/credits\\\");\\r\\n    let r = [];\\r\\n    i.credits.forEach((e => {\\r\\n        r.push({\\r\\n            title: e.title,\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        });\\r\\n        e.celebrities.forEach((e => {\\r\\n            r.push({\\r\\n                title: e.name + \\\"\\\\n\\\" + e.latin_name,\\r\\n                desc: e.character,\\r\\n                img: e.avatar.normal + \\\"@Referer=\\\" + e.avatar.normal,\\r\\n                col_type: 'movie_1_vertical_pic',\\r\\n                url: $('hiker://empty#noHistory##immersiveTheme#').rule((e) => {\\r\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                    elessarView(e.uri.split(\\\"subject_id=\\\")[1], e.id, e.name);\\r\\n                }, e)\\r\\n            })\\r\\n        }))\\r\\n    }));\\r\\n    setHomeResult({\\r\\n        data: r\\r\\n    })\\r\\n}\\r\\n\\r\\n//短评页面\\r\\nfunction shortCommentList(type, id) {\\r\\n    addListener('onClose', \\\"clearMyVar('shortcomment')\\\");\\r\\n    let items = {\\r\\n        热门: 'hot',\\r\\n        最新: 'latest'\\r\\n    }\\r\\n    let u = getMyVar('shortcomment', 'hot');\\r\\n    let a = [];\\r\\n    let chooseColor = getConfig('chooseColor') // || \\\"#FA7298\\\";\\r\\n    for (i in items) {\\r\\n        a.push({\\r\\n            title: u === items[i] ? '““””<b> <font color=' + chooseColor + '>' + i + ' </font></b>' : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty').lazyRule((t) => {\\r\\n                putMyVar(\\\"shortcomment\\\", t);\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, items[i])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    let page = MY_PAGE;\\r\\n    let r = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/interests?start=\\\" + 30 * (page - 1) + \\\"&count=30&order_by=\\\" + u);\\r\\n    let l = [];\\r\\n    let starColor = getConfig('starColor');\\r\\n    r.interests.forEach((e => {\\r\\n        let t = \\\"\\\";\\r\\n        if (e.rating) {\\r\\n            t = computeRating(e.rating.max, e.rating.value);\\r\\n        }\\r\\n        l.push({\\r\\n            title: e.user.name,\\r\\n            img: e.user.avatar,\\r\\n            url: e.user.url,\\r\\n            col_type: \\\"avatar\\\"\\r\\n        });\\r\\n        l.push({\\r\\n            title: e.comment + (t ? '<br/><small>看过 <font color=' + starColor + '>' + t + \\\"</font></small>\\\" : \\\"\\\") + '<br/><small><font color=\\\"grey\\\">' + e.vote_count + \\\"赞•\\\" + /\\\\d{4}-\\\\d{1,2}-\\\\d{1,2}/g.exec(e.create_time) + \\\"</font></small>\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        });\\r\\n        l.push({\\r\\n            col_type: \\\"line\\\"\\r\\n        })\\r\\n    }));\\r\\n\\r\\n    if (page == 1) {\\r\\n        l.unshift({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        });\\r\\n        l.unshift({\\r\\n            title: \\\"<big>共<strong> \\\" + r.total + \\\" </strong>条短评</big>\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        });\\r\\n        setHomeResult({\\r\\n            data: a.concat(l)\\r\\n        })\\r\\n    } else {\\r\\n        setHomeResult({\\r\\n            data: l\\r\\n        })\\r\\n    }\\r\\n}\\r\\n\\r\\n//剧评页面\\r\\nfunction dramaReviewList(type, id) {\\r\\n    addListener('onClose', \\\"clearMyVar('dramareview')\\\");\\r\\n    let items = {\\r\\n        热门: 'hot',\\r\\n        最新: 'latest'\\r\\n    }\\r\\n    let u = getMyVar('dramareview', 'hot');\\r\\n    let a = [];\\r\\n    let chooseColor = getConfig('chooseColor');\\r\\n    for (i in items) {\\r\\n        a.push({\\r\\n            title: u === items[i] ? '““””<b> <font color=' + chooseColor + '>' + i + ' </font></b>' : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty').lazyRule((t) => {\\r\\n                putMyVar(\\\"dramareview\\\", t);\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, items[i])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    let page = MY_PAGE\\r\\n    let r = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/reviews?start=\\\" + 15 * (page - 1) + \\\"&count=15&order_by=\\\" + u);\\r\\n    let l = [];\\r\\n    let starColor = getConfig('starColor');\\r\\n    r.reviews.forEach((e => {\\r\\n        let t = \\\"\\\";\\r\\n        if (e.rating) {\\r\\n            t = computeRating(e.rating.max, e.rating.value);\\r\\n        }\\r\\n        let i = e.comments_count ? e.comments_count + \\\"回复\\\" : \\\"\\\",\\r\\n            r = e.useful_count ? e.useful_count + \\\"有用\\\" : \\\"\\\",\\r\\n            o = e.reshares_count ? e.reshares_count + \\\"转发\\\" : \\\"\\\";\\r\\n\\r\\n        r = i && r ? \\\"•\\\" + r : r;\\r\\n        o = (i || r) && o ? \\\"•\\\" + o : o;\\r\\n        l.push({\\r\\n            title: e.user.name,\\r\\n            img: e.user.avatar,\\r\\n            url: e.user.url,\\r\\n            col_type: \\\"avatar\\\"\\r\\n        })\\r\\n        l.push({\\r\\n            title: \\\"<strong>\\\" + e.title + \\\"</strong><br/>\\\" + e.abstract + '   <small>(<a href=\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);dramaReviewView(' + e.id + ')\\\">更多</a>)</small>' + (t ? '<br/><small>看过 <font color=' + starColor + '>' + t + \\\"</font></small>\\\" : \\\"\\\") + '<br/><small><font color=\\\"grey\\\">' + i + r + o + \\\"</font></small>\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n        l.push({\\r\\n            col_type: \\\"line\\\"\\r\\n        })\\r\\n    }));\\r\\n\\r\\n    if (page == 1) {\\r\\n        l.unshift({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        });\\r\\n        l.unshift({\\r\\n            title: \\\"<big>共<strong> \\\" + r.total + \\\" </strong>条剧评</big>\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        });\\r\\n\\r\\n        setHomeResult({\\r\\n            data: a.concat(l)\\r\\n        })\\r\\n    } else {\\r\\n        setHomeResult({\\r\\n            data: l\\r\\n        })\\r\\n    }\\r\\n}\\r\\n\\r\\n//预告片页面\\r\\nfunction trailers(type, id) {\\r\\n    setPageTitle('预告-片段-花絮')\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/trailers\\\").trailers;\\r\\n    i.forEach((e => {\\r\\n        e.col_type = \\\"movie_2\\\", e.desc = e.subject_title + \\\"•\\\" + e.create_time, e.img = e.cover_url, e.url = e.video_url\\r\\n    }));\\r\\n\\r\\n    let r = i.filter((e => \\\"A\\\" === e.type));\\r\\n    let l = i.filter((e => \\\"B\\\" === e.type));\\r\\n    let o = i.filter((e => \\\"C\\\" === e.type));\\r\\n\\r\\n    if (r.length > 0) {\\r\\n        r.unshift({\\r\\n            title: \\\"预告\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n    }\\r\\n    if (l.length > 0) {\\r\\n        l.unshift({\\r\\n            title: \\\"片段\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n    }\\r\\n    if (o.length > 0) {\\r\\n        o.unshift({\\r\\n            title: \\\"花絮\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n    }\\r\\n\\r\\n    setHomeResult({\\r\\n        data: r.concat(l)\\r\\n            .concat(o)\\r\\n    })\\r\\n}\\r\\n\\r\\n//视频评论页面\\r\\nfunction videoComment(type, id) {\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/videos\\\").videos;\\r\\n    i.forEach((e => {\\r\\n        e.col_type = \\\"movie_2\\\", e.desc = e.author.name + \\\"•\\\" + e.create_time, e.img = e.cover_url + \\\"@Referer=\\\" + e.cover_url, e.url = e.video_url\\r\\n    }))\\r\\n    if (i.length > 0) {\\r\\n        i.unshift({\\r\\n            title: \\\"视频评论\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n    }\\r\\n    setHomeResult({\\r\\n        data: i\\r\\n    })\\r\\n}\\r\\n\\r\\n//演职人员详情页面\\r\\nfunction elessarView(id, pid, name) {\\r\\n    setPageTitle(name);\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/elessar/subject/\\\" + id);\\r\\n    let a = [];\\r\\n    a.push({\\r\\n        title: '““””' + (i.title + '(' + i.latin_title + ')').big().bold(),\\r\\n        desc: '““””' + i.desc.match(/\\\\<p\\\\>.*\\\\<\\\\/p\\\\>/)[0],\\r\\n        img: i.cover.normal.url + '@Referer=' + i.cover.normal.url,\\r\\n        col_type: 'movie_1_vertical_pic_blur',\\r\\n        url: $('hiker://empty').rule((desc, extra, name) => {\\r\\n            let info = extra.info.map(e => e.join(':&nbsp;'));\\r\\n            setResult([{\\r\\n                title: '<h2>' + name + '</h2>' + info.join('<br/>') + desc.match(/\\\\<p\\\\>.*\\\\<\\\\/p\\\\>/)[0],\\r\\n                col_type: 'rich_text'\\r\\n            }])\\r\\n        }, i.desc, i.extra, i.title)\\r\\n    })\\r\\n    \\r\\n    let index = i.modules.findIndex(cur => cur.type == \\\"award_result_collection\\\");\\r\\n    if (index > -1) {\\r\\n        let e = i.modules[index].payload;\\r\\n        a.push({\\r\\n            title: '““””' + '获奖记录'.big().bold() + '<small>(共' + e.total + '项)</small>',\\r\\n            desc: '““””<strong>' + e.awards[0].ceremony.title + '</strong>\\\\n' + e.awards[0].category.title + (e.awards[0].is_won ? '' : '(提名)'),\\r\\n            col_type: 'text_center_1',\\r\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((id, count) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                elessarAwards(id, count);\\r\\n            }, e.id, e.total),\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            }\\r\\n        })\\r\\n    }\\r\\n    \\r\\n    index = i.modules.findIndex(cur => cur.type == \\\"work_collections\\\");\\r\\n    if (index > -1) {\\r\\n        let e2 = i.modules[index].payload;\\r\\n        a.push({\\r\\n            col_type: 'line'\\r\\n        })\\r\\n        a.push({\\r\\n            title: '““””' + '影视作品'.big().bold() + ('(共' + e2.collections[0].total + '部)').small(),\\r\\n            col_type: 'text_center_1',\\r\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((id, type) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                elessarWorks(id, type);\\r\\n            }, e2.id, e2.collections[0].title),\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            }\\r\\n        })\\r\\n\\r\\n        let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n        let works = e2.collections[0].works;\\r\\n        let length = works.length <= 3 ? works.length : 3;\\r\\n        for (let i = 0; i < length; i++) {\\r\\n            let e = works[i];\\r\\n            let rating = \\\"\\\";\\r\\n            if (e.subject.extra.rating_group.rating) {\\r\\n                rating = computeRating(e.subject.extra.rating_group.rating.max, e.subject.extra.rating_group.rating.value) + \\\" \\\" + e.subject.extra.rating_group.rating.value + \\\"分\\\";\\r\\n            }\\r\\n\\r\\n            let type = e.subject.subtype,\\r\\n                id = e.subject.id,\\r\\n                title = e.subject.title;\\r\\n            let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n            let urlParams = {};\\r\\n            if (useConfig.startsWith('{')) {\\r\\n                eval('urlParams = ' + useConfig);\\r\\n            } else {\\r\\n                urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                    if (type === \\\"playlist\\\") {\\r\\n                        douList(id, MY_PAGE, 50);\\r\\n                    } else {\\r\\n                        eval(useConfig);\\r\\n                    }\\r\\n                }, type, id, title, useConfig);\\r\\n            }\\r\\n            a.push({\\r\\n                title: title,\\r\\n                img: e.subject.cover.normal.url + \\\"@Referer=\\\" + e.subject.cover.normal.url,\\r\\n                desc: rating,\\r\\n                col_type: 'movie_3',\\r\\n                url: urlParams.url,\\r\\n                extra: urlParams.extra\\r\\n            })\\r\\n        }\\r\\n        /*a.push({\\r\\n            title: '查看更多',\\r\\n            img: 'https://joker-tx.coding.net/p/hikerimg/d/hiker/git/raw/master/img/more_ver.png?download=false',\\r\\n            col_type: 'movie_3',\\r\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#')\\r\\n                .rule((id, type) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                elessarWorks(id, type);\\r\\n            }, e2.id, e2.collections[0].title)\\r\\n        })*/\\r\\n    }\\r\\n    \\r\\n    index = i.modules.findIndex(cur => cur.type == \\\"photos\\\");\\r\\n    if (index > -1) {\\r\\n        let e3 = i.modules[index].payload;\\r\\n        a.push({\\r\\n            col_type: 'line'\\r\\n        })\\r\\n        a.push({\\r\\n            title: '““””' + '演员照片'.big().bold() + ('(共' + e3.total + '张)').small(),\\r\\n            col_type: 'text_center_1',\\r\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((pid) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                elessarPhotos(pid);\\r\\n            }, pid),\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            }\\r\\n        })\\r\\n\\r\\n        let plength = e3.photos.length <= 2 ? e3.photos.length : 2;\\r\\n        for (let i = 0; i < plength; i++) {\\r\\n            a.push({\\r\\n                //title: e3.photos[0].description,\\r\\n                col_type: 'card_pic_2',\\r\\n                desc: '0',\\r\\n                img: e3.photos[i].image.normal.url + '@Referer=' + e3.photos[i].image.normal.url,\\r\\n                url: e3.photos[i].image.normal.url + '@Referer=' + e3.photos[i].image.normal.url\\r\\n            })\\r\\n        }\\r\\n\\r\\n        /*a.push({\\r\\n            //title: '查看更多',\\r\\n            img: 'https://joker-tx.coding.net/p/hikerimg/d/hiker/git/raw/master/img/more.png?download=false',\\r\\n            col_type: 'card_pic_2',\\r\\n            desc: '0',\\r\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#')\\r\\n                .rule((pid) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                elessarPhotos(pid);\\r\\n            }, pid)\\r\\n        })*/\\r\\n    }\\r\\n\\r\\n    setResult(a);\\r\\n}\\r\\n\\r\\n//演职人员获奖详情页面\\r\\nfunction elessarAwards(id, count) {\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/elessar/award_result_collection/\\\" + id + \\\"/awards?start=\\\" + 30 * (MY_PAGE - 1) + \\\"&count=30\\\");\\r\\n    let l = [];\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    i.awards.forEach(t => {\\r\\n        l.push({\\r\\n            title: (t.year+\\\"\\\").bold().big(),\\r\\n            col_type: 'rich_text'\\r\\n        })\\r\\n\\r\\n        for (let i = 0; i < t.modules.length; i++) {\\r\\n            let e = t.modules[i];\\r\\n            if (!e.ceremony || !e.category) {\\r\\n                let rating = \\\"\\\";\\r\\n                if (e.extra.rating_group.rating) {\\r\\n                    rating = computeRating(e.extra.rating_group.rating.max, e.extra.rating_group.rating.value) + \\\" \\\" + e.extra.rating_group.rating.value + \\\"分\\\";\\r\\n                }\\r\\n                let type = e.subtype,\\r\\n                    id = e.id,\\r\\n                    title = e.title;\\r\\n                let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n                let urlParams = {};\\r\\n                if (useConfig.startsWith('{')) {\\r\\n                    eval('urlParams = ' + useConfig);\\r\\n                } else {\\r\\n                    urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                        if (type === \\\"playlist\\\") {\\r\\n                            douList(id, MY_PAGE, 50);\\r\\n                        } else {\\r\\n                            eval(useConfig);\\r\\n                        }\\r\\n                    }, type, id, title, useConfig);\\r\\n                }\\r\\n                l.push({\\r\\n                    title: title,\\r\\n                    img: e.cover.normal.url + \\\"@Referer=\\\" + e.cover.normal.url,\\r\\n                    desc: rating + '\\\\n' + e.extra.short_info,\\r\\n                    url: urlParams.url,\\r\\n                    extra: urlParams.extra\\r\\n                })\\r\\n            } else {\\r\\n                l.push({\\r\\n                    title: e.ceremony.title.bold() + '<small>(<a href=\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);awardView(`' + e.ceremony.id + '`,`' + e.ceremony.title + '`);\\\">查看详情</a>)</small>' + '<br/>' + (e.category.title + (e.is_won ? '' : '(提名)')).small(),\\r\\n                    col_type: 'rich_text'\\r\\n                })\\r\\n            }\\r\\n        }\\r\\n    })\\r\\n\\r\\n    if (MY_PAGE == 1) {\\r\\n        l.unshift({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        l.unshift({\\r\\n            title: \\\"<big>共<strong> \\\" + count + \\\" </strong>项获奖记录</big>\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n    }\\r\\n    setResult(l);\\r\\n}\\r\\n\\r\\n//演职人员作品页面\\r\\nfunction elessarWorks(id, type) {\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/elessar/work_collections/\\\" + id + \\\"/works?start=\\\" + 30 * (MY_PAGE - 1) + \\\"&count=30&collection_title=\\\" + type);\\r\\n\\r\\n    let l = [];\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    i.works.forEach((e => {\\r\\n        let rating = \\\"\\\";\\r\\n        if (e.subject.extra.rating_group.rating) {\\r\\n            rating = computeRating(e.subject.extra.rating_group.rating.max, e.subject.extra.rating_group.rating.value) + \\\" \\\" + e.subject.extra.rating_group.rating.value + \\\"分\\\";\\r\\n        }\\n        \\n        let year = e.subject.extra ? (e.subject.extra.year ? '('+e.subject.extra.year+')' : '') : '';\\r\\n\\r\\n        let type = e.subject.subtype,\\r\\n            id = e.subject.id,\\r\\n            title = e.subject.title;\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        l.push({\\r\\n            title: title + year,\\r\\n            img: e.subject.cover.normal.url + \\\"@Referer=\\\" + e.subject.cover.normal.url,\\r\\n            desc: e.roles.join(\\\"•\\\") + \\\"\\\\n\\\" + rating + '\\\\n' + e.subject.extra.short_info,\\r\\n            col_type: 'movie_1_vertical_pic',\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra\\r\\n        })\\r\\n    }))\\r\\n\\r\\n    if (MY_PAGE == 1) {\\r\\n        l.unshift({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        l.unshift({\\r\\n            title: \\\"<big>共<strong> \\\" + i.total + \\\" </strong>部作品</big>\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n    }\\r\\n    setHomeResult({\\r\\n        data: l\\r\\n    })\\r\\n}\\r\\n\\r\\n//演职人员照片页面\\r\\nfunction elessarPhotos(pid) {\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/celebrity/\\\" + pid + \\\"/photos?start=\\\" + 30 * (MY_PAGE - 1) + \\\"&count=30\\\");\\r\\n    let l = [];\\r\\n    i.photos.forEach(e => {\\r\\n        l.push({\\r\\n            col_type: 'card_pic_2',\\r\\n            desc: '0',\\r\\n            img: e.image.normal.url + '@Referer=' + e.image.normal.url,\\r\\n            url: e.image.normal.url + '@Referer=' + e.image.normal.url\\r\\n        })\\r\\n    })\\r\\n    if (MY_PAGE == 1) {\\r\\n        l.unshift({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        l.unshift({\\r\\n            title: \\\"<big>共<strong> \\\" + i.total + \\\" </strong>张照片</big>\\\",\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n    }\\r\\n    setResult(l);\\r\\n}\\r\\n\\r\\n//剧评详情页面\\r\\nfunction dramaReviewView(id) {\\r\\n    setPageTitle('剧评详情');\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/review/\\\" + id);\\r\\n\\r\\n    i.photos.forEach((e => {\\r\\n        i.content = i.content.replace('id=\\\"' + e.tag_name + '\\\"', 'src=\\\"' + e.image.large.url + \\\"@Referer=\\\" + e.image.large.url + '\\\"')\\r\\n    }));\\r\\n\\r\\n    let l = getDoubanRes(\\\"https://frodo.douban.com/api/v2/review/\\\" + id + \\\"/comments\\\");\\r\\n    let o = [{\\r\\n        col_type: \\\"blank_block\\\"\\r\\n    }, {\\r\\n        title: \\\"<big><strong>评论：</strong></big>\\\",\\r\\n        col_type: \\\"rich_text\\\"\\r\\n    }];\\r\\n\\r\\n    l.comments.length > 0 ? l.comments.forEach((e => {\\r\\n        o.push({\\r\\n            title: e.author.name,\\r\\n            img: e.author.avatar,\\r\\n            url: e.author.url,\\r\\n            col_type: \\\"avatar\\\"\\r\\n        })\\r\\n        o.push({\\r\\n            title: e.text + (e.replies.length > 0 ? ' <small><a href=\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);dramaReviewReplyView(' + e.id + ');\\\">[查看回复]</a></small>' : \\\"\\\"),\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n        o.push({\\r\\n            col_type: \\\"line\\\"\\r\\n        })\\r\\n    })) : o.push({\\r\\n        title: '<font color=\\\"grey\\\">( •̥́ ˍ •̀ू )还没有人评论...</font>',\\r\\n        col_type: \\\"rich_text\\\"\\r\\n    });\\r\\n\\r\\n    let a = \\\"\\\";\\r\\n    if (i.rating) {\\r\\n        a = computeRating(i.rating.max, i.rating.value);\\r\\n    }\\r\\n    let color = JSON.parse(fetch(getMyVar('qdb_config')))\\r\\n        .starColor || \\\"#ffac2d\\\";\\r\\n    let s = [{\\r\\n        title: \\\"<big><strong>\\\" + i.title + \\\"</strong></big>\\\",\\r\\n        col_type: \\\"rich_text\\\"\\r\\n    }, {\\r\\n        title: i.user.name + \\\" 的剧评\\\",\\r\\n        img: i.user.avatar,\\r\\n        url: i.user.url,\\r\\n        col_type: \\\"avatar\\\"\\r\\n    }, {\\r\\n        title: (i.spoiler ? \\\"<small><font color=#f20c00>这篇影评可能有剧透</font></small><br/>\\\" : \\\"\\\") + (a ? '<small>看过 <font color=' + color + '>' + a + \\\"</font><br/></small>\\\" : \\\"\\\") + '<small><font color=\\\"grey\\\">' + /\\\\d{4}-\\\\d{1,2}-\\\\d{1,2}/g.exec(i.create_time) + \\\"</font></small>\\\",\\r\\n        col_type: \\\"rich_text\\\"\\r\\n    }, {\\r\\n        col_type: \\\"line_blank\\\"\\r\\n    }, {\\r\\n        title: i.content.replace(/<div\\\\s*[^>]*>(.*?)<\\\\/div>/g, \\\"$1\\\") + (i.is_original ? '<small><font color=\\\"grey\\\">&copy;本文版权归该作者所有，任何形式转载请联系作者。</font></small>' : \\\"\\\"),\\r\\n        col_type: \\\"rich_text\\\"\\r\\n    }];\\r\\n\\r\\n    setHomeResult({\\r\\n        data: s.concat(o)\\r\\n    })\\r\\n}\\r\\n\\r\\n//剧评回复页面\\r\\nfunction dramaReviewReplyView(id) {\\r\\n    setPageTitle('回复详情');\\r\\n    let t = getDoubanRes(\\\"https://frodo.douban.com/api/v2/review/comment/\\\" + id + \\\"/replies\\\");\\r\\n    let i = [];\\r\\n    t.replies.forEach((e => {\\r\\n        i.push({\\r\\n            title: e.author.name,\\r\\n            img: e.author.avatar,\\r\\n            url: e.author.url,\\r\\n            col_type: \\\"avatar\\\"\\r\\n        })\\r\\n        i.push({\\r\\n            title: (e.ref_comment.has_ref ? '回复@<font color=\\\"blue\\\">' + e.ref_comment.author.name + \\\"</font>：\\\" : \\\"\\\") + e.text,\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        })\\r\\n        i.push({\\r\\n            col_type: \\\"line\\\"\\r\\n        })\\r\\n    }))\\r\\n\\r\\n    setHomeResult({\\r\\n        data: i\\r\\n    })\\r\\n}\\r\\n\\r\\n//相关推荐页面\\r\\nfunction recommendations(type, id){\\r\\n    setPageTitle('相关推荐');\\r\\n    let res = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\"+ type + \\\"/\\\" + id + \\\"/recommendations\\\");\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    let i = res.map((e => {\\r\\n        let type = e.type,\\r\\n            id = e.id,\\r\\n            title = e.title;\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        return {\\r\\n            title: title,\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra,\\r\\n            col_type: 'movie_3',\\r\\n            img: e.pic ? e.pic.normal + \\\"@Referer=\\\" + e.pic.normal : e.cover.url + '@Referer=' + e.cover.url,\\r\\n            desc: e.null_rating_reason || e.rating.value\\r\\n        }\\r\\n    }));\\r\\n\\r\\n    setHomeResult({\\r\\n        data: i\\r\\n    })\\r\\n}\\r\\n\\r\\n//影片详情页面\\r\\nfunction detailsView(type, id) {\\r\\n    let i = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id);\\r\\n    setPageTitle(i.title);\\r\\n    let info = \\\"\\\";\\r\\n    if (i.is_tv) {\\r\\n        info = [i.countries ? i.countries.join(\\\" \\\") : null, i.genres ? i.genres.join(\\\" \\\") : null, i.pubdate ? i.pubdate[0] + \\\"首播\\\" : null, i.episodes_count ? \\\"共\\\" + i.episodes_count + \\\"集\\\" : null, i.durations ? \\\"单集片长\\\" + i.durations : null].filter((e => null !== e)).join(\\\" / \\\");\\r\\n    } else {\\r\\n        info = [i.countries ? i.countries.join(\\\" \\\") : null, i.genres ? i.genres.join(\\\" \\\") : null, i.pubdate ? i.pubdate[0] + \\\"首播\\\" : null, i.durations ? \\\"片长\\\" + i.durations : null].filter((e => null !== e)).join(\\\" / \\\");\\r\\n    }\\r\\n    let infoItems = [{\\r\\n        title: i.title + \\\"\\\\n\\\" + i.original_title + \\\"(\\\" + i.year + \\\")\\\",\\r\\n        desc: info || i.card_subtitle,\\r\\n        img: i.pic.normal + \\\"@Referer=\\\" + i.pic.normal,\\r\\n        col_type: \\\"movie_1_vertical_pic_blur\\\",\\r\\n        url: 'hiker://page/settingPage?view=analysisSettingModule#noHistory#',\\r\\n        extra: {\\r\\n            newWindow: true,\\r\\n            windowId: '高级功能',\\r\\n            gradient: true\\r\\n        }\\r\\n    }];\\r\\n\\r\\n    let rating = \\\"\\\";\\r\\n    if (i.rating) {\\r\\n        rating = computeRating(i.rating.max, i.rating.value);\\r\\n    }\\r\\n    let ratingItems = [];\\r\\n    let color = getConfig('starColor');\\r\\n    let ratingTitle = ''\\r\\n    if (rating) {\\r\\n        ratingTitle = '豆瓣评分™'.big().bold() + '<br>' + rating.fontcolor(color) + '&nbsp;&nbsp;' + (i.rating.value.toFixed(1) + '分').big().bold();\\r\\n    } else {\\r\\n        ratingTitle = '暂无评分'.big().bold() + '<br>' + '点我查看影片信息'.fontcolor('grey');\\r\\n    }\\r\\n    ratingItems = [{\\r\\n        title: '““””' + ratingTitle,\\r\\n        col_type: \\\"text_center_1\\\",\\r\\n        extra: {\\r\\n            lineVisible: false\\r\\n        },\\r\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((type, id, ratingCount) => {\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            rating(type, id, ratingCount);\\r\\n        }, i.subtype, i.id, i.rating ? i.rating.count : 0)\\r\\n    }];\\r\\n\\r\\n    let relatedItems = [{\\r\\n        title: \\\"剧照\\\",\\r\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧照.png\\\",\\r\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            stillsList(t[0], t[1]);\\r\\n        }, [i.subtype, i.id]),\\r\\n        col_type: \\\"icon_round_small_4\\\"\\r\\n    }, {\\r\\n        title: \\\"演职\\\",\\r\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/演职.png\\\",\\r\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            credits(t[0], t[1]);\\r\\n        }, [i.subtype, i.id]),\\r\\n        col_type: \\\"icon_round_small_4\\\"\\r\\n    }, {\\r\\n        title: \\\"短评\\\",\\r\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/短评.png\\\",\\r\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            shortCommentList(t[0], t[1]);\\r\\n        }, [i.subtype, i.id]),\\r\\n        col_type: \\\"icon_round_small_4\\\"\\r\\n    }, {\\r\\n        title: \\\"剧评\\\",\\r\\n        img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧评.png\\\",\\r\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            dramaReviewList(t[0], t[1]);\\r\\n        }, [i.subtype, i.id]),\\r\\n        col_type: \\\"icon_round_small_4\\\"\\r\\n    }];\\r\\n\\r\\n    let introItems = [];\\r\\n    if (i.intro) {\\r\\n        introItems = [{\\r\\n            title: \\\"““””<big><strong>剧情简介</strong></big>\\\",\\r\\n            col_type: \\\"text_center_1\\\",\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            },\\r\\n            url: 'hiker://empty'\\r\\n        }, {\\r\\n            title: \\\"&nbsp;&nbsp;&nbsp;&nbsp;\\\" + i.intro.replace(/\\\\n/g, \\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\").replace(/\\\\s/g, \\\" \\\").replace(/\\\\t/g, \\\" \\\"),\\r\\n            col_type: \\\"rich_text\\\"\\r\\n        }]\\r\\n    }\\r\\n\\r\\n    let videoRelatedItems = [];\\r\\n    if (i.trailer) {\\r\\n        videoRelatedItems.push({\\r\\n            title: \\\"““””<big><strong>预告</strong></big>\\\",\\r\\n            col_type: \\\"text_center_1\\\",\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            },\\r\\n            url: 'hiker://empty'\\r\\n        });\\r\\n        videoRelatedItems.push({\\r\\n            title: i.trailer.title,\\r\\n            img: i.trailer.cover_url,\\r\\n            url: i.trailer.video_url,\\r\\n            desc: i.trailer.subject_title + \\\"•\\\" + i.trailer.create_time,\\r\\n            col_type: \\\"movie_2\\\"\\r\\n        });\\r\\n        videoRelatedItems.push({\\r\\n            title: '查看更多',\\r\\n            img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/more.png\\\",\\r\\n            col_type: \\\"movie_2\\\",\\r\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                trailers(t[0], t[1]);\\r\\n            }, [i.subtype, i.id]),\\r\\n        });\\r\\n    }\\r\\n    if (i.video) {\\r\\n        videoRelatedItems.push({\\r\\n            title: \\\"““””<big><strong>视频评论</strong></big>\\\",\\r\\n            col_type: \\\"text_center_1\\\",\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            },\\r\\n            url: 'hiker://empty'\\r\\n        });\\r\\n        videoRelatedItems.push({\\r\\n            title: i.video.title,\\r\\n            img: i.video.cover_url + \\\"@Referer=\\\" + i.video.cover_url,\\r\\n            url: i.video.video_url,\\r\\n            desc: i.video.author.name + \\\"•\\\" + i.video.create_time,\\r\\n            col_type: \\\"movie_2\\\"\\r\\n        });\\r\\n        videoRelatedItems.push({\\r\\n            title: '查看更多',\\r\\n            img: \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/more.png\\\",\\r\\n            col_type: \\\"movie_2\\\",\\r\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                videoComment(t[0], t[1]);\\r\\n            }, [i.subtype, i.id]),\\r\\n        });\\r\\n    }\\r\\n\\r\\n    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\r\\n\\r\\n    let analysisConfigs = getConfig('analysisConfigs', config);\\r\\n    let extraConfig = analysisConfigs[analysisConfigs.use].extra || '{}';\\r\\n    let extra = {};\\r\\n    try {\\r\\n        if (extraConfig.startsWith('{')) eval('extra=' + extraConfig);\\r\\n    } catch (e) {}\\r\\n    let videoItems = [];\\r\\n    videoUrlsModule(videoItems, type, id, ['icon_2', 'icon_small_4'], parseVideoUrlLazy, i, extra);\\r\\n    if (videoItems.length > 0) {\\r\\n        videoItems.unshift({\\r\\n            title: \\\"““””<big><strong>在线观看</strong></big>\\\",\\r\\n            col_type: \\\"text_center_1\\\",\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            },\\r\\n            url: 'hiker://empty'\\r\\n        })\\r\\n    } else {\\r\\n        videoItems.unshift({\\r\\n            title: \\\"““””<big><strong>尚无片源</strong></big>\\\",\\r\\n            col_type: \\\"text_center_1\\\",\\r\\n            extra: {\\r\\n                lineVisible: false\\r\\n            },\\r\\n            url: 'toast://真的没片源'\\r\\n        })\\r\\n    }\\r\\n\\r\\n    let quickSearchConfigs = getConfig('quickSearchConfigs', config);\\r\\n    let quickSearchItems = [];\\r\\n    quickSearchConfigs.order.forEach(quickSearchItem => {\\r\\n        if (quickSearchConfigs[quickSearchItem]) {\\r\\n            quickSearchItems.push({\\r\\n                title: quickSearchItem,\\r\\n                img: quickSearchConfigs[quickSearchItem].pic,\\r\\n                col_type: quickSearchConfigs.mode || 'icon_small_4',\\r\\n                url: 'hiker://search?s=' + i.title + '&rule=' + quickSearchConfigs[quickSearchItem].name\\r\\n            })\\r\\n        }\\r\\n    })\\r\\n    if (quickSearchItems.length > 0) {\\r\\n        quickSearchItems.unshift({\\r\\n                title: '““””<strong><big>快速搜索</big></strong>',\\r\\n                col_type: 'text_center_1',\\r\\n                extra: {\\r\\n                    lineVisible: false\\r\\n                },\\r\\n                url: 'hiker://empty'\\r\\n            })\\r\\n            /*quickSearchItems.unshift({\\r\\n                col_type: 'line'\\r\\n            })*/\\r\\n    }\\r\\n\\r\\n    setHomeResult({\\r\\n        data: infoItems.concat(ratingItems)\\r\\n            .concat(relatedItems)\\r\\n            .concat({\\r\\n                col_type: 'line'\\r\\n            })\\r\\n            .concat(quickSearchItems)\\r\\n            .concat({\\r\\n                col_type: 'line'\\r\\n            })\\r\\n            .concat(videoItems)\\r\\n            .concat({\\r\\n                col_type: 'line'\\r\\n            })\\r\\n            .concat(videoRelatedItems)\\r\\n            .concat({\\r\\n                col_type: 'line'\\r\\n            })\\r\\n            .concat(introItems)\\r\\n            .concat({\\r\\n                col_type: 'line',\\r\\n                extra:{\\r\\n                  id: 'recommendations'\\r\\n                }\\r\\n            })\\r\\n            .concat({\\r\\n                col_type: 'text_center_1',\\r\\n                title: '““””<small><font color=#871f78>以上数据来源于豆瓣，如您喜欢，请下载官方app</font></small>',\\r\\n                desc: '““””<small><font color=#f20c00>此规则仅限学习交流使用，请于导入后24小时内删除，任何组织或个人不得以任何方式方法传播此规则的整体或部分！</font></small>',\\r\\n                url: 'https://movie.douban.com/subject/' + id + '/',\\r\\n                extra: {\\r\\n                    lineVisible: false\\r\\n                }\\r\\n            })\\r\\n    })\\r\\n    be([{\\r\\n        func: function(obj){\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            let res = getDoubanRes(obj.url);\\r\\n            \\r\\n            let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n            let l = [res[0],res[1],res[2]];\\r\\n            let i = l.map((e => {\\r\\n                let type = e.type,\\r\\n                    id = e.id,\\r\\n                    title = e.title;\\r\\n                let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n                let urlParams = {};\\r\\n                if (useConfig.startsWith('{')) {\\r\\n                    eval('urlParams = ' + useConfig);\\r\\n                } else {\\r\\n                    urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                        if (type === \\\"playlist\\\") {\\r\\n                            douList(id, MY_PAGE, 50);\\r\\n                        } else {\\r\\n                            eval(useConfig);\\r\\n                        }\\r\\n                    }, type, id, title, useConfig);\\r\\n                }\\r\\n                return {\\r\\n                    title: title,\\r\\n                    url: urlParams.url,\\r\\n                    extra: urlParams.extra,\\r\\n                    img: e.pic ? e.pic.normal + \\\"@Referer=\\\" + e.pic.normal : e.cover.url + '@Referer=' + e.cover.url,\\r\\n                    desc: e.null_rating_reason || e.rating.value\\r\\n                }\\r\\n            }));\\r\\n            addItemAfter('recommendations', i[2]);\\r\\n            addItemAfter('recommendations', i[1]);\\r\\n            addItemAfter('recommendations', i[0]);\\r\\n            addItemAfter('recommendations', {\\r\\n                title: \\\"““””<big><strong>相关推荐</strong></big>\\\",\\r\\n                col_type: \\\"text_center_1\\\",\\r\\n                url: $('hiker://empty/#noHistory#').rule((t) => {\\r\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                    recommendations(t[0], t[1]);\\r\\n                }, [obj.type, obj.id]),\\r\\n                extra: {\\r\\n                    lineVisible: false\\r\\n                }\\r\\n            })\\r\\n            updateItem('recommendations',{col_type: 'line',extra:{id:'nooop'}})\\r\\n        },\\r\\n        param: {\\r\\n            url: \\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id + \\\"/recommendations\\\",\\r\\n            type: type,\\r\\n            id: id\\r\\n        }\\r\\n    }])\\r\\n}\\r\\n\\r\\n//推荐\\r\\nfunction findList(page, count) {\\r\\n    if (!getMyVar('findList')) putMyVar('findList', '{\\\"item\\\":\\\"movie\\\",\\\"playable\\\":\\\"0\\\",\\\"score\\\":\\\"0,10\\\"}');\\r\\n    let a = [];\\r\\n    let temp = JSON.parse(getMyVar('findList'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let items = {\\r\\n        电影: 'movie',\\r\\n        电视剧: 'tv'\\r\\n    }\\r\\n    for (i in items) {\\r\\n        a.push({\\r\\n            title: temp.item === items[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('findList'));\\r\\n                temp.item = e;\\r\\n                putMyVar(\\\"findList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, items[i])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        col_type: 'blank_block'\\r\\n    })\\r\\n\\r\\n    let playable = {\\r\\n        全部影片: '0',\\r\\n        仅有片源: '1'\\r\\n    }\\r\\n    for (let r in playable) {\\r\\n        a.push({\\r\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('findList'));\\r\\n                temp.playable = e;\\r\\n                putMyVar(\\\"findList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, playable[r])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score.replace(',', '-') + ' </font></b>',\\r\\n        col_type: 'scroll_button',\\r\\n        url: $(temp.score.replace(',', '-'), '评分应在0-10之间').input(() => {\\r\\n            let temp = JSON.parse(getMyVar('findList'));\\r\\n            let inputs = input.split('-');\\r\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\r\\n                temp.score = input.replace('-', ',');\\r\\n                putMyVar(\\\"findList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            } else {\\r\\n                return 'toast://请正确输入'\\r\\n            }\\r\\n        })\\r\\n    })\\r\\n\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + temp.item + \\\"/recommend\\\" + '?playable=' + temp.playable + '&score_range=' + temp.score + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=8\\\"));\\r\\n    let l = s.items;\\r\\n    l = l.filter(e => e.type !== \\\"ad\\\" && e.type !== \\\"tags\\\");\\r\\n\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    let i = l.map((e => {\\r\\n        let type = e.type,\\r\\n            id = e.id,\\r\\n            title = e.subtitle || e.title;\\r\\n        let baseUrl = e.type === \\\"playlist\\\" ? 'hiker://empty/$page{fypage}' : 'hiker://empty#immersiveTheme#';\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(baseUrl + \\\"#noHistory#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        return {\\r\\n            title: title + (type === \\\"playlist\\\" ? \\\"\\\" : \\\"（\\\" + e.year + \\\"）\\\"),\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra,\\r\\n            img: e.pic ? e.pic.normal + \\\"@Referer=\\\" + e.pic.normal : e.cover_url + \\\"@Referer=\\\" + e.cover_url,\\r\\n            desc: e.type !== \\\"playlist\\\" ? (e.tags.map((e => e.name)).join(\\\",\\\") + \\\"\\\\n\\\" + (e.rating ? computeRating(e.rating.max, e.rating.value) + \\\" \\\" + e.rating.value.toFixed(1) + \\\"分\\\" : \\\"暂无评分\\\")) : (e.title + \\\"\\\\n\\\" + e.tags.join(\\\",\\\") + \\\"\\\\n共\\\" + e.items_count + \\\"部\\\")\\r\\n        }\\r\\n    }));\\r\\n\\r\\n    return page > 1 ? i : a.concat(i);\\r\\n}\\r\\n\\r\\n//热门\\r\\nfunction hotList(page, count) {\\r\\n    if (!getMyVar('hotList')) putMyVar('hotList', '{\\\"item\\\":\\\"movie_showing?area=全部\\\",\\\"playable\\\":\\\"0\\\",\\\"sort\\\":\\\"recommend\\\",\\\"score\\\":\\\"0,10\\\"}');\\r\\n    let a = [];\\r\\n    let temp = JSON.parse(getMyVar('hotList'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let items = {\\r\\n        电影: {\\r\\n            影院热映电影: 'movie_showing?area=全部',\\r\\n            豆瓣热门电影: 'hot_gaia?area=全部',\\r\\n            热门华语电影: 'hot_gaia?area=华语',\\r\\n            热门欧美电影: 'hot_gaia?area=欧美',\\r\\n            热门韩国电影: 'hot_gaia?area=韩国',\\r\\n            热门日本电影: 'hot_gaia?area=日本'\\r\\n        },\\r\\n        电视剧: {\\r\\n            热播电视剧: 'tv_hot',\\r\\n            热播国产剧: 'tv_domestic',\\r\\n            热播欧美剧: 'tv_american',\\r\\n            热播日剧: 'tv_japanese',\\r\\n            热播韩剧: 'tv_korean',\\r\\n            热播动画: 'tv_animation'\\r\\n        },\\r\\n        综艺: {\\r\\n            热播综艺: 'show_hot',\\r\\n            国内综艺: 'show_domestic',\\r\\n            国外综艺: 'show_foreign'\\r\\n        }\\r\\n    }\\r\\n    for (let i in items) {\\r\\n        for (let j in items[i]) {\\r\\n            a.push({\\r\\n                title: temp.item == items[i][j] ? '““””<b> <font color=' + color + '>' + j + ' </font></b>' : j,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                    let temp = JSON.parse(getMyVar('hotList'));\\r\\n                    temp.item = e;\\r\\n                    putMyVar('hotList', JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, items[i][j])\\r\\n            })\\r\\n        }\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n    }\\r\\n\\r\\n    let sort = {\\r\\n        热度排序: 'recommend',\\r\\n        时间排序: 'time',\\r\\n        评分排序: 'rank'\\r\\n    }\\r\\n    for (let r in sort) {\\r\\n        a.push({\\r\\n            title: temp.sort == sort[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('hotList'));\\r\\n                temp.sort = e;\\r\\n                putMyVar(\\\"hotList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, sort[r])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        col_type: \\\"blank_block\\\"\\r\\n    })\\r\\n\\r\\n    let playable = {\\r\\n        全部影片: '0',\\r\\n        仅有片源: '1'\\r\\n    }\\r\\n    for (let r in playable) {\\r\\n        a.push({\\r\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('hotList'));\\r\\n                temp.playable = e;\\r\\n                putMyVar(\\\"hotList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, playable[r])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score.replace(',', '-') + ' </font></b>',\\r\\n        col_type: 'scroll_button',\\r\\n        url: $(temp.score.replace(',', '-'), '评分应在0-10之间').input(() => {\\r\\n            let temp = JSON.parse(getMyVar('hotList'));\\r\\n            let inputs = input.split('-');\\r\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\r\\n                temp.score = input.replace('-', ',');\\r\\n                putMyVar(\\\"hotList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            } else {\\r\\n                return 'toast://请正确输入'\\r\\n            }\\r\\n        })\\r\\n    })\\r\\n\\r\\n    let l = [];\\r\\n    if (temp.item.indexOf('?') != -1) {\\r\\n        let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/movie/\\\" + temp.item + '&playable=' + temp.playable + '&sort=' + temp.sort + '&score_range=' + temp.score + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=30\\\") + '&loc_id=108288');\\r\\n        l = s.items;\\r\\n    } else {\\r\\n        let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/subject_collection/\\\" + temp.item + '/items' + '?playable=' + temp.playable + '&sort=' + temp.sort + '&score_range=' + temp.score + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=30\\\"));\\r\\n        l = s.subject_collection_items;\\r\\n    }\\r\\n\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    let i = l.map((e => {\\r\\n        let type = e.type,\\r\\n            id = e.id,\\r\\n            title = e.title;\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        return {\\r\\n            title: title + \\\"（\\\" + e.year + \\\"）\\\",\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra,\\r\\n            img: e.pic ? e.pic.normal + \\\"@Referer=\\\" + e.pic.normal : e.cover.url + '@Referer=' + e.cover.url,\\r\\n            desc: (e.tags ? e.tags.map((e => e.name)).join(\\\",\\\") : e.card_subtitle) + \\\"\\\\n\\\" + (e.rating ? computeRating(e.rating.max, e.rating.value) + \\\" \\\" + e.rating.value.toFixed(1) + \\\"分\\\" : \\\"暂无评分\\\")\\r\\n        }\\r\\n    }));\\r\\n\\r\\n    return page > 1 ? i : a.concat(i);\\r\\n}\\r\\n\\r\\n//分类\\r\\nfunction classList(page, count) {\\r\\n    if (!getMyVar('classlist')){\\r\\n        putMyVar('classlist', JSON.stringify({subtype:\\\"\\\",local:\\\"\\\",year:\\\"\\\",class:\\\"\\\",rank:\\\"U\\\",type:\\\"\\\",filter:\\\"\\\",score:\\\"0,10\\\"}));\\r\\n    }\\r\\n    let a = [];\\r\\n    let temp = JSON.parse(getMyVar('classlist'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let items = {\\r\\n        subtype: [\\\"全部形式\\\", \\\"电影\\\", \\\"电视剧\\\", \\\"综艺\\\", \\\"动漫\\\", \\\"纪录片\\\", \\\"短片\\\"],\\r\\n        local: [\\\"全部地区\\\", \\\"自定义地区\\\", \\\"中国大陆\\\", \\\"美国\\\", \\\"中国香港\\\", \\\"中国台湾\\\", \\\"日本\\\", \\\"韩国\\\", \\\"英国\\\", \\\"法国\\\", \\\"德国\\\", \\\"意大利\\\", \\\"西班牙\\\", \\\"印度\\\", \\\"泰国\\\", \\\"俄罗斯\\\", \\\"伊朗\\\", \\\"加拿大\\\", \\\"澳大利亚\\\", \\\"爱尔兰\\\", \\\"瑞典\\\", \\\"巴西\\\", \\\"丹麦\\\"],\\r\\n        type: [\\\"全部类型\\\", \\\"自定义类型\\\", \\\"剧情\\\", \\\"喜剧\\\", \\\"动作\\\", \\\"爱情\\\", \\\"科幻\\\", \\\"动画\\\", \\\"悬疑\\\", \\\"惊悚\\\", \\\"恐怖\\\", \\\"犯罪\\\", \\\"同性\\\", \\\"音乐\\\", \\\"歌舞\\\", \\\"传记\\\", \\\"历史\\\", \\\"战争\\\", \\\"西部\\\", \\\"奇幻\\\", \\\"冒险\\\", \\\"灾难\\\", \\\"武侠\\\", \\\"\\\\u60c5\\\\u8272\\\"],\\r\\n        year: [\\\"全部年代\\\", \\\"自定义年份\\\", \\\"2020年代\\\", \\\"2010年代\\\", \\\"2000年代\\\", \\\"90年代\\\", \\\"80年代\\\", \\\"70年代\\\", \\\"60年代\\\", \\\"更早\\\"],\\r\\n        class: [\\\"全部特色\\\", \\\"自定义标签\\\", \\\"经典\\\", \\\"青春\\\", \\\"文艺\\\", \\\"搞笑\\\", \\\"励志\\\", \\\"魔幻\\\", \\\"感人\\\", \\\"女性\\\", \\\"黑帮\\\", \\\"治愈\\\", \\\"美食\\\", \\\"宗教\\\", \\\"小说改编\\\", \\\"超级英雄\\\"]\\r\\n    }\\r\\n    for (item in items) {\\r\\n        for (let i = 0; i < items[item].length; i++) {\\r\\n            let title = \\\"\\\";\\r\\n            if(temp[item] == items[item][i] || (temp[item] == \\\"\\\" && i == 0)){\\r\\n                title = '““””<b> <font color=' + color + '>' + items[item][i] + ' </font></b>';\\r\\n            }else{\\r\\n                title = items[item][i];\\r\\n            }\\r\\n            let url = $('hiker://empty#noLoading#').lazyRule((text,item) => {\\r\\n                        let temp = JSON.parse(getMyVar('classlist'));\\r\\n                        temp[item] = text.indexOf(\\\"全部\\\") != -1 ? \\\"\\\" : text;\\r\\n                        putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                        refreshPage();\\r\\n                        return 'hiker://empty'\\r\\n                    }, items[item][i], item);\\r\\n            \\r\\n            if(items[item][i] == \\\"自定义年份\\\"){\\r\\n                if(temp.year == \\\"自定义年份\\\"){\\r\\n                    title = '““””<b> <font color=' + color + '>自定义年份:' + temp.customYear + ' </font></b>';\\r\\n                }\\r\\n                \\r\\n                url = $(temp.customYear, '直接输入具体年份,例如2000').input(() => {\\r\\n                    let temp = JSON.parse(getMyVar('classlist'));\\r\\n                    if(input.length == 4){\\r\\n                        temp.customYear = input;\\r\\n                        temp.year = \\\"自定义年份\\\";\\r\\n                        putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                        refreshPage();\\r\\n                        return 'hiker://empty'\\r\\n                    }else{\\r\\n                        return 'toast://请正确输入'\\r\\n                    }\\r\\n                });\\r\\n            }else if(items[item][i] == \\\"自定义地区\\\"){\\r\\n                if(temp.local == \\\"自定义地区\\\"){\\r\\n                    title = '““””<b> <font color=' + color + '>自定义地区:' + temp.customLocal + ' </font></b>';\\r\\n                }\\r\\n                \\r\\n                url = $(temp.customLocal, '直接输入具体地区,例如中国大陆').input(() => {\\r\\n                    let temp = JSON.parse(getMyVar('classlist'));\\r\\n                    if(input.length > 0){\\r\\n                        temp.customLocal = input;\\r\\n                        temp.local = \\\"自定义地区\\\";\\r\\n                        putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                        refreshPage();\\r\\n                        return 'hiker://empty'\\r\\n                    }else{\\r\\n                        return 'toast://请正确输入'\\r\\n                    }\\r\\n                });\\r\\n            }else if(items[item][i] == \\\"自定义类型\\\"){\\r\\n                if(temp.type == \\\"自定义类型\\\"){\\r\\n                    title = '““””<b> <font color=' + color + '>自定义类型:' + temp.customType + ' </font></b>';\\r\\n                }\\r\\n                \\r\\n                url = $(temp.customType, '直接输入具体类型,例如剧情').input(() => {\\r\\n                    let temp = JSON.parse(getMyVar('classlist'));\\r\\n                    if(input.length > 0){\\r\\n                        temp.customType = input;\\r\\n                        temp.type = \\\"自定义类型\\\";\\r\\n                        putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                        refreshPage();\\r\\n                        return 'hiker://empty'\\r\\n                    }else{\\r\\n                        return 'toast://请正确输入'\\r\\n                    }\\r\\n                });\\r\\n            }else if(items[item][i] == \\\"自定义标签\\\"){\\r\\n                if(temp.class == \\\"自定义标签\\\"){\\r\\n                    title = '““””<b> <font color=' + color + '>自定义标签:' + temp.customClass + ' </font></b>';\\r\\n                }\\r\\n                \\r\\n                url = $(temp.customClass, '直接输入具体标签,例如经典\\\\n可写多个标签,使用\\\"英文逗号\\\"分隔').input(() => {\\r\\n                    let temp = JSON.parse(getMyVar('classlist'));\\r\\n                    if(input.length > 0){\\r\\n                        temp.customClass = input;\\r\\n                        temp.class = \\\"自定义标签\\\";\\r\\n                        putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                        refreshPage();\\r\\n                        return 'hiker://empty'\\r\\n                    }else{\\r\\n                        return 'toast://请正确输入'\\r\\n                    }\\r\\n                });\\r\\n            }\\r\\n            a.push({\\r\\n                title: title,\\r\\n                col_type: 'scroll_button',\\r\\n                url: url\\r\\n            })\\r\\n        }\\r\\n        a.push({\\r\\n            col_type: 'blank_block'\\r\\n        })\\r\\n    }\\r\\n\\r\\n    let rank = {\\r\\n        默认排序: \\\"U\\\",\\r\\n        热度: \\\"T\\\",\\r\\n        评分: \\\"S\\\",\\r\\n        时间: \\\"R\\\"\\r\\n    }\\r\\n    for (let r in rank) {\\r\\n        a.push({\\r\\n            title: temp.rank === rank[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('classlist'));\\r\\n                temp.rank = e;\\r\\n                putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, rank[r])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        col_type: 'blank_block'\\r\\n    })\\r\\n\\r\\n    let filter = {\\r\\n        全部影片: '',\\r\\n        仅有片源: 'playable'\\r\\n    }\\r\\n    for (let r in filter) {\\r\\n        a.push({\\r\\n            title: temp.filter === filter[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('classlist'));\\r\\n                temp.filter = e;\\r\\n                putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, filter[r])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score.replace(',', '-') + ' </font></b>',\\r\\n        col_type: 'scroll_button',\\r\\n        url: $(temp.score.replace(',', '-'), '评分应在0-10之间').input(() => {\\r\\n            let temp = JSON.parse(getMyVar('classlist'));\\r\\n            let inputs = input.split('-');\\r\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\r\\n                temp.score = input.replace('-', ',');\\r\\n                putMyVar(\\\"classlist\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            } else {\\r\\n                return 'toast://请正确输入'\\r\\n            }\\r\\n        })\\r\\n    })\\r\\n\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/movie/tag?\\\"\\r\\n            + (page ? \\\"start=\\\" + (page - 1) * count\\r\\n            + \\\"&count=\\\" + count : \\\"start=0&count=30\\\")\\r\\n            + \\\"&q=\\\" + temp.subtype\\r\\n            + \\\",\\\" + (temp.local==\\\"自定义地区\\\" ? temp.customLocal : temp.local)\\r\\n            + \\\",\\\" + (temp.type==\\\"自定义类型\\\" ? temp.customType : temp.type)\\r\\n            + \\\",\\\" + (temp.year==\\\"自定义年份\\\" ? temp.customYear : temp.year)\\r\\n            + \\\",\\\" + (temp.class==\\\"自定义标签\\\" ? temp.customClass : temp.class)\\r\\n            + \\\"&sort=\\\" + temp.rank + \\\"&score_range=\\\" + temp.score + '&filter=' + temp.filter);\\r\\n    let l = s.data;\\r\\n\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    let i = l.map((e => {\\r\\n        let type = e.type,\\r\\n            id = e.id,\\r\\n            title = e.title;\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        return {\\r\\n            title: title,\\r\\n            col_type: 'movie_3',\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra,\\r\\n            img: e.cover_url + \\\"@Referer=\\\" + e.cover_url,\\r\\n            desc: e.null_rating_reason || e.rating.value\\r\\n        }\\r\\n    }));\\r\\n\\r\\n    return page > 1 ? i : a.concat(i);\\r\\n}\\r\\n\\r\\n//片单\\r\\nfunction playList(page, count) {\\r\\n    if (!getMyVar('playlist')) putMyVar('playlist', '{\\\"subtype\\\":\\\"\\\",\\\"type\\\":\\\"all\\\"}');\\r\\n    let a = [];\\r\\n    let temp = JSON.parse(getMyVar('playlist', '{\\\"subtype\\\":\\\"\\\",\\\"type\\\":\\\"all\\\"}'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let items = {\\r\\n        type: {\\r\\n            全部: \\\"all\\\",\\r\\n            豆瓣片单: \\\"official\\\",\\r\\n            精选: \\\"selected\\\",\\r\\n            经典: \\\"classical\\\",\\r\\n            获奖: \\\"prize\\\",\\r\\n            高分: \\\"high_score\\\",\\r\\n            榜单: \\\"movie_list\\\",\\r\\n            冷门佳片: \\\"dark_horse\\\",\\r\\n            主题: \\\"topic\\\",\\r\\n            导演: \\\"director\\\",\\r\\n            演员: \\\"actor\\\",\\r\\n            系列: \\\"series\\\",\\r\\n            华语: \\\"chinese\\\",\\r\\n            欧美: \\\"western\\\",\\r\\n            日本: \\\"japanese\\\",\\r\\n            韩国: \\\"korea\\\",\\r\\n            喜剧: \\\"comedy\\\",\\r\\n            动作: \\\"action\\\",\\r\\n            爱情: \\\"love\\\",\\r\\n            科幻: \\\"science_fiction\\\",\\r\\n            动画: \\\"cartoon\\\",\\r\\n            悬疑: \\\"mystery\\\",\\r\\n            惊悚: \\\"panic\\\",\\r\\n            恐怖: \\\"horrible\\\",\\r\\n            犯罪: \\\"criminal\\\",\\r\\n            同性: \\\"lgbt\\\",\\r\\n            战争: \\\"war\\\",\\r\\n            奇幻: \\\"fantasy\\\",\\r\\n            \\\"\\\\u60c5\\\\u8272\\\": \\\"erotica\\\",\\r\\n            音乐: \\\"music\\\",\\r\\n            纪录片: \\\"documentary\\\",\\r\\n            治愈: \\\"cure\\\",\\r\\n            艺术: \\\"art\\\",\\r\\n            黑色幽默: \\\"dark_humor\\\",\\r\\n            青春: \\\"youth\\\",\\r\\n            女性: \\\"female\\\",\\r\\n            真实事件改编: \\\"real_event\\\",\\r\\n            暴力: \\\"violence\\\",\\r\\n            黑白: \\\"black_white\\\",\\r\\n            美食: \\\"food\\\",\\r\\n            旅行: \\\"travel\\\",\\r\\n            儿童: \\\"child\\\",\\r\\n            人性: \\\"humanity\\\",\\r\\n            家庭: \\\"family\\\",\\r\\n            文艺: \\\"literary_art\\\",\\r\\n            小说改编: \\\"novel\\\",\\r\\n            感人: \\\"moving\\\",\\r\\n            励志: \\\"inspiration\\\"\\r\\n        },\\r\\n        subtype: {\\r\\n            全部: \\\"\\\",\\r\\n            电影: \\\"movie\\\",\\r\\n            电视剧: \\\"tv\\\"\\r\\n        }\\r\\n    }\\r\\n    for (let i in items) {\\r\\n        for (let j in items[i]) {\\r\\n            a.push({\\r\\n                title: temp[i] === items[i][j] ? '““””<b> <font color=' + color + '>' + j + ' </font></b>' : j,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((t) => {\\r\\n                    let temp = JSON.parse(getMyVar('playlist', '{\\\"subtype\\\":\\\"\\\",\\\"type\\\":\\\"all\\\"}'));\\r\\n                    temp[t[0]] = t[1];\\r\\n                    putMyVar(\\\"playlist\\\", JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, [i, items[i][j]])\\r\\n            })\\r\\n        }\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n    }\\r\\n\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/skynet/new_playlists\\\" + \\\"?category=\\\" + temp.type + \\\"&subject_type=\\\" + temp.subtype + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=10\\\"));\\r\\n    let l = s.data[0].items;\\r\\n\\r\\n    let i = l.map((e => ({\\r\\n        title: e.title,\\r\\n        url: $('hiker://empty/$page{fypage}#noHistory#').rule((type, id) => {\\r\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n            if (type === \\\"playlist\\\") {\\r\\n                douList(id, MY_PAGE, 50);\\r\\n            } else {\\r\\n                subjectCollectionList(MY_PAGE, 50, id);\\r\\n            }\\r\\n        }, e.type, e.id),\\r\\n        img: e.cover_url + \\\"@Referer=\\\" + e.cover_url,\\r\\n        desc: \\\"共\\\" + e.items_count + \\\"部\\\"\\r\\n    })));\\r\\n\\r\\n    return page > 1 ? i : a.concat(i);\\r\\n}\\r\\n\\r\\n//榜单\\r\\nfunction rankList(page, count) {\\r\\n    if (!getMyVar('rankList')) putMyVar('rankList', '{\\\"type\\\":\\\"movie\\\",\\\"list\\\":\\\"rank_list\\\",\\\"year_lists\\\":[],\\\"category_lists\\\":[],\\\"year\\\":\\\"\\\",\\\"category\\\":\\\"\\\"}');\\r\\n    let a = [];\\r\\n    let temp = JSON.parse(getMyVar('rankList'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let items = {\\r\\n        电影: 'movie',\\r\\n        电视剧: 'tv'\\r\\n    }\\r\\n    for (let i in items) {\\r\\n        a.push({\\r\\n            title: temp.type == items[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('rankList'));\\r\\n                temp.type = e;\\r\\n                putMyVar(\\\"rankList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, items[i])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        col_type: \\\"blank_block\\\"\\r\\n    })\\r\\n\\r\\n    let list = {\\r\\n        口碑榜单: 'rank_list',\\r\\n        年度榜单: 'year_ranks',\\r\\n        类型榜单: 'category_ranks'\\r\\n    }\\r\\n    for (let i in list) {\\r\\n        a.push({\\r\\n            title: temp.list == list[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('rankList'));\\r\\n                temp.list = e;\\r\\n                putMyVar(\\\"rankList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, list[i])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    if (temp.list == 'year_ranks' && temp.year_lists.length == 0) {\\r\\n        let t = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + temp.type + '/rank_list');\\r\\n        temp.year_lists = t.groups[1].tabs;\\r\\n        putMyVar('rankList', JSON.stringify(temp));\\r\\n    } else if (temp.list == 'category_ranks' && temp.category_lists.length == 0) {\\r\\n        let t = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + temp.type + '/rank_list');\\r\\n        temp.category_lists = t.groups[2].tabs;\\r\\n        putMyVar('rankList', JSON.stringify(temp));\\r\\n    }\\r\\n\\r\\n    if (temp.list == 'year_ranks') {\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        if (!temp.year) temp.year = temp.year_lists[0].key;\\r\\n        for (let t of temp.year_lists) {\\r\\n            a.push({\\r\\n                title: temp.year == t.key ? '““””<b> <font color=' + color + '>' + t.title + ' </font></b>' : t.title,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                    let temp = JSON.parse(getMyVar('rankList'));\\r\\n                    temp.year = e;\\r\\n                    putMyVar(\\\"rankList\\\", JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, t.key)\\r\\n            })\\r\\n        }\\r\\n    } else if (temp.list == 'category_ranks') {\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        if (!temp.category) temp.category = temp.category_lists[0].key;\\r\\n        for (let t of temp.category_lists) {\\r\\n            a.push({\\r\\n                title: temp.category == t.key ? '““””<b> <font color=' + color + '>' + t.title + ' </font></b>' : t.title,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                    let temp = JSON.parse(getMyVar('rankList'));\\r\\n                    temp.category = e;\\r\\n                    putMyVar(\\\"rankList\\\", JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, t.key)\\r\\n            })\\r\\n        }\\r\\n    }\\r\\n\\r\\n    let l = [];\\r\\n    if (temp.list == 'rank_list' && MY_PAGE == 1) {\\r\\n        let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + temp.type + '/' + temp.list + (page ? \\\"?start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"?start=0&count=10\\\"));\\r\\n        l = s.groups[0].selected_collections;\\r\\n    } else if (temp.list == 'year_ranks' && MY_PAGE == 1) {\\r\\n        let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + temp.type + '/' + temp.list + '?year=' + temp.year + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=10\\\"));\\r\\n        l = s.groups[0].selected_collections;\\r\\n    } else if (temp.list == 'category_ranks') {\\r\\n        let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + temp.type + '/' + temp.list + '?category=' + temp.category + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=10\\\"));\\r\\n        l = s.selected_collections;\\r\\n    }\\r\\n\\r\\n    let i = [];\\r\\n    if (temp.list == 'category_ranks') {\\r\\n        i = l.map((e => ({\\r\\n            title: '““””' + e.title.bold(),\\r\\n            url: $('hiker://empty/$page{fypage}#noHistory#').rule((type, id) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    subjectCollectionList(MY_PAGE, 50, id);\\r\\n                }\\r\\n            }, e.type, e.id),\\r\\n            img: e.cover_url + \\\"@Referer=\\\" + e.cover_url,\\r\\n            desc: \\\"共\\\" + e.total + \\\"部\\\"\\r\\n        })));\\r\\n    } else {\\r\\n        i = l.map((e => ({\\r\\n            title: '' /*'““””' + e.medium_name + '\\\\n' + getStrongText(e.title)*/ ,\\r\\n            col_type: 'card_pic_2',\\r\\n            url: $('hiker://empty/$page{fypage}#noHistory#').rule((type, id, stitle) => {\\r\\n                setPageTitle(stitle);\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    subjectCollectionList(MY_PAGE, 50, id);\\r\\n                }\\r\\n            }, e.type, e.id, e.title),\\r\\n            img: e.cover_url + \\\"@Referer=\\\" + e.cover_url,\\r\\n            desc: \\\"0\\\"\\r\\n        })));\\r\\n    }\\r\\n\\r\\n    return page > 1 ? i : a.concat(i);\\r\\n}\\r\\n\\r\\n//将上映\\r\\nfunction comingList(page, count) {\\r\\n    if (!getMyVar('coming')) putMyVar('coming', '{\\\"type\\\":\\\"movie\\\",\\\"rank\\\":\\\"&sortby=hot\\\",\\\"local\\\":\\\"domestic\\\",\\\"area\\\":\\\"\\\",\\\"filter\\\":\\\"\\\"}');\\r\\n    let a = [];\\r\\n    let temp = JSON.parse(getMyVar('coming'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let items = {\\r\\n        电影: 'movie',\\r\\n        电视剧: 'tv'\\r\\n    }\\r\\n    for (let i in items) {\\r\\n        a.push({\\r\\n            title: temp.type === items[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('coming'));\\r\\n                temp.type = e;\\r\\n                putMyVar(\\\"coming\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, items[i])\\r\\n        })\\r\\n    }\\r\\n    let rank = {\\r\\n        热度: '&sortby=hot',\\r\\n        时间: ''\\r\\n    }\\r\\n    a.push({\\r\\n        col_type: \\\"blank_block\\\"\\r\\n    })\\r\\n    for (let i in rank) {\\r\\n        a.push({\\r\\n            title: temp.rank === rank[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('coming'));\\r\\n                temp.rank = e;\\r\\n                putMyVar(\\\"coming\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, rank[i])\\r\\n        })\\r\\n    }\\r\\n    let local = {\\r\\n        国内: 'domestic',\\r\\n        全球: 'international'\\r\\n    }\\r\\n    if (temp.type == 'movie') {\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        for (let i in local) {\\r\\n            a.push({\\r\\n                title: temp.local === local[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                    let temp = JSON.parse(getMyVar('coming'));\\r\\n                    temp.local = e;\\r\\n                    putMyVar(\\\"coming\\\", JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, local[i])\\r\\n            })\\r\\n        }\\r\\n    }\\r\\n    let area = {\\r\\n        全部: '',\\r\\n        美国: '&area_filter=american',\\r\\n        欧洲: '&area_filter=europe',\\r\\n        日本: '&area_filter=japanese',\\r\\n        韩国: '&area_filter=korean'\\r\\n    }\\r\\n    if (temp.type == 'movie' && temp.local == 'international') {\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        for (let i in area) {\\r\\n            a.push({\\r\\n                title: temp.area === area[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                    let temp = JSON.parse(getMyVar('coming'));\\r\\n                    temp.area = e;\\r\\n                    putMyVar(\\\"coming\\\", JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, area[i])\\r\\n            })\\r\\n        }\\r\\n    }\\r\\n    let filter = {\\r\\n        全部: '',\\r\\n        国产剧: '&type_filter=tv_domestic',\\r\\n        欧美剧: '&type_filter=tv_american',\\r\\n        日剧: '&type_filter=tv_japanese',\\r\\n        韩剧: '&type_filter=tv_korean',\\r\\n        动画: '&type_filter=tv_animation',\\r\\n        国内综艺: '&type_filter=show_domestic',\\r\\n        国外综艺: '&type_filter=show_foreign'\\r\\n    }\\r\\n    if (temp.type == 'tv') {\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n        for (let i in filter) {\\r\\n            a.push({\\r\\n                title: temp.filter === filter[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                    let temp = JSON.parse(getMyVar('coming'));\\r\\n                    temp.filter = e;\\r\\n                    putMyVar(\\\"coming\\\", JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, filter[i])\\r\\n            })\\r\\n        }\\r\\n    }\\r\\n\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + temp.type + \\\"/coming_soon\\\" + \\\"?area=\\\" + temp.local + temp.rank + temp.area + temp.filter + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=10\\\"));\\r\\n    let l = s.subjects;\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n\\r\\n    let i = l.map((e => {\\r\\n        let type = e.type,\\r\\n            id = e.id,\\r\\n            title = e.title;\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        return {\\r\\n            title: title + \\\"（\\\" + e.year + \\\"）\\\",\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra,\\r\\n            img: e.cover_url + \\\"@Referer=\\\" + e.cover_url,\\r\\n            desc: \\\"上映日期:\\\" + e.pubdate + \\\"\\\\n\\\" + e.wish_count + \\\"人想看\\\" + \\\"\\\\n\\\" + e.null_rating_reason\\r\\n        }\\r\\n    }));\\r\\n\\r\\n    return page > 1 ? i : a.concat(i);\\r\\n}\\r\\n\\r\\n//片单详情\\r\\nfunction subjectCollectionList(page, count, id) {\\r\\n    if (!getMyVar('ranking')) putMyVar('ranking', '{\\\"item\\\":\\\"movie_real_time_hotest\\\",\\\"playable\\\":\\\"0\\\",\\\"score\\\":\\\"0-10\\\"}');\\r\\n    let a = [];\\r\\n    let temp = JSON.parse(getMyVar('ranking'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let items = {\\r\\n        电影: {\\r\\n            实时热门电影: 'movie_real_time_hotest',\\r\\n            一周口碑电影: 'movie_weekly_best',\\r\\n            top250电影: 'movie_top250'\\r\\n        },\\r\\n        电视剧: {\\r\\n            实时热门剧集: 'tv_real_time_hotest',\\r\\n            华语口碑剧集: 'tv_chinese_best_weekly',\\r\\n            全球口碑剧集: 'tv_global_best_weekly'\\r\\n        },\\r\\n        综艺: {\\r\\n            国内口碑综艺: 'show_chinese_best_weekly',\\r\\n            国外口碑综艺: 'show_global_best_weekly'\\r\\n        }\\r\\n    }\\r\\n    for (let i in items) {\\r\\n        for (let j in items[i]) {\\r\\n            a.push({\\r\\n                title: temp.item == items[i][j] ? '““””<b> <font color=' + color + '>' + j + ' </font></b>' : j,\\r\\n                col_type: 'scroll_button',\\r\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\r\\n                    let temp = JSON.parse(getMyVar('ranking'));\\r\\n                    temp.item = e;\\r\\n                    putMyVar(\\\"ranking\\\", JSON.stringify(temp));\\r\\n                    refreshPage();\\r\\n                    return 'hiker://empty'\\r\\n                }, items[i][j])\\r\\n            })\\r\\n        }\\r\\n        a.push({\\r\\n            col_type: \\\"blank_block\\\"\\r\\n        })\\r\\n    }\\r\\n\\r\\n    a.push({\\r\\n        col_type: 'blank_block'\\r\\n    })\\r\\n\\r\\n    let i = [];\\r\\n    let playable = {\\r\\n        全部影片: '0',\\r\\n        仅有片源: '1'\\r\\n    }\\r\\n    for (let r in playable) {\\r\\n        i.push({\\r\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('ranking'));\\r\\n                temp.playable = e;\\r\\n                putMyVar(\\\"ranking\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, playable[r])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    i.push({\\r\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score + ' </font></b>',\\r\\n        col_type: 'scroll_button',\\r\\n        url: $(temp.score, '评分应在0-10之间').input(() => {\\r\\n            let temp = JSON.parse(getMyVar('ranking'));\\r\\n            let inputs = input.split('-');\\r\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\r\\n                temp.score = input;\\r\\n                putMyVar(\\\"ranking\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            } else {\\r\\n                return 'toast://请正确输入'\\r\\n            }\\r\\n        })\\r\\n    })\\r\\n\\r\\n    let t = getDoubanRes(\\\"https://frodo.douban.com/api/v2/subject_collection/\\\" + (id || temp.item));\\r\\n    i.push({\\r\\n        title: t.title + '(共' + t.total + '部)',\\r\\n        desc: t.description,\\r\\n        /*img: t.header_bg_image + \\\"@Referer=\\\" + t.header_bg_image,\\r\\n        url: t.header_bg_image + \\\"?type=.jpg@Referer=\\\" + t.header_bg_image + \\\"?type=.jpg\\\",*/\\r\\n        url: 'toast://点我干嘛',\\r\\n        col_type: \\\"text_1\\\"\\r\\n    })\\r\\n\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/subject_collection/\\\" + (id || temp.item) + \\\"/items?\\\" + (page ? \\\"start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"start=0&count=50\\\"));\\r\\n    let l = s.subject_collection_items;\\r\\n    if (temp.playable == '1') l = l.filter(e => !!e.has_linewatch);\\r\\n    if (temp.score != '0-10') {\\r\\n        l = l.filter(e => {\\r\\n            let r = temp.score.split('-');\\r\\n            return e.rating && e.rating.value < r[1] && e.rating.value > r[0];\\r\\n        });\\r\\n    }\\r\\n\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    let r = l.map((e => {\\r\\n        let type = e.type,\\r\\n            id = e.id,\\r\\n            title = e.title;\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        return {\\r\\n            title: title,\\r\\n            col_type: 'movie_1_vertical_pic',\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra,\\r\\n            img: e.pic.normal + \\\"@Referer=\\\" + e.pic.normal,\\r\\n            desc: e.card_subtitle.split(\\\"/\\\").filter(((e, t) => {\\r\\n                if (t < 3) return e\\r\\n            })).join(\\\",\\\") + \\\"\\\\n\\\" + (e.rating ? computeRating(e.rating.max, e.rating.value) + \\\" \\\" + e.rating.value.toFixed(1) + \\\"分\\\" : \\\"暂无评分\\\")\\r\\n        }\\r\\n    }));\\r\\n\\r\\n    setHomeResult({\\r\\n        data: page > 1 ? r : (id ? i.concat(r) : a.concat(i).concat(r))\\r\\n    })\\r\\n}\\r\\n\\r\\n//豆列详情\\r\\nfunction douList(id, page, count) {\\r\\n    addListener('onClose', 'clearMyVar(\\\"douList\\\")');\\r\\n    if (!getMyVar('douList')) putMyVar('douList', '{\\\"playable\\\":\\\"0\\\",\\\"score\\\":\\\"0-10\\\"}');\\r\\n    let i = [];\\r\\n    let temp = JSON.parse(getMyVar('douList'));\\r\\n    let color = getConfig('chooseColor');\\r\\n\\r\\n    let playable = {\\r\\n        全部影片: '0',\\r\\n        仅有片源: '1'\\r\\n    }\\r\\n    for (let r in playable) {\\r\\n        i.push({\\r\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\r\\n            col_type: 'scroll_button',\\r\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\r\\n                let temp = JSON.parse(getMyVar('douList'));\\r\\n                temp.playable = e;\\r\\n                putMyVar(\\\"douList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            }, playable[r])\\r\\n        })\\r\\n    }\\r\\n\\r\\n    i.push({\\r\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score + ' </font></b>',\\r\\n        col_type: 'scroll_button',\\r\\n        url: $(temp.score, '评分应在0-10之间').input(() => {\\r\\n            let temp = JSON.parse(getMyVar('douList'));\\r\\n            let inputs = input.split('-');\\r\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\r\\n                temp.score = input;\\r\\n                putMyVar(\\\"douList\\\", JSON.stringify(temp));\\r\\n                refreshPage();\\r\\n                return 'hiker://empty'\\r\\n            } else {\\r\\n                return 'toast://请正确输入'\\r\\n            }\\r\\n        })\\r\\n    })\\r\\n\\r\\n    let t = getDoubanRes(\\\"https://frodo.douban.com/api/v2/doulist/\\\" + id);\\r\\n    i.push({\\r\\n        title: t.title,\\r\\n        desc: '共' + t.items_count + '部(' + t.playable_count + '部可播放)',\\r\\n        /*img: t.header_bg_image + \\\"@Referer=\\\" + t.header_bg_image,\\r\\n        url: t.header_bg_image + \\\"?type=.jpg@Referer=\\\" + t.header_bg_image + \\\"?type=.jpg\\\",*/\\r\\n        url: 'toast://别点我',\\r\\n        col_type: \\\"text_1\\\"\\r\\n    });\\r\\n\\r\\n    let s = getDoubanRes(\\\"https://frodo.douban.com/api/v2/doulist/\\\" + id + \\\"/posts\\\" + '?playable=' + temp.playable + (page ? \\\"&start=\\\" + (page - 1) * count + \\\"&count=\\\" + count : \\\"&start=0&count=50\\\"));\\r\\n    let l = s.items;\\r\\n    if (temp.score != '0-10') {\\r\\n        l = l.filter(e => {\\r\\n            let r = temp.score.split('-');\\r\\n            return e.content.subject.rating && e.content.subject.rating.value < r[1] && e.content.subject.rating.value > r[0];\\r\\n        });\\r\\n    }\\r\\n\\r\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\r\\n    let r = l.map((e => {\\r\\n        let type = e.content.subject.type,\\r\\n            id = e.content.subject.id,\\r\\n            title = e.content.subject.title;\\r\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\r\\n        let urlParams = {};\\r\\n        if (useConfig.startsWith('{')) {\\r\\n            eval('urlParams = ' + useConfig);\\r\\n        } else {\\r\\n            urlParams.url = $(\\\"hiker://empty#noHistory##immersiveTheme#\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\r\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                if (type === \\\"playlist\\\") {\\r\\n                    douList(id, MY_PAGE, 50);\\r\\n                } else {\\r\\n                    eval(useConfig);\\r\\n                }\\r\\n            }, type, id, title, useConfig);\\r\\n        }\\r\\n        return {\\r\\n            title: title,\\r\\n            url: urlParams.url,\\r\\n            extra: urlParams.extra,\\r\\n            img: e.content.subject.pic.normal + \\\"@Referer=\\\" + e.content.subject.pic.normal,\\r\\n            desc: e.content.subject.card_subtitle.split(\\\"/\\\").filter(((e, t) => {\\r\\n                if (t < 3) return e\\r\\n            })).join(\\\",\\\") + \\\"\\\\n\\\" + (e.content.subject.rating ? computeRating(e.content.subject.rating.max, e.content.subject.rating.value) + \\\" \\\" + e.content.subject.rating.value.toFixed(1) + \\\"分\\\" : \\\"暂无评分\\\")\\r\\n        }\\r\\n    }));\\r\\n\\r\\n    setHomeResult({\\r\\n        data: page > 1 ? r : i.concat(r)\\r\\n    })\\r\\n}\\r\\n\\r\\n\\r\\n\\r\\n//视频模块\\r\\nfunction videoUrlsModule(d, type, id, col, lazy, _res, extra) {\\r\\n    //col是样式col[0],col[1]分别是tv和movie的样式(tv会有分集信息title会很长)\\r\\n    if (!col) col = ['icon_2', 'icon_small_4'];\\r\\n    if (!lazy) lazy = 'return input';\\r\\n    let res = _res || getDoubanRes(\\\"https://frodo.douban.com/api/v2/\\\" + type + \\\"/\\\" + id);\\r\\n    for (let item in res.vendors) {\\r\\n        let e = res.vendors[item];\\r\\n        if (type === \\\"tv\\\") {\\r\\n            d.push({\\r\\n                title: e.title + (e.episodes_info ? \\\"•\\\" + e.episodes_info : \\\"\\\"),\\r\\n                img: e.icon,\\r\\n                col_type: col[0] || \\\"icon_2\\\",\\r\\n                url: $('hiker://empty?id=' + id + '&type=' + type + '&title=' + e.title).rule((res, id, e, lazy, extra) => {\\r\\n                    let title = res.title,\\r\\n                        pic = res.pic.normal + \\\"@Referer=\\\" + res.pic.normal;\\r\\n                    setPageTitle(e.title + '-' + title);\\r\\n                    try {\\r\\n                        setPagePicUrl(pic);\\r\\n                    } catch (e) {}\\r\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\r\\n                    let urls = getTvUrls(id, e.id);\\r\\n                    lazy = $(\\\"\\\").lazyRule(lazy => {\\r\\n                        let resultUrl = \\\"toast://解析失败\\\";\\r\\n                        try {\\r\\n                            if (lazy.startsWith(\\\"(\\\")) {\\r\\n                                eval('resultUrl = ' + lazy)\\r\\n                            } else {\\r\\n                                eval('resultUrl = ' + '(() => {' + lazy + '})()')\\r\\n                            }\\r\\n                        } catch (e) {\\r\\n                            log(e.message)\\r\\n                        }\\r\\n                        return resultUrl\\r\\n                    }, lazy)\\r\\n                    let d = [];\\r\\n                    if (typeof(urls) == \\\"object\\\") {\\r\\n                        let d = [];\\r\\n                        for (let i = 0; i < urls.length; i++) {\\r\\n                            d.push({\\r\\n                                title: '第' + (i + 1) + '集',\\r\\n                                col_type: 'text_4',\\r\\n                                url: lazy ? urls[i] + lazy : urls[i],\\r\\n                                extra: extra\\r\\n                            })\\r\\n                        }\\r\\n                        setResult(d);\\r\\n                    } else if (typeof(urls) == \\\"string\\\" && urls == '被封ip') {\\r\\n                        let rule = JSON.parse(request(\\\"hiker://page/releaseIP?rule=青豆\\\"))\\r\\n                            .rule;\\r\\n                        eval(rule);\\r\\n                    } else if (typeof(urls) == 'string' && urls == '没有收录') {\\r\\n                        let d = [];\\r\\n                        d.push({\\r\\n                            title: '豆瓣没有收录此视频源的详细信息',\\r\\n                            desc: '点我可以去视频源网站看看',\\r\\n                            col_type: 'text_center_1',\\r\\n                            url: e.url\\r\\n                        })\\r\\n                        setResult(d);\\r\\n                    }\\r\\n                }, res, id, e, lazy, extra)\\r\\n            })\\r\\n        } else if (type === 'movie') {\\r\\n            let mLazy = $(\\\"\\\").lazyRule(lazy => {\\r\\n                let resultUrl = \\\"toast://解析失败\\\";\\r\\n                try {\\r\\n                    if (lazy.startsWith(\\\"(\\\")) {\\r\\n                        eval('resultUrl = ' + lazy)\\r\\n                    } else {\\r\\n                        eval('resultUrl = ' + '(() => {' + lazy + '})()')\\r\\n                    }\\r\\n                } catch (e) {\\r\\n                    log(e.message)\\r\\n                }\\r\\n                return resultUrl\\r\\n            }, lazy)\\r\\n            d.push({\\r\\n                title: e.title + (e.episodes_info ? \\\"•\\\" + e.episodes_info : \\\"\\\"),\\r\\n                img: e.icon,\\r\\n                col_type: col[1] || \\\"icon_small_4\\\",\\r\\n                url: mLazy ? e.url + mLazy : e.url,\\r\\n                extra: extra\\r\\n            })\\r\\n        }\\r\\n    }\\r\\n}\\r\\n\\r\\n//获取电视剧分集链接,id是片子编号,uid是视频源编号\\r\\nfunction getTvUrls(id, uid) {\\r\\n    let cookieCache = 'hiker://files/cache/doubancookie.txt';\\r\\n    let mUrl = 'https://movie.douban.com/subject/' + id + '/';\\r\\n    let headers = {\\r\\n        \\\"User-Agent\\\": PC_UA,\\r\\n    }\\r\\n    if (fileExist(cookieCache)) {\\r\\n        headers[\\\"Cookie\\\"] = fetch(cookieCache)\\r\\n    }\\r\\n    let html = request(mUrl, {\\r\\n        headers: headers\\r\\n    })\\r\\n    if ((html.includes(\\\"登录跳转\\\") && html.includes(\\\"异常请求\\\")) || (html.includes(\\\"window.location.href\\\") && html.includes(\\\"sec.douban\\\"))) {\\r\\n        return '被封ip';\\r\\n    } else {\\r\\n        let s = {\\r\\n            qq: 1,\\r\\n            youku: 3,\\r\\n            letv: 6,\\r\\n            mgtv: 7,\\r\\n            bilibili: 8,\\r\\n            iqiyi: 9,\\r\\n            cntv: 12,\\r\\n            cctv6: 13,\\r\\n            miguvideo: 15,\\r\\n            xigua: 17,\\r\\n            acfun: 18,\\r\\n            maiduidui: 19\\r\\n        };\\r\\n        let num = s[uid];\\r\\n\\r\\n        var sources = {};\\r\\n        let sl = html.match(/sources\\\\[[1-9]{1,2}\\\\][\\\\s\\\\S]*?\\\\]/g);\\r\\n        if (sl) {\\r\\n            for (var i in sl) {\\r\\n                eval(sl[i]);\\r\\n            }\\r\\n        } else {\\r\\n            let script_list = parseDomForArray(html, 'body&&script[src]');\\r\\n            let sources_url = \\\"\\\";\\r\\n            for (let i in script_list) {\\r\\n                let url = parseDomForHtml(script_list[i], 'script&&src');\\r\\n                if (url.indexOf('mixed_static') !== -1) {\\r\\n                    sources_url = url;\\r\\n                }\\r\\n            }\\r\\n            let sources_list = request(sources_url).match(/sources\\\\[[1-9]{1,2}\\\\][\\\\s\\\\S]*?\\\\]/g);\\r\\n            for (var i in sources_list) {\\r\\n                eval(sources_list[i]);\\r\\n            }\\r\\n        }\\r\\n\\r\\n        let ren = sources[num];\\r\\n        if (ren && ren.length > 0) {\\r\\n            /*var r = ren.map(e => unescape(e.play_link.replace(/(https|http):\\\\/\\\\/www.douban.com\\\\/link2\\\\/\\\\?url=/, '')\\r\\n                .split(';')[0].split('.html')[0] + '.html'))*/\\r\\n            var r = ren.map(e => unescape(e.play_link.split('?url=')[1].split('&')[0]))\\r\\n\\r\\n        }\\r\\n        return r || '没有收录';\\r\\n    }\\r\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"设置页\",\"path\":\"settingPage\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/utils')).rule);\\n\\n//影片详情配置模块\\nfunction detailViewModeModule(d, detailsViewConfigs) {\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\n    d.push({\\n        title: '自定义影片详情页面'.bold(),\\n        col_type: \\\"rich_text\\\"\\n    })\\n    for (let configKey of Object.keys(detailsViewConfigs)) {\\n        if (configKey === 'use') continue;\\n        d.push({\\n            title: configKey === detailsViewConfigs.use ? \\\"““\\\" + configKey + \\\"””\\\" : configKey,\\n            url: $(\\\"hiker://empty#noLoading#\\\").lazyRule(configKey => {\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\n                if (config.detailsViewConfigs.use === configKey) {\\n                    //putMyVar(\\\"input_config_type\\\", '影片详情页面配置')\\n                    putMyVar(\\\"input_name\\\", configKey);\\n                    putMyVar(\\\"input_code\\\", config.detailsViewConfigs[configKey].config);\\n                    putMyVar(\\\"input_setting_code\\\", config.detailsViewConfigs[configKey].setting || \\\"\\\");\\n                    return 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage';\\n                }\\n                config.detailsViewConfigs.use = configKey\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n                refreshPage(false);\\n                return 'toast://切换成功'\\n            }, configKey),\\n            col_type: 'flex_button'\\n        })\\n    }\\n    d.push({\\n        col_type: 'blank_block'\\n    })\\n    d.push({\\n        title: '➕',\\n        col_type: 'flex_button',\\n        url: 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage'\\n    });\\n    d.push({\\n        title: '➖',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(detailsViewConfigs).filter(configKey => configKey !== 'use' && configKey !== '默认'), 2)\\n            .select(() => {\\n                if (input === '默认') return 'toast://默认配置无法删除！'\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\n                if (input === config.detailsViewConfigs.use) return 'toast://该配置正在使用，无法删除！'\\n                return $('确认删除\\\"' + input + '\\\"？').confirm((config, configKey) => {\\n                    delete config.detailsViewConfigs[configKey]\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n                    refreshPage(false);\\n                    return 'toast://删除' + configKey + '成功'\\n                }, config, input)\\n            })\\n    })\\n    d.push({\\n        title: '📝',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(detailsViewConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\n            let config = JSON.parse(request(getMyVar('qdb_config')))\\n            putMyVar(\\\"input_name\\\", configKey);\\n            putMyVar(\\\"input_code\\\", config.detailsViewConfigs[configKey].config);\\n            putMyVar(\\\"input_setting_code\\\", config.detailsViewConfigs[configKey].setting || \\\"\\\");\\n            return 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage'\\n        })\\n    })\\n    d.push({\\n        title: '📥',\\n        col_type: 'flex_button',\\n        url: $(\\\"\\\", \\\"请输入口令\\\").input(() => {\\n            if (!input.includes(\\\"影片详情页面配置\\\")) return \\\"toast://该口令不是影片详情页面配置\\\";\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\n            let importConfigs = ConfigTool.import(input);\\n            if (!importConfigs) return \\\"toast://似乎出了错，请尝试再次导入～\\\";\\n            putMyVar(\\\"input_name\\\", importConfigs.name);\\n            putMyVar(\\\"input_code\\\", importConfigs.data.config);\\n            putMyVar(\\\"input_setting_code\\\", importConfigs.data.setting || \\\"\\\");\\n            return 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage';\\n        })\\n    })\\n    d.push({\\n        title: '📤',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(detailsViewConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\n            let config = getConfig();\\n            let selectConfig = {\\n                name: input,\\n                data: config.detailsViewConfigs[input]\\n            }\\n            return $(ConfigTool.encTypeList, 2).select((selectConfig) => {\\n                eval(JSON.parse(request('hiker://page/utils')).rule)\\n                return ConfigTool.toClipboard(ConfigTool.export(selectConfig.name, selectConfig, \\\"影片详情页面配置\\\", input))\\n            }, selectConfig)\\n        })\\n    })\\n}\\n// 详情页设置模块\\nfunction detailViewSettingModule(d) {\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\n    detailViewModeModule(d, detailsViewConfigs)\\n    let detailViewSetting = detailsViewConfigs[detailsViewConfigs.use].setting\\n    let result = \\\"toast://该详情页无设置页面\\\";\\n    if (detailViewSetting) {\\n        try {\\n            if (detailViewSetting.indexOf('return') == -1) throw new Error('必须 return @rule=js: 或 $().rule');\\n            if (detailViewSetting.startsWith(\\\"(\\\")) {\\n                eval('result = ' + detailViewSetting)\\n            } else {\\n                eval('result = ' + '(() => {' + detailViewSetting + '})()')\\n            }\\n        } catch (e) {\\n            log(e.message);\\n            result = \\\"toast://错误的设置页面代码,请前往 日志 查看错误原因\\\"\\n        }\\n    }\\n    d.push({\\n        title: '⚙️',\\n        col_type: 'flex_button',\\n        url: result\\n    })\\n}\\n\\n// 首页设置模块\\nfunction homePageSettingModule(d) {\\n    let homePageConfigs = getConfig('homePageConfigs');\\n    d.push({\\n        title: '自定义首页'.bold(),\\n        col_type: \\\"rich_text\\\"\\n    })\\n    for (let configKey of Object.keys(homePageConfigs)) {\\n        if (configKey === 'use') continue;\\n        d.push({\\n            title: configKey === homePageConfigs.use ? \\\"““\\\" + configKey + \\\"””\\\" : configKey,\\n            url: $(\\\"hiker://empty#noLoading#\\\").lazyRule(configKey => {\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\n                if (config.homePageConfigs.use === configKey) {\\n                    //putMyVar(\\\"input_config_type\\\", '首页配置')\\n                    putMyVar(\\\"input_name\\\", configKey);\\n                    putMyVar(\\\"input_code\\\", config.homePageConfigs[configKey].config);\\n                    return 'hiker://page/setting-editor?rule=青豆&view=homePageModeEditPage';\\n                }\\n                config.homePageConfigs.use = configKey\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n                refreshPage(false);\\n                return 'toast://切换成功'\\n            }, configKey),\\n            col_type: 'flex_button'\\n        })\\n    }\\n    d.push({\\n        col_type: 'blank_block'\\n    })\\n    d.push({\\n        title: '➕',\\n        col_type: 'flex_button',\\n        url: 'hiker://page/setting-editor?view=homePageModeEditPage'\\n    });\\n    d.push({\\n        title: '➖',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(homePageConfigs).filter(configKey => configKey !== 'use' && configKey !== '默认'), 2)\\n            .select(() => {\\n                if (input === '默认') return 'toast://默认配置无法删除！'\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\n                if (input === config.homePageConfigs.use) return 'toast://该配置正在使用，无法删除！'\\n                return $('确认删除\\\"' + input + '\\\"？').confirm((config, configKey) => {\\n                    delete config.homePageConfigs[configKey]\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n                    refreshPage(false);\\n                    return 'toast://删除' + configKey + '成功'\\n                }, config, input)\\n            })\\n    })\\n    d.push({\\n        title: '📝',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(homePageConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\n            let config = JSON.parse(request(getMyVar('qdb_config')));\\n            let configKey = input;\\n            putMyVar(\\\"input_name\\\", configKey);\\n            putMyVar(\\\"input_code\\\", config.homePageConfigs[configKey].config);\\n            return 'hiker://page/setting-editor?rule=青豆&view=homePageModeEditPage';\\n        })\\n    })\\n    d.push({\\n        title: '📥',\\n        col_type: 'flex_button',\\n        url: $(\\\"\\\", \\\"请输入口令\\\").input(() => {\\n            if (!input.includes(\\\"首页配置\\\")) return \\\"toast://该口令不是首页配置\\\";\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\n            let importConfigs = ConfigTool.import(input);\\n            if (!importConfigs) return \\\"toast://似乎出了错，请尝试再次导入～\\\";\\n            putMyVar(\\\"input_name\\\", importConfigs.name);\\n            putMyVar(\\\"input_code\\\", importConfigs.data.config);\\n            return 'hiker://page/setting-editor?rule=青豆&view=homePageModeEditPage';\\n        })\\n    })\\n    d.push({\\n        title: '📤',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(homePageConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\n            let config = getConfig();\\n            let selectConfig = {\\n                name: input,\\n                data: config.homePageConfigs[input]\\n            }\\n            return $(ConfigTool.encTypeList, 2).select((selectConfig) => {\\n                eval(JSON.parse(request('hiker://page/utils')).rule)\\n                return ConfigTool.toClipboard(ConfigTool.export(selectConfig.name, selectConfig, \\\"首页配置\\\", input))\\n            }, selectConfig)\\n        })\\n    })\\n}\\n\\n// 解析配置模块\\nfunction analysisModeModule(d, analysisConfigs) {\\n    d.push({\\n        title: '自定义解析插件'.bold(),\\n        col_type: \\\"rich_text\\\"\\n    })\\n    for (let configKey of Object.keys(analysisConfigs)) {\\n        if (configKey === 'use') continue;\\n        d.push({\\n            title: configKey === analysisConfigs.use ? \\\"““\\\" + configKey + \\\"””\\\" : configKey,\\n            url: $(\\\"hiker://empty#noLoading#\\\").lazyRule(configKey => {\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\n                if (config.analysisConfigs.use === configKey) {\\n                    //putMyVar(\\\"input_config_type\\\", '解析插件配置')\\n                    putMyVar(\\\"input_name\\\", configKey);\\n                    putMyVar(\\\"input_code\\\", config.analysisConfigs[configKey].config);\\n                    putMyVar(\\\"input_extra\\\", config.analysisConfigs[configKey].extra || \\\"\\\");\\n                    putMyVar(\\\"input_setting_code\\\", config.analysisConfigs[configKey].setting || \\\"\\\");\\n                    return 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage';\\n                }\\n                config.analysisConfigs.use = configKey\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n                refreshPage(false);\\n                return 'toast://切换成功'\\n            }, configKey),\\n            col_type: 'flex_button'\\n        })\\n    }\\n    d.push({\\n        col_type: 'blank_block'\\n    })\\n    d.push({\\n        title: '➕',\\n        col_type: 'flex_button',\\n        url: 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage'\\n    });\\n    d.push({\\n        title: '➖',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(analysisConfigs).filter(configKey => configKey !== 'use' && configKey !== '不解析' && configKey !== '断插'), 2)\\n            .select(() => {\\n                if (input === '不解析' && input === '断插') return 'toast://默认解析无法删除！'\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\n                if (input === config.analysisConfigs.use) return 'toast://该解析正在使用，无法删除！'\\n                return $('确认删除\\\"' + input + '\\\"？').confirm((config, configKey) => {\\n                    delete config.analysisConfigs[configKey]\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n                    refreshPage(false);\\n                    return 'toast://删除' + configKey + '成功'\\n                }, config, input)\\n            })\\n    })\\n    d.push({\\n        title: '📝',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(analysisConfigs).filter(configKey => configKey !== 'use'), 2)\\n            .select(() => {\\n                // if (input === '不解析' && input === '断插') return 'toast://默认解析无法编辑！'\\n                let config = JSON.parse(request(getMyVar('qdb_config')));\\n                let configKey = input;\\n                putMyVar(\\\"input_name\\\", configKey);\\n                putMyVar(\\\"input_code\\\", config.analysisConfigs[configKey].config);\\n                putMyVar(\\\"input_extra\\\", config.analysisConfigs[configKey].extra || \\\"\\\");\\n                putMyVar(\\\"input_setting_code\\\", config.analysisConfigs[configKey].setting || \\\"\\\");\\n                return 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage';\\n            })\\n    })\\n    d.push({\\n        title: '📥',\\n        col_type: 'flex_button',\\n        url: $(\\\"\\\", \\\"请输入口令\\\").input(() => {\\n            if (!input.includes(\\\"解析插件配置\\\")) return \\\"toast://该口令不是解析插件配置\\\";\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\n            let importConfigs = ConfigTool.import(input);\\n            if (!importConfigs) return \\\"toast://似乎出了错，请尝试再次导入～\\\";\\n            putMyVar(\\\"input_name\\\", importConfigs.name);\\n            putMyVar(\\\"input_code\\\", importConfigs.data.config);\\n            putMyVar(\\\"input_extra\\\", importConfigs.data.extra || \\\"\\\");\\n            putMyVar(\\\"input_setting_code\\\", importConfigs.data.setting || \\\"\\\");\\n            return 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage';\\n        })\\n    })\\n    d.push({\\n        title: '📤',\\n        col_type: 'flex_button',\\n        url: $(Object.keys(analysisConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\n            let config = getConfig();\\n            let selectConfig = {\\n                name: input,\\n                data: config.analysisConfigs[input]\\n            }\\n            return $(ConfigTool.encTypeList, 2).select((selectConfig) => {\\n                eval(JSON.parse(request('hiker://page/utils')).rule)\\n                return ConfigTool.toClipboard(ConfigTool.export(selectConfig.name, selectConfig, \\\"解析插件配置\\\", input))\\n            }, selectConfig)\\n        })\\n    })\\n}\\n\\n// 解析设置模块\\nfunction analysisSettingModule(d) {\\n    let analysisConfigs = getConfig('analysisConfigs');\\n    analysisModeModule(d, analysisConfigs);\\n    /**\\n     * 这下面的都是拿设置页面的配置出来 eval 执行，最终获得插件设置页面的 url，这个 url 可以是网页也可以是二级界面\\n     */\\n    let analysisSetting = analysisConfigs[analysisConfigs.use].setting;\\n    let result = \\\"toast://该插件无设置页面\\\";\\n    if (analysisSetting) {\\n        try {\\n            if (analysisSetting.indexOf('return') == -1) throw new Error('必须 return @rule=js: 或 $().rule');\\n            if (analysisSetting.startsWith(\\\"(\\\")) {\\n                eval('result = ' + analysisSetting);\\n            } else {\\n                eval('result = ' + '(() => {' + analysisSetting + '})()');\\n            }\\n        } catch (e) {\\n            log(e.message);\\n            result = \\\"toast://错误的设置页面代码,请前往 日志 查看错误原因\\\"\\n        }\\n    }\\n    d.push({\\n        title: '⚙️',\\n        col_type: 'flex_button',\\n        url: result\\n    })\\n}\\n\\n//自定义快速搜索模块\\nfunction quickSearchDIYModule(d, config) {\\n    let quickSearchConfigs = getConfig('quickSearchConfigs', config);\\n    d.push({\\n        title: '自定义快速搜索'.bold(),\\n        col_type: \\\"rich_text\\\"\\n    })\\n    for (let configKey of quickSearchConfigs.order) {\\n        d.push({\\n            title: configKey,\\n            url: $('➕是添加\\\\n➖是删除\\\\n📝是修改\\\\n🔁是排序\\\\n⚙️是设置样式').confirm(() => {\\n                return 'toast://下次不要再点我了'\\n            }),\\n            col_type: 'flex_button'\\n        })\\n    }\\n    d.push({\\n        col_type: 'blank_block'\\n    })\\n    d.push({\\n        title: '➕️',\\n        col_type: 'flex_button',\\n        url: $('显示名@@小程序名@@图片链接', '根据提示输入就好了\\\\n小程序名为空则为海阔搜索').input(() => {\\n            let config = JSON.parse(fetch(getMyVar('qdb_config')));\\n            input = input.split('@@');\\n            if(input.length != 3 || input[0] === \\\"\\\") return \\\"toast://格式不对，按格式输入!\\\";\\n            if (config.quickSearchConfigs.order.indexOf(input[0]) == -1) config.quickSearchConfigs.order.push(input[0]);\\n            config.quickSearchConfigs[input[0]] = {\\n                name: input[1],\\n                pic: input[2]\\n            };\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n            refreshPage(false);\\n            return 'toast://添加成功';\\n        })\\n    });\\n    d.push({\\n        title: '➖',\\n        col_type: 'flex_button',\\n        url: $(quickSearchConfigs.order, 2).select(() => {\\n            let config = JSON.parse(request(getMyVar('qdb_config')))\\n            return $('确认删除\\\"' + input + '\\\"？').confirm((config, configKey) => {\\n                let index = config.quickSearchConfigs.order.indexOf(configKey);\\n                config.quickSearchConfigs.order.splice(index, 1);\\n                delete config.quickSearchConfigs[configKey]\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\n                refreshPage(false);\\n                return 'toast://删除' + configKey + '成功'\\n            }, config, input)\\n        })\\n    })\\n    d.push({\\n        title: '📝',\\n        col_type: 'flex_button',\\n        url: $(quickSearchConfigs.order, 2).select(() => {\\n            let config = JSON.parse(request(getMyVar('qdb_config')));\\n            let quickSearchConfigs = config.quickSearchConfigs;\\n            let dtext = input + '@@' + quickSearchConfigs[input].name + '@@' + quickSearchConfigs[input].pic;\\n            return $(dtext, '请修改').input((config, raw) => {\\n                input = input.split('@@');\\n                if (raw != input[0]) {\\n                    let index = config.quickSearchConfigs.order.indexOf(raw);\\n                    config.quickSearchConfigs.order[index] = input[0];\\n                    delete config.quickSearchConfigs[raw];\\n                }\\n                if (config.quickSearchConfigs.order.indexOf(input[0]) == -1) config.quickSearchConfigs.order.push(input[0]);\\n                config.quickSearchConfigs[input[0]] = {\\n                    name: input[1],\\n                    pic: input[2]\\n                };\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n                refreshPage(false);\\n                return 'toast://修改成功';\\n            }, config, input)\\n        })\\n    })\\n    d.push({\\n        title: '🔁',\\n        col_type: 'flex_button',\\n        url: $('hiker://empty#noHistory#').rule(() => {\\n            addListener('onClose', $.toString(() => {\\n                clearMyVar('json');\\n                clearMyVar('op');\\n            }))\\n            if (getMyVar('json') == \\\"\\\") {\\n                let config = JSON.parse(request(getMyVar('qdb_config')));\\n                let quickSearchConfigs = config.quickSearchConfigs;\\n                putMyVar('json', JSON.stringify(quickSearchConfigs));\\n            }\\n\\n            let old = JSON.parse(getMyVar('json'));\\n            let d = [];\\n            d.push({\\n                title: '分别点击两项以交换顺序\\\\n‘‘排序完毕后点我保存排序,否则排序不生效’’',\\n                col_type: 'text_center_1',\\n                url: $('#noLoading#').lazyRule(() => {\\n                    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\n                    config.quickSearchConfigs = JSON.parse(getMyVar('json'));\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n                    back(true);\\n                    return 'toast://修改成功'\\n                })\\n            })\\n            old.order.forEach((value, index) => {\\n                d.push({\\n                    title: getMyVar('op') == value ? value + '‘‘(当前选中)’’' : value,\\n                    col_type: 'text_1',\\n                    url: $().lazyRule((key, index) => {\\n                        let op = getMyVar('op');\\n                        if (op == '') {\\n                            putMyVar('op', key);\\n                            refreshPage();\\n                            return 'hiker://empty'\\n                        } else if (op == key) {\\n                            clearMyVar('op');\\n                            refreshPage();\\n                            return 'hiker://empty'\\n                        } else {\\n                            let old = JSON.parse(getMyVar('json'));\\n                            let newa = {\\n                                mode: old.mode,\\n                                order: old.order\\n                            };\\n                            let opindex = newa.order.indexOf(op);\\n                            if (Math.abs(opindex - index) == 1) {\\n                                newa.order[opindex] = key;\\n                                newa.order[index] = op;\\n                            } else if (opindex > index) {\\n                                newa.order.splice(opindex, 1);\\n                                newa.order.splice(index, 0, op);\\n                            } else {\\n                                newa.order.splice(opindex, 1);\\n                                newa.order.splice(index - 1, 0, op);\\n                            }\\n                            newa.order.forEach(value => newa[value] = old[value])\\n                            putMyVar('json', JSON.stringify(newa));\\n                            clearMyVar('op');\\n                            refreshPage();\\n                            return 'hiker://empty'\\n                        }\\n                    }, value, index)\\n                })\\n            })\\n            setResult(d);\\n        })\\n    })\\n    d.push({\\n        title: '⚙️',\\n        col_type: 'flex_button',\\n        url: $(quickSearchConfigs['mode'] || \\\"\\\", '请正确输入组件样式\\\\n建议值:flex_button scroll_button icon_round_small_4 icon_small_4').input(() => {\\n            let config = JSON.parse(request(getMyVar('qdb_config')));\\n            config.quickSearchConfigs.mode = input;\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n            refreshPage(false);\\n            return 'toast://样式修改成功'\\n        })\\n    })\\n}\\n\\n//设置页面\\nfunction settingPage() {\\n    let conf = getConfig();\\n    let d = [];\\n\\n    let starColor = conf.starColor || '#ffac2d';\\n    d.push({\\n        title: '““””' + '自定义星星颜色'.bold(),\\n        desc: '““””<font color=' + starColor + '>' + '★★★★★</font>',\\n        col_type: 'text_1',\\n        url: $(starColor, '别忘了#').input(() => {\\n            let config = JSON.parse(fetch(getMyVar('qdb_config')));\\n            config.starColor = input;\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n            refreshPage();\\n            return \\\"toast://设置更改已保存\\\";\\n        })\\n    })\\n    let chooseColor = conf.chooseColor || '#FA7298';\\n    d.push({\\n        title: '““””' + '自定义选中标签颜色'.bold(),\\n        desc: '““””<font color=' + chooseColor + '>' + '我是预览效果</font>',\\n        col_type: 'text_1',\\n        url: $(chooseColor, '别忘了#').input(() => {\\n            let config = JSON.parse(fetch(getMyVar('qdb_config')));\\n            config.chooseColor = input;\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n            refreshPage();\\n            return \\\"toast://设置更改已保存\\\";\\n        })\\n    })\\n\\n    homePageSettingModule(d);\\n    d.push({\\n        col_type: 'line'\\n    })\\n\\n    quickSearchDIYModule(d, conf);\\n    d.push({\\n        col_type: 'line'\\n    })\\n\\n    detailViewSettingModule(d);\\n    d.push({\\n        col_type: 'line'\\n    })\\n\\n    if (true/*getItem('password') == 'true'*/) {\\n        analysisSettingModule(d);\\n        d.push({\\n            col_type: 'line'\\n        })\\n    }\\n\\n    d.push({\\n        title: '““””' + '恢复默认设置'.bold(),\\n        desc: '重生',\\n        col_type: 'text_1',\\n        url: $(['重置星星颜色', '重置选中标签颜色', '重置快速搜索', '重置首页为默认', '重置详情页' , '清除全部设置'], 1).select(() => {\\n            return $(\\\"确定要\\\" + input + \\\"？\\\").confirm((sel) => {\\n                let item = '';\\n                switch (sel) {\\n                    case '重置星星颜色':\\n                        item = 'starColor';\\n                        break;\\n                    case '重置选中标签颜色':\\n                        item = 'chooseColor';\\n                        break;\\n                    case '重置快速搜索':\\n                        item = 'quickSearchConfigs';\\n                        break;\\n                    case '重置首页为默认':\\n                        item = 'homePageConfigs';\\n                        break;\\n                    case '重置详情页':\\n                        item = 'detailViewConfigs';\\n                        break;\\n                    case '清除全部设置':\\n                        item = 'all';\\n                        break;\\n                }\\n                // eval(JSON.parse(request('hiker://page/settingPage')).rule);\\n                let defaultConfigs = $.require(\\\"hiker://page/defaultConfigs\\\");\\n                if (item == 'all') {\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(defaultConfigs));\\n                    refreshPage();\\n                    return \\\"toast://已\\\" + sel;\\n                } else if(item == \\\"homePageConfigs\\\"){\\n                    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\n                    config[item][\\\"默认\\\"] = defaultConfigs[item][\\\"默认\\\"];\\n                    config[item].use = \\\"默认\\\";\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n                    refreshPage();\\n                    return \\\"toast://已\\\" + sel;\\n                }else {\\n                    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\n                    config[item] = defaultConfigs[item];\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\n                    refreshPage();\\n                    return \\\"toast://已\\\" + sel;\\n                }\\n            }, input)\\n        })\\n    })\\n    setResult(d);\\n}\\n\\nlet view = getParam(\\\"view\\\",\\\"\\\");\\nif(view==\\\"\\\"){\\n    setPageTitle(\\\"设置\\\")\\n    settingPage();\\n}else if(view==\\\"analysisSettingModule\\\"){\\n    let d = [];\\n    setPageTitle(\\\"解析设置\\\")\\n    analysisSettingModule(d);\\n    setResult(d);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"默认配置\",\"path\":\"defaultConfigs\",\"rule\":\"js:\\r\\nlet defaultConfigs = {\\r\\n    starColor: \\\"#ffac2d\\\",\\r\\n    chooseColor: \\\"#FA7298\\\",\\r\\n    quickSearchConfigs: {\\r\\n        mode: \\\"scroll_button\\\",\\r\\n        order: [\\\"海阔搜索\\\"],\\r\\n        \\\"海阔搜索\\\": {\\r\\n            name: \\\"\\\",\\r\\n            pic: \\\"\\\"\\r\\n        }\\r\\n    },\\r\\n    detailsViewConfigs: {\\r\\n        use: \\\"默认\\\",\\r\\n        \\\"默认\\\": {\\r\\n            config: \\\"eval(JSON.parse(request('hiker://page/main')).rule);detailsView(type, id);\\\"\\r\\n        }\\r\\n    },\\r\\n    homePageConfigs:{\\r\\n        use: \\\"默认\\\",\\r\\n        \\\"默认\\\": {\\r\\n            config: `let d = [];\\r\\nd.push({\\r\\n    title: '',\\r\\n    img: 'https://gitcode.net/qq_41846756/hiker/-/raw/master/img/豆瓣.png',\\r\\n    desc: '0',\\r\\n    col_type: 'card_pic_1',\\r\\n    url: 'hiker://page/settingPage'\\r\\n})\\r\\n\\r\\nlet s = [\\\"推荐\\\", \\\"热门\\\", \\\"分类\\\", \\\"片单\\\", \\\"榜单\\\", \\\"将上映\\\"];\\r\\nlet img = \\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/\\\";\\r\\nfor (let i in s) {\\r\\n    d.push({\\r\\n        title: s[i],\\r\\n        img: img + s[i] + '.jpg',\\r\\n        col_type: 'icon_2',\\r\\n        url: \\\"hiker://empty\\\" + '$page{fypage}/#/' + s[i] + \\\"#noHistory#\\\"\\r\\n    })\\r\\n}\\r\\nreturn d;`\\r\\n        }\\r\\n    },\\r\\n    analysisConfigs: {\\r\\n        use: \\\"不解析\\\",\\r\\n        \\\"不解析\\\": {\\r\\n            config: $.toString(() => {\\r\\n                return input;\\r\\n            }),\\r\\n            setting: $.toString(() => {\\r\\n                return \\\"toast://该插件无设置页面\\\";\\r\\n            })\\r\\n        },\\r\\n        \\\"断插\\\": {\\r\\n            config: $.toString(() => {\\r\\n                let file = \\\"hiker://files/rules/DuanNian/MyParse.json\\\";\\r\\n                let oldfile = \\\"hiker://files/cache/MyParseSet.json\\\";\\r\\n                if (fileExist(file)) {\\r\\n                    eval('json=' + fetch(file));\\r\\n                    let jsUrl = json.settings.cj;\\r\\n                    eval(fetch(jsUrl));\\r\\n                    return aytmParse(input);\\r\\n                } else if (fileExist(oldfile)) {\\r\\n                    let jsUrl = JSON.parse(fetch(oldfile)).cj;\\r\\n                    eval(fetch(jsUrl));\\r\\n                    return aytmParse(input);\\r\\n                } else {\\r\\n                    return 'toast://没找到断插配置文件';\\r\\n                }\\r\\n            }),\\r\\n            setting: $.toString(() => {\\r\\n                let file = \\\"hiker://files/rules/DuanNian/MyParse.json\\\";\\r\\n                let oldfile = \\\"hiker://files/cache/MyParseSet.json\\\";\\r\\n                if (fileExist(file)) {\\r\\n                    eval('json=' + fetch(file));\\r\\n                    let jsUrl = json.settings.cj;\\r\\n                    eval(fetch(jsUrl));\\r\\n                    return setUrl;\\r\\n                } else if (fileExist(oldfile)) {\\r\\n                    let jsUrl = JSON.parse(fetch(oldfile)).cj;\\r\\n                    eval(fetch(jsUrl));\\r\\n                    return setUrl;\\r\\n                } else {\\r\\n                    return \\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置\\\";\\r\\n                }\\r\\n            })\\r\\n        }\\r\\n    }\\r\\n}\\r\\n$.exports = defaultConfigs;\"},{\"col_type\":\"movie_3\",\"name\":\"工具集\",\"path\":\"utils\",\"rule\":\"js:\\r\\n//初始化配置,name为配置项名称\\r\\nfunction initConfigs(name, config) {\\r\\n    if (!config) {\\r\\n        config = JSON.parse(fetch(getMyVar('qdb_config')));\\r\\n    }\\r\\n    if (config[name] == null) {\\r\\n        let defaultConfigs = $.require(\\\"hiker://page/defaultConfigs\\\");\\r\\n        config[name] = defaultConfigs[name] ? defaultConfigs[name] : {};\\r\\n        writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\r\\n    }\\r\\n    return config;\\r\\n}\\r\\n\\r\\n//获取配置项\\r\\nfunction getConfig(name, rootConfig) {\\r\\n    let config = rootConfig ? rootConfig : JSON.parse(fetch(getMyVar('qdb_config')));\\r\\n    if (name) {\\r\\n        if (config[name] == null) {\\r\\n            config = initConfigs(name, config);\\r\\n        }\\r\\n        return config[name];\\r\\n    } else {\\r\\n        return config;\\r\\n    }\\r\\n}\\r\\n\\r\\n//编码工具类\\r\\nlet ZipTool = {\\r\\n    dependence: 'https://unpkg.com/lz-string@1.4.4/libs/lz-string.min.js',\\r\\n    compress: {\\r\\n        size: {\\r\\n            key: \\\"text-compress-size\\\",\\r\\n            set: (newValue) => {\\r\\n                putMyVar(this.key, newValue.toString())\\r\\n            },\\r\\n            get: () => {\\r\\n                return parseInt(getMyVar(this.key, \\\"0\\\"))\\r\\n            }\\r\\n        },\\r\\n        exec: (input) => {\\r\\n            eval(request(ZipTool.dependence))\\r\\n            let result = LZString.compressToEncodedURIComponent(input)\\r\\n                // ZipTool.compress.size.set(result.length * 2)\\r\\n            return result\\r\\n        }\\r\\n    },\\r\\n    decompress: {\\r\\n        size: {\\r\\n            get: () => {\\r\\n                return getMyVar(\\\"text-decompress\\\", \\\"0\\\")\\r\\n                    .length\\r\\n            }\\r\\n        },\\r\\n        exec: (input) => {\\r\\n            eval(request(ZipTool.dependence))\\r\\n            let result = LZString.decompressFromEncodedURIComponent(input)\\r\\n            return result\\r\\n        }\\r\\n    }\\r\\n}\\r\\n\\r\\n// 配置项工具类\\r\\nlet ConfigTool = {\\r\\n    encTypeList: ['Base64', 'Zipper'].concat(getPastes()),\\r\\n    toClipboard: (configCommand, name) => {\\r\\n        if (configCommand.startsWith('toast://')) return configCommand\\r\\n        if (!name) {\\r\\n            let commandSplits = configCommand.split(\\\"￥\\\")\\r\\n            name = commandSplits[2]\\r\\n            name = name ? (\\\"“\\\" + name + \\\"”\\\") : ''\\r\\n        }\\r\\n        refreshPage(false);\\r\\n        return \\\"copy://\\\" + configCommand + \\\".js:'toast://导出\\\" + name + \\\"成功！'\\\";\\r\\n    },\\r\\n    export: (name, config, remark, encType) => {\\r\\n        let symbol = \\\"青豆口令￥\\\" + remark + \\\"￥\\\" + name + \\\"￥\\\" + encType + \\\"￥\\\";\\r\\n        let result = config\\r\\n        if (typeof result === \\\"object\\\") {\\r\\n            result = JSON.stringify(config);\\r\\n        } else if (typeof result === \\\"string\\\") {\\r\\n            result = config;\\r\\n        } else {\\r\\n            throw \\\"导出数据不合法\\\"\\r\\n        }\\r\\n        switch (encType) {\\r\\n            case 'Base64':\\r\\n                result = base64Encode(result);\\r\\n                break;\\r\\n            case 'Zipper':\\r\\n                result = ZipTool.compress.exec(result)\\r\\n                break;\\r\\n            default :\\r\\n                if (getAppVersion() > 2070) {\\r\\n                    symbol = \\\"青豆口令￥\\\" + remark + \\\"￥\\\" + name\\r\\n                    result = sharePaste(ConfigTool.export(name, config, remark, 'Zipper'),encType);\\r\\n                    return result + '\\\\n\\\\n' + symbol\\r\\n                } else {\\r\\n                    return 'toast://请更新视界版本至 C2070 以上'\\r\\n                }\\r\\n                break;\\r\\n        }\\r\\n        result = symbol + result\\r\\n        return result;\\r\\n    },\\r\\n    import: (configCommand) => {\\r\\n        let result = ''\\r\\n        if (configCommand.startsWith('云')) {\\r\\n            if (getAppVersion() > 2070) {\\r\\n                result = configCommand.split('青豆')[0].replace(/\\\\\\\\n/, '')\\r\\n                configCommand = parsePaste(result)\\r\\n            } else {\\r\\n                return 'toast://请更新视界版本至 C2070 以上'\\r\\n            }\\r\\n        }\\r\\n        try {\\r\\n            let resultSplits = configCommand.split(\\\"￥\\\")\\r\\n            let encType = resultSplits[3]\\r\\n            result = resultSplits[4]\\r\\n            switch (encType) {\\r\\n                case 'Base64':\\r\\n                    result = base64Decode(result);\\r\\n                    break;\\r\\n                case 'Zipper':\\r\\n                    result = ZipTool.decompress.exec(result)\\r\\n                    break;\\r\\n            }\\r\\n            result = JSON.parse(result);\\r\\n        } catch (e) {\\r\\n            log(e.message)\\r\\n            throw \\\"导入数据不合法\\\"\\r\\n        }\\r\\n        return result;\\r\\n    }\\r\\n}\"}],\"saved\":false,\"title\":\"青豆\",\"version\":0,\"url\":\"hiker://empty#immersiveTheme#?type=movie&id=36081094;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 11；； Mi 10 Pro) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.152 Mobile Safari/537.36}\",\"col_type\":\"movie_1_vertical_pic\",\"find_rule\":\"js:(\\n(type, id, title, useConfig) => {\\n    eval(JSON.parse(request(\\\"hiker://page/main\\\")).rule);\\n    if (type === \\\"playlist\\\") {\\n        douList(id, MY_PAGE, 50);\\n    } else {\\n        eval(useConfig);\\n    }\\n}\\n)(\\\"movie\\\",\\\"36081094\\\",\\\"热辣滚烫\\\",\\\"eval(JSON.parse(request('hiker://page/main')).rule);detailsView(type, id);\\\")\",\"group\":\"①推荐\",\"ua\":\"mobile\",\"preRule\":\"let file = \\\"hiker://files/rules/joker/qdb_config.js\\\";\\nlet bakfile = \\\"hiker://files/rules/joker/qdb_config.js.bak\\\";\\ntry {\\n    let defaultConfigs = $.require(\\\"hiker://page/defaultConfigs?rule=青豆\\\");\\n    if (!fileExist(file)) {\\n        writeFile(file, JSON.stringify(defaultConfigs));\\n    }else{\\n        try{\\n            let config = JSON.parse(fetch(file));\\n            config.detailsViewConfigs[\\\"默认\\\"] = defaultConfigs.detailsViewConfigs[\\\"默认\\\"];\\n            config.homePageConfigs[\\\"默认\\\"] = defaultConfigs.homePageConfigs[\\\"默认\\\"];\\n            writeFile(file, JSON.stringify(config));\\n        }catch(e){\\n            writeFile(bakfile, fetch(file));\\n            writeFile(file, JSON.stringify(defaultConfigs));\\n        }\\n    }\\n    putMyVar(\\\"qdb_config\\\", file);\\n} catch (e) {\\n    let pos = \\\"预处理\\\";\\n    eval(JSON.parse(request(\\\"hiker://page/urgencyMode?rule=青豆\\\")).rule)\\n}\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"配置编辑界面\\\",\\\"path\\\":\\\"setting-editor\\\",\\\"rule\\\":\\\"js:\\\\n/**\\\\n * 通过传入 params 对象生成编辑界面\\\\n * @param d 视界 setResult 用的列表\\\\n * @param configKey config 的 key 值，比如我要拿 config.detailsViewConfigs，configKey 就传 \\\\\\\"detailsViewConfigs\\\\\\\"\\\\n * @param params 编辑界面的配置\\\\n *\\\\n * 【params对象数据示例】\\\\n * {\\\\n        key: \\\\\\\"input_name\\\\\\\",\\\\n        desc: \\\\\\\"请输入名称\\\\\\\",\\\\n        type: 'textarea',\\\\n        data: {\\\\n            config: {\\\\n                key: \\\\\\\"input_code\\\\\\\",\\\\n                desc: \\\\\\\"请输入输入配置\\\\\\\",\\\\n                type: 'textarea'\\\\n            },\\\\n        }\\\\n    }\\\\n */\\\\nfunction modeEditPage(d, configKey, params) {\\\\n    addListener('onClose', $.toString((params) => {\\\\n        clearMyVar(params.key)\\\\n        let datas = params.data;\\\\n        let dataKeys = Object.keys(datas);\\\\n        for (let i in dataKeys) {\\\\n            let dataKey = dataKeys[i]\\\\n            clearMyVar(datas[dataKey].key)\\\\n        }\\\\n    }, params))\\\\n    d.push({\\\\n        title: \\\\\\\"保存\\\\\\\",\\\\n        desc: params.desc,\\\\n        col_type: 'input',\\\\n        extra: {\\\\n            titleVisible: false,\\\\n            defaultValue: getMyVar(params.key, \\\\\\\"\\\\\\\"),\\\\n            type: params.type ? params.type : '',\\\\n            onChange: 'putMyVar(\\\\\\\"' + params.key + '\\\\\\\", input)'\\\\n        }\\\\n    })\\\\n    let datas = params.data;\\\\n    let dataKeys = Object.keys(datas);\\\\n    for (let dataKey of dataKeys) {\\\\n        let data = datas[dataKey]\\\\n        d.push({\\\\n            title: \\\\\\\"保存\\\\\\\",\\\\n            desc: data.desc,\\\\n            col_type: 'input',\\\\n            extra: {\\\\n                titleVisible: false,\\\\n                defaultValue: getMyVar(data.key, \\\\\\\"\\\\\\\"),\\\\n                type: data.type ? data.type : '',\\\\n                height: 5,\\\\n                highlight: true,\\\\n                onChange: 'putMyVar(\\\\\\\"' + data.key + '\\\\\\\", input)'\\\\n            }\\\\n        })\\\\n    }\\\\n    d.push({\\\\n        title: '保存',\\\\n        col_type: 'text_center_1',\\\\n        url: $('hiker://empty#noLoading#').lazyRule((configKey, params) => {\\\\n            let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n            let name = getMyVar(params.key, \\\\\\\"\\\\\\\");\\\\n            if(name == '默认') return 'toast://默认配置无法编辑'\\\\n            config[configKey].use = name\\\\n            if (!config[configKey][name]) config[configKey][name] = {}\\\\n            let datas = params.data;\\\\n            let dataKeys = Object.keys(datas);\\\\n            for (let i in dataKeys) {\\\\n                let dataKey = dataKeys[i]\\\\n                let data = datas[dataKey]\\\\n                config[configKey][name][dataKey] = getMyVar(data.key, \\\\\\\"\\\\\\\");\\\\n            }\\\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n            back();\\\\n            return 'toast://保存成功'\\\\n        }, configKey, params)\\\\n    })\\\\n}\\\\n\\\\n//自定义首页-配置编辑页面\\\\nfunction homePageModeEditPage(d) {\\\\n    d.push({\\\\n        title: '<font color=\\\\\\\"red\\\\\\\">' + '返回数组,供setResult使用' + '</font>' + '<font color=\\\\\\\"#808080\\\\\\\"><br>' + '【内置函数】' + '<br>&nbsp;&nbsp;&nbsp;hiker://page/settingPage: 设置页(默认首页有使用示例)' + '</font>',\\\\n        col_type: 'rich_text'\\\\n    })\\\\n    modeEditPage(d, \\\\\\\"homePageConfigs\\\\\\\", {\\\\n        key: \\\\\\\"input_name\\\\\\\",\\\\n        desc: \\\\\\\"请输入名称\\\\\\\",\\\\n        // type: 'input'\\\\n        data: {\\\\n            config: {\\\\n                key: \\\\\\\"input_code\\\\\\\",\\\\n                desc: \\\\\\\"请输入配置代码\\\\\\\",\\\\n                type: 'textarea'\\\\n            }\\\\n        }\\\\n    })\\\\n}\\\\n\\\\n//自定义详情页面-配置编辑页面\\\\nfunction detailViewModeEditPage(d) {\\\\n    d.push({\\\\n        title: '<font color=\\\\\\\"#808080\\\\\\\">' + '【内置变量】' + '<br>&nbsp;&nbsp;&nbsp;id: 片单id' + '<br>&nbsp;&nbsp;&nbsp;type: 片单类型' + '<br>&nbsp;&nbsp;&nbsp;title: 片单标题' + '</font>',\\\\n        col_type: 'rich_text'\\\\n    })\\\\n    modeEditPage(d, \\\\\\\"detailsViewConfigs\\\\\\\", {\\\\n        key: \\\\\\\"input_name\\\\\\\",\\\\n        desc: \\\\\\\"请输入名称\\\\\\\",\\\\n        // type: 'input'\\\\n        data: {\\\\n            config: {\\\\n                key: \\\\\\\"input_code\\\\\\\",\\\\n                desc: \\\\\\\"请输入配置代码\\\\\\\",\\\\n                type: 'textarea'\\\\n            },\\\\n            setting: {\\\\n                key: \\\\\\\"input_setting_code\\\\\\\",\\\\n                desc: \\\\\\\"请输入设置页面代码\\\\\\\",\\\\n                type: 'textarea'\\\\n            }\\\\n        }\\\\n    })\\\\n}\\\\n\\\\n//自定义解析-编辑页面\\\\nfunction analysisModeEditPage(d) {\\\\n    d.push({\\\\n        title: '<font color=\\\\\\\"#808080\\\\\\\">' + '【解析代码内置变量】' + '<br>&nbsp;&nbsp;&nbsp;input: 视频链接' + '</font>',\\\\n        col_type: 'rich_text'\\\\n    })\\\\n    modeEditPage(d, \\\\\\\"analysisConfigs\\\\\\\", {\\\\n        key: \\\\\\\"input_name\\\\\\\",\\\\n        desc: \\\\\\\"请输入名称\\\\\\\",\\\\n        // type: 'input'\\\\n        data: {\\\\n            config: {\\\\n                key: \\\\\\\"input_code\\\\\\\",\\\\n                desc: \\\\\\\"请输入解析代码\\\\\\\",\\\\n                type: 'textarea'\\\\n            },\\\\n            extra: {\\\\n                key: 'input_extra',\\\\n                desc: '请输入extra属性值',\\\\n                type: 'textarea'\\\\n            },\\\\n            setting: {\\\\n                key: \\\\\\\"input_setting_code\\\\\\\",\\\\n                desc: \\\\\\\"请输入设置页面代码\\\\\\\",\\\\n                type: 'textarea'\\\\n            }\\\\n        }\\\\n    })\\\\n}\\\\n\\\\nlet d = [];\\\\nlet view = getParam(\\\\\\\"view\\\\\\\",\\\\\\\"\\\\\\\");\\\\nif(view==\\\\\\\"analysisModeEditPage\\\\\\\"){\\\\n    setPageTitle(\\\\\\\"自定义解析编辑\\\\\\\")\\\\n    analysisModeEditPage(d);\\\\n}else if(view==\\\\\\\"detailViewModeEditPage\\\\\\\"){\\\\n    setPageTitle(\\\\\\\"自定义详情页编辑\\\\\\\")\\\\n    detailViewModeEditPage(d);\\\\n}else if(view==\\\\\\\"homePageModeEditPage\\\\\\\"){\\\\n    setPageTitle(\\\\\\\"自定义首页编辑\\\\\\\")\\\\n    homePageModeEditPage(d);\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"解除被封ip\\\",\\\"path\\\":\\\"releaseIP\\\",\\\"rule\\\":\\\"js:\\\\nlet id = getParam('id');\\\\nlet d = [];\\\\nd.push({\\\\n    title: '您已被封禁IP地址或触发了人机验证，请按照以下步骤处理(如不处理您将在一段时间内无法正常获取剧集列表)',\\\\n    url: 'hiker://empty',\\\\n    col_type: 'text_1'\\\\n});\\\\nd.push({\\\\n    title: '1.点击此处导入自动获取Cookie插件',\\\\n    url: $()\\\\n        .lazyRule(() => {\\\\n            let getDoubanCookie = \\\\\\\"(function(){if(window['location']['host']=='www.douban.com'){fy_bridge_app['writeFile']('hiker://files/cache/doubancookie.txt',fy_bridge_app['getCookie']('https://www.douban.com/'));}if(window['location']['host']=='m.douban.com'){fy_bridge_app['writeFile']('hiker://files/cache/doubancookie.txt',fy_bridge_app['getCookie']('https://m.douban.com/'));}}());\\\\\\\"\\\\n            if (!fileExist('hiker://files/cache/global_getDoubanCookie.js')) {\\\\n                writeFile('hiker://files/cache/global_getDoubanCookie.js', getDoubanCookie);\\\\n            };\\\\n            return 'rule://' + base64Encode('海阔视界，网页插件￥js_url￥global_getDoubanCookie@hiker://files/cache/global_getDoubanCookie.js');\\\\n        }),\\\\n    col_type: 'text_1'\\\\n});\\\\nd.push({\\\\n    title: '2.点击此处进入网页进行登录或人机验证，完成后返回此页面',\\\\n    url: 'https://movie.douban.com/subject/' + id + '/',\\\\n    col_type: 'text_1'\\\\n});\\\\nd.push({\\\\n    title: '3.完成登录或人机验证后返回影片详情页面重新进入',\\\\n    url: 'hiker://empty',\\\\n    col_type: 'text_1'\\\\n});\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"抢救页面\\\",\\\"path\\\":\\\"urgencyMode\\\",\\\"rule\\\":\\\"js:\\\\nlet d = [];\\\\n\\\\nd.push({\\\\n  title: '很明显,出了一些小问题,建议查看设置',\\\\n  desc: \\\\\\\"出错位置:\\\\\\\" + (typeof(pos) == 'undefined' ? '未知' : pos),\\\\n  col_type: 'text_center_1',\\\\n  url: 'hiker://empty',\\\\n});\\\\n\\\\nd.push({\\\\n    title: '点我进入设置页',\\\\n    col_type: 'text_1',\\\\n    url: \\\\\\\"hiker://page/settingPage\\\\\\\"\\\\n})\\\\n\\\\nd.push({\\\\n  title: '若修改设置不起作用,点我复制错误信息提交给开发者',\\\\n  desc: e.toString(),\\\\n  col_type: 'text_1',\\\\n  url: 'copy://' + e.toString(),\\\\n});\\\\n\\\\nsetResult(d);\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"顺佬专用详情页\\\",\\\"path\\\":\\\"Sdetail\\\",\\\"rule\\\":\\\"js:\\\\neval(MY_RULE.preRule);\\\\neval(JSON.parse(request(\\\\\\\"hiker://page/main\\\\\\\")).rule);\\\\nlet type = getParam('type', ''),\\\\n    id = getParam('id', '');\\\\ndetailsView(type, id);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"主代码\\\",\\\"path\\\":\\\"main\\\",\\\"rule\\\":\\\"let version = 202402170001;\\\\r\\\\neval(JSON.parse(request('hiker://page/utils')).rule);\\\\r\\\\n\\\\r\\\\nlet parseVideoUrlLazy = $.toString(() => {\\\\r\\\\n    eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n    let analysisConfigs = getConfig('analysisConfigs');\\\\r\\\\n    let analysisConfig = analysisConfigs[analysisConfigs.use].config;\\\\r\\\\n    let result = \\\\\\\"toast://解析失败\\\\\\\";\\\\r\\\\n    try {\\\\r\\\\n        if (analysisConfig.startsWith(\\\\\\\"(\\\\\\\")) {\\\\r\\\\n            eval('result = ' + analysisConfig);\\\\r\\\\n        } else {\\\\r\\\\n            eval('result = ' + '(() => {' + analysisConfig + '})()');\\\\r\\\\n        }\\\\r\\\\n    } catch (e) {}\\\\r\\\\n    return result;\\\\r\\\\n})\\\\r\\\\n\\\\r\\\\n//首页\\\\r\\\\nfunction home() {\\\\r\\\\n    if (getItem(\\\\\\\"start\\\\\\\", \\\\\\\"\\\\\\\") == \\\\\\\"\\\\\\\") {\\\\r\\\\n        setItem(\\\\\\\"start\\\\\\\", \\\\\\\"1\\\\\\\");\\\\r\\\\n        setItem('update', String(version));\\\\r\\\\n        confirm({\\\\r\\\\n            title: '温馨提示',\\\\r\\\\n            content: '此规则仅限学习交流使用\\\\\\\\n请于导入后24小时内删除!\\\\\\\\n\\\\\\\\n任何组织或个人不得以任何方式方法\\\\\\\\n传播此规则的整体或部分!!\\\\\\\\n\\\\\\\\n感谢大佬们提供的技术支持!!!',\\\\r\\\\n            confirm: '',\\\\r\\\\n            cancel: ''\\\\r\\\\n        })\\\\r\\\\n    } else {\\\\r\\\\n        let updateInfo = getItem('update', '');\\\\r\\\\n        if (updateInfo == '' || parseInt(updateInfo) < version) {\\\\r\\\\n            setItem('update', String(version));\\\\r\\\\n            confirm({\\\\r\\\\n                title: '本次更新内容',\\\\r\\\\n                content: '降低配置文件出错概率',\\\\r\\\\n                confirm: '',\\\\r\\\\n                cancel: ''\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n    addListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\r\\\\n        clearMyVar(\\\\\\\"qdb_config\\\\\\\");\\\\r\\\\n    }))\\\\r\\\\n    let homePageConfigs = getConfig('homePageConfigs');\\\\r\\\\n    let homePageConfig = homePageConfigs[homePageConfigs.use].config;\\\\r\\\\n    if (homePageConfig.startsWith(\\\\\\\"(\\\\\\\")) {\\\\r\\\\n        eval('d = ' + homePageConfig)\\\\r\\\\n    } else {\\\\r\\\\n        eval('d = ' + '(() => {' + homePageConfig + '})()')\\\\r\\\\n    }\\\\r\\\\n    setResult(d);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//海阔搜索\\\\r\\\\nfunction search() {\\\\r\\\\n    let wd = MY_URL.split(\\\\\\\"/#/\\\\\\\")[1];\\\\r\\\\n    let page = MY_PAGE;\\\\r\\\\n    let s = getDoubanRes('https://frodo.douban.com/api/v2/search/subjects?type=movie&q=' + wd + (page ? '&start=' + (page - 1) * 20 : '&start=0') + '&count=20');\\\\r\\\\n\\\\r\\\\n    let list = s.items;\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n\\\\r\\\\n    let items = [];\\\\r\\\\n    list.forEach(data => {\\\\r\\\\n        if (data.target_type == 'doulist_cards') {\\\\r\\\\n            data.target.doulists.forEach(e => {\\\\r\\\\n                items.push({\\\\r\\\\n                    title: e.title,\\\\r\\\\n                    url: $('hiker://empty/$page{fypage}#noHistory#')\\\\r\\\\n                        .rule((type, id) => {\\\\r\\\\n                            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                            if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                                douList(id, MY_PAGE, 50);\\\\r\\\\n                            } else if (type == \\\\\\\"collection\\\\\\\" || type == \\\\\\\"chart\\\\\\\") {\\\\r\\\\n                                subjectCollectionList(MY_PAGE, 50, id);\\\\r\\\\n                            }\\\\r\\\\n                        }, e.target_type, e.id),\\\\r\\\\n                    img: e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url\\\\r\\\\n                })\\\\r\\\\n            })\\\\r\\\\n        } else if (data.target_type == 'chart') {\\\\r\\\\n            let e = data.target;\\\\r\\\\n            items.push({\\\\r\\\\n                title: e.title,\\\\r\\\\n                url: $('hiker://empty/$page{fypage}#noHistory#')\\\\r\\\\n                    .rule((type, id) => {\\\\r\\\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                        if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                            douList(id, MY_PAGE, 50);\\\\r\\\\n                        } else if (type == \\\\\\\"collection\\\\\\\" || type == \\\\\\\"chart\\\\\\\") {\\\\r\\\\n                            subjectCollectionList(MY_PAGE, 50, id);\\\\r\\\\n                        }\\\\r\\\\n                    }, data.target_type, e.id),\\\\r\\\\n                img: e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url\\\\r\\\\n            })\\\\r\\\\n        } else {\\\\r\\\\n            let type = data.target_type,\\\\r\\\\n                id = data.target.id,\\\\r\\\\n                title = data.target.title;\\\\r\\\\n            let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n            let urlParams = {};\\\\r\\\\n            if (useConfig.startsWith('{')) {\\\\r\\\\n                eval('urlParams = ' + useConfig);\\\\r\\\\n            } else {\\\\r\\\\n                urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id)\\\\r\\\\n                    .rule((type, id, title, useConfig) => {\\\\r\\\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                        if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                            douList(id, MY_PAGE, 50);\\\\r\\\\n                        } else {\\\\r\\\\n                            eval(useConfig);\\\\r\\\\n                        }\\\\r\\\\n                    }, type, id, title, useConfig);\\\\r\\\\n            }\\\\r\\\\n            items.push({\\\\r\\\\n                title: title,\\\\r\\\\n                img: data.target.cover_url + \\\\\\\"@Referer=\\\\\\\" + data.target.cover_url,\\\\r\\\\n                desc: data.type_name,\\\\r\\\\n                content: data.target.card_subtitle,\\\\r\\\\n                url: urlParams.url,\\\\r\\\\n                extra: urlParams.extra\\\\r\\\\n            });\\\\r\\\\n        }\\\\r\\\\n\\\\r\\\\n    });\\\\r\\\\n\\\\r\\\\n    setSearchResult({\\\\r\\\\n        data: items\\\\r\\\\n    });\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//二级页面\\\\r\\\\nfunction erji() {\\\\r\\\\n    addListener(\\\\\\\"onClose\\\\\\\", $.toString(() => {\\\\r\\\\n        clearMyVar(\\\\\\\"findList\\\\\\\");\\\\r\\\\n        clearMyVar(\\\\\\\"hotList\\\\\\\");\\\\r\\\\n        clearMyVar(\\\\\\\"classlist\\\\\\\");\\\\r\\\\n        clearMyVar(\\\\\\\"playlist\\\\\\\");\\\\r\\\\n        clearMyVar(\\\\\\\"rankList\\\\\\\");\\\\r\\\\n        clearMyVar(\\\\\\\"ranking\\\\\\\");\\\\r\\\\n        clearMyVar(\\\\\\\"coming\\\\\\\");\\\\r\\\\n        clearMyVar(\\\\\\\"analysis\\\\\\\");\\\\r\\\\n    }))\\\\r\\\\n\\\\r\\\\n    let choice = MY_URL.split('/#/')[1].split('#')[0];\\\\r\\\\n    let d = [];\\\\r\\\\n    switch (choice) {\\\\r\\\\n        case \\\\\\\"推荐\\\\\\\":\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            d = findList(MY_PAGE, 10);\\\\r\\\\n            break;\\\\r\\\\n        case \\\\\\\"热门\\\\\\\":\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            d = hotList(MY_PAGE, 10);\\\\r\\\\n            break;\\\\r\\\\n        case \\\\\\\"分类\\\\\\\":\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            d = classList(MY_PAGE, 15);\\\\r\\\\n            break;\\\\r\\\\n        case \\\\\\\"片单\\\\\\\":\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            d = playList(MY_PAGE, 10);\\\\r\\\\n            break;\\\\r\\\\n        case \\\\\\\"榜单\\\\\\\":\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            d = rankList(MY_PAGE, 10);\\\\r\\\\n            break;\\\\r\\\\n        case \\\\\\\"将上映\\\\\\\":\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            d = comingList(MY_PAGE, 10);\\\\r\\\\n            break;\\\\r\\\\n    }\\\\r\\\\n    setResult(d);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//获取豆瓣资源,返回json数据\\\\r\\\\nfunction getDoubanRes(url) {\\\\n    //log(url)\\\\r\\\\n    var cc =null;\\\\r\\\\n    if($.type(url)=='object'){\\\\r\\\\n         cc=url.cc;\\\\r\\\\n         url = url.url;\\\\r\\\\n    }\\\\r\\\\n    var _url = url;\\\\r\\\\n    if (url.indexOf('apikey') === -1) {\\\\r\\\\n        _url += (url.indexOf('?') === -1 ? '?' : '&') + \\\\\\\"apikey=0dad551ec0f84ed02907ff5c42e8ec70\\\\\\\"\\\\r\\\\n    }\\\\r\\\\n    let _ts = parseInt(Date.now()/1000).toString();\\\\r\\\\n    let m = 'GET&' + encodeURIComponent(url.split('douban.com')[1].split('?')[0]) + '&' + _ts;\\\\r\\\\n    eval(getCryptoJS());\\\\r\\\\n    let _sig = hexToBase64(CryptoJS.HmacSHA1(m,'bf7dddc7c9cfe6f7').toString());\\\\r\\\\n    _url += '&_sig=' + _sig +'&_ts=' + _ts;\\\\r\\\\n    //let cookieCache = 'hiker://files/cache/doubancookie.txt';\\\\r\\\\n    let s = fetch(_url, {\\\\r\\\\n        headers: {\\\\r\\\\n            //'Cookie': fetch(cookieCache),\\\\r\\\\n            \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Rexxar-Core/0.1.3 api-client/1 com.douban.frodo/7.9.0.beta2(215) Android/25 product/TAS-AL00 vendor/HUAWEI model/TAS-AL00  rom/android  network/wifi  platform/mobile com.douban.frodo/7.9.0.beta2(215) Rexxar/1.2.151  platform/mobile 1.2.151\\\\\\\"\\\\r\\\\n        },\\\\r\\\\n        method: 'GET'\\\\r\\\\n        //body: 'host=frodo.douban.com'\\\\r\\\\n    });\\\\r\\\\n    let json = JSON.parse(s);\\\\r\\\\n    if(json.localized_message){\\\\r\\\\n        cc= cc==null ? 1 : cc+1;\\\\r\\\\n        log('重试次数:'+cc);\\\\r\\\\n        if(cc>5){throw new Error('超时')}\\\\r\\\\n        java.lang.Thread.sleep(1000);\\\\r\\\\n        return getDoubanRes({url:url,cc:cc});\\\\r\\\\n    }else{\\\\r\\\\n        return json;\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//根据评分信息获取评分星星样式\\\\r\\\\nfunction computeRating(e, t) {\\\\r\\\\n    let i = \\\\\\\"\\\\\\\";\\\\r\\\\n    for (let r = 0; r < 5; r++) r < Math.round(t / (e / 5)) ? i += \\\\\\\"★\\\\\\\" : i += \\\\\\\"☆\\\\\\\";\\\\r\\\\n    return i;\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//评分详情页面\\\\r\\\\nfunction rating(type, id, ratingCount) {\\\\r\\\\n    setPageTitle('影片信息');\\\\r\\\\n    //评分统计\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/rating\\\\\\\");\\\\r\\\\n\\\\r\\\\n    let r = \\\\\\\"<h2>评分统计</h2>\\\\\\\";\\\\r\\\\n\\\\r\\\\n    r += '<small><font color=\\\\\\\"grey\\\\\\\">' + ratingCount + '人评分' + '</font></small><br/>';\\\\r\\\\n\\\\r\\\\n    let starColor = getConfig('starColor');\\\\r\\\\n    if (i.stats.length == 0) {\\\\r\\\\n        i.stats = [0, 0, 0, 0, 0];\\\\r\\\\n    }\\\\r\\\\n    i.stats.reverse().forEach(((value, index) => {\\\\r\\\\n        r += '<font color=' + starColor + '>' + [\\\\\\\"★★★★★\\\\\\\", \\\\\\\"★★★★☆\\\\\\\", \\\\\\\"★★★☆☆\\\\\\\", \\\\\\\"★★☆☆☆\\\\\\\", \\\\\\\"★☆☆☆☆\\\\\\\"][index] + \\\\\\\"</font>&nbsp;\\\\\\\";\\\\r\\\\n\\\\r\\\\n        r += function(e) {\\\\r\\\\n            let t1 = '';\\\\r\\\\n            for (let i = 0; i < e; i++) t1 += \\\\\\\"▇\\\\\\\";\\\\r\\\\n            let t2 = '';\\\\r\\\\n            for (let i = 0; i < 10 - e; i++) t2 += \\\\\\\"▇\\\\\\\";\\\\r\\\\n            return t1.fontcolor('#ffac2d') + t2.fontcolor('#e5e1e4');\\\\r\\\\n        }((10 * value).toFixed(0));\\\\r\\\\n\\\\r\\\\n        r += '&nbsp;<small><font color=\\\\\\\"grey\\\\\\\">' + (100 * value)\\\\r\\\\n            .toFixed(1) + \\\\\\\"%</font></small><br/>\\\\\\\";\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    r += [i.done_count ? i.done_count + \\\\\\\"人看过\\\\\\\" : \\\\\\\"\\\\\\\", i.doing_count ? i.doing_count + \\\\\\\"人在看\\\\\\\" : \\\\\\\"\\\\\\\", i.wish_count ? i.wish_count + \\\\\\\"人想看\\\\\\\" : \\\\\\\"\\\\\\\"].join(\\\\\\\"&nbsp;&nbsp;\\\\\\\")\\\\r\\\\n        .small()\\\\r\\\\n        .fontcolor('grey');\\\\r\\\\n    //影片信息\\\\r\\\\n    i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/desc\\\\\\\");\\\\r\\\\n    let l = i.html.replace(/[\\\\\\\\n\\\\\\\\t\\\\\\\\r]/g, \\\\\\\"\\\\\\\")\\\\r\\\\n        .replace(/<td\\\\\\\\s*[^>]*>(.*?)<\\\\\\\\/td>/g, \\\\\\\"<span>$1</span>\\\\\\\")\\\\r\\\\n        .replace(/<tr\\\\\\\\s*[^>]*>(.*?)<\\\\\\\\/tr>/g, \\\\\\\"<teng>$1</teng><br/>\\\\\\\");\\\\r\\\\n    parseDomForArray(l, \\\\\\\"section&&teng\\\\\\\").forEach((e => {\\\\r\\\\n        let t = parseDomForArray(e, \\\\\\\"span\\\\\\\");\\\\r\\\\n        l = l.replace(t[0], '<font color=\\\\\\\"grey\\\\\\\">' + t[0].replace(/<span\\\\\\\\s*[^>]*>(.*?)<\\\\\\\\/span>/g, \\\\\\\"$1\\\\\\\") + \\\\\\\"：</font>\\\\\\\")\\\\r\\\\n    }));\\\\r\\\\n    r += l;\\\\r\\\\n    //获奖记录\\\\r\\\\n    let page = MY_PAGE;\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/awards?start=\\\\\\\" + 20 * (page - 1) + \\\\\\\"&count=20\\\\\\\");\\\\r\\\\n    r += \\\\\\\"<h2>获奖记录\\\\\\\" + '<small><font color=\\\\\\\"grey\\\\\\\">' + (s.total != 0 ? '(共' + s.total + '项)' : '(暂无)') + '</font></small>' + \\\\\\\"</h2>\\\\\\\";\\\\r\\\\n    //r += '<font color=\\\\\\\"grey\\\\\\\">' + (s.total != 0 ? '共' + s.total + '项' : '暂无') + '</font><br/>';\\\\r\\\\n    let r2 = '';\\\\r\\\\n    s.awards.forEach(e => {\\\\r\\\\n        r2 += (e.ceremony.title + '(' + e.ceremony.year + ')').big().bold() + '<small>(<a href=\\\\\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);awardView(`' + e.ceremony.id + '`,`' + e.ceremony.title + '`);\\\\\\\">查看详情</a>)</small>' + '<br/>';\\\\r\\\\n        e.categories.forEach(item => {\\\\r\\\\n            r2 += (item.category.title + (item.is_won ? '' : '(提名)') + '&nbsp;').fontcolor(\\\\\\\"grey\\\\\\\");\\\\r\\\\n            r2 += item.celebrities.map(celebrity => celebrity.name).join('&nbsp;/&nbsp;');\\\\r\\\\n            r2 += '<br/>';\\\\r\\\\n        })\\\\r\\\\n        r2 += '<br/>';\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    if (page == 1) {\\\\r\\\\n        setHomeResult({\\\\r\\\\n            data: [{\\\\r\\\\n                title: r + r2,\\\\r\\\\n                col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n            }]\\\\r\\\\n        })\\\\r\\\\n    } else if(s.awards.length == 0){\\\\r\\\\n        setResult([]);\\\\r\\\\n    } else{\\\\r\\\\n        setHomeResult({\\\\r\\\\n            data: [{\\\\r\\\\n                title: r2,\\\\r\\\\n                col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n            }]\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//奖项详情页面\\\\r\\\\nfunction awardView(id, name) {\\\\r\\\\n    setPageTitle(name);\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/ceremony/\\\\\\\" + id);\\\\r\\\\n    let a = [];\\\\r\\\\n    a.push({\\\\r\\\\n        title: '““””' + (s.title + '(' + s.year + ')').big().bold(),\\\\r\\\\n        col_type: 'text_1',\\\\r\\\\n        extra: {\\\\r\\\\n            lineVisible: false\\\\r\\\\n        }\\\\r\\\\n    })\\\\r\\\\n    s.playlists.forEach(e => {\\\\r\\\\n        a.push({\\\\r\\\\n            title: e.title,\\\\r\\\\n            desc: '共' + e.items_count + '部',\\\\r\\\\n            img: e.cover_url + '@Referer=' + e.cover_url,\\\\r\\\\n            url: $('hiker://empty#noHistory#').rule((id) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                douList(id);\\\\r\\\\n            }, e.id)\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let r = '';\\\\r\\\\n    s.prizes.forEach(e => {\\\\r\\\\n        r += '<h4>获奖名单(' + e.title + ')</h4>';\\\\r\\\\n        e.categories.forEach(t => {\\\\r\\\\n            r += (t.title + '&nbsp;&nbsp;&nbsp;&nbsp;').fontcolor(\\\\\\\"grey\\\\\\\").bold();\\\\r\\\\n            r += t.results.map(item => !!item.info ? item.info + ('&nbsp;-&nbsp;' + item.title + '&nbsp;&nbsp;').fontcolor(\\\\\\\"grey\\\\\\\") : item.title).join('&nbsp;/&nbsp;').bold();\\\\r\\\\n            r += '<br/>';\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n    a.push({\\\\r\\\\n        title: r,\\\\r\\\\n        col_type: 'rich_text'\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let i = [];\\\\r\\\\n    s.ceremonies.forEach(e => {\\\\r\\\\n        i.push({\\\\r\\\\n            title: e.title,\\\\r\\\\n            desc: e.year + '年',\\\\r\\\\n            col_type: 'movie_3',\\\\r\\\\n            img: e.pic.normal + '@Referer=' + e.pic.normal,\\\\r\\\\n            url: $('hiker://empty#noHistory#').rule((id, name) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                awardView(id, name);\\\\r\\\\n            }, e.id, e.title)\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n    if (i.length > 0) {\\\\r\\\\n        i.unshift({\\\\r\\\\n            title: '““””' + '历届回顾'.big().bold(),\\\\r\\\\n            col_type: 'text_1',\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    setResult(a.concat(i));\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//剧照页面\\\\r\\\\nfunction stillsList(type, id) {\\\\r\\\\n    addListener('onClose', 'clearMyVar(\\\\\\\"photo\\\\\\\")');\\\\r\\\\n    let page = MY_PAGE;\\\\r\\\\n    let items = {\\\\r\\\\n        剧照: 'photos',\\\\r\\\\n        海报: 'covers'\\\\r\\\\n    };\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = getMyVar('photo', 'photos');\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n    for (let i in items) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp == items[i] ? '““””' + i.fontcolor(color) : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker://empty').lazyRule((t) => {\\\\r\\\\n                putMyVar('photo', t);\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty';\\\\r\\\\n            }, items[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let r = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/\\\\\\\" + temp + \\\\\\\"?start=\\\\\\\" + 30 * (page - 1) + \\\\\\\"&count=30\\\\\\\");\\\\r\\\\n    let l = r.photos.map((e => ({\\\\r\\\\n        title: e.create_time,\\\\r\\\\n        img: e.image.small.url + \\\\\\\"@Referer=\\\\\\\" + e.image.small.url,\\\\r\\\\n        url: e.image.large.url + \\\\\\\"?type=.jpg@Referer=\\\\\\\" + e.image.large.url + \\\\\\\"?type=.jpg\\\\\\\",\\\\r\\\\n        col_type: \\\\\\\"pic_2\\\\\\\"\\\\r\\\\n    })));\\\\r\\\\n\\\\r\\\\n    if (page == 1) {\\\\r\\\\n        l.unshift({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        if (temp == 'photos') {\\\\r\\\\n            l.unshift({\\\\r\\\\n                title: \\\\\\\"<big>共<strong> \\\\\\\" + r.total + ' </strong>张剧照</big><br/><small><font color=\\\\\\\"grey\\\\\\\">官方剧照：' + r.o + \\\\\\\"张&nbsp;截图：\\\\\\\" + r.c + \\\\\\\"张&nbsp;工作照：\\\\\\\" + r.w + \\\\\\\"张&nbsp;新闻图片：\\\\\\\" + r.n + \\\\\\\"张&nbsp;粉丝图片：\\\\\\\" + r.f + \\\\\\\"张</font></small>\\\\\\\",\\\\r\\\\n                col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n            })\\\\r\\\\n        } else {\\\\r\\\\n            l.unshift({\\\\r\\\\n                title: \\\\\\\"<big>共<strong> \\\\\\\" + r.total + \\\\\\\"</strong>张海报</big>\\\\\\\",\\\\r\\\\n                col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n        l = a.concat(l);\\\\r\\\\n    }\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: l\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//演职人员页面\\\\r\\\\nfunction credits(type, id) {\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/credits\\\\\\\");\\\\r\\\\n    let r = [];\\\\r\\\\n    i.credits.forEach((e => {\\\\r\\\\n        r.push({\\\\r\\\\n            title: e.title,\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        e.celebrities.forEach((e => {\\\\r\\\\n            r.push({\\\\r\\\\n                title: e.name + \\\\\\\"\\\\\\\\n\\\\\\\" + e.latin_name,\\\\r\\\\n                desc: e.character,\\\\r\\\\n                img: e.avatar.normal + \\\\\\\"@Referer=\\\\\\\" + e.avatar.normal,\\\\r\\\\n                col_type: 'movie_1_vertical_pic',\\\\r\\\\n                url: $('hiker://empty#noHistory##immersiveTheme#').rule((e) => {\\\\r\\\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                    elessarView(e.uri.split(\\\\\\\"subject_id=\\\\\\\")[1], e.id, e.name);\\\\r\\\\n                }, e)\\\\r\\\\n            })\\\\r\\\\n        }))\\\\r\\\\n    }));\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: r\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//短评页面\\\\r\\\\nfunction shortCommentList(type, id) {\\\\r\\\\n    addListener('onClose', \\\\\\\"clearMyVar('shortcomment')\\\\\\\");\\\\r\\\\n    let items = {\\\\r\\\\n        热门: 'hot',\\\\r\\\\n        最新: 'latest'\\\\r\\\\n    }\\\\r\\\\n    let u = getMyVar('shortcomment', 'hot');\\\\r\\\\n    let a = [];\\\\r\\\\n    let chooseColor = getConfig('chooseColor') // || \\\\\\\"#FA7298\\\\\\\";\\\\r\\\\n    for (i in items) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: u === items[i] ? '““””<b> <font color=' + chooseColor + '>' + i + ' </font></b>' : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty').lazyRule((t) => {\\\\r\\\\n                putMyVar(\\\\\\\"shortcomment\\\\\\\", t);\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, items[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let page = MY_PAGE;\\\\r\\\\n    let r = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/interests?start=\\\\\\\" + 30 * (page - 1) + \\\\\\\"&count=30&order_by=\\\\\\\" + u);\\\\r\\\\n    let l = [];\\\\r\\\\n    let starColor = getConfig('starColor');\\\\r\\\\n    r.interests.forEach((e => {\\\\r\\\\n        let t = \\\\\\\"\\\\\\\";\\\\r\\\\n        if (e.rating) {\\\\r\\\\n            t = computeRating(e.rating.max, e.rating.value);\\\\r\\\\n        }\\\\r\\\\n        l.push({\\\\r\\\\n            title: e.user.name,\\\\r\\\\n            img: e.user.avatar,\\\\r\\\\n            url: e.user.url,\\\\r\\\\n            col_type: \\\\\\\"avatar\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        l.push({\\\\r\\\\n            title: e.comment + (t ? '<br/><small>看过 <font color=' + starColor + '>' + t + \\\\\\\"</font></small>\\\\\\\" : \\\\\\\"\\\\\\\") + '<br/><small><font color=\\\\\\\"grey\\\\\\\">' + e.vote_count + \\\\\\\"赞•\\\\\\\" + /\\\\\\\\d{4}-\\\\\\\\d{1,2}-\\\\\\\\d{1,2}/g.exec(e.create_time) + \\\\\\\"</font></small>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        l.push({\\\\r\\\\n            col_type: \\\\\\\"line\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    if (page == 1) {\\\\r\\\\n        l.unshift({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        l.unshift({\\\\r\\\\n            title: \\\\\\\"<big>共<strong> \\\\\\\" + r.total + \\\\\\\" </strong>条短评</big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        setHomeResult({\\\\r\\\\n            data: a.concat(l)\\\\r\\\\n        })\\\\r\\\\n    } else {\\\\r\\\\n        setHomeResult({\\\\r\\\\n            data: l\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//剧评页面\\\\r\\\\nfunction dramaReviewList(type, id) {\\\\r\\\\n    addListener('onClose', \\\\\\\"clearMyVar('dramareview')\\\\\\\");\\\\r\\\\n    let items = {\\\\r\\\\n        热门: 'hot',\\\\r\\\\n        最新: 'latest'\\\\r\\\\n    }\\\\r\\\\n    let u = getMyVar('dramareview', 'hot');\\\\r\\\\n    let a = [];\\\\r\\\\n    let chooseColor = getConfig('chooseColor');\\\\r\\\\n    for (i in items) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: u === items[i] ? '““””<b> <font color=' + chooseColor + '>' + i + ' </font></b>' : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty').lazyRule((t) => {\\\\r\\\\n                putMyVar(\\\\\\\"dramareview\\\\\\\", t);\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, items[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let page = MY_PAGE\\\\r\\\\n    let r = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/reviews?start=\\\\\\\" + 15 * (page - 1) + \\\\\\\"&count=15&order_by=\\\\\\\" + u);\\\\r\\\\n    let l = [];\\\\r\\\\n    let starColor = getConfig('starColor');\\\\r\\\\n    r.reviews.forEach((e => {\\\\r\\\\n        let t = \\\\\\\"\\\\\\\";\\\\r\\\\n        if (e.rating) {\\\\r\\\\n            t = computeRating(e.rating.max, e.rating.value);\\\\r\\\\n        }\\\\r\\\\n        let i = e.comments_count ? e.comments_count + \\\\\\\"回复\\\\\\\" : \\\\\\\"\\\\\\\",\\\\r\\\\n            r = e.useful_count ? e.useful_count + \\\\\\\"有用\\\\\\\" : \\\\\\\"\\\\\\\",\\\\r\\\\n            o = e.reshares_count ? e.reshares_count + \\\\\\\"转发\\\\\\\" : \\\\\\\"\\\\\\\";\\\\r\\\\n\\\\r\\\\n        r = i && r ? \\\\\\\"•\\\\\\\" + r : r;\\\\r\\\\n        o = (i || r) && o ? \\\\\\\"•\\\\\\\" + o : o;\\\\r\\\\n        l.push({\\\\r\\\\n            title: e.user.name,\\\\r\\\\n            img: e.user.avatar,\\\\r\\\\n            url: e.user.url,\\\\r\\\\n            col_type: \\\\\\\"avatar\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        l.push({\\\\r\\\\n            title: \\\\\\\"<strong>\\\\\\\" + e.title + \\\\\\\"</strong><br/>\\\\\\\" + e.abstract + '   <small>(<a href=\\\\\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);dramaReviewView(' + e.id + ')\\\\\\\">更多</a>)</small>' + (t ? '<br/><small>看过 <font color=' + starColor + '>' + t + \\\\\\\"</font></small>\\\\\\\" : \\\\\\\"\\\\\\\") + '<br/><small><font color=\\\\\\\"grey\\\\\\\">' + i + r + o + \\\\\\\"</font></small>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        l.push({\\\\r\\\\n            col_type: \\\\\\\"line\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    if (page == 1) {\\\\r\\\\n        l.unshift({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        l.unshift({\\\\r\\\\n            title: \\\\\\\"<big>共<strong> \\\\\\\" + r.total + \\\\\\\" </strong>条剧评</big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n\\\\r\\\\n        setHomeResult({\\\\r\\\\n            data: a.concat(l)\\\\r\\\\n        })\\\\r\\\\n    } else {\\\\r\\\\n        setHomeResult({\\\\r\\\\n            data: l\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//预告片页面\\\\r\\\\nfunction trailers(type, id) {\\\\r\\\\n    setPageTitle('预告-片段-花絮')\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/trailers\\\\\\\").trailers;\\\\r\\\\n    i.forEach((e => {\\\\r\\\\n        e.col_type = \\\\\\\"movie_2\\\\\\\", e.desc = e.subject_title + \\\\\\\"•\\\\\\\" + e.create_time, e.img = e.cover_url, e.url = e.video_url\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    let r = i.filter((e => \\\\\\\"A\\\\\\\" === e.type));\\\\r\\\\n    let l = i.filter((e => \\\\\\\"B\\\\\\\" === e.type));\\\\r\\\\n    let o = i.filter((e => \\\\\\\"C\\\\\\\" === e.type));\\\\r\\\\n\\\\r\\\\n    if (r.length > 0) {\\\\r\\\\n        r.unshift({\\\\r\\\\n            title: \\\\\\\"预告\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    if (l.length > 0) {\\\\r\\\\n        l.unshift({\\\\r\\\\n            title: \\\\\\\"片段\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    if (o.length > 0) {\\\\r\\\\n        o.unshift({\\\\r\\\\n            title: \\\\\\\"花絮\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: r.concat(l)\\\\r\\\\n            .concat(o)\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//视频评论页面\\\\r\\\\nfunction videoComment(type, id) {\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/videos\\\\\\\").videos;\\\\r\\\\n    i.forEach((e => {\\\\r\\\\n        e.col_type = \\\\\\\"movie_2\\\\\\\", e.desc = e.author.name + \\\\\\\"•\\\\\\\" + e.create_time, e.img = e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url, e.url = e.video_url\\\\r\\\\n    }))\\\\r\\\\n    if (i.length > 0) {\\\\r\\\\n        i.unshift({\\\\r\\\\n            title: \\\\\\\"视频评论\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: i\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//演职人员详情页面\\\\r\\\\nfunction elessarView(id, pid, name) {\\\\r\\\\n    setPageTitle(name);\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/elessar/subject/\\\\\\\" + id);\\\\r\\\\n    let a = [];\\\\r\\\\n    a.push({\\\\r\\\\n        title: '““””' + (i.title + '(' + i.latin_title + ')').big().bold(),\\\\r\\\\n        desc: '““””' + i.desc.match(/\\\\\\\\<p\\\\\\\\>.*\\\\\\\\<\\\\\\\\/p\\\\\\\\>/)[0],\\\\r\\\\n        img: i.cover.normal.url + '@Referer=' + i.cover.normal.url,\\\\r\\\\n        col_type: 'movie_1_vertical_pic_blur',\\\\r\\\\n        url: $('hiker://empty').rule((desc, extra, name) => {\\\\r\\\\n            let info = extra.info.map(e => e.join(':&nbsp;'));\\\\r\\\\n            setResult([{\\\\r\\\\n                title: '<h2>' + name + '</h2>' + info.join('<br/>') + desc.match(/\\\\\\\\<p\\\\\\\\>.*\\\\\\\\<\\\\\\\\/p\\\\\\\\>/)[0],\\\\r\\\\n                col_type: 'rich_text'\\\\r\\\\n            }])\\\\r\\\\n        }, i.desc, i.extra, i.title)\\\\r\\\\n    })\\\\r\\\\n    \\\\r\\\\n    let index = i.modules.findIndex(cur => cur.type == \\\\\\\"award_result_collection\\\\\\\");\\\\r\\\\n    if (index > -1) {\\\\r\\\\n        let e = i.modules[index].payload;\\\\r\\\\n        a.push({\\\\r\\\\n            title: '““””' + '获奖记录'.big().bold() + '<small>(共' + e.total + '项)</small>',\\\\r\\\\n            desc: '““””<strong>' + e.awards[0].ceremony.title + '</strong>\\\\\\\\n' + e.awards[0].category.title + (e.awards[0].is_won ? '' : '(提名)'),\\\\r\\\\n            col_type: 'text_center_1',\\\\r\\\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((id, count) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                elessarAwards(id, count);\\\\r\\\\n            }, e.id, e.total),\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    \\\\r\\\\n    index = i.modules.findIndex(cur => cur.type == \\\\\\\"work_collections\\\\\\\");\\\\r\\\\n    if (index > -1) {\\\\r\\\\n        let e2 = i.modules[index].payload;\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: 'line'\\\\r\\\\n        })\\\\r\\\\n        a.push({\\\\r\\\\n            title: '““””' + '影视作品'.big().bold() + ('(共' + e2.collections[0].total + '部)').small(),\\\\r\\\\n            col_type: 'text_center_1',\\\\r\\\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((id, type) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                elessarWorks(id, type);\\\\r\\\\n            }, e2.id, e2.collections[0].title),\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n\\\\r\\\\n        let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n        let works = e2.collections[0].works;\\\\r\\\\n        let length = works.length <= 3 ? works.length : 3;\\\\r\\\\n        for (let i = 0; i < length; i++) {\\\\r\\\\n            let e = works[i];\\\\r\\\\n            let rating = \\\\\\\"\\\\\\\";\\\\r\\\\n            if (e.subject.extra.rating_group.rating) {\\\\r\\\\n                rating = computeRating(e.subject.extra.rating_group.rating.max, e.subject.extra.rating_group.rating.value) + \\\\\\\" \\\\\\\" + e.subject.extra.rating_group.rating.value + \\\\\\\"分\\\\\\\";\\\\r\\\\n            }\\\\r\\\\n\\\\r\\\\n            let type = e.subject.subtype,\\\\r\\\\n                id = e.subject.id,\\\\r\\\\n                title = e.subject.title;\\\\r\\\\n            let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n            let urlParams = {};\\\\r\\\\n            if (useConfig.startsWith('{')) {\\\\r\\\\n                eval('urlParams = ' + useConfig);\\\\r\\\\n            } else {\\\\r\\\\n                urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                    if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                        douList(id, MY_PAGE, 50);\\\\r\\\\n                    } else {\\\\r\\\\n                        eval(useConfig);\\\\r\\\\n                    }\\\\r\\\\n                }, type, id, title, useConfig);\\\\r\\\\n            }\\\\r\\\\n            a.push({\\\\r\\\\n                title: title,\\\\r\\\\n                img: e.subject.cover.normal.url + \\\\\\\"@Referer=\\\\\\\" + e.subject.cover.normal.url,\\\\r\\\\n                desc: rating,\\\\r\\\\n                col_type: 'movie_3',\\\\r\\\\n                url: urlParams.url,\\\\r\\\\n                extra: urlParams.extra\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n        /*a.push({\\\\r\\\\n            title: '查看更多',\\\\r\\\\n            img: 'https://joker-tx.coding.net/p/hikerimg/d/hiker/git/raw/master/img/more_ver.png?download=false',\\\\r\\\\n            col_type: 'movie_3',\\\\r\\\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#')\\\\r\\\\n                .rule((id, type) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                elessarWorks(id, type);\\\\r\\\\n            }, e2.id, e2.collections[0].title)\\\\r\\\\n        })*/\\\\r\\\\n    }\\\\r\\\\n    \\\\r\\\\n    index = i.modules.findIndex(cur => cur.type == \\\\\\\"photos\\\\\\\");\\\\r\\\\n    if (index > -1) {\\\\r\\\\n        let e3 = i.modules[index].payload;\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: 'line'\\\\r\\\\n        })\\\\r\\\\n        a.push({\\\\r\\\\n            title: '““””' + '演员照片'.big().bold() + ('(共' + e3.total + '张)').small(),\\\\r\\\\n            col_type: 'text_center_1',\\\\r\\\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((pid) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                elessarPhotos(pid);\\\\r\\\\n            }, pid),\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n\\\\r\\\\n        let plength = e3.photos.length <= 2 ? e3.photos.length : 2;\\\\r\\\\n        for (let i = 0; i < plength; i++) {\\\\r\\\\n            a.push({\\\\r\\\\n                //title: e3.photos[0].description,\\\\r\\\\n                col_type: 'card_pic_2',\\\\r\\\\n                desc: '0',\\\\r\\\\n                img: e3.photos[i].image.normal.url + '@Referer=' + e3.photos[i].image.normal.url,\\\\r\\\\n                url: e3.photos[i].image.normal.url + '@Referer=' + e3.photos[i].image.normal.url\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n\\\\r\\\\n        /*a.push({\\\\r\\\\n            //title: '查看更多',\\\\r\\\\n            img: 'https://joker-tx.coding.net/p/hikerimg/d/hiker/git/raw/master/img/more.png?download=false',\\\\r\\\\n            col_type: 'card_pic_2',\\\\r\\\\n            desc: '0',\\\\r\\\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#')\\\\r\\\\n                .rule((pid) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                elessarPhotos(pid);\\\\r\\\\n            }, pid)\\\\r\\\\n        })*/\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    setResult(a);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//演职人员获奖详情页面\\\\r\\\\nfunction elessarAwards(id, count) {\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/elessar/award_result_collection/\\\\\\\" + id + \\\\\\\"/awards?start=\\\\\\\" + 30 * (MY_PAGE - 1) + \\\\\\\"&count=30\\\\\\\");\\\\r\\\\n    let l = [];\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    i.awards.forEach(t => {\\\\r\\\\n        l.push({\\\\r\\\\n            title: (t.year+\\\\\\\"\\\\\\\").bold().big(),\\\\r\\\\n            col_type: 'rich_text'\\\\r\\\\n        })\\\\r\\\\n\\\\r\\\\n        for (let i = 0; i < t.modules.length; i++) {\\\\r\\\\n            let e = t.modules[i];\\\\r\\\\n            if (!e.ceremony || !e.category) {\\\\r\\\\n                let rating = \\\\\\\"\\\\\\\";\\\\r\\\\n                if (e.extra.rating_group.rating) {\\\\r\\\\n                    rating = computeRating(e.extra.rating_group.rating.max, e.extra.rating_group.rating.value) + \\\\\\\" \\\\\\\" + e.extra.rating_group.rating.value + \\\\\\\"分\\\\\\\";\\\\r\\\\n                }\\\\r\\\\n                let type = e.subtype,\\\\r\\\\n                    id = e.id,\\\\r\\\\n                    title = e.title;\\\\r\\\\n                let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n                let urlParams = {};\\\\r\\\\n                if (useConfig.startsWith('{')) {\\\\r\\\\n                    eval('urlParams = ' + useConfig);\\\\r\\\\n                } else {\\\\r\\\\n                    urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                        if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                            douList(id, MY_PAGE, 50);\\\\r\\\\n                        } else {\\\\r\\\\n                            eval(useConfig);\\\\r\\\\n                        }\\\\r\\\\n                    }, type, id, title, useConfig);\\\\r\\\\n                }\\\\r\\\\n                l.push({\\\\r\\\\n                    title: title,\\\\r\\\\n                    img: e.cover.normal.url + \\\\\\\"@Referer=\\\\\\\" + e.cover.normal.url,\\\\r\\\\n                    desc: rating + '\\\\\\\\n' + e.extra.short_info,\\\\r\\\\n                    url: urlParams.url,\\\\r\\\\n                    extra: urlParams.extra\\\\r\\\\n                })\\\\r\\\\n            } else {\\\\r\\\\n                l.push({\\\\r\\\\n                    title: e.ceremony.title.bold() + '<small>(<a href=\\\\\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);awardView(`' + e.ceremony.id + '`,`' + e.ceremony.title + '`);\\\\\\\">查看详情</a>)</small>' + '<br/>' + (e.category.title + (e.is_won ? '' : '(提名)')).small(),\\\\r\\\\n                    col_type: 'rich_text'\\\\r\\\\n                })\\\\r\\\\n            }\\\\r\\\\n        }\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    if (MY_PAGE == 1) {\\\\r\\\\n        l.unshift({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        l.unshift({\\\\r\\\\n            title: \\\\\\\"<big>共<strong> \\\\\\\" + count + \\\\\\\" </strong>项获奖记录</big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    setResult(l);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//演职人员作品页面\\\\r\\\\nfunction elessarWorks(id, type) {\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/elessar/work_collections/\\\\\\\" + id + \\\\\\\"/works?start=\\\\\\\" + 30 * (MY_PAGE - 1) + \\\\\\\"&count=30&collection_title=\\\\\\\" + type);\\\\r\\\\n\\\\r\\\\n    let l = [];\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    i.works.forEach((e => {\\\\r\\\\n        let rating = \\\\\\\"\\\\\\\";\\\\r\\\\n        if (e.subject.extra.rating_group.rating) {\\\\r\\\\n            rating = computeRating(e.subject.extra.rating_group.rating.max, e.subject.extra.rating_group.rating.value) + \\\\\\\" \\\\\\\" + e.subject.extra.rating_group.rating.value + \\\\\\\"分\\\\\\\";\\\\r\\\\n        }\\\\n        \\\\n        let year = e.subject.extra ? (e.subject.extra.year ? '('+e.subject.extra.year+')' : '') : '';\\\\r\\\\n\\\\r\\\\n        let type = e.subject.subtype,\\\\r\\\\n            id = e.subject.id,\\\\r\\\\n            title = e.subject.title;\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        l.push({\\\\r\\\\n            title: title + year,\\\\r\\\\n            img: e.subject.cover.normal.url + \\\\\\\"@Referer=\\\\\\\" + e.subject.cover.normal.url,\\\\r\\\\n            desc: e.roles.join(\\\\\\\"•\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\" + rating + '\\\\\\\\n' + e.subject.extra.short_info,\\\\r\\\\n            col_type: 'movie_1_vertical_pic',\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra\\\\r\\\\n        })\\\\r\\\\n    }))\\\\r\\\\n\\\\r\\\\n    if (MY_PAGE == 1) {\\\\r\\\\n        l.unshift({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        l.unshift({\\\\r\\\\n            title: \\\\\\\"<big>共<strong> \\\\\\\" + i.total + \\\\\\\" </strong>部作品</big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: l\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//演职人员照片页面\\\\r\\\\nfunction elessarPhotos(pid) {\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/celebrity/\\\\\\\" + pid + \\\\\\\"/photos?start=\\\\\\\" + 30 * (MY_PAGE - 1) + \\\\\\\"&count=30\\\\\\\");\\\\r\\\\n    let l = [];\\\\r\\\\n    i.photos.forEach(e => {\\\\r\\\\n        l.push({\\\\r\\\\n            col_type: 'card_pic_2',\\\\r\\\\n            desc: '0',\\\\r\\\\n            img: e.image.normal.url + '@Referer=' + e.image.normal.url,\\\\r\\\\n            url: e.image.normal.url + '@Referer=' + e.image.normal.url\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n    if (MY_PAGE == 1) {\\\\r\\\\n        l.unshift({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        l.unshift({\\\\r\\\\n            title: \\\\\\\"<big>共<strong> \\\\\\\" + i.total + \\\\\\\" </strong>张照片</big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    setResult(l);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//剧评详情页面\\\\r\\\\nfunction dramaReviewView(id) {\\\\r\\\\n    setPageTitle('剧评详情');\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/review/\\\\\\\" + id);\\\\r\\\\n\\\\r\\\\n    i.photos.forEach((e => {\\\\r\\\\n        i.content = i.content.replace('id=\\\\\\\"' + e.tag_name + '\\\\\\\"', 'src=\\\\\\\"' + e.image.large.url + \\\\\\\"@Referer=\\\\\\\" + e.image.large.url + '\\\\\\\"')\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    let l = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/review/\\\\\\\" + id + \\\\\\\"/comments\\\\\\\");\\\\r\\\\n    let o = [{\\\\r\\\\n        col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        title: \\\\\\\"<big><strong>评论：</strong></big>\\\\\\\",\\\\r\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n    }];\\\\r\\\\n\\\\r\\\\n    l.comments.length > 0 ? l.comments.forEach((e => {\\\\r\\\\n        o.push({\\\\r\\\\n            title: e.author.name,\\\\r\\\\n            img: e.author.avatar,\\\\r\\\\n            url: e.author.url,\\\\r\\\\n            col_type: \\\\\\\"avatar\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        o.push({\\\\r\\\\n            title: e.text + (e.replies.length > 0 ? ' <small><a href=\\\\\\\"hiker://empty#noHistory#@rule=js:eval(JSON.parse(fetch(`hiker://page/main`)).rule);dramaReviewReplyView(' + e.id + ');\\\\\\\">[查看回复]</a></small>' : \\\\\\\"\\\\\\\"),\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        o.push({\\\\r\\\\n            col_type: \\\\\\\"line\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    })) : o.push({\\\\r\\\\n        title: '<font color=\\\\\\\"grey\\\\\\\">( •̥́ ˍ •̀ू )还没有人评论...</font>',\\\\r\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n    });\\\\r\\\\n\\\\r\\\\n    let a = \\\\\\\"\\\\\\\";\\\\r\\\\n    if (i.rating) {\\\\r\\\\n        a = computeRating(i.rating.max, i.rating.value);\\\\r\\\\n    }\\\\r\\\\n    let color = JSON.parse(fetch(getMyVar('qdb_config')))\\\\r\\\\n        .starColor || \\\\\\\"#ffac2d\\\\\\\";\\\\r\\\\n    let s = [{\\\\r\\\\n        title: \\\\\\\"<big><strong>\\\\\\\" + i.title + \\\\\\\"</strong></big>\\\\\\\",\\\\r\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        title: i.user.name + \\\\\\\" 的剧评\\\\\\\",\\\\r\\\\n        img: i.user.avatar,\\\\r\\\\n        url: i.user.url,\\\\r\\\\n        col_type: \\\\\\\"avatar\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        title: (i.spoiler ? \\\\\\\"<small><font color=#f20c00>这篇影评可能有剧透</font></small><br/>\\\\\\\" : \\\\\\\"\\\\\\\") + (a ? '<small>看过 <font color=' + color + '>' + a + \\\\\\\"</font><br/></small>\\\\\\\" : \\\\\\\"\\\\\\\") + '<small><font color=\\\\\\\"grey\\\\\\\">' + /\\\\\\\\d{4}-\\\\\\\\d{1,2}-\\\\\\\\d{1,2}/g.exec(i.create_time) + \\\\\\\"</font></small>\\\\\\\",\\\\r\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        col_type: \\\\\\\"line_blank\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        title: i.content.replace(/<div\\\\\\\\s*[^>]*>(.*?)<\\\\\\\\/div>/g, \\\\\\\"$1\\\\\\\") + (i.is_original ? '<small><font color=\\\\\\\"grey\\\\\\\">&copy;本文版权归该作者所有，任何形式转载请联系作者。</font></small>' : \\\\\\\"\\\\\\\"),\\\\r\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n    }];\\\\r\\\\n\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: s.concat(o)\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//剧评回复页面\\\\r\\\\nfunction dramaReviewReplyView(id) {\\\\r\\\\n    setPageTitle('回复详情');\\\\r\\\\n    let t = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/review/comment/\\\\\\\" + id + \\\\\\\"/replies\\\\\\\");\\\\r\\\\n    let i = [];\\\\r\\\\n    t.replies.forEach((e => {\\\\r\\\\n        i.push({\\\\r\\\\n            title: e.author.name,\\\\r\\\\n            img: e.author.avatar,\\\\r\\\\n            url: e.author.url,\\\\r\\\\n            col_type: \\\\\\\"avatar\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        i.push({\\\\r\\\\n            title: (e.ref_comment.has_ref ? '回复@<font color=\\\\\\\"blue\\\\\\\">' + e.ref_comment.author.name + \\\\\\\"</font>：\\\\\\\" : \\\\\\\"\\\\\\\") + e.text,\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        i.push({\\\\r\\\\n            col_type: \\\\\\\"line\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }))\\\\r\\\\n\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: i\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//相关推荐页面\\\\r\\\\nfunction recommendations(type, id){\\\\r\\\\n    setPageTitle('相关推荐');\\\\r\\\\n    let res = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\"+ type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/recommendations\\\\\\\");\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    let i = res.map((e => {\\\\r\\\\n        let type = e.type,\\\\r\\\\n            id = e.id,\\\\r\\\\n            title = e.title;\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        return {\\\\r\\\\n            title: title,\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra,\\\\r\\\\n            col_type: 'movie_3',\\\\r\\\\n            img: e.pic ? e.pic.normal + \\\\\\\"@Referer=\\\\\\\" + e.pic.normal : e.cover.url + '@Referer=' + e.cover.url,\\\\r\\\\n            desc: e.null_rating_reason || e.rating.value\\\\r\\\\n        }\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: i\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//影片详情页面\\\\r\\\\nfunction detailsView(type, id) {\\\\r\\\\n    let i = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id);\\\\r\\\\n    setPageTitle(i.title);\\\\r\\\\n    let info = \\\\\\\"\\\\\\\";\\\\r\\\\n    if (i.is_tv) {\\\\r\\\\n        info = [i.countries ? i.countries.join(\\\\\\\" \\\\\\\") : null, i.genres ? i.genres.join(\\\\\\\" \\\\\\\") : null, i.pubdate ? i.pubdate[0] + \\\\\\\"首播\\\\\\\" : null, i.episodes_count ? \\\\\\\"共\\\\\\\" + i.episodes_count + \\\\\\\"集\\\\\\\" : null, i.durations ? \\\\\\\"单集片长\\\\\\\" + i.durations : null].filter((e => null !== e)).join(\\\\\\\" / \\\\\\\");\\\\r\\\\n    } else {\\\\r\\\\n        info = [i.countries ? i.countries.join(\\\\\\\" \\\\\\\") : null, i.genres ? i.genres.join(\\\\\\\" \\\\\\\") : null, i.pubdate ? i.pubdate[0] + \\\\\\\"首播\\\\\\\" : null, i.durations ? \\\\\\\"片长\\\\\\\" + i.durations : null].filter((e => null !== e)).join(\\\\\\\" / \\\\\\\");\\\\r\\\\n    }\\\\r\\\\n    let infoItems = [{\\\\r\\\\n        title: i.title + \\\\\\\"\\\\\\\\n\\\\\\\" + i.original_title + \\\\\\\"(\\\\\\\" + i.year + \\\\\\\")\\\\\\\",\\\\r\\\\n        desc: info || i.card_subtitle,\\\\r\\\\n        img: i.pic.normal + \\\\\\\"@Referer=\\\\\\\" + i.pic.normal,\\\\r\\\\n        col_type: \\\\\\\"movie_1_vertical_pic_blur\\\\\\\",\\\\r\\\\n        url: 'hiker://page/settingPage?view=analysisSettingModule#noHistory#',\\\\r\\\\n        extra: {\\\\r\\\\n            newWindow: true,\\\\r\\\\n            windowId: '高级功能',\\\\r\\\\n            gradient: true\\\\r\\\\n        }\\\\r\\\\n    }];\\\\r\\\\n\\\\r\\\\n    let rating = \\\\\\\"\\\\\\\";\\\\r\\\\n    if (i.rating) {\\\\r\\\\n        rating = computeRating(i.rating.max, i.rating.value);\\\\r\\\\n    }\\\\r\\\\n    let ratingItems = [];\\\\r\\\\n    let color = getConfig('starColor');\\\\r\\\\n    let ratingTitle = ''\\\\r\\\\n    if (rating) {\\\\r\\\\n        ratingTitle = '豆瓣评分™'.big().bold() + '<br>' + rating.fontcolor(color) + '&nbsp;&nbsp;' + (i.rating.value.toFixed(1) + '分').big().bold();\\\\r\\\\n    } else {\\\\r\\\\n        ratingTitle = '暂无评分'.big().bold() + '<br>' + '点我查看影片信息'.fontcolor('grey');\\\\r\\\\n    }\\\\r\\\\n    ratingItems = [{\\\\r\\\\n        title: '““””' + ratingTitle,\\\\r\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\r\\\\n        extra: {\\\\r\\\\n            lineVisible: false\\\\r\\\\n        },\\\\r\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((type, id, ratingCount) => {\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            rating(type, id, ratingCount);\\\\r\\\\n        }, i.subtype, i.id, i.rating ? i.rating.count : 0)\\\\r\\\\n    }];\\\\r\\\\n\\\\r\\\\n    let relatedItems = [{\\\\r\\\\n        title: \\\\\\\"剧照\\\\\\\",\\\\r\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧照.png\\\\\\\",\\\\r\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            stillsList(t[0], t[1]);\\\\r\\\\n        }, [i.subtype, i.id]),\\\\r\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        title: \\\\\\\"演职\\\\\\\",\\\\r\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/演职.png\\\\\\\",\\\\r\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            credits(t[0], t[1]);\\\\r\\\\n        }, [i.subtype, i.id]),\\\\r\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        title: \\\\\\\"短评\\\\\\\",\\\\r\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/短评.png\\\\\\\",\\\\r\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            shortCommentList(t[0], t[1]);\\\\r\\\\n        }, [i.subtype, i.id]),\\\\r\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\r\\\\n    }, {\\\\r\\\\n        title: \\\\\\\"剧评\\\\\\\",\\\\r\\\\n        img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/剧评.png\\\\\\\",\\\\r\\\\n        url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            dramaReviewList(t[0], t[1]);\\\\r\\\\n        }, [i.subtype, i.id]),\\\\r\\\\n        col_type: \\\\\\\"icon_round_small_4\\\\\\\"\\\\r\\\\n    }];\\\\r\\\\n\\\\r\\\\n    let introItems = [];\\\\r\\\\n    if (i.intro) {\\\\r\\\\n        introItems = [{\\\\r\\\\n            title: \\\\\\\"““””<big><strong>剧情简介</strong></big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            },\\\\r\\\\n            url: 'hiker://empty'\\\\r\\\\n        }, {\\\\r\\\\n            title: \\\\\\\"&nbsp;&nbsp;&nbsp;&nbsp;\\\\\\\" + i.intro.replace(/\\\\\\\\n/g, \\\\\\\"<br/>&nbsp;&nbsp;&nbsp;&nbsp;\\\\\\\").replace(/\\\\\\\\s/g, \\\\\\\" \\\\\\\").replace(/\\\\\\\\t/g, \\\\\\\" \\\\\\\"),\\\\r\\\\n            col_type: \\\\\\\"rich_text\\\\\\\"\\\\r\\\\n        }]\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let videoRelatedItems = [];\\\\r\\\\n    if (i.trailer) {\\\\r\\\\n        videoRelatedItems.push({\\\\r\\\\n            title: \\\\\\\"““””<big><strong>预告</strong></big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            },\\\\r\\\\n            url: 'hiker://empty'\\\\r\\\\n        });\\\\r\\\\n        videoRelatedItems.push({\\\\r\\\\n            title: i.trailer.title,\\\\r\\\\n            img: i.trailer.cover_url,\\\\r\\\\n            url: i.trailer.video_url,\\\\r\\\\n            desc: i.trailer.subject_title + \\\\\\\"•\\\\\\\" + i.trailer.create_time,\\\\r\\\\n            col_type: \\\\\\\"movie_2\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        videoRelatedItems.push({\\\\r\\\\n            title: '查看更多',\\\\r\\\\n            img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/more.png\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"movie_2\\\\\\\",\\\\r\\\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                trailers(t[0], t[1]);\\\\r\\\\n            }, [i.subtype, i.id]),\\\\r\\\\n        });\\\\r\\\\n    }\\\\r\\\\n    if (i.video) {\\\\r\\\\n        videoRelatedItems.push({\\\\r\\\\n            title: \\\\\\\"““””<big><strong>视频评论</strong></big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            },\\\\r\\\\n            url: 'hiker://empty'\\\\r\\\\n        });\\\\r\\\\n        videoRelatedItems.push({\\\\r\\\\n            title: i.video.title,\\\\r\\\\n            img: i.video.cover_url + \\\\\\\"@Referer=\\\\\\\" + i.video.cover_url,\\\\r\\\\n            url: i.video.video_url,\\\\r\\\\n            desc: i.video.author.name + \\\\\\\"•\\\\\\\" + i.video.create_time,\\\\r\\\\n            col_type: \\\\\\\"movie_2\\\\\\\"\\\\r\\\\n        });\\\\r\\\\n        videoRelatedItems.push({\\\\r\\\\n            title: '查看更多',\\\\r\\\\n            img: \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/more.png\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"movie_2\\\\\\\",\\\\r\\\\n            url: $('hiker://empty/#/$page{fypage}#noHistory#').rule((t) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                videoComment(t[0], t[1]);\\\\r\\\\n            }, [i.subtype, i.id]),\\\\r\\\\n        });\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\r\\\\n\\\\r\\\\n    let analysisConfigs = getConfig('analysisConfigs', config);\\\\r\\\\n    let extraConfig = analysisConfigs[analysisConfigs.use].extra || '{}';\\\\r\\\\n    let extra = {};\\\\r\\\\n    try {\\\\r\\\\n        if (extraConfig.startsWith('{')) eval('extra=' + extraConfig);\\\\r\\\\n    } catch (e) {}\\\\r\\\\n    let videoItems = [];\\\\r\\\\n    videoUrlsModule(videoItems, type, id, ['icon_2', 'icon_small_4'], parseVideoUrlLazy, i, extra);\\\\r\\\\n    if (videoItems.length > 0) {\\\\r\\\\n        videoItems.unshift({\\\\r\\\\n            title: \\\\\\\"““””<big><strong>在线观看</strong></big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            },\\\\r\\\\n            url: 'hiker://empty'\\\\r\\\\n        })\\\\r\\\\n    } else {\\\\r\\\\n        videoItems.unshift({\\\\r\\\\n            title: \\\\\\\"““””<big><strong>尚无片源</strong></big>\\\\\\\",\\\\r\\\\n            col_type: \\\\\\\"text_center_1\\\\\\\",\\\\r\\\\n            extra: {\\\\r\\\\n                lineVisible: false\\\\r\\\\n            },\\\\r\\\\n            url: 'toast://真的没片源'\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let quickSearchConfigs = getConfig('quickSearchConfigs', config);\\\\r\\\\n    let quickSearchItems = [];\\\\r\\\\n    quickSearchConfigs.order.forEach(quickSearchItem => {\\\\r\\\\n        if (quickSearchConfigs[quickSearchItem]) {\\\\r\\\\n            quickSearchItems.push({\\\\r\\\\n                title: quickSearchItem,\\\\r\\\\n                img: quickSearchConfigs[quickSearchItem].pic,\\\\r\\\\n                col_type: quickSearchConfigs.mode || 'icon_small_4',\\\\r\\\\n                url: 'hiker://search?s=' + i.title + '&rule=' + quickSearchConfigs[quickSearchItem].name\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    })\\\\r\\\\n    if (quickSearchItems.length > 0) {\\\\r\\\\n        quickSearchItems.unshift({\\\\r\\\\n                title: '““””<strong><big>快速搜索</big></strong>',\\\\r\\\\n                col_type: 'text_center_1',\\\\r\\\\n                extra: {\\\\r\\\\n                    lineVisible: false\\\\r\\\\n                },\\\\r\\\\n                url: 'hiker://empty'\\\\r\\\\n            })\\\\r\\\\n            /*quickSearchItems.unshift({\\\\r\\\\n                col_type: 'line'\\\\r\\\\n            })*/\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: infoItems.concat(ratingItems)\\\\r\\\\n            .concat(relatedItems)\\\\r\\\\n            .concat({\\\\r\\\\n                col_type: 'line'\\\\r\\\\n            })\\\\r\\\\n            .concat(quickSearchItems)\\\\r\\\\n            .concat({\\\\r\\\\n                col_type: 'line'\\\\r\\\\n            })\\\\r\\\\n            .concat(videoItems)\\\\r\\\\n            .concat({\\\\r\\\\n                col_type: 'line'\\\\r\\\\n            })\\\\r\\\\n            .concat(videoRelatedItems)\\\\r\\\\n            .concat({\\\\r\\\\n                col_type: 'line'\\\\r\\\\n            })\\\\r\\\\n            .concat(introItems)\\\\r\\\\n            .concat({\\\\r\\\\n                col_type: 'line',\\\\r\\\\n                extra:{\\\\r\\\\n                  id: 'recommendations'\\\\r\\\\n                }\\\\r\\\\n            })\\\\r\\\\n            .concat({\\\\r\\\\n                col_type: 'text_center_1',\\\\r\\\\n                title: '““””<small><font color=#871f78>以上数据来源于豆瓣，如您喜欢，请下载官方app</font></small>',\\\\r\\\\n                desc: '““””<small><font color=#f20c00>此规则仅限学习交流使用，请于导入后24小时内删除，任何组织或个人不得以任何方式方法传播此规则的整体或部分！</font></small>',\\\\r\\\\n                url: 'https://movie.douban.com/subject/' + id + '/',\\\\r\\\\n                extra: {\\\\r\\\\n                    lineVisible: false\\\\r\\\\n                }\\\\r\\\\n            })\\\\r\\\\n    })\\\\r\\\\n    be([{\\\\r\\\\n        func: function(obj){\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            let res = getDoubanRes(obj.url);\\\\r\\\\n            \\\\r\\\\n            let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n            let l = [res[0],res[1],res[2]];\\\\r\\\\n            let i = l.map((e => {\\\\r\\\\n                let type = e.type,\\\\r\\\\n                    id = e.id,\\\\r\\\\n                    title = e.title;\\\\r\\\\n                let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n                let urlParams = {};\\\\r\\\\n                if (useConfig.startsWith('{')) {\\\\r\\\\n                    eval('urlParams = ' + useConfig);\\\\r\\\\n                } else {\\\\r\\\\n                    urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                        eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                        if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                            douList(id, MY_PAGE, 50);\\\\r\\\\n                        } else {\\\\r\\\\n                            eval(useConfig);\\\\r\\\\n                        }\\\\r\\\\n                    }, type, id, title, useConfig);\\\\r\\\\n                }\\\\r\\\\n                return {\\\\r\\\\n                    title: title,\\\\r\\\\n                    url: urlParams.url,\\\\r\\\\n                    extra: urlParams.extra,\\\\r\\\\n                    img: e.pic ? e.pic.normal + \\\\\\\"@Referer=\\\\\\\" + e.pic.normal : e.cover.url + '@Referer=' + e.cover.url,\\\\r\\\\n                    desc: e.null_rating_reason || e.rating.value\\\\r\\\\n                }\\\\r\\\\n            }));\\\\r\\\\n            addItemAfter('recommendations', i[2]);\\\\r\\\\n            addItemAfter('recommendations', i[1]);\\\\r\\\\n            addItemAfter('recommendations', i[0]);\\\\r\\\\n            addItemAfter('recommendations', {\\\\r\\\\n                title: \\\\\\\"““””<big><strong>相关推荐</strong></big>\\\\\\\",\\\\r\\\\n                col_type: \\\\\\\"text_center_1\\\\\\\",\\\\r\\\\n                url: $('hiker://empty/#noHistory#').rule((t) => {\\\\r\\\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                    recommendations(t[0], t[1]);\\\\r\\\\n                }, [obj.type, obj.id]),\\\\r\\\\n                extra: {\\\\r\\\\n                    lineVisible: false\\\\r\\\\n                }\\\\r\\\\n            })\\\\r\\\\n            updateItem('recommendations',{col_type: 'line',extra:{id:'nooop'}})\\\\r\\\\n        },\\\\r\\\\n        param: {\\\\r\\\\n            url: \\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id + \\\\\\\"/recommendations\\\\\\\",\\\\r\\\\n            type: type,\\\\r\\\\n            id: id\\\\r\\\\n        }\\\\r\\\\n    }])\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//推荐\\\\r\\\\nfunction findList(page, count) {\\\\r\\\\n    if (!getMyVar('findList')) putMyVar('findList', '{\\\\\\\"item\\\\\\\":\\\\\\\"movie\\\\\\\",\\\\\\\"playable\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"score\\\\\\\":\\\\\\\"0,10\\\\\\\"}');\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('findList'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let items = {\\\\r\\\\n        电影: 'movie',\\\\r\\\\n        电视剧: 'tv'\\\\r\\\\n    }\\\\r\\\\n    for (i in items) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.item === items[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('findList'));\\\\r\\\\n                temp.item = e;\\\\r\\\\n                putMyVar(\\\\\\\"findList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, items[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        col_type: 'blank_block'\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let playable = {\\\\r\\\\n        全部影片: '0',\\\\r\\\\n        仅有片源: '1'\\\\r\\\\n    }\\\\r\\\\n    for (let r in playable) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('findList'));\\\\r\\\\n                temp.playable = e;\\\\r\\\\n                putMyVar(\\\\\\\"findList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, playable[r])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score.replace(',', '-') + ' </font></b>',\\\\r\\\\n        col_type: 'scroll_button',\\\\r\\\\n        url: $(temp.score.replace(',', '-'), '评分应在0-10之间').input(() => {\\\\r\\\\n            let temp = JSON.parse(getMyVar('findList'));\\\\r\\\\n            let inputs = input.split('-');\\\\r\\\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\\\r\\\\n                temp.score = input.replace('-', ',');\\\\r\\\\n                putMyVar(\\\\\\\"findList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            } else {\\\\r\\\\n                return 'toast://请正确输入'\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + temp.item + \\\\\\\"/recommend\\\\\\\" + '?playable=' + temp.playable + '&score_range=' + temp.score + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=8\\\\\\\"));\\\\r\\\\n    let l = s.items;\\\\r\\\\n    l = l.filter(e => e.type !== \\\\\\\"ad\\\\\\\" && e.type !== \\\\\\\"tags\\\\\\\");\\\\r\\\\n\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    let i = l.map((e => {\\\\r\\\\n        let type = e.type,\\\\r\\\\n            id = e.id,\\\\r\\\\n            title = e.subtitle || e.title;\\\\r\\\\n        let baseUrl = e.type === \\\\\\\"playlist\\\\\\\" ? 'hiker://empty/$page{fypage}' : 'hiker://empty#immersiveTheme#';\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(baseUrl + \\\\\\\"#noHistory#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        return {\\\\r\\\\n            title: title + (type === \\\\\\\"playlist\\\\\\\" ? \\\\\\\"\\\\\\\" : \\\\\\\"（\\\\\\\" + e.year + \\\\\\\"）\\\\\\\"),\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra,\\\\r\\\\n            img: e.pic ? e.pic.normal + \\\\\\\"@Referer=\\\\\\\" + e.pic.normal : e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url,\\\\r\\\\n            desc: e.type !== \\\\\\\"playlist\\\\\\\" ? (e.tags.map((e => e.name)).join(\\\\\\\",\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\" + (e.rating ? computeRating(e.rating.max, e.rating.value) + \\\\\\\" \\\\\\\" + e.rating.value.toFixed(1) + \\\\\\\"分\\\\\\\" : \\\\\\\"暂无评分\\\\\\\")) : (e.title + \\\\\\\"\\\\\\\\n\\\\\\\" + e.tags.join(\\\\\\\",\\\\\\\") + \\\\\\\"\\\\\\\\n共\\\\\\\" + e.items_count + \\\\\\\"部\\\\\\\")\\\\r\\\\n        }\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    return page > 1 ? i : a.concat(i);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//热门\\\\r\\\\nfunction hotList(page, count) {\\\\r\\\\n    if (!getMyVar('hotList')) putMyVar('hotList', '{\\\\\\\"item\\\\\\\":\\\\\\\"movie_showing?area=全部\\\\\\\",\\\\\\\"playable\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"sort\\\\\\\":\\\\\\\"recommend\\\\\\\",\\\\\\\"score\\\\\\\":\\\\\\\"0,10\\\\\\\"}');\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('hotList'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let items = {\\\\r\\\\n        电影: {\\\\r\\\\n            影院热映电影: 'movie_showing?area=全部',\\\\r\\\\n            豆瓣热门电影: 'hot_gaia?area=全部',\\\\r\\\\n            热门华语电影: 'hot_gaia?area=华语',\\\\r\\\\n            热门欧美电影: 'hot_gaia?area=欧美',\\\\r\\\\n            热门韩国电影: 'hot_gaia?area=韩国',\\\\r\\\\n            热门日本电影: 'hot_gaia?area=日本'\\\\r\\\\n        },\\\\r\\\\n        电视剧: {\\\\r\\\\n            热播电视剧: 'tv_hot',\\\\r\\\\n            热播国产剧: 'tv_domestic',\\\\r\\\\n            热播欧美剧: 'tv_american',\\\\r\\\\n            热播日剧: 'tv_japanese',\\\\r\\\\n            热播韩剧: 'tv_korean',\\\\r\\\\n            热播动画: 'tv_animation'\\\\r\\\\n        },\\\\r\\\\n        综艺: {\\\\r\\\\n            热播综艺: 'show_hot',\\\\r\\\\n            国内综艺: 'show_domestic',\\\\r\\\\n            国外综艺: 'show_foreign'\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n    for (let i in items) {\\\\r\\\\n        for (let j in items[i]) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp.item == items[i][j] ? '““””<b> <font color=' + color + '>' + j + ' </font></b>' : j,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('hotList'));\\\\r\\\\n                    temp.item = e;\\\\r\\\\n                    putMyVar('hotList', JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, items[i][j])\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let sort = {\\\\r\\\\n        热度排序: 'recommend',\\\\r\\\\n        时间排序: 'time',\\\\r\\\\n        评分排序: 'rank'\\\\r\\\\n    }\\\\r\\\\n    for (let r in sort) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.sort == sort[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('hotList'));\\\\r\\\\n                temp.sort = e;\\\\r\\\\n                putMyVar(\\\\\\\"hotList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, sort[r])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let playable = {\\\\r\\\\n        全部影片: '0',\\\\r\\\\n        仅有片源: '1'\\\\r\\\\n    }\\\\r\\\\n    for (let r in playable) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('hotList'));\\\\r\\\\n                temp.playable = e;\\\\r\\\\n                putMyVar(\\\\\\\"hotList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, playable[r])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score.replace(',', '-') + ' </font></b>',\\\\r\\\\n        col_type: 'scroll_button',\\\\r\\\\n        url: $(temp.score.replace(',', '-'), '评分应在0-10之间').input(() => {\\\\r\\\\n            let temp = JSON.parse(getMyVar('hotList'));\\\\r\\\\n            let inputs = input.split('-');\\\\r\\\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\\\r\\\\n                temp.score = input.replace('-', ',');\\\\r\\\\n                putMyVar(\\\\\\\"hotList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            } else {\\\\r\\\\n                return 'toast://请正确输入'\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let l = [];\\\\r\\\\n    if (temp.item.indexOf('?') != -1) {\\\\r\\\\n        let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/movie/\\\\\\\" + temp.item + '&playable=' + temp.playable + '&sort=' + temp.sort + '&score_range=' + temp.score + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=30\\\\\\\") + '&loc_id=108288');\\\\r\\\\n        l = s.items;\\\\r\\\\n    } else {\\\\r\\\\n        let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/subject_collection/\\\\\\\" + temp.item + '/items' + '?playable=' + temp.playable + '&sort=' + temp.sort + '&score_range=' + temp.score + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=30\\\\\\\"));\\\\r\\\\n        l = s.subject_collection_items;\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    let i = l.map((e => {\\\\r\\\\n        let type = e.type,\\\\r\\\\n            id = e.id,\\\\r\\\\n            title = e.title;\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        return {\\\\r\\\\n            title: title + \\\\\\\"（\\\\\\\" + e.year + \\\\\\\"）\\\\\\\",\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra,\\\\r\\\\n            img: e.pic ? e.pic.normal + \\\\\\\"@Referer=\\\\\\\" + e.pic.normal : e.cover.url + '@Referer=' + e.cover.url,\\\\r\\\\n            desc: (e.tags ? e.tags.map((e => e.name)).join(\\\\\\\",\\\\\\\") : e.card_subtitle) + \\\\\\\"\\\\\\\\n\\\\\\\" + (e.rating ? computeRating(e.rating.max, e.rating.value) + \\\\\\\" \\\\\\\" + e.rating.value.toFixed(1) + \\\\\\\"分\\\\\\\" : \\\\\\\"暂无评分\\\\\\\")\\\\r\\\\n        }\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    return page > 1 ? i : a.concat(i);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//分类\\\\r\\\\nfunction classList(page, count) {\\\\r\\\\n    if (!getMyVar('classlist')){\\\\r\\\\n        putMyVar('classlist', JSON.stringify({subtype:\\\\\\\"\\\\\\\",local:\\\\\\\"\\\\\\\",year:\\\\\\\"\\\\\\\",class:\\\\\\\"\\\\\\\",rank:\\\\\\\"U\\\\\\\",type:\\\\\\\"\\\\\\\",filter:\\\\\\\"\\\\\\\",score:\\\\\\\"0,10\\\\\\\"}));\\\\r\\\\n    }\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let items = {\\\\r\\\\n        subtype: [\\\\\\\"全部形式\\\\\\\", \\\\\\\"电影\\\\\\\", \\\\\\\"电视剧\\\\\\\", \\\\\\\"综艺\\\\\\\", \\\\\\\"动漫\\\\\\\", \\\\\\\"纪录片\\\\\\\", \\\\\\\"短片\\\\\\\"],\\\\r\\\\n        local: [\\\\\\\"全部地区\\\\\\\", \\\\\\\"自定义地区\\\\\\\", \\\\\\\"中国大陆\\\\\\\", \\\\\\\"美国\\\\\\\", \\\\\\\"中国香港\\\\\\\", \\\\\\\"中国台湾\\\\\\\", \\\\\\\"日本\\\\\\\", \\\\\\\"韩国\\\\\\\", \\\\\\\"英国\\\\\\\", \\\\\\\"法国\\\\\\\", \\\\\\\"德国\\\\\\\", \\\\\\\"意大利\\\\\\\", \\\\\\\"西班牙\\\\\\\", \\\\\\\"印度\\\\\\\", \\\\\\\"泰国\\\\\\\", \\\\\\\"俄罗斯\\\\\\\", \\\\\\\"伊朗\\\\\\\", \\\\\\\"加拿大\\\\\\\", \\\\\\\"澳大利亚\\\\\\\", \\\\\\\"爱尔兰\\\\\\\", \\\\\\\"瑞典\\\\\\\", \\\\\\\"巴西\\\\\\\", \\\\\\\"丹麦\\\\\\\"],\\\\r\\\\n        type: [\\\\\\\"全部类型\\\\\\\", \\\\\\\"自定义类型\\\\\\\", \\\\\\\"剧情\\\\\\\", \\\\\\\"喜剧\\\\\\\", \\\\\\\"动作\\\\\\\", \\\\\\\"爱情\\\\\\\", \\\\\\\"科幻\\\\\\\", \\\\\\\"动画\\\\\\\", \\\\\\\"悬疑\\\\\\\", \\\\\\\"惊悚\\\\\\\", \\\\\\\"恐怖\\\\\\\", \\\\\\\"犯罪\\\\\\\", \\\\\\\"同性\\\\\\\", \\\\\\\"音乐\\\\\\\", \\\\\\\"歌舞\\\\\\\", \\\\\\\"传记\\\\\\\", \\\\\\\"历史\\\\\\\", \\\\\\\"战争\\\\\\\", \\\\\\\"西部\\\\\\\", \\\\\\\"奇幻\\\\\\\", \\\\\\\"冒险\\\\\\\", \\\\\\\"灾难\\\\\\\", \\\\\\\"武侠\\\\\\\", \\\\\\\"\\\\\\\\u60c5\\\\\\\\u8272\\\\\\\"],\\\\r\\\\n        year: [\\\\\\\"全部年代\\\\\\\", \\\\\\\"自定义年份\\\\\\\", \\\\\\\"2020年代\\\\\\\", \\\\\\\"2010年代\\\\\\\", \\\\\\\"2000年代\\\\\\\", \\\\\\\"90年代\\\\\\\", \\\\\\\"80年代\\\\\\\", \\\\\\\"70年代\\\\\\\", \\\\\\\"60年代\\\\\\\", \\\\\\\"更早\\\\\\\"],\\\\r\\\\n        class: [\\\\\\\"全部特色\\\\\\\", \\\\\\\"自定义标签\\\\\\\", \\\\\\\"经典\\\\\\\", \\\\\\\"青春\\\\\\\", \\\\\\\"文艺\\\\\\\", \\\\\\\"搞笑\\\\\\\", \\\\\\\"励志\\\\\\\", \\\\\\\"魔幻\\\\\\\", \\\\\\\"感人\\\\\\\", \\\\\\\"女性\\\\\\\", \\\\\\\"黑帮\\\\\\\", \\\\\\\"治愈\\\\\\\", \\\\\\\"美食\\\\\\\", \\\\\\\"宗教\\\\\\\", \\\\\\\"小说改编\\\\\\\", \\\\\\\"超级英雄\\\\\\\"]\\\\r\\\\n    }\\\\r\\\\n    for (item in items) {\\\\r\\\\n        for (let i = 0; i < items[item].length; i++) {\\\\r\\\\n            let title = \\\\\\\"\\\\\\\";\\\\r\\\\n            if(temp[item] == items[item][i] || (temp[item] == \\\\\\\"\\\\\\\" && i == 0)){\\\\r\\\\n                title = '““””<b> <font color=' + color + '>' + items[item][i] + ' </font></b>';\\\\r\\\\n            }else{\\\\r\\\\n                title = items[item][i];\\\\r\\\\n            }\\\\r\\\\n            let url = $('hiker://empty#noLoading#').lazyRule((text,item) => {\\\\r\\\\n                        let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n                        temp[item] = text.indexOf(\\\\\\\"全部\\\\\\\") != -1 ? \\\\\\\"\\\\\\\" : text;\\\\r\\\\n                        putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                        refreshPage();\\\\r\\\\n                        return 'hiker://empty'\\\\r\\\\n                    }, items[item][i], item);\\\\r\\\\n            \\\\r\\\\n            if(items[item][i] == \\\\\\\"自定义年份\\\\\\\"){\\\\r\\\\n                if(temp.year == \\\\\\\"自定义年份\\\\\\\"){\\\\r\\\\n                    title = '““””<b> <font color=' + color + '>自定义年份:' + temp.customYear + ' </font></b>';\\\\r\\\\n                }\\\\r\\\\n                \\\\r\\\\n                url = $(temp.customYear, '直接输入具体年份,例如2000').input(() => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n                    if(input.length == 4){\\\\r\\\\n                        temp.customYear = input;\\\\r\\\\n                        temp.year = \\\\\\\"自定义年份\\\\\\\";\\\\r\\\\n                        putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                        refreshPage();\\\\r\\\\n                        return 'hiker://empty'\\\\r\\\\n                    }else{\\\\r\\\\n                        return 'toast://请正确输入'\\\\r\\\\n                    }\\\\r\\\\n                });\\\\r\\\\n            }else if(items[item][i] == \\\\\\\"自定义地区\\\\\\\"){\\\\r\\\\n                if(temp.local == \\\\\\\"自定义地区\\\\\\\"){\\\\r\\\\n                    title = '““””<b> <font color=' + color + '>自定义地区:' + temp.customLocal + ' </font></b>';\\\\r\\\\n                }\\\\r\\\\n                \\\\r\\\\n                url = $(temp.customLocal, '直接输入具体地区,例如中国大陆').input(() => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n                    if(input.length > 0){\\\\r\\\\n                        temp.customLocal = input;\\\\r\\\\n                        temp.local = \\\\\\\"自定义地区\\\\\\\";\\\\r\\\\n                        putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                        refreshPage();\\\\r\\\\n                        return 'hiker://empty'\\\\r\\\\n                    }else{\\\\r\\\\n                        return 'toast://请正确输入'\\\\r\\\\n                    }\\\\r\\\\n                });\\\\r\\\\n            }else if(items[item][i] == \\\\\\\"自定义类型\\\\\\\"){\\\\r\\\\n                if(temp.type == \\\\\\\"自定义类型\\\\\\\"){\\\\r\\\\n                    title = '““””<b> <font color=' + color + '>自定义类型:' + temp.customType + ' </font></b>';\\\\r\\\\n                }\\\\r\\\\n                \\\\r\\\\n                url = $(temp.customType, '直接输入具体类型,例如剧情').input(() => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n                    if(input.length > 0){\\\\r\\\\n                        temp.customType = input;\\\\r\\\\n                        temp.type = \\\\\\\"自定义类型\\\\\\\";\\\\r\\\\n                        putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                        refreshPage();\\\\r\\\\n                        return 'hiker://empty'\\\\r\\\\n                    }else{\\\\r\\\\n                        return 'toast://请正确输入'\\\\r\\\\n                    }\\\\r\\\\n                });\\\\r\\\\n            }else if(items[item][i] == \\\\\\\"自定义标签\\\\\\\"){\\\\r\\\\n                if(temp.class == \\\\\\\"自定义标签\\\\\\\"){\\\\r\\\\n                    title = '““””<b> <font color=' + color + '>自定义标签:' + temp.customClass + ' </font></b>';\\\\r\\\\n                }\\\\r\\\\n                \\\\r\\\\n                url = $(temp.customClass, '直接输入具体标签,例如经典\\\\\\\\n可写多个标签,使用\\\\\\\"英文逗号\\\\\\\"分隔').input(() => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n                    if(input.length > 0){\\\\r\\\\n                        temp.customClass = input;\\\\r\\\\n                        temp.class = \\\\\\\"自定义标签\\\\\\\";\\\\r\\\\n                        putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                        refreshPage();\\\\r\\\\n                        return 'hiker://empty'\\\\r\\\\n                    }else{\\\\r\\\\n                        return 'toast://请正确输入'\\\\r\\\\n                    }\\\\r\\\\n                });\\\\r\\\\n            }\\\\r\\\\n            a.push({\\\\r\\\\n                title: title,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: url\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: 'blank_block'\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let rank = {\\\\r\\\\n        默认排序: \\\\\\\"U\\\\\\\",\\\\r\\\\n        热度: \\\\\\\"T\\\\\\\",\\\\r\\\\n        评分: \\\\\\\"S\\\\\\\",\\\\r\\\\n        时间: \\\\\\\"R\\\\\\\"\\\\r\\\\n    }\\\\r\\\\n    for (let r in rank) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.rank === rank[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n                temp.rank = e;\\\\r\\\\n                putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, rank[r])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        col_type: 'blank_block'\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let filter = {\\\\r\\\\n        全部影片: '',\\\\r\\\\n        仅有片源: 'playable'\\\\r\\\\n    }\\\\r\\\\n    for (let r in filter) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.filter === filter[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n                temp.filter = e;\\\\r\\\\n                putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, filter[r])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score.replace(',', '-') + ' </font></b>',\\\\r\\\\n        col_type: 'scroll_button',\\\\r\\\\n        url: $(temp.score.replace(',', '-'), '评分应在0-10之间').input(() => {\\\\r\\\\n            let temp = JSON.parse(getMyVar('classlist'));\\\\r\\\\n            let inputs = input.split('-');\\\\r\\\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\\\r\\\\n                temp.score = input.replace('-', ',');\\\\r\\\\n                putMyVar(\\\\\\\"classlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            } else {\\\\r\\\\n                return 'toast://请正确输入'\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/movie/tag?\\\\\\\"\\\\r\\\\n            + (page ? \\\\\\\"start=\\\\\\\" + (page - 1) * count\\\\r\\\\n            + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"start=0&count=30\\\\\\\")\\\\r\\\\n            + \\\\\\\"&q=\\\\\\\" + temp.subtype\\\\r\\\\n            + \\\\\\\",\\\\\\\" + (temp.local==\\\\\\\"自定义地区\\\\\\\" ? temp.customLocal : temp.local)\\\\r\\\\n            + \\\\\\\",\\\\\\\" + (temp.type==\\\\\\\"自定义类型\\\\\\\" ? temp.customType : temp.type)\\\\r\\\\n            + \\\\\\\",\\\\\\\" + (temp.year==\\\\\\\"自定义年份\\\\\\\" ? temp.customYear : temp.year)\\\\r\\\\n            + \\\\\\\",\\\\\\\" + (temp.class==\\\\\\\"自定义标签\\\\\\\" ? temp.customClass : temp.class)\\\\r\\\\n            + \\\\\\\"&sort=\\\\\\\" + temp.rank + \\\\\\\"&score_range=\\\\\\\" + temp.score + '&filter=' + temp.filter);\\\\r\\\\n    let l = s.data;\\\\r\\\\n\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    let i = l.map((e => {\\\\r\\\\n        let type = e.type,\\\\r\\\\n            id = e.id,\\\\r\\\\n            title = e.title;\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        return {\\\\r\\\\n            title: title,\\\\r\\\\n            col_type: 'movie_3',\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra,\\\\r\\\\n            img: e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url,\\\\r\\\\n            desc: e.null_rating_reason || e.rating.value\\\\r\\\\n        }\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    return page > 1 ? i : a.concat(i);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//片单\\\\r\\\\nfunction playList(page, count) {\\\\r\\\\n    if (!getMyVar('playlist')) putMyVar('playlist', '{\\\\\\\"subtype\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"all\\\\\\\"}');\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('playlist', '{\\\\\\\"subtype\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"all\\\\\\\"}'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let items = {\\\\r\\\\n        type: {\\\\r\\\\n            全部: \\\\\\\"all\\\\\\\",\\\\r\\\\n            豆瓣片单: \\\\\\\"official\\\\\\\",\\\\r\\\\n            精选: \\\\\\\"selected\\\\\\\",\\\\r\\\\n            经典: \\\\\\\"classical\\\\\\\",\\\\r\\\\n            获奖: \\\\\\\"prize\\\\\\\",\\\\r\\\\n            高分: \\\\\\\"high_score\\\\\\\",\\\\r\\\\n            榜单: \\\\\\\"movie_list\\\\\\\",\\\\r\\\\n            冷门佳片: \\\\\\\"dark_horse\\\\\\\",\\\\r\\\\n            主题: \\\\\\\"topic\\\\\\\",\\\\r\\\\n            导演: \\\\\\\"director\\\\\\\",\\\\r\\\\n            演员: \\\\\\\"actor\\\\\\\",\\\\r\\\\n            系列: \\\\\\\"series\\\\\\\",\\\\r\\\\n            华语: \\\\\\\"chinese\\\\\\\",\\\\r\\\\n            欧美: \\\\\\\"western\\\\\\\",\\\\r\\\\n            日本: \\\\\\\"japanese\\\\\\\",\\\\r\\\\n            韩国: \\\\\\\"korea\\\\\\\",\\\\r\\\\n            喜剧: \\\\\\\"comedy\\\\\\\",\\\\r\\\\n            动作: \\\\\\\"action\\\\\\\",\\\\r\\\\n            爱情: \\\\\\\"love\\\\\\\",\\\\r\\\\n            科幻: \\\\\\\"science_fiction\\\\\\\",\\\\r\\\\n            动画: \\\\\\\"cartoon\\\\\\\",\\\\r\\\\n            悬疑: \\\\\\\"mystery\\\\\\\",\\\\r\\\\n            惊悚: \\\\\\\"panic\\\\\\\",\\\\r\\\\n            恐怖: \\\\\\\"horrible\\\\\\\",\\\\r\\\\n            犯罪: \\\\\\\"criminal\\\\\\\",\\\\r\\\\n            同性: \\\\\\\"lgbt\\\\\\\",\\\\r\\\\n            战争: \\\\\\\"war\\\\\\\",\\\\r\\\\n            奇幻: \\\\\\\"fantasy\\\\\\\",\\\\r\\\\n            \\\\\\\"\\\\\\\\u60c5\\\\\\\\u8272\\\\\\\": \\\\\\\"erotica\\\\\\\",\\\\r\\\\n            音乐: \\\\\\\"music\\\\\\\",\\\\r\\\\n            纪录片: \\\\\\\"documentary\\\\\\\",\\\\r\\\\n            治愈: \\\\\\\"cure\\\\\\\",\\\\r\\\\n            艺术: \\\\\\\"art\\\\\\\",\\\\r\\\\n            黑色幽默: \\\\\\\"dark_humor\\\\\\\",\\\\r\\\\n            青春: \\\\\\\"youth\\\\\\\",\\\\r\\\\n            女性: \\\\\\\"female\\\\\\\",\\\\r\\\\n            真实事件改编: \\\\\\\"real_event\\\\\\\",\\\\r\\\\n            暴力: \\\\\\\"violence\\\\\\\",\\\\r\\\\n            黑白: \\\\\\\"black_white\\\\\\\",\\\\r\\\\n            美食: \\\\\\\"food\\\\\\\",\\\\r\\\\n            旅行: \\\\\\\"travel\\\\\\\",\\\\r\\\\n            儿童: \\\\\\\"child\\\\\\\",\\\\r\\\\n            人性: \\\\\\\"humanity\\\\\\\",\\\\r\\\\n            家庭: \\\\\\\"family\\\\\\\",\\\\r\\\\n            文艺: \\\\\\\"literary_art\\\\\\\",\\\\r\\\\n            小说改编: \\\\\\\"novel\\\\\\\",\\\\r\\\\n            感人: \\\\\\\"moving\\\\\\\",\\\\r\\\\n            励志: \\\\\\\"inspiration\\\\\\\"\\\\r\\\\n        },\\\\r\\\\n        subtype: {\\\\r\\\\n            全部: \\\\\\\"\\\\\\\",\\\\r\\\\n            电影: \\\\\\\"movie\\\\\\\",\\\\r\\\\n            电视剧: \\\\\\\"tv\\\\\\\"\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n    for (let i in items) {\\\\r\\\\n        for (let j in items[i]) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp[i] === items[i][j] ? '““””<b> <font color=' + color + '>' + j + ' </font></b>' : j,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((t) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('playlist', '{\\\\\\\"subtype\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"type\\\\\\\":\\\\\\\"all\\\\\\\"}'));\\\\r\\\\n                    temp[t[0]] = t[1];\\\\r\\\\n                    putMyVar(\\\\\\\"playlist\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, [i, items[i][j]])\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/skynet/new_playlists\\\\\\\" + \\\\\\\"?category=\\\\\\\" + temp.type + \\\\\\\"&subject_type=\\\\\\\" + temp.subtype + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=10\\\\\\\"));\\\\r\\\\n    let l = s.data[0].items;\\\\r\\\\n\\\\r\\\\n    let i = l.map((e => ({\\\\r\\\\n        title: e.title,\\\\r\\\\n        url: $('hiker://empty/$page{fypage}#noHistory#').rule((type, id) => {\\\\r\\\\n            eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n            if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                douList(id, MY_PAGE, 50);\\\\r\\\\n            } else {\\\\r\\\\n                subjectCollectionList(MY_PAGE, 50, id);\\\\r\\\\n            }\\\\r\\\\n        }, e.type, e.id),\\\\r\\\\n        img: e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url,\\\\r\\\\n        desc: \\\\\\\"共\\\\\\\" + e.items_count + \\\\\\\"部\\\\\\\"\\\\r\\\\n    })));\\\\r\\\\n\\\\r\\\\n    return page > 1 ? i : a.concat(i);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//榜单\\\\r\\\\nfunction rankList(page, count) {\\\\r\\\\n    if (!getMyVar('rankList')) putMyVar('rankList', '{\\\\\\\"type\\\\\\\":\\\\\\\"movie\\\\\\\",\\\\\\\"list\\\\\\\":\\\\\\\"rank_list\\\\\\\",\\\\\\\"year_lists\\\\\\\":[],\\\\\\\"category_lists\\\\\\\":[],\\\\\\\"year\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"category\\\\\\\":\\\\\\\"\\\\\\\"}');\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('rankList'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let items = {\\\\r\\\\n        电影: 'movie',\\\\r\\\\n        电视剧: 'tv'\\\\r\\\\n    }\\\\r\\\\n    for (let i in items) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.type == items[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('rankList'));\\\\r\\\\n                temp.type = e;\\\\r\\\\n                putMyVar(\\\\\\\"rankList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, items[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let list = {\\\\r\\\\n        口碑榜单: 'rank_list',\\\\r\\\\n        年度榜单: 'year_ranks',\\\\r\\\\n        类型榜单: 'category_ranks'\\\\r\\\\n    }\\\\r\\\\n    for (let i in list) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.list == list[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('rankList'));\\\\r\\\\n                temp.list = e;\\\\r\\\\n                putMyVar(\\\\\\\"rankList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, list[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    if (temp.list == 'year_ranks' && temp.year_lists.length == 0) {\\\\r\\\\n        let t = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + temp.type + '/rank_list');\\\\r\\\\n        temp.year_lists = t.groups[1].tabs;\\\\r\\\\n        putMyVar('rankList', JSON.stringify(temp));\\\\r\\\\n    } else if (temp.list == 'category_ranks' && temp.category_lists.length == 0) {\\\\r\\\\n        let t = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + temp.type + '/rank_list');\\\\r\\\\n        temp.category_lists = t.groups[2].tabs;\\\\r\\\\n        putMyVar('rankList', JSON.stringify(temp));\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    if (temp.list == 'year_ranks') {\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        if (!temp.year) temp.year = temp.year_lists[0].key;\\\\r\\\\n        for (let t of temp.year_lists) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp.year == t.key ? '““””<b> <font color=' + color + '>' + t.title + ' </font></b>' : t.title,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('rankList'));\\\\r\\\\n                    temp.year = e;\\\\r\\\\n                    putMyVar(\\\\\\\"rankList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, t.key)\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    } else if (temp.list == 'category_ranks') {\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        if (!temp.category) temp.category = temp.category_lists[0].key;\\\\r\\\\n        for (let t of temp.category_lists) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp.category == t.key ? '““””<b> <font color=' + color + '>' + t.title + ' </font></b>' : t.title,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('rankList'));\\\\r\\\\n                    temp.category = e;\\\\r\\\\n                    putMyVar(\\\\\\\"rankList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, t.key)\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let l = [];\\\\r\\\\n    if (temp.list == 'rank_list' && MY_PAGE == 1) {\\\\r\\\\n        let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + temp.type + '/' + temp.list + (page ? \\\\\\\"?start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"?start=0&count=10\\\\\\\"));\\\\r\\\\n        l = s.groups[0].selected_collections;\\\\r\\\\n    } else if (temp.list == 'year_ranks' && MY_PAGE == 1) {\\\\r\\\\n        let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + temp.type + '/' + temp.list + '?year=' + temp.year + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=10\\\\\\\"));\\\\r\\\\n        l = s.groups[0].selected_collections;\\\\r\\\\n    } else if (temp.list == 'category_ranks') {\\\\r\\\\n        let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + temp.type + '/' + temp.list + '?category=' + temp.category + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=10\\\\\\\"));\\\\r\\\\n        l = s.selected_collections;\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let i = [];\\\\r\\\\n    if (temp.list == 'category_ranks') {\\\\r\\\\n        i = l.map((e => ({\\\\r\\\\n            title: '““””' + e.title.bold(),\\\\r\\\\n            url: $('hiker://empty/$page{fypage}#noHistory#').rule((type, id) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    subjectCollectionList(MY_PAGE, 50, id);\\\\r\\\\n                }\\\\r\\\\n            }, e.type, e.id),\\\\r\\\\n            img: e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url,\\\\r\\\\n            desc: \\\\\\\"共\\\\\\\" + e.total + \\\\\\\"部\\\\\\\"\\\\r\\\\n        })));\\\\r\\\\n    } else {\\\\r\\\\n        i = l.map((e => ({\\\\r\\\\n            title: '' /*'““””' + e.medium_name + '\\\\\\\\n' + getStrongText(e.title)*/ ,\\\\r\\\\n            col_type: 'card_pic_2',\\\\r\\\\n            url: $('hiker://empty/$page{fypage}#noHistory#').rule((type, id, stitle) => {\\\\r\\\\n                setPageTitle(stitle);\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    subjectCollectionList(MY_PAGE, 50, id);\\\\r\\\\n                }\\\\r\\\\n            }, e.type, e.id, e.title),\\\\r\\\\n            img: e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url,\\\\r\\\\n            desc: \\\\\\\"0\\\\\\\"\\\\r\\\\n        })));\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    return page > 1 ? i : a.concat(i);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//将上映\\\\r\\\\nfunction comingList(page, count) {\\\\r\\\\n    if (!getMyVar('coming')) putMyVar('coming', '{\\\\\\\"type\\\\\\\":\\\\\\\"movie\\\\\\\",\\\\\\\"rank\\\\\\\":\\\\\\\"&sortby=hot\\\\\\\",\\\\\\\"local\\\\\\\":\\\\\\\"domestic\\\\\\\",\\\\\\\"area\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"filter\\\\\\\":\\\\\\\"\\\\\\\"}');\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('coming'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let items = {\\\\r\\\\n        电影: 'movie',\\\\r\\\\n        电视剧: 'tv'\\\\r\\\\n    }\\\\r\\\\n    for (let i in items) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.type === items[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('coming'));\\\\r\\\\n                temp.type = e;\\\\r\\\\n                putMyVar(\\\\\\\"coming\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, items[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    let rank = {\\\\r\\\\n        热度: '&sortby=hot',\\\\r\\\\n        时间: ''\\\\r\\\\n    }\\\\r\\\\n    a.push({\\\\r\\\\n        col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n    })\\\\r\\\\n    for (let i in rank) {\\\\r\\\\n        a.push({\\\\r\\\\n            title: temp.rank === rank[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('coming'));\\\\r\\\\n                temp.rank = e;\\\\r\\\\n                putMyVar(\\\\\\\"coming\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, rank[i])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n    let local = {\\\\r\\\\n        国内: 'domestic',\\\\r\\\\n        全球: 'international'\\\\r\\\\n    }\\\\r\\\\n    if (temp.type == 'movie') {\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        for (let i in local) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp.local === local[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('coming'));\\\\r\\\\n                    temp.local = e;\\\\r\\\\n                    putMyVar(\\\\\\\"coming\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, local[i])\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n    let area = {\\\\r\\\\n        全部: '',\\\\r\\\\n        美国: '&area_filter=american',\\\\r\\\\n        欧洲: '&area_filter=europe',\\\\r\\\\n        日本: '&area_filter=japanese',\\\\r\\\\n        韩国: '&area_filter=korean'\\\\r\\\\n    }\\\\r\\\\n    if (temp.type == 'movie' && temp.local == 'international') {\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        for (let i in area) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp.area === area[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('coming'));\\\\r\\\\n                    temp.area = e;\\\\r\\\\n                    putMyVar(\\\\\\\"coming\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, area[i])\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n    let filter = {\\\\r\\\\n        全部: '',\\\\r\\\\n        国产剧: '&type_filter=tv_domestic',\\\\r\\\\n        欧美剧: '&type_filter=tv_american',\\\\r\\\\n        日剧: '&type_filter=tv_japanese',\\\\r\\\\n        韩剧: '&type_filter=tv_korean',\\\\r\\\\n        动画: '&type_filter=tv_animation',\\\\r\\\\n        国内综艺: '&type_filter=show_domestic',\\\\r\\\\n        国外综艺: '&type_filter=show_foreign'\\\\r\\\\n    }\\\\r\\\\n    if (temp.type == 'tv') {\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n        for (let i in filter) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp.filter === filter[i] ? '““””<b> <font color=' + color + '>' + i + ' </font></b>' : i,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('coming'));\\\\r\\\\n                    temp.filter = e;\\\\r\\\\n                    putMyVar(\\\\\\\"coming\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, filter[i])\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + temp.type + \\\\\\\"/coming_soon\\\\\\\" + \\\\\\\"?area=\\\\\\\" + temp.local + temp.rank + temp.area + temp.filter + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=10\\\\\\\"));\\\\r\\\\n    let l = s.subjects;\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n\\\\r\\\\n    let i = l.map((e => {\\\\r\\\\n        let type = e.type,\\\\r\\\\n            id = e.id,\\\\r\\\\n            title = e.title;\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        return {\\\\r\\\\n            title: title + \\\\\\\"（\\\\\\\" + e.year + \\\\\\\"）\\\\\\\",\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra,\\\\r\\\\n            img: e.cover_url + \\\\\\\"@Referer=\\\\\\\" + e.cover_url,\\\\r\\\\n            desc: \\\\\\\"上映日期:\\\\\\\" + e.pubdate + \\\\\\\"\\\\\\\\n\\\\\\\" + e.wish_count + \\\\\\\"人想看\\\\\\\" + \\\\\\\"\\\\\\\\n\\\\\\\" + e.null_rating_reason\\\\r\\\\n        }\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    return page > 1 ? i : a.concat(i);\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//片单详情\\\\r\\\\nfunction subjectCollectionList(page, count, id) {\\\\r\\\\n    if (!getMyVar('ranking')) putMyVar('ranking', '{\\\\\\\"item\\\\\\\":\\\\\\\"movie_real_time_hotest\\\\\\\",\\\\\\\"playable\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"score\\\\\\\":\\\\\\\"0-10\\\\\\\"}');\\\\r\\\\n    let a = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('ranking'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let items = {\\\\r\\\\n        电影: {\\\\r\\\\n            实时热门电影: 'movie_real_time_hotest',\\\\r\\\\n            一周口碑电影: 'movie_weekly_best',\\\\r\\\\n            top250电影: 'movie_top250'\\\\r\\\\n        },\\\\r\\\\n        电视剧: {\\\\r\\\\n            实时热门剧集: 'tv_real_time_hotest',\\\\r\\\\n            华语口碑剧集: 'tv_chinese_best_weekly',\\\\r\\\\n            全球口碑剧集: 'tv_global_best_weekly'\\\\r\\\\n        },\\\\r\\\\n        综艺: {\\\\r\\\\n            国内口碑综艺: 'show_chinese_best_weekly',\\\\r\\\\n            国外口碑综艺: 'show_global_best_weekly'\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n    for (let i in items) {\\\\r\\\\n        for (let j in items[i]) {\\\\r\\\\n            a.push({\\\\r\\\\n                title: temp.item == items[i][j] ? '““””<b> <font color=' + color + '>' + j + ' </font></b>' : j,\\\\r\\\\n                col_type: 'scroll_button',\\\\r\\\\n                url: $('hiker://empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                    let temp = JSON.parse(getMyVar('ranking'));\\\\r\\\\n                    temp.item = e;\\\\r\\\\n                    putMyVar(\\\\\\\"ranking\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                    refreshPage();\\\\r\\\\n                    return 'hiker://empty'\\\\r\\\\n                }, items[i][j])\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n        a.push({\\\\r\\\\n            col_type: \\\\\\\"blank_block\\\\\\\"\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    a.push({\\\\r\\\\n        col_type: 'blank_block'\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let i = [];\\\\r\\\\n    let playable = {\\\\r\\\\n        全部影片: '0',\\\\r\\\\n        仅有片源: '1'\\\\r\\\\n    }\\\\r\\\\n    for (let r in playable) {\\\\r\\\\n        i.push({\\\\r\\\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('ranking'));\\\\r\\\\n                temp.playable = e;\\\\r\\\\n                putMyVar(\\\\\\\"ranking\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, playable[r])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    i.push({\\\\r\\\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score + ' </font></b>',\\\\r\\\\n        col_type: 'scroll_button',\\\\r\\\\n        url: $(temp.score, '评分应在0-10之间').input(() => {\\\\r\\\\n            let temp = JSON.parse(getMyVar('ranking'));\\\\r\\\\n            let inputs = input.split('-');\\\\r\\\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\\\r\\\\n                temp.score = input;\\\\r\\\\n                putMyVar(\\\\\\\"ranking\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            } else {\\\\r\\\\n                return 'toast://请正确输入'\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let t = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/subject_collection/\\\\\\\" + (id || temp.item));\\\\r\\\\n    i.push({\\\\r\\\\n        title: t.title + '(共' + t.total + '部)',\\\\r\\\\n        desc: t.description,\\\\r\\\\n        /*img: t.header_bg_image + \\\\\\\"@Referer=\\\\\\\" + t.header_bg_image,\\\\r\\\\n        url: t.header_bg_image + \\\\\\\"?type=.jpg@Referer=\\\\\\\" + t.header_bg_image + \\\\\\\"?type=.jpg\\\\\\\",*/\\\\r\\\\n        url: 'toast://点我干嘛',\\\\r\\\\n        col_type: \\\\\\\"text_1\\\\\\\"\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/subject_collection/\\\\\\\" + (id || temp.item) + \\\\\\\"/items?\\\\\\\" + (page ? \\\\\\\"start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"start=0&count=50\\\\\\\"));\\\\r\\\\n    let l = s.subject_collection_items;\\\\r\\\\n    if (temp.playable == '1') l = l.filter(e => !!e.has_linewatch);\\\\r\\\\n    if (temp.score != '0-10') {\\\\r\\\\n        l = l.filter(e => {\\\\r\\\\n            let r = temp.score.split('-');\\\\r\\\\n            return e.rating && e.rating.value < r[1] && e.rating.value > r[0];\\\\r\\\\n        });\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    let r = l.map((e => {\\\\r\\\\n        let type = e.type,\\\\r\\\\n            id = e.id,\\\\r\\\\n            title = e.title;\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        return {\\\\r\\\\n            title: title,\\\\r\\\\n            col_type: 'movie_1_vertical_pic',\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra,\\\\r\\\\n            img: e.pic.normal + \\\\\\\"@Referer=\\\\\\\" + e.pic.normal,\\\\r\\\\n            desc: e.card_subtitle.split(\\\\\\\"/\\\\\\\").filter(((e, t) => {\\\\r\\\\n                if (t < 3) return e\\\\r\\\\n            })).join(\\\\\\\",\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\" + (e.rating ? computeRating(e.rating.max, e.rating.value) + \\\\\\\" \\\\\\\" + e.rating.value.toFixed(1) + \\\\\\\"分\\\\\\\" : \\\\\\\"暂无评分\\\\\\\")\\\\r\\\\n        }\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: page > 1 ? r : (id ? i.concat(r) : a.concat(i).concat(r))\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//豆列详情\\\\r\\\\nfunction douList(id, page, count) {\\\\r\\\\n    addListener('onClose', 'clearMyVar(\\\\\\\"douList\\\\\\\")');\\\\r\\\\n    if (!getMyVar('douList')) putMyVar('douList', '{\\\\\\\"playable\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"score\\\\\\\":\\\\\\\"0-10\\\\\\\"}');\\\\r\\\\n    let i = [];\\\\r\\\\n    let temp = JSON.parse(getMyVar('douList'));\\\\r\\\\n    let color = getConfig('chooseColor');\\\\r\\\\n\\\\r\\\\n    let playable = {\\\\r\\\\n        全部影片: '0',\\\\r\\\\n        仅有片源: '1'\\\\r\\\\n    }\\\\r\\\\n    for (let r in playable) {\\\\r\\\\n        i.push({\\\\r\\\\n            title: temp.playable == playable[r] ? '““””<b> <font color=' + color + '>' + r + ' </font></b>' : r,\\\\r\\\\n            col_type: 'scroll_button',\\\\r\\\\n            url: $('hiker: //empty#noLoading#').lazyRule((e) => {\\\\r\\\\n                let temp = JSON.parse(getMyVar('douList'));\\\\r\\\\n                temp.playable = e;\\\\r\\\\n                putMyVar(\\\\\\\"douList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            }, playable[r])\\\\r\\\\n        })\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    i.push({\\\\r\\\\n        title: '““””<b> <font color=' + color + '>评分区间:' + temp.score + ' </font></b>',\\\\r\\\\n        col_type: 'scroll_button',\\\\r\\\\n        url: $(temp.score, '评分应在0-10之间').input(() => {\\\\r\\\\n            let temp = JSON.parse(getMyVar('douList'));\\\\r\\\\n            let inputs = input.split('-');\\\\r\\\\n            if (inputs.length == 2 && inputs.every(e => e >= 0 && e <= 10) && parseFloat(inputs[0]) < inputs[1]) {\\\\r\\\\n                temp.score = input;\\\\r\\\\n                putMyVar(\\\\\\\"douList\\\\\\\", JSON.stringify(temp));\\\\r\\\\n                refreshPage();\\\\r\\\\n                return 'hiker://empty'\\\\r\\\\n            } else {\\\\r\\\\n                return 'toast://请正确输入'\\\\r\\\\n            }\\\\r\\\\n        })\\\\r\\\\n    })\\\\r\\\\n\\\\r\\\\n    let t = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/doulist/\\\\\\\" + id);\\\\r\\\\n    i.push({\\\\r\\\\n        title: t.title,\\\\r\\\\n        desc: '共' + t.items_count + '部(' + t.playable_count + '部可播放)',\\\\r\\\\n        /*img: t.header_bg_image + \\\\\\\"@Referer=\\\\\\\" + t.header_bg_image,\\\\r\\\\n        url: t.header_bg_image + \\\\\\\"?type=.jpg@Referer=\\\\\\\" + t.header_bg_image + \\\\\\\"?type=.jpg\\\\\\\",*/\\\\r\\\\n        url: 'toast://别点我',\\\\r\\\\n        col_type: \\\\\\\"text_1\\\\\\\"\\\\r\\\\n    });\\\\r\\\\n\\\\r\\\\n    let s = getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/doulist/\\\\\\\" + id + \\\\\\\"/posts\\\\\\\" + '?playable=' + temp.playable + (page ? \\\\\\\"&start=\\\\\\\" + (page - 1) * count + \\\\\\\"&count=\\\\\\\" + count : \\\\\\\"&start=0&count=50\\\\\\\"));\\\\r\\\\n    let l = s.items;\\\\r\\\\n    if (temp.score != '0-10') {\\\\r\\\\n        l = l.filter(e => {\\\\r\\\\n            let r = temp.score.split('-');\\\\r\\\\n            return e.content.subject.rating && e.content.subject.rating.value < r[1] && e.content.subject.rating.value > r[0];\\\\r\\\\n        });\\\\r\\\\n    }\\\\r\\\\n\\\\r\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\r\\\\n    let r = l.map((e => {\\\\r\\\\n        let type = e.content.subject.type,\\\\r\\\\n            id = e.content.subject.id,\\\\r\\\\n            title = e.content.subject.title;\\\\r\\\\n        let useConfig = detailsViewConfigs[detailsViewConfigs.use].config;\\\\r\\\\n        let urlParams = {};\\\\r\\\\n        if (useConfig.startsWith('{')) {\\\\r\\\\n            eval('urlParams = ' + useConfig);\\\\r\\\\n        } else {\\\\r\\\\n            urlParams.url = $(\\\\\\\"hiker://empty#noHistory##immersiveTheme#\\\\\\\" + '?type=' + type + '&id=' + id).rule((type, id, title, useConfig) => {\\\\r\\\\n                eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                if (type === \\\\\\\"playlist\\\\\\\") {\\\\r\\\\n                    douList(id, MY_PAGE, 50);\\\\r\\\\n                } else {\\\\r\\\\n                    eval(useConfig);\\\\r\\\\n                }\\\\r\\\\n            }, type, id, title, useConfig);\\\\r\\\\n        }\\\\r\\\\n        return {\\\\r\\\\n            title: title,\\\\r\\\\n            url: urlParams.url,\\\\r\\\\n            extra: urlParams.extra,\\\\r\\\\n            img: e.content.subject.pic.normal + \\\\\\\"@Referer=\\\\\\\" + e.content.subject.pic.normal,\\\\r\\\\n            desc: e.content.subject.card_subtitle.split(\\\\\\\"/\\\\\\\").filter(((e, t) => {\\\\r\\\\n                if (t < 3) return e\\\\r\\\\n            })).join(\\\\\\\",\\\\\\\") + \\\\\\\"\\\\\\\\n\\\\\\\" + (e.content.subject.rating ? computeRating(e.content.subject.rating.max, e.content.subject.rating.value) + \\\\\\\" \\\\\\\" + e.content.subject.rating.value.toFixed(1) + \\\\\\\"分\\\\\\\" : \\\\\\\"暂无评分\\\\\\\")\\\\r\\\\n        }\\\\r\\\\n    }));\\\\r\\\\n\\\\r\\\\n    setHomeResult({\\\\r\\\\n        data: page > 1 ? r : i.concat(r)\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n\\\\r\\\\n\\\\r\\\\n//视频模块\\\\r\\\\nfunction videoUrlsModule(d, type, id, col, lazy, _res, extra) {\\\\r\\\\n    //col是样式col[0],col[1]分别是tv和movie的样式(tv会有分集信息title会很长)\\\\r\\\\n    if (!col) col = ['icon_2', 'icon_small_4'];\\\\r\\\\n    if (!lazy) lazy = 'return input';\\\\r\\\\n    let res = _res || getDoubanRes(\\\\\\\"https://frodo.douban.com/api/v2/\\\\\\\" + type + \\\\\\\"/\\\\\\\" + id);\\\\r\\\\n    for (let item in res.vendors) {\\\\r\\\\n        let e = res.vendors[item];\\\\r\\\\n        if (type === \\\\\\\"tv\\\\\\\") {\\\\r\\\\n            d.push({\\\\r\\\\n                title: e.title + (e.episodes_info ? \\\\\\\"•\\\\\\\" + e.episodes_info : \\\\\\\"\\\\\\\"),\\\\r\\\\n                img: e.icon,\\\\r\\\\n                col_type: col[0] || \\\\\\\"icon_2\\\\\\\",\\\\r\\\\n                url: $('hiker://empty?id=' + id + '&type=' + type + '&title=' + e.title).rule((res, id, e, lazy, extra) => {\\\\r\\\\n                    let title = res.title,\\\\r\\\\n                        pic = res.pic.normal + \\\\\\\"@Referer=\\\\\\\" + res.pic.normal;\\\\r\\\\n                    setPageTitle(e.title + '-' + title);\\\\r\\\\n                    try {\\\\r\\\\n                        setPagePicUrl(pic);\\\\r\\\\n                    } catch (e) {}\\\\r\\\\n                    eval(JSON.parse(request('hiker://page/main')).rule);\\\\r\\\\n                    let urls = getTvUrls(id, e.id);\\\\r\\\\n                    lazy = $(\\\\\\\"\\\\\\\").lazyRule(lazy => {\\\\r\\\\n                        let resultUrl = \\\\\\\"toast://解析失败\\\\\\\";\\\\r\\\\n                        try {\\\\r\\\\n                            if (lazy.startsWith(\\\\\\\"(\\\\\\\")) {\\\\r\\\\n                                eval('resultUrl = ' + lazy)\\\\r\\\\n                            } else {\\\\r\\\\n                                eval('resultUrl = ' + '(() => {' + lazy + '})()')\\\\r\\\\n                            }\\\\r\\\\n                        } catch (e) {\\\\r\\\\n                            log(e.message)\\\\r\\\\n                        }\\\\r\\\\n                        return resultUrl\\\\r\\\\n                    }, lazy)\\\\r\\\\n                    let d = [];\\\\r\\\\n                    if (typeof(urls) == \\\\\\\"object\\\\\\\") {\\\\r\\\\n                        let d = [];\\\\r\\\\n                        for (let i = 0; i < urls.length; i++) {\\\\r\\\\n                            d.push({\\\\r\\\\n                                title: '第' + (i + 1) + '集',\\\\r\\\\n                                col_type: 'text_4',\\\\r\\\\n                                url: lazy ? urls[i] + lazy : urls[i],\\\\r\\\\n                                extra: extra\\\\r\\\\n                            })\\\\r\\\\n                        }\\\\r\\\\n                        setResult(d);\\\\r\\\\n                    } else if (typeof(urls) == \\\\\\\"string\\\\\\\" && urls == '被封ip') {\\\\r\\\\n                        let rule = JSON.parse(request(\\\\\\\"hiker://page/releaseIP?rule=青豆\\\\\\\"))\\\\r\\\\n                            .rule;\\\\r\\\\n                        eval(rule);\\\\r\\\\n                    } else if (typeof(urls) == 'string' && urls == '没有收录') {\\\\r\\\\n                        let d = [];\\\\r\\\\n                        d.push({\\\\r\\\\n                            title: '豆瓣没有收录此视频源的详细信息',\\\\r\\\\n                            desc: '点我可以去视频源网站看看',\\\\r\\\\n                            col_type: 'text_center_1',\\\\r\\\\n                            url: e.url\\\\r\\\\n                        })\\\\r\\\\n                        setResult(d);\\\\r\\\\n                    }\\\\r\\\\n                }, res, id, e, lazy, extra)\\\\r\\\\n            })\\\\r\\\\n        } else if (type === 'movie') {\\\\r\\\\n            let mLazy = $(\\\\\\\"\\\\\\\").lazyRule(lazy => {\\\\r\\\\n                let resultUrl = \\\\\\\"toast://解析失败\\\\\\\";\\\\r\\\\n                try {\\\\r\\\\n                    if (lazy.startsWith(\\\\\\\"(\\\\\\\")) {\\\\r\\\\n                        eval('resultUrl = ' + lazy)\\\\r\\\\n                    } else {\\\\r\\\\n                        eval('resultUrl = ' + '(() => {' + lazy + '})()')\\\\r\\\\n                    }\\\\r\\\\n                } catch (e) {\\\\r\\\\n                    log(e.message)\\\\r\\\\n                }\\\\r\\\\n                return resultUrl\\\\r\\\\n            }, lazy)\\\\r\\\\n            d.push({\\\\r\\\\n                title: e.title + (e.episodes_info ? \\\\\\\"•\\\\\\\" + e.episodes_info : \\\\\\\"\\\\\\\"),\\\\r\\\\n                img: e.icon,\\\\r\\\\n                col_type: col[1] || \\\\\\\"icon_small_4\\\\\\\",\\\\r\\\\n                url: mLazy ? e.url + mLazy : e.url,\\\\r\\\\n                extra: extra\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//获取电视剧分集链接,id是片子编号,uid是视频源编号\\\\r\\\\nfunction getTvUrls(id, uid) {\\\\r\\\\n    let cookieCache = 'hiker://files/cache/doubancookie.txt';\\\\r\\\\n    let mUrl = 'https://movie.douban.com/subject/' + id + '/';\\\\r\\\\n    let headers = {\\\\r\\\\n        \\\\\\\"User-Agent\\\\\\\": PC_UA,\\\\r\\\\n    }\\\\r\\\\n    if (fileExist(cookieCache)) {\\\\r\\\\n        headers[\\\\\\\"Cookie\\\\\\\"] = fetch(cookieCache)\\\\r\\\\n    }\\\\r\\\\n    let html = request(mUrl, {\\\\r\\\\n        headers: headers\\\\r\\\\n    })\\\\r\\\\n    if ((html.includes(\\\\\\\"登录跳转\\\\\\\") && html.includes(\\\\\\\"异常请求\\\\\\\")) || (html.includes(\\\\\\\"window.location.href\\\\\\\") && html.includes(\\\\\\\"sec.douban\\\\\\\"))) {\\\\r\\\\n        return '被封ip';\\\\r\\\\n    } else {\\\\r\\\\n        let s = {\\\\r\\\\n            qq: 1,\\\\r\\\\n            youku: 3,\\\\r\\\\n            letv: 6,\\\\r\\\\n            mgtv: 7,\\\\r\\\\n            bilibili: 8,\\\\r\\\\n            iqiyi: 9,\\\\r\\\\n            cntv: 12,\\\\r\\\\n            cctv6: 13,\\\\r\\\\n            miguvideo: 15,\\\\r\\\\n            xigua: 17,\\\\r\\\\n            acfun: 18,\\\\r\\\\n            maiduidui: 19\\\\r\\\\n        };\\\\r\\\\n        let num = s[uid];\\\\r\\\\n\\\\r\\\\n        var sources = {};\\\\r\\\\n        let sl = html.match(/sources\\\\\\\\[[1-9]{1,2}\\\\\\\\][\\\\\\\\s\\\\\\\\S]*?\\\\\\\\]/g);\\\\r\\\\n        if (sl) {\\\\r\\\\n            for (var i in sl) {\\\\r\\\\n                eval(sl[i]);\\\\r\\\\n            }\\\\r\\\\n        } else {\\\\r\\\\n            let script_list = parseDomForArray(html, 'body&&script[src]');\\\\r\\\\n            let sources_url = \\\\\\\"\\\\\\\";\\\\r\\\\n            for (let i in script_list) {\\\\r\\\\n                let url = parseDomForHtml(script_list[i], 'script&&src');\\\\r\\\\n                if (url.indexOf('mixed_static') !== -1) {\\\\r\\\\n                    sources_url = url;\\\\r\\\\n                }\\\\r\\\\n            }\\\\r\\\\n            let sources_list = request(sources_url).match(/sources\\\\\\\\[[1-9]{1,2}\\\\\\\\][\\\\\\\\s\\\\\\\\S]*?\\\\\\\\]/g);\\\\r\\\\n            for (var i in sources_list) {\\\\r\\\\n                eval(sources_list[i]);\\\\r\\\\n            }\\\\r\\\\n        }\\\\r\\\\n\\\\r\\\\n        let ren = sources[num];\\\\r\\\\n        if (ren && ren.length > 0) {\\\\r\\\\n            /*var r = ren.map(e => unescape(e.play_link.replace(/(https|http):\\\\\\\\/\\\\\\\\/www.douban.com\\\\\\\\/link2\\\\\\\\/\\\\\\\\?url=/, '')\\\\r\\\\n                .split(';')[0].split('.html')[0] + '.html'))*/\\\\r\\\\n            var r = ren.map(e => unescape(e.play_link.split('?url=')[1].split('&')[0]))\\\\r\\\\n\\\\r\\\\n        }\\\\r\\\\n        return r || '没有收录';\\\\r\\\\n    }\\\\r\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"设置页\\\",\\\"path\\\":\\\"settingPage\\\",\\\"rule\\\":\\\"js:\\\\neval(JSON.parse(request('hiker://page/utils')).rule);\\\\n\\\\n//影片详情配置模块\\\\nfunction detailViewModeModule(d, detailsViewConfigs) {\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\n    d.push({\\\\n        title: '自定义影片详情页面'.bold(),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    })\\\\n    for (let configKey of Object.keys(detailsViewConfigs)) {\\\\n        if (configKey === 'use') continue;\\\\n        d.push({\\\\n            title: configKey === detailsViewConfigs.use ? \\\\\\\"““\\\\\\\" + configKey + \\\\\\\"””\\\\\\\" : configKey,\\\\n            url: $(\\\\\\\"hiker://empty#noLoading#\\\\\\\").lazyRule(configKey => {\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n                if (config.detailsViewConfigs.use === configKey) {\\\\n                    //putMyVar(\\\\\\\"input_config_type\\\\\\\", '影片详情页面配置')\\\\n                    putMyVar(\\\\\\\"input_name\\\\\\\", configKey);\\\\n                    putMyVar(\\\\\\\"input_code\\\\\\\", config.detailsViewConfigs[configKey].config);\\\\n                    putMyVar(\\\\\\\"input_setting_code\\\\\\\", config.detailsViewConfigs[configKey].setting || \\\\\\\"\\\\\\\");\\\\n                    return 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage';\\\\n                }\\\\n                config.detailsViewConfigs.use = configKey\\\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n                refreshPage(false);\\\\n                return 'toast://切换成功'\\\\n            }, configKey),\\\\n            col_type: 'flex_button'\\\\n        })\\\\n    }\\\\n    d.push({\\\\n        col_type: 'blank_block'\\\\n    })\\\\n    d.push({\\\\n        title: '➕',\\\\n        col_type: 'flex_button',\\\\n        url: 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage'\\\\n    });\\\\n    d.push({\\\\n        title: '➖',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(detailsViewConfigs).filter(configKey => configKey !== 'use' && configKey !== '默认'), 2)\\\\n            .select(() => {\\\\n                if (input === '默认') return 'toast://默认配置无法删除！'\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n                if (input === config.detailsViewConfigs.use) return 'toast://该配置正在使用，无法删除！'\\\\n                return $('确认删除\\\\\\\"' + input + '\\\\\\\"？').confirm((config, configKey) => {\\\\n                    delete config.detailsViewConfigs[configKey]\\\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n                    refreshPage(false);\\\\n                    return 'toast://删除' + configKey + '成功'\\\\n                }, config, input)\\\\n            })\\\\n    })\\\\n    d.push({\\\\n        title: '📝',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(detailsViewConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\\\n            let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n            putMyVar(\\\\\\\"input_name\\\\\\\", configKey);\\\\n            putMyVar(\\\\\\\"input_code\\\\\\\", config.detailsViewConfigs[configKey].config);\\\\n            putMyVar(\\\\\\\"input_setting_code\\\\\\\", config.detailsViewConfigs[configKey].setting || \\\\\\\"\\\\\\\");\\\\n            return 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage'\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '📥',\\\\n        col_type: 'flex_button',\\\\n        url: $(\\\\\\\"\\\\\\\", \\\\\\\"请输入口令\\\\\\\").input(() => {\\\\n            if (!input.includes(\\\\\\\"影片详情页面配置\\\\\\\")) return \\\\\\\"toast://该口令不是影片详情页面配置\\\\\\\";\\\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n            let importConfigs = ConfigTool.import(input);\\\\n            if (!importConfigs) return \\\\\\\"toast://似乎出了错，请尝试再次导入～\\\\\\\";\\\\n            putMyVar(\\\\\\\"input_name\\\\\\\", importConfigs.name);\\\\n            putMyVar(\\\\\\\"input_code\\\\\\\", importConfigs.data.config);\\\\n            putMyVar(\\\\\\\"input_setting_code\\\\\\\", importConfigs.data.setting || \\\\\\\"\\\\\\\");\\\\n            return 'hiker://page/setting-editor?rule=青豆&view=detailViewModeEditPage';\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '📤',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(detailsViewConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n            let config = getConfig();\\\\n            let selectConfig = {\\\\n                name: input,\\\\n                data: config.detailsViewConfigs[input]\\\\n            }\\\\n            return $(ConfigTool.encTypeList, 2).select((selectConfig) => {\\\\n                eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n                return ConfigTool.toClipboard(ConfigTool.export(selectConfig.name, selectConfig, \\\\\\\"影片详情页面配置\\\\\\\", input))\\\\n            }, selectConfig)\\\\n        })\\\\n    })\\\\n}\\\\n// 详情页设置模块\\\\nfunction detailViewSettingModule(d) {\\\\n    let detailsViewConfigs = getConfig('detailsViewConfigs');\\\\n    detailViewModeModule(d, detailsViewConfigs)\\\\n    let detailViewSetting = detailsViewConfigs[detailsViewConfigs.use].setting\\\\n    let result = \\\\\\\"toast://该详情页无设置页面\\\\\\\";\\\\n    if (detailViewSetting) {\\\\n        try {\\\\n            if (detailViewSetting.indexOf('return') == -1) throw new Error('必须 return @rule=js: 或 $().rule');\\\\n            if (detailViewSetting.startsWith(\\\\\\\"(\\\\\\\")) {\\\\n                eval('result = ' + detailViewSetting)\\\\n            } else {\\\\n                eval('result = ' + '(() => {' + detailViewSetting + '})()')\\\\n            }\\\\n        } catch (e) {\\\\n            log(e.message);\\\\n            result = \\\\\\\"toast://错误的设置页面代码,请前往 日志 查看错误原因\\\\\\\"\\\\n        }\\\\n    }\\\\n    d.push({\\\\n        title: '⚙️',\\\\n        col_type: 'flex_button',\\\\n        url: result\\\\n    })\\\\n}\\\\n\\\\n// 首页设置模块\\\\nfunction homePageSettingModule(d) {\\\\n    let homePageConfigs = getConfig('homePageConfigs');\\\\n    d.push({\\\\n        title: '自定义首页'.bold(),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    })\\\\n    for (let configKey of Object.keys(homePageConfigs)) {\\\\n        if (configKey === 'use') continue;\\\\n        d.push({\\\\n            title: configKey === homePageConfigs.use ? \\\\\\\"““\\\\\\\" + configKey + \\\\\\\"””\\\\\\\" : configKey,\\\\n            url: $(\\\\\\\"hiker://empty#noLoading#\\\\\\\").lazyRule(configKey => {\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n                if (config.homePageConfigs.use === configKey) {\\\\n                    //putMyVar(\\\\\\\"input_config_type\\\\\\\", '首页配置')\\\\n                    putMyVar(\\\\\\\"input_name\\\\\\\", configKey);\\\\n                    putMyVar(\\\\\\\"input_code\\\\\\\", config.homePageConfigs[configKey].config);\\\\n                    return 'hiker://page/setting-editor?rule=青豆&view=homePageModeEditPage';\\\\n                }\\\\n                config.homePageConfigs.use = configKey\\\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n                refreshPage(false);\\\\n                return 'toast://切换成功'\\\\n            }, configKey),\\\\n            col_type: 'flex_button'\\\\n        })\\\\n    }\\\\n    d.push({\\\\n        col_type: 'blank_block'\\\\n    })\\\\n    d.push({\\\\n        title: '➕',\\\\n        col_type: 'flex_button',\\\\n        url: 'hiker://page/setting-editor?view=homePageModeEditPage'\\\\n    });\\\\n    d.push({\\\\n        title: '➖',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(homePageConfigs).filter(configKey => configKey !== 'use' && configKey !== '默认'), 2)\\\\n            .select(() => {\\\\n                if (input === '默认') return 'toast://默认配置无法删除！'\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n                if (input === config.homePageConfigs.use) return 'toast://该配置正在使用，无法删除！'\\\\n                return $('确认删除\\\\\\\"' + input + '\\\\\\\"？').confirm((config, configKey) => {\\\\n                    delete config.homePageConfigs[configKey]\\\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n                    refreshPage(false);\\\\n                    return 'toast://删除' + configKey + '成功'\\\\n                }, config, input)\\\\n            })\\\\n    })\\\\n    d.push({\\\\n        title: '📝',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(homePageConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\\\n            let config = JSON.parse(request(getMyVar('qdb_config')));\\\\n            let configKey = input;\\\\n            putMyVar(\\\\\\\"input_name\\\\\\\", configKey);\\\\n            putMyVar(\\\\\\\"input_code\\\\\\\", config.homePageConfigs[configKey].config);\\\\n            return 'hiker://page/setting-editor?rule=青豆&view=homePageModeEditPage';\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '📥',\\\\n        col_type: 'flex_button',\\\\n        url: $(\\\\\\\"\\\\\\\", \\\\\\\"请输入口令\\\\\\\").input(() => {\\\\n            if (!input.includes(\\\\\\\"首页配置\\\\\\\")) return \\\\\\\"toast://该口令不是首页配置\\\\\\\";\\\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n            let importConfigs = ConfigTool.import(input);\\\\n            if (!importConfigs) return \\\\\\\"toast://似乎出了错，请尝试再次导入～\\\\\\\";\\\\n            putMyVar(\\\\\\\"input_name\\\\\\\", importConfigs.name);\\\\n            putMyVar(\\\\\\\"input_code\\\\\\\", importConfigs.data.config);\\\\n            return 'hiker://page/setting-editor?rule=青豆&view=homePageModeEditPage';\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '📤',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(homePageConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n            let config = getConfig();\\\\n            let selectConfig = {\\\\n                name: input,\\\\n                data: config.homePageConfigs[input]\\\\n            }\\\\n            return $(ConfigTool.encTypeList, 2).select((selectConfig) => {\\\\n                eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n                return ConfigTool.toClipboard(ConfigTool.export(selectConfig.name, selectConfig, \\\\\\\"首页配置\\\\\\\", input))\\\\n            }, selectConfig)\\\\n        })\\\\n    })\\\\n}\\\\n\\\\n// 解析配置模块\\\\nfunction analysisModeModule(d, analysisConfigs) {\\\\n    d.push({\\\\n        title: '自定义解析插件'.bold(),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    })\\\\n    for (let configKey of Object.keys(analysisConfigs)) {\\\\n        if (configKey === 'use') continue;\\\\n        d.push({\\\\n            title: configKey === analysisConfigs.use ? \\\\\\\"““\\\\\\\" + configKey + \\\\\\\"””\\\\\\\" : configKey,\\\\n            url: $(\\\\\\\"hiker://empty#noLoading#\\\\\\\").lazyRule(configKey => {\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n                if (config.analysisConfigs.use === configKey) {\\\\n                    //putMyVar(\\\\\\\"input_config_type\\\\\\\", '解析插件配置')\\\\n                    putMyVar(\\\\\\\"input_name\\\\\\\", configKey);\\\\n                    putMyVar(\\\\\\\"input_code\\\\\\\", config.analysisConfigs[configKey].config);\\\\n                    putMyVar(\\\\\\\"input_extra\\\\\\\", config.analysisConfigs[configKey].extra || \\\\\\\"\\\\\\\");\\\\n                    putMyVar(\\\\\\\"input_setting_code\\\\\\\", config.analysisConfigs[configKey].setting || \\\\\\\"\\\\\\\");\\\\n                    return 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage';\\\\n                }\\\\n                config.analysisConfigs.use = configKey\\\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n                refreshPage(false);\\\\n                return 'toast://切换成功'\\\\n            }, configKey),\\\\n            col_type: 'flex_button'\\\\n        })\\\\n    }\\\\n    d.push({\\\\n        col_type: 'blank_block'\\\\n    })\\\\n    d.push({\\\\n        title: '➕',\\\\n        col_type: 'flex_button',\\\\n        url: 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage'\\\\n    });\\\\n    d.push({\\\\n        title: '➖',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(analysisConfigs).filter(configKey => configKey !== 'use' && configKey !== '不解析' && configKey !== '断插'), 2)\\\\n            .select(() => {\\\\n                if (input === '不解析' && input === '断插') return 'toast://默认解析无法删除！'\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n                if (input === config.analysisConfigs.use) return 'toast://该解析正在使用，无法删除！'\\\\n                return $('确认删除\\\\\\\"' + input + '\\\\\\\"？').confirm((config, configKey) => {\\\\n                    delete config.analysisConfigs[configKey]\\\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n                    refreshPage(false);\\\\n                    return 'toast://删除' + configKey + '成功'\\\\n                }, config, input)\\\\n            })\\\\n    })\\\\n    d.push({\\\\n        title: '📝',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(analysisConfigs).filter(configKey => configKey !== 'use'), 2)\\\\n            .select(() => {\\\\n                // if (input === '不解析' && input === '断插') return 'toast://默认解析无法编辑！'\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')));\\\\n                let configKey = input;\\\\n                putMyVar(\\\\\\\"input_name\\\\\\\", configKey);\\\\n                putMyVar(\\\\\\\"input_code\\\\\\\", config.analysisConfigs[configKey].config);\\\\n                putMyVar(\\\\\\\"input_extra\\\\\\\", config.analysisConfigs[configKey].extra || \\\\\\\"\\\\\\\");\\\\n                putMyVar(\\\\\\\"input_setting_code\\\\\\\", config.analysisConfigs[configKey].setting || \\\\\\\"\\\\\\\");\\\\n                return 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage';\\\\n            })\\\\n    })\\\\n    d.push({\\\\n        title: '📥',\\\\n        col_type: 'flex_button',\\\\n        url: $(\\\\\\\"\\\\\\\", \\\\\\\"请输入口令\\\\\\\").input(() => {\\\\n            if (!input.includes(\\\\\\\"解析插件配置\\\\\\\")) return \\\\\\\"toast://该口令不是解析插件配置\\\\\\\";\\\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n            let importConfigs = ConfigTool.import(input);\\\\n            if (!importConfigs) return \\\\\\\"toast://似乎出了错，请尝试再次导入～\\\\\\\";\\\\n            putMyVar(\\\\\\\"input_name\\\\\\\", importConfigs.name);\\\\n            putMyVar(\\\\\\\"input_code\\\\\\\", importConfigs.data.config);\\\\n            putMyVar(\\\\\\\"input_extra\\\\\\\", importConfigs.data.extra || \\\\\\\"\\\\\\\");\\\\n            putMyVar(\\\\\\\"input_setting_code\\\\\\\", importConfigs.data.setting || \\\\\\\"\\\\\\\");\\\\n            return 'hiker://page/setting-editor?rule=青豆&view=analysisModeEditPage';\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '📤',\\\\n        col_type: 'flex_button',\\\\n        url: $(Object.keys(analysisConfigs).filter(configKey => configKey !== 'use'), 2).select(() => {\\\\n            // if (input === '默认') return 'toast://默认配置无法编辑！'\\\\n            eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n            let config = getConfig();\\\\n            let selectConfig = {\\\\n                name: input,\\\\n                data: config.analysisConfigs[input]\\\\n            }\\\\n            return $(ConfigTool.encTypeList, 2).select((selectConfig) => {\\\\n                eval(JSON.parse(request('hiker://page/utils')).rule)\\\\n                return ConfigTool.toClipboard(ConfigTool.export(selectConfig.name, selectConfig, \\\\\\\"解析插件配置\\\\\\\", input))\\\\n            }, selectConfig)\\\\n        })\\\\n    })\\\\n}\\\\n\\\\n// 解析设置模块\\\\nfunction analysisSettingModule(d) {\\\\n    let analysisConfigs = getConfig('analysisConfigs');\\\\n    analysisModeModule(d, analysisConfigs);\\\\n    /**\\\\n     * 这下面的都是拿设置页面的配置出来 eval 执行，最终获得插件设置页面的 url，这个 url 可以是网页也可以是二级界面\\\\n     */\\\\n    let analysisSetting = analysisConfigs[analysisConfigs.use].setting;\\\\n    let result = \\\\\\\"toast://该插件无设置页面\\\\\\\";\\\\n    if (analysisSetting) {\\\\n        try {\\\\n            if (analysisSetting.indexOf('return') == -1) throw new Error('必须 return @rule=js: 或 $().rule');\\\\n            if (analysisSetting.startsWith(\\\\\\\"(\\\\\\\")) {\\\\n                eval('result = ' + analysisSetting);\\\\n            } else {\\\\n                eval('result = ' + '(() => {' + analysisSetting + '})()');\\\\n            }\\\\n        } catch (e) {\\\\n            log(e.message);\\\\n            result = \\\\\\\"toast://错误的设置页面代码,请前往 日志 查看错误原因\\\\\\\"\\\\n        }\\\\n    }\\\\n    d.push({\\\\n        title: '⚙️',\\\\n        col_type: 'flex_button',\\\\n        url: result\\\\n    })\\\\n}\\\\n\\\\n//自定义快速搜索模块\\\\nfunction quickSearchDIYModule(d, config) {\\\\n    let quickSearchConfigs = getConfig('quickSearchConfigs', config);\\\\n    d.push({\\\\n        title: '自定义快速搜索'.bold(),\\\\n        col_type: \\\\\\\"rich_text\\\\\\\"\\\\n    })\\\\n    for (let configKey of quickSearchConfigs.order) {\\\\n        d.push({\\\\n            title: configKey,\\\\n            url: $('➕是添加\\\\\\\\n➖是删除\\\\\\\\n📝是修改\\\\\\\\n🔁是排序\\\\\\\\n⚙️是设置样式').confirm(() => {\\\\n                return 'toast://下次不要再点我了'\\\\n            }),\\\\n            col_type: 'flex_button'\\\\n        })\\\\n    }\\\\n    d.push({\\\\n        col_type: 'blank_block'\\\\n    })\\\\n    d.push({\\\\n        title: '➕️',\\\\n        col_type: 'flex_button',\\\\n        url: $('显示名@@小程序名@@图片链接', '根据提示输入就好了\\\\\\\\n小程序名为空则为海阔搜索').input(() => {\\\\n            let config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\n            input = input.split('@@');\\\\n            if(input.length != 3 || input[0] === \\\\\\\"\\\\\\\") return \\\\\\\"toast://格式不对，按格式输入!\\\\\\\";\\\\n            if (config.quickSearchConfigs.order.indexOf(input[0]) == -1) config.quickSearchConfigs.order.push(input[0]);\\\\n            config.quickSearchConfigs[input[0]] = {\\\\n                name: input[1],\\\\n                pic: input[2]\\\\n            };\\\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            return 'toast://添加成功';\\\\n        })\\\\n    });\\\\n    d.push({\\\\n        title: '➖',\\\\n        col_type: 'flex_button',\\\\n        url: $(quickSearchConfigs.order, 2).select(() => {\\\\n            let config = JSON.parse(request(getMyVar('qdb_config')))\\\\n            return $('确认删除\\\\\\\"' + input + '\\\\\\\"？').confirm((config, configKey) => {\\\\n                let index = config.quickSearchConfigs.order.indexOf(configKey);\\\\n                config.quickSearchConfigs.order.splice(index, 1);\\\\n                delete config.quickSearchConfigs[configKey]\\\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config))\\\\n                refreshPage(false);\\\\n                return 'toast://删除' + configKey + '成功'\\\\n            }, config, input)\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '📝',\\\\n        col_type: 'flex_button',\\\\n        url: $(quickSearchConfigs.order, 2).select(() => {\\\\n            let config = JSON.parse(request(getMyVar('qdb_config')));\\\\n            let quickSearchConfigs = config.quickSearchConfigs;\\\\n            let dtext = input + '@@' + quickSearchConfigs[input].name + '@@' + quickSearchConfigs[input].pic;\\\\n            return $(dtext, '请修改').input((config, raw) => {\\\\n                input = input.split('@@');\\\\n                if (raw != input[0]) {\\\\n                    let index = config.quickSearchConfigs.order.indexOf(raw);\\\\n                    config.quickSearchConfigs.order[index] = input[0];\\\\n                    delete config.quickSearchConfigs[raw];\\\\n                }\\\\n                if (config.quickSearchConfigs.order.indexOf(input[0]) == -1) config.quickSearchConfigs.order.push(input[0]);\\\\n                config.quickSearchConfigs[input[0]] = {\\\\n                    name: input[1],\\\\n                    pic: input[2]\\\\n                };\\\\n                writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n                refreshPage(false);\\\\n                return 'toast://修改成功';\\\\n            }, config, input)\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '🔁',\\\\n        col_type: 'flex_button',\\\\n        url: $('hiker://empty#noHistory#').rule(() => {\\\\n            addListener('onClose', $.toString(() => {\\\\n                clearMyVar('json');\\\\n                clearMyVar('op');\\\\n            }))\\\\n            if (getMyVar('json') == \\\\\\\"\\\\\\\") {\\\\n                let config = JSON.parse(request(getMyVar('qdb_config')));\\\\n                let quickSearchConfigs = config.quickSearchConfigs;\\\\n                putMyVar('json', JSON.stringify(quickSearchConfigs));\\\\n            }\\\\n\\\\n            let old = JSON.parse(getMyVar('json'));\\\\n            let d = [];\\\\n            d.push({\\\\n                title: '分别点击两项以交换顺序\\\\\\\\n‘‘排序完毕后点我保存排序,否则排序不生效’’',\\\\n                col_type: 'text_center_1',\\\\n                url: $('#noLoading#').lazyRule(() => {\\\\n                    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\n                    config.quickSearchConfigs = JSON.parse(getMyVar('json'));\\\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n                    back(true);\\\\n                    return 'toast://修改成功'\\\\n                })\\\\n            })\\\\n            old.order.forEach((value, index) => {\\\\n                d.push({\\\\n                    title: getMyVar('op') == value ? value + '‘‘(当前选中)’’' : value,\\\\n                    col_type: 'text_1',\\\\n                    url: $().lazyRule((key, index) => {\\\\n                        let op = getMyVar('op');\\\\n                        if (op == '') {\\\\n                            putMyVar('op', key);\\\\n                            refreshPage();\\\\n                            return 'hiker://empty'\\\\n                        } else if (op == key) {\\\\n                            clearMyVar('op');\\\\n                            refreshPage();\\\\n                            return 'hiker://empty'\\\\n                        } else {\\\\n                            let old = JSON.parse(getMyVar('json'));\\\\n                            let newa = {\\\\n                                mode: old.mode,\\\\n                                order: old.order\\\\n                            };\\\\n                            let opindex = newa.order.indexOf(op);\\\\n                            if (Math.abs(opindex - index) == 1) {\\\\n                                newa.order[opindex] = key;\\\\n                                newa.order[index] = op;\\\\n                            } else if (opindex > index) {\\\\n                                newa.order.splice(opindex, 1);\\\\n                                newa.order.splice(index, 0, op);\\\\n                            } else {\\\\n                                newa.order.splice(opindex, 1);\\\\n                                newa.order.splice(index - 1, 0, op);\\\\n                            }\\\\n                            newa.order.forEach(value => newa[value] = old[value])\\\\n                            putMyVar('json', JSON.stringify(newa));\\\\n                            clearMyVar('op');\\\\n                            refreshPage();\\\\n                            return 'hiker://empty'\\\\n                        }\\\\n                    }, value, index)\\\\n                })\\\\n            })\\\\n            setResult(d);\\\\n        })\\\\n    })\\\\n    d.push({\\\\n        title: '⚙️',\\\\n        col_type: 'flex_button',\\\\n        url: $(quickSearchConfigs['mode'] || \\\\\\\"\\\\\\\", '请正确输入组件样式\\\\\\\\n建议值:flex_button scroll_button icon_round_small_4 icon_small_4').input(() => {\\\\n            let config = JSON.parse(request(getMyVar('qdb_config')));\\\\n            config.quickSearchConfigs.mode = input;\\\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n            refreshPage(false);\\\\n            return 'toast://样式修改成功'\\\\n        })\\\\n    })\\\\n}\\\\n\\\\n//设置页面\\\\nfunction settingPage() {\\\\n    let conf = getConfig();\\\\n    let d = [];\\\\n\\\\n    let starColor = conf.starColor || '#ffac2d';\\\\n    d.push({\\\\n        title: '““””' + '自定义星星颜色'.bold(),\\\\n        desc: '““””<font color=' + starColor + '>' + '★★★★★</font>',\\\\n        col_type: 'text_1',\\\\n        url: $(starColor, '别忘了#').input(() => {\\\\n            let config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\n            config.starColor = input;\\\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://设置更改已保存\\\\\\\";\\\\n        })\\\\n    })\\\\n    let chooseColor = conf.chooseColor || '#FA7298';\\\\n    d.push({\\\\n        title: '““””' + '自定义选中标签颜色'.bold(),\\\\n        desc: '““””<font color=' + chooseColor + '>' + '我是预览效果</font>',\\\\n        col_type: 'text_1',\\\\n        url: $(chooseColor, '别忘了#').input(() => {\\\\n            let config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\n            config.chooseColor = input;\\\\n            writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n            refreshPage();\\\\n            return \\\\\\\"toast://设置更改已保存\\\\\\\";\\\\n        })\\\\n    })\\\\n\\\\n    homePageSettingModule(d);\\\\n    d.push({\\\\n        col_type: 'line'\\\\n    })\\\\n\\\\n    quickSearchDIYModule(d, conf);\\\\n    d.push({\\\\n        col_type: 'line'\\\\n    })\\\\n\\\\n    detailViewSettingModule(d);\\\\n    d.push({\\\\n        col_type: 'line'\\\\n    })\\\\n\\\\n    if (true/*getItem('password') == 'true'*/) {\\\\n        analysisSettingModule(d);\\\\n        d.push({\\\\n            col_type: 'line'\\\\n        })\\\\n    }\\\\n\\\\n    d.push({\\\\n        title: '““””' + '恢复默认设置'.bold(),\\\\n        desc: '重生',\\\\n        col_type: 'text_1',\\\\n        url: $(['重置星星颜色', '重置选中标签颜色', '重置快速搜索', '重置首页为默认', '重置详情页' , '清除全部设置'], 1).select(() => {\\\\n            return $(\\\\\\\"确定要\\\\\\\" + input + \\\\\\\"？\\\\\\\").confirm((sel) => {\\\\n                let item = '';\\\\n                switch (sel) {\\\\n                    case '重置星星颜色':\\\\n                        item = 'starColor';\\\\n                        break;\\\\n                    case '重置选中标签颜色':\\\\n                        item = 'chooseColor';\\\\n                        break;\\\\n                    case '重置快速搜索':\\\\n                        item = 'quickSearchConfigs';\\\\n                        break;\\\\n                    case '重置首页为默认':\\\\n                        item = 'homePageConfigs';\\\\n                        break;\\\\n                    case '重置详情页':\\\\n                        item = 'detailViewConfigs';\\\\n                        break;\\\\n                    case '清除全部设置':\\\\n                        item = 'all';\\\\n                        break;\\\\n                }\\\\n                // eval(JSON.parse(request('hiker://page/settingPage')).rule);\\\\n                let defaultConfigs = $.require(\\\\\\\"hiker://page/defaultConfigs\\\\\\\");\\\\n                if (item == 'all') {\\\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(defaultConfigs));\\\\n                    refreshPage();\\\\n                    return \\\\\\\"toast://已\\\\\\\" + sel;\\\\n                } else if(item == \\\\\\\"homePageConfigs\\\\\\\"){\\\\n                    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\n                    config[item][\\\\\\\"默认\\\\\\\"] = defaultConfigs[item][\\\\\\\"默认\\\\\\\"];\\\\n                    config[item].use = \\\\\\\"默认\\\\\\\";\\\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n                    refreshPage();\\\\n                    return \\\\\\\"toast://已\\\\\\\" + sel;\\\\n                }else {\\\\n                    let config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\n                    config[item] = defaultConfigs[item];\\\\n                    writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\n                    refreshPage();\\\\n                    return \\\\\\\"toast://已\\\\\\\" + sel;\\\\n                }\\\\n            }, input)\\\\n        })\\\\n    })\\\\n    setResult(d);\\\\n}\\\\n\\\\nlet view = getParam(\\\\\\\"view\\\\\\\",\\\\\\\"\\\\\\\");\\\\nif(view==\\\\\\\"\\\\\\\"){\\\\n    setPageTitle(\\\\\\\"设置\\\\\\\")\\\\n    settingPage();\\\\n}else if(view==\\\\\\\"analysisSettingModule\\\\\\\"){\\\\n    let d = [];\\\\n    setPageTitle(\\\\\\\"解析设置\\\\\\\")\\\\n    analysisSettingModule(d);\\\\n    setResult(d);\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"默认配置\\\",\\\"path\\\":\\\"defaultConfigs\\\",\\\"rule\\\":\\\"js:\\\\r\\\\nlet defaultConfigs = {\\\\r\\\\n    starColor: \\\\\\\"#ffac2d\\\\\\\",\\\\r\\\\n    chooseColor: \\\\\\\"#FA7298\\\\\\\",\\\\r\\\\n    quickSearchConfigs: {\\\\r\\\\n        mode: \\\\\\\"scroll_button\\\\\\\",\\\\r\\\\n        order: [\\\\\\\"海阔搜索\\\\\\\"],\\\\r\\\\n        \\\\\\\"海阔搜索\\\\\\\": {\\\\r\\\\n            name: \\\\\\\"\\\\\\\",\\\\r\\\\n            pic: \\\\\\\"\\\\\\\"\\\\r\\\\n        }\\\\r\\\\n    },\\\\r\\\\n    detailsViewConfigs: {\\\\r\\\\n        use: \\\\\\\"默认\\\\\\\",\\\\r\\\\n        \\\\\\\"默认\\\\\\\": {\\\\r\\\\n            config: \\\\\\\"eval(JSON.parse(request('hiker://page/main')).rule);detailsView(type, id);\\\\\\\"\\\\r\\\\n        }\\\\r\\\\n    },\\\\r\\\\n    homePageConfigs:{\\\\r\\\\n        use: \\\\\\\"默认\\\\\\\",\\\\r\\\\n        \\\\\\\"默认\\\\\\\": {\\\\r\\\\n            config: `let d = [];\\\\r\\\\nd.push({\\\\r\\\\n    title: '',\\\\r\\\\n    img: 'https://gitcode.net/qq_41846756/hiker/-/raw/master/img/豆瓣.png',\\\\r\\\\n    desc: '0',\\\\r\\\\n    col_type: 'card_pic_1',\\\\r\\\\n    url: 'hiker://page/settingPage'\\\\r\\\\n})\\\\r\\\\n\\\\r\\\\nlet s = [\\\\\\\"推荐\\\\\\\", \\\\\\\"热门\\\\\\\", \\\\\\\"分类\\\\\\\", \\\\\\\"片单\\\\\\\", \\\\\\\"榜单\\\\\\\", \\\\\\\"将上映\\\\\\\"];\\\\r\\\\nlet img = \\\\\\\"https://gitcode.net/qq_41846756/hiker/-/raw/master/img/\\\\\\\";\\\\r\\\\nfor (let i in s) {\\\\r\\\\n    d.push({\\\\r\\\\n        title: s[i],\\\\r\\\\n        img: img + s[i] + '.jpg',\\\\r\\\\n        col_type: 'icon_2',\\\\r\\\\n        url: \\\\\\\"hiker://empty\\\\\\\" + '$page{fypage}/#/' + s[i] + \\\\\\\"#noHistory#\\\\\\\"\\\\r\\\\n    })\\\\r\\\\n}\\\\r\\\\nreturn d;`\\\\r\\\\n        }\\\\r\\\\n    },\\\\r\\\\n    analysisConfigs: {\\\\r\\\\n        use: \\\\\\\"不解析\\\\\\\",\\\\r\\\\n        \\\\\\\"不解析\\\\\\\": {\\\\r\\\\n            config: $.toString(() => {\\\\r\\\\n                return input;\\\\r\\\\n            }),\\\\r\\\\n            setting: $.toString(() => {\\\\r\\\\n                return \\\\\\\"toast://该插件无设置页面\\\\\\\";\\\\r\\\\n            })\\\\r\\\\n        },\\\\r\\\\n        \\\\\\\"断插\\\\\\\": {\\\\r\\\\n            config: $.toString(() => {\\\\r\\\\n                let file = \\\\\\\"hiker://files/rules/DuanNian/MyParse.json\\\\\\\";\\\\r\\\\n                let oldfile = \\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\";\\\\r\\\\n                if (fileExist(file)) {\\\\r\\\\n                    eval('json=' + fetch(file));\\\\r\\\\n                    let jsUrl = json.settings.cj;\\\\r\\\\n                    eval(fetch(jsUrl));\\\\r\\\\n                    return aytmParse(input);\\\\r\\\\n                } else if (fileExist(oldfile)) {\\\\r\\\\n                    let jsUrl = JSON.parse(fetch(oldfile)).cj;\\\\r\\\\n                    eval(fetch(jsUrl));\\\\r\\\\n                    return aytmParse(input);\\\\r\\\\n                } else {\\\\r\\\\n                    return 'toast://没找到断插配置文件';\\\\r\\\\n                }\\\\r\\\\n            }),\\\\r\\\\n            setting: $.toString(() => {\\\\r\\\\n                let file = \\\\\\\"hiker://files/rules/DuanNian/MyParse.json\\\\\\\";\\\\r\\\\n                let oldfile = \\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\";\\\\r\\\\n                if (fileExist(file)) {\\\\r\\\\n                    eval('json=' + fetch(file));\\\\r\\\\n                    let jsUrl = json.settings.cj;\\\\r\\\\n                    eval(fetch(jsUrl));\\\\r\\\\n                    return setUrl;\\\\r\\\\n                } else if (fileExist(oldfile)) {\\\\r\\\\n                    let jsUrl = JSON.parse(fetch(oldfile)).cj;\\\\r\\\\n                    eval(fetch(jsUrl));\\\\r\\\\n                    return setUrl;\\\\r\\\\n                } else {\\\\r\\\\n                    return \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置\\\\\\\";\\\\r\\\\n                }\\\\r\\\\n            })\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n$.exports = defaultConfigs;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"工具集\\\",\\\"path\\\":\\\"utils\\\",\\\"rule\\\":\\\"js:\\\\r\\\\n//初始化配置,name为配置项名称\\\\r\\\\nfunction initConfigs(name, config) {\\\\r\\\\n    if (!config) {\\\\r\\\\n        config = JSON.parse(fetch(getMyVar('qdb_config')));\\\\r\\\\n    }\\\\r\\\\n    if (config[name] == null) {\\\\r\\\\n        let defaultConfigs = $.require(\\\\\\\"hiker://page/defaultConfigs\\\\\\\");\\\\r\\\\n        config[name] = defaultConfigs[name] ? defaultConfigs[name] : {};\\\\r\\\\n        writeFile(getMyVar('qdb_config'), JSON.stringify(config));\\\\r\\\\n    }\\\\r\\\\n    return config;\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//获取配置项\\\\r\\\\nfunction getConfig(name, rootConfig) {\\\\r\\\\n    let config = rootConfig ? rootConfig : JSON.parse(fetch(getMyVar('qdb_config')));\\\\r\\\\n    if (name) {\\\\r\\\\n        if (config[name] == null) {\\\\r\\\\n            config = initConfigs(name, config);\\\\r\\\\n        }\\\\r\\\\n        return config[name];\\\\r\\\\n    } else {\\\\r\\\\n        return config;\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n//编码工具类\\\\r\\\\nlet ZipTool = {\\\\r\\\\n    dependence: 'https://unpkg.com/lz-string@1.4.4/libs/lz-string.min.js',\\\\r\\\\n    compress: {\\\\r\\\\n        size: {\\\\r\\\\n            key: \\\\\\\"text-compress-size\\\\\\\",\\\\r\\\\n            set: (newValue) => {\\\\r\\\\n                putMyVar(this.key, newValue.toString())\\\\r\\\\n            },\\\\r\\\\n            get: () => {\\\\r\\\\n                return parseInt(getMyVar(this.key, \\\\\\\"0\\\\\\\"))\\\\r\\\\n            }\\\\r\\\\n        },\\\\r\\\\n        exec: (input) => {\\\\r\\\\n            eval(request(ZipTool.dependence))\\\\r\\\\n            let result = LZString.compressToEncodedURIComponent(input)\\\\r\\\\n                // ZipTool.compress.size.set(result.length * 2)\\\\r\\\\n            return result\\\\r\\\\n        }\\\\r\\\\n    },\\\\r\\\\n    decompress: {\\\\r\\\\n        size: {\\\\r\\\\n            get: () => {\\\\r\\\\n                return getMyVar(\\\\\\\"text-decompress\\\\\\\", \\\\\\\"0\\\\\\\")\\\\r\\\\n                    .length\\\\r\\\\n            }\\\\r\\\\n        },\\\\r\\\\n        exec: (input) => {\\\\r\\\\n            eval(request(ZipTool.dependence))\\\\r\\\\n            let result = LZString.decompressFromEncodedURIComponent(input)\\\\r\\\\n            return result\\\\r\\\\n        }\\\\r\\\\n    }\\\\r\\\\n}\\\\r\\\\n\\\\r\\\\n// 配置项工具类\\\\r\\\\nlet ConfigTool = {\\\\r\\\\n    encTypeList: ['Base64', 'Zipper'].concat(getPastes()),\\\\r\\\\n    toClipboard: (configCommand, name) => {\\\\r\\\\n        if (configCommand.startsWith('toast://')) return configCommand\\\\r\\\\n        if (!name) {\\\\r\\\\n            let commandSplits = configCommand.split(\\\\\\\"￥\\\\\\\")\\\\r\\\\n            name = commandSplits[2]\\\\r\\\\n            name = name ? (\\\\\\\"“\\\\\\\" + name + \\\\\\\"”\\\\\\\") : ''\\\\r\\\\n        }\\\\r\\\\n        refreshPage(false);\\\\r\\\\n        return \\\\\\\"copy://\\\\\\\" + configCommand + \\\\\\\".js:'toast://导出\\\\\\\" + name + \\\\\\\"成功！'\\\\\\\";\\\\r\\\\n    },\\\\r\\\\n    export: (name, config, remark, encType) => {\\\\r\\\\n        let symbol = \\\\\\\"青豆口令￥\\\\\\\" + remark + \\\\\\\"￥\\\\\\\" + name + \\\\\\\"￥\\\\\\\" + encType + \\\\\\\"￥\\\\\\\";\\\\r\\\\n        let result = config\\\\r\\\\n        if (typeof result === \\\\\\\"object\\\\\\\") {\\\\r\\\\n            result = JSON.stringify(config);\\\\r\\\\n        } else if (typeof result === \\\\\\\"string\\\\\\\") {\\\\r\\\\n            result = config;\\\\r\\\\n        } else {\\\\r\\\\n            throw \\\\\\\"导出数据不合法\\\\\\\"\\\\r\\\\n        }\\\\r\\\\n        switch (encType) {\\\\r\\\\n            case 'Base64':\\\\r\\\\n                result = base64Encode(result);\\\\r\\\\n                break;\\\\r\\\\n            case 'Zipper':\\\\r\\\\n                result = ZipTool.compress.exec(result)\\\\r\\\\n                break;\\\\r\\\\n            default :\\\\r\\\\n                if (getAppVersion() > 2070) {\\\\r\\\\n                    symbol = \\\\\\\"青豆口令￥\\\\\\\" + remark + \\\\\\\"￥\\\\\\\" + name\\\\r\\\\n                    result = sharePaste(ConfigTool.export(name, config, remark, 'Zipper'),encType);\\\\r\\\\n                    return result + '\\\\\\\\n\\\\\\\\n' + symbol\\\\r\\\\n                } else {\\\\r\\\\n                    return 'toast://请更新视界版本至 C2070 以上'\\\\r\\\\n                }\\\\r\\\\n                break;\\\\r\\\\n        }\\\\r\\\\n        result = symbol + result\\\\r\\\\n        return result;\\\\r\\\\n    },\\\\r\\\\n    import: (configCommand) => {\\\\r\\\\n        let result = ''\\\\r\\\\n        if (configCommand.startsWith('云')) {\\\\r\\\\n            if (getAppVersion() > 2070) {\\\\r\\\\n                result = configCommand.split('青豆')[0].replace(/\\\\\\\\\\\\\\\\n/, '')\\\\r\\\\n                configCommand = parsePaste(result)\\\\r\\\\n            } else {\\\\r\\\\n                return 'toast://请更新视界版本至 C2070 以上'\\\\r\\\\n            }\\\\r\\\\n        }\\\\r\\\\n        try {\\\\r\\\\n            let resultSplits = configCommand.split(\\\\\\\"￥\\\\\\\")\\\\r\\\\n            let encType = resultSplits[3]\\\\r\\\\n            result = resultSplits[4]\\\\r\\\\n            switch (encType) {\\\\r\\\\n                case 'Base64':\\\\r\\\\n                    result = base64Decode(result);\\\\r\\\\n                    break;\\\\r\\\\n                case 'Zipper':\\\\r\\\\n                    result = ZipTool.decompress.exec(result)\\\\r\\\\n                    break;\\\\r\\\\n            }\\\\r\\\\n            result = JSON.parse(result);\\\\r\\\\n        } catch (e) {\\\\r\\\\n            log(e.message)\\\\r\\\\n            throw \\\\\\\"导入数据不合法\\\\\\\"\\\\r\\\\n        }\\\\r\\\\n        return result;\\\\r\\\\n    }\\\\r\\\\n}\\\"}]\"}","picUrl":"https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2904304396.webp@Referer=https://img9.doubanio.com/view/photo/s_ratio_poster/public/p2904304396.webp","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!