API tools faq
paste
xiaomianao666

小程序：AI聚集

xiaomianao666
Apr 30th, 2024
187
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 109.08 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","class_name":"首页&豌豆&茶杯狐&搜片&青麦&电影狗&茶杯虎&土拨鼠","type":"tool","class_url":"home&https://www.wandou.pro/&https://cupfox.app/&http://soupian.de/&https://www.qimaitv.com/&https://www.dianyinggou.com/yingku/&https://www.725998.com/yingku&https://www.tbsdy.com/m/index.html","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                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://www.qimaitv.com/index.php?s')) {\n                    var html = fetch(input)\n                    let arr = pdfa(html, \"body&&iframe\");\n                    if (arr.length > 0) {\n                        var url = pdfh(arr[0], 'iframe&&src')\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                        }, url, MY_RULE,moban)\n                    }\n                } else if (!input.startsWith(\"https://cupfox.app/\") && !input.startsWith(\"https://51souju.com/\") &&\n                    !input.startsWith(\"https://www.dianyinggou.com/\") && !input.startsWith(\"https://www.wandou.pro/\") && !input.startsWith(\"http://soupian.xyz/\") && !input.startsWith(\"https://www.qimaitv.com/\") && !\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');","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    //back(false)\\n}));\\n\\n\\nvar BitTS=[];\\n\\n//putMyVar(\\\"muban\\\", {名称:'极客影视'})\\n\\n\\neval(JSON.parse(request('hiker://page/ztools')).rule)\\n\\nvar url = '';\\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    putMyVar('weburl', url);\\n\\n    var keys = MY_PARAMS;\\n    var from = keys.from ? keys.from : '';\\n    var dtitle = keys.pageTitle ? keys.pageTitle : '';\\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        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    var html = fetchPC(url)\\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\\n    if (dtitle != \\\"\\\") {\\n        setPageTitle(dtitle)\\n    } else if (from == 'home' ||getPageTitle().includes('详情')) {\\n        if (title != '') {\\n            if (title.includes('-')) {\\n                title = title.split('-')[0].trim()\\n            }\\n            setPageTitle(title)\\n        }\\n    }\\n\\n    let alist = pdfa(html, \\\"body&&a\\\");\\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    //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: \\\"\\\",\\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        });\\n        toast(\\\"AI匹配失败，已使用X5加载\\\");\\n        log(\\\"当前页面地址: \\\" + url)\\n        setResult(d);\\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        d2.unshift({\\n            title: \\\"推送本页=>TVBox\\\",\\n            url: $(push).lazyRule(() => {\\n                return 'hiker://page/push?pushurl=' + encodeURIComponent(input);\\n            }),\\n            col_type: \\\"scroll_button\\\"\\n        });\\n\\n\\n        d2.unshift({\\n            title: (getItem('webpush', '0') == '1' ? '单推🟢' : '单推🔴'),\\n            url: `hiker://empty@lazyRule=.js:getItem('webpush','0')=='1'?setItem('webpush','0'):setItem('webpush','1');refreshPage();'toast://切换成功！'`,\\n\\n            col_type: 'scroll_button'\\n        });\\n\\n        d2.splice(2, 0, {\\n            title: parsetype[parseInt(web)].split(':')[0],\\n            col_type: 'scroll_button',\\n            url: $('#noLoading#').lazyRule((inf) => {\\n                if (getItem('webpush', '0') == '1') {\\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        if (getItem('ai', '0') == '1') {\\n\\n            d2.unshift({\\n                title: getPageTitle(),\\n                img: ' https://pic3.58cdn.com.cn/nowater/webim/big/n_v281d60bd127e84cd28807d51143eaa61f.gif@Referer=',\\n                col_type: 'movie_1_vertical_pic_blur'\\n            })\\n        }\\n        setResult(d2)\\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.pro/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.qimaitv.com/favicon.ico', 'https://www.tbsdy.com/res/mrs/1/img/983635/2022/01/01/101.jpg']\\n\\n\\nif (MY_PAGE == 1) {\\n    ['豌豆', '茶杯狐', '搜片', '青麦', '土拨鼠'].map((x, i) => {\\n        var ix = storage0.getMyVar('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: $('').lazyRule((i) => {\\n                storage0.putMyVar('index', i)\\n                //clearMyVar('sou')\\n                clearMyVar('page')\\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: $('').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: $('').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\\n\\nif (MY_PAGE == 1) {\\n    d.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    addListener(\\\"onClose\\\", $.toString(() => {\\n        clearMyVar(\\\"sou\\\");\\n    }));\\n\\n    addListener(\\\"onRefresh\\\", $.toString(() => {\\n        clearMyVar(\\\"sou\\\");\\n        clearMyVar(\\\"durl\\\");\\n    }));\\n}\\n\\nlet s = getMyVar(\\\"sou\\\", \\\"\\\");\\nlet r = \\\"\\\";\\n\\nvar index = storage0.getMyVar('index', 0)\\n\\nswitch (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        break;\\n    case 4:\\n        eval(JSON.parse(request('hiker://page/tbsdy')).rule)\\n        break;\\n}\\n\\n\\n\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"工具\",\"path\":\"tool\",\"rule\":\"function 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$.exports = {\\n    wrap: wrap,\\n    wrap1: wrap1,\\n    rehtml: removehtml,\\n    merge: merge\\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://soupian.de/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        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://soupian.de/', {})\\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://lanmeiguojiang.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.pro' + 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://api.xiamm.cc/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.pro\\\" + 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} else {\\n\\n}\\n\\n\\nif (getItem('home', '关') == '开') {\\n    var html = fetch('https://www.wandou.pro/')\\n    let json = JSON.parse(pdfh(html, \\\"body&&#__NEXT_DATA__&&Html\\\"));\\n\\n\\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://lanmeiguojiang.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}\"},{\"col_type\":\"movie_3\",\"name\":\"2.茶杯狐\",\"path\":\"cupfox\",\"rule\":\"js:\\n\\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\\nvar html = fetchPC('https://cupfox.app/', {})\\n\\n\\nfunction 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://lanmeiguojiang.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\"},{\"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 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\"},{\"col_type\":\"movie_3\",\"name\":\"4.青麦\",\"path\":\"qimaitv\",\"rule\":\"js:\\nif (s != \\\"\\\") {\\n    MY_URL = \\\"https://www.qimaitv.com/index.php?s=api&c=api&m=getplaylist&title=\\\" + s + \\\"&id=undefined&page=\\\"+MY_PAGE;\\n    let html = fetch(MY_URL, {\\n        headers: {\\n            \\\"X-Requested-With\\\": \\\"XMLHttpRequest\\\"\\n        }\\n    });\\n    var info = ''\\n    try {\\n        info = JSON.parse(html).info;\\n    } catch {\\n\\n    }\\n    if (info != null) {\\n        var data = pdfa(info, \\\"body&&a\\\");\\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    for (let it of data) {\\n        let t = pdfh(it, \\\"h4&&Text\\\");\\n        let web = pdfh(it, '.label-1&&Text');\\n        let img = pd(it, 'img&&src');\\n        if (!t) {\\n            continue;\\n        }\\n        var u = \\\"hiker://page/p?u=\\\" + base64Encode(pd(it, \\\"a&&href\\\"))\\n        u = getItem('ai', '0') == '0' ? u : u + '#immersiveTheme#'\\n        d.push({\\n            title: wrap1(web + '-' + t, s),\\n            url: u,\\n            col_type: \\\"avatar\\\",\\n            img:img,\\n            //desc: (pdfa(it, \\\"a&&span\\\") || []).map(i => pdfh(i, \\\"Text\\\")).join(\\\" \\\"),\\n            pic_url: \\\"\\\",\\n            extra: {\\n                id: pd(it, \\\"a&&href\\\"),\\n                inheritTitle: false,\\n                pageTitle: t,\\n                web:web,\\n            }\\n        });\\n    }\\n    setResult(d)\\n} else {\\n\\n}\\n\\nif (getItem('home', '关') == '开') {\\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://lanmeiguojiang.com/tubiao/more/10.png'\\n        })\\n\\n        var html = JSON.parse(fetch(`http://www.qimaitv.com/index.php?s=movie&c=home&m=getmovie&type=%E7%83%AD%E9%97%A8&catid=${t}`)).html\\n\\n        var list = pdfa(html, `body&&.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    ['热播电影-1', '热播电视剧-2', '热播动漫-3', '热播综艺-5'].map(x => {\\n        setLists(x)\\n    })\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"函数2\",\"path\":\"ztools\",\"rule\":\"js:\\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\\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}\"},{\"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=[]\\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\\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                            }\\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://lanmeiguojiang.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://lanmeiguojiang.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\":\"js:\\nconst 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>' + 'W'.fontcolor(\\\"#FF0000\\\") + '</b>' : '““””<b>' + 'M'.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    })\\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(MY_RULE.title, JSON.stringify(new_cate))\\n                        putMyVar(MY_RULE.url, input)\\n                        refreshPage(true)\\n                        return \\\"hiker://empty\\\"\\n                    }, {\\n                        cate_temp: cate_temp,\\n                        key: key,\\n                        page: page,\\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(MY_RULE.title, JSON.stringify(params.cate_temp))\\n                        putMyVar(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                    }),\\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&&src'),\\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    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&&src');\\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}\"}]","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!