小程序：夸克网盘

海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@夸克网盘@{"last_chapter_rule":"","title":"夸克网盘","author":"\n","url":"hiker://empty##fypage","version":0,"col_type":"text_1","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js:\nvar d = [];\naddListener(\n    'onRefresh', $.toString(() => {\n        clearMyVar('s')\n    })\n)\n//搜索相关代码 取自云盘君,云盘君(推送)\neval(JSON.parse(fetch(\"hiker://page/sou\")).rule);\nlet s = getMyVar('s', '');\nif (s == \"\") {\n    try {\n        if (MY_PAGE == 1) {\n            header = {\n                'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.51 Mobile Safari/537.36',\n                'Host': 'top.baidu.com',\n                'Accept': 'application/json, text/plain, */*',\n                'Accept-Language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',\n                'Accept-Encoding': 'gzip, deflate, br',\n                'Referer': 'https://top.baidu.com/board?tab=novel',\n            }\n            let json;\n            d.push({\n                title: (getMyVar('topbaidu', '0') == '0' ? '☑电影热搜榜' : '电影热搜榜'),\n                url: `hiker://empty#noLoading#@lazyRule=.js:putMyVar('topbaidu','0');refreshPage();'hiker://empty'`,\n                col_type: 'flex_button'\n            }, {\n                title: (getMyVar('topbaidu', '0') == '1' ? '☑电视剧热搜榜' : '电视剧热搜榜'),\n                url: `hiker://empty#noLoading#@lazyRule=.js:putMyVar('topbaidu','1');refreshPage();'hiker://empty'`,\n                col_type: 'flex_button'\n            });\n\n            if (getMyVar('topbaidu', '0') == \"1\") {\n                if (getMyVar('dsjjson', \"\") == \"\") {\n                    json = request('https://top.baidu.com/api/board?platform=wise&tab=teleplay&tag=%7B%7D', {\n                        headers: header\n                    });\n                    putMyVar('dsjjson', json);\n                } else {\n                    json = getMyVar('dsjjson');\n                }\n            } else {\n                if (getMyVar('dyjson', '') == \"\") {\n                    json = request('https://top.baidu.com/api/board?platform=wise&tab=movie&tag=%7B%7D', {\n                        headers: header\n                    });\n                    putMyVar('dyjson', json);\n                } else {\n                    json = getMyVar('dyjson');\n                }\n            }\n            let list = JSON.parse(json).data.cards[0].content;\n\n            for (let i = 0; i < list.length; i++) {\n                let name = list[i].word + '    (' + list[i].show[2] + ')';\n                let des = list[i].desc;\n                d.push({\n                    title: i == \"0\" ? '““””<span style=\"color:#ff3300\">' + (parseInt(i) + 1).toString() + '</span>' + \"\\t\\t\\t\" + name : i == \"1\" ? '““””<span style=\"color:#ff6600\">' + (parseInt(i) + 1).toString() + '</span>' + \"\\t\\t\\t\" + name : i == \"2\" ? '““””<span style=\"color:#ff9900\">' + (parseInt(i) + 1).toString() + '</span>' + \"\\t\\t\\t\" + name : '““””<span>' + (parseInt(i) + 1).toString() + '</span>' + \"\\t\\t\\t\" + name,\n                    url: $('#noLoading#').lazyRule((name) => {\n                        name = name.split('    (')[0];\n                        putMyVar('s', name);\n                        refreshPage();\n                        return 'hiker://empty'\n                    }, name),\n                    desc: des,\n                    col_type: \"text_1\"\n                });\n            }\n        }\n    } catch (e) {}\n    setResult(d);\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?p=fypage\",\n    extra: {\n        pageTitle: \"搜索\" + key,\n        key: key\n    }\n});\n\nsetResult(d);","detail_col_type":"movie_1","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"","ua":"mobile","preRule":"","pages":"[{\"col_type\":\"movie_3\",\"name\":\"调用\",\"path\":\"share\",\"rule\":\"js:\\nvar res = {};\\nvar d = []\\nif (MY_PAGE == 1) {\\n    var 排序 = [\\\"⇅名称正序\\\", \\\"⇅名称倒序\\\", \\\"⇅时间正序\\\", \\\"⇅时间倒序\\\", ];\\n    d.push({\\n        title: getItem('排序名称', 排序[0]),\\n        url: $(排序, 1, '请选择').select(() => {\\n            setItem('排序名称', input);\\n            switch (input) {\\n                case '名称正序':\\n                    setItem('排序', 'file_name:asc');\\n                    break;\\n                case '名称倒序':\\n                    setItem('排序', 'file_name:desc')\\n                    break;\\n                case '时间正序':\\n                    setItem('排序', 'updated_at:asc')\\n                    break;\\n                case '时间倒序':\\n                    setItem('排序', 'updated_at:desc')\\n                    break;\\n            }\\n            refreshPage();\\n        }),\\n        col_type: 'text_2'\\n    })\\n    var 样式 = [\\\"列表模式\\\", \\\"文件名模式\\\"];\\n    d.push({\\n        title: getItem('样式名称', 样式[0]),\\n        url: $(样式, 1, '请选择').select(() => {\\n            setItem('样式名称', input);\\n            switch (input) {\\n                case '列表模式':\\n                    setItem('样式', 'avatar')\\n                    break;\\n                case '文件名模式':\\n                    setItem('样式', 'text_1')\\n                    break;\\n            }\\n            refreshPage();\\n        }),\\n        col_type: 'text_2'\\n    })\\n    d.push({\\n        col_type: 'line_blank'\\n    })\\n}\\n\\neval(JSON.parse(fetch('hiker://page/tools')).rule);\\n\\n//判断来路\\nif (MY_URL.includes('http')) {\\n    var pwd_id = MY_URL.match(/[0-9a-zA-Z]{12,13}/)[0];\\n    putMyVar('pwd_id', pwd_id)\\n    var fid = '';\\n    if (MY_URL.includes('##')) {\\n        var pwd = MY_URL.split('##')[1];\\n        putMyVar('pwd', pwd);\\n        addListener('onClose', $.toString(() => {\\n            clearMyVar('pwd')\\n        }))\\n    }\\n} else {\\n    var fid = MY_URL.split('??')[1]\\n}\\n//获取数据\\nvar code = JSON.parse(request(geturl()));\\n//判断token是否失效\\nif (code.message.includes('token')) {\\n    getstoken(getMyVar('pwd_id'), getMyVar('pwd'))\\n    var code = JSON.parse(request(geturl()));\\n}\\n//判断链接是否有效\\nif (code.status == 200) {\\n    //设置标题\\n    if (getPageTitle() == '🔎') {\\n        setPageTitle(code.data.share.title)\\n    }\\n    var list = code.data.list;\\n    list.forEach(item => {\\n        //判断是否文件夹\\n        if (item.dir) {\\n            d.push({\\n                title: item.file_name,\\n                desc: $.dateFormat(item.updated_at, 'yyyy-MM-dd') + '  ' + item.include_items + '项  ',\\n                img: 'https://hikerfans.com/tubiao/messy/27.svg',\\n                url: $().lazyRule((fid) => {\\n                    putMyVar('fid', fid)\\n                    return 'hiker://page/share??' + fid + '??fypage'\\n                }, item.fid),\\n                col_type: getItem('样式', 'avatar'),\\n                extra: {\\n                    inheritTitle: false\\n                }\\n            })\\n        } else {\\n            d.push({\\n                title: item.file_name,\\n                desc: $.dateFormat(item.updated_at, 'yyyy-MM-dd') + '  ' + size(item.size),\\n                img: item.thumbnail,\\n                url: $().lazyRule((fid, token, pwd_id, cate) => {\\n                    eval(JSON.parse(fetch('hiker://page/tools')).rule);\\n                    let url = 'https://pan.quark.cn/1/clouddrive/file/share/download';\\n                    var qz = '';\\n                    if (cate.match(/doc|image/)) {\\n                        url = url + '?pr=ucpro&fr=h5';\\n                        qz = 'download://';\\n                    } else\\n                    if (cate.match(/video/)) {\\n                        var bs = '#isVideo=true#'\\n                    } else\\n                    if (cate.match(/music/)) {\\n                        var bs = '#isMusic=true#'\\n                    }\\n                    let body = JSON.stringify({\\n                        fids: [fid],\\n                        pwd_id: pwd_id,\\n                        stoken: decodeURIComponent(getMyVar('stoken')),\\n                        fids_token: [token]\\n                    });\\n                    var data = JSON.parse(post(url, {\\n                        body: body\\n                    })).data[0].download_url;\\n                    return qz + data + bs\\n                }, item.fid, item.share_fid_token, getMyVar('pwd_id'), item.obj_category),\\n                col_type: getItem('样式', 'avatar'),\\n                extra: {\\n                    id: item.fid,\\n                    inheritTitle: false,\\n                    cls: 'playlist ' + item.obj_category\\n                }\\n            })\\n        }\\n        d.push({\\n            col_type: 'line'\\n        })\\n    })\\n} else {\\n    d.push({\\n        title: '““' + (getMyVar('msg', '') == '' ? code.message : getMyVar('msg', '')) + '””',\\n        url: 'hiker://empty',\\n        col_type: 'text_center_1',\\n        extra: {\\n            lineVisible: false\\n        }\\n    })\\n}\\nres.data = d;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"工具\",\"path\":\"tools\",\"rule\":\"//获取stoken\\nfunction getstoken(pwd_id, passcode) {\\n    let url = 'https://pan.quark.cn/1/clouddrive/share/sharepage/token';\\n    let body = {\\n        \\\"pwd_id\\\": pwd_id,\\n        \\\"passcode\\\": passcode\\n    };\\n    var code = JSON.parse(post(url, {\\n        body: body\\n    }));\\n    if (code.status == 200) {\\n        let stoken = code.data.stoken;\\n        stoken = encodeURIComponent(stoken)\\n        putMyVar('stoken', stoken)\\n        clearMyVar('msg')\\n        return stoken\\n    }\\n    putMyVar('msg', code.message)\\n}\\n\\n//列表链接\\nfunction geturl() {\\n    return `https://pan.quark.cn/1/clouddrive/share/sharepage/detail?pwd_id=${getMyVar('pwd_id')}&stoken=${getMyVar('stoken')}&pdir_fid=${fid}&force=0&_page=${MY_PAGE}&_size=50&_fetch_banner=1&_fetch_share=1&_fetch_total=1&_sort=file_type:asc,${getItem('排序', 'file_name:asc')}`;\\n}\\n\\n//文件大小单位转换\\nfunction size(size) {\\n    return (size / 1024 / 1024 > 1024 ? (size / 1024 / 1024 / 1024).toFixed(2) + ' GB' : (size / 1024 / 1024).toFixed(2) + ' MB')\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"规则列表\",\"path\":\"data\",\"rule\":\"let rules = [{\\n    name: \\\"趣盘搜\\\",\\n    page: true,\\n    find: function(s, page) {\\n        var d = [];\\n        var body = JSON.stringify({\\n            \\\"style\\\": \\\"get\\\",\\n            \\\"datasrc\\\": \\\"search\\\",\\n            \\\"query\\\": {\\n                \\\"id\\\": \\\"\\\",\\n                \\\"datetime\\\": \\\"\\\",\\n                \\\"commonid\\\": 1,\\n                \\\"parmid\\\": \\\"\\\",\\n                \\\"fileid\\\": \\\"\\\",\\n                \\\"reportid\\\": \\\"\\\",\\n                \\\"validid\\\": \\\"\\\",\\n                \\\"searchtext\\\": s\\n            },\\n            \\\"page\\\": {\\n                \\\"pageSize\\\": 10,\\n                \\\"pageIndex\\\": page\\n            },\\n            \\\"order\\\": {\\n                \\\"prop\\\": \\\"id\\\",\\n                \\\"order\\\": \\\"desc\\\"\\n            },\\n            \\\"message\\\": \\\"请求资源列表数据\\\"\\n        });\\n        JSON.parse(post('https://v.funletu.com/search', {\\n            body: body\\n        })).data.forEach(item => {\\n            d.push({\\n                title: item.title,\\n                desc: \\\"““””<font color=#f13b66a>趣盘搜</font>&nbsp;\\\" + item.category + ' ' + item.filetype + ' ' + item.updatetime,\\n                url: item.url + '??fypage@rule=js:$.require(\\\"hiker://page/share\\\")',\\n                col_type: 'text_1'\\n            })\\n        })\\n        return d;\\n    }\\n}, {\\n    name: \\\"爱盘搜\\\",\\n    page: true,\\n    find: function(s, page) {\\n        var d = [];\\n        var html = fetch(`https://aipanso.com/search?page=${page}&k=${s}&s=0&t=-1`);\\n        var list = pdfa(html, '#app&&a:has(van-card)');\\n        list.forEach(item => { \\n            try {\\n                var url = 'https://aipanso.com' + pdfh(item, 'a&&href');\\n                url = JSON.parse(fetch(url.replace('/s/', '/cv/'), {\\n                    headers: {\\n                        Referer: url\\n                    },\\n                    redirect: false,\\n                    withHeaders: true\\n                })).headers.location[0];\\n                d.push({   \\n                    title: pdfh(item, 'template&&Text'),\\n                    desc: \\\"““””<font color=#f13b66a>爱盘搜</font>&nbsp;\\\" + pdfh(item, 'template,1&&Text'),\\n                    url: url + '??fypage@rule=js:$.require(\\\"hiker://page/share\\\")',\\n                });\\n            } catch (e) {}\\n        })\\n        return d\\n    }\\n}, {\\n    name: \\\"口袋云\\\",\\n    page: true,\\n    find: function(s, page) {\\n        var d = [];\\n        var url = \\\"https://www.woxiangsou.com/api/v1/resInfo/search?deviceId=0&keyword=\\\" + s + \\\"&sourceType=3&timeFilter=0&sizeFilter=0&offset=\\\" + ((page - 1) * 20) + \\\"&limit=20&applyAt=0&channelId=0\\\";\\n        eval(JSON.parse(fetch('hiker://page/tools')).rule);\\n        JSON.parse(fetch(url))\\n            .resInfos.map(item => {\\n                d.push({\\n                    title: item.name,\\n                    desc: \\\"““””<font color=#f13b66a>口袋云</font>&nbsp; 时间: \\\" + $.dateFormat(item.lastUpdateTime / 1, 'yyyy-MM-dd') + ' 大小: ' + size(item.size),\\n                    url: decodeURIComponent(item.url).match(/https\\\\:\\\\/\\\\/pan.*?[0-9a-zA-Z]{12,13}/)[0] + '??fypage@rule=js:$.require(\\\"hiker://page/share\\\")',\\n                })\\n            })\\n        return d\\n    }\\n}, {\\n    name: \\\"盘搜\\\",\\n    page: true,\\n    find: function(s, page) {\\n        var d = [];\\n        var offset = page == 1 ? '' : '&offset=(page - 1) * 10';\\n\\n        var html = fetch(`https://www.pansearch.me/search?keyword=${s}${offset}&pan=quark`);\\n        var list = pdfa(html, 'body&&.break-all');\\n        list.forEach(item => { \\n            try {\\n                d.push({   \\n                    title: pdfh(item, 'Text').match(/资源名称：(.*?)描述/)[1],\\n                    desc: \\\"““””<font color=#f13b66a>盘搜</font>&nbsp;\\\" + pdfh(item, 'Text').match(/文件(.*?)分享/)[1].slice(0, -10),\\n                    url: pd(item, 'a&&href') + '??fypage@rule=js:$.require(\\\"hiker://page/share\\\")',\\n                });\\n            } catch (e) {}\\n        })\\n        return d\\n    }\\n}, {\\n    name: \\\"来搜一下\\\",\\n    page: true,\\n    find: function(s, page) {\\n        var d = [];\\n        var url = \\\"https://www.laisoyixia.com/s/search?q=\\\" + s + \\\"&currentPage=\\\" + page + \\\"&o=41\\\"\\n        pdfa(fetch(url), \\\"body&&.result-piece\\\")\\n            .map(item => {\\n                d.push({\\n                    title: pdfh(div, \\\".title&&a&&Text\\\"),\\n                    desc: \\\"““””<font color=#f13b66a>来搜一下</font>&nbsp;\\\" + pdfh(item, \\\".basic-info&&Text\\\"),\\n                    url: pdfh(item, \\\".title&&a&&href\\\") + '??fypage@rule=js:$.require(\\\"hiker://page/share\\\")',\\n                })\\n            })\\n        return d\\n    }\\n}, {\\n    //嫖的uckk云的\\n    name: \\\"小云搜索\\\",\\n    page: true,\\n    find: function(s, page) {\\n        var d = [];\\n        url = \\\"https://www.yunso.net/api/validate/search?wd=\\\" + s + \\\"&mode=90001&stype=20500&uk=&page=\\\" + page + \\\"&limit=20&screen_filetype=undefined\\\"\\n        data = '<body>' + JSON.parse(fetch(url)).data + '</body>'\\n        pdfa(String(data), \\\"body&&.layui-card\\\")\\n            .map(div => {\\n                if (pdfh(div, \\\"a&&Text\\\")) {\\n                    d.push({\\n                        title: pdfh(div, \\\"a&&Text\\\"),\\n                        desc: \\\"““””<font color=#f13b66a>小云搜索</font>&nbsp;\\\" + pdfh(div, \\\".layui-card-body&&Text\\\"),\\n                        url: base64Decode(pdfh(div, \\\"div&&url\\\")) + '??fypage@rule=js:$.require(\\\"hiker://page/share\\\")',\\n                    })\\n                }\\n            })\\n        return d\\n    }\\n}, {\\n    name: \\\"KK网盘资源\\\",\\n    page: true,\\n    find: function(s, page) {\\n        var d = [];\\n        var hash = pdfh(fetchPC('https://www.kkpans.com'), 'input[name=formhash]&&value');\\n        var url = 'https://www.kkpans.com/' + JSON.parse(post('https://www.kkpans.com/search.php?mod=forum', {\\n            body: 'formhash=' + hash + '&srchtxt=' + s + '&searchsubmit=yes',\\n\\n            redirect: false,\\n            withHeaders: true\\n        })).headers.location[0] + '&page=' + page;\\n\\n        pdfa(fetch(url), 'body&&.list').forEach(item => {\\n            var url = fetch('https://www.kkpans.com/' + pdfh(item, 'a,3&&href')).match(/https\\\\:\\\\/\\\\/pan.*?[0-9a-zA-Z]{12,13}/)[0];\\n            d.push({\\n                title: pdfh(item, '.threadlist_tit&&Text'),\\n                desc: \\\"““””<font color=#f13b66a>KK网盘资源</font>&nbsp;\\\" + pdfh(item, '.mr&&Text') + ' ' + pdfh(item, '.mtime&&Text'),\\n                url: url + '??fypage@rule=js:$.require(\\\"hiker://page/share\\\")',\\n            })\\n        })\\n        return d;\\n    }\\n}];\\n\\n//并发规则数\\nlet size = 10;\\n\\n$.exports = function(page, rule) {\\n    if (!page && !rule) {\\n        return rules.map(it => it.name);\\n    }\\n    if (rule != null) {\\n        if (page != null && page > 1) {\\n            return rules.filter(i => i.name == rule && i.page);\\n        }\\n        return rules.filter(i => i.name == rule);\\n    }\\n    let start = (page - 1) * size;\\n    if (rules.length < start + 1) {\\n        return [];\\n    }\\n    let len = size;\\n    if (rules.length < page * size) {\\n        len = rules.length - start\\n    }\\n    return rules.slice(start, start + len);\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"sou\",\"rule\":\"let r = getItem(\\\"r\\\", \\\"\\\");\\nif (MY_PAGE == 1) {\\n    d.push({\\n        title: '搜索',\\n        desc: '请输入关键词',\\n        col_type: 'input',\\n        url: $.toString(() => {\\n            if (input.includes('pan.quark.cn')) {\\n                return 'hiker://page/share??' + input + '??fypage'\\n            }\\n            putMyVar('s', input);\\n            refreshPage();\\n            return 'hiker://empty'\\n        }),\\n        extra: {\\n            defaultValue: getMyVar('s', '')\\n        }\\n    });\\n    let rules = $.require(\\\"hiker://page/data\\\")();\\n    d.push({\\n        title: \\\"\\\" == r ? \\\"““全部””\\\" : \\\"全部\\\",\\n        url: $(\\\"#noLoading#\\\").lazyRule(() => {\\n            clearItem(\\\"r\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\"\\n        }),\\n        col_type: \\\"scroll_button\\\",\\n        desc: \\\"\\\",\\n        pic_url: \\\"\\\"\\n    });\\n    for (let it of rules) {\\n        d.push({\\n            title: it == r ? \\\"““\\\" + it + \\\"””\\\" : it,\\n            url: $(\\\"#noLoading#\\\").lazyRule((r) => {\\n                setItem(\\\"r\\\", r);\\n                refreshPage();\\n                return \\\"hiker://empty\\\"\\n            }, it),\\n            col_type: \\\"scroll_button\\\",\\n            desc: \\\"\\\",\\n            pic_url: \\\"\\\"\\n        });\\n    }\\n    d.push({\\n        col_type: 'line',\\n        extra: {\\n            id: 'quark-l'\\n        }\\n    });\\n}\\nlet s = getMyVar('s', '');\\nif (s != \\\"\\\") {\\n    let p = MY_PAGE;\\n    let data = $.require(\\\"hiker://page/data\\\")(p, r != \\\"\\\" ? r : null);\\n\\n    let pageid = \\\"quark-page\\\" + p;\\n    if (data.length > 0) {\\n        d.push({\\n            title: \\\"加载第\\\" + p + \\\"页中，进度：1/\\\" + data.length,\\n            url: \\\"\\\",\\n            col_type: \\\"text_center_1\\\",\\n            desc: \\\"\\\",\\n            pic_url: \\\"\\\",\\n            extra: {\\n                id: pageid\\n            }\\n        });\\n    }\\n    setResult(d);\\n    //log(data.length);\\n    if (data.length > 0) {\\n        //多线程加载        \\n        let realPage = \\\"\\\" == r ? 1 : p;\\n        let tasks = data.map(it => {\\n            return {\\n                func: function(rule) {\\n                    return rule.find(s, realPage);\\n                },\\n                param: it,\\n                id: \\\"rule@\\\" + it.name\\n            }\\n        });\\n\\n        batchExecute(tasks, {\\n            func: function(param, id, error, result) {\\n                //log(\\\"listener: \\\" + (result || []).length)\\n                param.i = param.i + 1;\\n                if (result) {\\n                    try {\\n                        for (let it of result) {\\n                            param.j = param.j + 1;\\n                            addItemBefore(pageid, {\\n                                title: it.title.includes(\\\"““””\\\") ? it.title : \\\"““””\\\" + it.title.replace(new RegExp(\\\"<em>|</em>\\\", \\\"g\\\"), \\\"\\\").replace(new RegExp(s, \\\"g\\\"), \\\"<strong><span style=\\\\\\\"color: #1E90FF\\\\\\\">\\\" + s + \\\"</span></strong>\\\"),\\n                                desc: it.desc,\\n                                url: it.url,\\n                                pic_url: it.pic_url,\\n                                col_type: it.pic_url ? 'movie_1_vertical_pic' : \\\"text_1\\\",\\n                                extra: {\\n                                    id: \\\"__app\\\" + MY_PAGE + \\\"@\\\" + param.j,\\n                                    inheritTitle: false\\n                                }\\n                            })\\n                        }\\n                    } catch (e) {}\\n\\n                }\\n                if (param.i >= param.all) {\\n                    deleteItem(pageid)\\n                } else {\\n                    updateItem({\\n                        title: \\\"加载第\\\" + MY_PAGE + \\\"页中，进度：\\\" + (param.i + 1) + \\\"/\\\" + param.all,\\n                        url: \\\"\\\",\\n                        col_type: \\\"text_center_1\\\",\\n                        desc: \\\"\\\",\\n                        pic_url: \\\"\\\",\\n                        extra: {\\n                            id: pageid\\n                        }\\n                    })\\n                }\\n            },\\n            param: {\\n                all: data.length,\\n                i: 0,\\n                j: -1\\n            }\\n        })\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"搜索页面\",\"path\":\"soup\",\"rule\":\"js:\\nvar d = [];\\nif (MY_PARAMS.key) {\\n    putMyVar(\\\"s\\\", MY_PARAMS.key);\\n}\\neval(JSON.parse(fetch(\\\"hiker://page/sou\\\")).rule);\"}]","icon":"http://fc5tn.baidu.com/it/u=453085766,879744170&fm=203&src=787&fc_m=cvican","proxy":""}