API tools faq
paste
xiaomianao666

小程序：AI聚集

xiaomianao666
Feb 27th, 2024
161
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 176.33 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@AI聚集@{"last_chapter_rule":"","title":"AI聚集","author":"","url":"hiker://empty##fyclass##fypage","version":54,"col_type":"movie_3_marquee","class_name":"首页&豌豆&茶杯狐&搜片&青麦&电影狗&茶杯虎&土拨鼠&动漫巴士","type":"tool","class_url":"home&https://www.wandou.la/&https://cupfox.app/&http://soupian.xyz/&https://www.qmtv.pro/&https://www.dianyinggou.com/yingku/&https://www.725998.com/yingku&https://www.tbsdy.com/m/index.html&https://dm84.tv","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar myurl = MY_URL.split(\"##\")[1];\n\nlet anchorId = myurl;\nlet js = $.require(\"hiker://page/x5ai\")(MY_RULE.title, anchorId);\n\nfunction loadUrl(myurl, myrule, m) {\n    setResult([{\n        col_type: \"x5_webview_single\",\n        url: myurl,\n        desc: \"float&&top\",\n        extra: {\n            floatVideo: true,\n            canBack: true,\n            urlInterceptor: $.toString((MY_RULE, moban) => {\n                log(input)\n                if (input.startsWith('https://www.aliyundrive.com/s/')) {\n                    return $.toString((url) => {\n                        fba.open(JSON.stringify({\n                            rule: '云盘汇影',\n                            url: 'hiker://page/detail?rule=云盘汇影&url=' + url + '??fypage'\n                        }));\n                    }, input)\n                } else if (input.startsWith('https://dm84.tv/v/')) {\n                    return $.toString((url, MY_RULE, moban) => {\n                        var u = 'hiker://empty?u=' + url;\n                        u = moban == '0' ? u : u + '#immersiveTheme#';\n                        fba.open(JSON.stringify({\n                            rule: MY_RULE.title,\n                            title: '影片详情',\n                            group: MY_RULE.group,\n                            preRule: MY_RULE.preRule,\n                            pages: MY_RULE.pages,\n                            url: u,\n                            findRule: MY_RULE.detail_find_rule\n                        }));\n                    }, input, MY_RULE, moban)\n                } else if (!input.startsWith('https://dm84.tv') && !input.startsWith(\"https://cupfox.app/\") && !input.startsWith(\"https://51souju.com/\") &&\n                    !input.startsWith(\"https://www.dianyinggou.com/\") && !input.startsWith(\"https://www.wandou.la/\") && !input.startsWith(\"http://soupian.xyz/\") && !input.startsWith(\"http://m.qmtv.pro/\") && !\n                    input.startsWith(\"https://www.725998.com/\") && !input.includes(\"search\")) {\n                    return $.toString((url, MY_RULE, moban) => {\n                        var u = 'hiker://empty?u=' + url;\n                        u = moban == '0' ? u : u + '#immersiveTheme#';\n                        fba.open(JSON.stringify({\n                            rule: MY_RULE.title,\n                            title: '影片详情',\n                            group: MY_RULE.group,\n                            preRule: MY_RULE.preRule,\n                            pages: MY_RULE.pages,\n                            url: u,\n                            findRule: MY_RULE.detail_find_rule\n                        }));\n                    }, input, MY_RULE, moban)\n                }\n            }, MY_RULE, getItem('ai', '0')),\n            js: js,\n        }\n    }]);\n}\n\nif (myurl == 'home') {\n    refreshX5Desc('0')\n    $.require('hiker://page/pro')\n} else {\n    loadUrl(myurl, MY_RULE);\n}","search_url":"hiker://empty##**","group":"①推荐","searchFind":"js:\nvar d = [];\nlet key = MY_URL.split(\"##\")[1];\nd.push({\n    title: \"点我开始聚合搜索\" + key,\n    url: \"hiker://page/soup\",\n    extra: {\n        pageTitle: \"搜索\" + key,\n        key: key\n    }\n});\n\nsetResult(d);","detail_col_type":"movie_1","detail_find_rule":"js:\nlog(MY_URL)\n\neval(JSON.parse(request('hiker://page/p')).rule)","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"var ua = '';\nrequire('https://gitcode.net/qq_32394351/dr/-/raw/master/js/预处理.js');\n\ninitConfig({\n    wandou: \"api.json.wandou9.xyz:8036\",\n    soupian: 'soupian.xyz',\n    qimai: 'www.qmtv.pro'\n});","pages":"[{\"col_type\":\"movie_3\",\"name\":\"二级解析\",\"path\":\"p\",\"rule\":\"js:\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    updateItem('parset', {\\n        title: getItem('嗅探', '视频嗅探'),\\n    });\\n    clearMyVar('weburl');\\n    putMyVar('bm', '0');\\n    storage0.putMyVar(\\\"duoselect\\\", []);\\n    //back(false)\\n}));\\n\\nvar BitTS = [];\\n\\n//putMyVar(\\\"muban\\\", {名称:'极客影视'})\\n\\neval(JSON.parse(request('hiker://page/ztools')).rule)\\n\\nvar url = '';\\nvar html = '';\\n\\nvar keys = MY_PARAMS;\\nvar from = keys.from != undefined ? keys.from : '';\\nvar dtitle = keys.pageTitle != undefined ? keys.pageTitle : '';\\n\\n\\nif (getMyVar('weburl', '') == '') {\\n    //MY_URL = MY_URL.replace('#immersiveTheme#', '');\\n    MY_URL = MY_URL.includes('#') ? MY_URL.split('#')[0] : MY_URL;\\n    var u = getParam(\\\"u\\\")\\n    if (u == undefined) {\\n        u = MY_URL\\n    }\\n    log('u:' + u);\\n    url = getTurl(u);\\n    //预读\\n    //log('url:'+url);\\n    var temp = fetch(url);\\n    var al = pdfa(temp, \\\"body&&a\\\");\\n    if (temp.search(/window.location.href/) != -1 && al.length == 0) {\\n        MY_URL = url;\\n        var te = temp.replace(/.+href=\\\"(.*?)\\\".+/g, '<a href=\\\"$1\\\"></a>');\\n        url = pd(te, \\\"a&&href\\\");\\n        log('js重定向:' + url);\\n    } else {\\n        html = temp;\\n    }\\n\\n    putMyVar('weburl', url);\\n\\n} else {\\n    url = getMyVar('weburl');\\n}\\nvar durl = url;\\nlog('二级页面:' + durl);\\n\\nif (getItem('ai', '0') == '1') {\\n    var lazy = $('').lazyRule(() => {\\n        try {\\n            var html = JSON.parse(request(input).match(/r player_.*?=(.*?)</)[1])\\n            var url = html.url\\n            if (html.encrypt == '1') {\\n                url = unescape(url);\\n            } else if (html.encrypt == '2') {\\n                url = unescape(base64Decode(url));\\n            }\\n            if (/m3u8|mp4/.test(url)) {\\n                return url\\n            } else {\\n                return 'video://' + input\\n            }\\n        } catch (e) {\\n            return 'video://' + input\\n        }\\n    })\\n\\n    try {\\n        log(url)\\n        MY_URL = 'hiker://empty##' + url\\n        require(config.自动匹配);\\n        自动二级(lazy);\\n        putMyVar('bm', '1')\\n    } catch {\\n        putMyVar('bm', '0')\\n    }\\n}\\n\\n\\nlog('模板:' + getMyVar('bm', '0'))\\n\\nif (getMyVar('bm', '0') == '0') {\\n\\n    var d = [];\\n    MY_URL = url\\n\\n    function getTitle(html, s) {\\n        var title = '';\\n        var titles = pdfa(html, s);\\n        //log(titles);\\n        if (titles.length == 0) {\\n            return title\\n        }\\n        for (let x of titles) {\\n            if (x.includes('<font')) {\\n                title = pdfh(x, 'h1--font&&Text');\\n            } else if (x.includes('<span')) {\\n                title = pdfh(x, 'h1--span&&Text');\\n            } else {\\n                title = pdfh(x, 'Text');\\n            }\\n            if (title != '') {\\n                break;\\n            } else {\\n                continue;\\n            }\\n        }\\n        return title\\n    }\\n\\n    if (html == \\\"\\\") {\\n        html = fetchPC(url)\\n    }\\n\\n    let alist = pdfa(html, \\\"body&&a\\\");\\n    /*if(html.search(/window.location.href/)!=-1&&alist.length==0){\\n        MY_URL=url;\\n    var temp=html.replace(/.+href=\\\"(.*?)\\\".+/g,'<a href=\\\"$1\\\"></a>');\\n    url=pd(temp,\\\"a&&href\\\");\\n    log('js重定向:'+url);\\n    putMyVar('weburl', url);\\n    html = fetchPC(url);\\n    alist = pdfa(html, \\\"body&&a\\\");\\n    }*/\\n\\n    let arr = alist.map(it => {\\n        return {\\n            //html: it,\\n            text: pdfh(it, \\\"a&&Text\\\"),\\n            title: pdfh(it, \\\"a&&title\\\"),\\n            href: pd(it, \\\"a&&href\\\", url)\\n        }\\n    });\\n\\n\\n    var title = getTitle(html, 'body&&h1');\\n    if (title == '') {\\n        title = getTitle(html, \\\"body&&h3[class*='title']\\\");\\n    }\\n    if (title == '') {\\n        title = getTitle(html, \\\"head&&title\\\");\\n    }\\n    if (dtitle != \\\"\\\") {\\n        setPageTitle(dtitle);\\n    } else if (getPageTitle().includes('详情')) {\\n        if (title != '') {\\n            if (title.includes('-')) {\\n                title = title.split('-')[0].trim()\\n            }\\n            setPageTitle(title)\\n        }\\n    }\\n\\n\\n    //log(arr);\\n    let debug = false;\\n\\n    function clearText(it) {\\n        return it.replace(/第|集|章/g, \\\"\\\");\\n    }\\n\\n    function isMovie(it) {\\n        if (it == null || it.text == null) {\\n            return false;\\n        }\\n        if (nofile(it)) {\\n            return false;\\n        }\\n        let tit = it.title || \\\"\\\";\\n        it = it.text || \\\"\\\";\\n        if (it == \\\"\\\" || it.length > 8) {\\n            return false;\\n        }\\n        //排除\\n        let reg = /\\\\.|高清直播|写真推荐|影院|影视|蓝光电影|高清电影|第一季|第二季|第三季|第四季|第五季/;\\n        if (tit != \\\"\\\" && !tit.includes(it) || reg.test(it)) {\\n            return false;\\n        }\\n        return it.match(/原画|备用|蓝光|超清|高清|正片|韩版|4K|4k|1080P|720P|TC|HD|BD|中字/)\\n    }\\n\\n    function notChapter(it) {\\n        if (it == null || it.text == null) {\\n            return true;\\n        }\\n        return it.text.match(/[0-9]\\\\.[0-9]分/);\\n    }\\n\\n    function isChapter(it, pre, next) {\\n        if (notChapter(it)) {\\n            //优先排除\\n            return false;\\n        }\\n        //判断是不是电影\\n        if (isMovie(it)) {\\n            return true;\\n        }\\n        return isChapter0(it, pre) || isChapter0(it, next);\\n    }\\n\\n    function getChapterNum(it) {\\n        if (it == null || it.text == null) {\\n            return -1;\\n        }\\n        it = it.text || \\\"\\\";\\n        if (it == \\\"\\\") {\\n            return -1;\\n        }\\n        it = clearText(it);\\n        let reg = /^[0-9]*$/;\\n        if (!reg.test(it)) {\\n            return -1;\\n        }\\n        it = parseInt(it);\\n        if (isNaN(it)) {\\n            return -1;\\n        }\\n        if (it > 1900 && it < 2100) {\\n            return -1;\\n        }\\n        return it;\\n    }\\n\\n    function isChapter0(it, brother) {\\n        /*if (debug) {\\n            log({\\n                it: it,\\n                brother: brother\\n            });\\n        }*/\\n        it = getChapterNum(it);\\n        //if (debug) log(it);\\n        if (it < 0) {\\n            return false;\\n        }\\n        brother = getChapterNum(brother);\\n        //if (debug) log(brother);\\n        if (brother < 0) {\\n            return false;\\n        }\\n        return it - brother < 2 && it - brother > -2;\\n    }\\n\\n    let tfpush = getItem('webpush', '0');\\n\\n    let _web = $.toString((tfpush) => {\\n        let urls = _getUrls();\\n        let reg = /\\\\.html|\\\\.css|\\\\.js/;\\n        for (let k in urls) {\\n            if (!reg.test(urls[k]) && urls[k].match(/\\\\.mp4|\\\\.m3u8/)) {\\n                fy_bridge_app.log(urls[k]);\\n                //return fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\"\\\")) + \\\"#ignoreImg=true#\\\";\\n                if (tfpush == '0') {\\n                    return fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\"\\\")) + \\\"#ignoreImg=true#\\\";\\n                } else {\\n                    let play = fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\"\\\"));\\n                    return 'hiker://page/push?pushurl=' + encodeURIComponent(JSON.stringify({\\n                        \\\"name\\\": document.title,\\n                        \\\"url\\\": play\\n                    }));\\n                }\\n            }\\n        }\\n    }, tfpush);\\n\\n    function __web(mode) {\\n        return $.toString((tfpush) => {\\n            let urls = _getUrls();\\n            let reg = /\\\\.html|\\\\.css|\\\\.js/;\\n            for (let k in urls) {\\n                if (!reg.test(urls[k]) && urls[k].match(/\\\\.mp4|\\\\.m3u8/)) {\\n                    fy_bridge_app.log(urls[k]);\\n                    //return fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\"\\\")) + \\\"#ignoreImg=true#\\\";\\n                    if (tfpush == '0') {\\n                        return fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\"\\\")) + \\\"#ignoreImg=true#\\\";\\n                    } else {\\n                        let play = fy_bridge_app.getHeaderUrl(urls[k].replace(/.*?url=/, \\\"\\\"));\\n                        return 'hiker://page/push?pushurl=' + encodeURIComponent(JSON.stringify({\\n                            \\\"name\\\": document.title,\\n                            \\\"url\\\": play\\n                        }));\\n                    }\\n                }\\n            }\\n        }, mode);\\n    }\\n\\n    $.extend({\\n        lweb: __web\\n    })\\n\\n    let web = getItem('web', '0');\\n    var pushtype = ['列表', '单集']\\n    var parsetype = ['Web嗅探:0', '视频嗅探:1', 'dm盒子:2']\\n    log('推送类型:' + pushtype[parseInt(tfpush)])\\n    log('嗅探类型:' + parsetype[parseInt(web)].split(':')[0])\\n\\n    for (let i = 0; i < arr.length; i++) {\\n        let it = arr[i];\\n        let t = it.text;\\n        if (!it.href || it.href == \\\"\\\") {\\n            continue;\\n        }\\n        let pre = i == 0 ? null : arr[i - 1];\\n        let next = i == (arr.length - 1) ? null : arr[i + 1];\\n        if (isChapter(it, pre, next)) {\\n            if (tfpush == '1') {\\n                /*var urlx = \\\"webRule://\\\" + it.href + \\\"@\\\" + _web;\\n                var extrax = {\\n                    jsLoadingInject: true,\\n                    id: it.href,\\n                    cls: 'plays',\\n                    blockRules: ['.m4a', '.mp3', '.flv', '.avi', '.3gp', '.mpeg', '.wmv', '.mov', '.rmvb', '.gif', '.jpeg', '.png', '.ico', '.svg']\\n                };*/\\n                var urlx = 'hiker://page/push?&pushurl=' + encodeURIComponent(JSON.stringify({\\n                    \\\"name\\\": getPageTitle(),\\n                    \\\"url\\\": it.text + '$' + it.href,\\n                    \\\"content\\\": MY_URL.title,\\n                }));\\n                var extrax = {\\n                    id: it.href,\\n                    cls: 'plays',\\n                };\\n            } else {\\n                if (web == '0') {\\n                    var urlx = \\\"webRule://\\\" + it.href + \\\"@\\\" + _web;\\n                    var extrax = {\\n                        jsLoadingInject: true,\\n                        id: it.href,\\n                        cls: 'plays',\\n                        blockRules: ['.m4a', '.mp3', '.flv', '.avi', '.3gp', '.mpeg', '.wmv', '.mov', '.rmvb', '.gif', '.jpeg', '.png', '.ico', '.svg']\\n                    };\\n                } else if (web == '1') {\\n                    var urlx = \\\"video://\\\" + it.href;\\n                    var extrax = {\\n                        id: it.href,\\n                        cls: 'plays',\\n                    };\\n                } else if (web == '2') {\\n                    lazy = $('').lazyRule(() => {\\n                        return $.require('hiker://page/lazyToX5?rule=dm盒子').videoX5();\\n                    })\\n                    var urlx = it.href + lazy\\n                    var extrax = {\\n                        id: it.href,\\n                        cls: 'plays',\\n                    };\\n                }\\n            }\\n            d.push({\\n                title: t,\\n                url: urlx,\\n                ph: t + \\\"$\\\" + it.href,\\n                col_type: \\\"text_3\\\",\\n                extra: extrax\\n            });\\n        }\\n    }\\n    if (d.length == 0) {\\n        //匹配失败\\n        d.push({\\n            title: 'x5',\\n            col_type: 'avatar',\\n            url: 'hiker://empty',\\n            extra: {\\n                id: 'aijump'\\n            }\\n        })\\n        d.push({\\n            title: \\\"\\\",\\n            url: url,\\n            col_type: \\\"x5_webview_single\\\",\\n            desc: \\\"float&&screen-100\\\",\\n            pic_url: \\\"\\\",\\n            extra: {\\n                floatVideo: true,\\n                canBack: true,\\n                blockRules: [\\\".gif\\\", \\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\"]\\n            }\\n        });\\n\\n        toast(\\\"AI匹配失败，已使用X5加载\\\");\\n        log(\\\"当前页面地址: \\\" + url)\\n        setResult(d);\\n\\n        if (MY_PARAMS.web == \\\"哔滴影视\\\") {\\n            var trule = request(\\\"hiker://home@哔嘀影视\\\")\\n            //log(trule)\\n\\n            if (trule != null) {\\n                var tjson = JSON.parse(trule);\\n                var jsr = tjson.preRule;\\n                var ticon = tjson.icon;\\n                //log(jsr)\\n                eval(jsr)\\n                //log(config.ui)\\n                updateItem('aijump', {\\n                    title: '哔滴影视',\\n                    col_type: 'avatar',\\n                    img: ticon,\\n                    url: \\\"hiker://page/details?rule=哔嘀影视&url=\\\" + durl + '#immersiveTheme#',\\n                    extra: {\\n                        config: JSON.stringify(config),\\n                    }\\n                })\\n            }\\n        }\\n\\n    } else {\\n        //为线路加分割线\\n        let d2 = [];\\n        let mtab = [];\\n\\n        d = unique(d)\\n        //log(BitTS)\\n        for (let i = 0; i < d.length; i++) {\\n            d2.push(d[i]);\\n            mtab.push(d[i].ph);\\n            if (i < d.length - 1) {\\n                let it = d[i];\\n                let t1 = parseInt(clearText(it.title));\\n                let next = d[i + 1];\\n                let t2 = parseInt(clearText(next.title));\\n                if (t2 - t1 > 1 || t1 - t2 > 1) {\\n                    mtab.push('#');\\n                    d2.push({\\n                        col_type: \\\"big_blank_block\\\"\\n                    });\\n                    d2.push({\\n                        col_type: \\\"line_blank\\\"\\n                    });\\n                    d2.push({\\n                        col_type: \\\"big_blank_block\\\"\\n                    });\\n                }\\n            }\\n        }\\n\\n        let playl = mtab.join('#').replace(/###/g, '$$$$$$');\\n\\n\\n        let from = [];\\n        for (var j = 0; j < playl.split('$$$').length; j++) {\\n            from.push(\\\"播放列表\\\" + [j + 1]);\\n        }\\n        let push = JSON.stringify({\\n            \\\"name\\\": getPageTitle(),\\n            \\\"from\\\": from.join('$$$'),\\n            \\\"url\\\": playl.replace(/\\\\&/g, '＆＆'),\\n            \\\"content\\\": MY_RULE.title\\n        });\\n        //log(push);\\n\\n        var tconfig = {\\n            name: getPageTitle(),\\n            content: MY_RULE.title\\n        }\\n\\n        d2.unshift({\\n            title: \\\"推送本页=>TVBox\\\",\\n            url: $(push).lazyRule((tconfig) => {\\n                var dlist = storage0.getMyVar(\\\"duoselect\\\");\\n                if (dlist.length > 0) {\\n                    var plays = dlist.map(x => x.title + \\\"$\\\" + x.url).join(\\\"#\\\");\\n                    var dpush = JSON.stringify({\\n                        \\\"name\\\": tconfig.name,\\n                        \\\"from\\\": \\\"播放列表\\\",\\n                        \\\"url\\\": plays,\\n                        \\\"content\\\": tconfig.content\\n                    });\\n                    //log(dpush)\\n                    return 'hiker://page/push?pushurl=' + encodeURIComponent(dpush);\\n                }\\n\\n                return 'hiker://page/push?pushurl=' + encodeURIComponent(input);\\n            }, tconfig),\\n            col_type: \\\"scroll_button\\\",\\n            extra: {\\n                id: 'pushs',\\n            }\\n        });\\n\\n\\n        d2.unshift({\\n            title: '选推',\\n            col_type: 'scroll_button',\\n            url: $('#noLoading#').lazyRule(() => {\\n                setItem('webpush', '0');\\n\\n                updateItem('spush', {\\n                    title: '单推',\\n                });\\n\\n                if (findItem('dselect').extra.mode == 'open') {\\n                    toast('选推模式关闭');\\n                    storage0.putMyVar(\\\"duoselect\\\", []);\\n                    refreshPage();\\n                    return \\\"hiker://empty\\\";\\n                }\\n\\n                let Ids = (findItemsByCls('plays')).map(it => it.extra.id);\\n                Ids.forEach(x => {\\n                    var title = findItem(x).title;\\n\\n                    updateItem(x, {\\n                        url: $.msm(title, x),\\n                    });\\n                });\\n                var title = findItem('dselect').title;\\n                updateItem('dselect', {\\n                    title: `““””<span style=\\\"color:#4682B4\\\">` + title,\\n                    extra: {\\n                        mode: 'open'\\n                    }\\n                });\\n\\n                updateItem('pushs', {\\n                    title: '推送选中=>TVBox',\\n                });\\n\\n                toast('选推模式开启')\\n                return \\\"hiker://empty\\\";\\n            }),\\n            extra: {\\n                id: 'dselect',\\n                'mode': 'close'\\n            }\\n        })\\n\\n\\n        d2.unshift({\\n            title: (getItem('webpush', '0') == '1' ? '““””<font color=\\\"#00FF00\\\">单推</font>' : '单推'),\\n            url: `hiker://empty@lazyRule=.js:getItem('webpush','0')=='1'?setItem('webpush','0'):setItem('webpush','1');refreshPage();'toast://切换成功！'`,\\n            col_type: 'scroll_button',\\n            extra: {\\n                id: 'spush',\\n            }\\n        });\\n\\n        d2.splice(3, 0, {\\n            title: parsetype[parseInt(web)].split(':')[0],\\n            col_type: 'scroll_button',\\n            url: $('#noLoading#').lazyRule((inf) => {\\n                if (getItem('webpush', '0') == '1' || findItem('dselect').extra.mode == 'open') {\\n                    return 'toast://单推|选推模式开启无法修改'\\n                }\\n                let all_cols = inf\\n                let col = storage0.getItem('嗅探', 'Web嗅探');\\n                let 嗅探 = all_cols.map((it) => {\\n                    return it.split(':')[0] === col ? '➡️' + it : it;\\n                });\\n                let tips = '请选择嗅探模式';\\n                return $(嗅探, 1, tips).select(() => {\\n                    input = input.replace(/➡️/g, '');\\n                    storage0.setItem('嗅探', input.split(':')[0]);\\n                    var mode = input.split(':')[1]\\n                    storage0.setItem('web', mode)\\n                    let oldIds = (findItemsByCls('plays')).map(it => it.extra.id);\\n                    oldIds.forEach(x => {\\n                        if (mode == '0') {\\n                            updateItem(x, {\\n                                url: \\\"webRule://\\\" + x + \\\"@\\\" + $.lweb('0'),\\n                                extra: {\\n                                    jsLoadingInject: true,\\n                                    id: x,\\n                                    cls: 'plays',\\n                                    blockRules: ['.m4a', '.mp3', '.flv', '.avi', '.3gp', '.mpeg', '.wmv', '.mov', '.rmvb', '.gif', '.jpeg', '.png', '.ico', '.svg']\\n                                }\\n                            });\\n                        }\\n                        if (mode == '1') {\\n                            updateItem(x, {\\n                                url: \\\"video://\\\" + x,\\n                                extra: {\\n                                    id: x,\\n                                    cls: 'plays',\\n                                }\\n                            });\\n                        }\\n                        if (mode == '2') {\\n                            updateItem(x, {\\n                                url: x + $('').lazyRule(() => {\\n                                    return $.require('hiker://page/lazyToX5?rule=dm盒子').videoX5();\\n                                }),\\n                                extra: {\\n                                    id: x,\\n                                    cls: 'plays',\\n                                }\\n                            });\\n                        }\\n                    })\\n                    updateItem('parse', {\\n                        title: storage0.getItem('嗅探', 'Web嗅探'),\\n                    });\\n\\n                    return 'toast://已切嗅探方式为:' + input;\\n                });\\n                return 'hiker://empty'\\n            }, parsetype),\\n            extra: {\\n                id: 'parse',\\n            }\\n        });\\n\\n        d2.unshift({\\n            title: '““””<small>⚡️' + durl + '</small>',\\n            col_type: 'text_center_1',\\n            url: durl,\\n        });\\n\\n\\n        if (MY_PARAMS.web == \\\"哔滴影视\\\") {\\n            var trule = request(\\\"hiker://home@哔嘀影视\\\")\\n            //log(trule)\\n\\n            if (trule != null) {\\n                var tjson = JSON.parse(trule);\\n                var jsr = tjson.preRule;\\n                var ticon = tjson.icon;\\n                //log(jsr)\\n                eval(jsr)\\n                //log(config.ui)\\n                d2.unshift({\\n                    title: '哔滴影视',\\n                    col_type: 'avatar',\\n                    img: ticon,\\n                    url: \\\"hiker://page/details?rule=哔嘀影视&url=\\\" + durl + '#immersiveTheme#',\\n                    extra: {\\n                        config: JSON.stringify(config),\\n                    }\\n                })\\n            }\\n        }\\n\\n\\n\\n        var d3 = [];\\n        if (getItem('ai', '0') == '1') {\\n\\n            d3.push({\\n                title: getPageTitle(),\\n                img: 'https://pic3.58cdn.com.cn/nowater/webim/big/n_v281d60bd127e84cd28807d51143eaa61f.gif',\\n                col_type: 'movie_1_vertical_pic_blur',\\n                extra: {\\n                    id: 'd3',\\n                }\\n            })\\n            setResult(d3)\\n        }\\n\\n        if (findItem('d3') != null) {\\n            addItemAfter('d3', d2);\\n        } else {\\n            setResult(d2)\\n        }\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"聚合搜索\",\"path\":\"pro\",\"rule\":\"var d = [];\\n\\nvar getRangeColors = function() {       \\n    return '#' + ('00000' + (Math.random() * 0x1000000 << 0).toString(16)).substr(-6);     \\n}\\n\\nvar imgs = ['https://www.wandou.la/favicon.ico', 'https://bj.bcebos.com/baidu-rmb-video-cover-1/74f13d0620f72b00a4e9b67f3dab96d1.png', 'https://bj.bcebos.com/baidu-rmb-video-cover-1/73b8cf6ae078303a572e76c79dd93e7a.png', 'https://www.qmtv.pro/profile/upload/favicon.png', 'https://www.tbsdy.com/img/mrsw/common/favicon.ico']\\n\\nvar names=['豌豆', '茶杯狐', '搜片', '青麦', '土拨鼠'];\\n\\nif (MY_PAGE == 1) {\\n    names.map((x, i) => {\\n        var ix = storage0.getMyVar('page_index', 0);\\n        var title = ix == i ? `““””<font color=${getRangeColors()}>` + x + '</font>' : x;\\n        d.push({\\n            title: title,\\n            col_type: 'icon_5',\\n            img: imgs[i],\\n            url: $('#noLoading#').lazyRule((i) => {\\n                storage0.putMyVar('page_index', i)\\n                //clearMyVar('sou')\\n                clearMyVar('page')\\n                clearMyVar('cfpage')\\n                refreshPage()\\n                return 'toast://切换成功'\\n            }, i),\\n        })\\n    })\\n\\n    var web = getItem('web', '0')\\n    //log(web)\\n    var title = ''\\n    switch (web) {\\n        case '0':\\n            title = 'Web嗅探'\\n            break;\\n        case '1':\\n            title = '视频嗅探'\\n            break;\\n        case '2':\\n            title = 'dm盒子'\\n            break;\\n    }\\n    setItem('嗅探', title)\\n\\n    d.push({\\n        title: '设置',\\n        url: \\\"hiker://page/setting\\\",\\n        col_type: 'flex_button'\\n    }, {\\n        title: \\\"页面加载:\\\" + getItem('home', '关'),\\n        url: $('#noLoading#').lazyRule(() => {\\n            if (getItem('home', '关') == '关') {\\n                setItem('home', '开')\\n            } else {\\n                setItem('home', '关')\\n            }\\n            refreshPage()\\n            return 'hiker://empty'\\n        }),\\n        col_type: \\\"flex_button\\\"\\n    }, {\\n        title: title,\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            var web = getItem('web', '0')\\n            switch (web) {\\n                case '0':\\n                    setItem('web', '1')\\n                    break;\\n                case '1':\\n                    setItem('web', '2')\\n                    break;\\n                case '2':\\n                    setItem('web', '0')\\n                    break;\\n            }\\n            refreshPage();\\n            return 'hiker://empty'\\n        }),\\n        col_type: \\\"flex_button\\\",\\n        extra: {\\n            id: 'parset'\\n        }\\n    }, {\\n        title: '模板:' + (getItem('ai', '0') == '0' ? '关闭' : '开启'),\\n        col_type: \\\"flex_button\\\",\\n        url: $('#noLoading#').lazyRule(() => {\\n            if (getItem('ai', '0') == '0') {\\n                setItem('ai', '1')\\n            } else {\\n                setItem('ai', '0')\\n            }\\n            refreshPage(false)\\n            return 'hiker://empty'\\n        }),\\n        col_type: 'flex_button',\\n        extra: {\\n            id: 'aimb'\\n        }\\n    });\\n}\\n\\n\\nvar rulename=MY_RULE.title;\\nif (MY_PAGE == 1) {\\n    \\n    let {searchw}=$.require(\\\"hiker://page/tool?rule=\\\" + rulename);\\n    \\n    var sconfig = {\\n        history: false, //历史\\n        histshow: 10, //保留10个\\n        suggest: false, //建议\\n    }\\n    \\n    \\n    var sfig = storage0.getItem('sconfig', sconfig);\\n         \\n    searchw(d, {\\n        sug:sfig.suggest?sfig.suggest:false,\\n        history: sfig.history?sfig.history:false,\\n        show: sfig.histshow?sfig.histshow:10\\n    })\\n    \\n    \\n    \\n    addListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"sou\\\");\\n    }));\\n\\n    addListener(\\\"onRefresh\\\", $.toString(() => {\\n        clearMyVar(\\\"sou\\\");\\n        clearMyVar(\\\"durl\\\");\\n        clearMyVar('cfpage')\\n    }));\\n}\\n\\nlet s = getMyVar(\\\"sou\\\", \\\"\\\");\\nif(s!=\\\"\\\"){\\n    let num=10;\\n$.searchwords.addData(s, rulename,num);\\n}\\n\\nlet r = \\\"\\\";\\n\\nvar index = Number(storage0.getMyVar('page_index', 0))\\nlet nextindex=index+1;\\n\\n\\ntry {\\n    switch (parseInt(index)) {\\n        case 0:\\n            eval(JSON.parse(request('hiker://page/wandou')).rule)\\n            break;\\n        case 1:\\n            eval(JSON.parse(request('hiker://page/cupfox')).rule)\\n            break;\\n        case 2:\\n            eval(JSON.parse(request('hiker://page/soupian')).rule)\\n            break;\\n        case 3:\\n            eval(JSON.parse(request('hiker://page/qimaitv')).rule)\\n\\n            break;\\n        case 4:\\n            eval(JSON.parse(request('hiker://page/tbsdy')).rule)\\n            break;\\n    }\\n} catch(e) {\\n    //setItem('home', '关')\\n    if(index>4){\\n        nextindex=0;\\n    }\\n    toast(names[Number(storage0.getMyVar('page_index', 0))]+`发生错误，错误信息:${e.message}`);\\n    log(names[Number(storage0.getMyVar('page_index', 0))]+`发生错误，错误信息:${e.message}`);\\n    //storage0.putMyVar('page_index', nextindex);\\n    //refreshPage();\\n}\\n\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"工具\",\"path\":\"tool\",\"rule\":\"js:\\nfunction wrap(text, s) {\\n    return text.includes(\\\"““””\\\") ? text : \\\"““””\\\" + text.replace(new RegExp(\\\"<em>|</em>\\\", \\\"g\\\"), \\\"\\\").replace(new RegExp(s, \\\"g\\\"), \\\"<strong><span style=\\\\\\\"color: #1E90FF\\\\\\\">\\\" + s + \\\"</span></strong>\\\")\\n}\\n\\nfunction wrap1(text, s) {\\n    return text.replace(new RegExp(\\\"<em>|</em>\\\", \\\"g\\\"), \\\"\\\").replace(new RegExp(s, \\\"g\\\"), \\\"<strong><span style=\\\\\\\"color: #1E90FF\\\\\\\">\\\" + s + \\\"</span></strong>\\\")\\n}\\n\\nfunction removehtml(text) {\\n    return text.replace(/<[^<]+?>/g, '')\\n}\\n\\nfunction merge(text, s, m) {\\n    if (m == 0) {\\n        text = '““””' + text + '-' + \\\"<strong><span style=\\\\\\\"color: #FF5733\\\\\\\">\\\" + s + \\\"</span></strong>\\\"\\n    } else {\\n        text = text + '-' + \\\"<strong><span style=\\\\\\\"color: #FF5733\\\\\\\">\\\" + s + \\\"</span></strong>\\\"\\n    }\\n    return text\\n}\\n\\nfunction setPageD(d, page, ptag, titles, color) {\\n    var paged = getMyVar(ptag, \\\"0\\\");\\n    titles.map((x, i) => {\\n        var title = Number(paged) == i ? \\\"““””<b><font color=\\\" + color + \\\">\\\" + x + \\\"</font></b>\\\" : `${x}`;\\n        if (page == 1) {\\n            d.push({\\n                title: title,\\n                col_type: 'text_2',\\n                url: i + $('#noLoading#').lazyRule((ptag) => {\\n                    putMyVar(ptag, input);\\n                    clearMyVar('cfpage')\\n                    refreshPage();\\n                    return 'hiker://empty'\\n                }, ptag),\\n            })\\n        }\\n    })\\n    return getMyVar(ptag, \\\"0\\\")\\n}\\n\\n//url解析\\nfunction urlParse(u) {\\n    var dict = {}\\n    dict.Source = u;\\n    let params = (url) => {\\n        let queryParams = {};\\n        let reg = /([^?=&]+)=([^?=&]+)/g;\\n        url.replace(reg, function() {\\n            queryParams[arguments[1]] = arguments[2];\\n        })\\n        return queryParams\\n    }\\n    var javaUrl = JavaImporter(java.net.URL);\\n    with(javaUrl) {\\n        var url = new URL(u);\\n        dict.Protocol = url.getProtocol();\\n        dict.Host = url.getHost();\\n        dict.Port = url.getPort();\\n        dict.File = url.getFile();\\n        dict.Path = url.getPath();\\n        dict.Ref = url.getRef();\\n        dict.Hosts = `${url.getProtocol()}://${url.getHost()}`\\n    }\\n    dict.Params = params(u);\\n    return dict;\\n}\\n\\n\\n//json对象转查询字符串\\nObject.ToParams = function() {\\n    var json = arguments[0];\\n    return Object.keys(json).map(key => key + '=' + json[key]).join('&');\\n}\\n\\n\\n//搜索补全\\nfunction 搜索建议(arr, setting) {\\n    $.extend({\\n        searchwords: {\\n            addData: function(name, rule_name, num) {\\n                clearMyVar('page')\\n                clearMyVar(\\\"cfpage\\\")\\n                clearMyVar(\\\"durl\\\")\\n                //log(name)\\n                let localData = request('hiker://files/cache/' + rule_name + '-搜索记录.json');\\n                if (!localData) localData = \\\"[]\\\";\\n                let lishi = JSON.parse(localData);\\n                let ccc = lishi.indexOf(name);\\n                if (ccc > -1) {\\n                    lishi.splice(ccc, 1)\\n                };\\n                lishi.push(name);\\n\\n                lishi = lishi.slice(-num);\\n                //log(lishi)\\n                writeFile('hiker://files/cache/' + rule_name + '-搜索记录.json', JSON.stringify(lishi));\\n            },\\n            getData: function(rule_name) {\\n                var res = request('hiker://files/cache/' + rule_name + '-搜索记录.json');\\n                return JSON.parse(res)\\n            },\\n            delData: function(index, rule_name) {\\n                let localData = this.getData(rule_name).reverse();\\n                //log(localData)\\n                if (localData.length > 0) {\\n                    //log(index)\\n                    localData.splice(index, 1);\\n                    localData.reverse();\\n                    writeFile('hiker://files/cache/' + rule_name + '-搜索记录.json', JSON.stringify(localData));\\n                }\\n            }\\n        }\\n    })\\n\\n    var rule_name = MY_RULE.title;\\n    let num = setting.show != undefined ? setting.show : 3;\\n    let sug = setting.sug != undefined ? setting.sug : false;\\n    var key = getMyVar(\\\"sou\\\", \\\"\\\")\\n    if (setting.history == true) {\\n        arr.push({\\n            title: `${key!=\\\"\\\"?'<small>'+key+'</small>':'<b>历史记录</b>'}`,\\n            desc: '<b>📄\\\\t\\\\t</b>',\\n            img: 'https://i2.100024.xyz/2023/06/10/md3vui.webp',\\n            url: $('hiker://empty').rule((rule_name, num) => {\\n                setPageTitle('历史记录:' + num)\\n                var d = [];\\n                let localData = request('hiker://files/cache/' + rule_name + '-搜索记录.json');\\n                if (!localData) localData = \\\"[]\\\";\\n                let lishi = JSON.parse(localData).slice(-num).reverse();\\n                //log(lishi)\\n                //log(localData)\\n                config.sug = lishi;\\n                initConfig({\\n                    sug: config.sug\\n                });\\n                //log(config.sug)\\n                config.sug.map((x, i) => {\\n                    d.push({\\n                        title: `““””<small>${x}</small>`,\\n                        url: $('#noLoading#').lazyRule((x, rule_name, num) => {\\n                            putMyVar(\\\"sou\\\", x);\\n                            $.searchwords.addData(x, rule_name, num);\\n                            back();\\n                            return 'hiker://empty'\\n                        }, x, rule_name, num), //'hiker://search?s=' + x + '&rule=' + rule_name,\\n                        col_type: \\\"flex_button\\\",\\n                        extra: {\\n                            longClick: [{\\n                                title: '删除',\\n                                js: $.toString((x, rule_name, i) => {\\n                                    $.searchwords.delData(i, rule_name);\\n                                    deleteItem('clsid' + i);\\n                                    return 'hiker://empty'\\n                                }, x, rule_name, i)\\n                            }],\\n                            id: 'clsid' + i,\\n                        }\\n                    })\\n                })\\n                d.push({\\n                    title: `““””<small>清除历史记录</small>`,\\n                    url: $('#noLoading#').lazyRule((rule_name) => {\\n                        let test = $(\\\"是否确认？\\\").confirm((rule_name) => {\\n                            writeFile('hiker://files/cache/' + rule_name + '-搜索记录.json', '');\\n                            refreshPage();\\n                            return \\\"toast://完成\\\";\\n                        }, rule_name);\\n                        return test\\n                    }, rule_name),\\n                    col_type: \\\"text_center_1\\\",\\n                    extra: {\\n                        cls: \\\"#s\\\"\\n                    }\\n                })\\n\\n                setResult(d);\\n            }, rule_name, num),\\n            col_type: \\\"avatar\\\",\\n            extra: {\\n                id: '13input',\\n                //cls: \\\"#s\\\"\\n            }\\n        })\\n    }\\n    if (sug) {\\n        arr.push({\\n            title: \\\"搜索\\\",\\n            url: $.toString((rule_name, num) => {\\n                putMyVar(\\\"sou\\\", input);\\n                $.searchwords.addData(input, rule_name, num);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, rule_name, num),\\n            //'\\\"hiker://search?s=\\\" + input + \\\"&rule=\\\"+MY_RULE.title ',\\n            desc: \\\"请输入关键词，尽量少字不要多字\\\",\\n            col_type: \\\"input\\\",\\n            extra: {\\n                //defaultValue: getMyVar(\\\"sou\\\", \\\"\\\"),\\n                onChange: $.toString((rule_name, setting) => {\\n                    //putMyVar(\\\"sou\\\", input)\\n                    let sug = config.sug || [];\\n                    for (let i in sug) {\\n                        deleteItem(sug[i]);\\n                    }\\n                    if (input == '') {\\n                        deleteItemByCls(\\\"#s\\\")\\n                    };\\n\\n                    if (input) {\\n                        if (input == '清除搜索记录') writeFile('hiker://files/cache/' + rule_name + '-搜索记录.json', '');\\n                        initConfig({\\n                            sug: [input]\\n                        });\\n                        http.fetch(`https://www.douban.com/j/search_suggest?debug=&q=${input}`, {}).success(data => {\\n                            var gg = JSON.parse(data).words;\\n                            //log(gg)\\n                            putMyVar('建议数据', gg)\\n\\n                        }).error(msg => log(msg.toString())).start(log(2))\\n                        var gg = JSON.parse(getMyVar('建议数据'));\\n                        let num = setting.show != undefined ? setting.show : 3;\\n                        deleteItemByCls(\\\"#s\\\");\\n                        for (let i in gg) {\\n                            var nn = gg[i];\\n\\n                            addItemAfter(\\\"12input\\\", {\\n                                title: nn,\\n                                url: $(\\\"#noLoading#\\\").lazyRule((nn, rule_name, num) => {\\n                                    putMyVar(\\\"sou\\\", nn);\\n                                    $.searchwords.addData(nn, rule_name, num);\\n                                    refreshPage();\\n                                    //return 'hiker://search?s=' + nn + '&rule=' + rule_name;\\n                                    return 'hiker://empty';\\n                                }, nn, rule_name, num),\\n                                col_type: \\\"text_1\\\",\\n                                extra: {\\n                                    id: input,\\n                                    cls: \\\"#s\\\"\\n                                }\\n                            });\\n\\n                        }\\n                    }\\n                }, rule_name, setting),\\n                //titleVisible: false,\\n                id: \\\"12input\\\"\\n            }\\n        });\\n    } else {\\n        arr.push({\\n            title: \\\"搜索\\\",\\n            url: $.toString(() => {\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n            }),\\n            col_type: \\\"input\\\",\\n            desc: \\\"请输入关键词，尽量少字不要多字\\\",\\n            pic_url: \\\"\\\",\\n            extra: {\\n                defaultValue: getMyVar(\\\"sou\\\", \\\"\\\"),\\n                onChange: $.toString(() => {\\n                    putMyVar(\\\"sou\\\", input);\\n                    clearMyVar('page')\\n                    clearMyVar(\\\"durl\\\")\\n                })\\n            }\\n        })\\n    }\\n}\\n\\n\\n\\n$.exports = {\\n    wrap: wrap,\\n    wrap1: wrap1,\\n    rehtml: removehtml,\\n    merge: merge,\\n    setpaged: setPageD,\\n    urlParse: urlParse,\\n    searchw: 搜索建议,\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索页面\",\"path\":\"soup\",\"rule\":\"js:\\nvar d = [];\\nif (MY_PARAMS.key && getMyVar(\\\"use\\\", \\\"\\\") == \\\"\\\") {\\n    putMyVar(\\\"sou\\\", MY_PARAMS.key);\\n    putMyVar(\\\"use\\\", \\\"1\\\");\\n    addListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"use\\\");\\n    }));\\n}\\n$.require('hiker://page/pro')\"},{\"col_type\":\"movie_3\",\"name\":\"x5\",\"path\":\"x5\",\"rule\":\"js:\\nvar d = [];\\nlet url = base64Decode(getParam(\\\"u\\\"));\\nd.push({\\n    title: \\\"\\\",\\n    url: url,\\n    col_type: \\\"x5_webview_single\\\",\\n    desc: \\\"float&&100%\\\",\\n    pic_url: \\\"\\\",\\n    extra: {\\n        floatVideo: true,\\n        canBack: true,\\n        blockRules: [\\\".gif\\\", \\\"/ad/\\\", \\\"google\\\", \\\"/sh/to/\\\", \\\".GIF\\\"]\\n    }\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"3.搜片\",\"path\":\"soupian\",\"rule\":\"js:\\nif (s != \\\"\\\") {\\n    var html = fetch(`http://${config.soupian}/search?key=${s}`)\\n    var list = pdfa(html, 'body&&.list-row-info')\\n    let {\\n        wrap1\\n    } = $.require(\\\"hiker://page/tool\\\");\\n    for (let it of list) {\\n        //log(it)\\n        //let name = it.movie_name;\\n        let name = pdfh(it, 'h4&&Text');\\n        let web = pdfh(it, 'a&&title').replace(name,'').trim();\\n        \\n        let img = pdfh(it, 'img&&src');\\n        if(!img.includes('http')){\\n            img='https://'+config.soupian+img;\\n        }\\n            \\n        let url = pdfh(it, 'a&&href');\\n        var u = \\\"hiker://page/p?rule=\\\" + MY_RULE.title + \\\"&u=\\\" + base64Encode(url)\\n        u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n        d.push({\\n            title: wrap1(web+'-'+name, s),\\n            url: u,\\n            col_type: \\\"avatar\\\",\\n            //desc: \\\"““””<font color=#f13b66a>搜片</font>\\\",\\n            pic_url: img,\\n            extra: {\\n                id: url,\\n                inheritTitle: false,\\n                pageTitle:name,\\n                web:web,\\n            }\\n        });\\n    }\\n    setResult(d)\\n} else {\\n\\n}\\n\\nif (getItem('home', '关') == '开') {\\n    var html = request(`http://${config.soupian}/`, {})\\n\\n\\n    function setLists(item) {\\n        var title = item.split('-')[0]\\n        var t = item.split('-')[1]\\n        d.push({\\n            title: title,\\n            col_type: 'avatar',\\n            img: 'https://hikerfans.com/tubiao/more/10.png'\\n        })\\n\\n        var list = pdfa(html, `body&&.list-header:matches(${t})+*&&a`)\\n\\n        list.map(x => {\\n            var name = pdfh(x, '.poster-item-title&&Text')\\n            d.push({\\n                title: name,\\n                img: pdfh(x, 'img&&src'),\\n                url: $('').lazyRule((n) => {\\n                    putMyVar(\\\"sou\\\", n)\\n                    refreshPage()\\n                    return 'hiker://empty'\\n                }, name)\\n            })\\n        })\\n    }\\n\\n    ['热门电影-电影', '热门电视剧-电视剧', '热门综艺-综艺', '热门动漫-动漫'].map(x => {\\n        setLists(x)\\n    })\\n\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"1.豌豆\",\"path\":\"wandou\",\"rule\":\"js:\\nlet durl = getMyVar(\\\"durl\\\", \\\"\\\");\\nif (durl != '') {\\n\\n    durl = 'https://www.wandou.la' + durl.replace('.html', '')\\n    let url = durl;\\n    let id = url;\\n    let html = fetch(url);\\n    var rule = MY_RULE.title\\n    var name = pdfh(html, '.movie-content&&p&&Text');\\n    d.push({\\n        title: name,\\n        img: pdfh(html, '.movie-img&&img&&src'),\\n        col_type: 'movie_1_vertical_pic',\\n        desc: pdfh(html, '.bottom&&p&&Text'),\\n        url: 'hiker://page/x5?u=' + base64Encode(url),\\n        extra: {\\n            id: url,\\n            inheritTitle: false\\n        }\\n    })\\n    //setResult(d);\\n\\n    let text = pdfh(html, \\\"body&&#__NEXT_DATA__&&Html\\\");\\n    //log(text);\\n    let erji = JSON.parse(text);\\n    // log(erji);\\n    let list = erji.props.pageProps.data.playData;\\n\\n    if (list && list.length > 0) {\\n        try {\\n            MY_URL = \\\"\\\";\\n            let {\\n                wrap\\n            } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n            list = list.map(it => {\\n                let u = it.data_url;\\n                u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                return {\\n                    title: it.site_name,\\n                    url: u,\\n                    col_type: \\\"avatar\\\",\\n                    img: it.site_icon,\\n                    extra: {\\n                        inheritTitle: false,\\n                        id: u,\\n                        from: 'home',\\n                        pageTitle: name,\\n                        web: it.site_name,\\n                    }\\n                }\\n            });\\n            if (MY_PAGE == 1) {\\n                //addItemAfter(id, list);\\n                d = d.concat(list);\\n            }\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n    setResult(d)\\n}\\n\\nlet r = \\\"\\\";\\nif (s != \\\"\\\") {\\n\\n    json = \\\"https://\\\"+config.wandou+\\\"/movie/getsearchlist/keywords/\\\" + s + \\\"/page/1/rows/16.json\\\";\\n    data = JSON.parse(fetch(json)).data;\\n    let {\\n        wrap\\n    } = $.require(\\\"hiker://page/tool\\\");\\n    for (let it of data) {\\n        let name = it.movie_name;\\n        //log(name)\\n        let img = it.movie_img_url;\\n        let url = \\\"https://www.wandou.la\\\" + it.movie_url.replace(\\\".html\\\", \\\"\\\");\\n        //log(url)\\n        d.push({\\n            title: wrap(name, s),\\n            url: $(url).lazyRule((rule, id, s, name) => {\\n                var cls = findItemsByCls(id);\\n                if (!!cls) {\\n                    deleteItemByCls(id)\\n                } else {\\n                    let url = input;\\n                    let id = url;\\n                    let html = fetch(url);\\n                    //log(html)\\n                    let text = pdfh(html, \\\"body&&#__NEXT_DATA__&&Html\\\");\\n                    //log(text);\\n                    let erji = JSON.parse(text);\\n                    //log(erji);\\n                    let list = erji.props.pageProps.data.playData;\\n\\n                    if (list && list.length > 0) {\\n                        try {\\n                            MY_URL = \\\"\\\";\\n                            let {\\n                                wrap\\n                            } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n                            list = list.map(it => {\\n                                let u = it.data_url;\\n                                u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                                u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                                return {\\n                                    title: it.site_name,\\n                                    url: u,\\n                                    col_type: \\\"avatar\\\",\\n                                    img: it.site_icon,\\n                                    extra: {\\n                                        inheritTitle: false,\\n                                        cls: id,\\n                                        from: 'home',\\n                                        pageTitle: name,\\n                                        web: it.site_name,\\n                                    }\\n                                }\\n                            });\\n                            addItemAfter(id, list);\\n                        } catch (e) {\\n                            log(e.toString());\\n                        }\\n                    }\\n                }\\n                return \\\"hiker://empty\\\"\\n            }, MY_RULE.title, url, s, name),\\n            col_type: \\\"movie_1_left_pic\\\",\\n            desc: \\\"““””<font color=#f13b66a>豌豆</font>\\\",\\n            pic_url: img,\\n            extra: {\\n                id: url,\\n                inheritTitle: false\\n            }\\n        });\\n    }\\n    setResult(d)\\n}\\n\\n\\nif (getItem('home', '关') == '开') {\\n    var page = MY_PAGE;\\n    let {\\n        setpaged\\n    } = $.require(\\\"hiker://page/tool\\\");\\n\\n    var pindex = setpaged(d,page,\\\"wandou_ptag\\\", [\\\"首页\\\", \\\"分类\\\"], \\\"#4682B4\\\");\\n\\n\\n    //首页\\n    if (pindex == \\\"0\\\") {\\n\\n        var html = fetch('https://www.wandou.la/')\\n        let json = JSON.parse(pdfh(html, \\\"body&&#__NEXT_DATA__&&Html\\\"));\\n\\n        function setLists(item) {\\n            var title = item.split('#')[0]\\n            var key = item.split('#')[1]\\n            d.push({\\n                title: title,\\n                col_type: 'avatar',\\n                img: 'https://hikerfans.com/tubiao/more/10.png'\\n            })\\n\\n            var list = json.props.pageProps.fallback[key].data\\n\\n            list.map(x => {\\n                var name = x.hot_name\\n                d.push({\\n                    title: name,\\n                    img: x.hot_img_url,\\n                    desc: x.hot_rate,\\n                    url: $('').lazyRule((n, u) => {\\n                        putMyVar(\\\"sou\\\", n)\\n                        putMyVar('durl', u)\\n                        refreshPage()\\n                        return 'hiker://empty'\\n                    }, name, x.hot_url)\\n                })\\n            })\\n        }\\n\\n        ['热门电影#index-getMovieList-movie', '热门剧集#index-getTvList-tv-28'].map(x => {\\n            setLists(x)\\n        })\\n    }\\n    if (pindex == \\\"1\\\") {\\n        \\n        var types = {\\n            \\\"wandou_tag\\\": [\\\"类型:0\\\", \\\"喜剧:1\\\", \\\"爱情:2\\\", \\\"奇幻:4\\\", \\\"犯罪:5\\\", \\\"悬疑:6\\\", \\\"历史:7\\\", \\\"战争:8\\\", \\\"动作:9\\\", \\\"科幻:10\\\", \\\"动画:11\\\", \\\"冒险:12\\\", \\\"灾难:15\\\", \\\"惊悚:17\\\", \\\"恐怖:18\\\", \\\"歌舞:22\\\", \\\"武侠:24\\\", \\\"音乐:27\\\"],\\n            \\\"wandou_country\\\": [\\\"地区:0\\\", \\\"中国:1\\\", \\\"韩国:3\\\", \\\"日本:4\\\", \\\"美国:6\\\", \\\"英国:9\\\", \\\"法国:10\\\", \\\"德国:11\\\", \\\"其他:12\\\"],\\n            \\\"wandou_year\\\": [\\\"时间:0\\\", \\\"2022:1\\\", \\\"2022:2\\\", \\\"2020:3\\\", \\\"2019:4\\\", \\\"2010年代:5\\\", \\\"2000年代:6\\\", \\\"90年代:7\\\", \\\"80年代:8\\\", \\\"70年代:9\\\", \\\"60年代:10\\\", \\\"更早:11\\\"],\\n            \\\"wandou_sort\\\": [\\\"综合排序:1\\\", \\\"近期热度:2\\\", \\\"高分优先:3\\\"]\\n        }\\n\\n        var ojson = [{\\n            name: '电影',\\n            id: 'movie',\\n            content: types\\n        }, {\\n            name: '电视剧',\\n            id: 'tv',\\n            content: types\\n        }, {\\n            name: '动漫',\\n            id: 'anime',\\n            content: types\\n        }, {\\n            name: '综艺',\\n            id: 'variety',\\n            content: types\\n        }, {\\n            name: '纪录片',\\n            id: 'documentary',\\n            content: types\\n        }]\\n\\n        var 大类 = [];\\n        ojson.map(x => {\\n            大类.push(x.name + \\\"@\\\" + x.id);\\n        })\\n        var index = storage0.getMyVar(\\\"index\\\", '0');\\n        var j = ojson[index];\\n        var keys = Object.keys(j.content);\\n\\n        var temp = {};\\n        keys.forEach(x => {\\n            var type = x;\\n            var l = j.content[x];\\n            if (['version'].includes(x)) {\\n                return\\n            }\\n            if (l.length > 0) {\\n                var ns = l.map((k) => {\\n                    var name = k.split(':')[0];\\n                    var id = k.split(':')[1];\\n                    return {\\n                        'name': name,\\n                        'url': id,\\n                        'type': x\\n                    }\\n                })\\n                temp[x] = ns;\\n            }\\n        })\\n\\n        var t = Object.values(temp).map(x => x.map(z => JSON.stringify(z)).join('#'))\\n\\n        var TrueJson = {\\n            type: Array(大类.join('#')),\\n            item: t != \\\"\\\" ? t : [],\\n        }\\n        //log(TrueJson)\\n\\n        //需根据实际修改\\n        const 页面标识 =\\\"wandoupage\\\";\\n        const 单项清除 =[];\\n        const 分类颜色 = getRangeColors();\\n        const Json大类 = 'type';\\n        const Json拼接 = 'item';\\n        const Json拆分 = '#';\\n        const Json单项 = '@';\\n        const Json列表 = [\\\"wandou_tag\\\", \\\"wandou_country\\\", \\\"wandou_year\\\", \\\"wandou_sort\\\"]; //切换清除\\n        const 排除 = '';\\n        const 分类展开 = '∨';\\n        const 分类折叠 = '∧';\\n\\n        //动态分类\\n        eval(JSON.parse(request('hiker://page/jdtfl')).rule);\\n        var type = storage0.getMyVar(\\\"wandoupage\\\", \\\"movie\\\");\\n        var tag = storage0.getMyVar(\\\"wandou_tag\\\", \\\"0\\\");\\n        var country = storage0.getMyVar(\\\"wandou_country\\\", \\\"0\\\");\\n        var year = storage0.getMyVar(\\\"wandou_year\\\", \\\"0\\\");\\n        var sort = storage0.getMyVar(\\\"wandou_sort\\\", \\\"1\\\");\\n\\n        //log(`${type}:${tag}+${country}+${year}+${sort}`)\\n        var jurl = `https://${config.wandou}/movie/get${type}list/tag/${tag}/country/${country}/year/${year}/sort/${sort}/page/${page}/rows/30.json`;\\n        \\n        //log(jurl)\\n        var plist = JSON.parse(fetch(jurl)).data\\n        plist.map(x => {\\n            var name = x.movie_name;\\n            d.push({\\n                title: name,\\n                img: x.movie_img_url + \\\"@Referer=\\\",\\n                desc: x.movie_rate,\\n                url: $('').lazyRule((n, u) => {\\n                    putMyVar(\\\"sou\\\", n)\\n                    putMyVar('durl', u)\\n                    refreshPage()\\n                    return 'hiker://empty'\\n                }, name, x.movie_url),\\n                col_type: 'movie_3_marquee'\\n            })\\n        })\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"2.茶杯狐\",\"path\":\"cupfox\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/xtools')).rule)\\n\\nif (s != \\\"\\\") {\\n    let {\\n        wrap1,\\n        rehtml\\n    } = $.require(\\\"hiker://page/tool\\\");\\n    var json = search(s, storage0.getMyVar('page', MY_PAGE))\\n    if (JSON.stringify(json) != \\\"{}\\\") {\\n        var list = json.resources;\\n        list.map(it => {\\n            //log(it.website+'-'+rehtml(it.text))\\n            var u = \\\"hiker://page/p?u=\\\" + base64Encode(it.url)\\n            u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n            d.push({\\n                title: wrap1(it.website + '-' + rehtml(it.text), s),\\n                url: u,\\n                col_type: \\\"avatar\\\",\\n                img: it.icon,\\n                desc: it.website,\\n                extra: {\\n                    inheritTitle: false,\\n                    pageTitle: rehtml(it.text),\\n                    web: it.website,\\n                }\\n            });\\n        })\\n    }\\n\\n    setResult(d)\\n} else {\\n\\n}\\n\\nif (getItem('home', '关') == '开') {\\n    var page = MY_PAGE;\\n    let {\\n        setpaged\\n    } = $.require(\\\"hiker://page/tool\\\");\\n\\n    var pindex = setpaged(d, page, \\\"cupfox_ptag\\\", [\\\"首页\\\", \\\"选片\\\"], \\\"#4682B4\\\");\\n\\n    if (pindex == \\\"0\\\") {\\n        var html = fetchPC('https://cupfox.app/', {})\\n\\n        function setLists(item) {\\n            var title = item.split('-')[0]\\n            var t = item.split('-')[1]\\n            d.push({\\n                title: title,\\n                col_type: 'avatar',\\n                img: 'https://hikerfans.com/tubiao/more/10.png'\\n            })\\n\\n            var list = pdfa(html, `body&&#${t}&&.movie-list-item`)\\n\\n            list.map(x => {\\n                var name = pdfh(x, '.movie-title&&Text')\\n                d.push({\\n                    title: name,\\n                    img: pdfh(x, 'img&&src'),\\n                    desc: pdfh(x, '.movie-rating&&Text'),                   \\n                    url: $('').lazyRule((n) => {\\n                        putMyVar(\\\"sou\\\", n)\\n                        refreshPage()\\n                        return 'hiker://empty'\\n                    }, name)\\n                })\\n            })\\n        }\\n\\n        ['热播新剧-tv', '热门电影-movie', '热播动漫-anime', '热播综艺-show', '热播纪录片-documentary'].map(x => {\\n            setLists(x)\\n        })\\n    }\\n\\n    if (pindex == \\\"1\\\") {\\n\\n\\n        var ojson = [{\\n            name: '电影',\\n            id: 'movie',\\n            content: {\\n                \\\"cupfox_genres\\\": [\\\"全部类型:\\\", \\\"喜剧\\\", \\\"爱情\\\", \\\"动作\\\", \\\"科幻\\\", \\\"奇幻\\\", \\\"动画\\\", \\\"悬疑\\\", \\\"犯罪\\\", \\\"恐怖\\\", \\\"战争\\\", \\\"音乐\\\", \\\"歌舞\\\", \\\"历史\\\", \\\"传记\\\", \\\"灾难\\\", \\\"纪录片\\\", \\\"短片\\\"],\\n                \\\"cupfox_countries\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"韩国\\\", \\\"日本\\\", \\\"中国大陆\\\", \\\"美国\\\", \\\"中国香港\\\", \\\"中国台湾\\\", \\\"英国\\\", \\\"法国\\\", \\\"意大利\\\", \\\"西班牙\\\", \\\"印度\\\", \\\"泰国\\\", \\\"俄罗斯\\\"],\\n                \\\"cupfox_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2010年代\\\", \\\"2000年代\\\", \\\"90年代\\\", \\\"80年代\\\", \\\"70年代\\\", \\\"60年代\\\", \\\"更早\\\"],\\n                \\\"cupfox_sort\\\": [\\\"近期热度:T\\\", \\\"高分优先:S\\\"],\\n            }\\n        }, {\\n            name: '电视剧',\\n            id: 'tv',\\n            content: {\\n                \\\"cupfox_genres\\\": [\\\"全部类型:\\\", \\\"喜剧\\\", \\\"爱情\\\", \\\"科幻\\\", \\\"奇幻\\\", \\\"古装\\\", \\\"战争\\\", \\\"悬疑\\\", \\\"恐怖\\\", \\\"纪录片\\\"],\\n                \\\"cupfox_countries\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"韩国\\\", \\\"日本\\\", \\\"美国\\\", \\\"英国\\\", \\\"泰国\\\"],\\n                \\\"cupfox_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2010年代\\\", \\\"2000年代\\\", \\\"90年代\\\", \\\"80年代\\\", \\\"70年代\\\", \\\"60年代\\\", \\\"更早\\\"],\\n                \\\"cupfox_sort\\\": [\\\"近期热度:T\\\", \\\"高分优先:S\\\"],\\n            }\\n        }, {\\n            name: '动漫',\\n            id: 'anime',\\n            content: {\\n                \\\"cupfox_genres\\\": [\\\"全部类型:\\\", \\\"喜剧\\\", \\\"爱情\\\", \\\"动作\\\", \\\"科幻\\\", \\\"奇幻\\\"],\\n                \\\"cupfox_countries\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"日本\\\"],\\n                \\\"cupfox_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2010年代\\\", \\\"2000年代\\\", \\\"90年代\\\", \\\"80年代\\\", \\\"70年代\\\", \\\"60年代\\\", \\\"更早\\\"],\\n                \\\"cupfox_sort\\\": [\\\"近期热度:T\\\", \\\"高分优先:S\\\"],\\n            }\\n        }, {\\n            name: '综艺',\\n            id: 'variety',\\n            content: {\\n                \\\"cupfox_genres\\\": [\\\"全部类型:\\\", \\\"真人秀\\\", \\\"脱口秀\\\", \\\"音乐\\\", \\\"歌舞\\\"],\\n                \\\"cupfox_countries\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"韩国\\\", \\\"日本\\\"],\\n                \\\"cupfox_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2010年代\\\", \\\"2000年代\\\", \\\"90年代\\\", \\\"80年代\\\", \\\"70年代\\\", \\\"60年代\\\", \\\"更早\\\"],\\n                \\\"cupfox_sort\\\": [\\\"近期热度:T\\\", \\\"高分优先:S\\\"],\\n            }\\n        }]\\n\\n\\n        var 大类 = []\\n        ojson.map(x => {\\n            大类.push(x.name + \\\"@\\\" + x.name)\\n        })\\n\\n        var index = storage0.getMyVar(\\\"index\\\", '0')\\n\\n        var j = ojson[index]\\n        var keys = Object.keys(j.content)\\n\\n        var temp = {}\\n        keys.forEach(x => {\\n            var type = x\\n\\n            var l = j.content[x]\\n\\n            if (['area', 'lang', 'version', 'state'].includes(x)) {\\n                return\\n            }\\n\\n            if (l.length > 0) {\\n                var ns = l.map((k) => {\\n\\n                    var name = k.includes(\\\":\\\") ? k.split(':')[0] : k\\n                    var id = k.includes(\\\":\\\") ? k.split(':')[1] : k\\n                    return {\\n                        'name': name,\\n                        'url': id,\\n                        'type': x\\n                    }\\n                })\\n                temp[x] = ns\\n            }\\n        })\\n\\n        var t = Object.values(temp).map(x => x.map(z => JSON.stringify(z)).join('#'))\\n\\n\\n        var TrueJson = {\\n            type: Array(大类.join('#')),\\n            item: t != \\\"\\\" ? t : [],\\n        }\\n        //log(TrueJson)\\n\\n        //需根据实际修改\\n        const 分类颜色 = getRangeColors();\\n        const Json大类 = 'type';\\n        const Json拼接 = 'item';\\n        const Json拆分 = '#';\\n        const Json单项 = '@';\\n        const Json列表 = [\\\"cupfox_genres\\\", \\\"cupfox_countries\\\", \\\"cupfox_year\\\", \\\"cupfox_sort\\\", \\\"cfpage\\\"]; //切换清除\\n        const 单项清除 = [\\\"cfpage\\\"];\\n        const 排除 = '';\\n        const 分类展开 = '∨';\\n        const 分类折叠 = '∧';\\n        const 页面标识 = 'aicupfox';\\n\\n\\n        //动态分类\\n        eval(JSON.parse(request('hiker://page/jdtfl')).rule)\\n\\n        var type = storage0.getMyVar(页面标识, \\\"电影\\\")\\n        var tag = storage0.getMyVar(\\\"cupfox_genres\\\", \\\"\\\")\\n        var country = storage0.getMyVar(\\\"cupfox_countries\\\", \\\"\\\")\\n        var year = storage0.getMyVar(\\\"cupfox_year\\\", \\\"\\\")\\n        var sort = storage0.getMyVar(\\\"cupfox_sort\\\", \\\"T\\\")\\n\\n        //log(type + tag + country + year + sort)\\n\\n        var fjson = cupfoxfilter({\\n            tags: type,\\n            genres: tag,\\n            countries: country,\\n            year_range: year,\\n            sort: sort,\\n        }, storage0.getMyVar('cfpage', MY_PAGE))\\n\\n        fjson.subjects.map(x => {\\n            d.push({\\n                title: x.title,\\n                img: x.cover + \\\"@Referer=\\\",\\n                desc: x.star,\\n                col_type: 'movie_3_marquee',\\n                url: $('').lazyRule((n) => {\\n                    putMyVar(\\\"sou\\\", n)\\n                    refreshPage()\\n                    return 'hiker://empty'\\n                }, x.title),\\n            })\\n        })\\n\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"函数\",\"path\":\"xtools\",\"rule\":\"js:\\nfunction encodeUTF8(s) {\\nvar i, r = [], c, x;\\nfor (i = 0; i < s.length; i++)\\nif ((c = s.charCodeAt(i)) < 0x80) r.push(c);\\nelse if (c < 0x800) r.push(0xC0 + (c >> 6 & 0x1F), 0x80 + (c & 0x3F));\\nelse {\\nif ((x = c ^ 0xD800) >> 10 == 0) //对四字节UTF-16转换为Unicode\\nc = (x << 10) + (s.charCodeAt(++i) ^ 0xDC00) + 0x10000,\\nr.push(0xF0 + (c >> 18 & 0x7), 0x80 + (c >> 12 & 0x3F));\\nelse r.push(0xE0 + (c >> 12 & 0xF));\\nr.push(0x80 + (c >> 6 & 0x3F), 0x80 + (c & 0x3F));\\n};\\nreturn r;\\n}\\n\\nfunction sha1(s) {\\nvar data = new Uint8Array(encodeUTF8(s))\\nvar i, j, t;\\nvar l = ((data.length + 8) >>> 6 << 4) + 16, s = new Uint8Array(l << 2);\\ns.set(new Uint8Array(data.buffer)), s = new Uint32Array(s.buffer);\\nfor (t = new DataView(s.buffer), i = 0; i < l; i++)s[i] = t.getUint32(i << 2);\\ns[data.length >> 2] |= 0x80 << (24 - (data.length & 3) * 8);\\ns[l - 1] = data.length << 3;\\nvar w = [], f = [\\nfunction () { return m[1] & m[2] | ~m[1] & m[3]; },\\nfunction () { return m[1] ^ m[2] ^ m[3]; },\\nfunction () { return m[1] & m[2] | m[1] & m[3] | m[2] & m[3]; },\\nfunction () { return m[1] ^ m[2] ^ m[3]; }\\n], rol = function (n, c) { return n << c | n >>> (32 - c); },\\nk = [1518500249, 1859775393, -1894007588, -899497514],\\nm = [1732584193, -271733879, null, null, -1009589776];\\nm[2] = ~m[0], m[3] = ~m[1];\\nfor (i = 0; i < s.length; i += 16) {\\nvar o = m.slice(0);\\nfor (j = 0; j < 80; j++)\\nw[j] = j < 16 ? s[i + j] : rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1),\\nt = rol(m[0], 5) + f[j / 20 | 0]() + m[4] + w[j] + k[j / 20 | 0] | 0,\\nm[1] = rol(m[1], 30), m.pop(), m.unshift(t);\\nfor (j = 0; j < 5; j++)m[j] = m[j] + o[j] | 0;\\n};\\nt = new DataView(new Uint32Array(m).buffer);\\nfor (var i = 0; i < 5; i++)m[i] = t.getUint32(i << 2);\\n\\nvar hex = Array.prototype.map.call(new Uint8Array(new Uint32Array(m).buffer), function (e) {\\nreturn (e < 16 ? \\\"0\\\" : \\\"\\\") + e.toString(16);\\n}).join(\\\"\\\");\\nreturn hex;\\n}\\n\\n\\nfunction search1(s, page) {\\n    eval(getCryptoJS())\\n    if (page == 1) {\\n        p = 0\\n    } else if (page == 2) {\\n        p = 19\\n    } else {\\n        p = parseInt(page) + 20\\n    }\\n    storage0.putMyVar('page', p)\\n    ss = s + 'URBBRGROUN'\\n    tk = CryptoJS.SHA1(ss).toString();\\n    var j = fetch(`https://api.cupfox.app/api/v2/search/?text=${s}&type=0&from=${p}&size=20&douban_id=0&token=${tk}`)\\n    try {\\n        var json = JSON.parse(j)\\n    } catch {\\n        var json = {}\\n    }\\n    return json\\n}\\n\\nfunction search(s, page) {\\n    eval(getCryptoJS())\\n    if (page == 1) {\\n        p = 0\\n    } else if (page == 2) {\\n        p = 19\\n    } else {\\n        p = parseInt(page) + 20\\n    }\\n    storage0.putMyVar('page', p)\\n    ss = s + 'URBBRGROUN'\\n    tk = CryptoJS.SHA1(ss).toString();\\n    var j = fetch(`https://api.cupfox.app/api/v2/search/?text=${s}&type=0&from=${p}&size=20&douban_id=0&token=${tk}`)\\n    try {\\n        var json = JSON.parse(j)\\n    } catch {\\n        var json = {}\\n    }\\n    return json\\n}\\n\\nfunction cupfoxfilter(dict,page) {\\n    var s=Object.values(dict).join(\\\"\\\");\\n    let start=0;\\n    let limit=24;\\n    if (page == 1) {\\n        start = 0;\\n    } else {\\n        start=parseInt(page)+limit;\\n    }\\n    storage0.putMyVar('cfpage', start)\\n    //log(start+\\\"  \\\"+limit)\\n    ss = s + 'URBBRGROUN'\\n    tk = sha1(ss)\\n    var url=`https://api.cupfox.app/api/v2/filter/?tags=${dict.tags}&genres=${dict.genres}&countries=${dict.countries}&year_range=${dict.year_range}&sort=${dict.sort}&start=${start}&limit=${limit}&token=${tk}`;\\n    //log(url)\\n    var j = fetch(`${url}`)\\n    try {\\n        var json = JSON.parse(j)\\n    } catch {\\n        var json = {}\\n    }\\n    return json\\n}\\n\"},{\"col_type\":\"movie_3\",\"name\":\"函数2\",\"path\":\"ztools\",\"rule\":\"js:\\n//url解析\\nlet {\\n    urlParse\\n} = $.require(\\\"hiker://page/tool\\\");\\n\\n\\nfunction stringInArray(str, arr) {\\n    return arr.some(item => str.includes(item));\\n}\\n\\n\\n//排除没路径\\nfunction nofile(u) {\\n    url = u.href\\n    if (stringInArray(url, ['magnet', 'ed2k'])) {\\n        BitTS.push(u);\\n        return true\\n    }\\n    var u = urlParse(url)\\n    if (u.File == '' || u.File == '/' || u.Ref != null) {\\n        return true\\n    }\\n}\\n//去重\\nfunction unique(arr) {\\n    const res = new Map()\\n    return arr.filter((a) => !res.has(a.url) && res.set(a.url, 1))\\n}\\n\\n//重定向可用链接\\nfunction getTurl(u) {\\n    //log(u)\\n    try {\\n        var url = base64Decode(u);\\n    } catch {\\n        var url = u\\n    }\\n    if (!url.includes('http') || url == undefined) {\\n        url = u\\n    }\\n    url = url.includes('?') ? url.split('?')[0] : url\\n    log('url:' + url)\\n    var file = urlParse(url).File\\n    var turl = ''\\n    let head = JSON.parse(request(url, {\\n        onlyHeaders: true\\n    }));\\n    //log(head)\\n    if (head.url != undefined || head.url != '') {\\n        var jurlp = urlParse(head.url)\\n        if (jurlp.File == '/' || jurlp.File == '') {\\n            turl = jurlp.Hosts + file\\n        } else {\\n            turl = head.url\\n        }\\n    } else {\\n        turl = url\\n    }\\n    //log('turl:'+turl)\\n    turl = turl.replace(/\\\\?from.+$/gm, '');\\n\\n    turl = videoRefDetail(turl)\\n    //log(turl)\\n    return turl\\n}\\n\\n\\nfunction videoRefDetail(url) {\\n    if (stringInArray(url, [\\\"6080\\\"])) {\\n        url = url.replace(\\\"vplay\\\", \\\"video\\\");\\n    } else if (stringInArray(url, [\\\"zhuiju\\\"])) {\\n        url = url.replace(\\\"vodplay\\\", \\\"voddetail\\\");\\n    } else if (stringInArray(url, [\\\"rrets\\\"])) {\\n        url = url.replace(\\\"play\\\", \\\"project\\\")\\n    }\\n    return url;\\n}\\n\\n\\n//多选模块\\nfunction MultiSelectMode(name, id) {\\n    return $('#noLoading#').lazyRule((datatitle, dataurl) => {\\n        function unique(arr) {\\n        const res = new Map()\\n        return arr.filter((a) => !res.has(a.url) && res.set(a.url, 1))\\n        }\\n        let duoselect = storage0.getMyVar(\\\"duoselect\\\") ? storage0.getMyVar(\\\"duoselect\\\") : [];\\n        if (duoselect.findIndex(x => x.url === dataurl) == -1) {\\n            duoselect.push({\\n                title: datatitle,\\n                url: dataurl\\n            })\\n            duoselect = unique(duoselect)\\n            updateItem(dataurl, {\\n                title: `““””<span style=\\\"color:#FF5733\\\">` + datatitle\\n                //title:`‘‘`+datatitle+`’’`\\n            });\\n        } else {\\n            function removeByValue(arr, val) {\\n                for (var i = 0; i < arr.length; i++) {\\n                    if (arr[i]['url'] == val) {\\n                        arr.splice(i, 1);\\n                        break;\\n                    }\\n                }\\n            }\\n            removeByValue(duoselect, dataurl)\\n            updateItem(dataurl, {\\n                title: datatitle\\n            });\\n        }\\n        storage0.putMyVar(\\\"duoselect\\\", duoselect);\\n        return \\\"hiker://empty\\\"\\n    }, name, id)\\n}\\n\\n$.extend({\\n    msm: MultiSelectMode,\\n})\"},{\"col_type\":\"movie_3\",\"name\":\"推送\",\"path\":\"push\",\"rule\":\"js:\\nlet items = [];\\nlet pushin = decodeURIComponent(getParam(\\\"pushurl\\\"));\\nlet tvip = getItem('hikertvboxset', '');\\n\\nitems.push({\\n    title: '当前IP：' + tvip,\\n    url: \\\"input://\\\" + getItem('hikertvboxset', 'http://' + getIP() + ':9978') + \\\"////请输入TVBox端的IP地址，如http://\\\" + getIP() + \\\":9978.js:setItem('hikertvboxset',input);refreshPage()\\\",\\n    col_type: 'flex_button'\\n});\\nvar purl = pushin;\\n\\nif (pushin.includes('\\\\n') && !pushin.startsWith('{')) {\\n    purl = pushin.replace(\\\"\\\\n\\\", '$');\\n}\\nif (pushin.startsWith('http') && pushin.includes(';{')) {\\n    purl = JSON.stringify({\\n        \\\"name\\\": \\\"海阔直链推送\\\",\\n        \\\"url\\\": pushin\\n    })\\n}\\nif (pushin.startsWith('https://www.aliyundrive.com/s/')) {\\n    let reftoken = JSON.parse(fetch('hiker://files/rules/icy/icy-ali-token.json', {}))[0].refresh_token;\\n    purl = JSON.stringify({\\n        \\\"url\\\": pushin,\\n        \\\"refresh_token\\\": reftoken\\n    })\\n}\\nif (pushin.includes(':52020')) {\\n    if (pushin.includes('redirectPlayUrl')) {\\n        purl = JSON.stringify({\\n            \\\"name\\\": \\\"海阔投屏直链\\\",\\n            \\\"url\\\": pushin\\n        })\\n    } else {\\n        purl = JSON.stringify({\\n            \\\"name\\\": \\\"海阔网页投屏\\\",\\n            \\\"url\\\": pushin\\n        })\\n    }\\n}\\n\\n//log('推送'+purl);\\nvar state = request(tvip + '/action', {\\n    headers: {\\n        'Content-Type': 'application/x-www-form-urlencoded',\\n        //'X-Requested-With': 'XMLHttpRequest',\\n        'Referer': tvip\\n    },\\n    timeout: 2000,\\n    body: 'do=push&url=' + purl.replace(/\\\\&/g, '＆＆'),\\n    method: 'POST'\\n});\\n//log(state);\\nif (state == 'ok') {\\n    //log(state);\\n    items.push({\\n        title: \\\"✅\\\" + state,\\n        url: $('').lazyRule(() => {\\n            back(false);\\n            return 'hiker://empty'\\n        }),\\n        col_type: \\\"text_center_1\\\"\\n    });\\n} else {\\n    //log(state);\\n    items.push({\\n        title: \\\"❎\\\" + state,\\n        url: \\\"hiker://empty\\\",\\n        col_type: \\\"text_center_1\\\"\\n    });\\n\\n}\\nsetResult(items);\"},{\"col_type\":\"movie_3\",\"name\":\"设置\",\"path\":\"setting\",\"rule\":\"js:\\nvar d = []\\n\\naddListener(\\\"onClose\\\", $.toString(() => {\\n    refreshPage()\\n}));\\n\\nif (MY_PAGE == 1) {\\n    d.push({\\n        title: '设置IP地址',\\n        url: \\\"input://\\\" + getItem('hikertvboxset', 'http://' + getIP() + ':9978') + \\\"////请输入tvbox推送IP地址，如http://\\\" + getIP() + \\\":9978.js:setItem('hikertvboxset',input);refreshPage()\\\",\\n        col_type: 'flex_button'\\n    });\\n    d.push({\\n        title: getItem('hikertvboxset', ''),\\n        url: 'hiker://empty',\\n        col_type: 'flex_button'\\n    });\\n\\n    var sconfig = {\\n        history: false, //历史\\n        histshow: 10, //保留10个\\n        suggest: false, //建议\\n    }\\n\\n    var sfig = storage0.getItem('sconfig', sconfig);\\n\\n    var lazy = $('').lazyRule((o, k) => {\\n        var obj = storage0.getItem('sconfig', o)\\n        if (obj[k] == false) {\\n            o[k] = true;\\n            storage0.setItem('sconfig', o)\\n        } else {\\n            o[k] = false;\\n            storage0.setItem('sconfig', o)\\n        }\\n        refreshPage(false)\\n        return 'hiker://empty'\\n    }, storage0.getItem('sconfig', sfig), 'action')\\n\\n    function Tof(key) {\\n        var b = storage0.getItem('sconfig', sfig)[key]\\n        if (b == true || b == undefined) {\\n            return 'https://hikerfans.com/tubiao/messy/55.svg'\\n        } else {\\n            return 'https://hikerfans.com/tubiao/messy/63.svg'\\n        }\\n    }\\n\\n    $.extend({\\n        GoS: {\\n            get: function(key) {\\n                return storage0.getItem('sconfig', sfig)[key];\\n            },\\n            save: function(cof, key, input) {\\n                var o = storage0.getItem('sconfig', cof);\\n                o[key] = input;\\n                storage0.setItem('sconfig', o);\\n            }\\n        }\\n    })\\n\\n    d.push({\\n        title: '启用历史记录',\\n        url: lazy.replace('action', 'history'),\\n        col_type: \\\"text_icon\\\",\\n        desc: \\\"\\\",\\n        pic_url: Tof('history'),\\n    });\\n\\n    if (sfig.history == true) {\\n        d.push({\\n            title: '历史保留',\\n            col_type: 'input',\\n            desc: '默认10',\\n            url: $.toString((cof) => {\\n                $.GoS.save(cof, 'histshow', Number(input));\\n                refreshPage(false);\\n                return 'toast://历史数据保留设置:' + input;\\n            }, storage0.getItem('sconfig', sfig)),\\n            extra: {\\n                defaultValue: $.GoS.get('histshow') == 0 ? 10 : $.GoS.get('histshow'),\\n                type: 'number'\\n            }\\n        })\\n    }\\n\\n    d.push({\\n        title: '启用建议',\\n        url: lazy.replace('action', 'suggest'),\\n        col_type: \\\"text_icon\\\",\\n        desc: \\\"\\\",\\n        pic_url: Tof('suggest'),\\n    });\\n\\n    //log(sfig)\\n\\n}\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"x5ai\",\"path\":\"x5ai\",\"rule\":\"$.exports = function(rule, anchorId) {\\n    return $.toString((rule, anchorId, moban) => {\\n        if (window.check0 == null) {\\n            function check0() {\\n                try {\\n                    let html = document.querySelector(\\\"html\\\").innerHTML;\\n                    fba.putVar(\\\"html0\\\", html);\\n                    fba.parseLazyRuleAsync($$$().lazyRule((rule, url, anchorId, moban) => {\\n                        try {\\n\\n                            let html = getVar(\\\"html0\\\", \\\"\\\");\\n                            let iurl = '';\\n                            clearVar(\\\"html0\\\");\\n                            //log('url:' + url)\\n                            if (url.startsWith('https://cupfox.app/page?url=')) {\\n                                var baseurl = url.replace(/.+url=(.*?)&.+/gm, '$1')\\n                                iurl = base64Decode(baseurl)\\n                                putVar('iframe', iurl)\\n                                log('iurl:' + iurl)\\n                            } else if (url.startsWith('https://m.qmtv.pro/#/third-page?playurl=')) {\\n                                var baseurl=url.replace(/.*?playurl=(.*?)$/gm,'$1');\\n                                iurl=decodeURIComponent(baseurl);\\n                                putVar('iframe', iurl);\\n                                log('iurl:' + iurl);\\n                            }\\n                            return iurl.length > 0 ? \\\"1\\\" : \\\"0\\\";\\n                        } catch (e) {\\n                            log(e.toString());\\n                        }\\n                    }, rule, location.href, anchorId, moban), $$$.toString((rule, moban) => {\\n                        //fba.log(input)\\n                        //fba.log(rule)\\n                        if (\\\"0\\\" == input) {\\n                            window.checkc = window.checkc + 1;\\n                            /*if (window.checkc > 120) {\\n                                fba.log(\\\"执行超过30秒，无法解析\\\");\\n                            } else {*/\\n                            setTimeout(window.check0, 250);\\n                            //}\\n                        } else {\\n                            var url = fba.getVar('iframe');\\n                            fba.log('moban' + moban)\\n                            if (moban == '1') {\\n                                url = url + '#immersiveTheme#'\\n                            }\\n                            fba.log(url)\\n                            fba.open(JSON.stringify({\\n                                rule: rule,\\n                                title: '影片详情',\\n                                group: \\\"\\\",\\n                                preRule: \\\"\\\",\\n                                pages: \\\"\\\",\\n                                url: 'hiker://page/p?rule=' + rule + '&u=' + url,\\n                                findRule: \\\"\\\"\\n                            }));\\n                            window.checkurl = location.href;\\n\\n                            function checku0() {\\n                                if (window.checkurl != location.href) {\\n                                    //hash发生了变化\\n                                    setTimeout(function() {\\n                                        window.checkc = 0;\\n                                        check0();\\n                                    }, 2000);\\n                                } else {\\n                                    setTimeout(checku0, 250);\\n                                }\\n                            }\\n                            checku0();\\n                        }\\n                    }, rule, moban));\\n                } catch (e) {\\n                    fba.log(e.toString());\\n                    setTimeout(window.check0, 250);\\n                }\\n            }\\n            window.checkc = 0;\\n            window.check0 = check0;\\n            check0();\\n        }\\n    }, rule, anchorId, getItem('ai', '0'));\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"5.茶杯虎\",\"path\":\"aiobb\",\"rule\":\"js:\\nlet durl = getMyVar(\\\"durl\\\", \\\"\\\");\\nif (durl != '') {\\n    MY_URL = durl\\n    log(durl)\\n\\n    let url = durl;\\n    let id = url;\\n    try {\\n        var html = fetch(url);\\n    } catch {\\n        var html = ''\\n    }\\n    var rule = MY_RULE.title\\n    if (html == undefined || html == '') {\\n        toast('无数据')\\n        clearMyVar(\\\"sou\\\");\\n        clearMyVar(\\\"durl\\\");\\n        refreshPage()\\n    } else {\\n\\n        d.push({\\n            title: pdfh(html, 'h4&&Text'),\\n            img: pd(html, 'img&&src'),\\n            col_type: 'movie_1_vertical_pic',\\n            desc: pdfh(html, 'body&&.pubTime&&Text'),\\n            url: url,\\n            extra: {\\n                id: url,\\n                inheritTitle: false\\n            }\\n        })\\n\\n\\n        var list = pdfa(html, '.movieZy&&a')\\n        if (list && list.length > 0) {\\n            try {\\n                MY_URL = \\\"\\\";\\n                let {\\n                    merge\\n                } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n                list = list.map(it => {\\n                    let u = pdfh(it, 'a&&href');\\n                    let t = pdfh(it, 'ul&&Text');\\n                    u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                    u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                    return {\\n                        title: merge(t, '详情', 1),\\n                        img: 'https://www.725998.com/static/search/images/onLine.png',\\n                        col_type: \\\"avatar\\\",\\n                        url: u,\\n                        extra: {\\n                            inheritTitle: false,\\n                            cls: url,\\n                            from: 'home',\\n                        }\\n                    }\\n                });\\n                d = d.concat(list)\\n            } catch (e) {\\n                log(e.toString());\\n            }\\n        } else {\\n            d.push({\\n                title: '无资源',\\n                col_type: 'text_center_1',\\n            })\\n        }\\n        setResult(d)\\n    }\\n\\n}\\ns = getMyVar(\\\"sou\\\", \\\"\\\");\\n\\nlet r = \\\"\\\";\\nif (s != \\\"\\\") {\\n\\n    var url = post(`https://www.725998.com/keywords.html`, {\\n        body: {\\n            keywords: s,\\n            type: 'movie'\\n        },\\n        onlyHeaders: true\\n    })\\n    var json = JSON.parse(url)\\n    var turl = json.url.replace(/-\\\\d+.html$/, '-' + MY_PAGE + '.html')\\n    MY_URL = turl\\n    var html = fetch(turl)\\n\\n    var list = pdfa(html, 'body&&.each')\\n    //log(list)\\n\\n    let {\\n        wrap\\n    } = $.require(\\\"hiker://page/tool\\\");\\n\\n    for (let it of list) {\\n        let name = pdfh(it, 'a&&title');\\n        let img = pd(it, 'img&&src');\\n        if (img == \\\"\\\") {\\n            img = \\\"https://www.725998.com/static/search/images/preloadImg.png\\\";\\n        }\\n        let url = pd(it, 'a&&href');\\n        let desc = pdfa(it, 'body&&.info&&a').map(x => pdfh(x, 'a&&Text')).join(' ');\\n        let score = pdfh(it, '.noScore&&Text');\\n        d.push({\\n            title: wrap(name, s),\\n            col_type: 'movie_1_vertical_pic',\\n            img: img,\\n            desc: '评分:' + score + '\\\\n' + desc,\\n            url: $(url).lazyRule((rule, url, s) => {\\n                var cls = findItemsByCls(url);\\n                if (!!cls) {\\n                    deleteItemByCls(url)\\n                } else {\\n                    let url = input;\\n                    let id = url;\\n                    let html = fetch(url);\\n                    var list = pdfa(html, '.movieZy&&a')\\n                    if (list && list.length > 0) {\\n                        try {\\n                            MY_URL = \\\"\\\";\\n                            let {\\n                                merge\\n                            } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n                            list = list.map(it => {\\n                                let u = pdfh(it, 'a&&href');\\n                                let t = pdfh(it, 'ul&&Text');\\n                                u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                                u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                                return {\\n                                    title: merge(t, '详情', 1),\\n                                    img: 'https://www.725998.com/static/search/images/onLine.png',\\n                                    col_type: \\\"avatar\\\",\\n                                    url: u,\\n                                    extra: {\\n                                        inheritTitle: false,\\n                                        cls: url,\\n                                        from: 'home',\\n                                    }\\n                                }\\n                            });\\n                            addItemAfter(id, list);\\n                        } catch (e) {\\n                            log(e.toString());\\n                        }\\n                    } else {\\n                        addItemAfter(id, {\\n                            title: '无资源',\\n                            col_type: 'text_center_1',\\n                            extra: {\\n                                cls: url,\\n                            }\\n                        })\\n                    }\\n                }\\n                return \\\"hiker://empty\\\"\\n            }, MY_RULE.title, url, s),\\n            extra: {\\n                id: url,\\n                inheritTitle: false\\n            }\\n        })\\n    }\\n\\n    setResult(d)\\n} else {\\n\\n}\\n\\nif (getItem('home', '关') == '开') {\\n    function setLists(item) {\\n        MY_URL = 'https://www.725998.com/';\\n        var title = item.split('#')[0]\\n        var key = item.split('#')[1]\\n        d.push({\\n            title: title,\\n            col_type: 'avatar',\\n            img: 'https://hikerfans.com/tubiao/more/10.png'\\n        })\\n\\n        var html = fetch(`https://www.725998.com/yingku-list/${key}-0-0-0-0-0-0.html`)\\n        var list = pdfa(html, 'body&&.each')\\n\\n        list.map(x => {\\n            var name = pdfh(x, 'a&&title')\\n            let img = pd(x, 'img&&src');\\n            if (img == \\\"\\\") {\\n                img = \\\"https://www.725998.com/static/search/images/preloadImg.png\\\";\\n            }\\n            let url = pd(x, 'a&&href');\\n            let score = pdfh(x, '.noScore&&Text');\\n            d.push({\\n                title: name,\\n                img: img,\\n                desc: score,\\n                url: $('').lazyRule((n, u) => {\\n                    putMyVar(\\\"sou\\\", n)\\n                    putMyVar('durl', u)\\n                    refreshPage()\\n                    return 'hiker://empty'\\n                }, name, url)\\n            })\\n        })\\n    }\\n\\n    ['电影#1', '电视剧#2', '动漫#3', '纪录片#4'].map(x => {\\n\\n        setLists(x)\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"6.电影狗\",\"path\":\"dydog\",\"rule\":\"js:\\nMY_URL='https://www.dianyinggou.com/soMore/all-all-all-all-';\\nlet durl = getMyVar(\\\"durl\\\", \\\"\\\");\\nif (durl != '') {\\n    //log(durl)\\n\\n    let url = durl;\\n    let id = url;\\n    let name = s;\\n    try {\\n        var html = fetch(url);\\n    } catch {\\n        var html = ''\\n    }\\n    var rule = MY_RULE.title\\n\\n    d.push({\\n        title: pdfh(html, 'h4&&Text'),\\n        img: pdfh(html, 'img&&data-url'),\\n        col_type: 'movie_1_vertical_pic',\\n        desc: pdfh(html, 'body&&.pubTime&&Text'),\\n        url: url,\\n        extra: {\\n            id: url,\\n            inheritTitle: false\\n        }\\n    })\\n\\n    let html = fetch(`https://www.dianyinggou.com/SpiderMovie/zy/${name}`, {\\n        headers: {\\n            'x-requested-with': 'XMLHttpRequest'\\n        }\\n    });\\n\\n    var list = pdfa(html, '.movieZy&&a')\\n    if (list && list.length > 0) {\\n        try {\\n            MY_URL = \\\"\\\";\\n            let {\\n                wrap1\\n            } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n            \\n            list = list.map(it => {\\n                let u = pdfh(it, 'a&&href');\\n                let t = pdfh(it, 'li,0&&Text');\\n                let web=pdfh(it, 'li,1&&Text');\\n                u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                return {\\n                    title: wrap1(web+'-'+t, s),\\n                    img: 'https://www.725998.com/static/search/images/onLine.png',\\n                    col_type: \\\"avatar\\\",\\n                    url: u,\\n                    extra: {\\n                        inheritTitle: false,\\n                        cls: url,\\n                        pageTitle:t,\\n                        web:web,\\n                    }\\n                }\\n            });\\n            d = d.concat(list)\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n    setResult(d)\\n}\\ns = getMyVar(\\\"sou\\\", \\\"\\\");\\nlet r = \\\"\\\";\\nif (s != \\\"\\\") {\\n    var page = MY_PAGE;\\n    var url = `https://www.dianyinggou.com/so/${s}/page_${page}.html`;\\n    //log(url)\\n    var html = fetch(url)\\n\\n    var list = pdfa(html, 'body&&.each')\\n    //log(list)\\n\\n    let {\\n        wrap\\n    } = $.require(\\\"hiker://page/tool\\\");\\n\\n    for (let it of list) {\\n        let name = pdfh(it, 'a&&title');\\n        let img = pd(it, 'img&&data-url');\\n        if (img == \\\"\\\") {\\n            img = \\\"https://www.dianyinggou.com/View/images/blank_bg.png\\\";\\n        }\\n        let url = pd(it, 'a&&href');\\n        let desc = pdfa(it, 'body&&.info&&a').map(x => pdfh(x, 'a&&Text')).join(' ');\\n        let score = pdfh(it, '.noScore&&Text');\\n        d.push({\\n            title: wrap(name, s),\\n            col_type: 'movie_1_vertical_pic',\\n            img: img,\\n            desc: '评分:' + score + '\\\\n' + desc,\\n            url: $(url).lazyRule((rule, url, s, name) => {\\n                var cls = findItemsByCls(url);\\n                if (!!cls) {\\n                    deleteItemByCls(url)\\n                } else {\\n                    let url = input;\\n                    let id = url;\\n                    let html = fetch(`https://www.dianyinggou.com/SpiderMovie/zy/${name}`, {\\n                        headers: {\\n                            'x-requested-with': 'XMLHttpRequest'\\n                        }\\n                    });\\n                    var list = pdfa(html, '.movieZy&&a')\\n                    if (list && list.length > 0) {\\n                        try {\\n                            MY_URL = \\\"\\\";\\n                            let {\\n                                wrap1\\n                            } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n                            list = list.map(it => {\\n                                let u = pdfh(it, 'a&&href');\\n                                let t = pdfh(it, 'li,0&&Text');\\n                                let web=pdfh(it, 'li,1&&Text');\\n                                u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                                u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                                return {\\n                                    title: wrap1(web+'-'+t, s),\\n                                    img: 'https://www.725998.com/static/search/images/onLine.png',\\n                                    col_type: \\\"avatar\\\",\\n                                    url: u,\\n                                    extra: {\\n                                        inheritTitle: false,\\n                                        cls: url,\\n                                        pageTitle:t,\\n                                        web:web,\\n                                    }\\n                                }\\n                            });\\n                            addItemAfter(id, list);\\n                        } catch (e) {\\n                            log(e.toString());\\n                        }\\n                    }\\n                }\\n                return \\\"hiker://empty\\\"\\n            }, MY_RULE.title, url, s, name),\\n            extra: {\\n                id: url,\\n                inheritTitle: false\\n            }\\n        })\\n    }\\n\\n    setResult(d)\\n} else {\\n\\n}\\n\\nif (getItem('home', '关') == '开') {\\n    function setLists(item) {\\n        MY_URL = 'https://www.dianyinggou.com/';\\n        var title = item.split('#')[0]\\n        var key = item.split('#')[1]\\n        d.push({\\n            title: title,\\n            col_type: 'avatar',\\n            img: 'https://hikerfans.com/tubiao/more/10.png'\\n        })\\n\\n        var date = new Date();\\n        var year = date.getFullYear();\\n        //var html = fetch(`https://www.dianyinggou.com/mRecommd/${key}`);\\n        var html = fetch(`https://www.dianyinggou.com/soMore/${key}-all-all-${year}-`);\\n\\n        var list = pdfa(html, 'body&&.each')\\n\\n        list.map(x => {\\n            var name = pdfh(x, 'a&&title')\\n            let img = pd(x, 'img&&data-url');\\n            if (img == \\\"\\\") {\\n                img = \\\"https://www.dianyinggou.com/View/images/blank_bg.png\\\";\\n            }\\n            let url = pd(x, 'a&&href');\\n            let score = pdfh(x, '.noScore&&Text');\\n            d.push({\\n                title: name,\\n                img: img,\\n                desc: score,\\n                url: $('').lazyRule((n, u) => {\\n                    putMyVar(\\\"sou\\\", n)\\n                    putMyVar('durl', u)\\n                    refreshPage()\\n                    return 'hiker://empty'\\n                }, name, url)\\n            })\\n        })\\n    }\\n\\n    function home() {\\n        ['电影#movie', '电视剧#tv', '纪录片#doc', '动漫#comic'].map(x => {\\n\\n            setLists(x)\\n        })\\n    }\\n    \\n    var page=MY_PAGE;\\n    let true_url = getMyVar(MY_RULE.url, MY_URL);\\n    if(page>1){\\n        //log(true_url)\\n        true_url=true_url+`/page_${page}.html`\\n        //log(true_url)\\n    }\\n    var html =fetch(true_url).replace('%','');\\n    //log(html)\\n    \\n    \\n    const 分类颜色 = getRangeColors();\\n    const 大类定位 = '.w_100';\\n    const 拼接分类 = 'body&&.y_filterMenu:nth-child(n+2)>div>div';\\n    const 小类定位 = 'body&&a:not(:matches(分类))';\\n    const 分类标题 = 'a&&Text';\\n    const 分类链接 = 'a&&href';\\n\\n    //动态分类\\n    eval(JSON.parse(request('hiker://page/dtfl')).rule);\\n    \\n    var list = pdfa(html, 'body&&.each')\\n\\n    list.map(x => {\\n        var name = pdfh(x, 'a&&title')\\n        let img = pd(x, 'img&&src||img&&data-url');\\n        if (img == \\\"\\\") {\\n            img = \\\"https://www.dianyinggou.com/View/images/blank_bg.png\\\";\\n        }\\n        let url = pd(x, 'a&&href');\\n        let score = pdfh(x, '.noScore&&Text');\\n        d.push({\\n            title: name,\\n            img: img,\\n            desc: score,\\n            url: $('').lazyRule((n, u) => {\\n                putMyVar(\\\"sou\\\", n)\\n                putMyVar('durl', u)\\n                refreshPage()\\n                return 'hiker://empty'\\n            }, name, url)\\n        })\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"动态分类\",\"path\":\"dtfl\",\"rule\":\"const empty = \\\"hiker://empty\\\"\\n\\nif (typeof(拼接分类) != 'undefined' && 拼接分类 != '') {\\n    var categories = pdfa(html, 大类定位).concat(pdfa(html, 拼接分类))\\n} else {\\n    var categories = pdfa(html, 大类定位)\\n}\\n\\nlet init_cate = []\\n\\nfor (let i = 0; i < 20; i++) {\\n    init_cate.push(\\\"0\\\")\\n}\\n\\nconst fold = getMyVar(MY_RULE.group, \\\"0\\\")\\nconst cate_temp_json = getMyVar(页面标识+MY_RULE.title, JSON.stringify(init_cate))\\nconst cate_temp = JSON.parse(cate_temp_json)\\n\\n\\n\\nif (parseInt(page) === 1) {\\n    d.push({\\n    col_type:'big_blank_block'\\n    })\\n    d.push({\\n    col_type:'big_blank_block'\\n    })\\n    \\n    d.push({\\n        title: fold === '1' ? '““””<b>' + 分类折叠.fontcolor(\\\"#FF0000\\\") + '</b>' : '““””<b>' + 分类展开.fontcolor(\\\"#1aad19\\\") + '</b>',\\n        url: $().lazyRule((fold) => {\\n            putMyVar(MY_RULE.group, fold === '1' ? '0' : '1');\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, fold),\\n        col_type: 'scroll_button',\\n        extra: {\\n            longClick: [{\\n                title: '清除',\\n                js: $.toString((mark) => {\\n                    clearMyVar(mark + MY_RULE.url);\\n                    refreshPage();\\n                    return 'toast://清除成功';\\n                }, 页面标识)\\n            }]\\n        }\\n    })\\n    categories.forEach((category, index) => {\\n        let sub_categories = pdfa(category, 小类定位);\\n        if (index === 0) {\\n            sub_categories.forEach((item, key) => {\\n                let title = pdfh(item, 分类标题)\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\")\\n                }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\n                        let new_cate = []\\n                        params.cate_temp.forEach((cate, index) => {\\n                            new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\")\\n                        })\\n                        putMyVar(params.mark+MY_RULE.title, JSON.stringify(new_cate))\\n                        putMyVar(params.mark+MY_RULE.url, input)\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        key: key,\\n                        page: page,\\n                        mark:页面标识,\\n                    }),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        } else if (fold === '1') {\\n            sub_categories.forEach((item, key) => {\\n                let title = pdfh(item, 分类标题)\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\")\\n                }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: $(pd(item, 分类链接) + '#noLoading#').lazyRule((params) => {\\n                        params.cate_temp[params.index] = params.key.toString()\\n\\n                        putMyVar(params.mark+MY_RULE.title, JSON.stringify(params.cate_temp))\\n                        putMyVar(params.mark+MY_RULE.url, input)\\n\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        index: index,\\n                        key: key,\\n                        page: page,\\n                        mark:页面标识,\\n                    }),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        }\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"7.土拨鼠\",\"path\":\"tbsdy\",\"rule\":\"js:\\nlet durl = getMyVar(\\\"durl\\\", \\\"\\\");\\nif (durl != '') {\\n    MY_URL = durl;\\n    //log(durl)\\n\\n    let url = durl;\\n    let id = url;\\n    let name = s;\\n    try {\\n        var html = fetch(url, {\\n            headers: {\\n                \\\"User-Agent\\\": PC_UA\\n            }\\n        });\\n    } catch {\\n        var html = ''\\n    }\\n\\n    var rule = MY_RULE.title\\n    let desc = pdfh(html, '.video_plot_info_content&&Text');\\n    let score = pdfh(html, '.video_point&&Text');\\n\\n    d.push({\\n        title: pdfh(html, '.video_info_title_text&&Text'),\\n        img: pdfh(html, '.video_cover_img_box&&img&&data-url'),\\n        col_type: 'movie_1_vertical_pic',\\n        desc: '评分:' + score + '\\\\n主演:' + desc,\\n        url: url,\\n        extra: {\\n            id: url,\\n            inheritTitle: false,\\n        }\\n    })\\n\\n\\n    var list = pdfa(html, 'body&&.video_download_link_item')\\n    if (list && list.length > 0) {\\n        try {\\n            let {\\n                wrap1\\n            } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n\\n            list = list.map(it => {\\n                let u = pdfh(it, 'a&&href');\\n                let t = pdfh(it, '.video_download_link_name_text&&Text');\\n                let web = pdfh(it, '.resource_website_name&&Text');\\n                let img = pd(it, '.video_labels&&img&&src');\\n\\n                u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                return {\\n                    title: wrap1(web + '-' + t, s),\\n                    img: img,\\n                    col_type: \\\"avatar\\\",\\n                    url: u,\\n                    extra: {\\n                        inheritTitle: false,\\n                        cls: url,\\n                        pageTitle: t,\\n                        web: web,\\n                    }\\n                }\\n            });\\n            d = d.concat(list)\\n        } catch (e) {\\n            log(e.toString());\\n        }\\n    }\\n    setResult(d)\\n}\\ns = getMyVar(\\\"sou\\\", \\\"\\\");\\nlet r = \\\"\\\";\\nif (s != \\\"\\\") {\\n    var page = MY_PAGE;\\n    MY_URL = `https://www.tbsdy.com/search.html?keyword=${s}&paged=${page}&category=`;\\n    //log(MY_URL)\\n    let html = fetch(MY_URL, {\\n        headers: {\\n            \\\"User-Agent\\\": PC_UA\\n        }\\n    });\\n\\n    var list = pdfa(html, 'body&&.search_result_item')\\n\\n    let {\\n        wrap\\n    } = $.require(\\\"hiker://page/tool\\\");\\n\\n    for (let it of list) {\\n        let name = pdfh(it, '.search_result_title&&Text');\\n        let img = pd(it, 'img&&src');\\n        if (img == \\\"\\\") {\\n            img = \\\"\\\";\\n        }\\n        let url = pd(it, 'a&&href');\\n        let desc = pdfa(it, 'body&&.search_result_item&&.search_result_sub_info_line&&.video_actor').map(x => pdfh(x, 'span&&Text')).join(' ');\\n        let score = pdfh(it, '.search_video_img_point&&Text');\\n        d.push({\\n            title: wrap(name, s),\\n            col_type: 'movie_1_vertical_pic',\\n            img: img,\\n            desc: '评分:' + score + '\\\\n主演:' + desc,\\n            url: $(url).lazyRule((rule, url, s, name) => {\\n\\n                var cls = findItemsByCls(url);\\n                if (!!cls) {\\n                    deleteItemByCls(url)\\n                } else {\\n                    let url = input;\\n                    let id = url;\\n                    let html = fetch(url, {\\n                        headers: {\\n                            \\\"User-Agent\\\": PC_UA\\n                        }\\n                    });\\n\\n                    var list = pdfa(html, 'body&&.video_download_link_item')\\n                    if (list && list.length > 0) {\\n                        try {\\n                            MY_URL = url;\\n                            let {\\n                                wrap1\\n                            } = $.require(\\\"hiker://page/tool?rule=\\\" + rule);\\n                            list = list.map(it => {\\n                                let u = pdfh(it, 'a&&href');\\n                                let t = pdfh(it, '.video_download_link_name_text&&Text');\\n                                let web = pdfh(it, '.resource_website_name&&Text');\\n                                let img = pd(it, '.video_labels&&img&&src');\\n\\n                                u = \\\"hiker://page/p?rule=\\\" + rule + \\\"&u=\\\" + base64Encode(u);\\n                                u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n                                return {\\n                                    title: wrap1(web + '-' + t, s),\\n                                    img: img,\\n                                    col_type: \\\"avatar\\\",\\n                                    url: u,\\n                                    extra: {\\n                                        inheritTitle: false,\\n                                        cls: url,\\n                                        pageTitle: t,\\n                                        web: web,\\n                                    }\\n                                }\\n                            });\\n                            addItemAfter(id, list);\\n                        } catch (e) {\\n                            log(e.toString());\\n                        }\\n                    }\\n                }\\n                return \\\"hiker://empty\\\"\\n            }, MY_RULE.title, url, s, name),\\n            extra: {\\n                id: url,\\n                inheritTitle: false\\n            }\\n        })\\n    }\\n\\n    setResult(d)\\n} else {\\n\\n}\\n\\nif (getItem('home', '关') == '开') {\\n    var page = MY_PAGE;\\n    let {\\n        setpaged\\n    } = $.require(\\\"hiker://page/tool\\\");\\n\\n    var pindex = setpaged(d, page, \\\"tbsdy_ptag\\\", [\\\"首页\\\", \\\"分类\\\"], \\\"#4682B4\\\");\\n    if (pindex == 0) {\\n\\n        let html = fetch('https://www.tbsdy.com/', {\\n            headers: {\\n                \\\"User-Agent\\\": PC_UA\\n            }\\n        });\\n\\n        function setLists(item) {\\n            MY_URL = 'https://www.tbsdy.com/';\\n            var title = item.name;\\n            var key = item.select;\\n            d.push({\\n                title: title,\\n                col_type: 'avatar',\\n                img: item.img,\\n            })\\n\\n            var list = pdfa(html, `body&&.container_main_hot_${key}&&.hot_resource_one`)\\n\\n            list.map(x => {\\n                var name = pdfh(x, '.resource_name&&Text')\\n                let img = pd(x, '.resource_posters&&data-url');\\n                if (img == \\\"\\\") {\\n                    img = \\\"\\\";\\n                }\\n                let url = pd(x, 'a&&href');\\n\\n                let score = pdfh(x, '.update_tip||.resource_score||img&&Text');\\n\\n                d.push({\\n                    title: name,\\n                    img: img,\\n                    desc: score,\\n                    url: $('').lazyRule((n, u) => {\\n                        putMyVar(\\\"sou\\\", n)\\n                        putMyVar('durl', u)\\n                        refreshPage()\\n                        return 'hiker://empty'\\n                    }, name, url)\\n                })\\n            })\\n        }\\n\\n        [{\\n            name: '热门电视剧',\\n            select: 'tvs',\\n            img: 'https://www.tbsdy.com/img/mrsw/web/index/index_tv.svg',\\n        }, {\\n            name: '热门电影',\\n            select: 'movies',\\n            img: 'https://www.tbsdy.com/img/mrsw/web/index/index_mv.svg'\\n        }, {\\n            name: '热门动漫',\\n            select: 'animes',\\n            img: 'https://www.tbsdy.com/img/mrsw/web/index/index_show.svg'\\n        }, {\\n            name: '热门综艺',\\n            select: 'varietys',\\n            img: 'https://www.tbsdy.com/img/mrsw/web/index/index_records.svg'\\n        }, {\\n            name: '热门纪录片',\\n            select: 'documentarys',\\n            img: 'https://www.tbsdy.com/img/mrsw/web/index/index_records.svg',\\n        }].map(x => {\\n\\n            setLists(x)\\n        })\\n    }\\n\\n    if (pindex == 1) {\\n        MY_URL = \\\"https://www.tbsdy.com/classify.html\\\";\\n\\n        const 页面标识 = 'aitbsdy'\\n        const 分类颜色 = getRangeColors();\\n        const 大类定位 = 'body&&.top_navs_category';\\n        const 拼接分类 = 'body&&.classify_category_lines';\\n        const 小类定位 = 'body&&.top_nav||.classify_category_one';\\n        const 分类标题 = 'Text';\\n        const 分类链接 = 'a&&href';\\n        const 分类展开 = '∧';\\n        const 分类折叠 = '∨';\\n        \\n\\n        let {\\n            urlParse\\n        } = $.require(\\\"hiker://page/tool\\\");\\n\\n        let true_url = getMyVar(页面标识 + MY_RULE.url, MY_URL);\\n\\n        var uParse = urlParse(true_url);\\n        var urlpath = uParse.Path;\\n        var urlpa = uParse.Params;\\n        var uhost = uParse.Hosts\\n\\n        true_url = uhost + urlpath + \\\"?\\\" + Object.ToParams(Object.assign({}, urlpa, {\\n            paged: page\\n        }));\\n        //log(true_url)\\n\\n        var html = fetchPC(true_url);\\n        //log(html)\\n\\n        //动态分类\\n eval(JSON.parse(request('hiker://page/dtfl')).rule);\\n\\n        var list = pdfa(html, 'body&&.classify_main_resources&&a')\\n\\n        list.map(x => {\\n            var name = pdfh(x, '.resource_name&&Text')\\n            let img = pd(x, 'img&&data-url');\\n            if (img == \\\"\\\") {\\n                img = \\\"https://www.dianyinggou.com/View/images/blank_bg.png\\\";\\n            }\\n            let url = pd(x, 'a&&href');\\n            let score = pdfh(x, '.resource_score&&Text');\\n            d.push({\\n                title: name,\\n                img: img,\\n                desc: score,\\n                url: $('').lazyRule((n, u) => {\\n                    putMyVar(\\\"sou\\\", n)\\n                    putMyVar('durl', u)\\n                    refreshPage()\\n                    return 'hiker://empty'\\n                }, name, url)\\n            })\\n        })\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"动态分类Json\",\"path\":\"jdtfl\",\"rule\":\"js:\\nconst empty = \\\"hiker://empty\\\";\\n\\nif (typeof(Json拼接) != 'undefined' && Json拼接 != '') {\\n    \\n    var categoriesjson=TrueJson[Json大类];\\n    \\n    if(TrueJson[Json拼接].constructor  == Object){\\n    var itemjson=Object.keys(TrueJson[Json拼接]).map(x=>Object.values(TrueJson[Json拼接][x]).map(z=>JSON.stringify(z)).join(Json拆分))\\n    }else if(TrueJson[Json拼接].constructor  == Array){\\n     var itemjson=TrueJson[Json拼接]\\n    }\\n   \\n    categoriesjson=categoriesjson.concat(itemjson);\\n    \\n} else {\\n    var categoriesjson=TrueJson[Json大类];\\n}\\n\\n//log(categoriesjson)\\n\\nlet init_cate = [];\\n\\nfor (let i = 0; i < 20; i++) {\\n    init_cate.push(\\\"0\\\");\\n}\\n\\nconst fold = getVar(MY_RULE.group, \\\"0\\\");\\nconst cate_temp_json = getVar(MY_RULE.title+页面标识, JSON.stringify(init_cate));\\nconst cate_temp = JSON.parse(cate_temp_json);\\n\\nif (parseInt(page) === 1) {\\n    d.push({\\n        title: fold === '1' ? '““””<b>' + 分类展开.fontcolor(\\\"#FF0000\\\") + '</b>' : '““””<b>' + 分类折叠.fontcolor(\\\"#1aad19\\\") + '</b>',\\n        url: $().lazyRule((fold) => {\\n            putVar(MY_RULE.group, fold === '1' ? '0' : '1');\\n            clearMyVar('page')\\n            clearMyVar(\\\"cfpage\\\")\\n            refreshPage(false);\\n            return \\\"hiker://empty\\\"\\n        }, fold),\\n        col_type: 'scroll_button',\\n    });\\n    categoriesjson.forEach((category, index) => {\\n        let sub_categories = category.split(Json拆分);\\n        if (index === 0) {\\n            sub_categories.forEach((item, key) => {\\n                let title = item.split(Json单项)[0];\\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\");\\n                }\\n                if(title==''){\\n                  return\\n                }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: item.split(Json单项)[1] + $('#noLoading#').lazyRule((params,list,pagetab) => {\\n    \\n                    storage0.putMyVar('index',params.key)\\n\\n                    list.map(key=>{\\n                        clearMyVar(key);\\n                    })\\n                        let new_cate = []\\n                        params.cate_temp.forEach((cate, index) => {\\n                            new_cate.push(index === 0 ? params.key.toString() : \\\"0\\\")\\n     \\n                        })\\n                        putVar(MY_RULE.title+pagetab, JSON.stringify(new_cate))\\n                        putVar(pagetab, input)\\n                        putMyVar(pagetab,input)\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        key: key,\\n                        page: page,\\n                    },Json列表,页面标识),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        } else if (fold === '1') {\\n            sub_categories.forEach((item, key) => {\\n                var obj=JSON.parse(item)\\n    \\n                let title = obj['name']\\n                \\n                if (typeof(排除) != 'undefined' && 排除 != '') {\\n    \\n                    title = title.replace(new RegExp(排除, \\\"g\\\"), \\\"\\\")\\n           \\n                }\\n                   if(title==''){\\n                      return\\n                    }\\n                d.push({\\n                    title: key.toString() === cate_temp[index] ? \\\"““””\\\" + title.fontcolor(分类颜色) : title,\\n                    url: $(item+'#noLoading#').lazyRule((params,pagetab,list) => {\\n                        var obj=JSON.parse(input)\\n                        var url=obj['url']\\n                        var type=obj['type']\\n                        \\n                        list.map(key=>{\\n                        clearMyVar(key);\\n                        })\\n                        \\n                        params.cate_temp[params.index] = params.key.toString()\\n\\n                        putVar(MY_RULE.title+pagetab, JSON.stringify(params.cate_temp))\\n                        putVar(pagetab, url)\\n                        \\n                        if(type!=''?true:false){\\n                            var key=type\\n                            var value=url\\n                            storage0.putMyVar(key,value)\\n                        }\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        index: index,\\n                        key: key,\\n                        page: page,\\n                    },页面标识,单项清除),\\n                    col_type: 'scroll_button',\\n                })\\n            })\\n            d.push({\\n                col_type: \\\"blank_block\\\"\\n            });\\n        }\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"4.青麦\",\"path\":\"qimaitv\",\"rule\":\"js:\\nif (s != \\\"\\\") {\\n    var url = \\\"https://\\\" + config.qimai + \\\"/api/app/movie/index/searchMovieByName\\\";\\n\\n    let html = fetch(url, {\\n        headers: {\\n            \\\"X-Requested-With\\\": \\\"XMLHttpRequest\\\"\\n        },\\n        body: {\\n            \\\"condition\\\": s,\\n            \\\"pageSize\\\": 25,\\n            \\\"pageNum\\\": MY_PAGE\\n        }\\n    });\\n\\n    var info = ''\\n    try {\\n        info = JSON.parse(html).data.records;\\n    } catch {\\n\\n    }\\n    if (info != null) {\\n        var data = info;\\n    } else {\\n        data = []\\n        d.push({\\n            title: '““””<small>无结果</samll>',\\n            col_type: 'text_center_1'\\n        })\\n        setResult(d)\\n    }\\n    \\n    let {\\n        wrap1\\n    } = $.require(\\\"hiker://page/tool\\\");\\n    \\n    for (let item of data){\\n        var j = JSON.parse(fetch('https://' + config.qimai + '/api/app/movie/website/page', {\\n        body: {\\n            \\\"condition\\\": {\\n                movieName: item.name,\\n                movieType: item.type,\\n                movieYear: item.year\\n            },\\n            \\\"pageSize\\\": 10,\\n            \\\"pageNum\\\": MY_PAGE\\n        },\\n        method:'POST',\\n    })).data.records\\n    \\n    d.push({\\n            img:item.cover+'@Referer='+item.cover,\\n            url:'hiker://empty',\\n            col_type:'movie_1_left_pic'\\n        })\\n    \\n      for (let it of j) {\\n        let t = item.name;\\n        let web = it.name;\\n        let img = it.icon;\\n        let url = it.playUrl;\\n\\n        if (!t) {\\n            continue;\\n        }\\n        var u = \\\"hiker://page/p?u=\\\" + base64Encode(url)\\n        u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n        \\n        \\n\\n\\n        d.push({\\n            title: wrap1(web + '-' + t, s),\\n            url: u,\\n            col_type: \\\"avatar\\\",\\n            img: img,\\n            //desc: '',\\n            extra: {\\n                id: it.uri,\\n                inheritTitle: false,\\n                pageTitle: t,\\n                web: web,\\n            }\\n        });\\n      }\\n    }\\n    setResult(d)\\n} else {\\n\\n}\\n\\nif (getItem('home', '关') == '开') {\\n    var page = MY_PAGE;\\n    let {\\n        setpaged\\n    } = $.require(\\\"hiker://page/tool\\\");\\n\\n    var pindex = setpaged(d, page, \\\"qmtv_ptag\\\", [\\\"首页\\\", \\\"选片\\\"], \\\"#4682B4\\\");\\n\\n    if (pindex == 0) {\\n\\n        function setLists(item) {\\n            var title = item.split('-')[0]\\n            var t = item.split('-')[1]\\n            d.push({\\n                title: title,\\n                col_type: 'avatar',\\n                img: 'https://hikerfans.com/tubiao/more/10.png'\\n            })\\n\\n\\n            var json = JSON.parse(fetchPC(`https://${config.qimai}/api/app/movie/index/searchAllMovie`))\\n\\n\\n            var list = json.data[t].records;\\n\\n            list.map(x => {\\n                var name = x.title;\\n                d.push({\\n                    title: name,\\n                    img: x.cover,\\n                    desc: x.rate,\\n                    url: $('').lazyRule((n) => {\\n                        putMyVar(\\\"sou\\\", n)\\n                        refreshPage()\\n                        return 'hiker://empty'\\n                    }, name)\\n                })\\n            })\\n        }\\n\\n        ['热播电影-listHotMovie', '热播电视剧-listHotTv', '热播动漫-listHotComic', '热播综艺-listHotVariety'].map(x => {\\n            setLists(x)\\n        })\\n\\n    }\\n\\n\\n    if (pindex == 1) {\\n        var ojson = [{\\n            name: '电影',\\n            id: 'movie',\\n            content: {\\n                \\\"qmtv_classify\\\": [\\\"全部类型:\\\", \\\"喜剧\\\", \\\"爱情\\\", \\\"动作\\\", \\\"科幻\\\", \\\"悬疑\\\", \\\"犯罪\\\", \\\"惊悚\\\", \\\"冒险\\\", \\\"音乐\\\", \\\"历史\\\", \\\"奇幻\\\", \\\"恐怖\\\", \\\"战争\\\", \\\"传记\\\", \\\"歌舞\\\", \\\"武侠\\\", \\\"灾难\\\", \\\"西部\\\", \\\"纪录片\\\", \\\"短片\\\"],\\n                \\\"qmtv_region\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"韩国\\\", \\\"日本\\\", \\\"中国大陆\\\", \\\"美国\\\", \\\"中国香港\\\", \\\"中国台湾\\\", \\\"英国\\\", \\\"法国\\\", \\\"意大利\\\", \\\"西班牙\\\", \\\"印度\\\", \\\"泰国\\\", \\\"俄罗斯\\\"],\\n                \\\"qmtv_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2019\\\", \\\"2018\\\", \\\"2017\\\", \\\"2016\\\", \\\"2015\\\", \\\"2014\\\", \\\"2013\\\", \\\"2012\\\", \\\"2010\\\"],\\n                \\\"qmtv_sort\\\": [\\\"近期热度:time\\\", \\\"高分优先:rate\\\"],\\n            }\\n        }, {\\n            name: '电视剧',\\n            id: 'tv',\\n            content: {\\n                \\\"qmtv_classify\\\": [\\\"全部类型:\\\", \\\"喜剧\\\", \\\"爱情\\\", \\\"科幻\\\", \\\"奇幻\\\", \\\"古装\\\", \\\"战争\\\", \\\"悬疑\\\", \\\"恐怖\\\", \\\"纪录片\\\"],\\n                \\\"qmtv_genres\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"韩国\\\", \\\"日本\\\", \\\"美国\\\", \\\"英国\\\", \\\"泰国\\\"],\\n                \\\"qmtv_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2019\\\", \\\"2018\\\", \\\"2017\\\", \\\"2016\\\", \\\"2015\\\", \\\"2014\\\", \\\"2013\\\", \\\"2012\\\", \\\"2010\\\"],\\n                \\\"qmtv_sort\\\": [\\\"近期热度:time\\\", \\\"高分优先:rate\\\"],\\n            }\\n        }, {\\n            name: '动漫',\\n            id: 'anime',\\n            content: {\\n                \\\"qmtv_classify\\\": [\\\"全部类型:\\\", \\\"喜剧\\\", \\\"爱情\\\", \\\"动作\\\", \\\"科幻\\\", \\\"奇幻\\\"],\\n                \\\"qmtv_genres\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"日本\\\"],\\n                \\\"qmtv_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2019\\\", \\\"2018\\\", \\\"2017\\\", \\\"2016\\\", \\\"2015\\\", \\\"2014\\\", \\\"2013\\\", \\\"2012\\\", \\\"2010\\\"],\\n                \\\"qmtv_sort\\\": [\\\"近期热度:time\\\", \\\"高分优先:rate\\\"],\\n            }\\n        }, {\\n            name: '综艺',\\n            id: 'variety',\\n            content: {\\n                \\\"qmtv_classify\\\": [\\\"全部类型:\\\", \\\"真人秀\\\", \\\"脱口秀\\\", \\\"音乐\\\", \\\"歌舞\\\"],\\n                \\\"qmtv_genres\\\": [\\\"全部地区:\\\", \\\"华语\\\", \\\"欧美\\\", \\\"韩国\\\", \\\"日本\\\"],\\n                \\\"qmtv_year\\\": [\\\"全部年代:\\\", \\\"2023\\\", \\\"2022\\\", \\\"2021\\\", \\\"2020\\\", \\\"2019\\\", \\\"2018\\\", \\\"2017\\\", \\\"2016\\\", \\\"2015\\\", \\\"2014\\\", \\\"2013\\\", \\\"2012\\\", \\\"2010\\\"],\\n                \\\"qmtv_sort\\\": [\\\"近期热度:time\\\", \\\"高分优先:rate\\\"],\\n            }\\n        }]\\n\\n\\n        var 大类 = []\\n        ojson.map(x => {\\n            大类.push(x.name + \\\"@\\\" + x.name)\\n        })\\n\\n        var index = storage0.getMyVar(\\\"index\\\", '0')\\n\\n        var j = ojson[index]\\n        var keys = Object.keys(j.content)\\n\\n        var temp = {}\\n        keys.forEach(x => {\\n            var type = x\\n\\n            var l = j.content[x]\\n\\n            if (['area', 'lang', 'version', 'state'].includes(x)) {\\n                return\\n            }\\n\\n            if (l.length > 0) {\\n                var ns = l.map((k) => {\\n\\n                    var name = k.includes(\\\":\\\") ? k.split(':')[0] : k\\n                    var id = k.includes(\\\":\\\") ? k.split(':')[1] : k\\n                    return {\\n                        'name': name,\\n                        'url': id,\\n                        'type': x\\n                    }\\n                })\\n                temp[x] = ns\\n            }\\n        })\\n\\n        var t = Object.values(temp).map(x => x.map(z => JSON.stringify(z)).join('#'))\\n\\n\\n        var TrueJson = {\\n            type: Array(大类.join('#')),\\n            item: t != \\\"\\\" ? t : [],\\n        }\\n        //log(TrueJson)\\n\\n        //需根据实际修改\\n        const 分类颜色 = getRangeColors();\\n        const Json大类 = 'type';\\n        const Json拼接 = 'item';\\n        const Json拆分 = '#';\\n        const Json单项 = '@';\\n        const Json列表 = [\\\"qmtv_classify\\\", \\\"qmtv_genres\\\", \\\"qmtv_year\\\", \\\"qmtv_sort\\\"]; //切换清除\\n        const 单项清除 = [];\\n        const 排除 = '';\\n        const 分类展开 = '∨';\\n        const 分类折叠 = '∧';\\n        const 页面标识 = 'aiqmtv';\\n\\n\\n        //动态分类\\n        eval(JSON.parse(request('hiker://page/jdtfl')).rule)\\n\\n        var type = storage0.getMyVar(页面标识, \\\"电影\\\");\\n        var tag = storage0.getMyVar(\\\"qmtv_classify\\\", \\\"\\\");\\n        var country = storage0.getMyVar(\\\"qmtv_genres\\\", \\\"\\\");\\n        var year = storage0.getMyVar(\\\"qmtv_year\\\", \\\"\\\");\\n        var sort = storage0.getMyVar(\\\"qmtv_sort\\\", \\\"\\\");\\n\\n        body = JSON.stringify({\\n                \\\"condition\\\": {\\n                    \\\"type\\\": type,\\n                    \\\"classify\\\": tag,\\n                    \\\"region\\\": country,\\n                    \\\"sort\\\": sort,\\n                    \\\"years\\\": year,\\n                },\\n                \\\"pageNum\\\": page,\\n                \\\"pageSize\\\": 28,\\n            }\\n\\n        )\\n\\n        //log(body)\\n\\n        var json = fetch(\\\"https://\\\" + config.qimai + \\\"/api/app/movie/index/screenMovie\\\", {\\n\\n            headers: {\\n                'content-type': 'application/json',\\n                'Origin': 'http://' + config.qimai,\\n            },\\n            body: body,\\n            method: 'POST'\\n        })\\n\\n\\n        var info = [];\\n        try {\\n            info = JSON.parse(json).data.records;\\n        } catch {}\\n\\n        if (info.length > 0) {\\n            var data = info;\\n        } else {\\n            data = []\\n            d.push({\\n                title: '““””<small>无结果</samll>',\\n                col_type: 'text_center_1'\\n            })\\n            setResult(d)\\n        }\\n\\n        data.map(x => {\\n            var name = x.name;\\n            d.push({\\n                title: name,\\n                img: x.cover,\\n                desc: x.rate,\\n                url: $('').lazyRule((n) => {\\n                    putMyVar(\\\"sou\\\", n)\\n                    refreshPage()\\n                    return 'hiker://empty'\\n                }, name)\\n            })\\n        })\\n\\n    }\\n}\"}]","icon":"","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!