邀您一起看：请登录

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥请登录@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"search\",\"rule\":\"js:\\nvar d = [];\\naddListener('onClose', () => {\\n    //refreshPage(false)\\n})\\nvar rule = MY_RULE.title;\\nsetPageTitle(MY_RULE.title + '·搜索')\\nclearVar('rurl');\\nclearMyVar('isdown');\\nvar home = config.home;\\n\\nvar cookie = getCookie(home);\\nvar loghtml = fetch(home);\\nvar islogin = loghtml.includes('登录');\\n//log(cookie)\\n//log(islogin) //true需要登录,false已经登录\\nif (getParam('key') != undefined) {\\n    putMyVar('keyword', getParam('key'))\\n}\\n\\n\\n\\nif (islogin) {\\n    eval(JSON.parse(fetch(\\\"hiker://page/login\\\", {})).rule);\\n} else {\\n    //log(MY_URL)\\n    var page = MY_PAGE;\\n    //log(page)\\n    var key = getMyVar('keyword', '')\\n    //log(key)\\n\\n    if (page == 1) {\\n        d.push({\\n            title: \\\"🔍\\\",\\n            url: $.toString((r) => {\\n                putMyVar('keyword', input);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, MY_RULE.title),\\n            desc: '必须登录并且1分钟只能搜索3次',\\n            col_type: \\\"input\\\",\\n            extra: {\\n                defaultValue: getMyVar('keyword', '') || \\\"\\\",\\n            }\\n        })\\n    }\\n\\n    MY_URL = home + '/search.php?key=' + key + '&page=' + page;\\n    if (key != '') {\\n        if (page == 1) {\\n            var homehtml = fetch(MY_URL, {\\n                headers: {\\n                    'Cookie': cookie,\\n                    'Referer': home,\\n                    'User-Agent': MOBILE_UA,\\n                }\\n            })\\n            if (homehtml.includes('登录')) {\\n                log('尚未登录')\\n            }\\n\\n            var hash = pdfh(homehtml, \\\"input[name=formhash]&&value\\\");\\n            //log(hash)\\n\\n            var json = JSON.parse(post(home + '/search.php?mod=forum', {\\n                headers: {\\n                    'Referer': home,\\n                    'origin': home,\\n                    'Cookie': cookie,\\n                    'User-Agent': MOBILE_UA,\\n                },\\n                body: {\\n                    mod: 'forum',\\n                    formhash: hash,\\n                    srchtype: 'title',\\n                    srhfid: 2,\\n                    srhlocality: 'forum::forumdisplay',\\n                    srchtxt: getParam('key'),\\n                    searchsubmit: 'true',\\n                },\\n                onlyHeaders: true,\\n                //redirect: false\\n            }));\\n            var rurl = json.url;\\n            putMyVar('rurl', rurl)\\n        }\\n\\n        var url = getMyVar('rurl') + '&page=' + page;\\n        if (getMyVar('rurl') == 'https://www.4khdr.cn/search.php?mod=forum') {\\n            toast('搜索过于频繁请稍候再试')\\n            setResult(d)\\n        }else{\\n\\n        var html = fetch(url, {\\n            headers: {\\n                'Cookie': cookie,\\n                'Referer': home,\\n                'User-Agent': MOBILE_UA,\\n            }\\n        })\\n        let tpage = '共 1 页 ';\\n        try {\\n            tpage = pdfh(html, '.pg&&span&&title');\\n        } catch {}\\n        let tpagestr = tpage + ' 当前 ' + page + ' 页';\\n        let tpagenum = tpage.replace(/[^0-9]/g, '');\\n        //log(tpagenum)\\n        if (page > tpagenum) {\\n            if (page != 1) {\\n                d.push({\\n                    title: '““””<small>到底了</small>',\\n                    col_type: 'text_center_1',\\n                    url: 'hiker://empty',\\n                })\\n            }\\n            putMyVar('isdown', '1')\\n            setResult(d);\\n        }\\n\\n        if (page == 1) {\\n            d.push({\\n                title: '' + pdfh(html, '.tl&&h2&&Text'),\\n                col_type: 'text_center_1',\\n                url: 'hiker://empty',\\n            })\\n        }\\n\\n        if (getMyVar('isdown') != '1') {\\n            d.push({\\n                title: '““””<small>' + tpagestr + '</small>',\\n                col_type: 'text_center_1',\\n                url: 'hiker://empty',\\n            })\\n            var list = pdfa(html, '#threadlist&&li'); //列表\\n\\n            for (let item of list) {\\n                var u = pd(item, 'a&&href');\\n                d.push({\\n                    title: pdfh(item, 'a&&Text'), //标题\\n                    desc: pdfh(item, ''), //第几集或清晰度\\n                    url: \\\"hiker://page/er?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u) + \\\"#immersiveTheme#\\\",\\n                    col_type: 'text_1',\\n                    extra: {\\n                        pageTitle: pdfh(item, 'a&&Text')\\n                    }\\n                });\\n            }\\n\\n            if (html.includes('对不起，没有找到匹配结果。')) {\\n                toast('无结果')\\n            } else {\\n                if (d.length < 3) {\\n                    toast('没有数据看日志记录')\\n                    log(html)\\n                }\\n            }\\n        }\\n      }\\n    }\\n}\\n\\nsetHomeResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"登录\",\"path\":\"login\",\"rule\":\"js:\\nevalPrivateJS(\\\"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\\\")\"},{\"col_type\":\"movie_3\",\"name\":\"二级\",\"path\":\"er\",\"rule\":\"js:\\nvar d  = [];\\nMY_URL = base64Decode(getParam('u').replace(/#immersiveTheme#/g, ''));\\n//log(MY_URL)\\nvar  html  =  fetch(MY_URL)\\n\\nif (getPageTitle() == '详情') {\\n    setPageTitle(pdfh(html, 'title&&Text'))\\n}\\n\\n\\nfunction small(str) {\\n    return '““””<small>' + str + '</small>'\\n}\\n\\nvar lazy = $('').lazyRule((MY_HOME,rule) => {\\n    if(input.startsWith('https://4khdr.cn/thread')){\\n        return \\\"hiker://page/er?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(input) + \\\"#immersiveTheme#\\\"\\n    }\\n    if (input.startsWith('https://www.aliyundrive.com/s/')) {\\n        return 'hiker://page/detail?rule=云盘汇影&url=' + input + '??fypage'\\n        //return 'hiker://page/push?rule=云盘君(推送)&url=hiker://empty##' + encodeURIComponent(input) + '???fypage';\\n    } else {\\n        require(\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=4831\\\");\\n        return input\\n    }\\n}, MY_HOME, MY_RULE.title)\\n\\nvar regex1 = /<img.*?>/g;\\nvar regex2 = /(<br>).\\\\1/g;\\nvar regex3 = /color=\\\".+?\\\"/g;\\nvar regex4 = /简介(\\\\s·){1,}.*?/g;\\nvar regex5 = / 　　/g;\\nvar regex6 = /简介：/g;\\nvar regex7 = /简介.+/g;\\ntry {\\n\\n    var title = pdfh(html, '.t_f&&font:matches(导演|主演)&&*:not(br)&&Html').replace(regex1, '').replace(regex2, '').replace(regex3, '').replace(regex7, '')\\n    //log(title)\\n} catch {\\n    var title = ''\\n}\\ntry {\\n    //var desc = pdfh(html, '.t_f&&font[color=\\\"#000000\\\"],-1&&Text')\\n    var xdesc = pdfh(html, '.t_f&&font:matches(简介)&&*:not(br)&&Html')\\n    var desc = xdesc.match(/简介(?:\\\\s)?(?::|：|·).+/g)[0].replace(/<[^>]+>/g, '').replace(regex4, '').replace(regex5, '').replace(regex6, '')\\n    //log(desc)\\n} catch {\\n    var desc = ''\\n}\\n\\n\\nd.push({\\n    title: '““””<small>' + title + '</small>',\\n        desc:  desc,\\n        pic_url: pd(html, '.zoom&&file'),\\n        col_type:   'movie_1_vertical_pic_blur',\\n    url: MY_URL,\\n})\\nd.push({\\n    title: \\\"““””<font color='blue'>⏬长按更多选项⏬<font>\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: \\\"hiker://empty\\\",\\n    extra: {\\n        lineVisible: false,\\n        textSize: 18\\n    }\\n});\\n\\nArray.prototype.flat = function(i) {\\n    i = arguments[0] || 1;\\n    const flat = (arr, deep) => {\\n        if (deep > 0)\\n            return arr.reduce((pre, cur) => pre.concat(Array.isArray(cur) ? flat(cur, deep - 1) : cur), [])\\n        return arr.slice()\\n    }\\n    return flat(this, i);\\n}\\n\\n//var 线路 = pdfa(html,'.t_f&&tr:has(a[href^=\\\"mag\\\"]):not(:has(:matches(⏬)))||tr:has(a[href^=\\\"https://w\\\"]),1:2')\\nvar 线路 = pdfa(html, '#postlist&&.t_table:has(a)')\\n线路=线路.map(x=>{\\n    var list=pdfa(x, 'body&&tr');\\n    return list;\\n}).flat()\\n\\n\\nif (线路.length == 0) {\\n    线路 = pdfa(html, '#postlist&&.t_f&&a').filter(x => /(magnet:)/.test(x))\\n}\\nif(线路.length==0){\\n    线路=pdfa(html,'.t_fsz&&a[href*=https://4khdr.cn/thread]')\\n}\\n\\n\\nvar open = {\\n    copy: function(url) {\\n        return {\\n            title: \\\"复制链接\\\",\\n            js: JSON.stringify(\\\"copy://\\\" + url),\\n        }\\n    },\\n    magnet: function(url) {\\n        return {\\n            title: \\\"其它应用打开\\\",\\n            js: JSON.stringify(\\\"magnet://\\\" + url),\\n        }\\n    },\\n    ali: function(url) {\\n        return [{\\n            title: \\\"云盘君(推送)\\\",\\n            js: $.toString((input) => {\\n                return 'hiker://page/push?rule=云盘君(推送)&url=hiker://empty##' + encodeURIComponent(input) + '???fypage';\\n            }, url),\\n        }, {\\n            title: \\\"保存\\\",\\n            js: JSON.stringify('smartdrive://share/browse?shareId=' + url.replace(/.*?(\\\\w+)$/g, '$1') + '&sharePwd=')\\n        }]\\n    }\\n}\\n\\nvar urls = [];\\nfor (let i in 线路) {\\n    if(!线路[i].includes('href')){\\n        continue;\\n    }\\n    \\n    let list = [];\\n    var action = [];\\n    var url = pd(线路[i], 'a&&href')\\n\\n    if (urls.includes(url)) {\\n        continue;\\n    } else {\\n        urls.push(url);\\n    }\\n    var temp=\\\"<table>\\\"+线路[i]+\\\"</table>\\\"\\n    \\n    //log(temp)\\n    list = pdfa(temp,'body&&tr')\\n\\n    list = list.length == 0 ? pdfa(线路[i], 'body&&a') : list;\\n    list = list.map(x => pdfh(x, 'Text')).filter(y => !y.includes('magnet:?xt') && y != \\\"\\\");\\n\\n    action.push(open.copy(url));\\n    if (url.includes('magnet')) {\\n        action.push(open.magnet(url));\\n    }\\n    if (url.startsWith('https://www.aliyundrive.com/s/')) {\\n        var arr = open.ali(url);\\n        action = action.concat(arr);\\n    }\\n\\n\\n    d.push({\\n        title: small(list.join('\\\\n').replace('资源下载地址⏬', '')),\\n        url: url + lazy,\\n        col_type: \\\"text_1\\\",\\n        // desc: '““'+pdfh(线路[i],'font,-1&&Text')+'””',\\n        //pic_url: \\\"\\\"\\n        extra: {\\n            longClick: action\\n        }\\n    });\\n\\n}\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"轮播\",\"path\":\"lunbo\",\"rule\":\"js:\\nfunction banner(title, start, arr, data, cfg) {\\n    let id = title + 'lunbo';\\n    var rnum = Math.floor(Math.random() * data.length);\\n    var item = data[rnum];\\n    putMyVar('rnum', rnum);\\n    let time = 5000;\\n    let col_type = 'pic_1_card';\\n    let color = \\\"white\\\";\\n    let desc = '';\\n    if (cfg != undefined) {\\n        time = cfg.time ? cfg.time : time;\\n        col_type = cfg.col_type ? cfg.col_type : col_type;\\n        desc = cfg.desc ? cfg.desc : desc;\\n    }\\n\\n    arr.push({\\n        col_type: col_type,\\n        img: item.img,\\n        desc: desc,\\n        title: item.title,\\n        url: item.url,\\n        extra: {\\n            id: id+'bar',\\n        }\\n    })\\n\\n    if (start == false || getMyVar('benstart', 'true') == 'false') {\\n        unRegisterTask(id)\\n        return\\n    }\\n\\n    let obj = {\\n        data: data,\\n    };\\n\\n    registerTask(id, time, $.toString((obj,id) => {\\n        var data = obj.data;\\n        var rum = getMyVar('rnum');\\n\\n        var i = Number(getMyVar('banneri', '0'));\\n        if (rum != '') {\\n            i = Number(rum) + 1\\n            clearMyVar('rnum')\\n        } else {\\n            i = i + 1;\\n        }\\n        //log(i)\\n        //log(data.length)\\n\\n        if (i > data.length - 1) {\\n            i = 0\\n        }\\n        var item = data[i];\\n        //log(item)\\n        try {\\n            updateItem(id+'bar', {\\n                title: item.title,\\n                img: item.img,\\n                url: item.url,\\n                extra: {\\n                    //name: item.title.replace(/<[^>]+>/g, ''),\\n                    //sname: item.extra.sname,\\n                    //stype: item.extra.stype,\\n                    //surl: item.url,\\n                    //img:item.img,\\n                    //pageTitle: item.title.replace(/<[^>]+>/g, ''),\\n                }\\n            })\\n        } catch (e) {\\n            log(e.message)\\n            unRegisterTask(id)\\n        }\\n        putMyVar('banneri', i);\\n\\n    }, obj,id))\\n}\"}],\"params\":\"{\\\"defaultValue\\\":\\\"\\\",\\\"onChange\\\":\\\"(\\\\n() => {\\\\n    putMyVar(\\\\\\\"keyword\\\\\\\", input);\\\\n}\\\\n)()\\\"}\",\"saved\":false,\"title\":\"4khdr·X\",\"version\":0,\"url\":\"hiker://page/search?&page=fypage\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\nvar d = [];\\naddListener('onClose', () => {\\n    //refreshPage(false)\\n})\\nvar rule = MY_RULE.title;\\nsetPageTitle(MY_RULE.title + '·搜索')\\nclearVar('rurl');\\nclearMyVar('isdown');\\nvar home = config.home;\\n\\nvar cookie = getCookie(home);\\nvar loghtml = fetch(home);\\nvar islogin = loghtml.includes('登录');\\n//log(cookie)\\n//log(islogin) //true需要登录,false已经登录\\nif (getParam('key') != undefined) {\\n    putMyVar('keyword', getParam('key'))\\n}\\n\\n\\n\\nif (islogin) {\\n    eval(JSON.parse(fetch(\\\"hiker://page/login\\\", {})).rule);\\n} else {\\n    //log(MY_URL)\\n    var page = MY_PAGE;\\n    //log(page)\\n    var key = getMyVar('keyword', '')\\n    //log(key)\\n\\n    if (page == 1) {\\n        d.push({\\n            title: \\\"🔍\\\",\\n            url: $.toString((r) => {\\n                putMyVar('keyword', input);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, MY_RULE.title),\\n            desc: '必须登录并且1分钟只能搜索3次',\\n            col_type: \\\"input\\\",\\n            extra: {\\n                defaultValue: getMyVar('keyword', '') || \\\"\\\",\\n            }\\n        })\\n    }\\n\\n    MY_URL = home + '/search.php?key=' + key + '&page=' + page;\\n    if (key != '') {\\n        if (page == 1) {\\n            var homehtml = fetch(MY_URL, {\\n                headers: {\\n                    'Cookie': cookie,\\n                    'Referer': home,\\n                    'User-Agent': MOBILE_UA,\\n                }\\n            })\\n            if (homehtml.includes('登录')) {\\n                log('尚未登录')\\n            }\\n\\n            var hash = pdfh(homehtml, \\\"input[name=formhash]&&value\\\");\\n            //log(hash)\\n\\n            var json = JSON.parse(post(home + '/search.php?mod=forum', {\\n                headers: {\\n                    'Referer': home,\\n                    'origin': home,\\n                    'Cookie': cookie,\\n                    'User-Agent': MOBILE_UA,\\n                },\\n                body: {\\n                    mod: 'forum',\\n                    formhash: hash,\\n                    srchtype: 'title',\\n                    srhfid: 2,\\n                    srhlocality: 'forum::forumdisplay',\\n                    srchtxt: getParam('key'),\\n                    searchsubmit: 'true',\\n                },\\n                onlyHeaders: true,\\n                //redirect: false\\n            }));\\n            var rurl = json.url;\\n            putMyVar('rurl', rurl)\\n        }\\n\\n        var url = getMyVar('rurl') + '&page=' + page;\\n        if (getMyVar('rurl') == 'https://www.4khdr.cn/search.php?mod=forum') {\\n            toast('搜索过于频繁请稍候再试')\\n            setResult(d)\\n        }else{\\n\\n        var html = fetch(url, {\\n            headers: {\\n                'Cookie': cookie,\\n                'Referer': home,\\n                'User-Agent': MOBILE_UA,\\n            }\\n        })\\n        let tpage = '共 1 页 ';\\n        try {\\n            tpage = pdfh(html, '.pg&&span&&title');\\n        } catch {}\\n        let tpagestr = tpage + ' 当前 ' + page + ' 页';\\n        let tpagenum = tpage.replace(/[^0-9]/g, '');\\n        //log(tpagenum)\\n        if (page > tpagenum) {\\n            if (page != 1) {\\n                d.push({\\n                    title: '““””<small>到底了</small>',\\n                    col_type: 'text_center_1',\\n                    url: 'hiker://empty',\\n                })\\n            }\\n            putMyVar('isdown', '1')\\n            setResult(d);\\n        }\\n\\n        if (page == 1) {\\n            d.push({\\n                title: '' + pdfh(html, '.tl&&h2&&Text'),\\n                col_type: 'text_center_1',\\n                url: 'hiker://empty',\\n            })\\n        }\\n\\n        if (getMyVar('isdown') != '1') {\\n            d.push({\\n                title: '““””<small>' + tpagestr + '</small>',\\n                col_type: 'text_center_1',\\n                url: 'hiker://empty',\\n            })\\n            var list = pdfa(html, '#threadlist&&li'); //列表\\n\\n            for (let item of list) {\\n                var u = pd(item, 'a&&href');\\n                d.push({\\n                    title: pdfh(item, 'a&&Text'), //标题\\n                    desc: pdfh(item, ''), //第几集或清晰度\\n                    url: \\\"hiker://page/er?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u) + \\\"#immersiveTheme#\\\",\\n                    col_type: 'text_1',\\n                    extra: {\\n                        pageTitle: pdfh(item, 'a&&Text')\\n                    }\\n                });\\n            }\\n\\n            if (html.includes('对不起，没有找到匹配结果。')) {\\n                toast('无结果')\\n            } else {\\n                if (d.length < 3) {\\n                    toast('没有数据看日志记录')\\n                    log(html)\\n                }\\n            }\\n        }\\n      }\\n    }\\n}\\n\\nsetHomeResult(d)\",\"group\":\"1⃣影视💯\",\"ua\":\"mobile\",\"preRule\":\"initConfig({\\n    categoryLib: 'http://hiker.nokia.press/hikerule/rulelist.json?id=2705',\\n    categoryLocalLib: 'hiker://files/rules/js/categories-header.js',\\n    categoryGiteeLib: 'https://gitee.com/reborn0/HikerRules/raw/master/plugins/categories-header.js',\\n    home: 'https://www.4khdr.cn',\\n})\\n\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索\\\",\\\"path\\\":\\\"search\\\",\\\"rule\\\":\\\"js:\\\\nvar d = [];\\\\naddListener('onClose', () => {\\\\n    //refreshPage(false)\\\\n})\\\\nvar rule = MY_RULE.title;\\\\nsetPageTitle(MY_RULE.title + '·搜索')\\\\nclearVar('rurl');\\\\nclearMyVar('isdown');\\\\nvar home = config.home;\\\\n\\\\nvar cookie = getCookie(home);\\\\nvar loghtml = fetch(home);\\\\nvar islogin = loghtml.includes('登录');\\\\n//log(cookie)\\\\n//log(islogin) //true需要登录,false已经登录\\\\nif (getParam('key') != undefined) {\\\\n    putMyVar('keyword', getParam('key'))\\\\n}\\\\n\\\\n\\\\n\\\\nif (islogin) {\\\\n    eval(JSON.parse(fetch(\\\\\\\"hiker://page/login\\\\\\\", {})).rule);\\\\n} else {\\\\n    //log(MY_URL)\\\\n    var page = MY_PAGE;\\\\n    //log(page)\\\\n    var key = getMyVar('keyword', '')\\\\n    //log(key)\\\\n\\\\n    if (page == 1) {\\\\n        d.push({\\\\n            title: \\\\\\\"🔍\\\\\\\",\\\\n            url: $.toString((r) => {\\\\n                putMyVar('keyword', input);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            }, MY_RULE.title),\\\\n            desc: '必须登录并且1分钟只能搜索3次',\\\\n            col_type: \\\\\\\"input\\\\\\\",\\\\n            extra: {\\\\n                defaultValue: getMyVar('keyword', '') || \\\\\\\"\\\\\\\",\\\\n            }\\\\n        })\\\\n    }\\\\n\\\\n    MY_URL = home + '/search.php?key=' + key + '&page=' + page;\\\\n    if (key != '') {\\\\n        if (page == 1) {\\\\n            var homehtml = fetch(MY_URL, {\\\\n                headers: {\\\\n                    'Cookie': cookie,\\\\n                    'Referer': home,\\\\n                    'User-Agent': MOBILE_UA,\\\\n                }\\\\n            })\\\\n            if (homehtml.includes('登录')) {\\\\n                log('尚未登录')\\\\n            }\\\\n\\\\n            var hash = pdfh(homehtml, \\\\\\\"input[name=formhash]&&value\\\\\\\");\\\\n            //log(hash)\\\\n\\\\n            var json = JSON.parse(post(home + '/search.php?mod=forum', {\\\\n                headers: {\\\\n                    'Referer': home,\\\\n                    'origin': home,\\\\n                    'Cookie': cookie,\\\\n                    'User-Agent': MOBILE_UA,\\\\n                },\\\\n                body: {\\\\n                    mod: 'forum',\\\\n                    formhash: hash,\\\\n                    srchtype: 'title',\\\\n                    srhfid: 2,\\\\n                    srhlocality: 'forum::forumdisplay',\\\\n                    srchtxt: getParam('key'),\\\\n                    searchsubmit: 'true',\\\\n                },\\\\n                onlyHeaders: true,\\\\n                //redirect: false\\\\n            }));\\\\n            var rurl = json.url;\\\\n            putMyVar('rurl', rurl)\\\\n        }\\\\n\\\\n        var url = getMyVar('rurl') + '&page=' + page;\\\\n        if (getMyVar('rurl') == 'https://www.4khdr.cn/search.php?mod=forum') {\\\\n            toast('搜索过于频繁请稍候再试')\\\\n            setResult(d)\\\\n        }else{\\\\n\\\\n        var html = fetch(url, {\\\\n            headers: {\\\\n                'Cookie': cookie,\\\\n                'Referer': home,\\\\n                'User-Agent': MOBILE_UA,\\\\n            }\\\\n        })\\\\n        let tpage = '共 1 页 ';\\\\n        try {\\\\n            tpage = pdfh(html, '.pg&&span&&title');\\\\n        } catch {}\\\\n        let tpagestr = tpage + ' 当前 ' + page + ' 页';\\\\n        let tpagenum = tpage.replace(/[^0-9]/g, '');\\\\n        //log(tpagenum)\\\\n        if (page > tpagenum) {\\\\n            if (page != 1) {\\\\n                d.push({\\\\n                    title: '““””<small>到底了</small>',\\\\n                    col_type: 'text_center_1',\\\\n                    url: 'hiker://empty',\\\\n                })\\\\n            }\\\\n            putMyVar('isdown', '1')\\\\n            setResult(d);\\\\n        }\\\\n\\\\n        if (page == 1) {\\\\n            d.push({\\\\n                title: '' + pdfh(html, '.tl&&h2&&Text'),\\\\n                col_type: 'text_center_1',\\\\n                url: 'hiker://empty',\\\\n            })\\\\n        }\\\\n\\\\n        if (getMyVar('isdown') != '1') {\\\\n            d.push({\\\\n                title: '““””<small>' + tpagestr + '</small>',\\\\n                col_type: 'text_center_1',\\\\n                url: 'hiker://empty',\\\\n            })\\\\n            var list = pdfa(html, '#threadlist&&li'); //列表\\\\n\\\\n            for (let item of list) {\\\\n                var u = pd(item, 'a&&href');\\\\n                d.push({\\\\n                    title: pdfh(item, 'a&&Text'), //标题\\\\n                    desc: pdfh(item, ''), //第几集或清晰度\\\\n                    url: \\\\\\\"hiker://page/er?rule=\\\\\\\" + rule + \\\\\\\"&u=\\\\\\\" + base64Encode(u) + \\\\\\\"#immersiveTheme#\\\\\\\",\\\\n                    col_type: 'text_1',\\\\n                    extra: {\\\\n                        pageTitle: pdfh(item, 'a&&Text')\\\\n                    }\\\\n                });\\\\n            }\\\\n\\\\n            if (html.includes('对不起，没有找到匹配结果。')) {\\\\n                toast('无结果')\\\\n            } else {\\\\n                if (d.length < 3) {\\\\n                    toast('没有数据看日志记录')\\\\n                    log(html)\\\\n                }\\\\n            }\\\\n        }\\\\n      }\\\\n    }\\\\n}\\\\n\\\\nsetHomeResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"登录\\\",\\\"path\\\":\\\"login\\\",\\\"rule\\\":\\\"js:\\\\nevalPrivateJS(\\\\\\\"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\\\\\\\")\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"二级\\\",\\\"path\\\":\\\"er\\\",\\\"rule\\\":\\\"js:\\\\nvar d  = [];\\\\nMY_URL = base64Decode(getParam('u').replace(/#immersiveTheme#/g, ''));\\\\n//log(MY_URL)\\\\nvar  html  =  fetch(MY_URL)\\\\n\\\\nif (getPageTitle() == '详情') {\\\\n    setPageTitle(pdfh(html, 'title&&Text'))\\\\n}\\\\n\\\\n\\\\nfunction small(str) {\\\\n    return '““””<small>' + str + '</small>'\\\\n}\\\\n\\\\nvar lazy = $('').lazyRule((MY_HOME,rule) => {\\\\n    if(input.startsWith('https://4khdr.cn/thread')){\\\\n        return \\\\\\\"hiker://page/er?rule=\\\\\\\" + rule + \\\\\\\"&u=\\\\\\\" + base64Encode(input) + \\\\\\\"#immersiveTheme#\\\\\\\"\\\\n    }\\\\n    if (input.startsWith('https://www.aliyundrive.com/s/')) {\\\\n        return 'hiker://page/detail?rule=云盘汇影&url=' + input + '??fypage'\\\\n        //return 'hiker://page/push?rule=云盘君(推送)&url=hiker://empty##' + encodeURIComponent(input) + '???fypage';\\\\n    } else {\\\\n        require(\\\\\\\"http://hiker.nokia.press/hikerule/rulelist.json?id=4831\\\\\\\");\\\\n        return input\\\\n    }\\\\n}, MY_HOME, MY_RULE.title)\\\\n\\\\nvar regex1 = /<img.*?>/g;\\\\nvar regex2 = /(<br>).\\\\\\\\1/g;\\\\nvar regex3 = /color=\\\\\\\".+?\\\\\\\"/g;\\\\nvar regex4 = /简介(\\\\\\\\s·){1,}.*?/g;\\\\nvar regex5 = / 　　/g;\\\\nvar regex6 = /简介：/g;\\\\nvar regex7 = /简介.+/g;\\\\ntry {\\\\n\\\\n    var title = pdfh(html, '.t_f&&font:matches(导演|主演)&&*:not(br)&&Html').replace(regex1, '').replace(regex2, '').replace(regex3, '').replace(regex7, '')\\\\n    //log(title)\\\\n} catch {\\\\n    var title = ''\\\\n}\\\\ntry {\\\\n    //var desc = pdfh(html, '.t_f&&font[color=\\\\\\\"#000000\\\\\\\"],-1&&Text')\\\\n    var xdesc = pdfh(html, '.t_f&&font:matches(简介)&&*:not(br)&&Html')\\\\n    var desc = xdesc.match(/简介(?:\\\\\\\\s)?(?::|：|·).+/g)[0].replace(/<[^>]+>/g, '').replace(regex4, '').replace(regex5, '').replace(regex6, '')\\\\n    //log(desc)\\\\n} catch {\\\\n    var desc = ''\\\\n}\\\\n\\\\n\\\\nd.push({\\\\n    title: '““””<small>' + title + '</small>',\\\\n        desc:  desc,\\\\n        pic_url: pd(html, '.zoom&&file'),\\\\n        col_type:   'movie_1_vertical_pic_blur',\\\\n    url: MY_URL,\\\\n})\\\\nd.push({\\\\n    title: \\\\\\\"““””<font color='blue'>⏬长按更多选项⏬<font>\\\\\\\",\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    extra: {\\\\n        lineVisible: false,\\\\n        textSize: 18\\\\n    }\\\\n});\\\\n\\\\nArray.prototype.flat = function(i) {\\\\n    i = arguments[0] || 1;\\\\n    const flat = (arr, deep) => {\\\\n        if (deep > 0)\\\\n            return arr.reduce((pre, cur) => pre.concat(Array.isArray(cur) ? flat(cur, deep - 1) : cur), [])\\\\n        return arr.slice()\\\\n    }\\\\n    return flat(this, i);\\\\n}\\\\n\\\\n//var 线路 = pdfa(html,'.t_f&&tr:has(a[href^=\\\\\\\"mag\\\\\\\"]):not(:has(:matches(⏬)))||tr:has(a[href^=\\\\\\\"https://w\\\\\\\"]),1:2')\\\\nvar 线路 = pdfa(html, '#postlist&&.t_table:has(a)')\\\\n线路=线路.map(x=>{\\\\n    var list=pdfa(x, 'body&&tr');\\\\n    return list;\\\\n}).flat()\\\\n\\\\n\\\\nif (线路.length == 0) {\\\\n    线路 = pdfa(html, '#postlist&&.t_f&&a').filter(x => /(magnet:)/.test(x))\\\\n}\\\\nif(线路.length==0){\\\\n    线路=pdfa(html,'.t_fsz&&a[href*=https://4khdr.cn/thread]')\\\\n}\\\\n\\\\n\\\\nvar open = {\\\\n    copy: function(url) {\\\\n        return {\\\\n            title: \\\\\\\"复制链接\\\\\\\",\\\\n            js: JSON.stringify(\\\\\\\"copy://\\\\\\\" + url),\\\\n        }\\\\n    },\\\\n    magnet: function(url) {\\\\n        return {\\\\n            title: \\\\\\\"其它应用打开\\\\\\\",\\\\n            js: JSON.stringify(\\\\\\\"magnet://\\\\\\\" + url),\\\\n        }\\\\n    },\\\\n    ali: function(url) {\\\\n        return [{\\\\n            title: \\\\\\\"云盘君(推送)\\\\\\\",\\\\n            js: $.toString((input) => {\\\\n                return 'hiker://page/push?rule=云盘君(推送)&url=hiker://empty##' + encodeURIComponent(input) + '???fypage';\\\\n            }, url),\\\\n        }, {\\\\n            title: \\\\\\\"保存\\\\\\\",\\\\n            js: JSON.stringify('smartdrive://share/browse?shareId=' + url.replace(/.*?(\\\\\\\\w+)$/g, '$1') + '&sharePwd=')\\\\n        }]\\\\n    }\\\\n}\\\\n\\\\nvar urls = [];\\\\nfor (let i in 线路) {\\\\n    if(!线路[i].includes('href')){\\\\n        continue;\\\\n    }\\\\n    \\\\n    let list = [];\\\\n    var action = [];\\\\n    var url = pd(线路[i], 'a&&href')\\\\n\\\\n    if (urls.includes(url)) {\\\\n        continue;\\\\n    } else {\\\\n        urls.push(url);\\\\n    }\\\\n    var temp=\\\\\\\"<table>\\\\\\\"+线路[i]+\\\\\\\"</table>\\\\\\\"\\\\n    \\\\n    //log(temp)\\\\n    list = pdfa(temp,'body&&tr')\\\\n\\\\n    list = list.length == 0 ? pdfa(线路[i], 'body&&a') : list;\\\\n    list = list.map(x => pdfh(x, 'Text')).filter(y => !y.includes('magnet:?xt') && y != \\\\\\\"\\\\\\\");\\\\n\\\\n    action.push(open.copy(url));\\\\n    if (url.includes('magnet')) {\\\\n        action.push(open.magnet(url));\\\\n    }\\\\n    if (url.startsWith('https://www.aliyundrive.com/s/')) {\\\\n        var arr = open.ali(url);\\\\n        action = action.concat(arr);\\\\n    }\\\\n\\\\n\\\\n    d.push({\\\\n        title: small(list.join('\\\\\\\\n').replace('资源下载地址⏬', '')),\\\\n        url: url + lazy,\\\\n        col_type: \\\\\\\"text_1\\\\\\\",\\\\n        // desc: '““'+pdfh(线路[i],'font,-1&&Text')+'””',\\\\n        //pic_url: \\\\\\\"\\\\\\\"\\\\n        extra: {\\\\n            longClick: action\\\\n        }\\\\n    });\\\\n\\\\n}\\\\n\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"轮播\\\",\\\"path\\\":\\\"lunbo\\\",\\\"rule\\\":\\\"js:\\\\nfunction banner(title, start, arr, data, cfg) {\\\\n    let id = title + 'lunbo';\\\\n    var rnum = Math.floor(Math.random() * data.length);\\\\n    var item = data[rnum];\\\\n    putMyVar('rnum', rnum);\\\\n    let time = 5000;\\\\n    let col_type = 'pic_1_card';\\\\n    let color = \\\\\\\"white\\\\\\\";\\\\n    let desc = '';\\\\n    if (cfg != undefined) {\\\\n        time = cfg.time ? cfg.time : time;\\\\n        col_type = cfg.col_type ? cfg.col_type : col_type;\\\\n        desc = cfg.desc ? cfg.desc : desc;\\\\n    }\\\\n\\\\n    arr.push({\\\\n        col_type: col_type,\\\\n        img: item.img,\\\\n        desc: desc,\\\\n        title: item.title,\\\\n        url: item.url,\\\\n        extra: {\\\\n            id: id+'bar',\\\\n        }\\\\n    })\\\\n\\\\n    if (start == false || getMyVar('benstart', 'true') == 'false') {\\\\n        unRegisterTask(id)\\\\n        return\\\\n    }\\\\n\\\\n    let obj = {\\\\n        data: data,\\\\n    };\\\\n\\\\n    registerTask(id, time, $.toString((obj,id) => {\\\\n        var data = obj.data;\\\\n        var rum = getMyVar('rnum');\\\\n\\\\n        var i = Number(getMyVar('banneri', '0'));\\\\n        if (rum != '') {\\\\n            i = Number(rum) + 1\\\\n            clearMyVar('rnum')\\\\n        } else {\\\\n            i = i + 1;\\\\n        }\\\\n        //log(i)\\\\n        //log(data.length)\\\\n\\\\n        if (i > data.length - 1) {\\\\n            i = 0\\\\n        }\\\\n        var item = data[i];\\\\n        //log(item)\\\\n        try {\\\\n            updateItem(id+'bar', {\\\\n                title: item.title,\\\\n                img: item.img,\\\\n                url: item.url,\\\\n                extra: {\\\\n                    //name: item.title.replace(/<[^>]+>/g, ''),\\\\n                    //sname: item.extra.sname,\\\\n                    //stype: item.extra.stype,\\\\n                    //surl: item.url,\\\\n                    //img:item.img,\\\\n                    //pageTitle: item.title.replace(/<[^>]+>/g, ''),\\\\n                }\\\\n            })\\\\n        } catch (e) {\\\\n            log(e.message)\\\\n            unRegisterTask(id)\\\\n        }\\\\n        putMyVar('banneri', i);\\\\n\\\\n    }, obj,id))\\\\n}\\\"}]\",\"proxy\":\"\"}","title":"请登录"}