API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：HG影视-三体

xiaomianao666
Jan 19th, 2023
831
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 212.79 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥HG影视-三体@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"js:\\neval(JSON.parse(fetch('hiker://page/chapter', {})).rule);\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"接口数据2022/10/12\",\"path\":\"ResCode\",\"rule\":\"优质@暖光影视=https://app.bl210.com/api.php/v1.vod#暖光影视\\n优质@奈非迷=https://app.netflixmi.com/api.php/v1.vod#奈非迷影视\\n优质@美剧范=http://ttzmz.net/api.php/v1.vod#美剧范\\n优质@零刻影院=https://ys.ling00.cn/api.php/v1.vod#零刻影院\\n优质@段友影视=https://shangjihuoke.com/api.php/tv.vod#段友影视\\n优质@独播社=http://35ys.cc/api.php/v1.vod#独播社\\n优质@创意影视=https://www.30dian.cn/api.php/v1.vod#创意影视\\n优质@嗷呜视频=http://www.cx99999.cn/lvdou_api.php/v1.vod#嗷呜视频\\n优质@爱麻花影视=http://v.jiexi.work/qingdoujiekou.php/v1.vod#爱麻花影视\\n优质@爱酷影视=https://www.zhanlangbu.com/ruifenglb_api.php/v1.vod#爱酷影视\\n优质@HG影视=http://bbq.1006.tk/api.php/v1.vod#HG影视\\n优质@F7高清=http://bc.haokanju1.cc/lvdou_api.php/v1.vod#F7高清\\n普通@追剧影院=http://82.157.98.129/lvdou_api.php/v1.vod#追剧影院\\n普通@追剧吧=http://117.50.163.45:88/lvdou_api.php/v1.vod#追剧吧\\n普通@追剧TV=http://111.229.120.180:88/lvdou_api.php/v2.vod#追剧TV\\n普通@渔渔影视=http://luobo.yugenye.site/api.php/v1.vod#渔渔影视\\n普通@余生影视=http://yu.cuicanys.cn/lvdou_api.php/v1.vod#余生影视\\n普通@影视猫=https://vip.wscyun.com/api.php/v1.vod#影视猫\\n普通@影视大全=https://xc.xixi2yy.xyz/mogai_api.php/v1.vod#影视大全HD\\n普通@呀哩动漫=https://app.yaliyali.cc/api.php/v1.vod#呀哩动漫\\n普通@影库=https://yingkudy.com/lvdou_api.php/v1.vod#影库\\n普通@月儿影视=https://yue52.xyz/api.php/v1.vod#\\n普通@星宿漫=http://3.xingxiuman.com/mogai_api.php/v1.vod#星宿漫\\n普通@小鸟动漫=http://xydm.baicai.buzz/mogai_api.php/v1.vod#小鸟动漫\\n普通@熊猫视频=http://anegh.com/lvdou_api.php/v1.vod#熊猫视频\\n普通@熊猫动漫=http://dongman.k8aa.com/mogai_api.php/v1.vod#熊猫动漫\\n普通@万能影院=http://app.wnvod.net/lvdou_api.php/v1.vod#万能影院\\n普通@蜗牛动漫=http://woniudm.woniu.cyou:20000/mogai_api.php/v1.vod#蜗牛动漫\\n普通@我爱跟剧=https://www.genmov.com/mogai_api.php/v1.vod#我爱跟剧\\n普通@淘剧社=https://app.shuhai99.com/api.php/v1.vod#淘剧社\\n普通@群鑫影视=http://www.qunxinys.com/api.php/v1.vod#群鑫影视\\n普通@龙猫追剧=https://lb.ybnxcx.com/api.php/v1.vod#\\n普通@看剧吧=http://app.ishen520.com/api.php/v1.vod#看剧吧\\n普通@寒枫视频=https://vip.shenyunwl.cn/mogai_api.php/v1.vod#寒枫视频\\n普通@艾思影视=https://www.aitee.cc/api.php/v1.vod#\\n普通@阿里影视=http://aliys.cn:90/api.php/v1.vod#阿里影视\\n普通@爱电影=https://www.idianying.com.cn/mogai_api.php/v1.vod#爱电影\\n普通@OK影视=http://123.ok00.xyz/api.php/v1.vod#OK影视\\n普通@MX影视=http://mkk.gotka.top/api.php/v1.vod#\\n普通@69美剧=https://www.69mj.com/api.php/v1.vod#\\n神马@影视阁=http://216.98.10.85/api.php/iptv/vod/#影视阁\\n神马@天空TV=http://tv.tkys.tv/api.php/iptv/vod/#天空TV\\n神马@芒迅TV=http://www.hdyangtv.com/api.php/iptv/vod/#芒迅TV\\n神马@猫咪TV=http://106.12.113.90:6565/api.php/iptv/vod/#猫咪TV\\n神马@黑龙影视=http://vip.ji-ding-he.site/api.php/iptv/vod/#黑龙影视\\n神马@贵宾影院=https://vipdytv.com/api.php/iptv/vod/#\\n神马@爱西西TV=http://tv2.aixixi.vip/api.php/iptv/vod/#爱西西TV\\n神马@CV影视=http://www.cccvvv.top/api.php/iptv/vod/#CV影视\\n神马@2号币=http://phoebe.cf/api.php/iptv/vod/#2号币影院\"},{\"col_type\":\"movie_3\",\"name\":\"搜索\",\"path\":\"sear\",\"rule\":\"var res = {};\\nvar items = [];\\n//设置搜索线程\\nvar ssmode = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\nvar key = MY_URL.split('$$$')[1];\\n//setError(le);\\nif (ssmode == '0') {\\n    setPageTitle(key + ' 的搜索结果')\\n};\\ntry {\\n    if (getItem('clmode', '1') == 1) {\\n        var one = fetch('hiker://files/rules/xyq/APPMovie.txt');\\n    } else {\\n        var one = fetchCache('', 24);\\n    }\\n    //log(two +'\\\\n'+ one);\\n    if (/\\\\=http/.test(one)) {\\n        var remfile = one;\\n    } else {\\n        log('当前加载的是内置数据');\\n        var remfile = JSON.parse(fetch('hiker://page/ResCode', {})).rule;\\n    }\\n} catch (e) {\\n    log('当前加载的是内置数据');\\n    var remfile = JSON.parse(fetch('hiker://page/ResCode', {})).rule;\\n};\\nif (/\\\\=http/.test(remfile)) {\\n    eval(JSON.parse(fetch('hiker://page/conver', {})).rule);\\n    remfile = JSON.stringify(newfile);\\n}\\nvar html = JSON.parse(remfile);\\n\\nvar dlist = html.data;\\n\\nif (ssmode == '1' || MY_TYPE == 'home') {\\n    for (var l = 0; l < dlist.length; l++) {\\n        var list = dlist[l].list;\\n        var tytit = dlist[l].title;\\n\\n        items.push({\\n            title: MY_TYPE == \\\"home\\\" ? \\\"点击查看 \\\" + tytit + \\\" 分类 ““\\\" + key + \\\"”” 的聚搜结果\\\" : \\\"点击查看 \\\" + tytit + \\\" 分类 \\\" + key + \\\" 的聚搜结果\\\",\\n            url: \\\"hiker://page/ss2\\\",\\n            col_type: 'text_1',\\n            extra: {\\n                list: list,\\n                tytit: tytit,\\n                url: 'hiker://empty$$$' + key + '$$$fypage$$$'\\n            }\\n        });\\n\\n    } //for i\\n}; //end mode 1\\n\\nif (ssmode == '0' || MY_TYPE == 'home') {\\n    for (var i = 0; i < dlist.length; i++) {\\n        var list = dlist[i].list;\\n        var tytit = dlist[i].title;\\n\\n        items.push({\\n            title: MY_TYPE == \\\"home\\\" ? \\\" 选择一个 \\\" + dlist[i].title + \\\" 项目查看 ““\\\" + key + \\\"”” 的搜索结果\\\" : \\\" 选择一个 \\\" + dlist[i].title + \\\" 项目查看 \\\" + key + \\\" 的搜索结果\\\",\\n            col_type: 'text_1'\\n        });\\n\\n        for (var j = 0; j < list.length; j++) {\\n            var link = list[j].url;\\n            var litit = list[j].murl;\\n            if (/\\\\/vod\\\\//.test(link)) {\\n                if (/37\\\\.161|216\\\\.98|phoebe|hfys8|feifan12|tvzy|hdyangtv|tkys|tegouys/.test(link)) {\\n                    var hmurl = link + '?ac=list&zm=' + key + '&page=fypage';\\n                } else {\\n                    var hmurl = link + '?ac=list&wd=' + key + '&page=fypage';\\n                }\\n            } else {\\n                if (/dijiaxia/.test(link)) {\\n                    link = 'http://www.dijiaxia.com/api.php/app/'\\n                };\\n                if (link.indexOf('api.php/app/') != -1) {\\n                    var hmurl = link + 'search?pg=fypage&text=' + key + '&token=';\\n                } else if (link.indexOf('xgapp.php/v1/') != -1) {\\n                    var hmurl = link + 'search?pg=fypage&text=' + key;\\n                } else {\\n                    if (/iopenyun/.test(link)) {\\n                        var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\n                    } else {\\n                        var hmurl = link + '?page=fypage&limit=10&wd=' + key;\\n                    }\\n                }\\n            }\\n            items.push({\\n                title: list[j].title,\\n                img: list[j].img,\\n                url: $('hiker://empty#x#' + hmurl + '#x#' + link + '#x#' + litit + '#x#' + key + '#x#').rule(() => {\\n                    $.require('hiker://page/searerj');\\n                }),\\n                col_type: 'icon_round_small_4'\\n                //col_type: 'text_3'\\n                //link:link,\\n                //type: i\\n            });\\n\\n        } //for j\\n\\n\\n    } //for i\\n\\n} //end mode 0\\n\\n\\nres.data = items;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"APP分类列表\",\"path\":\"applistdata\",\"rule\":\"if (html.list) {\\n    var list = html.list;\\n} else if (html.data && html.data.list) {\\n    var list = html.data.list;\\n} else {\\n    var list = html.data;\\n}\\n//log(list);\\nfor (var i = 0; i < list.length; i++) {\\n    var title = list[i].vod_name;\\n    var img = list[i].vod_pic;\\n    var url = list[i].vod_id;\\n    var desc = list[i].vod_remarks;\\n    var nowDate = new Date();\\n    var month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\n    var day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\n    var dateStr = month + '' + day;\\n    if (html.list) {\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    } else if (html.data && html.data.list) {\\n        if (murl.search(/mogai_api/) != -1) {\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else if (murl.includes('grelighting')) {\\n            var link = murl + '/?ids=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else {\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\n        }\\n    } else {\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    };\\n    if (/fantuan/.test(murl)) {\\n        var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    } else if (/iopenyun/.test(murl)) {\\n        var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n    } else if (/dijiaxia/.test(murl)) {\\n        var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\n    }\\n    items.push({\\n        title: title,\\n        pic_url: img + '@Referer=',\\n        url: $(link).rule(() => {\\n            var res = {};\\n            var items = [];\\n            items.push({\\n                title: '',\\n                desc: '255&&float',\\n                url: '',\\n                col_type: 'x5_webview_single'\\n            });\\n            refreshX5WebView('');\\n            var html = JSON.parse(getResCode());\\n            var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n            try {\\n                eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n            } catch (e) {}\\n            res.data = items;\\n            setHomeResult(res);\\n        }),\\n        desc: desc,\\n        col_type: 'movie_3_marquee'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"TV列表解析\",\"path\":\"tvlistdata\",\"rule\":\"var list = html.data;\\nfor (var i = 0; i < list.length; i++) {\\n    var title = list[i].title;\\n    var img = list[i].pic;\\n    var url = list[i].nextlink;\\n    var desc = list[i].state;\\n    url = url.startsWith('http') ? url : murl + '?ac=detail&ids=' + url;\\n    items.push({\\n        title: title,\\n        pic_url: img + '@Referer=',\\n        url: $(url).rule(() => {\\n            var res = {};\\n            var items = [];\\n            var html = JSON.parse(getResCode());\\n            var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n            items.push({\\n                title: '',\\n                desc: '255&&float',\\n                url: '',\\n                col_type: 'x5_webview_single'\\n            });\\n            refreshX5WebView('');\\n            try {\\n            eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\n            } catch (e) {}\\n            res.data = items;\\n            setHomeResult(res);\\n        }),\\n        desc: desc,\\n        col_type: 'movie_3_marquee'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"APP简介与选集\",\"path\":\"appmovlist\",\"rule\":\"if (html.data.vod_url_with_player) {\\n    var conts = html.data.vod_url_with_player;\\n    if (conts.length < 1) {\\n        conts = html.data.vod_play_url.split('$$$');\\n        var tabs = html.data.vod_play_from.split('$$$');\\n    }\\n} else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n    var conts = html.data.vod_info.vod_url_with_player;\\n    if (conts.length < 1) {\\n        conts = html.data.vod_info.vod_play_url.split('$$$');\\n        var tabs = html.data.vod_info.vod_play_from.split('$$$');\\n    }\\n} else if (html.data.list) {\\n    var conts = html.data.list[0].vod_play_url.split('$$$');\\n    var tabs = html.data.list[0].vod_play_from.split('$$$');\\n} else if (html.data.length == 1) {\\n    var conts = html.data[0].vod_play_list;\\n    //log(conts);\\n    if (conts.length < 1) {\\n        conts = html.data[0].vod_play_url.split('$$$');\\n        var tabs = html.data[0].vod_play_from.split('$$$');\\n    }\\n} else {\\n    var conts = html.data.vod_play_list;\\n    if (conts.length < 1) {\\n        conts = html.data.vod_play_url.split('$$$');\\n        var tabs = html.data.vod_play_from.split('$$$');\\n    }\\n};\\n\\n//log(html);\\n\\nif (html.data.length == 1) {\\n    var thumb = html.data[0].vod_pic;\\n    var des = html.data[0].vod_content;\\n} else if (html.data.list) {\\n    var thumb = html.data.list[0].vod_pic;\\n    var des = html.data.list[0].vod_content;\\n} else {\\n    var thumb = html.data.vod_info ? html.data.vod_info.vod_pic : html.data.vod_pic;\\n    var des = html.data.vod_info ? html.data.vod_info.vod_content : html.data.vod_content;\\n};\\nitems.push({\\n    title: '剧情简介：',\\n    desc: des,\\n    pic_url: thumb,\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\n        setResult([{\\n            title: des,\\n            col_type: 'long_text'\\n        }]);\\n    }, des),\\n    col_type: 'movie_1_vertical_pic'\\n});\\neval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\n\\nitems.push({\\n    title: '““排序””',\\n    url: \\\"hiker://empty@lazyRule=.js:putMyVar('appmappsort', getMyVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\",\\n    col_type: 'scroll_button'\\n});\\nvar title = MY_URL;\\nfor (var k = 0; k < conts.length; k++) {\\n    //setError(list.length);\\n    if (html.data.vod_url_with_player) {\\n        var ptab = conts[k].code ? conts[k].code : tabs[k];\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n        var ptab = conts[k].code ? conts[k].code : tabs[k];\\n    } else {\\n        var ptab = conts[k].from ? conts[k].from : tabs[k];\\n    }\\n    items.push({\\n        title: (getMyVar(title, '0') == k ? '👉🏻' : '') + ptab,\\n        url: `hiker://empty@lazyRule=.js:putMyVar('` + title + \\\"', '\\\" + k + `');refreshPage();'toast://切换成功！'`,\\n        col_type: 'scroll_button'\\n    });\\n\\n}\\n\\n\\n\\nvar jiek = '';\\n//for (var i = 0; i < conts.length; i++) {\\nif (getMyVar('appmappsort', '1') == '1') {\\n    if (conts[getMyVar(title, '0')].urls) {\\n        var list = conts[getMyVar(title, '0')].urls;\\n    } else if (conts[getMyVar(title, '0')].url) {\\n        var list = conts[getMyVar(title, '0')].url.split(\\\"#\\\");\\n    } else {\\n        var list = conts[getMyVar(title, '0')].split(\\\"#\\\");\\n    };\\n} else {\\n    if (conts[getMyVar(title, '0')].urls) {\\n        var list = conts[getMyVar(title, '0')].urls.reverse();\\n    } else if (conts[getMyVar(title, '0')].url) {\\n        var list = conts[getMyVar(title, '0')].url.split(\\\"#\\\").reverse();\\n    } else {\\n        var list = conts[getMyVar(title, '0')].split(\\\"#\\\").reverse();\\n    }\\n};\\n//setError(list.length);\\nif (html.data.vod_url_with_player) {\\n    var ptab = conts[getMyVar(title, '0')].code ? conts[getMyVar(title, '0')].code : tabs[getMyVar(title, '0')];\\n} else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n    var ptab = conts[getMyVar(title, '0')].code ? conts[getMyVar(title, '0')].code : tabs[getMyVar(title, '0')];\\n} else {\\n    var ptab = conts[getMyVar(title, '0')].from ? conts[getMyVar(title, '0')].from : tabs[getMyVar(title, '0')];\\n}\\n/*\\n    items.push({\\n        title: ptab + ' 🔗' + [i + 1] + '/' + [conts.length] + \\\"““↓↑””\\\",\\n        url: \\\"hiker://empty@lazyRule=.js:putVar('appmappsort', getVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\",\\n        col_type: 'scroll_button'\\n    });*/\\nvar vlink = {};\\nfor (var j = 0; j < list.length; j++) {\\n    if (conts[getMyVar(title, '0')].urls) {\\n        var vlink = list[j].url.replace(/#456#/g, 'http').replace(/#123#/g, '.').replace(/#789#/g, ':');\\n        var vtitle = list[j].name;\\n    } else {\\n        //var vlink = list[j].split(\\\"$\\\")[1];\\n        if (list[j].split('$')[1] != null) {\\n            vlink = list[j].split('$')[1];\\n        } else {\\n            vlink = list[j].split('$')[0];\\n        }\\n        //var title = list[j].split(\\\"$\\\")[0];                               \\n        var vtitle = (list[j].split('$')[0].includes('http') ? [j + 1] : list[j].split('$')[0]);\\n    }\\n    try {\\n        if (html.data.vod_url_with_player) {\\n            var jiek = conts[getMyVar(title, '0')].parse_api;\\n        } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n            var jiek = conts[getMyVar(title, '0')].parse_api;\\n        } else {\\n            if (conts[getMyVar(title, '0')].player_info.parse2 && (conts[getMyVar(title, '0')].player_info.parse2).indexOf(\\\"=\\\") != -1) {\\n                var jiek = (conts[getMyVar(title, '0')].player_info.parse2).replace(/\\\\.\\\\./g, \\\".\\\").split(',')[0].replace('jsonbs', '');\\n            } else if (conts[getMyVar(title, '0')].player_info.parse && (conts[getMyVar(title, '0')].player_info.parse).indexOf(\\\"=\\\") != -1) {\\n                var jiek = (conts[getMyVar(title, '0')].player_info.parse).replace(/\\\\.\\\\./g, \\\".\\\").split(',')[0];\\n            } else {\\n                var jiek = \\\"\\\";\\n            }\\n            //setError(jiek);                \\n        }\\n    } catch (e) {}\\n    //jiek拼接\\n    if (jiek != '' && jiek != null) {\\n        if (jiek.substring(0, 4) == 'http') {\\n            jiek = jiek;\\n        } else if (jiek.substring(0, 2) == '\\\\/\\\\/') {\\n            jiek = 'https:' + jiek;\\n        }\\n    } else {\\n        jiek = \\\"\\\";\\n    }\\n    //对失效接口进行替换\\n    if (/cokemv/.test(myurl) && /cokeqie|xin|90mm/.test(ptab)) {\\n        jiek = 'https://player.90mm.me/play.php?url=';\\n    } else if (/\\\\.m3u8\\\\.tv|www\\\\.x-n\\\\.cc/.test(jiek)) {\\n        jiek = 'https://jx.m3u8.tv/jiexi/?url=';\\n    } else if (/cjt521/.test(myurl)) {\\n        jiek = conts[getMyVar(title, '0')].player_info.parse;\\n    } else if (jiek.indexOf('jpg.hou.lu/jm/za/index.php') != -1) {\\n        jiek = 'http://vip.mengx.vip/home/api?type=ys&uid=3249696&key=aefqrtuwxyEFHKNOQY&url=';\\n    } else if (ptab == 'renrenmi' && jiek.search(/jhdyw/) != -1) {\\n        jiek = 'http://www.1080kan.cc/jiexi/rrmi.php?url=';\\n    } else if (ptab == 'fqfilm' && jiek.search(/jhdyw/) != -1) {\\n        jiek = 'http://www.1080kan.cc/jiexi/fq.php?url=';\\n    } else if (ptab == 'rrsp' && jiek.search(/jhdyw/) != -1) {\\n        jiek = 'http://www.1080kan.cc/jiexi/rr.php?url=';\\n    } else if (/miaoparty/.test(ptab) && myurl.search(/fun4k/) != -1) {\\n        jiek = 'https://www.fun4k.com/aplayer/?url=';\\n    } else if (/jhyun\\\\.php/.test(jiek)) {\\n        jiek = jiek.replace('http://svip.jhyun.jx.cn:1234/jhyun.php?url=', 'https://api.jhdyw.vip/?url=');\\n    } else if (/www\\\\.ailemo\\\\.me/.test(jiek)) {\\n        jiek = jiek.replace('ailemo', 'ailemoo');\\n    };\\n    //打印接口\\n    try {\\n        if (j == '0') {\\n            if (html.data.vod_url_with_player) {\\n                log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + jiek);\\n            } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n                log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + jiek);\\n            } else {\\n                if (conts[getMyVar(title, '0')].player_info.parse2 && (conts[getMyVar(title, '0')].player_info.parse2).indexOf(\\\"=\\\") != -1) {\\n                    log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + conts[getMyVar(title, '0')].player_info.parse2.replace(/\\\\.\\\\./g, \\\".\\\").replace(/\\\\,/g, \\\"\\\\n\\\\n\\\"));\\n                } else if (conts[getMyVar(title, '0')].player_info.parse && (conts[getMyVar(title, '0')].player_info.parse).indexOf(\\\"=\\\") != -1) {\\n                    log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + conts[getMyVar(title, '0')].player_info.parse.replace(/\\\\.\\\\./g, \\\".\\\").replace(/\\\\,/g, \\\"\\\\n\\\\n\\\"));\\n                } else {\\n                    log('\\\\n线路：' + ptab + '\\\\n视频：' + vlink + '\\\\n' + '解析接口：\\\\n' + jiek);\\n                }\\n                //setError(jiek);                \\n            }\\n        }\\n    } catch (e) {}\\n    //声明链接\\n    var link = jiek + vlink;\\n    /*\\n    if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos/.test(vlink) && /http/.test(vlink)) {\\n        link = vlink;\\n    }\\n    */\\n    //log(link);\\n\\n    try {\\n        vtitle = vtitle.match(/(第|\\\\d|-)*(集|话|期)/g) ? vtitle.replace(/第|集|话|期/g, '') : vtitle.replace(/^\\\\s*/, \\\"\\\");\\n    } catch (e) {}\\n\\n    if (list.length <= 4) {\\n        var clt = 'text_2';\\n    } else {\\n        var clt = isNaN(vtitle) ? 'flex_button' : 'text_5'\\n    };\\n    items.push({\\n        title: vtitle,\\n        url: $('hiker://empty').lazyRule((ptab, link, myurl, vlink) => {\\n                function openurl(resurl) {\\n                    if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili|ixigua/) != -1) {\\n                        //html网页调用断插解析\\n                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                        if (enDn == '1') {\\n                            log('调用断插解析html');\\n                            eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                            eval(fetch(config.cj));\\n                            return aytmParse(resurl);\\n                        } else {\\n                            return resurl\\n                        };\\n                    } else if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(resurl) && /http/.test(resurl) && !/\\\\.html|\\\\.m3u8\\\\.tv/.test(resurl) && !/\\\\=http/.test(resurl) && ptab != 'duoduozy') {\\n                        if (/wkfile/.test(resurl)) {\\n                            return resurl + ';{Referer@https://fantuan.wkfile.com/}'\\n                        } else {\\n                            return /\\\\=ht/.test(resurl) ? resurl.substring(resurl.indexOf('=ht') + 1) : resurl + '#isVideo=true#';\\n                        }\\n                    } else {\\n                        //调用断插通用函数解析\\n                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                        if (enDn == '1') {\\n                            log('调用断插通用函数解析\\\\n' + ptab + '(通用函数)');\\n                            eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                            eval(fetch(config.cj));\\n                            var name = ptab + '(通用函数)';\\n                            return ParseS[name](resurl, myurl);\\n\\n                        } else if (ptab == 'ddzy') {\\n                            function getrandom(urlstr) {\\n                                randStr = urlstr.substring(0, 8);\\n                                string = urlstr.substring(8, urlstr.length);\\n                                substr = base64Decode(string);\\n                                return substr.substring(8, substr.length - 8);\\n                            };\\n                            var jxhtml = request(\\\"https://play.suoyou.cc/xplay/?url=\\\" + vlink, {\\n                                headers: {\\n                                    \\\"Referer\\\": \\\"https://www.jubaibai.cc/\\\"\\n                                }\\n                            });\\n                            eval(jxhtml.match(/var config[\\\\s\\\\S]*?}/)[0]);\\n                            var ddwy = post(\\\"https://play.suoyou.cc/xplay/hd0L3TjH4m8zSK1N.jpg\\\", {\\n                                headers: {\\n                                    \\\"User-Agent\\\": MOBILE_UA\\n                                },\\n                                body: {\\n                                    \\\"url\\\": config.url,\\n                                    \\\"vkey\\\": config.vkey,\\n                                    \\\"token\\\": config.token\\n                                }\\n                            });\\n                            return getrandom(JSON.parse(ddwy).url);\\n                        } else if (/miaoparty/.test(ptab)) {\\n                            requireCache('https://agit.ai/lzk23559/PublicRule/raw/branch/master/x5rule.js', 24);\\n                            return x5rule('https://www.fun4k.com/aplayer/?url=' + resurl);\\n                        } else {\\n                            return resurl\\n                        };\\n                    }\\n                };\\n\\n                try {\\n                    /*\\n                                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                                        if (enDn == '1' && vlink.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && vlink.search(/html|bilibili|ixigua/) != -1) {\\n                                            log('已开启断插，将调用断插解析html');\\n                                            eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                                            eval(fetch(config.cj));\\n                                            return aytmParse(vlink);\\n                                        };*/\\n                } catch (e) {}\\n\\n                var srcurl = link;\\n                //log(srcurl);\\n                //动态解析代码开始\\n                try {\\n                    //处理指定视频与线路\\n                    if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos|netease\\\\.com/.test(srcurl) && /http/.test(srcurl) && !/\\\\.html|\\\\.m3u8\\\\./.test(srcurl) && !/\\\\=http/.test(srcurl)) {\\n                        if (/wkfile/.test(srcurl)) {\\n                            return srcurl + ';{Referer@https://fantuan.wkfile.com/}'\\n                        } else {\\n                            return /\\\\=ht/.test(srcurl) ? srcurl.substring(srcurl.indexOf('=ht') + 1) : srcurl + '#isVideo=true#';\\n                        }\\n                    } else if (/hd8\\\\.pw/.test(vlink) && /\\\\.m3u8|\\\\.mp4/.test(vlink)) {\\n                        return vlink;\\n                    } else if (srcurl.indexOf(\\\"/share/\\\") != -1) {\\n                        try {\\n                            var link = srcurl.split(\\\"/share\\\")[0];\\n                            var fc = fetch(srcurl, {}).replace(\\\"var purl\\\", \\\"var main\\\");\\n                            if (fc.indexOf(\\\"main\\\") != -1) {\\n                                var mat = fc.match(/var main.*?;/)[0];\\n                                eval(mat);\\n                                var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main);\\n                            } else {\\n                                var main = fc.match(/url:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1];\\n                                var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main)\\n                            };\\n                            return play;\\n                        } catch (e) {\\n                            return 'x5WebView://' + (srcurl)\\n                        }\\n\\n                    } else if (/983vip/.test(srcurl)) {\\n                        return JSON.parse(fetch(srcurl, {\\n                            headers: {\\n                                \\\"User-Agent\\\": MOBILE_UA\\n                            },\\n                            redirect: false,\\n                            withHeaders: true\\n                        })).headers.location[0];\\n                    } else if (/x\\\\-n\\\\.cc|nhdz666/.test(srcurl) && /\\\\.html|bilibili/.test(srcurl)) {\\n                        return openurl(vlink);\\n                    }\\n                    //处理指定视频和线路结束\\n                    //----分割线----//\\n                    var scode = JSON.parse(fetch(srcurl, {\\n                        headers: {\\n                            \\\"User-Agent\\\": \\\"okhttp/4.1.0\\\"\\n                        },\\n                        redirect: false,\\n                        withStatusCode: true\\n                    }));\\n                    //log(scode);\\n                    if (scode.statusCode == '302' || scode.statusCode == '301') {\\n                        //打开解析有302重定向的链接\\n                        var redurl = scode.headers.location[0].replace(/\\\\\\\\/g, '');\\n                        if (/\\\\=http/.test(redurl) && /html|bilibili|key\\\\=/.test(redurl)) {\\n                            return JSON.parse(fetch(redurl, {})).url;\\n                        } else if (/\\\\=http/.test(redurl) && /\\\\.m3u8|\\\\.mp4|\\\\.flv/.test(redurl)) {\\n                            return redurl.substring(redurl.indexOf('=http') + 1);\\n                        } else if (/http/.test(redurl) && /key\\\\=|uid\\\\=|vid\\\\=/.test(redurl)) {\\n                            return JSON.parse(fetch(redurl, {})).url;\\n                        } else if (/http/.test(redurl) && /html|bilibili/.test(redurl)) {\\n                            return openurl(vlink);\\n                        } else {\\n                            return redurl\\n                        }\\n                    } else {\\n                        //var html = request(srcurl);\\n                        var html = scode.body;\\n                        //log(html);\\n                        if (/404 Not Found|备案后可继续访问/.test(html)) {\\n                            return openurl(vlink);\\n                        } else if (/\\\\<body/.test(html)) {\\n                            log('尝试非JSON接口网页解析');\\n                            requireCache('https://agit.ai/lzk23559/PublicRule/raw/branch/master/x5rule.js', 24);\\n                            return x5rule(srcurl, srcurl);\\n                            //return openurl(srcurl);\\n                        } else {\\n                            //json解析的取链接\\n                            var purl = html.match(/[\\\\'\\\\\\\"]url[\\\\'\\\\\\\"]:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1].replace(/\\\\\\\\/g, '');\\n                            //log(purl);\\n                            if (/http/.test(purl)) {\\n                                if (ptab == 'bilibili') {\\n                                    return purl + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\n                                } else if (ptab == 'mgtv') {\\n                                    return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                                } else if (/ojbk/.test(purl)) {\\n                                    return purl + ';{Referer@https://bak.ojbkjx.com/}';\\n                                } else if (/video_mp4|type\\\\=m3u8|pt\\\\=m3u8|\\\\/video\\\\/tos\\\\//.test(purl)) {\\n                                    return purl + '#isVideo=true#';\\n                                } else {\\n                                    return purl\\n                                };\\n                            } else {\\n                                //非http开头的打开原链接                                                                \\n                                return openurl(vlink)\\n                            }\\n                        }\\n                    }\\n                } catch (e) {\\n                    //报错判断处理\\n                    log('执行报错跳转处理');\\n                    /*if (srcurl.substring(0, 2) == '\\\\/\\\\/') {\\n                        return openurl('https:' + srcurl);\\n                    } else if (/\\\\=http/.test(srcurl) && /\\\\.html|bilibili/.test(srcurl)) {\\n                        //return srcurl.split('=')[1];\\n                        return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\n                    } else {*/\\n                    return openurl(vlink)\\n                    //return 'x5WebView://'+srcurl\\n                    //}\\n                }\\n                //动态解析代码结束\\n            },\\n            ptab,\\n            link,\\n            myurl,\\n            vlink),\\n        col_type: clt\\n    });\\n}\\n//}\"},{\"col_type\":\"movie_3\",\"name\":\"TV简介与选集\",\"path\":\"tvmovlist\",\"rule\":\"var tabs = Object.keys(html.videolist);\\nvar thumb = html.img_url;\\nitems.push({\\n    title: '剧情简介：',\\n    desc: html.intro,\\n    pic_url: thumb,\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\n        setResult([{\\n            title: des,\\n            col_type: 'long_text'\\n        }]);\\n    }, html.intro),\\n    col_type: 'movie_1_vertical_pic'\\n});\\neval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\n\\nitems.push({\\n    title: '““排序””',\\n    url: \\\"hiker://empty@lazyRule=.js:putMyVar('appmtvsort', getMyVar('appmtvsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\",\\n    col_type: 'scroll_button'\\n});\\nvar gva = MY_URL;\\nfor (var k = 0; k < tabs.length; k++) {\\n    var ptab = tabs[k];\\n    items.push({\\n        title: (getMyVar(gva, '0') == k ? '👉🏻' : '') + ptab,\\n        url: `hiker://empty@lazyRule=.js:putMyVar('` + gva + \\\"', '\\\" + k + `');refreshPage();'toast://切换成功！'`,\\n        col_type: 'scroll_button'\\n    });\\n\\n}\\n\\n//for (var i = 0; i < tabs.length; i++) {\\nif (getMyVar('appmtvsort', '1') == '1') {\\n    var list = html.videolist[tabs[getMyVar(gva, '0')]];\\n} else {\\n    var list = html.videolist[tabs[getMyVar(gva, '0')]].reverse();\\n};\\n\\nfor (var j = 0; j < list.length; j++) {\\n    var srcurl = list[j].url;\\n    if (/293jx1/.test(srcurl)) {\\n        srcurl = srcurl.replace('293jx1', 'jx');\\n    } else if (/8d8q|diliktv|haokanju1|cztv|fit\\\\:8|ppzhu/.test(myurl)) {\\n        srcurl = srcurl + '&app=10000&account=272775028&password=qq272775028';\\n    }\\n    var title = list[j].title;\\n    title = title.match(/(第|\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\n    if (list.length <= 4) {\\n        var clt = 'text_2';\\n    } else {\\n        var clt = isNaN(title) ? 'flex_button' : 'text_5'\\n    };\\n    items.push({\\n        title: title,\\n        url: $('hiker://empty').lazyRule((ptab, srcurl, myurl) => {\\n            function openurl(resurl) {\\n                if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili/) != -1) {\\n                    var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                    if (enDn == '1') {\\n                        log('调用断插解析');\\n                        eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                        eval(fetch(config.cj));\\n                        return aytmParse(resurl);\\n                    } else {\\n                        return resurl\\n                    };\\n                } else if (/\\\\=LT\\\\-/.test(resurl)) {\\n                    log('调用断插ltnb通用解析');\\n                    eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                    eval(fetch(config.cj));\\n                    var name = 'ltnb(通用函数)';\\n                    return ParseS[name](resurl.substring(resurl.indexOf('=LT-') + 1));\\n                } else {\\n                    return resurl\\n                }\\n            };\\n\\n            try {\\n                var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\n                if (enDn == '1' && srcurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && srcurl.search(/html|bilibili|ixigua/) != -1) {\\n                    log('已开启断插，将调用断插解析html');\\n                    eval(\\\"var config =\\\" + fetch(\\\"hiker://files/cache/MyParseSet.json\\\"));\\n                    eval(fetch(config.cj));\\n                    return aytmParse(srcurl.substring(srcurl.indexOf('=http') + 1));\\n                };\\n            } catch (e) {}\\n\\n            //log(srcurl);\\n            //动态解析代码开始\\n            try {\\n                if (/\\\\.m3u8|\\\\.mp4|obj\\\\/tos/.test(srcurl) && /http/.test(srcurl)) {\\n                    return /\\\\=ht/.test(srcurl) ? srcurl.substring(srcurl.indexOf('=ht') + 1) : srcurl + '#isVideo=true#';\\n                } else if (srcurl.indexOf(\\\"/share/\\\") != -1) {\\n                    try {\\n                        var link = srcurl.split(\\\"/share\\\")[0];\\n                        var fc = fetch(srcurl, {}).replace(\\\"var purl\\\", \\\"var main\\\");\\n                        if (fc.indexOf(\\\"main\\\") != -1) {\\n                            var mat = fc.match(/var main.*?;/)[0];\\n                            eval(mat);\\n                            var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main);\\n                        } else {\\n                            var main = fc.match(/url:.*?[\\\\'\\\\\\\"](.*?)[\\\\'\\\\\\\"]/)[1];\\n                            var play = (main.indexOf(\\\"http\\\") != -1 ? main : link + main)\\n                        };\\n                        return play;\\n                    } catch (e) {\\n                        return 'x5WebView://' + (srcurl)\\n                    }\\n                } else if (ptab == 'alizy') {\\n                    var purl = fetch('https://foubin.com/jiexi.php?url=' + srcurl, {}).match(/\\\\\\\"url\\\\\\\":\\\\\\\"(.*?)\\\\\\\"/)[1];\\n                    return purl;\\n                } else if (/19jx\\\\.vip|nfyingshi/.test(srcurl)) {\\n                    var purl = JSON.parse(fetch(srcurl.replace('http://', 'https://'), {\\n                        headers: {\\n                            \\\"User-Agent\\\": MOBILE_UA\\n                        },\\n                        redirect: false,\\n                        withHeaders: true\\n                    })).headers.location[0];\\n                    if (/titan.mgtv/.test(purl)) {\\n                        return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                    } else if (/obj\\\\/tos/.test(purl)) {\\n                        return purl + '#isVideo=true#';\\n                    } else {\\n                        return purl\\n                    };\\n                }\\n                /*else if (/zhaikanys/.test(srcurl)) {\\n                                       var purl = JSON.parse(fetch(srcurl + '&app=10003&account=272775028&password=qq272775028', {\\n                                           headers: {\\n                                               \\\"User-Agent\\\": MOBILE_UA\\n                                           },\\n                                           redirect: false,\\n                                           withHeaders: true\\n                                       })).headers.location[0];\\n                                       if (/titan.mgtv/.test(purl)) {\\n                                           return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                                       } else if (/obj\\\\/tos/.test(purl)) {\\n                                           return purl + '#isVideo=true#';\\n                                       } else {\\n                                           return purl\\n                                       };\\n                                   }*/\\n\\n                //----分割线----//\\n                var scode = JSON.parse(fetch(srcurl, {\\n                    headers: {\\n                        \\\"User-Agent\\\": MOBILE_UA\\n                    },\\n                    redirect: false,\\n                    withStatusCode: true\\n                }));\\n                //log(scode);\\n                if (scode.statusCode == '302' || scode.statusCode == '301') {\\n                    var purl = scode.headers.location[0].replace(/\\\\\\\\/g, '');\\n                } else {\\n                    //var html = request(srcurl);\\n                    var html = scode.body;\\n                    //log(html);\\n                    if (/404 Not Found|备案后可继续访问|不存在/.test(html) || html == '') {\\n                        return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\n                    } else if (/\\\\\\\"url\\\\\\\"\\\\:\\\\\\\"http/.test(html)) {\\n                        var purl = html.match(/\\\\\\\"url\\\\\\\":\\\\\\\"(.*?)\\\\\\\"/)[1].replace(/\\\\\\\\/g, '');\\n                    } else if (html.startsWith('{')) {\\n                        var purl = srcurl.substring(srcurl.indexOf('=http') + 1);\\n                    } else {\\n                        //var purl = srcurl\\n                        requireCache('https://agit.ai/lzk23559/PublicRule/raw/branch/master/x5rule.js', 24);\\n                        return x5rule(srcurl, srcurl);\\n                        //return 'x5WebView://'+(srcurl) \\n                    }\\n                };\\n                //log(purl);\\n                if (/titan.mgtv/.test(purl)) {\\n                    return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\n                } else if (/obj\\\\/tos/.test(purl)) {\\n                    return purl + '#isVideo=true#';\\n                } else {\\n                    return purl\\n                };\\n\\n            } catch (e) {\\n                if (srcurl.substring(0, 2) == '\\\\/\\\\/') {\\n                    return openurl('https:' + srcurl);\\n                } else if (/\\\\=http/.test(srcurl) && /\\\\.html|bilibili/.test(srcurl)) {\\n                    //return srcurl.split('=')[1];\\n                    return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\n                } else {\\n                    return openurl(srcurl)\\n                }\\n            }\\n            //动态解析代码结束\\n        }, ptab, srcurl, myurl),\\n        col_type: clt\\n    });\\n}\\n//}\"},{\"col_type\":\"movie_3\",\"name\":\"列表模式搜索二级\",\"path\":\"searerj\",\"rule\":\"var res = {};\\nvar items = [];\\nvar nowDate = new Date();\\nvar month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\nvar day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\nvar dateStr = month + '' + day;\\nvar spl = getResCode().split('#x#');\\nvar typet = spl[3];\\nvar tdomin = spl[2];\\nvar key = spl[4];\\n\\nif (/vipmv/.test(tdomin)) {\\n    var bhtml = request(spl[1]);\\n} else {\\n    var bhtml = fetch(spl[1], {\\n        headers: {\\n            \\\"User-Agent\\\": tdomin.indexOf(\\\"mogai_api\\\") != -1 ? \\\"Dart/2.14 (dart:io)\\\" : \\\"okhttp/4.1.0\\\"\\n        }\\n    });\\n}\\ntry {\\n    bhtml = bhtml.startsWith('\\\\r\\\\n') ? bhtml.replace('\\\\r\\\\n', '') : bhtml;\\n} catch (e) {}\\nif (/btwaf/.test(bhtml)) {\\n    /*\\n                items.push({\\n                    title:'有宝塔验证，点击访问原网页',\\n                    url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n                    col_type: 'text_1'\\n                });\\n                */\\n\\n    bhtml = fetch(spl[1] + '&btwaf' + bhtml.match(/btwaf(.*?)\\\\\\\"/)[1], {});\\n\\n}\\n//log(bhtml);\\nif (bhtml == \\\"\\\" || bhtml == null || bhtml.substring(0, 5) == 'error' || !bhtml.endsWith('}')) {\\n    items.push({\\n        title: '未搜索到相关资源，点击访问原网页',\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n        col_type: 'text_1'\\n    });\\n} else if (bhtml.length < 80) {\\n    items.push({\\n        title: '返回数据不完整，点击访问原网页',\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n        col_type: 'text_1'\\n    });\\n} else {\\n    var html = JSON.parse(bhtml);\\n    //log(spl[1]);\\n    if (html.list) {\\n        var list = html.list;\\n    } else if (html.data.list) {\\n        var list = html.data.list;\\n    } else if (html.data) {\\n        var list = html.data;\\n    }\\n\\n    if (list.length < 1) {\\n        items.push({\\n            title: '未搜索到，点击访问原网页',\\n            url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\n            col_type: 'text_1'\\n        });\\n    } else {\\n        for (var i = 0; i < list.length; i++) {\\n\\n            if (/\\\\/vod\\\\//.test(tdomin)) {\\n                var title = list[i].title;\\n                var pic = list[i].pic;\\n                //var vid=tdomin+'/detail?vod_id='+list[i].nextlink+'&rel_limit=10';\\n                var vid = list[i].nextlink;\\n                var rem = list[i].state;\\n                //var con=list[i].state;\\n            } else {\\n                if (tdomin.indexOf('api.php/app/') != -1) {\\n                    var title = list[i].vod_name;\\n                    var pic = list[i].vod_pic;\\n                    if (/fantuan/.test(tdomin)) {\\n                        var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\n                    } else {\\n                        var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\n                    }\\n                    var rem = list[i].vod_remarks;\\n                    //var con=list[i].type.type_des;\\n                } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\n                    var title = list[i].vod_name;\\n                    var pic = list[i].vod_pic;\\n                    var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\n                    var rem = list[i].vod_remarks;\\n                    //var con=list[i].type.type_des;\\n                } else {\\n                    var title = list[i].vod_name;\\n                    var pic = list[i].vod_pic;\\n                    if (/iopenyun/.test(tdomin)) {\\n                        var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\n                    } else if(/grelighting/.test(tdomin)){\\n                        var vid = tdomin + '/?ids=' + list[i].vod_id + '&token=';\\n                    } else {\\n                        var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\n                    }\\n                    var rem = list[i].vod_remarks;\\n                    //var con=list[i].type.type_des;\\n                }\\n            }\\n\\n            items.push({\\n                title: title.replace(key, '““' + key + '””'),\\n                pic_url: pic + '@Referer=',\\n                url: $(tdomin.indexOf(\\\"mogai_api\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((tdomin) => {\\n                    var res = {};\\n                    var items = [];\\n                    var html = JSON.parse(getResCode());\\n                    items.push({\\n                        title: '',\\n                        desc: '255&&float',\\n                        url: '',\\n                        col_type: 'x5_webview_single'\\n                    });\\n                    refreshX5WebView('');\\n                    var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n                    if (/\\\\/vod\\\\//.test(tdomin)) {\\n                        eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\n                    } else {\\n                        eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n                    }\\n                    res.data = items;\\n                    setHomeResult(res);\\n                }, tdomin),\\n                //content:rem,\\n                desc: rem,\\n                col_type: 'movie_1_vertical_pic'\\n            });\\n        } //for i\\n    } //else list.length\\n}\\n\\nres.data = items;\\nsetHomeResult(res);\"},{\"col_type\":\"movie_3\",\"name\":\"APP首页列表\",\"path\":\"appindexdata\",\"rule\":\"if (html.list) {\\n    var list = html.list;\\n} else if (html.data && html.data.list) {\\n    var list = html.data.list;\\n} else {\\n    var list = html.data;\\n}\\n\\nfor (var i = 0; i < list.length; i++) {\\n    if (list[i].vod_list) {\\n        var lists = list[i].vod_list;\\n        var typename = list[i].vod_type_name;\\n    } else {\\n        var lists = list[i].vlist;\\n        var typename = list[i].type_name\\n    }\\n    items.push({\\n        title: typename,\\n        col_type: 'text_1'\\n\\n    });\\n\\n    for (var j = 0; j < lists.length; j++) {\\n        var title = lists[j].vod_name;\\n        var img = lists[j].vod_pic;\\n        var url = lists[j].vod_id;\\n        var desc = lists[j].vod_remarks;\\n        var nowDate = new Date();\\n        var month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\n        var day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\n        var dateStr = month + '' + day;\\n        if (html.list) {\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else if (html.data && html.data.list) {\\n            if (murl.search(/mogai_api/) != -1) {\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n            } else if (murl.includes('grelighting')) {\\n                var link = murl + '/?ids=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n            } else {\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\n            }\\n        } else {\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        };\\n        if (/fantuan/.test(murl)) {\\n            var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else if (/iopenyun/.test(murl)) {\\n            var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\n        } else if (/dijiaxia/.test(murl)) {\\n            var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\n        }\\n        items.push({\\n            title: title,\\n            pic_url: img + '@Referer=',\\n            url: $(link).rule(() => {\\n                var res = {};\\n                var items = [];\\n                items.push({\\n                    title: '',\\n                    desc: '255&&float',\\n                    url: '',\\n                    col_type: 'x5_webview_single'\\n                });\\n                refreshX5WebView('');\\n                var html = JSON.parse(getResCode());\\n                var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n                try {\\n                    eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n                } catch (e) {}\\n                res.data = items;\\n                setHomeResult(res);\\n            }),\\n            desc: desc,\\n            col_type: 'movie_3_marquee'\\n        });\\n    }\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"断念插件调用\",\"path\":\"dnplugin\",\"rule\":\"var dnen = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\nitems.push({\\n    title: '断插：' + (dnen == '1' ? '““✅””' : '❎'),\\n    url: $('').lazyRule((dnen) => {\\n        if (dnen == '1') {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"enDn\\\\\\\":\\\\\\\"1\\\\\\\"', '\\\\\\\"enDn\\\\\\\":\\\\\\\"0\\\\\\\"');\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            refreshPage(false);\\n            return 'toast://已禁用断插调用！';\\n        } else {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"enDn\\\\\\\":\\\\\\\"0\\\\\\\"', '\\\\\\\"enDn\\\\\\\":\\\\\\\"1\\\\\\\"');\\n            //log(fileUrl);\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            refreshPage(false);\\n            return 'toast://已开启断插调用！'\\n        }\\n    }, dnen),\\n    col_type: 'text_3'\\n});\\nif (dnen == '1') {\\n    items.push({\\n        title: '线路配置',\\n        //url: \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\",\\n        url: \\\"select://\\\" + JSON.stringify({\\n        title:\\\"线路配置\\\",\\n        options: [\\\"原断\\\", \\\"魔断\\\"],\\n        col: 2,\\n        js: $.toString(() => {\\n            if(input==\\\"原断\\\"){\\n            return \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\";    \\n            }else{\\n            return \\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noHistory##noRecordHistory#\\\"    \\n            }\\n        })\\n    }),\\n        col_type: 'text_3'\\n    });\\n    items.push({\\n        title: '解析管理',\\n        //url: \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\",\\n        url: \\\"select://\\\" + JSON.stringify({\\n        title:\\\"解析管理\\\",\\n        options: [\\\"原断\\\", \\\"魔断\\\"],\\n        col: 2,\\n        js: $.toString(() => {\\n            if(input==\\\"原断\\\"){\\n             return \\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\";   \\n            }else{\\n             return \\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=编辑#noHistory##noRecordHistory#\\\"   \\n            }\\n        })\\n    }),\\n        col_type: 'text_3'\\n    });\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"设置页代码\",\"path\":\"setting\",\"rule\":\"var d = [];\\nvar setjson = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {}));\\nvar ssmd = setjson.ssmode;\\nvar ssxc = setjson.sscount;\\nd.push({\\n    title: '搜索设置',\\n    col_type: 'text_center_1'\\n});\\nd.push({\\n    title: '当前：' + '(' + (ssmd == 1 ? '聚合结果' : '引擎列表') + ')',\\n    url: $('hiker://empty').lazyRule(() => {\\n        var md = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\n\\n        if (md == 1) {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"ssmode\\\\\\\":\\\\\\\"1\\\\\\\"', '\\\\\\\"ssmode\\\\\\\":\\\\\\\"0\\\\\\\"');\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            back(true);\\n            return 'toast://切换为搜索引擎列表单选模式成功！';\\n        } else {\\n            var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace('\\\\\\\"ssmode\\\\\\\":\\\\\\\"0\\\\\\\"', '\\\\\\\"ssmode\\\\\\\":\\\\\\\"1\\\\\\\"');\\n            //log(fileUrl);\\n            writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n            back(true);\\n            return 'toast://切换为聚合搜索模式成功！'\\n        }\\n    }),\\n    col_type: 'text_2'\\n})\\nd.push({\\n    title: '搜索超时(' + '' + getItem('apptimout', '') + ')',\\n    url: \\\"input://\\\" + '3000' + \\\"////请设置超时时间，1000为一秒。.js:var num = parseInt(input).toString();if (num == 'NaN'||num<1000) {'toast://输入的值好像不正确。';} else {setItem('apptimout', num);refreshPage();'toast://设置成功。'}\\\",\\n    col_type: 'text_2'\\n});\\n\\nd.push({\\n    title: '搜索线程' + '(' + ssxc + ')',\\n    url: \\\"input://\\\" + JSON.stringify({\\n        value: \\\"5\\\",\\n        hint: \\\"请输入一个整数数字，推荐最大不要超过15。\\\",\\n        js: $.toString(() => {\\n            var num = parseInt(input).toString();\\n            if (num == 'NaN' || num < 1) {\\n                return 'toast://输入的值好像不正确。';\\n            } else {\\n                var fileUrl = fetch(\\\"hiker://files/rules/xyq/appmset.json\\\", {}).replace(/\\\\\\\"sscount\\\\\\\":\\\\\\\"[\\\\d]*\\\\\\\"/, '\\\\\\\"sscount\\\\\\\":\\\\\\\"' + num + '\\\\\\\"');\\n                writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", fileUrl);\\n                back(true);\\n                return 'toast://保存设置搜索线程完成！'\\n            }\\n        }),\\n    }),\\n    col_type: 'text_2'\\n});\\n\\nd.push({\\n    title: '更新相关',\\n    col_type: 'text_center_1'\\n});\\nd.push({\\n    title: '检测更新',\\n    url: $('').lazyRule((locver) => {\\n        try {\\n            var remf = fetchCache('https://codeberg.org/lzk23559/cloudrule/raw/branch/master/appmovie.txt', 24);\\n        } catch (e) {\\n            remf = '';\\n        }\\n        if (/￥base64/.test(remf)) {\\n            var remv = JSON.parse(base64Decode(remf.split('@')[2])).version;\\n        } else if (/￥home_rule￥/.test(remf)) {\\n            var remv = JSON.parse(remf.split('￥home_rule￥')[1]).version;\\n        };\\n        if (/￥home_rule/.test(remf)) {\\n            log('远程版本：' + remv);\\n            log('本地版本：' + locver);\\n            if (locver != remv) {\\n                putVar('appnver', remf);\\n                refreshPage();\\n                return 'toast://有新版本，点导入更新可更新规则。';\\n            } else {\\n                return 'toast://暂无新版本，24小时内检测无效。'\\n            };\\n        } else {\\n            return 'toast://检测更新失败，可能云端抽风了。'\\n        }\\n    }, locver),\\n    col_type: 'text_2'\\n});\\nif (getVar('appnver')) {\\n    d.push({\\n        title: '导入更新',\\n        url: $('').lazyRule(() => {\\n            return getVar('appnver');\\n        }),\\n        col_type: 'text_2'\\n    });\\n}\\nd.push({\\n    title: '接口相关',\\n    //url:'hiker://empty',\\n    url: $('hiker://empty').lazyRule(() => {\\n        var remfile = '';\\n        //log(remfile);\\n        if (/\\\\=http/.test(remfile)) {\\n            writeFile(\\\"hiker://files/rules/xyq/APPMovie.txt\\\", remfile);\\n            back(true);\\n            return 'toast://获取云端文件写本地成功。';\\n        } else {\\n            return 'toast://获取云端文件失败。'\\n        }\\n    }),\\n    col_type: 'text_center_1'\\n});\\nvar clmd = getItem('clmode', '1');\\nd.push({\\n    title: '云端/本地' + '(' + (clmd == 1 ? '本地' : '云端') + ')',\\n    url: $('').lazyRule(() => {\\n        var clmd = getItem('clmode', '1');\\n        if (clmd == 1) {\\n            setItem('clmode', '0');\\n            refreshPage();\\n            return 'toast://切换为云端接口成功，请返回刷新。';\\n        } else {\\n            setItem('clmode', '1');\\n            refreshPage();\\n            return 'toast://切换为本地接口成功，请返回刷新。'\\n        }\\n    }),\\n    col_type: 'text_2'\\n});\\nd.push({\\n    title: '编辑本地接口',\\n    url: $('').lazyRule(() => {\\n        return 'editFile://hiker://files/rules/xyq/APPMovie.txt'\\n    }),\\n    col_type: 'text_2'\\n});\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"最新章节\",\"path\":\"chapter\",\"rule\":\"var chp = [];\\ntry {\\n    var html = JSON.parse(getResCode());\\n    if (html.videolist) {\\n        var conts = Object.keys(html.videolist);\\n    } else if (html.data.vod_url_with_player) {\\n        var conts = html.data.vod_url_with_player;\\n        if (conts.length < 1) {\\n            conts = html.data.vod_play_url.split('$$$');\\n        }\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\n        var conts = html.data.vod_info.vod_url_with_player;\\n        if (conts.length < 1) {\\n            conts = html.data.vod_info.vod_play_url.split('$$$');\\n        }\\n    } else if (html.data.length == 1) {\\n        var conts = html.data[0].vod_play_list;\\n        //log(conts);\\n        if (conts.length < 1) {\\n            conts = html.data[0].vod_play_url.split('$$$');\\n        }\\n    } else {\\n        var conts = html.data.vod_play_list;\\n        if (conts.length < 1) {\\n            conts = html.data.vod_play_url.split('$$$');\\n        }\\n    }\\n\\n    for (var i = 0; i < conts.length; i++) {\\n        if (html.videolist) {\\n            var list = html.videolist[conts[i]];\\n        } else if (conts[i].urls) {\\n            var list = conts[i].urls;\\n        } else if (conts[i].url) {\\n            var list = conts[i].url.split(\\\"#\\\");\\n        } else {\\n            var list = conts[i].split(\\\"#\\\");\\n        }\\n        chp.push(list.length);\\n    }\\n} catch (e) {}\\n//log(Math.max.apply(Math,chp));\\nsetResult('更新至:' + (Math.max.apply(Math, chp)));\"},{\"col_type\":\"movie_3\",\"name\":\"分类搜索\",\"path\":\"ss2\",\"rule\":\"js:\\nvar items = [];\\nvar Data = [];\\nvar nowDate = new Date();\\nvar month = nowDate.getMonth() + 1 < 10 ? \\\"0\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\nvar day = nowDate.getDate() < 10 ? \\\"0\\\" + nowDate.getDate() : nowDate.getDate();\\nvar dateStr = month + '' + day;\\n//取搜索线程设置\\nvar ssxc = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).sscount;\\n//设置超时时间，越小越快，单位毫秒\\nvar timeou = getItem('apptimout', '3000');\\nvar key = MY_URL.split('$$$')[1];\\nvar num = MY_URL.split('$$$')[2];\\nvar le = parseInt(num * ssxc);\\nvar Tit = [];\\nlet list = MY_PARAMS.list;\\nlet tytit = MY_PARAMS.tytit;\\nlet pageid = \\\"__app\\\" + num;\\ntry {\\n    for (var j = le - ssxc; j < le; j++) {\\n        if (j < list.length) {\\n            var link = list[j].url;\\n            var litit = list[j].murl;\\n            if (/\\\\/vod\\\\//i.test(link)) {\\n                if (/37\\\\.161|216\\\\.98|phoebe|hfys8|feifan12|tvzy|hdyangtv|tkys|tegouys/.test(link)) {\\n                    var hmurl = link + '?ac=list&zm=' + key + '&page=1';\\n                } else {\\n                    var hmurl = link + '?ac=list&wd=' + key + '&page=1';\\n                }\\n            } else {\\n                if (/dijiaxia/.test(link)) {\\n                    link = 'http://www.dijiaxia.com/api.php/app/'\\n                };\\n                if (link.indexOf('api.php/app/') != -1) {\\n                    var hmurl = link + 'search?pg=1&text=' + key + '&token=';\\n                } else if (link.indexOf('xgapp.php/v1/') != -1) {\\n                    var hmurl = link + 'search?pg=1&text=' + key;\\n                } else {\\n                    if (/iopenyun/.test(link)) {\\n                        var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\n                    } else {\\n                        var hmurl = link + '?page=1&limit=10&wd=' + key;\\n                    }\\n                }\\n            }\\n            //Data.push({url: hmurl,options: {headers: {\\\"User-Agent\\\": \\\"Dart/2.14 (dart:io)\\\"},timeout: timeou}});\\n            Data.push({\\n                url: hmurl,\\n                options: {\\n                    headers: {\\n                        \\\"User-Agent\\\": link.indexOf(\\\"mogai_api\\\") != -1 ? \\\"Dart/2.14 (dart:io)\\\" : \\\"okhttp/4.1.0\\\"\\n                    },\\n                    timeout: timeou\\n                }\\n            });\\n            Tit.push({\\n                tit: list[j].title,\\n                link: link,\\n                typnm: litit\\n            });\\n        } //if\\n    } //for j\\n} catch (e) {}\\nif (Data.length <= 0) {\\n    setResult([]);\\n} else {\\n    items.push({\\n        title: \\\"正在加载中第\\\" + MY_PAGE + \\\"页，进度：1/\\\" + Data.length,\\n        url: \\\"\\\",\\n        col_type: \\\"text_center_1\\\",\\n        desc: \\\"\\\",\\n        pic_url: \\\"\\\",\\n        extra: {\\n            id: pageid\\n        }\\n    });\\n    setResult(items);\\n    let tasks = [];\\n\\n    for (let k in Data) {\\n        let it = Data[k];\\n        tasks.push({\\n            func: function(param) {\\n                let d = [];\\n                let html = fetch(param.it.url, param.it.options);\\n                //log(html);\\n                try {\\n                    html = html.substring(0, 2) == '\\\\r\\\\n' ? html.replace('\\\\r\\\\n', '') : html;\\n                } catch (e) {}\\n                if (/btwaf/.test(html)) {\\n                    html = fetch(param.it.url + '&btwaf' + html.match(/btwaf(.*?)\\\\\\\"/)[1], {});\\n                }\\n                if (html == \\\"\\\" || html == null || html.substring(0, 5) == 'error' || !html.endsWith('}')) {\\n                    d.push({\\n                        title: param.tit.tit + ' ' + '未搜索到，点击访问原网页',\\n                        url: param.it.url + `@lazyRule=.js:input.split(';')[0]`,\\n                        desc: \\\"\\\",\\n                        pic_url: \\\"\\\",\\n                        col_type: 'text_center_1'\\n                    });\\n                } else if (html.length < 80) {\\n                    d.push({\\n                        title: param.tit.tit + ' ' + '返回数据不完整，点击访问原网页',\\n                        url: param.it.url + `@lazyRule=.js:input.split(';')[0]`,\\n                        desc: \\\"\\\",\\n                        pic_url: \\\"\\\",\\n                        col_type: 'text_center_1'\\n                    });\\n                } else {\\n                    html = JSON.parse(html);\\n                    //log(html);\\n                    var typet = param.tit.typnm;\\n                    var tdomin = param.tit.link;\\n                    if (html.list) {\\n                        var list = html.list;\\n                    } else if (html.data.list) {\\n                        var list = html.data.list;\\n                    } else if (html.data) {\\n                        var list = html.data;\\n                    } else {\\n                        var list = [];\\n                    }\\n                    if (list.length < 1) {\\n                        d.push({\\n                            title: param.tit.tit + ' ' + '列表小于1，无法展示，点击访问原网页',\\n                            url: param.it.url + `@lazyRule=.js:input.split(';')[0]`,\\n                            desc: \\\"\\\",\\n                            pic_url: \\\"\\\",\\n                            col_type: 'text_center_1'\\n                        });\\n                    } else {\\n                        for (var i = 0; i < list.length; i++) {\\n                            if (/\\\\/vod\\\\//.test(tdomin)) {\\n                                var title = list[i].title;\\n                                var pic = list[i].pic;\\n                                var vid = list[i].nextlink;\\n                                var rem = list[i].state;\\n                            } else {\\n                                if (tdomin.indexOf('api.php/app/') != -1) {\\n                                    var title = list[i].vod_name;\\n                                    var pic = list[i].vod_pic;\\n                                    if (/fantuan/.test(tdomin)) {\\n                                        var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\n                                    } else {\\n                                        var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\n                                    }\\n                                    var rem = list[i].vod_remarks;\\n                                    //var con=list[i].type.type_des;\\n                                } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\n                                    var title = list[i].vod_name;\\n                                    var pic = list[i].vod_pic;\\n                                    var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\n                                    var rem = list[i].vod_remarks;\\n                                    //var con=list[i].type.type_des;\\n                                } else {\\n                                    var title = list[i].vod_name;\\n                                    var pic = list[i].vod_pic;\\n                                    if (/iopenyun/.test(tdomin)) {\\n                                        var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\n                                    } else if (/grelighting/.test(tdomin)) {\\n                                        var vid = tdomin + '/?ids=' + list[i].vod_id + '&token=';\\n                                    } else {\\n                                        var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\n                                    }\\n                                    var rem = list[i].vod_remarks;\\n                                    //var con=list[i].type.type_des;\\n                                }\\n\\n                            }\\n                            //var con=list[i].state;\\n                            //log(vid);\\n                            d.push({\\n                                title: MY_TYPE == \\\"home\\\" ? title.replace(key, '““' + key + '””') + '\\\\n' + rem : title + rem,\\n                                pic_url: pic + '@Referer=',\\n                                url: $(tdomin.indexOf(\\\"mogai_api\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((tdomin, tkt, patt) => {\\n                                    var res = {};\\n                                    var items = [];\\n                                    if (tkt != '') {\\n                                        setPageTitle(tkt + '-' + patt);\\n                                    }\\n                                    var html = JSON.parse(getResCode());\\n                                    items.push({\\n                                        title: '',\\n                                        desc: '255&&float',\\n                                        url: '',\\n                                        col_type: 'x5_webview_single'\\n                                    });\\n                                    var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n                                    if (/\\\\/vod\\\\//.test(tdomin)) {\\n                                        eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\n                                    } else {\\n                                        eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\n                                    }\\n\\n                                    res.data = items;\\n                                    setHomeResult(res);\\n                                }, tdomin, param.tit.tit, title),\\n                                //content: rem,\\n                                desc: tytit + ' => ' + param.tit.tit,\\n                                col_type: 'movie_1_vertical_pic'\\n                            });\\n                        } //for i\\n                    } //if list.length\\n                }\\n                return d;\\n            },\\n            param: {\\n                it: it,\\n                tit: Tit[k]\\n            },\\n            id: \\\"task\\\"\\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                for (let it of result) {\\n                    param.j = param.j + 1;\\n                    addItemBefore(pageid, {\\n                        title: it.title,\\n                        desc: it.desc,\\n                        url: it.url,\\n                        pic_url: it.pic_url,\\n                        col_type: it.col_type,\\n                        extra: {\\n                            id: \\\"__app\\\" + MY_PAGE + \\\"@\\\" + param.j\\n                        }\\n                    })\\n                }\\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}\"},{\"col_type\":\"movie_3\",\"name\":\"数据转换\",\"path\":\"conver\",\"rule\":\"//js:\\n//rem(res);\\nvar 记录 = [];\\nvar 输入条目 = remfile.match(/.+=http.+/g);\\nfor (var j in 输入条目) {\\n    var title = 输入条目[j].split('@')[1].split('=')[0];\\n    var url = 输入条目[j].split('=')[1].split('#')[0];\\n    var img = 输入条目[j].split('#')[1];\\n    if (img.indexOf(\\\"http\\\") != -1) {\\n        var img = img;\\n    } else if (img == \\\"\\\") {\\n        var img = \\\"https://gitcode.net/m0_72395205/iptv/-/raw/master/AppFile/AppIcon/通用图标.png\\\"\\n    } else {\\n        var img = \\\"https://gitcode.net/m0_72395205/iptv/-/raw/master/AppFile/AppIcon/\\\" + img + \\\".png\\\";\\n    }\\n    if (url.search(/api\\\\.php\\\\/.*?\\\\/vod/) != -1) {\\n        var murl = \\\"q:TV影视\\\";\\n    } else {\\n        var murl = \\\"q:APP影视\\\";\\n    }\\n    if (输入条目[j].split('@')[0] != \\\"\\\") {\\n        var type = 输入条目[j].split('@')[0];\\n    } else if (url.indexOf(\\\"api.php/app\\\") != -1 || url.indexOf(\\\"xgapp\\\") != -1) {\\n        var type = \\\"小龟\\\";\\n    } else if (url.indexOf(\\\".vod\\\") != -1) {\\n        var type = \\\"普通\\\";\\n    } else if (url.search(/api\\\\.php\\\\/.+?\\\\/vod\\\\//) != -1) {\\n        var type = \\\"神马\\\";\\n    }\\n    记录.push({\\n        title: title,\\n        url: url,\\n        img: img,\\n        murl: murl,\\n        type: type\\n    });\\n}\\nvar 新记录 = [];\\n\\nfor (var i in 记录) {\\n    var 当前条目 = [];\\n    当前条目.push(记录[i]);\\n    if (新记录.length == 0) {\\n        新记录.push({\\n            title: 记录[i].type,\\n            list: 当前条目\\n        });\\n    } else {\\n        let res = 新记录.some(item => {\\n            //判断类型，有就添加到当前项\\n            if (item.title == 记录[i].type) {\\n                item.list = 当前条目.concat(item.list.filter(d => d.url != 记录[i].url));\\n                return true\\n            }\\n        });\\n        if (!res) {\\n            //如果没找相同类型添加一个类型\\n            新记录.push({\\n                title: 记录[i].type,\\n                list: 当前条目\\n            });\\n        }\\n    }\\n}\\nvar newfile = {};\\nnewfile.data = 新记录;\\n//log(remfile);\"}],\"params\":\"{\\\"id\\\":\\\"__app1@11\\\"}\",\"saved\":false,\"title\":\"APP影视(P)\",\"version\":0,\"url\":\"http://bbq.1006.tk/api.php/v1.vod/detail?key=0119&vod_id=1469413&token=;get;utf-8;{User-Agent@okhttp/4.1.0}\",\"col_type\":\"movie_3\",\"find_rule\":\"js:(\\n(tdomin, tkt, patt) => {\\n    var res = {};\\n    var items = [];\\n    if (tkt != \\\"\\\") {\\n        setPageTitle(tkt + \\\"-\\\" + patt);\\n    }\\n    var html = JSON.parse(getResCode());\\n    items.push({title: \\\"\\\", desc: \\\"255&&float\\\", url: \\\"\\\", col_type: \\\"x5_webview_single\\\"});\\n    var myurl = MY_URL.match(/([\\\\S]*?:\\\\/\\\\/[\\\\S]*?)\\\\//)[1];\\n    if (/\\\\/vod\\\\//.test(tdomin)) {\\n        eval(JSON.parse(fetch(\\\"hiker://page/tvmovlist\\\", {})).rule);\\n    } else {\\n        eval(JSON.parse(fetch(\\\"hiker://page/appmovlist\\\", {})).rule);\\n    }\\n    res.data = items;\\n    setHomeResult(res);\\n}\\n)(\\\"http://bbq.1006.tk/api.php/v1.vod\\\",\\\"HG影视\\\",\\\"三体\\\")\",\"group\":\"视频\",\"ua\":\"mobile\",\"preRule\":\"if (!fileExist('hiker://files/rules/xyq/appmset.json')) {\\n    let set = `{\\\"ssmode\\\":\\\"0\\\",\\\"sscount\\\":\\\"5\\\",\\\"enDn\\\":\\\"0\\\"}`;\\n    writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", set);\\n};\\nif (!fileExist('hiker://files/rules/xyq/APPMovie.txt')) {\\n    setItem('clmode', '1');\\n    let shili = \\\"示例分类名@示例名称=示例接口链接#示例图片链接\\\\n优质@钟特影视=https://app.zteys.com/api.php/v1.vod#钟特影视\\\";\\n    writeFile(\\\"hiker://files/rules/xyq/APPMovie.txt\\\", shili);\\n};\\nvar ruleset = fetch('hiker://files/rules/xyq/appmset.json', {});\\nif (!JSON.parse(ruleset).enDn) {\\n    let set = ruleset.replace('\\\\\\\"\\\\}', '\\\\\\\"\\\\,\\\\\\\"enDn\\\\\\\"\\\\:\\\\\\\"0\\\\\\\"\\\\}');\\n    writeFile(\\\"hiker://files/rules/xyq/appmset.json\\\", set);\\n};\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"接口数据2022/10/12\\\",\\\"path\\\":\\\"ResCode\\\",\\\"rule\\\":\\\"优质@暖光影视=https://app.bl210.com/api.php/v1.vod#暖光影视\\\\n优质@奈非迷=https://app.netflixmi.com/api.php/v1.vod#奈非迷影视\\\\n优质@美剧范=http://ttzmz.net/api.php/v1.vod#美剧范\\\\n优质@零刻影院=https://ys.ling00.cn/api.php/v1.vod#零刻影院\\\\n优质@段友影视=https://shangjihuoke.com/api.php/tv.vod#段友影视\\\\n优质@独播社=http://35ys.cc/api.php/v1.vod#独播社\\\\n优质@创意影视=https://www.30dian.cn/api.php/v1.vod#创意影视\\\\n优质@嗷呜视频=http://www.cx99999.cn/lvdou_api.php/v1.vod#嗷呜视频\\\\n优质@爱麻花影视=http://v.jiexi.work/qingdoujiekou.php/v1.vod#爱麻花影视\\\\n优质@爱酷影视=https://www.zhanlangbu.com/ruifenglb_api.php/v1.vod#爱酷影视\\\\n优质@HG影视=http://bbq.1006.tk/api.php/v1.vod#HG影视\\\\n优质@F7高清=http://bc.haokanju1.cc/lvdou_api.php/v1.vod#F7高清\\\\n普通@追剧影院=http://82.157.98.129/lvdou_api.php/v1.vod#追剧影院\\\\n普通@追剧吧=http://117.50.163.45:88/lvdou_api.php/v1.vod#追剧吧\\\\n普通@追剧TV=http://111.229.120.180:88/lvdou_api.php/v2.vod#追剧TV\\\\n普通@渔渔影视=http://luobo.yugenye.site/api.php/v1.vod#渔渔影视\\\\n普通@余生影视=http://yu.cuicanys.cn/lvdou_api.php/v1.vod#余生影视\\\\n普通@影视猫=https://vip.wscyun.com/api.php/v1.vod#影视猫\\\\n普通@影视大全=https://xc.xixi2yy.xyz/mogai_api.php/v1.vod#影视大全HD\\\\n普通@呀哩动漫=https://app.yaliyali.cc/api.php/v1.vod#呀哩动漫\\\\n普通@影库=https://yingkudy.com/lvdou_api.php/v1.vod#影库\\\\n普通@月儿影视=https://yue52.xyz/api.php/v1.vod#\\\\n普通@星宿漫=http://3.xingxiuman.com/mogai_api.php/v1.vod#星宿漫\\\\n普通@小鸟动漫=http://xydm.baicai.buzz/mogai_api.php/v1.vod#小鸟动漫\\\\n普通@熊猫视频=http://anegh.com/lvdou_api.php/v1.vod#熊猫视频\\\\n普通@熊猫动漫=http://dongman.k8aa.com/mogai_api.php/v1.vod#熊猫动漫\\\\n普通@万能影院=http://app.wnvod.net/lvdou_api.php/v1.vod#万能影院\\\\n普通@蜗牛动漫=http://woniudm.woniu.cyou:20000/mogai_api.php/v1.vod#蜗牛动漫\\\\n普通@我爱跟剧=https://www.genmov.com/mogai_api.php/v1.vod#我爱跟剧\\\\n普通@淘剧社=https://app.shuhai99.com/api.php/v1.vod#淘剧社\\\\n普通@群鑫影视=http://www.qunxinys.com/api.php/v1.vod#群鑫影视\\\\n普通@龙猫追剧=https://lb.ybnxcx.com/api.php/v1.vod#\\\\n普通@看剧吧=http://app.ishen520.com/api.php/v1.vod#看剧吧\\\\n普通@寒枫视频=https://vip.shenyunwl.cn/mogai_api.php/v1.vod#寒枫视频\\\\n普通@艾思影视=https://www.aitee.cc/api.php/v1.vod#\\\\n普通@阿里影视=http://aliys.cn:90/api.php/v1.vod#阿里影视\\\\n普通@爱电影=https://www.idianying.com.cn/mogai_api.php/v1.vod#爱电影\\\\n普通@OK影视=http://123.ok00.xyz/api.php/v1.vod#OK影视\\\\n普通@MX影视=http://mkk.gotka.top/api.php/v1.vod#\\\\n普通@69美剧=https://www.69mj.com/api.php/v1.vod#\\\\n神马@影视阁=http://216.98.10.85/api.php/iptv/vod/#影视阁\\\\n神马@天空TV=http://tv.tkys.tv/api.php/iptv/vod/#天空TV\\\\n神马@芒迅TV=http://www.hdyangtv.com/api.php/iptv/vod/#芒迅TV\\\\n神马@猫咪TV=http://106.12.113.90:6565/api.php/iptv/vod/#猫咪TV\\\\n神马@黑龙影视=http://vip.ji-ding-he.site/api.php/iptv/vod/#黑龙影视\\\\n神马@贵宾影院=https://vipdytv.com/api.php/iptv/vod/#\\\\n神马@爱西西TV=http://tv2.aixixi.vip/api.php/iptv/vod/#爱西西TV\\\\n神马@CV影视=http://www.cccvvv.top/api.php/iptv/vod/#CV影视\\\\n神马@2号币=http://phoebe.cf/api.php/iptv/vod/#2号币影院\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"搜索\\\",\\\"path\\\":\\\"sear\\\",\\\"rule\\\":\\\"var res = {};\\\\nvar items = [];\\\\n//设置搜索线程\\\\nvar ssmode = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\\\nvar key = MY_URL.split('$$$')[1];\\\\n//setError(le);\\\\nif (ssmode == '0') {\\\\n    setPageTitle(key + ' 的搜索结果')\\\\n};\\\\ntry {\\\\n    if (getItem('clmode', '1') == 1) {\\\\n        var one = fetch('hiker://files/rules/xyq/APPMovie.txt');\\\\n    } else {\\\\n        var one = fetchCache('', 24);\\\\n    }\\\\n    //log(two +'\\\\\\\\n'+ one);\\\\n    if (/\\\\\\\\=http/.test(one)) {\\\\n        var remfile = one;\\\\n    } else {\\\\n        log('当前加载的是内置数据');\\\\n        var remfile = JSON.parse(fetch('hiker://page/ResCode', {})).rule;\\\\n    }\\\\n} catch (e) {\\\\n    log('当前加载的是内置数据');\\\\n    var remfile = JSON.parse(fetch('hiker://page/ResCode', {})).rule;\\\\n};\\\\nif (/\\\\\\\\=http/.test(remfile)) {\\\\n    eval(JSON.parse(fetch('hiker://page/conver', {})).rule);\\\\n    remfile = JSON.stringify(newfile);\\\\n}\\\\nvar html = JSON.parse(remfile);\\\\n\\\\nvar dlist = html.data;\\\\n\\\\nif (ssmode == '1' || MY_TYPE == 'home') {\\\\n    for (var l = 0; l < dlist.length; l++) {\\\\n        var list = dlist[l].list;\\\\n        var tytit = dlist[l].title;\\\\n\\\\n        items.push({\\\\n            title: MY_TYPE == \\\\\\\"home\\\\\\\" ? \\\\\\\"点击查看 \\\\\\\" + tytit + \\\\\\\" 分类 ““\\\\\\\" + key + \\\\\\\"”” 的聚搜结果\\\\\\\" : \\\\\\\"点击查看 \\\\\\\" + tytit + \\\\\\\" 分类 \\\\\\\" + key + \\\\\\\" 的聚搜结果\\\\\\\",\\\\n            url: \\\\\\\"hiker://page/ss2\\\\\\\",\\\\n            col_type: 'text_1',\\\\n            extra: {\\\\n                list: list,\\\\n                tytit: tytit,\\\\n                url: 'hiker://empty$$$' + key + '$$$fypage$$$'\\\\n            }\\\\n        });\\\\n\\\\n    } //for i\\\\n}; //end mode 1\\\\n\\\\nif (ssmode == '0' || MY_TYPE == 'home') {\\\\n    for (var i = 0; i < dlist.length; i++) {\\\\n        var list = dlist[i].list;\\\\n        var tytit = dlist[i].title;\\\\n\\\\n        items.push({\\\\n            title: MY_TYPE == \\\\\\\"home\\\\\\\" ? \\\\\\\" 选择一个 \\\\\\\" + dlist[i].title + \\\\\\\" 项目查看 ““\\\\\\\" + key + \\\\\\\"”” 的搜索结果\\\\\\\" : \\\\\\\" 选择一个 \\\\\\\" + dlist[i].title + \\\\\\\" 项目查看 \\\\\\\" + key + \\\\\\\" 的搜索结果\\\\\\\",\\\\n            col_type: 'text_1'\\\\n        });\\\\n\\\\n        for (var j = 0; j < list.length; j++) {\\\\n            var link = list[j].url;\\\\n            var litit = list[j].murl;\\\\n            if (/\\\\\\\\/vod\\\\\\\\//.test(link)) {\\\\n                if (/37\\\\\\\\.161|216\\\\\\\\.98|phoebe|hfys8|feifan12|tvzy|hdyangtv|tkys|tegouys/.test(link)) {\\\\n                    var hmurl = link + '?ac=list&zm=' + key + '&page=fypage';\\\\n                } else {\\\\n                    var hmurl = link + '?ac=list&wd=' + key + '&page=fypage';\\\\n                }\\\\n            } else {\\\\n                if (/dijiaxia/.test(link)) {\\\\n                    link = 'http://www.dijiaxia.com/api.php/app/'\\\\n                };\\\\n                if (link.indexOf('api.php/app/') != -1) {\\\\n                    var hmurl = link + 'search?pg=fypage&text=' + key + '&token=';\\\\n                } else if (link.indexOf('xgapp.php/v1/') != -1) {\\\\n                    var hmurl = link + 'search?pg=fypage&text=' + key;\\\\n                } else {\\\\n                    if (/iopenyun/.test(link)) {\\\\n                        var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\\\n                    } else {\\\\n                        var hmurl = link + '?page=fypage&limit=10&wd=' + key;\\\\n                    }\\\\n                }\\\\n            }\\\\n            items.push({\\\\n                title: list[j].title,\\\\n                img: list[j].img,\\\\n                url: $('hiker://empty#x#' + hmurl + '#x#' + link + '#x#' + litit + '#x#' + key + '#x#').rule(() => {\\\\n                    $.require('hiker://page/searerj');\\\\n                }),\\\\n                col_type: 'icon_round_small_4'\\\\n                //col_type: 'text_3'\\\\n                //link:link,\\\\n                //type: i\\\\n            });\\\\n\\\\n        } //for j\\\\n\\\\n\\\\n    } //for i\\\\n\\\\n} //end mode 0\\\\n\\\\n\\\\nres.data = items;\\\\nsetHomeResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"APP分类列表\\\",\\\"path\\\":\\\"applistdata\\\",\\\"rule\\\":\\\"if (html.list) {\\\\n    var list = html.list;\\\\n} else if (html.data && html.data.list) {\\\\n    var list = html.data.list;\\\\n} else {\\\\n    var list = html.data;\\\\n}\\\\n//log(list);\\\\nfor (var i = 0; i < list.length; i++) {\\\\n    var title = list[i].vod_name;\\\\n    var img = list[i].vod_pic;\\\\n    var url = list[i].vod_id;\\\\n    var desc = list[i].vod_remarks;\\\\n    var nowDate = new Date();\\\\n    var month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\n    var day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\n    var dateStr = month + '' + day;\\\\n    if (html.list) {\\\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    } else if (html.data && html.data.list) {\\\\n        if (murl.search(/mogai_api/) != -1) {\\\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else if (murl.includes('grelighting')) {\\\\n            var link = murl + '/?ids=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else {\\\\n            var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\\\n        }\\\\n    } else {\\\\n        var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    };\\\\n    if (/fantuan/.test(murl)) {\\\\n        var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    } else if (/iopenyun/.test(murl)) {\\\\n        var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n    } else if (/dijiaxia/.test(murl)) {\\\\n        var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\\\n    }\\\\n    items.push({\\\\n        title: title,\\\\n        pic_url: img + '@Referer=',\\\\n        url: $(link).rule(() => {\\\\n            var res = {};\\\\n            var items = [];\\\\n            items.push({\\\\n                title: '',\\\\n                desc: '255&&float',\\\\n                url: '',\\\\n                col_type: 'x5_webview_single'\\\\n            });\\\\n            refreshX5WebView('');\\\\n            var html = JSON.parse(getResCode());\\\\n            var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n            try {\\\\n                eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n            } catch (e) {}\\\\n            res.data = items;\\\\n            setHomeResult(res);\\\\n        }),\\\\n        desc: desc,\\\\n        col_type: 'movie_3_marquee'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"TV列表解析\\\",\\\"path\\\":\\\"tvlistdata\\\",\\\"rule\\\":\\\"var list = html.data;\\\\nfor (var i = 0; i < list.length; i++) {\\\\n    var title = list[i].title;\\\\n    var img = list[i].pic;\\\\n    var url = list[i].nextlink;\\\\n    var desc = list[i].state;\\\\n    url = url.startsWith('http') ? url : murl + '?ac=detail&ids=' + url;\\\\n    items.push({\\\\n        title: title,\\\\n        pic_url: img + '@Referer=',\\\\n        url: $(url).rule(() => {\\\\n            var res = {};\\\\n            var items = [];\\\\n            var html = JSON.parse(getResCode());\\\\n            var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n            items.push({\\\\n                title: '',\\\\n                desc: '255&&float',\\\\n                url: '',\\\\n                col_type: 'x5_webview_single'\\\\n            });\\\\n            refreshX5WebView('');\\\\n            try {\\\\n            eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\\\n            } catch (e) {}\\\\n            res.data = items;\\\\n            setHomeResult(res);\\\\n        }),\\\\n        desc: desc,\\\\n        col_type: 'movie_3_marquee'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"APP简介与选集\\\",\\\"path\\\":\\\"appmovlist\\\",\\\"rule\\\":\\\"if (html.data.vod_url_with_player) {\\\\n    var conts = html.data.vod_url_with_player;\\\\n    if (conts.length < 1) {\\\\n        conts = html.data.vod_play_url.split('$$$');\\\\n        var tabs = html.data.vod_play_from.split('$$$');\\\\n    }\\\\n} else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n    var conts = html.data.vod_info.vod_url_with_player;\\\\n    if (conts.length < 1) {\\\\n        conts = html.data.vod_info.vod_play_url.split('$$$');\\\\n        var tabs = html.data.vod_info.vod_play_from.split('$$$');\\\\n    }\\\\n} else if (html.data.list) {\\\\n    var conts = html.data.list[0].vod_play_url.split('$$$');\\\\n    var tabs = html.data.list[0].vod_play_from.split('$$$');\\\\n} else if (html.data.length == 1) {\\\\n    var conts = html.data[0].vod_play_list;\\\\n    //log(conts);\\\\n    if (conts.length < 1) {\\\\n        conts = html.data[0].vod_play_url.split('$$$');\\\\n        var tabs = html.data[0].vod_play_from.split('$$$');\\\\n    }\\\\n} else {\\\\n    var conts = html.data.vod_play_list;\\\\n    if (conts.length < 1) {\\\\n        conts = html.data.vod_play_url.split('$$$');\\\\n        var tabs = html.data.vod_play_from.split('$$$');\\\\n    }\\\\n};\\\\n\\\\n//log(html);\\\\n\\\\nif (html.data.length == 1) {\\\\n    var thumb = html.data[0].vod_pic;\\\\n    var des = html.data[0].vod_content;\\\\n} else if (html.data.list) {\\\\n    var thumb = html.data.list[0].vod_pic;\\\\n    var des = html.data.list[0].vod_content;\\\\n} else {\\\\n    var thumb = html.data.vod_info ? html.data.vod_info.vod_pic : html.data.vod_pic;\\\\n    var des = html.data.vod_info ? html.data.vod_info.vod_content : html.data.vod_content;\\\\n};\\\\nitems.push({\\\\n    title: '剧情简介：',\\\\n    desc: des,\\\\n    pic_url: thumb,\\\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\\\n        setResult([{\\\\n            title: des,\\\\n            col_type: 'long_text'\\\\n        }]);\\\\n    }, des),\\\\n    col_type: 'movie_1_vertical_pic'\\\\n});\\\\neval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\\\n\\\\nitems.push({\\\\n    title: '““排序””',\\\\n    url: \\\\\\\"hiker://empty@lazyRule=.js:putMyVar('appmappsort', getMyVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\\\\\",\\\\n    col_type: 'scroll_button'\\\\n});\\\\nvar title = MY_URL;\\\\nfor (var k = 0; k < conts.length; k++) {\\\\n    //setError(list.length);\\\\n    if (html.data.vod_url_with_player) {\\\\n        var ptab = conts[k].code ? conts[k].code : tabs[k];\\\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n        var ptab = conts[k].code ? conts[k].code : tabs[k];\\\\n    } else {\\\\n        var ptab = conts[k].from ? conts[k].from : tabs[k];\\\\n    }\\\\n    items.push({\\\\n        title: (getMyVar(title, '0') == k ? '👉🏻' : '') + ptab,\\\\n        url: `hiker://empty@lazyRule=.js:putMyVar('` + title + \\\\\\\"', '\\\\\\\" + k + `');refreshPage();'toast://切换成功！'`,\\\\n        col_type: 'scroll_button'\\\\n    });\\\\n\\\\n}\\\\n\\\\n\\\\n\\\\nvar jiek = '';\\\\n//for (var i = 0; i < conts.length; i++) {\\\\nif (getMyVar('appmappsort', '1') == '1') {\\\\n    if (conts[getMyVar(title, '0')].urls) {\\\\n        var list = conts[getMyVar(title, '0')].urls;\\\\n    } else if (conts[getMyVar(title, '0')].url) {\\\\n        var list = conts[getMyVar(title, '0')].url.split(\\\\\\\"#\\\\\\\");\\\\n    } else {\\\\n        var list = conts[getMyVar(title, '0')].split(\\\\\\\"#\\\\\\\");\\\\n    };\\\\n} else {\\\\n    if (conts[getMyVar(title, '0')].urls) {\\\\n        var list = conts[getMyVar(title, '0')].urls.reverse();\\\\n    } else if (conts[getMyVar(title, '0')].url) {\\\\n        var list = conts[getMyVar(title, '0')].url.split(\\\\\\\"#\\\\\\\").reverse();\\\\n    } else {\\\\n        var list = conts[getMyVar(title, '0')].split(\\\\\\\"#\\\\\\\").reverse();\\\\n    }\\\\n};\\\\n//setError(list.length);\\\\nif (html.data.vod_url_with_player) {\\\\n    var ptab = conts[getMyVar(title, '0')].code ? conts[getMyVar(title, '0')].code : tabs[getMyVar(title, '0')];\\\\n} else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n    var ptab = conts[getMyVar(title, '0')].code ? conts[getMyVar(title, '0')].code : tabs[getMyVar(title, '0')];\\\\n} else {\\\\n    var ptab = conts[getMyVar(title, '0')].from ? conts[getMyVar(title, '0')].from : tabs[getMyVar(title, '0')];\\\\n}\\\\n/*\\\\n    items.push({\\\\n        title: ptab + ' 🔗' + [i + 1] + '/' + [conts.length] + \\\\\\\"““↓↑””\\\\\\\",\\\\n        url: \\\\\\\"hiker://empty@lazyRule=.js:putVar('appmappsort', getVar('appmappsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\\\\\",\\\\n        col_type: 'scroll_button'\\\\n    });*/\\\\nvar vlink = {};\\\\nfor (var j = 0; j < list.length; j++) {\\\\n    if (conts[getMyVar(title, '0')].urls) {\\\\n        var vlink = list[j].url.replace(/#456#/g, 'http').replace(/#123#/g, '.').replace(/#789#/g, ':');\\\\n        var vtitle = list[j].name;\\\\n    } else {\\\\n        //var vlink = list[j].split(\\\\\\\"$\\\\\\\")[1];\\\\n        if (list[j].split('$')[1] != null) {\\\\n            vlink = list[j].split('$')[1];\\\\n        } else {\\\\n            vlink = list[j].split('$')[0];\\\\n        }\\\\n        //var title = list[j].split(\\\\\\\"$\\\\\\\")[0];                               \\\\n        var vtitle = (list[j].split('$')[0].includes('http') ? [j + 1] : list[j].split('$')[0]);\\\\n    }\\\\n    try {\\\\n        if (html.data.vod_url_with_player) {\\\\n            var jiek = conts[getMyVar(title, '0')].parse_api;\\\\n        } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n            var jiek = conts[getMyVar(title, '0')].parse_api;\\\\n        } else {\\\\n            if (conts[getMyVar(title, '0')].player_info.parse2 && (conts[getMyVar(title, '0')].player_info.parse2).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                var jiek = (conts[getMyVar(title, '0')].player_info.parse2).replace(/\\\\\\\\.\\\\\\\\./g, \\\\\\\".\\\\\\\").split(',')[0].replace('jsonbs', '');\\\\n            } else if (conts[getMyVar(title, '0')].player_info.parse && (conts[getMyVar(title, '0')].player_info.parse).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                var jiek = (conts[getMyVar(title, '0')].player_info.parse).replace(/\\\\\\\\.\\\\\\\\./g, \\\\\\\".\\\\\\\").split(',')[0];\\\\n            } else {\\\\n                var jiek = \\\\\\\"\\\\\\\";\\\\n            }\\\\n            //setError(jiek);                \\\\n        }\\\\n    } catch (e) {}\\\\n    //jiek拼接\\\\n    if (jiek != '' && jiek != null) {\\\\n        if (jiek.substring(0, 4) == 'http') {\\\\n            jiek = jiek;\\\\n        } else if (jiek.substring(0, 2) == '\\\\\\\\/\\\\\\\\/') {\\\\n            jiek = 'https:' + jiek;\\\\n        }\\\\n    } else {\\\\n        jiek = \\\\\\\"\\\\\\\";\\\\n    }\\\\n    //对失效接口进行替换\\\\n    if (/cokemv/.test(myurl) && /cokeqie|xin|90mm/.test(ptab)) {\\\\n        jiek = 'https://player.90mm.me/play.php?url=';\\\\n    } else if (/\\\\\\\\.m3u8\\\\\\\\.tv|www\\\\\\\\.x-n\\\\\\\\.cc/.test(jiek)) {\\\\n        jiek = 'https://jx.m3u8.tv/jiexi/?url=';\\\\n    } else if (/cjt521/.test(myurl)) {\\\\n        jiek = conts[getMyVar(title, '0')].player_info.parse;\\\\n    } else if (jiek.indexOf('jpg.hou.lu/jm/za/index.php') != -1) {\\\\n        jiek = 'http://vip.mengx.vip/home/api?type=ys&uid=3249696&key=aefqrtuwxyEFHKNOQY&url=';\\\\n    } else if (ptab == 'renrenmi' && jiek.search(/jhdyw/) != -1) {\\\\n        jiek = 'http://www.1080kan.cc/jiexi/rrmi.php?url=';\\\\n    } else if (ptab == 'fqfilm' && jiek.search(/jhdyw/) != -1) {\\\\n        jiek = 'http://www.1080kan.cc/jiexi/fq.php?url=';\\\\n    } else if (ptab == 'rrsp' && jiek.search(/jhdyw/) != -1) {\\\\n        jiek = 'http://www.1080kan.cc/jiexi/rr.php?url=';\\\\n    } else if (/miaoparty/.test(ptab) && myurl.search(/fun4k/) != -1) {\\\\n        jiek = 'https://www.fun4k.com/aplayer/?url=';\\\\n    } else if (/jhyun\\\\\\\\.php/.test(jiek)) {\\\\n        jiek = jiek.replace('http://svip.jhyun.jx.cn:1234/jhyun.php?url=', 'https://api.jhdyw.vip/?url=');\\\\n    } else if (/www\\\\\\\\.ailemo\\\\\\\\.me/.test(jiek)) {\\\\n        jiek = jiek.replace('ailemo', 'ailemoo');\\\\n    };\\\\n    //打印接口\\\\n    try {\\\\n        if (j == '0') {\\\\n            if (html.data.vod_url_with_player) {\\\\n                log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + jiek);\\\\n            } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n                log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + jiek);\\\\n            } else {\\\\n                if (conts[getMyVar(title, '0')].player_info.parse2 && (conts[getMyVar(title, '0')].player_info.parse2).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                    log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + conts[getMyVar(title, '0')].player_info.parse2.replace(/\\\\\\\\.\\\\\\\\./g, \\\\\\\".\\\\\\\").replace(/\\\\\\\\,/g, \\\\\\\"\\\\\\\\n\\\\\\\\n\\\\\\\"));\\\\n                } else if (conts[getMyVar(title, '0')].player_info.parse && (conts[getMyVar(title, '0')].player_info.parse).indexOf(\\\\\\\"=\\\\\\\") != -1) {\\\\n                    log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + conts[getMyVar(title, '0')].player_info.parse.replace(/\\\\\\\\.\\\\\\\\./g, \\\\\\\".\\\\\\\").replace(/\\\\\\\\,/g, \\\\\\\"\\\\\\\\n\\\\\\\\n\\\\\\\"));\\\\n                } else {\\\\n                    log('\\\\\\\\n线路：' + ptab + '\\\\\\\\n视频：' + vlink + '\\\\\\\\n' + '解析接口：\\\\\\\\n' + jiek);\\\\n                }\\\\n                //setError(jiek);                \\\\n            }\\\\n        }\\\\n    } catch (e) {}\\\\n    //声明链接\\\\n    var link = jiek + vlink;\\\\n    /*\\\\n    if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos/.test(vlink) && /http/.test(vlink)) {\\\\n        link = vlink;\\\\n    }\\\\n    */\\\\n    //log(link);\\\\n\\\\n    try {\\\\n        vtitle = vtitle.match(/(第|\\\\\\\\d|-)*(集|话|期)/g) ? vtitle.replace(/第|集|话|期/g, '') : vtitle.replace(/^\\\\\\\\s*/, \\\\\\\"\\\\\\\");\\\\n    } catch (e) {}\\\\n\\\\n    if (list.length <= 4) {\\\\n        var clt = 'text_2';\\\\n    } else {\\\\n        var clt = isNaN(vtitle) ? 'flex_button' : 'text_5'\\\\n    };\\\\n    items.push({\\\\n        title: vtitle,\\\\n        url: $('hiker://empty').lazyRule((ptab, link, myurl, vlink) => {\\\\n                function openurl(resurl) {\\\\n                    if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili|ixigua/) != -1) {\\\\n                        //html网页调用断插解析\\\\n                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                        if (enDn == '1') {\\\\n                            log('调用断插解析html');\\\\n                            eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                            eval(fetch(config.cj));\\\\n                            return aytmParse(resurl);\\\\n                        } else {\\\\n                            return resurl\\\\n                        };\\\\n                    } else if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos|netease\\\\\\\\.com/.test(resurl) && /http/.test(resurl) && !/\\\\\\\\.html|\\\\\\\\.m3u8\\\\\\\\.tv/.test(resurl) && !/\\\\\\\\=http/.test(resurl) && ptab != 'duoduozy') {\\\\n                        if (/wkfile/.test(resurl)) {\\\\n                            return resurl + ';{Referer@https://fantuan.wkfile.com/}'\\\\n                        } else {\\\\n                            return /\\\\\\\\=ht/.test(resurl) ? resurl.substring(resurl.indexOf('=ht') + 1) : resurl + '#isVideo=true#';\\\\n                        }\\\\n                    } else {\\\\n                        //调用断插通用函数解析\\\\n                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                        if (enDn == '1') {\\\\n                            log('调用断插通用函数解析\\\\\\\\n' + ptab + '(通用函数)');\\\\n                            eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                            eval(fetch(config.cj));\\\\n                            var name = ptab + '(通用函数)';\\\\n                            return ParseS[name](resurl, myurl);\\\\n\\\\n                        } else if (ptab == 'ddzy') {\\\\n                            function getrandom(urlstr) {\\\\n                                randStr = urlstr.substring(0, 8);\\\\n                                string = urlstr.substring(8, urlstr.length);\\\\n                                substr = base64Decode(string);\\\\n                                return substr.substring(8, substr.length - 8);\\\\n                            };\\\\n                            var jxhtml = request(\\\\\\\"https://play.suoyou.cc/xplay/?url=\\\\\\\" + vlink, {\\\\n                                headers: {\\\\n                                    \\\\\\\"Referer\\\\\\\": \\\\\\\"https://www.jubaibai.cc/\\\\\\\"\\\\n                                }\\\\n                            });\\\\n                            eval(jxhtml.match(/var config[\\\\\\\\s\\\\\\\\S]*?}/)[0]);\\\\n                            var ddwy = post(\\\\\\\"https://play.suoyou.cc/xplay/hd0L3TjH4m8zSK1N.jpg\\\\\\\", {\\\\n                                headers: {\\\\n                                    \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                                },\\\\n                                body: {\\\\n                                    \\\\\\\"url\\\\\\\": config.url,\\\\n                                    \\\\\\\"vkey\\\\\\\": config.vkey,\\\\n                                    \\\\\\\"token\\\\\\\": config.token\\\\n                                }\\\\n                            });\\\\n                            return getrandom(JSON.parse(ddwy).url);\\\\n                        } else if (/miaoparty/.test(ptab)) {\\\\n                            requireCache('https://agit.ai/lzk23559/PublicRule/raw/branch/master/x5rule.js', 24);\\\\n                            return x5rule('https://www.fun4k.com/aplayer/?url=' + resurl);\\\\n                        } else {\\\\n                            return resurl\\\\n                        };\\\\n                    }\\\\n                };\\\\n\\\\n                try {\\\\n                    /*\\\\n                                        var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                                        if (enDn == '1' && vlink.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && vlink.search(/html|bilibili|ixigua/) != -1) {\\\\n                                            log('已开启断插，将调用断插解析html');\\\\n                                            eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                                            eval(fetch(config.cj));\\\\n                                            return aytmParse(vlink);\\\\n                                        };*/\\\\n                } catch (e) {}\\\\n\\\\n                var srcurl = link;\\\\n                //log(srcurl);\\\\n                //动态解析代码开始\\\\n                try {\\\\n                    //处理指定视频与线路\\\\n                    if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos|netease\\\\\\\\.com/.test(srcurl) && /http/.test(srcurl) && !/\\\\\\\\.html|\\\\\\\\.m3u8\\\\\\\\./.test(srcurl) && !/\\\\\\\\=http/.test(srcurl)) {\\\\n                        if (/wkfile/.test(srcurl)) {\\\\n                            return srcurl + ';{Referer@https://fantuan.wkfile.com/}'\\\\n                        } else {\\\\n                            return /\\\\\\\\=ht/.test(srcurl) ? srcurl.substring(srcurl.indexOf('=ht') + 1) : srcurl + '#isVideo=true#';\\\\n                        }\\\\n                    } else if (/hd8\\\\\\\\.pw/.test(vlink) && /\\\\\\\\.m3u8|\\\\\\\\.mp4/.test(vlink)) {\\\\n                        return vlink;\\\\n                    } else if (srcurl.indexOf(\\\\\\\"/share/\\\\\\\") != -1) {\\\\n                        try {\\\\n                            var link = srcurl.split(\\\\\\\"/share\\\\\\\")[0];\\\\n                            var fc = fetch(srcurl, {}).replace(\\\\\\\"var purl\\\\\\\", \\\\\\\"var main\\\\\\\");\\\\n                            if (fc.indexOf(\\\\\\\"main\\\\\\\") != -1) {\\\\n                                var mat = fc.match(/var main.*?;/)[0];\\\\n                                eval(mat);\\\\n                                var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main);\\\\n                            } else {\\\\n                                var main = fc.match(/url:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1];\\\\n                                var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main)\\\\n                            };\\\\n                            return play;\\\\n                        } catch (e) {\\\\n                            return 'x5WebView://' + (srcurl)\\\\n                        }\\\\n\\\\n                    } else if (/983vip/.test(srcurl)) {\\\\n                        return JSON.parse(fetch(srcurl, {\\\\n                            headers: {\\\\n                                \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                            },\\\\n                            redirect: false,\\\\n                            withHeaders: true\\\\n                        })).headers.location[0];\\\\n                    } else if (/x\\\\\\\\-n\\\\\\\\.cc|nhdz666/.test(srcurl) && /\\\\\\\\.html|bilibili/.test(srcurl)) {\\\\n                        return openurl(vlink);\\\\n                    }\\\\n                    //处理指定视频和线路结束\\\\n                    //----分割线----//\\\\n                    var scode = JSON.parse(fetch(srcurl, {\\\\n                        headers: {\\\\n                            \\\\\\\"User-Agent\\\\\\\": \\\\\\\"okhttp/4.1.0\\\\\\\"\\\\n                        },\\\\n                        redirect: false,\\\\n                        withStatusCode: true\\\\n                    }));\\\\n                    //log(scode);\\\\n                    if (scode.statusCode == '302' || scode.statusCode == '301') {\\\\n                        //打开解析有302重定向的链接\\\\n                        var redurl = scode.headers.location[0].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                        if (/\\\\\\\\=http/.test(redurl) && /html|bilibili|key\\\\\\\\=/.test(redurl)) {\\\\n                            return JSON.parse(fetch(redurl, {})).url;\\\\n                        } else if (/\\\\\\\\=http/.test(redurl) && /\\\\\\\\.m3u8|\\\\\\\\.mp4|\\\\\\\\.flv/.test(redurl)) {\\\\n                            return redurl.substring(redurl.indexOf('=http') + 1);\\\\n                        } else if (/http/.test(redurl) && /key\\\\\\\\=|uid\\\\\\\\=|vid\\\\\\\\=/.test(redurl)) {\\\\n                            return JSON.parse(fetch(redurl, {})).url;\\\\n                        } else if (/http/.test(redurl) && /html|bilibili/.test(redurl)) {\\\\n                            return openurl(vlink);\\\\n                        } else {\\\\n                            return redurl\\\\n                        }\\\\n                    } else {\\\\n                        //var html = request(srcurl);\\\\n                        var html = scode.body;\\\\n                        //log(html);\\\\n                        if (/404 Not Found|备案后可继续访问/.test(html)) {\\\\n                            return openurl(vlink);\\\\n                        } else if (/\\\\\\\\<body/.test(html)) {\\\\n                            log('尝试非JSON接口网页解析');\\\\n                            requireCache('https://agit.ai/lzk23559/PublicRule/raw/branch/master/x5rule.js', 24);\\\\n                            return x5rule(srcurl, srcurl);\\\\n                            //return openurl(srcurl);\\\\n                        } else {\\\\n                            //json解析的取链接\\\\n                            var purl = html.match(/[\\\\\\\\'\\\\\\\\\\\\\\\"]url[\\\\\\\\'\\\\\\\\\\\\\\\"]:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                            //log(purl);\\\\n                            if (/http/.test(purl)) {\\\\n                                if (ptab == 'bilibili') {\\\\n                                    return purl + ';{Referer@https://www.bilibili.com/&&User-Agent@Mozilla/5.0}';\\\\n                                } else if (ptab == 'mgtv') {\\\\n                                    return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                                } else if (/ojbk/.test(purl)) {\\\\n                                    return purl + ';{Referer@https://bak.ojbkjx.com/}';\\\\n                                } else if (/video_mp4|type\\\\\\\\=m3u8|pt\\\\\\\\=m3u8|\\\\\\\\/video\\\\\\\\/tos\\\\\\\\//.test(purl)) {\\\\n                                    return purl + '#isVideo=true#';\\\\n                                } else {\\\\n                                    return purl\\\\n                                };\\\\n                            } else {\\\\n                                //非http开头的打开原链接                                                                \\\\n                                return openurl(vlink)\\\\n                            }\\\\n                        }\\\\n                    }\\\\n                } catch (e) {\\\\n                    //报错判断处理\\\\n                    log('执行报错跳转处理');\\\\n                    /*if (srcurl.substring(0, 2) == '\\\\\\\\/\\\\\\\\/') {\\\\n                        return openurl('https:' + srcurl);\\\\n                    } else if (/\\\\\\\\=http/.test(srcurl) && /\\\\\\\\.html|bilibili/.test(srcurl)) {\\\\n                        //return srcurl.split('=')[1];\\\\n                        return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\\\n                    } else {*/\\\\n                    return openurl(vlink)\\\\n                    //return 'x5WebView://'+srcurl\\\\n                    //}\\\\n                }\\\\n                //动态解析代码结束\\\\n            },\\\\n            ptab,\\\\n            link,\\\\n            myurl,\\\\n            vlink),\\\\n        col_type: clt\\\\n    });\\\\n}\\\\n//}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"TV简介与选集\\\",\\\"path\\\":\\\"tvmovlist\\\",\\\"rule\\\":\\\"var tabs = Object.keys(html.videolist);\\\\nvar thumb = html.img_url;\\\\nitems.push({\\\\n    title: '剧情简介：',\\\\n    desc: html.intro,\\\\n    pic_url: thumb,\\\\n    url: $('hiker://empty#noRecordHistory#').rule((des) => {\\\\n        setResult([{\\\\n            title: des,\\\\n            col_type: 'long_text'\\\\n        }]);\\\\n    }, html.intro),\\\\n    col_type: 'movie_1_vertical_pic'\\\\n});\\\\neval(JSON.parse(fetch('hiker://page/dnplugin', {})).rule);\\\\n\\\\nitems.push({\\\\n    title: '““排序””',\\\\n    url: \\\\\\\"hiker://empty@lazyRule=.js:putMyVar('appmtvsort', getMyVar('appmtvsort','1')=='1'?'0':'1');refreshPage(false);'toast://切换成功！'\\\\\\\",\\\\n    col_type: 'scroll_button'\\\\n});\\\\nvar gva = MY_URL;\\\\nfor (var k = 0; k < tabs.length; k++) {\\\\n    var ptab = tabs[k];\\\\n    items.push({\\\\n        title: (getMyVar(gva, '0') == k ? '👉🏻' : '') + ptab,\\\\n        url: `hiker://empty@lazyRule=.js:putMyVar('` + gva + \\\\\\\"', '\\\\\\\" + k + `');refreshPage();'toast://切换成功！'`,\\\\n        col_type: 'scroll_button'\\\\n    });\\\\n\\\\n}\\\\n\\\\n//for (var i = 0; i < tabs.length; i++) {\\\\nif (getMyVar('appmtvsort', '1') == '1') {\\\\n    var list = html.videolist[tabs[getMyVar(gva, '0')]];\\\\n} else {\\\\n    var list = html.videolist[tabs[getMyVar(gva, '0')]].reverse();\\\\n};\\\\n\\\\nfor (var j = 0; j < list.length; j++) {\\\\n    var srcurl = list[j].url;\\\\n    if (/293jx1/.test(srcurl)) {\\\\n        srcurl = srcurl.replace('293jx1', 'jx');\\\\n    } else if (/8d8q|diliktv|haokanju1|cztv|fit\\\\\\\\:8|ppzhu/.test(myurl)) {\\\\n        srcurl = srcurl + '&app=10000&account=272775028&password=qq272775028';\\\\n    }\\\\n    var title = list[j].title;\\\\n    title = title.match(/(第|\\\\\\\\d|-)*(集|话|期)/g) ? title.replace(/第|集|话|期/g, '') : title;\\\\n    if (list.length <= 4) {\\\\n        var clt = 'text_2';\\\\n    } else {\\\\n        var clt = isNaN(title) ? 'flex_button' : 'text_5'\\\\n    };\\\\n    items.push({\\\\n        title: title,\\\\n        url: $('hiker://empty').lazyRule((ptab, srcurl, myurl) => {\\\\n            function openurl(resurl) {\\\\n                if (resurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && resurl.search(/html|bilibili/) != -1) {\\\\n                    var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                    if (enDn == '1') {\\\\n                        log('调用断插解析');\\\\n                        eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                        eval(fetch(config.cj));\\\\n                        return aytmParse(resurl);\\\\n                    } else {\\\\n                        return resurl\\\\n                    };\\\\n                } else if (/\\\\\\\\=LT\\\\\\\\-/.test(resurl)) {\\\\n                    log('调用断插ltnb通用解析');\\\\n                    eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                    eval(fetch(config.cj));\\\\n                    var name = 'ltnb(通用函数)';\\\\n                    return ParseS[name](resurl.substring(resurl.indexOf('=LT-') + 1));\\\\n                } else {\\\\n                    return resurl\\\\n                }\\\\n            };\\\\n\\\\n            try {\\\\n                var enDn = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\n                if (enDn == '1' && srcurl.match(/youku|mgtv|ixigua|qq.com|qiyi|migu|bilibili|sohu|pptv|le|1905.com/) && srcurl.search(/html|bilibili|ixigua/) != -1) {\\\\n                    log('已开启断插，将调用断插解析html');\\\\n                    eval(\\\\\\\"var config =\\\\\\\" + fetch(\\\\\\\"hiker://files/cache/MyParseSet.json\\\\\\\"));\\\\n                    eval(fetch(config.cj));\\\\n                    return aytmParse(srcurl.substring(srcurl.indexOf('=http') + 1));\\\\n                };\\\\n            } catch (e) {}\\\\n\\\\n            //log(srcurl);\\\\n            //动态解析代码开始\\\\n            try {\\\\n                if (/\\\\\\\\.m3u8|\\\\\\\\.mp4|obj\\\\\\\\/tos/.test(srcurl) && /http/.test(srcurl)) {\\\\n                    return /\\\\\\\\=ht/.test(srcurl) ? srcurl.substring(srcurl.indexOf('=ht') + 1) : srcurl + '#isVideo=true#';\\\\n                } else if (srcurl.indexOf(\\\\\\\"/share/\\\\\\\") != -1) {\\\\n                    try {\\\\n                        var link = srcurl.split(\\\\\\\"/share\\\\\\\")[0];\\\\n                        var fc = fetch(srcurl, {}).replace(\\\\\\\"var purl\\\\\\\", \\\\\\\"var main\\\\\\\");\\\\n                        if (fc.indexOf(\\\\\\\"main\\\\\\\") != -1) {\\\\n                            var mat = fc.match(/var main.*?;/)[0];\\\\n                            eval(mat);\\\\n                            var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main);\\\\n                        } else {\\\\n                            var main = fc.match(/url:.*?[\\\\\\\\'\\\\\\\\\\\\\\\"](.*?)[\\\\\\\\'\\\\\\\\\\\\\\\"]/)[1];\\\\n                            var play = (main.indexOf(\\\\\\\"http\\\\\\\") != -1 ? main : link + main)\\\\n                        };\\\\n                        return play;\\\\n                    } catch (e) {\\\\n                        return 'x5WebView://' + (srcurl)\\\\n                    }\\\\n                } else if (ptab == 'alizy') {\\\\n                    var purl = fetch('https://foubin.com/jiexi.php?url=' + srcurl, {}).match(/\\\\\\\\\\\\\\\"url\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"(.*?)\\\\\\\\\\\\\\\"/)[1];\\\\n                    return purl;\\\\n                } else if (/19jx\\\\\\\\.vip|nfyingshi/.test(srcurl)) {\\\\n                    var purl = JSON.parse(fetch(srcurl.replace('http://', 'https://'), {\\\\n                        headers: {\\\\n                            \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                        },\\\\n                        redirect: false,\\\\n                        withHeaders: true\\\\n                    })).headers.location[0];\\\\n                    if (/titan.mgtv/.test(purl)) {\\\\n                        return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                    } else if (/obj\\\\\\\\/tos/.test(purl)) {\\\\n                        return purl + '#isVideo=true#';\\\\n                    } else {\\\\n                        return purl\\\\n                    };\\\\n                }\\\\n                /*else if (/zhaikanys/.test(srcurl)) {\\\\n                                       var purl = JSON.parse(fetch(srcurl + '&app=10003&account=272775028&password=qq272775028', {\\\\n                                           headers: {\\\\n                                               \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                                           },\\\\n                                           redirect: false,\\\\n                                           withHeaders: true\\\\n                                       })).headers.location[0];\\\\n                                       if (/titan.mgtv/.test(purl)) {\\\\n                                           return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                                       } else if (/obj\\\\\\\\/tos/.test(purl)) {\\\\n                                           return purl + '#isVideo=true#';\\\\n                                       } else {\\\\n                                           return purl\\\\n                                       };\\\\n                                   }*/\\\\n\\\\n                //----分割线----//\\\\n                var scode = JSON.parse(fetch(srcurl, {\\\\n                    headers: {\\\\n                        \\\\\\\"User-Agent\\\\\\\": MOBILE_UA\\\\n                    },\\\\n                    redirect: false,\\\\n                    withStatusCode: true\\\\n                }));\\\\n                //log(scode);\\\\n                if (scode.statusCode == '302' || scode.statusCode == '301') {\\\\n                    var purl = scode.headers.location[0].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                } else {\\\\n                    //var html = request(srcurl);\\\\n                    var html = scode.body;\\\\n                    //log(html);\\\\n                    if (/404 Not Found|备案后可继续访问|不存在/.test(html) || html == '') {\\\\n                        return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\\\n                    } else if (/\\\\\\\\\\\\\\\"url\\\\\\\\\\\\\\\"\\\\\\\\:\\\\\\\\\\\\\\\"http/.test(html)) {\\\\n                        var purl = html.match(/\\\\\\\\\\\\\\\"url\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"(.*?)\\\\\\\\\\\\\\\"/)[1].replace(/\\\\\\\\\\\\\\\\/g, '');\\\\n                    } else if (html.startsWith('{')) {\\\\n                        var purl = srcurl.substring(srcurl.indexOf('=http') + 1);\\\\n                    } else {\\\\n                        //var purl = srcurl\\\\n                        requireCache('https://agit.ai/lzk23559/PublicRule/raw/branch/master/x5rule.js', 24);\\\\n                        return x5rule(srcurl, srcurl);\\\\n                        //return 'x5WebView://'+(srcurl) \\\\n                    }\\\\n                };\\\\n                //log(purl);\\\\n                if (/titan.mgtv/.test(purl)) {\\\\n                    return purl + '#isVideo=true#' + ';{Referer@www.mgtv.com&&User-Agent@Mozilla/5.0}';\\\\n                } else if (/obj\\\\\\\\/tos/.test(purl)) {\\\\n                    return purl + '#isVideo=true#';\\\\n                } else {\\\\n                    return purl\\\\n                };\\\\n\\\\n            } catch (e) {\\\\n                if (srcurl.substring(0, 2) == '\\\\\\\\/\\\\\\\\/') {\\\\n                    return openurl('https:' + srcurl);\\\\n                } else if (/\\\\\\\\=http/.test(srcurl) && /\\\\\\\\.html|bilibili/.test(srcurl)) {\\\\n                    //return srcurl.split('=')[1];\\\\n                    return openurl(srcurl.substring(srcurl.indexOf('=http') + 1));\\\\n                } else {\\\\n                    return openurl(srcurl)\\\\n                }\\\\n            }\\\\n            //动态解析代码结束\\\\n        }, ptab, srcurl, myurl),\\\\n        col_type: clt\\\\n    });\\\\n}\\\\n//}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"列表模式搜索二级\\\",\\\"path\\\":\\\"searerj\\\",\\\"rule\\\":\\\"var res = {};\\\\nvar items = [];\\\\nvar nowDate = new Date();\\\\nvar month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\nvar day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\nvar dateStr = month + '' + day;\\\\nvar spl = getResCode().split('#x#');\\\\nvar typet = spl[3];\\\\nvar tdomin = spl[2];\\\\nvar key = spl[4];\\\\n\\\\nif (/vipmv/.test(tdomin)) {\\\\n    var bhtml = request(spl[1]);\\\\n} else {\\\\n    var bhtml = fetch(spl[1], {\\\\n        headers: {\\\\n            \\\\\\\"User-Agent\\\\\\\": tdomin.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? \\\\\\\"Dart/2.14 (dart:io)\\\\\\\" : \\\\\\\"okhttp/4.1.0\\\\\\\"\\\\n        }\\\\n    });\\\\n}\\\\ntry {\\\\n    bhtml = bhtml.startsWith('\\\\\\\\r\\\\\\\\n') ? bhtml.replace('\\\\\\\\r\\\\\\\\n', '') : bhtml;\\\\n} catch (e) {}\\\\nif (/btwaf/.test(bhtml)) {\\\\n    /*\\\\n                items.push({\\\\n                    title:'有宝塔验证，点击访问原网页',\\\\n                    url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n                    col_type: 'text_1'\\\\n                });\\\\n                */\\\\n\\\\n    bhtml = fetch(spl[1] + '&btwaf' + bhtml.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], {});\\\\n\\\\n}\\\\n//log(bhtml);\\\\nif (bhtml == \\\\\\\"\\\\\\\" || bhtml == null || bhtml.substring(0, 5) == 'error' || !bhtml.endsWith('}')) {\\\\n    items.push({\\\\n        title: '未搜索到相关资源，点击访问原网页',\\\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n        col_type: 'text_1'\\\\n    });\\\\n} else if (bhtml.length < 80) {\\\\n    items.push({\\\\n        title: '返回数据不完整，点击访问原网页',\\\\n        url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n        col_type: 'text_1'\\\\n    });\\\\n} else {\\\\n    var html = JSON.parse(bhtml);\\\\n    //log(spl[1]);\\\\n    if (html.list) {\\\\n        var list = html.list;\\\\n    } else if (html.data.list) {\\\\n        var list = html.data.list;\\\\n    } else if (html.data) {\\\\n        var list = html.data;\\\\n    }\\\\n\\\\n    if (list.length < 1) {\\\\n        items.push({\\\\n            title: '未搜索到，点击访问原网页',\\\\n            url: spl[1] + `@lazyRule=.js:input.split(';')[0]`,\\\\n            col_type: 'text_1'\\\\n        });\\\\n    } else {\\\\n        for (var i = 0; i < list.length; i++) {\\\\n\\\\n            if (/\\\\\\\\/vod\\\\\\\\//.test(tdomin)) {\\\\n                var title = list[i].title;\\\\n                var pic = list[i].pic;\\\\n                //var vid=tdomin+'/detail?vod_id='+list[i].nextlink+'&rel_limit=10';\\\\n                var vid = list[i].nextlink;\\\\n                var rem = list[i].state;\\\\n                //var con=list[i].state;\\\\n            } else {\\\\n                if (tdomin.indexOf('api.php/app/') != -1) {\\\\n                    var title = list[i].vod_name;\\\\n                    var pic = list[i].vod_pic;\\\\n                    if (/fantuan/.test(tdomin)) {\\\\n                        var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\\\n                    } else {\\\\n                        var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\\\n                    }\\\\n                    var rem = list[i].vod_remarks;\\\\n                    //var con=list[i].type.type_des;\\\\n                } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\\\n                    var title = list[i].vod_name;\\\\n                    var pic = list[i].vod_pic;\\\\n                    var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\\\n                    var rem = list[i].vod_remarks;\\\\n                    //var con=list[i].type.type_des;\\\\n                } else {\\\\n                    var title = list[i].vod_name;\\\\n                    var pic = list[i].vod_pic;\\\\n                    if (/iopenyun/.test(tdomin)) {\\\\n                        var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\\\n                    } else if(/grelighting/.test(tdomin)){\\\\n                        var vid = tdomin + '/?ids=' + list[i].vod_id + '&token=';\\\\n                    } else {\\\\n                        var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\\\n                    }\\\\n                    var rem = list[i].vod_remarks;\\\\n                    //var con=list[i].type.type_des;\\\\n                }\\\\n            }\\\\n\\\\n            items.push({\\\\n                title: title.replace(key, '““' + key + '””'),\\\\n                pic_url: pic + '@Referer=',\\\\n                url: $(tdomin.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((tdomin) => {\\\\n                    var res = {};\\\\n                    var items = [];\\\\n                    var html = JSON.parse(getResCode());\\\\n                    items.push({\\\\n                        title: '',\\\\n                        desc: '255&&float',\\\\n                        url: '',\\\\n                        col_type: 'x5_webview_single'\\\\n                    });\\\\n                    refreshX5WebView('');\\\\n                    var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n                    if (/\\\\\\\\/vod\\\\\\\\//.test(tdomin)) {\\\\n                        eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\\\n                    } else {\\\\n                        eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n                    }\\\\n                    res.data = items;\\\\n                    setHomeResult(res);\\\\n                }, tdomin),\\\\n                //content:rem,\\\\n                desc: rem,\\\\n                col_type: 'movie_1_vertical_pic'\\\\n            });\\\\n        } //for i\\\\n    } //else list.length\\\\n}\\\\n\\\\nres.data = items;\\\\nsetHomeResult(res);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"APP首页列表\\\",\\\"path\\\":\\\"appindexdata\\\",\\\"rule\\\":\\\"if (html.list) {\\\\n    var list = html.list;\\\\n} else if (html.data && html.data.list) {\\\\n    var list = html.data.list;\\\\n} else {\\\\n    var list = html.data;\\\\n}\\\\n\\\\nfor (var i = 0; i < list.length; i++) {\\\\n    if (list[i].vod_list) {\\\\n        var lists = list[i].vod_list;\\\\n        var typename = list[i].vod_type_name;\\\\n    } else {\\\\n        var lists = list[i].vlist;\\\\n        var typename = list[i].type_name\\\\n    }\\\\n    items.push({\\\\n        title: typename,\\\\n        col_type: 'text_1'\\\\n\\\\n    });\\\\n\\\\n    for (var j = 0; j < lists.length; j++) {\\\\n        var title = lists[j].vod_name;\\\\n        var img = lists[j].vod_pic;\\\\n        var url = lists[j].vod_id;\\\\n        var desc = lists[j].vod_remarks;\\\\n        var nowDate = new Date();\\\\n        var month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\n        var day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\n        var dateStr = month + '' + day;\\\\n        if (html.list) {\\\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else if (html.data && html.data.list) {\\\\n            if (murl.search(/mogai_api/) != -1) {\\\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n            } else if (murl.includes('grelighting')) {\\\\n                var link = murl + '/?ids=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n            } else {\\\\n                var link = murl + '/detail?key=' + dateStr + '&vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@okhttp/4.1.0}';\\\\n            }\\\\n        } else {\\\\n            var link = murl + 'video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        };\\\\n        if (/fantuan/.test(murl)) {\\\\n            var link = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + url + '&token=;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else if (/iopenyun/.test(murl)) {\\\\n            var link = murl + '/detailID?vod_id=' + url + '&rel_limit=10;get;utf-8;{User-Agent@Dart/2.14 (dart:io)}';\\\\n        } else if (/dijiaxia/.test(murl)) {\\\\n            var link = 'http://www.dijiaxia.com/api.php/app/video_detail?id=' + url;\\\\n        }\\\\n        items.push({\\\\n            title: title,\\\\n            pic_url: img + '@Referer=',\\\\n            url: $(link).rule(() => {\\\\n                var res = {};\\\\n                var items = [];\\\\n                items.push({\\\\n                    title: '',\\\\n                    desc: '255&&float',\\\\n                    url: '',\\\\n                    col_type: 'x5_webview_single'\\\\n                });\\\\n                refreshX5WebView('');\\\\n                var html = JSON.parse(getResCode());\\\\n                var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n                try {\\\\n                    eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n                } catch (e) {}\\\\n                res.data = items;\\\\n                setHomeResult(res);\\\\n            }),\\\\n            desc: desc,\\\\n            col_type: 'movie_3_marquee'\\\\n        });\\\\n    }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"断念插件调用\\\",\\\"path\\\":\\\"dnplugin\\\",\\\"rule\\\":\\\"var dnen = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).enDn;\\\\nitems.push({\\\\n    title: '断插：' + (dnen == '1' ? '““✅””' : '❎'),\\\\n    url: $('').lazyRule((dnen) => {\\\\n        if (dnen == '1') {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"');\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            refreshPage(false);\\\\n            return 'toast://已禁用断插调用！';\\\\n        } else {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"enDn\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"');\\\\n            //log(fileUrl);\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            refreshPage(false);\\\\n            return 'toast://已开启断插调用！'\\\\n        }\\\\n    }, dnen),\\\\n    col_type: 'text_3'\\\\n});\\\\nif (dnen == '1') {\\\\n    items.push({\\\\n        title: '线路配置',\\\\n        //url: \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\\\\\",\\\\n        url: \\\\\\\"select://\\\\\\\" + JSON.stringify({\\\\n        title:\\\\\\\"线路配置\\\\\\\",\\\\n        options: [\\\\\\\"原断\\\\\\\", \\\\\\\"魔断\\\\\\\"],\\\\n        col: 2,\\\\n        js: $.toString(() => {\\\\n            if(input==\\\\\\\"原断\\\\\\\"){\\\\n            return \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/Route.js');Route.setParse();setResult(d);\\\\\\\";    \\\\n            }else{\\\\n            return \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=设置#noHistory##noRecordHistory#\\\\\\\"    \\\\n            }\\\\n        })\\\\n    }),\\\\n        col_type: 'text_3'\\\\n    });\\\\n    items.push({\\\\n        title: '解析管理',\\\\n        //url: \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\\\\\",\\\\n        url: \\\\\\\"select://\\\\\\\" + JSON.stringify({\\\\n        title:\\\\\\\"解析管理\\\\\\\",\\\\n        options: [\\\\\\\"原断\\\\\\\", \\\\\\\"魔断\\\\\\\"],\\\\n        col: 2,\\\\n        js: $.toString(() => {\\\\n            if(input==\\\\\\\"原断\\\\\\\"){\\\\n             return \\\\\\\"hiker://empty#noRecordHistory#@rule=js:this.d=[];require('https://gitea.com/AI957/Hiker/raw/m/v/jxItem.js');jxItem.jxList();setResult(d)\\\\\\\";   \\\\n            }else{\\\\n             return \\\\\\\"hiker://page/Route?rule=MyFieldᴰⁿ&type=编辑#noHistory##noRecordHistory#\\\\\\\"   \\\\n            }\\\\n        })\\\\n    }),\\\\n        col_type: 'text_3'\\\\n    });\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"设置页代码\\\",\\\"path\\\":\\\"setting\\\",\\\"rule\\\":\\\"var d = [];\\\\nvar setjson = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {}));\\\\nvar ssmd = setjson.ssmode;\\\\nvar ssxc = setjson.sscount;\\\\nd.push({\\\\n    title: '搜索设置',\\\\n    col_type: 'text_center_1'\\\\n});\\\\nd.push({\\\\n    title: '当前：' + '(' + (ssmd == 1 ? '聚合结果' : '引擎列表') + ')',\\\\n    url: $('hiker://empty').lazyRule(() => {\\\\n        var md = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).ssmode;\\\\n\\\\n        if (md == 1) {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"');\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            back(true);\\\\n            return 'toast://切换为搜索引擎列表单选模式成功！';\\\\n        } else {\\\\n            var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace('\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"0\\\\\\\\\\\\\\\"', '\\\\\\\\\\\\\\\"ssmode\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"1\\\\\\\\\\\\\\\"');\\\\n            //log(fileUrl);\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n            back(true);\\\\n            return 'toast://切换为聚合搜索模式成功！'\\\\n        }\\\\n    }),\\\\n    col_type: 'text_2'\\\\n})\\\\nd.push({\\\\n    title: '搜索超时(' + '' + getItem('apptimout', '') + ')',\\\\n    url: \\\\\\\"input://\\\\\\\" + '3000' + \\\\\\\"////请设置超时时间，1000为一秒。.js:var num = parseInt(input).toString();if (num == 'NaN'||num<1000) {'toast://输入的值好像不正确。';} else {setItem('apptimout', num);refreshPage();'toast://设置成功。'}\\\\\\\",\\\\n    col_type: 'text_2'\\\\n});\\\\n\\\\nd.push({\\\\n    title: '搜索线程' + '(' + ssxc + ')',\\\\n    url: \\\\\\\"input://\\\\\\\" + JSON.stringify({\\\\n        value: \\\\\\\"5\\\\\\\",\\\\n        hint: \\\\\\\"请输入一个整数数字，推荐最大不要超过15。\\\\\\\",\\\\n        js: $.toString(() => {\\\\n            var num = parseInt(input).toString();\\\\n            if (num == 'NaN' || num < 1) {\\\\n                return 'toast://输入的值好像不正确。';\\\\n            } else {\\\\n                var fileUrl = fetch(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", {}).replace(/\\\\\\\\\\\\\\\"sscount\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"[\\\\\\\\d]*\\\\\\\\\\\\\\\"/, '\\\\\\\\\\\\\\\"sscount\\\\\\\\\\\\\\\":\\\\\\\\\\\\\\\"' + num + '\\\\\\\\\\\\\\\"');\\\\n                writeFile(\\\\\\\"hiker://files/rules/xyq/appmset.json\\\\\\\", fileUrl);\\\\n                back(true);\\\\n                return 'toast://保存设置搜索线程完成！'\\\\n            }\\\\n        }),\\\\n    }),\\\\n    col_type: 'text_2'\\\\n});\\\\n\\\\nd.push({\\\\n    title: '更新相关',\\\\n    col_type: 'text_center_1'\\\\n});\\\\nd.push({\\\\n    title: '检测更新',\\\\n    url: $('').lazyRule((locver) => {\\\\n        try {\\\\n            var remf = fetchCache('https://codeberg.org/lzk23559/cloudrule/raw/branch/master/appmovie.txt', 24);\\\\n        } catch (e) {\\\\n            remf = '';\\\\n        }\\\\n        if (/￥base64/.test(remf)) {\\\\n            var remv = JSON.parse(base64Decode(remf.split('@')[2])).version;\\\\n        } else if (/￥home_rule￥/.test(remf)) {\\\\n            var remv = JSON.parse(remf.split('￥home_rule￥')[1]).version;\\\\n        };\\\\n        if (/￥home_rule/.test(remf)) {\\\\n            log('远程版本：' + remv);\\\\n            log('本地版本：' + locver);\\\\n            if (locver != remv) {\\\\n                putVar('appnver', remf);\\\\n                refreshPage();\\\\n                return 'toast://有新版本，点导入更新可更新规则。';\\\\n            } else {\\\\n                return 'toast://暂无新版本，24小时内检测无效。'\\\\n            };\\\\n        } else {\\\\n            return 'toast://检测更新失败，可能云端抽风了。'\\\\n        }\\\\n    }, locver),\\\\n    col_type: 'text_2'\\\\n});\\\\nif (getVar('appnver')) {\\\\n    d.push({\\\\n        title: '导入更新',\\\\n        url: $('').lazyRule(() => {\\\\n            return getVar('appnver');\\\\n        }),\\\\n        col_type: 'text_2'\\\\n    });\\\\n}\\\\nd.push({\\\\n    title: '接口相关',\\\\n    //url:'hiker://empty',\\\\n    url: $('hiker://empty').lazyRule(() => {\\\\n        var remfile = '';\\\\n        //log(remfile);\\\\n        if (/\\\\\\\\=http/.test(remfile)) {\\\\n            writeFile(\\\\\\\"hiker://files/rules/xyq/APPMovie.txt\\\\\\\", remfile);\\\\n            back(true);\\\\n            return 'toast://获取云端文件写本地成功。';\\\\n        } else {\\\\n            return 'toast://获取云端文件失败。'\\\\n        }\\\\n    }),\\\\n    col_type: 'text_center_1'\\\\n});\\\\nvar clmd = getItem('clmode', '1');\\\\nd.push({\\\\n    title: '云端/本地' + '(' + (clmd == 1 ? '本地' : '云端') + ')',\\\\n    url: $('').lazyRule(() => {\\\\n        var clmd = getItem('clmode', '1');\\\\n        if (clmd == 1) {\\\\n            setItem('clmode', '0');\\\\n            refreshPage();\\\\n            return 'toast://切换为云端接口成功，请返回刷新。';\\\\n        } else {\\\\n            setItem('clmode', '1');\\\\n            refreshPage();\\\\n            return 'toast://切换为本地接口成功，请返回刷新。'\\\\n        }\\\\n    }),\\\\n    col_type: 'text_2'\\\\n});\\\\nd.push({\\\\n    title: '编辑本地接口',\\\\n    url: $('').lazyRule(() => {\\\\n        return 'editFile://hiker://files/rules/xyq/APPMovie.txt'\\\\n    }),\\\\n    col_type: 'text_2'\\\\n});\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"最新章节\\\",\\\"path\\\":\\\"chapter\\\",\\\"rule\\\":\\\"var chp = [];\\\\ntry {\\\\n    var html = JSON.parse(getResCode());\\\\n    if (html.videolist) {\\\\n        var conts = Object.keys(html.videolist);\\\\n    } else if (html.data.vod_url_with_player) {\\\\n        var conts = html.data.vod_url_with_player;\\\\n        if (conts.length < 1) {\\\\n            conts = html.data.vod_play_url.split('$$$');\\\\n        }\\\\n    } else if (html.data.vod_info && html.data.vod_info.vod_url_with_player) {\\\\n        var conts = html.data.vod_info.vod_url_with_player;\\\\n        if (conts.length < 1) {\\\\n            conts = html.data.vod_info.vod_play_url.split('$$$');\\\\n        }\\\\n    } else if (html.data.length == 1) {\\\\n        var conts = html.data[0].vod_play_list;\\\\n        //log(conts);\\\\n        if (conts.length < 1) {\\\\n            conts = html.data[0].vod_play_url.split('$$$');\\\\n        }\\\\n    } else {\\\\n        var conts = html.data.vod_play_list;\\\\n        if (conts.length < 1) {\\\\n            conts = html.data.vod_play_url.split('$$$');\\\\n        }\\\\n    }\\\\n\\\\n    for (var i = 0; i < conts.length; i++) {\\\\n        if (html.videolist) {\\\\n            var list = html.videolist[conts[i]];\\\\n        } else if (conts[i].urls) {\\\\n            var list = conts[i].urls;\\\\n        } else if (conts[i].url) {\\\\n            var list = conts[i].url.split(\\\\\\\"#\\\\\\\");\\\\n        } else {\\\\n            var list = conts[i].split(\\\\\\\"#\\\\\\\");\\\\n        }\\\\n        chp.push(list.length);\\\\n    }\\\\n} catch (e) {}\\\\n//log(Math.max.apply(Math,chp));\\\\nsetResult('更新至:' + (Math.max.apply(Math, chp)));\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"分类搜索\\\",\\\"path\\\":\\\"ss2\\\",\\\"rule\\\":\\\"js:\\\\nvar items = [];\\\\nvar Data = [];\\\\nvar nowDate = new Date();\\\\nvar month = nowDate.getMonth() + 1 < 10 ? \\\\\\\"0\\\\\\\" + (nowDate.getMonth() + 1) : nowDate.getMonth() + 1;\\\\nvar day = nowDate.getDate() < 10 ? \\\\\\\"0\\\\\\\" + nowDate.getDate() : nowDate.getDate();\\\\nvar dateStr = month + '' + day;\\\\n//取搜索线程设置\\\\nvar ssxc = JSON.parse(fetch('hiker://files/rules/xyq/appmset.json', {})).sscount;\\\\n//设置超时时间，越小越快，单位毫秒\\\\nvar timeou = getItem('apptimout', '3000');\\\\nvar key = MY_URL.split('$$$')[1];\\\\nvar num = MY_URL.split('$$$')[2];\\\\nvar le = parseInt(num * ssxc);\\\\nvar Tit = [];\\\\nlet list = MY_PARAMS.list;\\\\nlet tytit = MY_PARAMS.tytit;\\\\nlet pageid = \\\\\\\"__app\\\\\\\" + num;\\\\ntry {\\\\n    for (var j = le - ssxc; j < le; j++) {\\\\n        if (j < list.length) {\\\\n            var link = list[j].url;\\\\n            var litit = list[j].murl;\\\\n            if (/\\\\\\\\/vod\\\\\\\\//i.test(link)) {\\\\n                if (/37\\\\\\\\.161|216\\\\\\\\.98|phoebe|hfys8|feifan12|tvzy|hdyangtv|tkys|tegouys/.test(link)) {\\\\n                    var hmurl = link + '?ac=list&zm=' + key + '&page=1';\\\\n                } else {\\\\n                    var hmurl = link + '?ac=list&wd=' + key + '&page=1';\\\\n                }\\\\n            } else {\\\\n                if (/dijiaxia/.test(link)) {\\\\n                    link = 'http://www.dijiaxia.com/api.php/app/'\\\\n                };\\\\n                if (link.indexOf('api.php/app/') != -1) {\\\\n                    var hmurl = link + 'search?pg=1&text=' + key + '&token=';\\\\n                } else if (link.indexOf('xgapp.php/v1/') != -1) {\\\\n                    var hmurl = link + 'search?pg=1&text=' + key;\\\\n                } else {\\\\n                    if (/iopenyun/.test(link)) {\\\\n                        var hmurl = link + '/list?page=fypage&limit=10&wd=' + key;\\\\n                    } else {\\\\n                        var hmurl = link + '?page=1&limit=10&wd=' + key;\\\\n                    }\\\\n                }\\\\n            }\\\\n            //Data.push({url: hmurl,options: {headers: {\\\\\\\"User-Agent\\\\\\\": \\\\\\\"Dart/2.14 (dart:io)\\\\\\\"},timeout: timeou}});\\\\n            Data.push({\\\\n                url: hmurl,\\\\n                options: {\\\\n                    headers: {\\\\n                        \\\\\\\"User-Agent\\\\\\\": link.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? \\\\\\\"Dart/2.14 (dart:io)\\\\\\\" : \\\\\\\"okhttp/4.1.0\\\\\\\"\\\\n                    },\\\\n                    timeout: timeou\\\\n                }\\\\n            });\\\\n            Tit.push({\\\\n                tit: list[j].title,\\\\n                link: link,\\\\n                typnm: litit\\\\n            });\\\\n        } //if\\\\n    } //for j\\\\n} catch (e) {}\\\\nif (Data.length <= 0) {\\\\n    setResult([]);\\\\n} else {\\\\n    items.push({\\\\n        title: \\\\\\\"正在加载中第\\\\\\\" + MY_PAGE + \\\\\\\"页，进度：1/\\\\\\\" + Data.length,\\\\n        url: \\\\\\\"\\\\\\\",\\\\n        col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n        desc: \\\\\\\"\\\\\\\",\\\\n        pic_url: \\\\\\\"\\\\\\\",\\\\n        extra: {\\\\n            id: pageid\\\\n        }\\\\n    });\\\\n    setResult(items);\\\\n    let tasks = [];\\\\n\\\\n    for (let k in Data) {\\\\n        let it = Data[k];\\\\n        tasks.push({\\\\n            func: function(param) {\\\\n                let d = [];\\\\n                let html = fetch(param.it.url, param.it.options);\\\\n                //log(html);\\\\n                try {\\\\n                    html = html.substring(0, 2) == '\\\\\\\\r\\\\\\\\n' ? html.replace('\\\\\\\\r\\\\\\\\n', '') : html;\\\\n                } catch (e) {}\\\\n                if (/btwaf/.test(html)) {\\\\n                    html = fetch(param.it.url + '&btwaf' + html.match(/btwaf(.*?)\\\\\\\\\\\\\\\"/)[1], {});\\\\n                }\\\\n                if (html == \\\\\\\"\\\\\\\" || html == null || html.substring(0, 5) == 'error' || !html.endsWith('}')) {\\\\n                    d.push({\\\\n                        title: param.tit.tit + ' ' + '未搜索到，点击访问原网页',\\\\n                        url: param.it.url + `@lazyRule=.js:input.split(';')[0]`,\\\\n                        desc: \\\\\\\"\\\\\\\",\\\\n                        pic_url: \\\\\\\"\\\\\\\",\\\\n                        col_type: 'text_center_1'\\\\n                    });\\\\n                } else if (html.length < 80) {\\\\n                    d.push({\\\\n                        title: param.tit.tit + ' ' + '返回数据不完整，点击访问原网页',\\\\n                        url: param.it.url + `@lazyRule=.js:input.split(';')[0]`,\\\\n                        desc: \\\\\\\"\\\\\\\",\\\\n                        pic_url: \\\\\\\"\\\\\\\",\\\\n                        col_type: 'text_center_1'\\\\n                    });\\\\n                } else {\\\\n                    html = JSON.parse(html);\\\\n                    //log(html);\\\\n                    var typet = param.tit.typnm;\\\\n                    var tdomin = param.tit.link;\\\\n                    if (html.list) {\\\\n                        var list = html.list;\\\\n                    } else if (html.data.list) {\\\\n                        var list = html.data.list;\\\\n                    } else if (html.data) {\\\\n                        var list = html.data;\\\\n                    } else {\\\\n                        var list = [];\\\\n                    }\\\\n                    if (list.length < 1) {\\\\n                        d.push({\\\\n                            title: param.tit.tit + ' ' + '列表小于1，无法展示，点击访问原网页',\\\\n                            url: param.it.url + `@lazyRule=.js:input.split(';')[0]`,\\\\n                            desc: \\\\\\\"\\\\\\\",\\\\n                            pic_url: \\\\\\\"\\\\\\\",\\\\n                            col_type: 'text_center_1'\\\\n                        });\\\\n                    } else {\\\\n                        for (var i = 0; i < list.length; i++) {\\\\n                            if (/\\\\\\\\/vod\\\\\\\\//.test(tdomin)) {\\\\n                                var title = list[i].title;\\\\n                                var pic = list[i].pic;\\\\n                                var vid = list[i].nextlink;\\\\n                                var rem = list[i].state;\\\\n                            } else {\\\\n                                if (tdomin.indexOf('api.php/app/') != -1) {\\\\n                                    var title = list[i].vod_name;\\\\n                                    var pic = list[i].vod_pic;\\\\n                                    if (/fantuan/.test(tdomin)) {\\\\n                                        var vid = 'https://fantuan.wkfile.com/api.php/app/video_detail?id=' + list[i].vod_id + '&token=';\\\\n                                    } else {\\\\n                                        var vid = tdomin + 'video_detail?id=' + list[i].vod_id + '&token=';\\\\n                                    }\\\\n                                    var rem = list[i].vod_remarks;\\\\n                                    //var con=list[i].type.type_des;\\\\n                                } else if (tdomin.indexOf('xgapp.php/v1/') != -1) {\\\\n                                    var title = list[i].vod_name;\\\\n                                    var pic = list[i].vod_pic;\\\\n                                    var vid = tdomin + 'video_detail?id=' + list[i].vod_id;\\\\n                                    var rem = list[i].vod_remarks;\\\\n                                    //var con=list[i].type.type_des;\\\\n                                } else {\\\\n                                    var title = list[i].vod_name;\\\\n                                    var pic = list[i].vod_pic;\\\\n                                    if (/iopenyun/.test(tdomin)) {\\\\n                                        var vid = tdomin + '/detailID?vod_id=' + list[i].vod_id + '&token=';\\\\n                                    } else if (/grelighting/.test(tdomin)) {\\\\n                                        var vid = tdomin + '/?ids=' + list[i].vod_id + '&token=';\\\\n                                    } else {\\\\n                                        var vid = tdomin + '/detail?key=' + dateStr + '&vod_id=' + list[i].vod_id + '&token=';\\\\n                                    }\\\\n                                    var rem = list[i].vod_remarks;\\\\n                                    //var con=list[i].type.type_des;\\\\n                                }\\\\n\\\\n                            }\\\\n                            //var con=list[i].state;\\\\n                            //log(vid);\\\\n                            d.push({\\\\n                                title: MY_TYPE == \\\\\\\"home\\\\\\\" ? title.replace(key, '““' + key + '””') + '\\\\\\\\n' + rem : title + rem,\\\\n                                pic_url: pic + '@Referer=',\\\\n                                url: $(tdomin.indexOf(\\\\\\\"mogai_api\\\\\\\") != -1 ? vid + ';get;utf-8;{User-Agent@Dart/2.14 (dart:io)}' : vid + ';get;utf-8;{User-Agent@okhttp/4.1.0}').rule((tdomin, tkt, patt) => {\\\\n                                    var res = {};\\\\n                                    var items = [];\\\\n                                    if (tkt != '') {\\\\n                                        setPageTitle(tkt + '-' + patt);\\\\n                                    }\\\\n                                    var html = JSON.parse(getResCode());\\\\n                                    items.push({\\\\n                                        title: '',\\\\n                                        desc: '255&&float',\\\\n                                        url: '',\\\\n                                        col_type: 'x5_webview_single'\\\\n                                    });\\\\n                                    var myurl = MY_URL.match(/([\\\\\\\\S]*?:\\\\\\\\/\\\\\\\\/[\\\\\\\\S]*?)\\\\\\\\//)[1];\\\\n                                    if (/\\\\\\\\/vod\\\\\\\\//.test(tdomin)) {\\\\n                                        eval(JSON.parse(fetch('hiker://page/tvmovlist', {})).rule);\\\\n                                    } else {\\\\n                                        eval(JSON.parse(fetch('hiker://page/appmovlist', {})).rule);\\\\n                                    }\\\\n\\\\n                                    res.data = items;\\\\n                                    setHomeResult(res);\\\\n                                }, tdomin, param.tit.tit, title),\\\\n                                //content: rem,\\\\n                                desc: tytit + ' => ' + param.tit.tit,\\\\n                                col_type: 'movie_1_vertical_pic'\\\\n                            });\\\\n                        } //for i\\\\n                    } //if list.length\\\\n                }\\\\n                return d;\\\\n            },\\\\n            param: {\\\\n                it: it,\\\\n                tit: Tit[k]\\\\n            },\\\\n            id: \\\\\\\"task\\\\\\\"\\\\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                for (let it of result) {\\\\n                    param.j = param.j + 1;\\\\n                    addItemBefore(pageid, {\\\\n                        title: it.title,\\\\n                        desc: it.desc,\\\\n                        url: it.url,\\\\n                        pic_url: it.pic_url,\\\\n                        col_type: it.col_type,\\\\n                        extra: {\\\\n                            id: \\\\\\\"__app\\\\\\\" + MY_PAGE + \\\\\\\"@\\\\\\\" + param.j\\\\n                        }\\\\n                    })\\\\n                }\\\\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}\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"数据转换\\\",\\\"path\\\":\\\"conver\\\",\\\"rule\\\":\\\"//js:\\\\n//rem(res);\\\\nvar 记录 = [];\\\\nvar 输入条目 = remfile.match(/.+=http.+/g);\\\\nfor (var j in 输入条目) {\\\\n    var title = 输入条目[j].split('@')[1].split('=')[0];\\\\n    var url = 输入条目[j].split('=')[1].split('#')[0];\\\\n    var img = 输入条目[j].split('#')[1];\\\\n    if (img.indexOf(\\\\\\\"http\\\\\\\") != -1) {\\\\n        var img = img;\\\\n    } else if (img == \\\\\\\"\\\\\\\") {\\\\n        var img = \\\\\\\"https://gitcode.net/m0_72395205/iptv/-/raw/master/AppFile/AppIcon/通用图标.png\\\\\\\"\\\\n    } else {\\\\n        var img = \\\\\\\"https://gitcode.net/m0_72395205/iptv/-/raw/master/AppFile/AppIcon/\\\\\\\" + img + \\\\\\\".png\\\\\\\";\\\\n    }\\\\n    if (url.search(/api\\\\\\\\.php\\\\\\\\/.*?\\\\\\\\/vod/) != -1) {\\\\n        var murl = \\\\\\\"q:TV影视\\\\\\\";\\\\n    } else {\\\\n        var murl = \\\\\\\"q:APP影视\\\\\\\";\\\\n    }\\\\n    if (输入条目[j].split('@')[0] != \\\\\\\"\\\\\\\") {\\\\n        var type = 输入条目[j].split('@')[0];\\\\n    } else if (url.indexOf(\\\\\\\"api.php/app\\\\\\\") != -1 || url.indexOf(\\\\\\\"xgapp\\\\\\\") != -1) {\\\\n        var type = \\\\\\\"小龟\\\\\\\";\\\\n    } else if (url.indexOf(\\\\\\\".vod\\\\\\\") != -1) {\\\\n        var type = \\\\\\\"普通\\\\\\\";\\\\n    } else if (url.search(/api\\\\\\\\.php\\\\\\\\/.+?\\\\\\\\/vod\\\\\\\\//) != -1) {\\\\n        var type = \\\\\\\"神马\\\\\\\";\\\\n    }\\\\n    记录.push({\\\\n        title: title,\\\\n        url: url,\\\\n        img: img,\\\\n        murl: murl,\\\\n        type: type\\\\n    });\\\\n}\\\\nvar 新记录 = [];\\\\n\\\\nfor (var i in 记录) {\\\\n    var 当前条目 = [];\\\\n    当前条目.push(记录[i]);\\\\n    if (新记录.length == 0) {\\\\n        新记录.push({\\\\n            title: 记录[i].type,\\\\n            list: 当前条目\\\\n        });\\\\n    } else {\\\\n        let res = 新记录.some(item => {\\\\n            //判断类型，有就添加到当前项\\\\n            if (item.title == 记录[i].type) {\\\\n                item.list = 当前条目.concat(item.list.filter(d => d.url != 记录[i].url));\\\\n                return true\\\\n            }\\\\n        });\\\\n        if (!res) {\\\\n            //如果没找相同类型添加一个类型\\\\n            新记录.push({\\\\n                title: 记录[i].type,\\\\n                list: 当前条目\\\\n            });\\\\n        }\\\\n    }\\\\n}\\\\nvar newfile = {};\\\\nnewfile.data = 新记录;\\\\n//log(remfile);\\\"}]\"}","picUrl":"https://img.liangzipic.com/upload/vod/20221210-1/20b5c1964fe594e3b8af9b4b966a32f8.jpg@Referer=","title":"HG影视-三体"}
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!