API tools faq
paste
Advertisement
xiaomianao666

邀您一起看：重口社

xiaomianao666
Feb 18th, 2025
122
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 247.86 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥重口社@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"gmtModified\":0,\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"movie_3\",\"name\":\"aes\",\"path\":\"aes\",\"rule\":\"//加载CryptoJS库\\neval(getCryptoJS())\\n//13位时间戳\\nvar t = Math.floor(Date.now() );\\n//简单匹配\\nlet sp = (it, s, e) => String(it.split(s)[1]).split(e)[0];\\n//颜色\\nfunction strong(d, c) {\\n    return '‘‘’’<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\n}\\n//生成时间戳\\nfunction getCurrentTimestamp() {\\n    return new Date().getTime();\\n}\\n//md5加密\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\n//sha256加密\\nfunction sha256(str) {\\n    return CryptoJS.SHA256(str).toString();\\n}\\n//颜色\\nfunction color(txt) {\\n    return  '<b><font color=' + '#FF6699' + '>' + txt + '</font></b>'\\n}\\n//茄子解密函数\\nfunction qzDecrypt(word) {\\n    const key = CryptoJS.enc.Utf8.parse(\\\"yinsu12345abcdef\\\");\\n    const iv = CryptoJS.enc.Utf8.parse(\\\"keji123456999999\\\");\\n    let encryptedHexStr = CryptoJS.enc.Base64.parse(word);\\n    let decrypt = CryptoJS.AES.decrypt({\\n        ciphertext: encryptedHexStr\\n    }, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7\\n    });\\n    if (decrypt) {\\n        let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);\\n        return decryptedStr;\\n    } else {\\n        // 解密失败，返回null或错误信息\\n        return null;\\n    }\\n}\\n\\n\\n// 猫咪解密函数\\nfunction Decrypt(word) {\\n    const key = CryptoJS.enc.Utf8.parse(\\\"625222f9149e961d\\\");\\n    const iv = CryptoJS.enc.Utf8.parse(\\\"5efdtf6060e2o330\\\");\\n    let encryptedHexStr = CryptoJS.enc.Hex.parse(word);\\n    let decrypt = CryptoJS.AES.decrypt({\\n        ciphertext: encryptedHexStr\\n    }, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7\\n    });\\n    if (decrypt) {\\n        let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);\\n        return decryptedStr;\\n    } else {\\n        // 解密失败，返回null或错误信息\\n        return null;\\n    }\\n}\\n\\n// 猫咪加密函数\\nfunction Encrypt(plaintext) {\\n    const key = CryptoJS.enc.Utf8.parse(\\\"625222f9149e961d\\\");\\n    const iv = CryptoJS.enc.Utf8.parse(\\\"5efdtf6060e2o330\\\");\\n    var encrypted = CryptoJS.AES.encrypt(plaintext, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7\\n    });\\n    var ciphertext = encrypted.ciphertext.toString(CryptoJS.enc.Hex);\\n    return ciphertext.toUpperCase();\\n}\\n\\nvar lazy = $('').image(() => {\\nconst CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n\\tlet id = CryptoUtil.Data.parseUTF8(\\\"f5d965df75336270\\\");\\n\\tlet iv = CryptoUtil.Data.parseUTF8(\\\"97b60394abc2fbe1\\\");\\n\\tlet textData = CryptoUtil.Data.parseInputStream(input);\\n\\tlet encrypted = CryptoUtil.AES.decrypt(textData, id, {\\n  \\tmode: \\\"AES/CBC/PKCS7Padding\\\",\\n\\t\\tiv: iv\\n\\t});\\n\\treturn encrypted.toInputStream();\\n})\\n\\n//视频请求\\nvar vod = $('').lazyRule(() => {\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nvar url =JSON.parse(fetch(input)).video;\\nreturn url+`#isVideo=true#`\\n}catch(e){\\n    log(e.message)\\n    return 'toast://请求失败'\\n}\\n})\\n//图片请求\\nvar pics = $('').lazyRule(() => {\\nlet img= JSON.parse(fetch(input)).content.replace(/\\\\$/g,'').replace(/分割/g,'').split('@');\\nreturn 'pics://'+img.join('&&');\\n})\\n//猫咪漫画解析\\nvar maomimanhuajx=$('').lazyRule(() => { \\neval(JSON.parse(request('hiker://page/aes')).rule)\\nvar sign=Encrypt('{\\\"user_id\\\":1790368,\\\"list_id\\\":'+input+'}');\\nvar host='http://119.28.52.193:8089/api/comic/watch?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\nvar list=JSON.parse(html2).data;\\nlet picArr=[];\\nlet len= list.length-1;\\nfor (i = 0; i <= len; i++) {\\n       picArr[i] = list[i].image;\\n     }\\nreturn 'pics://'+picArr.join('&&');\\n})\\n\\n//猫咪FM解析\\nvar maomifmjx=$('').lazyRule(() => { \\neval(JSON.parse(request('hiker://page/aes')).rule)\\nvar sign=Encrypt('{\\\"id\\\":'+input+'}');\\nvar host='http://119.28.52.193:8089/api/book/detail?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\nvar url=JSON.parse(html2).data.data[0].content;\\nreturn url\\n})\\n\\n//猫咪解析\\nvar maomijx=$('').lazyRule(() => { \\neval(JSON.parse(request('hiker://page/aes')).rule)\\nvar sign=Encrypt('{\\\"id\\\":'+input+'}');\\nvar host='http://119.28.52.193:8089/api/video/detail?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\n//下载\\n//var down=JSON.parse(html2).data.videos[0].down;\\n//文件\\nvar url=JSON.parse(html2).data.videos[0].file;\\nreturn url\\n})\\n\\n//麻豆加密函数\\nfunction mdEncrypt(plaintext) {\\n    const key = CryptoJS.enc.Utf8.parse(\\\"Vq234zBeSdGgYXzVTEfnnjjdmaTkk7A4\\\");\\n    const iv = CryptoJS.enc.Utf8.parse(\\\"-p9B[~PnPs173150\\\");\\n    var encrypted = CryptoJS.AES.encrypt(plaintext, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7 // 注意这里应该是CryptoJS.pad.NoPadding\\n    });\\n    var ciphertext = encrypted.ciphertext.toString(CryptoJS.enc.Base64);\\n    return ciphertext;\\n}\\n\\n// 麻豆解密函数\\nfunction mdDecrypt(word) {\\n    const key = CryptoJS.enc.Utf8.parse(\\\"Vq234zBeSdGgYXzVTEfnnjjdmaTkk7A4\\\");\\n    const iv = CryptoJS.enc.Utf8.parse(\\\"-p9B[~PnPs\\\"+iv0);\\n    let encryptedHexStr = CryptoJS.enc.Base64.parse(word);\\n    let decrypt = CryptoJS.AES.decrypt({\\n        ciphertext: encryptedHexStr\\n    }, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CBC,\\n        padding: CryptoJS.pad.Pkcs7 // 注意这里应该是CryptoJS.pad.NoPadding\\n    });\\n    if (decrypt) {\\n        let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);\\n        return decryptedStr;\\n    } else {\\n        // 解密失败，返回null或错误信息\\n        return null;\\n    }\\n}\\n\\n//麻豆图片解密\\nvar mdlazy = $('').image(() => {\\nconst CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n\\tlet key = CryptoUtil.Data.parseUTF8(\\\"pnhXgN0U\\\");\\n\\tlet iv = CryptoUtil.Data.parseUTF8(\\\"GY4gEvBD\\\");\\n\\tlet textData = CryptoUtil.Data.parseInputStream(input).base64Decode();\\n\\tlet encrypted = CryptoUtil.DES.decrypt(textData, key, {\\n  \\tmode: \\\"DES/CBC/PKCS7Padding\\\",\\n\\t\\tiv: iv\\n\\t});\\n\\tlet base64Text = encrypted.toString().split(\\\"base64,\\\")[1];\\n    let encrypted0 = CryptoUtil.Data.parseBase64(base64Text, _base64.NO_WRAP);\\n    return encrypted0.toInputStream();\\n})\\n\\n//91tv视频解析\\nvar tvvod = $('').lazyRule(() => {\\neval(getCryptoJS())\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\nvar t0 =Math.floor(Date.now() / 1000)+1;\\nvar wsSecret=md5('E9MpC7D5AqWvjmXL3hGkQ2XjZNohAQ'+input.replace(/http(s)?:\\\\/\\\\/.*?\\\\//g,'/')+t0);\\nvar url=input+'?wsSecret='+wsSecret+'&wsTime='+t0;\\nwriteFile('hiker://files/cache/video0.m3u8', request(url));\\nreturn getPath('hiker://files/cache/video0.m3u8')+'#'+url;\\n})\\n//lutube图片解密\\nvar lulazy = $('').image(() => {\\nconst CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n\\tlet key = CryptoUtil.Data.parseHex(\\\"b2f3842866f9583d1ece61c4e055c255\\\");\\n\\tlet iv = CryptoUtil.Data.parseHex(\\\"e01ede6331d37afcc7be05597d654d22\\\");\\n\\tlet textData = CryptoUtil.Data.parseInputStream(input);\\n\\tlet encrypted = CryptoUtil.AES.decrypt(textData, key, {\\n  \\tmode: \\\"AES/CBC/PKCS7Padding\\\",\\n\\t\\tiv: iv\\n\\t});\\n\\treturn encrypted.toInputStream();\\n})\\n//ins图片解密，base64\\nvar inslazy = $('').image(() => {\\n    const CryptoUtil = $.require(\\\"hiker://assets/crypto-java.js\\\");\\n    let textData = CryptoUtil.Data.parseInputStream(input);\\n    let base64Text = textData.toString().split(\\\"base64,\\\")[1];\\n    let encrypted0 = CryptoUtil.Data.parseBase64(base64Text, _base64.NO_WRAP);\\n    return encrypted0.toInputStream();\\n})\\n\\n\\n//海角图片解密\\nvar n = function(e) {\\n    for (o = \\\"\\\", i = 0, a = 0, void 0; i < e.length;) {\\n        var t, n, o, i, a;\\n        (t = e.charCodeAt(i)) < 128 ? (o += String.fromCharCode(t), i++) : 191 < t && t < 224 ? (a = e.charCodeAt(i + 1), o += String.fromCharCode((31 & t) << 6 | 63 & a), i += 2) : (a = e.charCodeAt(i + 1), n = e.charCodeAt(i + 2), o += String.fromCharCode((15 & t) << 12 | (63 & a) << 6 | 63 & n), i += 3);\\n    }\\n    return o;\\n};\\nvar decryptData = function(t) {\\n    var o, i, a, r, s, c, u = \\\"\\\",\\n        d = 0,\\n        tt = \\\"ABCD*EFGHIJKLMNOPQRSTUVWX#YZabcdefghijklmnopqrstuvwxyz1234567890\\\"\\n    for (t = t.replace(/[^A-Za-z0-9\\\\*\\\\#]/g, \\\"\\\"); d < t.length;) a = tt.indexOf(t.charAt(d++)), o = (15 & (r = tt.indexOf(t.charAt(d++)))) << 4 | (s = tt.indexOf(t.charAt(d++))) >> 2, i = (3 & s) << 6 | (c = tt.indexOf(t.charAt(d++))), u += String.fromCharCode(a << 2 | r >> 4), 64 != s && (u += String.fromCharCode(o)), 64 != c && (u += String.fromCharCode(i));\\n    return n(u);\\n};\\n\\n$.exports.imageDecrypt = function() {\\n    let javaImport = new JavaImporter();\\n    javaImport.importPackage(\\n        Packages.com.example.hikerview.utils\\n    );\\n    with(javaImport) {\\n        let bytes = FileUtil.toBytes(input);\\n        bytes = new java.lang.String(bytes, 'UTF-8')\\n        let res = decryptData(bytes + \\\"\\\");\\n        res = new java.lang.String(res)\\n        res = res.split(\\\"base64,\\\")[1];\\n        return FileUtil.toInputStream(_base64.decode(res, _base64.NO_WRAP));\\n    }\\n}\\n\\n\\nfunction pageAdd(page) {\\n    if (getMyVar(\\\"page\\\")) {\\n        putMyVar(\\\"page\\\", (parseInt(page) + 1) + '');\\n    }\\n    return;\\n} //翻页\\n\\nfunction pageMoveto(page, pages) {\\n    var longClick = [{\\n        title: \\\"首页\\\",\\n        js: $.toString(() => {\\n            putMyVar(\\\"page\\\", \\\"1\\\");\\n            refreshPage();\\n            return \\\"hiker://empty\\\";\\n        }),\\n    }, {\\n        title: \\\"上页\\\",\\n        js: $.toString((page) => {\\n            if (page > 1) {\\n                putMyVar(\\\"page\\\", (parseInt(page) - 1));\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n            }\\n        }, page),\\n    }, {\\n        title: \\\"当前第\\\" + page + \\\"页\\\",\\n        js: \\\"\\\",\\n    }, {\\n        title: \\\"跳转\\\",\\n        js: $.toString(() => {\\n            return $(\\\"\\\").input(() => {\\n                putMyVar(\\\"page\\\", input);\\n                refreshPage();\\n            });\\n        }),\\n    }];\\n    if (typeof(pages) != 'undefined') {\\n        var extra1 = {\\n            title: \\\"尾页\\\" + pages,\\n            js: $.toString((pages) => {\\n                putMyVar(\\\"page\\\", pages);\\n                refreshPage();\\n                return \\\"hiker://empty\\\";\\n            }, pages),\\n        };\\n        longClick.push(extra1)\\n    }\\n    return longClick\\n} //长按跳页\\n\"},{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"Cate\",\"rule\":\"function strong(d, c) {\\n    return '‘‘’’<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\n}\\n//列表,col默认为'scroll_button'\\nfunction Cate(list,n,d,col) {\\n    if(!col){\\n        col='scroll_button';\\n    }\\n    var index_n=list[0].id.split('&')[0];\\n    list.forEach(data=>{\\n        var title = data.title.split('&');\\n        var id=data.id.split('&');\\n        if(data.img!=null){\\n            var img=data.img.split('&');\\n        }else{\\n            var img=[];\\n        }\\n        title.forEach((title,index)=>{\\n            d.push({\\n                title:(getMyVar(n,index_n)==id[index]?strong(title, 'FF6699') : title),\\n                img:img[index],\\n                url:$(id[index]).lazyRule((n,title,id) => {\\n               putMyVar(n, input);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, n,title,id[index]),\\n            col_type:col,\\n            })\\n        })\\n        d.push({\\n        col_type: 'blank_block',\\n    });\\n    })\\n    return d;\\n}\\n$.exports.Cate = Cate;\"},{\"col_type\":\"movie_3\",\"name\":\"00首页\",\"path\":\"home\",\"rule\":\"js:\\nif (MY_PAGE == 1) {\\n    d.push({   \\n        title: \\\"搜索 \\\",\\n        url: $.toString(() => {\\n        putMyVar('keyword',input)\\n        return \\\"hiker://page/search?page=fypage&kw=\\\" + input\\n    }),\\n           desc: \\\"请输入搜索关键词\\\",\\n           col_type: \\\"input\\\",\\n    })\\n};\\nvar pg= MY_URL.replace('hiker://empty##', '');\\nvar t = Math.floor(Date.now()); \\nvar c1= [{title: '首页&综合',id: '1&2&3&4&5',img:'https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/127.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/137.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/113.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/114.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/122.svg'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(c1,'c1',d,'icon_2_round');\\nd.push({\\n    col_type: 'line',\\n},{\\n    col_type: 'big_blank_block',\\n}\\n,{\\n    col_type: 'big_blank_block',\\n});\\n}\\nvar 分类=getMyVar('c1', '1');\\nif(分类==1){\\n$.require(\\\"video\\\")\\n}else if(分类==2){\\n$.require(\\\"zonghe\\\")\\n}\\n\"},{\"col_type\":\"movie_2\",\"name\":\"搜索\",\"path\":\"search\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar pg=MY_URL.split('=')[1].replace('&kw','');\\nif(MY_PAGE==1){\\nvar data=JSON.parse(getItem('search')).config;\\nvar url_n=data[0].api+data[0].platform;\\ndata.forEach(data => {\\n        var url=data.api+data.platform;\\n        if((data.title!='福利')&(!data.platform.includes('yuepao'))){\\n        d.push({\\n            title: getMyVar('搜索分类',url_n)==url?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,url,cate) => {\\n               putMyVar('搜索分类', url);\\n               putMyVar('搜索分类名',title);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,url,'搜索分类'),\\n           col_type:'scroll_button',\\n           extra:{\\n              key:'搜索分类: '+getMyVar('搜索分类',url_n),\\n              word:'搜索分类名: '+getMyVar('搜索分类名','视频'),\\n              keyword:getMyVar('keyword'),\\n          }\\n    })\\n    }\\n})\\nd.push({\\n        col_type: 'blank_block',\\n    });\\nvar list=JSON.parse(fetch(getMyVar('搜索分类','http://003.22s.lol/searchconfig/video.txt'))).searchapi;\\nvar url_n='https://api1.yilushunfeng.top/'+list[0].platform+'.php';\\nlist.forEach(data => {\\n        var url='https://api1.yilushunfeng.top/'+data.platform+'.php';\\n        d.push({\\n            title: getMyVar(getMyVar('搜索分类名','视频')+'搜索列表',url_n)==url?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,url,cate) => {\\n               putMyVar(getMyVar('搜索分类名','视频')+'搜索列表', url);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,url,getMyVar('搜索分类名','视频')+'搜索列表'),\\n           col_type:'scroll_button',\\n           extra:{\\n              key:getMyVar('搜索分类名','视频')+'搜索列表',\\n              url:url,\\n              wz:data.platform,\\n              keyword:getMyVar('keyword'),\\n          }\\n    })\\n})\\n}\\nvar search_url=getMyVar(getMyVar('搜索分类名','视频')+'搜索列表',url_n)+'?keyword='+getMyVar('keyword')+'&page='+pg;\\n//log(search_url)\\nvar host=search_url.split('?')[0];\\ntry{\\nif(getMyVar('搜索分类名','视频')=='视频'){\\nvar Arr=['lusir','51lieqi','tangtoutiao','50du','tiktok','xingba','anwangjiemi','qiyou','caoliushequ','91paofu','meiridasai','pornhub','douyinmax','51luoli','91porn_sfktv','shuiguopai','sifangktv','weimiquan','heiliaobdy','51chigua'];\\nvar Brr=['lutube'];\\nvar Crr=['ins'];\\nvar platform=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[2];\\n//log(platform)\\nvar item=JSON.parse(fetch(search_url)).videos;\\nitem.forEach(data => {\\n    if(Arr.includes(platform)){\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image+lazy,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2',\\n            extra:{\\n              id:data.id,\\n          }\\n        })\\n    }else if(Brr.includes(platform)){\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image+lulazy,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else if(Crr.includes(platform)){\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image+inslazy,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else{\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n        }\\n    })\\n}else if(getMyVar('搜索分类名','视频')=='全网破解'){\\n    var Arr=['ttt','loanword','loanword_2','91short','sepone','lusir','cape','degree','burma'];\\n  var platform=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[4];\\n  var item=JSON.parse(fetch(search_url)).videos;\\n // log(item)\\nitem.forEach(data => {\\n    if(Arr.includes(platform)){\\n        d.push({\\n            title: data.title,\\n            img: data.image+lazy,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else{\\n        d.push({\\n            title: data.title,\\n            img: data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n        }\\n    })\\n}else if(getMyVar('搜索分类名','视频')=='短视频'){\\n    var Arr=['tiktok18new','91dspweb','douyinmax','91porn_sifangktv','fantasi'];\\n  var platform=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[2];\\n  var item=JSON.parse(fetch(search_url)).videos;\\n // log(item)\\nitem.forEach(data => {\\n    if(Arr.includes(platform)){\\n        d.push({\\n            title: data.title,\\n            img: data.image+lazy,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else{\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n        }\\n    })\\n}else if(getMyVar('搜索分类').includes('actress')|(getMyVar('搜索分类名','视频')=='番号')|(getMyVar('搜索分类名','视频')=='三级')){\\n    var Arr=['shuiguopai'];\\n  var platform=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[2];\\n  var item=JSON.parse(fetch(search_url)).videos;\\n // log(item)\\nitem.forEach(data => {\\n    if(Arr.includes(platform)){\\n        d.push({\\n            title: data.title,\\n            img: data.image+lazy,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else{\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n        }\\n    })\\n}else if(getMyVar('搜索分类名','视频')=='吃瓜'){\\n  var wz=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[3];\\n  var list=JSON.parse(fetch(search_url)).videos;\\n // log(item)\\nif(wz=='haijiao'){\\n    list.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img:  data.image + \\\"@js=\\\" + $.toString((rule) => {\\n                            const image = $.require(\\\"hiker://page/aes?rule=\\\" + rule);\\n                            return image.imageDecrypt();\\n                        }, MY_RULE.title),\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/blackerji1\\\")',\\n            col_type:'pic_1',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n}else{\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: ((wz=='51cg')|(wz=='hlbdy')|(wz=='tiktok18'))?(data.image+lazy):data.image,\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/blackerji1\\\")',\\n            col_type:'pic_1',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n }\\n}else if(getMyVar('搜索分类名','视频')=='小说'){\\n  var wz=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[3];\\n  var list=JSON.parse(fetch(search_url)).videos;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/xiaoshuoerji1\\\")',\\n            col_type:'text_1',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n}else if(getMyVar('搜索分类名','视频')=='漫画'){\\n  var wz=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[2];\\n  var list=JSON.parse(fetch(search_url)).videos;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: data.image,\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/manhuaerji1\\\")',\\n            col_type:'movie_3',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n}else if(getMyVar('搜索分类名','视频')=='图片'){\\n  var wz=host.match(/top\\\\/.*\\\\.php/)[0].split('.php')[0].split('/')[2];\\n  var list=JSON.parse(fetch(search_url)).videos;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: wz=='tiktok18'?(data.image+lazy):data.image,\\n            //url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/tupianerji\\\")',\\n            url: wz=='tuzac'?data.image:(host+'?id='+data.id+pics),\\n            col_type:'movie_3',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n}\\n}catch(e){\\n    log(e.message)\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"02综合\",\"path\":\"zonghe\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\n//log(getItem('data'))\\n\\n // var list=getItem('data').split('综合数据开始')[1].split('综合数据结束')[0].split('换行');\\n var list=getItem('data').split('综合数据开始')[1].split('AV百科')[0].replace(/分割线/g,'换行').split('换行');\\n  list.forEach(data=>{\\n      var qd=sp(data, \\\"qd(\\\", \\\")\\\");\\n      var tp=sp(data, \\\"tp(\\\", \\\")\\\");\\n      var mc=sp(data, \\\"mc(\\\", \\\")\\\");\\n      var wz=sp(data, \\\"gjc(\\\", \\\")\\\");\\n      var ym=sp(data, \\\"ym(\\\", \\\")\\\");\\n      var lx=sp(data, \\\"lx(\\\", \\\")\\\");\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\n      if(lx=='二级菜单'){\\n      d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##'+'@rule=js:$.require(\\\"hiker://page/videoerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }else if(lx=='黑料'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/blackerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }else if(lx=='国内直播'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##'+'@rule=js:$.require(\\\"hiker://page/zhiboerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }else if((lx=='国外直播')|(lx=='视频')){\\n          if(!mc.includes('全网搜')){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/syvideo\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }\\n      }else if(lx.includes('女')&lx.includes('优')&(wz!='missav')){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/nvyouerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n          })\\n      }else if(lx=='帖子'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/tieerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n          })\\n      }else if(lx=='直播'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/zhibojuheerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              wz:mc,\\n          }\\n      })\\n      }else if(lx=='漫画'){\\n          if(mc=='猫咪漫画'){\\n         d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/maomimanhua\\\")',\\n          col_type:'icon_4_card'\\n      })\\n          }else{\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/manhuaerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n     }\\n      }else if(lx=='小说'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/xiaoshuoerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }else if(lx=='图片'){\\n          if(mc=='猫咪美图'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/maomimeitu\\\")',\\n          col_type:'icon_4_card'\\n          })\\n          }else if(mc!='美图色图'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/picerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n          })\\n          }\\n      }else if(lx=='有声小说'){\\n          if(mc=='猫咪FM'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/maomiFM\\\")',\\n          col_type:'icon_4_card'\\n          })\\n          }\\n      }\\n  })\\n/*\\nvar ziyong=getItem('data').replace('-','').split('分割线')[1].split('换行');\\n  ziyong.forEach(data=>{\\n      var qd=sp(data, \\\"qd(\\\", \\\")\\\");\\n      var tp=sp(data, \\\"tp(\\\", \\\")\\\");\\n      var mc=sp(data, \\\"mc(\\\", \\\")\\\");\\n      var wz=sp(data, \\\"gjc(\\\", \\\")\\\");\\n      var ym=sp(data, \\\"ym(\\\", \\\")\\\");\\n      var lx=sp(data, \\\"lx(\\\", \\\")\\\");\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\n      if(mc.includes('鉴赏')){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/videoerji\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }\\n      })\\n      */\\n}catch(e){\\n    log(e.message)\\n}\"},{\"col_type\":\"movie_2\",\"name\":\"视频分类\",\"path\":\"videoerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nvar 视频分类=fetch(host+'?getsort')\\nlet data= JSON.parse(视频分类);\\n//log(data)\\nvar keys=Object.keys(data).slice(2);\\n//log(keys)\\nvar key_n=keys[0];\\nkeys.forEach(key => {\\n    d.push({\\n            title: getMyVar('视频分类'+wz,key_n)==key?strong(key,'FF6699'):key,\\n            url:$(key).lazyRule((key,wz) => {\\n               putMyVar('视频分类'+wz, input);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, key,wz),\\n            col_type:'scroll_button',\\n    })\\n    })\\ndata[getMyVar('视频分类'+wz,key_n)].forEach(data => {\\n        d.push({\\n            title: data.title,\\n            url: 'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/voderji1\\\")',\\n           col_type:'text_3',\\n           extra:{\\n              host:`${host}?sort=${data.id}&page=`,\\n              wz:wz,\\n          }\\n    })\\n})\\n}catch(e){\\n    log(e.message)\\n    toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"视频二级\",\"path\":\"voderji1\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nvar pg=MY_URL.split('##')[1]\\nvar host=MY_PARAMS.host+pg;\\nvar url=host.split('?')[0];\\nvar wz=MY_PARAMS.wz;\\ntry{\\n    var list= JSON.parse(fetch(host)).videos;\\n  //  log(list)\\nif((wz=='xbk')|(wz=='md')){\\n    list.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image,\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n })\\n}else if(wz=='maomi'){\\n    list.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image,\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n    })\\n })\\n}else if(wz=='xcl'){\\n    list.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image,\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n    })\\n })\\n}else if(wz=='qisemao'){\\n    list.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:data.duration,\\n            img: data.image,\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n    })\\n })\\n}else if(wz=='91pf'){\\n    list.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:parseInt(data.duration/60)+':'+parseInt(data.duration%60),\\n            img: data.image+lazy,\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n    })\\n })\\n}else{\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: (data.date.includes('-')?data.date:data.created_date)+'\\\\t\\\\t\\\\t\\\\t'+(data.duration==null?'':data.duration),\\n            img: data.image+lazy,\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n })\\n }\\n \\n}catch(e){\\n    log(e.message)\\n     toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"黑料分类\",\"path\":\"blackerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nvar pg=MY_URL.split('##')[1];\\nif(MY_PAGE==1){\\nvar 黑料分类=fetch(host+'?getsort')\\nvar data= JSON.parse(黑料分类).categories;\\nvar index_n=data[0].id.toString();\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('黑料分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('黑料分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id.toString(),wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('黑料分类'+wz,index_n)+'&page='+pg)).videos;\\n//log(list)\\nif(wz=='haijiao'){\\n    list.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img:  data.image + \\\"@js=\\\" + $.toString((rule) => {\\n                            const image = $.require(\\\"hiker://page/aes?rule=\\\" + rule);\\n                            return image.imageDecrypt();\\n                        }, MY_RULE.title),\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/blackerji1\\\")',\\n            col_type:'pic_1',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n}else{\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: ((wz=='51cg')|(wz=='hlbdy'))?(data.image+lazy):data.image,\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/blackerji1\\\")',\\n            col_type:'pic_1',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n }\\n }catch(e){\\n     log(e.message)\\n }\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"黑料二级\",\"path\":\"blackerji1\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nvar url=MY_PARAMS.host;\\nvar wz=MY_PARAMS.wz;\\ntry{\\nvar data= JSON.parse(fetch(url));\\n//log(data)\\n        d.push({\\n            title:pdfh(data.titleCode,'h1&&Text')==''?pdfh(data.titleCode,'h2&&Text'):pdfh(data.titleCode,'h1&&Text'),\\n            col_type:'rich_text'\\n        })\\n        if(wz=='cgw'){\\n            var videos=data.video.replace(/\\\\$/g,'').split('@');\\n        var img=data.imgcode.match(/src\\\\=\\\\\\\".*?\\\\\\\".*?alt/)[0].split('\\\"')[1];\\n    videos.forEach((item, index) => {\\n        var n=index+1;\\n        if(item){\\n        d.push({\\n            title:'视频'+n,\\n            desc:'0',\\n            img:img,\\n            url:item.replace('分割',''),\\n            col_type: 'card_pic_1',\\n        });\\n        }\\n    })\\n        d.push({\\n            title: data.imgcode,\\n            col_type:'rich_text',\\n        })\\n        }else if(wz=='gtl'){\\n        var videos=data.video.replace(/\\\\$/g,'').split('@');\\n        var img=data.picCode.match(/src\\\\=\\\\\\\".*?\\\\\\\".*?alt/)[0].split('\\\"')[1];\\n    videos.forEach((item, index) => {\\n        var n=index+1;\\n        if(item){\\n        d.push({\\n            title:'视频'+n,\\n            desc:'0',\\n            img:img,\\n            url:item.replace('分割',''),\\n            col_type: 'card_pic_1',\\n        });\\n        }\\n    })\\n            d.push({\\n            title: data.picCode,\\n            col_type:'rich_text',\\n        })\\n        }else if(wz=='tiktok18'){\\n        var videos=data.video.replace(/\\\\$/g,'').split('@');\\n        var imgs=data.picCode.replace(/\\\\$/g,'').split('@分割');\\n    videos.forEach((item, index) => {\\n        var n=index+1;\\n        if(item){\\n        d.push({\\n            title:'视频'+n,\\n            desc:'0',\\n            img:imgs[0]+lazy,\\n            url:item.replace('分割',''),\\n            col_type: 'card_pic_1',\\n        });\\n        }\\n    })\\n        var texts=data.imgcode.replace(/\\\\<p\\\\>/,'&&&<p>').replace(/\\\\<\\\\/p\\\\>/,'&&&</p>').split('&&&');\\n      //  log(texts)\\n        texts.forEach((item, index) => {\\n    if (pdfh(item, 'p&&Text')) {\\n        d.push({\\n            title: pdfh(item, 'p&&Text'),\\n            col_type: 'rich_text',\\n        });\\n    }\\n    if (pdfh(item, 'h1&&Text')) {\\n        d.push({\\n            title: pdfh(item, 'p&&Text'),\\n            col_type: 'rich_text',\\n        });\\n    }\\n    if (pdfh(item, 'h2&&Text')) {\\n        d.push({\\n            title: pdfh(item, 'p&&Text'),\\n            col_type: 'rich_text',\\n        });\\n    }\\n    })\\n    var imgs=data.picCode.replace(/\\\\$/g,'').split('@分割');\\n    imgs.forEach((item, index) => {\\n        if(item){\\n        d.push({\\n            img:item+lazy,\\n            url:item+lazy,\\n            col_type: 'pic_1_full',\\n        });\\n        }\\n    })\\n        }else if(wz=='51cg'){\\n        var n=0\\n        var texts=data.imgcode.replace(/pstyle/g,'p style').replace(/\\\\<\\\\/p.*?\\\\>\\\\<p.*?\\\\>/g,'</p>&&<p>').split('&&');\\n       // log(texts)\\n       texts.forEach((item, index) => {\\n           if(pdfh(item,'.dplayer&&data-config')!=''){\\n        let url=JSON.parse(pdfh(item,'.dplayer&&data-config')).video;\\n        n++;\\n        d.push({\\n            title: '““视频””  ' + n,\\n            desc:'0',\\n            img: url.pic + lazy,\\n            url: url.url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'card_pic_1'\\n        });\\n       }\\n       })\\n       texts.forEach((item, index) => {\\n    if (pdfh(item, 'p&&Text')) {\\n        d.push({\\n            title: pdfh(item, 'p&&Text'),\\n            col_type: 'rich_text',\\n        });\\n    }\\n    var imgs = pdfa(item, 'p&&img').map(h => pdfh(h, 'img&&data-xkrkllgl'));\\n    imgs.forEach(item2 => {\\n        d.push({\\n            title: '',\\n            img: item2 + lazy,\\n            url: item2 + lazy,\\n            col_type: 'pic_1_full'\\n        });\\n    });\\n    if(pdfh(item,'.dplayer&&data-config')!=''){\\n        let url=JSON.parse(pdfh(item,'.dplayer&&data-config')).video;\\n        n++;\\n        d.push({\\n            title: '““视频””  ' + n,\\n            desc:'0',\\n            img: url.pic + lazy,\\n            url: url.url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'card_pic_1'\\n        });\\n    }\\n    })\\n        }else if(wz=='hlbdy'){\\n            var n=0\\n        var texts=data.picCode.replace(/\\\\<\\\\/p\\\\>\\\\n\\\\<p\\\\>/g,'</p>&&<p>').split('&&');\\n       // log(texts)\\n         texts.forEach((item, index) => {\\n           if(pdfh(item,'.dplayer&&config')!=''){\\n        let url=JSON.parse(pdfh(item,'.dplayer&&config')).video;\\n        n++;\\n        d.push({\\n            title: '““视频””  ' + n,\\n            desc:'0',\\n            img: url.pic + lazy,\\n            url: url.url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'card_pic_1'\\n        });\\n       }\\n       })\\n       var n=0;\\n       texts.forEach((item, index) => {\\n    if (pdfh(item, 'p&&Text')) {\\n        d.push({\\n            title: pdfh(item, 'p&&Text'),\\n            col_type: 'rich_text',\\n        });\\n    }\\n    var imgs = pdfa(item, 'p&&img').map(h => pdfh(h, 'img&&onload'));\\n    imgs.forEach(item2 => {\\n        d.push({\\n            title: '',\\n            img: item2.split(\\\"(this,'\\\")[1].split(\\\"')\\\")[0] + lazy,\\n            url: item2.split(\\\"(this,'\\\")[1].split(\\\"')\\\")[0] + lazy,\\n            col_type: 'pic_1_full'\\n        });\\n    });\\n    if(pdfh(item,'.dplayer&&config')!=''){\\n        let url=JSON.parse(pdfh(item,'.dplayer&&config')).video;\\n        n++;\\n        d.push({\\n            title: '““视频””  ' + n,\\n            desc:'0',\\n            img: url.pic + lazy,\\n            url: url.url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'card_pic_1'\\n        });\\n       }\\n    })\\n        }else if(wz=='haijiao'){\\n            try{\\n            var videos=data.video.replace(/\\\\$/g,'').split('@');\\n        var img=data.picCode.match(/xkrkllgl\\\\=\\\\\\\".*?\\\\\\\".*?alt/)[0].split('\\\"')[1];\\n    videos.forEach((item, index) => {\\n        var n=index+1;\\n        if(item){\\n        d.push({\\n            title:'视频'+n,\\n            desc:'0',\\n            img:img+ \\\"@js=\\\" + $.toString((rule) => {\\n                            const image = $.require(\\\"hiker://page/aes?rule=\\\" + rule);\\n                            return image.imageDecrypt();\\n                        }, MY_RULE.title),\\n            url:item.replace('分割','')+'#isVideo=true#',\\n            col_type: 'card_pic_1',\\n        });\\n        }\\n    })\\n        var texts=data.picCode.replace(/pstyle/g,'p style').replace(/\\\\<\\\\/p\\\\>/g,'</p>&&').split('&&');\\n        texts.forEach((item, index) => {\\n    if (pdfh(item, 'p&&Text')) {\\n        d.push({\\n            title: pdfh(item, 'p&&Text'),\\n            col_type: 'rich_text',\\n        });\\n    }\\n      var img=item.match(/xkrkllgl\\\\=\\\\\\\".*?\\\\\\\".*?alt/);\\n      if(img){\\n     // log(img)\\n      d.push({\\n          img:img[0].split('\\\"')[1]+ \\\"@js=\\\" + $.toString((rule) => {\\n                            const image = $.require(\\\"hiker://page/aes?rule=\\\" + rule);\\n                            return image.imageDecrypt();\\n                        }, MY_RULE.title),\\n          url:img[0].split('\\\"')[1]+ \\\"@js=\\\" + $.toString((rule) => {\\n                            const image = $.require(\\\"hiker://page/aes?rule=\\\" + rule);\\n                            return image.imageDecrypt();\\n                        }, MY_RULE.title),\\n          col_type:'pic_1_full'\\n      })\\n       }\\n    })\\n    }catch{}\\n        }else if(wz=='kanliao'){\\n            var texts=data.picCode.replace(/\\\\<br\\\\>/g,'&&').split('&&');\\n            var n=0;\\n           texts.forEach((item, index) => {\\n                if(pdfh(item,'.dplayer&&data-config')!=''){\\n        let url=JSON.parse(pdfh(item,'.dplayer&&data-config')).video;\\n        n++;\\n        d.push({\\n            title: '视频 ' + n,\\n           // desc:'0',\\n            img: url.pic,\\n            url: url.url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'text_1'\\n        });\\n       }\\n       })\\n       d.push({\\n            title: data.picCode,\\n            col_type:'rich_text',\\n        })\\n        }\\n        \\n        }catch{}\\n        \\n        \\n        /*\\n        try{\\n        var video=data.videocode.replace(/\\\\<\\\\/video\\\\>/g,'</video>&&').split('&&');\\n        video.forEach((item,index) => {\\n           if(pdfh(item, 'video&&src')){\\n            var n=index+1;\\n        d.push({\\n            title: '视频'+n,\\n            desc:'0',\\n            img: pdfh(item, 'video&&poster'),\\n            url: pdfh(item, 'video&&src'),\\n            col_type: 'card_pic_1'\\n        })\\n        }\\n        })\\n        }catch{}\\n        \\n        d.push({\\n            title:'视频',\\n            desc:'0',\\n            img:pdfh(data.videocode,'video&&poster'),\\n            url:pdfh(data.videocode,'video&&src'),\\n            col_type:'card_pic_1'\\n            \\n        })\\n        */\\n      \\n       \\n        \\n        /*\\n        if(wz=='cgw'){\\n        d.push({\\n            title: data.imgcode,\\n            col_type:'rich_text',\\n        })\\n        }\\n        */\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"国内直播分类\",\"path\":\"zhiboerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nif(MY_PAGE==1){\\nvar 直播分类=fetch(host+'?getpingtai')\\nvar data= JSON.parse(直播分类).pingtai;\\ndata.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            img:data.image,\\n            url:'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/zhiboerji1\\\")',\\n           col_type:'card_pic_3',\\n           extra:{\\n              host:`${host}?pingtai=${data.id}`,\\n              wz:wz,\\n          }\\n    })\\n})\\n}\\n}catch(e){\\n    log(e.message)\\n    toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"国内直播二级\",\"path\":\"zhiboerji1\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nlet host=MY_PARAMS.host;\\nlet url=host.split('?')[0];\\nvar wz=MY_PARAMS.wz;\\ntry{\\nlet list= JSON.parse(fetch(host)).zhubo;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            img: data.image,\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_3'\\n        })\\n })\\n}catch(e){\\n    log(e.message)\\n     toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"国外直播分类\",\"path\":\"guowaierji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_URL.split('##')[1].replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[3];\\nvar 国外直播分类=fetch(host+'?getsort')\\nvar data= JSON.parse(国外直播分类).categories;\\nvar index_n=data[0].id.toString()\\nif(MY_PAGE==1){\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('国外直播分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('国外直播分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id.toString(),wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\n\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('国外直播分类'+wz,index_n)+'&page='+pg)).videos;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: ((data.image.includes('upload')|data.image.includes('new.'))&!data.image.includes('toolmm'))?(data.image+lazy):data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n })\\n }catch(e){\\n     log(e.message)\\n     toast('看不了')\\n }\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"女 优分类\",\"path\":\"nvyouerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nvar pg=MY_URL.split('##')[1];\\nvar item=request(host+'?actress=&page='+pg)\\nvar data= JSON.parse(item).actresses;\\ndata.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:data.number,\\n            img:data.image,\\n            url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/nvyouerji1\\\")',\\n           col_type:'card_pic_3',\\n           extra:{\\n              host:`${host}?sort=${data.id}&page=`,\\n              wz:wz,\\n          }\\n    })\\n})\\n\\n}catch(e){\\n    log(e.message)\\n}\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"女 优二级\",\"path\":\"nvyouerji1\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nvar pg=MY_URL.split('##')[1];\\nvar host=MY_PARAMS.host+pg;\\nvar url=host.split('?')[0];\\nvar wz=MY_PARAMS.wz;\\ntry{\\nlet list= JSON.parse(fetch(host)).videos;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            img: data.image,\\n            desc:(data.createtime==null?'':data.createtime)+'  '+(data.date==null?'':data.date),\\n            url: url+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n })\\n}catch(e){\\n    log(e.message)\\n     toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"帖子分类\",\"path\":\"tieerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nvar pg=MY_URL.split('##')[1];\\nif(MY_PAGE==1){\\nvar 帖子分类=fetch(host+'?getsort')\\nvar data= JSON.parse(帖子分类).categories;\\nvar index_n=data[0].id.toString();\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('帖子分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('帖子分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id.toString(),wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('帖子分类'+wz,index_n)+'&page='+pg)).videos;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            //img: 'https://images.xoowbs.com/upload_01'+data.image.split('upload_01')[1],\\n            img:data.image+lazy,\\n            url: 'hiker://empty##'+'@rule=js:$.require(\\\"hiker://page/blackerji1\\\")',\\n            col_type:'pic_1',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n }catch(e){\\n    log(e.message)\\n     toast('看不了')\\n }\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"直播聚合分类\",\"path\":\"zhibojuheerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet wz=MY_PARAMS.wz;\\nif(wz=='直播聚合'){\\n    host='http://api.vipmisss.com:81/xcdsw/'\\n}else{\\n    host='http://api.maiyoux.com:81/mf/'\\n}\\nif(MY_PAGE==1){\\nvar 直播聚合=request(host+'json.txt')\\nvar data= JSON.parse(直播聚合).pingtai;\\ndata.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:data.Number,\\n            img:data.xinimg,\\n            url:'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/zhibojuheerji1\\\")',\\n           col_type:'card_pic_3',\\n           extra:{\\n              host:`${host}${data.address}`,\\n              wz:wz,\\n          }\\n    })\\n})\\n}\\n}catch(e){\\n    log(e.message)\\n    toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"直播聚合二级\",\"path\":\"zhibojuheerji1\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nlet host=MY_PARAMS.host;\\ntry{\\nlet list= JSON.parse(fetch(host)).zhubo;\\n//log(list)\\nlist.forEach(data => {\\n    if(!data.title.includes('9999')){\\n        d.push({\\n            title: data.title,\\n            img: data.img,\\n            url: data.address,\\n            col_type:'movie_2'\\n        })\\n        }\\n })\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"漫画分类\",\"path\":\"manhuaerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nvar pg=MY_URL.split('##')[1];\\nif(MY_PAGE==1){\\nvar 漫画分类=fetch(host+'?getsort')\\nvar data= JSON.parse(漫画分类).categories;\\nvar index_n=data[0].id.toString()\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('漫画分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('漫画分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id.toString(),wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('漫画分类'+wz,index_n)+'&page='+pg)).videos;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: data.image,\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/manhuaerji1\\\")',\\n            col_type:'movie_3',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n }catch(e){\\n     log(e.message)\\n     toast('看不了')\\n }\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"漫画目录\",\"path\":\"manhuaerji1\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nlet host=MY_PARAMS.host;\\nlet url=host.split('?')[0];\\nvar wz=MY_PARAMS.wz;\\ntry{\\nlet list= JSON.parse(fetch(host)).chapters;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            url: url+'?id='+data.id+pics,\\n            col_type:'text_2'\\n        })\\n })\\n      d.push({\\n          title:'第1章预览',\\n          col_type:'rich_text',\\n      })\\n let img= JSON.parse(fetch(host)).content.replace(/\\\\$/g,'').replace(/分割/g,'').split('@');\\n img.forEach(data => {\\n        d.push({\\n            img:data,\\n            url: 'pics://'+img.join('&&'),\\n            col_type:'pic_1_full'\\n        })\\n })\\n \\n}catch(e){\\n    log(e.message)\\n     toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"猫咪漫画\",\"path\":\"maomimanhua\",\"rule\":\" js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar pg=MY_URL.split('##')[1];\\ntry{\\nvar 猫咪漫画= [{title: '推荐&最新&精华',id: 'recommend&update&popular'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(猫咪漫画,'猫咪漫画',d);\\n}\\nvar sign=Encrypt('{\\\"page\\\":'+pg+'}');\\nvar host='http://119.28.52.193:8089/api/comic/'+getMyVar('猫咪漫画','recommend')+'?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\n//log(html2)\\nvar list=JSON.parse(html2).data.data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            img: data.thumb,\\n            url: 'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/maomimanhuaerji\\\")',\\n          //url:data.id+maomimanhuajx,\\n            col_type:'movie_3',\\n            extra:{\\n              id:data.id,\\n          }\\n        })\\n })\\n}catch(e){\\n    log(e.message)\\n     toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"小说分类\",\"path\":\"xiaoshuoerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nvar pg=MY_URL.split('##')[1];\\nif(MY_PAGE==1){\\nvar 小说分类=fetch(host+'?getsort')\\nvar data= JSON.parse(小说分类).categories;\\nvar index_n=data[0].id.toString();\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('小说分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('小说分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id.toString(),wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('小说分类'+wz,index_n)+'&page='+pg)).list;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/xiaoshuoerji1\\\")',\\n            col_type:'text_1',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n }catch{}\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"小说二级\",\"path\":\"xiaoshuoerji1\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nlet host=MY_PARAMS.host;\\nlet url=host.split('?')[0];\\nvar wz=MY_PARAMS.wz;\\ntry{\\n    if((wz=='jinjishuwu')|(wz=='lebo')|(wz=='huanxiang')|(wz=='jkun')){\\n        let novel= JSON.parse(fetch(host)).novel;\\n        d.push({\\n            title:novel,\\n            col_type:'rich_text'\\n        })\\n    }else{\\nlet id= JSON.parse(fetch(host)).id;\\n loadReadContentPage(id)\\n }\\n}catch{\\n    toast('谁特么看小说啊！')\\n}\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"猫咪漫画二级\",\"path\":\"maomimanhuaerji\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nvar pg=MY_URL.split('##')[1];\\nvar id=MY_PARAMS.id;\\nvar sign=Encrypt('{\\\"id\\\":'+id+',\\\"page\\\":'+pg+',\\\"sort\\\":0}');\\nvar host='http://119.28.52.193:8089/api/comic/lists?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\nvar list=JSON.parse(html2).data.data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.name,\\n            img: data.image,\\n            url: data.id+maomimanhuajx,\\n            col_type: \\\"movie_1_left_pic\\\",\\n    })\\n    })\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"猫咪美图\",\"path\":\"maomimeitu\",\"rule\":\" js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar pg=MY_URL.split('##')[1];\\ntry{\\nvar 猫咪美图= [{title: '热门&闲聊讨论&蕾丝女同&美腿玉足&巨乳美胸&男同&原创自拍&动漫&认证&sm&课堂&我妻&高潮脸&网红大咖&制服诱惑&蜜汁美臀',id: '0&3&7&9&10&22&1&8&26&6&31&23&2&18&4&21'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(猫咪美图,'猫咪美图',d);\\n}\\nvar sign=Encrypt('{\\\"page\\\":'+pg+',\\\"cate\\\":'+getMyVar('猫咪美图','0')+',\\\"type\\\":1}');\\nvar host='http://119.28.52.193:8089/api/v2/post/home?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\nvar list=JSON.parse(html2).data;\\nlist.forEach(data => {\\n    if(data.images){\\n        \\n        d.push({\\n            title: data.title,\\n            desc:data.time,\\n            img: data.images[0].image,\\n            url: $('').lazyRule(data => {\\n          let picArr=[];\\n          let img=data.images;\\n          let len= img.length-1;\\n           for (i = 0; i <= len; i++) {\\n                picArr[i] = img[i].image;\\n            }\\n            return \\\"pics://\\\" + picArr.join(\\\"&&\\\")\\n        },data),\\n            col_type:'movie_3'\\n        })\\n        }\\n })\\n }catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"猫咪FM\",\"path\":\"maomiFM\",\"rule\":\" js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar pg=MY_URL.split('##')[1];\\nvar 猫咪FM= [{title: '都市激情&家庭乱 伦&另类小说&青春校园&情 色笑话&人 妻乱 伦&性 爱技巧&玄幻奇幻',id: '8&9&10&11&12&13&14&15'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(猫咪FM,'猫咪FM',d);\\n}\\nvar sign=Encrypt('{\\\"page\\\":'+pg+',\\\"cate_id\\\":'+getMyVar('猫咪FM','8')+',\\\"status\\\":0,\\\"type\\\":0,\\\"new\\\":0}');\\nvar host='http://119.28.52.193:8089/api/book/index?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\nvar list=JSON.parse(html2).data.data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.name,\\n            img: data.thumb,\\n            url: data.id+maomifmjx,\\n            col_type:'movie_3'\\n        })\\n })\\n\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"01首页视频\",\"path\":\"video\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\n  var list=getItem('shouye').split('首页数据开始')[1].split('首页数据结束')[0].split('换行');\\n  list.forEach(data=>{\\n      var qd=sp(data, \\\"qd(\\\", \\\")\\\");\\n      var tp=sp(data, \\\"tp(\\\", \\\")\\\");\\n      var mc=sp(data, \\\"mc(\\\", \\\")\\\");\\n      var wz=sp(data, \\\"gjc(\\\", \\\")\\\");\\n      var ym=sp(data, \\\"ym(\\\", \\\")\\\");\\n      var lx=sp(data, \\\"lx(\\\", \\\")\\\");\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\n      if(qd=='麻豆TV'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/madou\\\")',\\n          col_type:'icon_4_card'\\n      })\\n      }else if(qd=='91TV'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/91tv\\\")',\\n          col_type:'icon_4_card'\\n      })\\n      }else if(qd=='猫咪'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/maomi\\\")',\\n          col_type:'icon_4_card'\\n      })\\n      }else if(qd=='猫咪原创'){\\n          d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/maomiyuanchuang\\\")',\\n          col_type:'icon_4_card'\\n      })\\n      }else{\\n      d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/syvideo\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }\\n  })\\n      \\n      var list1=getItem('shouye').split('分割线')[1].split('换行');\\n  list1.forEach(data=>{\\n      var qd=sp(data, \\\"qd(\\\", \\\")\\\");\\n      var tp=sp(data, \\\"tp(\\\", \\\")\\\");\\n      var mc=sp(data, \\\"mc(\\\", \\\")\\\");\\n      var wz=sp(data, \\\"gjc(\\\", \\\")\\\");\\n      var ym=sp(data, \\\"ym(\\\", \\\")\\\");\\n      var lx=sp(data, \\\"lx(\\\", \\\")\\\");\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\n      if(tp!=null){\\n          if((wz=='xiangjiao')|(wz=='91dsp')|(wz=='tiktok18')|(wz=='ogfap')|(wz=='tiktok18long')|(wz=='xiaohuli')){\\n     }else{\\n      d.push({\\n          title:mc,\\n          desc:qb,\\n          img:'http://api.xka1.top'+tp,\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/syvideo\\\")',\\n          col_type:'icon_4_card',\\n          extra:{\\n              host:`${ym}/${wz}.php`,\\n              wz:wz,\\n          }\\n      })\\n      }\\n      }\\n      })\\n}catch(e){\\n    log(e.message)\\n    if(getMyVar('a') == ''){\\n    var shouye=qzDecrypt(request('http://003.22s.lol/encrypt/api.php?path=qiezi/shouye'))\\n    var data=qzDecrypt(request('http://003.22s.lol/encrypt/api.php?path=qiezi/zonghe'))\\n    var search=fetch('http://003.22s.lol/searchconfig/vipapi/vipconfig.txt')\\n   // var kuozhan=qzDecrypt(request('http://004.22s.lol/encrypt/api.php?path=qiezi/heikeji'))\\n   // var yuming=qzDecrypt(request('http://01.xka3a.top/encrypt/api.php?path=yuming/yuming'))\\n  //  var gonggao=qzDecrypt(request('http://003.22s.lol/encrypt/api.php?path=qiezi/qz'))\\n    putMyVar('a','1')\\n    setItem('shouye',shouye)\\n    setItem('data',data)\\n    setItem('search',search)\\n    refreshPage()\\n    toast('数据已更新')\\n    /*\\n    \\n    域名替换匹配表达式https?://(api1?\\\\.)?(changfapiaopiao|yilushunfeng|phpjiekou|apijiekou)\\\\.top(/api)?《\\n线路集合https://api1.yilushunfeng.top|https://api.changfapiaopiao.top|http://api1.yilushunfeng.top|http://api.changfapiaopiao.top|http://api1.apijiekou.top/api|http://api.phpjiekou.top|http://004.22s.lol/api《\\n失效域名集合https://api.yilushunfeng.top|http://api.yilushunfeng.top|http://api11.phpjiekou.top《\\n最新接口域名https://api1.yilushunfeng.top《\\n*/\\n  }\\n}\"},{\"col_type\":\"movie_2\",\"name\":\"猫咪AV\",\"path\":\"maomiav\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_URL.split('##')[1].replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[3];\\nif(MY_PAGE==1){\\nvar 国外直播分类=fetch(host+'?getsort')\\nvar data= JSON.parse(国外直播分类).categories;\\nvar index_n=data[0].id\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('国外直播分类'+wz,index_n)==data.id?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('国外直播分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id,wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('国外直播分类'+wz,index_n)+'&page='+pg)).videos;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n })\\n }catch(e){\\n     log(e.message)\\n     toast('看不了')\\n }\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"麻豆TV\",\"path\":\"madou\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\n//md5加密\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\nvar t = Math.floor(Date.now()); \\nlet pg= MY_URL.split('##')[1];\\nvar md= [{title: '首页&频道&标签',id: '1&2&3',img:'https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/111.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/112.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/113.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/114.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/122.svg'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(md,'md',d);\\nd.push({\\n    col_type: 'line',\\n},{\\n    col_type: 'big_blank_block',\\n}\\n,{\\n    col_type: 'big_blank_block',\\n});\\n}\\nlet 分类=getMyVar('md', '1');\\n\\nif(分类==1){\\nvar sign = md5('list_row=20&page='+pg+'&timestamp='+t+'&type=2'+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^');\\nvar data0={\\n       \\\"encode_sign\\\":sign,\\n       \\\"list_row\\\":\\\"20\\\",\\n       \\\"page\\\":pg,\\n       \\\"timestamp\\\":t,\\n       \\\"type\\\":\\\"2\\\"};\\nvar data = mdEncrypt(JSON.stringify(data0)); \\nvar body = 'post-data='+data; \\nvar url='https://api.nzp1ve.com/video/listcache';\\n\\n}else{\\nvar sign = md5('timestamp='+t+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^');\\nvar data0={\\n        \\\"encode_sign\\\": sign,\\n        \\\"timestamp\\\": t\\n    };\\nvar data = mdEncrypt(JSON.stringify(data0)); \\nvar body = 'post-data='+data; \\nif(分类==2){\\nvar url = 'https://api.nzp1ve.com/video/channel';\\n}else if(分类==3){\\nvar url = 'https://api.nzp1ve.com/video/tags';\\n}\\n};\\nvar html = fetch(url, {\\n    headers: {\\n    'suffix':'173150',\\n    'Content-Type': 'application/x-www-form-urlencoded'\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\n\\nlet html1 = JSON.parse(html).data; \\nvar iv0= JSON.parse(html).suffix;\\nlet html2 = mdDecrypt(html1); \\nif(分类==1){\\nvar list = JSON.parse(html2).data.data;\\nlist.forEach((data) => {\\n        var tag=data.tags;\\n      var str1='';\\n     for(i in tag){\\n    var str1 = str1+tag[i].name+'   ';\\n}\\r\\n            d.push({\\r\\n                title: data.title,\\n               desc:str1, pic_url:data.panorama.replace('_sync.webp','.jpg'),\\r\\n                col_type: \\\"pic_1\\\",\\n                url :  data.video_url,\\n})\\n})\\n}else if(分类==2){\\nvar list = JSON.parse(html2).data;\\nlist.forEach((data) => {\\r\\n            d.push({\\r\\n                title: data.name,\\n                desc:data.total+'个片儿',\\n               pic_url:data.image,\\r\\n                col_type: \\\"icon_3\\\",\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/madoupindao\\\")',\\n                extra:{\\n              id:data.id,\\n          }\\n})\\n})\\n}else if(分类==3){\\nvar list = JSON.parse(html2).data;\\nlist.forEach((data) => {\\r\\n            d.push({\\r\\n                title: data.name,\\n                //pic_url:data.thumb,\\r\\n                col_type: \\\"text_3\\\",\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/madoubiaoqian\\\")',\\n                extra:{\\n              id:data.id,\\n          }\\n})\\n})\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"麻豆频道\",\"path\":\"madoupindao\",\"rule\":\"js: \\nvar d = [];\\n\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\n//md5加密\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\nvar t = Math.floor(Date.now());\\nvar t0 = Math.floor(Date.now()/1000);\\nlet id=MY_PARAMS.id;\\nlet p=MY_URL.split('##')[1];\\nvar sign = md5('channel='+id+'&list_row=60&page='+p+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); //log(sign)\\n\\nlet data0={\\n        \\\"channel\\\": id,\\n        \\\"encode_sign\\\": sign,\\n        \\\"list_row\\\": \\\"60\\\",\\n        \\\"page\\\": p,\\n        \\\"timestamp\\\": t,\\n        \\\"type\\\": \\\"2\\\"\\n    }\\n//log(data0)\\nvar data = mdEncrypt(JSON.stringify(data0)); \\n//log(data)\\nvar body = 'post-data='+data; \\nvar url = 'https://api.nzp1ve.com/video/listcache';\\nvar html = fetch(url, {\\n    headers: {\\n    'suffix':'173150',\\n    'Content-Type': 'application/x-www-form-urlencoded'\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\n//log(html)\\n\\nlet html1 = JSON.parse(html).data; \\n//log(html1)\\nvar iv0= JSON.parse(html).suffix;\\n//log(iv0);\\nlet html2 = mdDecrypt(html1); \\n//log(html2)\\n\\nvar list = JSON.parse(html2).data.data;\\n//log(list);\\nlist.forEach((data) => {\\nvar tag=data.tags;\\n      var str1='';\\n     for(i in tag){\\n    var str1 = str1+tag[i].name+'   ';\\n}\\r\\n            d.push({\\r\\n                title: data.title,\\n               desc:str1, pic_url:data.panorama.replace('_sync.webp','.jpg').replace('_longPreview',''),\\r\\n                col_type: \\\"pic_1\\\",\\n                url :  data.video_url,\\n})\\n})\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"麻豆标签\",\"path\":\"madoubiaoqian\",\"rule\":\"js: \\nvar d = [];\\n\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\n//md5加密\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\nvar t = Math.floor(Date.now());\\nvar t0 = Math.floor(Date.now()/1000);\\nlet id=MY_PARAMS.id;\\nlet p=MY_URL.split('##')[1];\\nvar sign = md5('list_row=60&page='+p+'&tags='+id+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); //log(sign)\\n\\nlet data0={\\n        \\\"encode_sign\\\": sign,\\n        \\\"list_row\\\": \\\"60\\\",\\n        \\\"page\\\": p,\\n        \\\"tags\\\": id,\\n        \\\"timestamp\\\": t,\\n        \\\"type\\\": \\\"2\\\"\\n    }\\n//log(data0)\\nvar data = mdEncrypt(JSON.stringify(data0)); \\n//log(data)\\nvar body = 'post-data='+data; \\nvar url = 'https://api.nzp1ve.com/video/listcache';\\nvar html = fetch(url, {\\n    headers: {\\n    'suffix':'173150',\\n    'Content-Type': 'application/x-www-form-urlencoded'\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\n//log(html)\\n\\nlet html1 = JSON.parse(html).data; \\n//log(html1)\\nvar iv0= JSON.parse(html).suffix;\\n//log(iv0);\\nlet html2 = mdDecrypt(html1); \\n//log(html2)\\n\\nvar list = JSON.parse(html2).data.data;\\n//log(list);\\nlist.forEach((data) => {\\nvar tag=data.tags;\\n      var str1='';\\n     for(i in tag){\\n    var str1 = str1+tag[i].name+'   ';\\n}\\r\\n            d.push({\\r\\n                title: data.title,\\n               desc:str1, pic_url:data.panorama.replace('_sync.webp','.jpg').replace('_longPreview',''),\\r\\n                col_type: \\\"pic_1\\\",\\n                url :  data.video_url,\\n})\\n})\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"91TV\",\"path\":\"91tv\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\n//md5加密\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\nvar t = Math.floor(Date.now()); \\nlet pg= MY_URL.split('##')[1];\\nvar tv= [{title: '首页&频道&标签',id: '1&2&3',img:'https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/111.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/112.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/113.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/114.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/122.svg'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(tv,'tv',d);\\nd.push({\\n    col_type: 'line',\\n},{\\n    col_type: 'big_blank_block',\\n}\\n,{\\n    col_type: 'big_blank_block',\\n});\\n}\\nlet 分类=getMyVar('tv', '1');\\n\\nif(分类==1){\\nvar sign = md5('list_row=20&page='+pg+'&timestamp='+t+'&type=2'+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); \\nvar data0={\\n       \\\"encode_sign\\\":sign,\\n       \\\"list_row\\\":\\\"20\\\",\\n       \\\"page\\\":pg,\\n       \\\"timestamp\\\":t,\\n       \\\"type\\\":\\\"2\\\"};\\nvar data = mdEncrypt(JSON.stringify(data0)); \\nvar body = 'post-data='+data; \\nvar url='https://tvv.zjqfart.cn/video/listcache';\\n\\n}else{\\nvar sign = md5('timestamp='+t+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); \\nvar data0={\\n        \\\"encode_sign\\\": sign,\\n        \\\"timestamp\\\": t\\n    };\\nvar data = mdEncrypt(JSON.stringify(data0)); \\nvar body = 'post-data='+data; \\nif(分类==2){\\nvar url = 'https://tvv.zjqfart.cn/video/channel';\\n}else if(分类==3){\\nvar url = 'https://tvv.zjqfart.cn/video/tags';\\n}\\n};\\nvar html = fetch(url, {\\n    headers: {\\n    'suffix':'173150',\\n    'Content-Type': 'application/x-www-form-urlencoded'\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nlet html1 = JSON.parse(html).data; \\nvar iv0= JSON.parse(html).suffix;\\nlet html2 = mdDecrypt(html1); \\nif(分类==1){\\nvar html3=fetch(JSON.parse(html2).data.file_name);\\nvar list = JSON.parse(html3).data;\\nlist.forEach((data) => {\\n        var tag=data.tags;\\n      var str1='';\\n     for(i in tag){\\n    var str1 = str1+tag[i].name+'   ';\\n}\\r\\n            d.push({\\r\\n                title: data.title,\\n               desc:str1, \\n               img:data.thumb+mdlazy,\\r\\n                col_type: \\\"pic_1\\\",\\n                url :  data.video_url+tvvod,\\n})\\n})\\n}else if(分类==2){\\nvar list = JSON.parse(html2).data;\\nlist.forEach((data) => {\\r\\n            d.push({\\r\\n                title: data.name,\\n                desc:data.total+'个片儿',\\n               pic_url:data.image,\\r\\n                col_type: \\\"icon_3\\\",\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/91tvpindao\\\")',\\n                extra:{\\n              id:data.id,\\n          }\\n})\\n})\\n}else if(分类==3){\\nvar list = JSON.parse(html2).data;\\n//log(list)\\nlist.forEach((data) => {\\r\\n            d.push({\\r\\n                title: data.name,\\n                //img:data.thumb+mdlazy,\\r\\n                col_type: \\\"text_3\\\",\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\"hiker://page/91tvbiaoqian\\\")',\\n                extra:{\\n              id:data.id,\\n          }\\n})\\n})\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"91tv标签\",\"path\":\"91tvbiaoqian\",\"rule\":\"js: \\nvar d = [];\\n\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\n//md5加密\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\nvar t = Math.floor(Date.now());\\nvar t0 = Math.floor(Date.now()/1000);\\nlet id=MY_PARAMS.id;\\nlet p=MY_URL.split('##')[1];\\nvar sign = md5('list_row=60&page='+p+'&tags='+id+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); //log(sign)\\n\\nlet data0={\\n        \\\"encode_sign\\\": sign,\\n        \\\"list_row\\\": \\\"60\\\",\\n        \\\"page\\\": p,\\n        \\\"tags\\\": id,\\n        \\\"timestamp\\\": t,\\n        \\\"type\\\": \\\"2\\\"\\n    }\\nvar data = mdEncrypt(JSON.stringify(data0)); \\nvar body = 'post-data='+data; \\nvar url = 'https://tvv.zjqfart.cn/video/listcache';\\nvar html = fetch(url, {\\n    headers: {\\n    'suffix':'173150',\\n    'Content-Type': 'application/x-www-form-urlencoded'\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nlet html1 = JSON.parse(html).data; \\nvar iv0= JSON.parse(html).suffix;\\nlet html2 = mdDecrypt(html1); \\nvar html3=fetch(JSON.parse(html2).data.file_name);\\nvar list = JSON.parse(html3).data;\\nlist.forEach((data) => {\\nvar tag=data.tags;\\n      var str1='';\\n     for(i in tag){\\n    var str1 = str1+tag[i].name+'   ';\\n}\\r\\n            d.push({\\r\\n                title: data.title,\\n               desc:str1, \\n               img:data.thumb+mdlazy,\\r\\n                col_type: \\\"pic_1\\\",\\n                url :  data.video_url+tvvod,\\n})\\n})\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"91tv频道\",\"path\":\"91tvpindao\",\"rule\":\"js: \\nvar d = [];\\n\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\n//md5加密\\nfunction md5(str) {\\n    return CryptoJS.MD5(str).toString();\\n}\\nvar t = Math.floor(Date.now());\\nvar t0 = Math.floor(Date.now()/1000);\\nlet id=MY_PARAMS.id;\\nlet p=MY_URL.split('##')[1];\\nvar sign = md5('channel='+id+'&list_row=60&page='+p+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); \\nlet data0={\\n        \\\"channel\\\": id,\\n        \\\"encode_sign\\\": sign,\\n        \\\"list_row\\\": \\\"60\\\",\\n        \\\"page\\\": p,\\n        \\\"timestamp\\\": t,\\n        \\\"type\\\": \\\"2\\\"\\n    }\\nvar data = mdEncrypt(JSON.stringify(data0)); \\nvar body = 'post-data='+data; \\nvar url = 'https://tvv.zjqfart.cn/video/listcache';\\nvar html = fetch(url, {\\n    headers: {\\n    'suffix':'173150',\\n    'Content-Type': 'application/x-www-form-urlencoded'\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nlet html1 = JSON.parse(html).data; \\nvar iv0= JSON.parse(html).suffix;\\nlet html2 = mdDecrypt(html1); \\nvar html3=fetch(JSON.parse(html2).data.file_name);\\nvar list = JSON.parse(html3).data;\\nlist.forEach((data) => {\\nvar tag=data.tags;\\n      var str1='';\\n     for(i in tag){\\n    var str1 = str1+tag[i].name+'   ';\\n}\\r\\n            d.push({\\r\\n                title: data.title,\\n               desc:str1,\\n               img:data.thumb+mdlazy,\\r\\n                col_type: \\\"pic_1\\\",\\n                url :  data.video_url+tvvod,\\n})\\n})\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"猫咪\",\"path\":\"maomi\",\"rule\":\" js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar pg=MY_URL.split('##')[1];\\nvar 猫咪= [{title: '猫咪原创&AI制作&不雅视频&亚洲无 码&抖音妹集合&热剧成人版&韩国三级&人气女 优',id: '10&16&5&9&11&12&13&6'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(猫咪,'猫咪',d);\\n}\\nvar sign=Encrypt('{\\\"special_id\\\":'+getMyVar('猫咪','10')+',\\\"page\\\":'+pg+'}');\\ntry{\\nvar host='http://119.28.52.193:8089/api/special/video?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\nvar list=JSON.parse(html2).data.data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.video_name,\\n            desc:data.create_at,\\n            img: data.image,\\n            url:data.video_id+maomijx,\\n            col_type:'movie_2'\\n        })\\n })\\n }catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"猫咪原创\",\"path\":\"maomiyuanchuang\",\"rule\":\" js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar pg=MY_URL.split('##')[1];\\nvar 猫咪原创= [{title: '最新&热门',id: '3&1'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Cate\\\").Cate(猫咪原创,'猫咪原创',d);\\n}\\nvar sign=Encrypt('{\\\"user_id\\\":1790368,\\\"type\\\":'+getMyVar('猫咪原创','3')+',\\\"page\\\":'+pg+'}');\\ntry{\\nvar host='http://119.28.52.193:8089/api/original/index?params='+sign;\\nvar body='params='+sign;\\nvar html = fetch(host, {\\n    headers: {\\n    'Content-Type': 'application/x-www-form-urlencoded',\\n    },\\n    body: body,\\n    method: 'POST'\\n}); \\nvar html2=Decrypt(html)\\nvar list=JSON.parse(html2).data.data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc:data.create_at,\\n            img: data.video_img,\\n            url:data.m3u8,\\n            col_type:'movie_3',\\n            extra: { \\n            longClick: [\\n            {title: '下载', js: $.toString((url)=>{ return  'download://'+url},data.down)}\\n            ]\\n           }\\n      })\\n })\\n }catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"首页视频分类\",\"path\":\"syvideo\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\nvar wz=MY_PARAMS.wz;\\nvar pg=MY_URL.split('##')[1];\\nif(wz=='baomads'){\\n    var host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top').replace('baomads','baoma/baomads');\\n}\\nvar 首页视频分类=fetch(host+'?getsort')\\nvar data= JSON.parse(首页视频分类).categories;\\nvar index_n=data[0].id.toString()\\nif(MY_PAGE==1){\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('首页视频分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('首页视频分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id.toString(),wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\n\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('首页视频分类'+wz,index_n)+'&page='+pg)).videos;\\n//log(list)\\nlist.forEach(data => {\\n    if((wz=='lutube')|(wz=='pali')){\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image+lulazy,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else if(wz.includes('kuaimao')|(wz=='fed')|(wz=='savsp')|(wz=='mmsp')|(wz=='cmav')|(wz=='hsck2')|wz.includes('xiangjiao')){\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.createtime==null?'':data.createtime)+'  '+(data.date==null?'':data.date),\\n            img: data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else if(wz=='ins'){\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\n            img: data.image+inslazy,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n    }else{\\n        if(data.image){\\n        var img=data.image;\\n        d.push({\\n            title: data.title,\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date)+'  '+(data.duration==null?'':data.duration),\\n            img: (img.includes('upload')||img.includes('new.'))?(data.image+lazy):data.image,\\n            url: host+'?id='+data.id+vod,\\n            col_type:'movie_2'\\n        })\\n        }\\n        }\\n })\\n }catch(e){\\n     log(e.message)\\n     toast('看不了')\\n }\\nsetResult(d)\"},{\"col_type\":\"text_4\",\"name\":\"图片二级\",\"path\":\"tupianerji\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule)\\nlet host=MY_PARAMS.host;\\nlet url=host.split('?')[0];\\nvar wz=MY_PARAMS.wz;\\ntry{\\n let img= JSON.parse(fetch(host)).content.replace(/\\\\$/g,'').replace(/分割/g,'').split('@');\\n img.forEach(data => {\\n        d.push({\\n            img:data,\\n            url: 'pics://'+img.join('&&'),\\n            col_type:'pic_1_full'\\n        })\\n })\\n \\n}catch(e){\\n    log(e.message)\\n     toast('看不了')\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"图片分类\",\"path\":\"picerji\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\ntry{\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top').replace('comic','picture');\\nvar wz=MY_PARAMS.wz;\\nvar pg=MY_URL.split('##')[1];\\nif(MY_PAGE==1){\\nvar 图片分类=fetch(host+'?getsort')\\nvar data= JSON.parse(图片分类).categories;\\nvar index_n=data[0].id.toString()\\ndata.forEach(data => {\\n        d.push({\\n            title: getMyVar('图片分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\n            url:$('').lazyRule((title,id,wz) => {\\n               putMyVar('图片分类'+wz, id);\\n                refreshPage();\\n                return 'hiker://empty';\\n            },data.title,data.id.toString(),wz),\\n           col_type:'scroll_button'\\n    })\\n})\\n}\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('图片分类'+wz,index_n)+'&page='+pg)).videos;\\n//log(list)\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.date,\\n            img: wz=='tiktok18'?(data.image+lazy):data.image,\\n            //url: 'hiker://empty'+'@rule=js:$.require(\\\"hiker://page/tupianerji\\\")',\\n            url: wz=='tuzac'?data.image:(host+'?id='+data.id+pics),\\n            col_type:'movie_3',\\n            extra:{\\n              host:`${host}?id=${data.id}`,\\n              wz:wz,\\n          }\\n        })\\n })\\n }catch(e){\\n     log(e.message)\\n     toast('看不了')\\n }\\nsetResult(d)\"}],\"params\":\"{\\\"host\\\":\\\"https://api1.yilushunfeng.top/video1/caoliusp_xilie/zhongkoushe.php\\\",\\\"wz\\\":\\\"zhongkoushe\\\"}\",\"saved\":false,\"title\":\"茄子\",\"version\":0,\"url\":\"hiker://empty##fypage;get;UTF-8;{User-Agent@Mozilla/5.0 (Linux；； Android 15；； 2407FRK8EC Build/AP3A.240617.008；； wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/128.0.6613.127 Mobile Safari/537.36}\",\"col_type\":\"movie_2\",\"find_rule\":\"js:$.require(\\\"hiker://page/syvideo\\\")\",\"group\":\".APP\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"aes\\\",\\\"path\\\":\\\"aes\\\",\\\"rule\\\":\\\"//加载CryptoJS库\\\\neval(getCryptoJS())\\\\n//13位时间戳\\\\nvar t = Math.floor(Date.now() );\\\\n//简单匹配\\\\nlet sp = (it, s, e) => String(it.split(s)[1]).split(e)[0];\\\\n//颜色\\\\nfunction strong(d, c) {\\\\n    return '‘‘’’<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\\\n}\\\\n//生成时间戳\\\\nfunction getCurrentTimestamp() {\\\\n    return new Date().getTime();\\\\n}\\\\n//md5加密\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\n//sha256加密\\\\nfunction sha256(str) {\\\\n    return CryptoJS.SHA256(str).toString();\\\\n}\\\\n//颜色\\\\nfunction color(txt) {\\\\n    return  '<b><font color=' + '#FF6699' + '>' + txt + '</font></b>'\\\\n}\\\\n//茄子解密函数\\\\nfunction qzDecrypt(word) {\\\\n    const key = CryptoJS.enc.Utf8.parse(\\\\\\\"yinsu12345abcdef\\\\\\\");\\\\n    const iv = CryptoJS.enc.Utf8.parse(\\\\\\\"keji123456999999\\\\\\\");\\\\n    let encryptedHexStr = CryptoJS.enc.Base64.parse(word);\\\\n    let decrypt = CryptoJS.AES.decrypt({\\\\n        ciphertext: encryptedHexStr\\\\n    }, key, {\\\\n        iv: iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7\\\\n    });\\\\n    if (decrypt) {\\\\n        let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);\\\\n        return decryptedStr;\\\\n    } else {\\\\n        // 解密失败，返回null或错误信息\\\\n        return null;\\\\n    }\\\\n}\\\\n\\\\n\\\\n// 猫咪解密函数\\\\nfunction Decrypt(word) {\\\\n    const key = CryptoJS.enc.Utf8.parse(\\\\\\\"625222f9149e961d\\\\\\\");\\\\n    const iv = CryptoJS.enc.Utf8.parse(\\\\\\\"5efdtf6060e2o330\\\\\\\");\\\\n    let encryptedHexStr = CryptoJS.enc.Hex.parse(word);\\\\n    let decrypt = CryptoJS.AES.decrypt({\\\\n        ciphertext: encryptedHexStr\\\\n    }, key, {\\\\n        iv: iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7\\\\n    });\\\\n    if (decrypt) {\\\\n        let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);\\\\n        return decryptedStr;\\\\n    } else {\\\\n        // 解密失败，返回null或错误信息\\\\n        return null;\\\\n    }\\\\n}\\\\n\\\\n// 猫咪加密函数\\\\nfunction Encrypt(plaintext) {\\\\n    const key = CryptoJS.enc.Utf8.parse(\\\\\\\"625222f9149e961d\\\\\\\");\\\\n    const iv = CryptoJS.enc.Utf8.parse(\\\\\\\"5efdtf6060e2o330\\\\\\\");\\\\n    var encrypted = CryptoJS.AES.encrypt(plaintext, key, {\\\\n        iv: iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7\\\\n    });\\\\n    var ciphertext = encrypted.ciphertext.toString(CryptoJS.enc.Hex);\\\\n    return ciphertext.toUpperCase();\\\\n}\\\\n\\\\nvar lazy = $('').image(() => {\\\\nconst CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n\\\\tlet id = CryptoUtil.Data.parseUTF8(\\\\\\\"f5d965df75336270\\\\\\\");\\\\n\\\\tlet iv = CryptoUtil.Data.parseUTF8(\\\\\\\"97b60394abc2fbe1\\\\\\\");\\\\n\\\\tlet textData = CryptoUtil.Data.parseInputStream(input);\\\\n\\\\tlet encrypted = CryptoUtil.AES.decrypt(textData, id, {\\\\n  \\\\tmode: \\\\\\\"AES/CBC/PKCS7Padding\\\\\\\",\\\\n\\\\t\\\\tiv: iv\\\\n\\\\t});\\\\n\\\\treturn encrypted.toInputStream();\\\\n})\\\\n\\\\n//视频请求\\\\nvar vod = $('').lazyRule(() => {\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nvar url =JSON.parse(fetch(input)).video;\\\\nreturn url+`#isVideo=true#`\\\\n}catch(e){\\\\n    log(e.message)\\\\n    return 'toast://请求失败'\\\\n}\\\\n})\\\\n//图片请求\\\\nvar pics = $('').lazyRule(() => {\\\\nlet img= JSON.parse(fetch(input)).content.replace(/\\\\\\\\$/g,'').replace(/分割/g,'').split('@');\\\\nreturn 'pics://'+img.join('&&');\\\\n})\\\\n//猫咪漫画解析\\\\nvar maomimanhuajx=$('').lazyRule(() => { \\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nvar sign=Encrypt('{\\\\\\\"user_id\\\\\\\":1790368,\\\\\\\"list_id\\\\\\\":'+input+'}');\\\\nvar host='http://119.28.52.193:8089/api/comic/watch?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\nvar list=JSON.parse(html2).data;\\\\nlet picArr=[];\\\\nlet len= list.length-1;\\\\nfor (i = 0; i <= len; i++) {\\\\n       picArr[i] = list[i].image;\\\\n     }\\\\nreturn 'pics://'+picArr.join('&&');\\\\n})\\\\n\\\\n//猫咪FM解析\\\\nvar maomifmjx=$('').lazyRule(() => { \\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nvar sign=Encrypt('{\\\\\\\"id\\\\\\\":'+input+'}');\\\\nvar host='http://119.28.52.193:8089/api/book/detail?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\nvar url=JSON.parse(html2).data.data[0].content;\\\\nreturn url\\\\n})\\\\n\\\\n//猫咪解析\\\\nvar maomijx=$('').lazyRule(() => { \\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nvar sign=Encrypt('{\\\\\\\"id\\\\\\\":'+input+'}');\\\\nvar host='http://119.28.52.193:8089/api/video/detail?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\n//下载\\\\n//var down=JSON.parse(html2).data.videos[0].down;\\\\n//文件\\\\nvar url=JSON.parse(html2).data.videos[0].file;\\\\nreturn url\\\\n})\\\\n\\\\n//麻豆加密函数\\\\nfunction mdEncrypt(plaintext) {\\\\n    const key = CryptoJS.enc.Utf8.parse(\\\\\\\"Vq234zBeSdGgYXzVTEfnnjjdmaTkk7A4\\\\\\\");\\\\n    const iv = CryptoJS.enc.Utf8.parse(\\\\\\\"-p9B[~PnPs173150\\\\\\\");\\\\n    var encrypted = CryptoJS.AES.encrypt(plaintext, key, {\\\\n        iv: iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7 // 注意这里应该是CryptoJS.pad.NoPadding\\\\n    });\\\\n    var ciphertext = encrypted.ciphertext.toString(CryptoJS.enc.Base64);\\\\n    return ciphertext;\\\\n}\\\\n\\\\n// 麻豆解密函数\\\\nfunction mdDecrypt(word) {\\\\n    const key = CryptoJS.enc.Utf8.parse(\\\\\\\"Vq234zBeSdGgYXzVTEfnnjjdmaTkk7A4\\\\\\\");\\\\n    const iv = CryptoJS.enc.Utf8.parse(\\\\\\\"-p9B[~PnPs\\\\\\\"+iv0);\\\\n    let encryptedHexStr = CryptoJS.enc.Base64.parse(word);\\\\n    let decrypt = CryptoJS.AES.decrypt({\\\\n        ciphertext: encryptedHexStr\\\\n    }, key, {\\\\n        iv: iv,\\\\n        mode: CryptoJS.mode.CBC,\\\\n        padding: CryptoJS.pad.Pkcs7 // 注意这里应该是CryptoJS.pad.NoPadding\\\\n    });\\\\n    if (decrypt) {\\\\n        let decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);\\\\n        return decryptedStr;\\\\n    } else {\\\\n        // 解密失败，返回null或错误信息\\\\n        return null;\\\\n    }\\\\n}\\\\n\\\\n//麻豆图片解密\\\\nvar mdlazy = $('').image(() => {\\\\nconst CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n\\\\tlet key = CryptoUtil.Data.parseUTF8(\\\\\\\"pnhXgN0U\\\\\\\");\\\\n\\\\tlet iv = CryptoUtil.Data.parseUTF8(\\\\\\\"GY4gEvBD\\\\\\\");\\\\n\\\\tlet textData = CryptoUtil.Data.parseInputStream(input).base64Decode();\\\\n\\\\tlet encrypted = CryptoUtil.DES.decrypt(textData, key, {\\\\n  \\\\tmode: \\\\\\\"DES/CBC/PKCS7Padding\\\\\\\",\\\\n\\\\t\\\\tiv: iv\\\\n\\\\t});\\\\n\\\\tlet base64Text = encrypted.toString().split(\\\\\\\"base64,\\\\\\\")[1];\\\\n    let encrypted0 = CryptoUtil.Data.parseBase64(base64Text, _base64.NO_WRAP);\\\\n    return encrypted0.toInputStream();\\\\n})\\\\n\\\\n//91tv视频解析\\\\nvar tvvod = $('').lazyRule(() => {\\\\neval(getCryptoJS())\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\nvar t0 =Math.floor(Date.now() / 1000)+1;\\\\nvar wsSecret=md5('E9MpC7D5AqWvjmXL3hGkQ2XjZNohAQ'+input.replace(/http(s)?:\\\\\\\\/\\\\\\\\/.*?\\\\\\\\//g,'/')+t0);\\\\nvar url=input+'?wsSecret='+wsSecret+'&wsTime='+t0;\\\\nwriteFile('hiker://files/cache/video0.m3u8', request(url));\\\\nreturn getPath('hiker://files/cache/video0.m3u8')+'#'+url;\\\\n})\\\\n//lutube图片解密\\\\nvar lulazy = $('').image(() => {\\\\nconst CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n\\\\tlet key = CryptoUtil.Data.parseHex(\\\\\\\"b2f3842866f9583d1ece61c4e055c255\\\\\\\");\\\\n\\\\tlet iv = CryptoUtil.Data.parseHex(\\\\\\\"e01ede6331d37afcc7be05597d654d22\\\\\\\");\\\\n\\\\tlet textData = CryptoUtil.Data.parseInputStream(input);\\\\n\\\\tlet encrypted = CryptoUtil.AES.decrypt(textData, key, {\\\\n  \\\\tmode: \\\\\\\"AES/CBC/PKCS7Padding\\\\\\\",\\\\n\\\\t\\\\tiv: iv\\\\n\\\\t});\\\\n\\\\treturn encrypted.toInputStream();\\\\n})\\\\n//ins图片解密，base64\\\\nvar inslazy = $('').image(() => {\\\\n    const CryptoUtil = $.require(\\\\\\\"hiker://assets/crypto-java.js\\\\\\\");\\\\n    let textData = CryptoUtil.Data.parseInputStream(input);\\\\n    let base64Text = textData.toString().split(\\\\\\\"base64,\\\\\\\")[1];\\\\n    let encrypted0 = CryptoUtil.Data.parseBase64(base64Text, _base64.NO_WRAP);\\\\n    return encrypted0.toInputStream();\\\\n})\\\\n\\\\n\\\\n//海角图片解密\\\\nvar n = function(e) {\\\\n    for (o = \\\\\\\"\\\\\\\", i = 0, a = 0, void 0; i < e.length;) {\\\\n        var t, n, o, i, a;\\\\n        (t = e.charCodeAt(i)) < 128 ? (o += String.fromCharCode(t), i++) : 191 < t && t < 224 ? (a = e.charCodeAt(i + 1), o += String.fromCharCode((31 & t) << 6 | 63 & a), i += 2) : (a = e.charCodeAt(i + 1), n = e.charCodeAt(i + 2), o += String.fromCharCode((15 & t) << 12 | (63 & a) << 6 | 63 & n), i += 3);\\\\n    }\\\\n    return o;\\\\n};\\\\nvar decryptData = function(t) {\\\\n    var o, i, a, r, s, c, u = \\\\\\\"\\\\\\\",\\\\n        d = 0,\\\\n        tt = \\\\\\\"ABCD*EFGHIJKLMNOPQRSTUVWX#YZabcdefghijklmnopqrstuvwxyz1234567890\\\\\\\"\\\\n    for (t = t.replace(/[^A-Za-z0-9\\\\\\\\*\\\\\\\\#]/g, \\\\\\\"\\\\\\\"); d < t.length;) a = tt.indexOf(t.charAt(d++)), o = (15 & (r = tt.indexOf(t.charAt(d++)))) << 4 | (s = tt.indexOf(t.charAt(d++))) >> 2, i = (3 & s) << 6 | (c = tt.indexOf(t.charAt(d++))), u += String.fromCharCode(a << 2 | r >> 4), 64 != s && (u += String.fromCharCode(o)), 64 != c && (u += String.fromCharCode(i));\\\\n    return n(u);\\\\n};\\\\n\\\\n$.exports.imageDecrypt = function() {\\\\n    let javaImport = new JavaImporter();\\\\n    javaImport.importPackage(\\\\n        Packages.com.example.hikerview.utils\\\\n    );\\\\n    with(javaImport) {\\\\n        let bytes = FileUtil.toBytes(input);\\\\n        bytes = new java.lang.String(bytes, 'UTF-8')\\\\n        let res = decryptData(bytes + \\\\\\\"\\\\\\\");\\\\n        res = new java.lang.String(res)\\\\n        res = res.split(\\\\\\\"base64,\\\\\\\")[1];\\\\n        return FileUtil.toInputStream(_base64.decode(res, _base64.NO_WRAP));\\\\n    }\\\\n}\\\\n\\\\n\\\\nfunction pageAdd(page) {\\\\n    if (getMyVar(\\\\\\\"page\\\\\\\")) {\\\\n        putMyVar(\\\\\\\"page\\\\\\\", (parseInt(page) + 1) + '');\\\\n    }\\\\n    return;\\\\n} //翻页\\\\n\\\\nfunction pageMoveto(page, pages) {\\\\n    var longClick = [{\\\\n        title: \\\\\\\"首页\\\\\\\",\\\\n        js: $.toString(() => {\\\\n            putMyVar(\\\\\\\"page\\\\\\\", \\\\\\\"1\\\\\\\");\\\\n            refreshPage();\\\\n            return \\\\\\\"hiker://empty\\\\\\\";\\\\n        }),\\\\n    }, {\\\\n        title: \\\\\\\"上页\\\\\\\",\\\\n        js: $.toString((page) => {\\\\n            if (page > 1) {\\\\n                putMyVar(\\\\\\\"page\\\\\\\", (parseInt(page) - 1));\\\\n                refreshPage();\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n            }\\\\n        }, page),\\\\n    }, {\\\\n        title: \\\\\\\"当前第\\\\\\\" + page + \\\\\\\"页\\\\\\\",\\\\n        js: \\\\\\\"\\\\\\\",\\\\n    }, {\\\\n        title: \\\\\\\"跳转\\\\\\\",\\\\n        js: $.toString(() => {\\\\n            return $(\\\\\\\"\\\\\\\").input(() => {\\\\n                putMyVar(\\\\\\\"page\\\\\\\", input);\\\\n                refreshPage();\\\\n            });\\\\n        }),\\\\n    }];\\\\n    if (typeof(pages) != 'undefined') {\\\\n        var extra1 = {\\\\n            title: \\\\\\\"尾页\\\\\\\" + pages,\\\\n            js: $.toString((pages) => {\\\\n                putMyVar(\\\\\\\"page\\\\\\\", pages);\\\\n                refreshPage();\\\\n                return \\\\\\\"hiker://empty\\\\\\\";\\\\n            }, pages),\\\\n        };\\\\n        longClick.push(extra1)\\\\n    }\\\\n    return longClick\\\\n} //长按跳页\\\\n\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"分类\\\",\\\"path\\\":\\\"Cate\\\",\\\"rule\\\":\\\"function strong(d, c) {\\\\n    return '‘‘’’<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\\\n}\\\\n//列表,col默认为'scroll_button'\\\\nfunction Cate(list,n,d,col) {\\\\n    if(!col){\\\\n        col='scroll_button';\\\\n    }\\\\n    var index_n=list[0].id.split('&')[0];\\\\n    list.forEach(data=>{\\\\n        var title = data.title.split('&');\\\\n        var id=data.id.split('&');\\\\n        if(data.img!=null){\\\\n            var img=data.img.split('&');\\\\n        }else{\\\\n            var img=[];\\\\n        }\\\\n        title.forEach((title,index)=>{\\\\n            d.push({\\\\n                title:(getMyVar(n,index_n)==id[index]?strong(title, 'FF6699') : title),\\\\n                img:img[index],\\\\n                url:$(id[index]).lazyRule((n,title,id) => {\\\\n               putMyVar(n, input);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            }, n,title,id[index]),\\\\n            col_type:col,\\\\n            })\\\\n        })\\\\n        d.push({\\\\n        col_type: 'blank_block',\\\\n    });\\\\n    })\\\\n    return d;\\\\n}\\\\n$.exports.Cate = Cate;\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"00首页\\\",\\\"path\\\":\\\"home\\\",\\\"rule\\\":\\\"js:\\\\nif (MY_PAGE == 1) {\\\\n    d.push({   \\\\n        title: \\\\\\\"搜索 \\\\\\\",\\\\n        url: $.toString(() => {\\\\n        putMyVar('keyword',input)\\\\n        return \\\\\\\"hiker://page/search?page=fypage&kw=\\\\\\\" + input\\\\n    }),\\\\n           desc: \\\\\\\"请输入搜索关键词\\\\\\\",\\\\n           col_type: \\\\\\\"input\\\\\\\",\\\\n    })\\\\n};\\\\nvar pg= MY_URL.replace('hiker://empty##', '');\\\\nvar t = Math.floor(Date.now()); \\\\nvar c1= [{title: '首页&综合',id: '1&2&3&4&5',img:'https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/127.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/137.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/113.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/114.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/122.svg'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(c1,'c1',d,'icon_2_round');\\\\nd.push({\\\\n    col_type: 'line',\\\\n},{\\\\n    col_type: 'big_blank_block',\\\\n}\\\\n,{\\\\n    col_type: 'big_blank_block',\\\\n});\\\\n}\\\\nvar 分类=getMyVar('c1', '1');\\\\nif(分类==1){\\\\n$.require(\\\\\\\"video\\\\\\\")\\\\n}else if(分类==2){\\\\n$.require(\\\\\\\"zonghe\\\\\\\")\\\\n}\\\\n\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"搜索\\\",\\\"path\\\":\\\"search\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\nvar pg=MY_URL.split('=')[1].replace('&kw','');\\\\nif(MY_PAGE==1){\\\\nvar data=JSON.parse(getItem('search')).config;\\\\nvar url_n=data[0].api+data[0].platform;\\\\ndata.forEach(data => {\\\\n        var url=data.api+data.platform;\\\\n        if((data.title!='福利')&(!data.platform.includes('yuepao'))){\\\\n        d.push({\\\\n            title: getMyVar('搜索分类',url_n)==url?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,url,cate) => {\\\\n               putMyVar('搜索分类', url);\\\\n               putMyVar('搜索分类名',title);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,url,'搜索分类'),\\\\n           col_type:'scroll_button',\\\\n           extra:{\\\\n              key:'搜索分类: '+getMyVar('搜索分类',url_n),\\\\n              word:'搜索分类名: '+getMyVar('搜索分类名','视频'),\\\\n              keyword:getMyVar('keyword'),\\\\n          }\\\\n    })\\\\n    }\\\\n})\\\\nd.push({\\\\n        col_type: 'blank_block',\\\\n    });\\\\nvar list=JSON.parse(fetch(getMyVar('搜索分类','http://003.22s.lol/searchconfig/video.txt'))).searchapi;\\\\nvar url_n='https://api1.yilushunfeng.top/'+list[0].platform+'.php';\\\\nlist.forEach(data => {\\\\n        var url='https://api1.yilushunfeng.top/'+data.platform+'.php';\\\\n        d.push({\\\\n            title: getMyVar(getMyVar('搜索分类名','视频')+'搜索列表',url_n)==url?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,url,cate) => {\\\\n               putMyVar(getMyVar('搜索分类名','视频')+'搜索列表', url);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,url,getMyVar('搜索分类名','视频')+'搜索列表'),\\\\n           col_type:'scroll_button',\\\\n           extra:{\\\\n              key:getMyVar('搜索分类名','视频')+'搜索列表',\\\\n              url:url,\\\\n              wz:data.platform,\\\\n              keyword:getMyVar('keyword'),\\\\n          }\\\\n    })\\\\n})\\\\n}\\\\nvar search_url=getMyVar(getMyVar('搜索分类名','视频')+'搜索列表',url_n)+'?keyword='+getMyVar('keyword')+'&page='+pg;\\\\n//log(search_url)\\\\nvar host=search_url.split('?')[0];\\\\ntry{\\\\nif(getMyVar('搜索分类名','视频')=='视频'){\\\\nvar Arr=['lusir','51lieqi','tangtoutiao','50du','tiktok','xingba','anwangjiemi','qiyou','caoliushequ','91paofu','meiridasai','pornhub','douyinmax','51luoli','91porn_sfktv','shuiguopai','sifangktv','weimiquan','heiliaobdy','51chigua'];\\\\nvar Brr=['lutube'];\\\\nvar Crr=['ins'];\\\\nvar platform=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[2];\\\\n//log(platform)\\\\nvar item=JSON.parse(fetch(search_url)).videos;\\\\nitem.forEach(data => {\\\\n    if(Arr.includes(platform)){\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image+lazy,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2',\\\\n            extra:{\\\\n              id:data.id,\\\\n          }\\\\n        })\\\\n    }else if(Brr.includes(platform)){\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image+lulazy,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else if(Crr.includes(platform)){\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image+inslazy,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else{\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n        }\\\\n    })\\\\n}else if(getMyVar('搜索分类名','视频')=='全网破解'){\\\\n    var Arr=['ttt','loanword','loanword_2','91short','sepone','lusir','cape','degree','burma'];\\\\n  var platform=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[4];\\\\n  var item=JSON.parse(fetch(search_url)).videos;\\\\n // log(item)\\\\nitem.forEach(data => {\\\\n    if(Arr.includes(platform)){\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.image+lazy,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else{\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n        }\\\\n    })\\\\n}else if(getMyVar('搜索分类名','视频')=='短视频'){\\\\n    var Arr=['tiktok18new','91dspweb','douyinmax','91porn_sifangktv','fantasi'];\\\\n  var platform=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[2];\\\\n  var item=JSON.parse(fetch(search_url)).videos;\\\\n // log(item)\\\\nitem.forEach(data => {\\\\n    if(Arr.includes(platform)){\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.image+lazy,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else{\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n        }\\\\n    })\\\\n}else if(getMyVar('搜索分类').includes('actress')|(getMyVar('搜索分类名','视频')=='番号')|(getMyVar('搜索分类名','视频')=='三级')){\\\\n    var Arr=['shuiguopai'];\\\\n  var platform=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[2];\\\\n  var item=JSON.parse(fetch(search_url)).videos;\\\\n // log(item)\\\\nitem.forEach(data => {\\\\n    if(Arr.includes(platform)){\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.image+lazy,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else{\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n        }\\\\n    })\\\\n}else if(getMyVar('搜索分类名','视频')=='吃瓜'){\\\\n  var wz=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[3];\\\\n  var list=JSON.parse(fetch(search_url)).videos;\\\\n // log(item)\\\\nif(wz=='haijiao'){\\\\n    list.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img:  data.image + \\\\\\\"@js=\\\\\\\" + $.toString((rule) => {\\\\n                            const image = $.require(\\\\\\\"hiker://page/aes?rule=\\\\\\\" + rule);\\\\n                            return image.imageDecrypt();\\\\n                        }, MY_RULE.title),\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/blackerji1\\\\\\\")',\\\\n            col_type:'pic_1',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n}else{\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: ((wz=='51cg')|(wz=='hlbdy')|(wz=='tiktok18'))?(data.image+lazy):data.image,\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/blackerji1\\\\\\\")',\\\\n            col_type:'pic_1',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n }\\\\n}else if(getMyVar('搜索分类名','视频')=='小说'){\\\\n  var wz=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[3];\\\\n  var list=JSON.parse(fetch(search_url)).videos;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/xiaoshuoerji1\\\\\\\")',\\\\n            col_type:'text_1',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n}else if(getMyVar('搜索分类名','视频')=='漫画'){\\\\n  var wz=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[2];\\\\n  var list=JSON.parse(fetch(search_url)).videos;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: data.image,\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/manhuaerji1\\\\\\\")',\\\\n            col_type:'movie_3',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n}else if(getMyVar('搜索分类名','视频')=='图片'){\\\\n  var wz=host.match(/top\\\\\\\\/.*\\\\\\\\.php/)[0].split('.php')[0].split('/')[2];\\\\n  var list=JSON.parse(fetch(search_url)).videos;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: wz=='tiktok18'?(data.image+lazy):data.image,\\\\n            //url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/tupianerji\\\\\\\")',\\\\n            url: wz=='tuzac'?data.image:(host+'?id='+data.id+pics),\\\\n            col_type:'movie_3',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n}\\\\n}catch(e){\\\\n    log(e.message)\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"02综合\\\",\\\"path\\\":\\\"zonghe\\\",\\\"rule\\\":\\\"js:\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\n//log(getItem('data'))\\\\n\\\\n // var list=getItem('data').split('综合数据开始')[1].split('综合数据结束')[0].split('换行');\\\\n var list=getItem('data').split('综合数据开始')[1].split('AV百科')[0].replace(/分割线/g,'换行').split('换行');\\\\n  list.forEach(data=>{\\\\n      var qd=sp(data, \\\\\\\"qd(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var tp=sp(data, \\\\\\\"tp(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var mc=sp(data, \\\\\\\"mc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var wz=sp(data, \\\\\\\"gjc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var ym=sp(data, \\\\\\\"ym(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var lx=sp(data, \\\\\\\"lx(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\\\n      if(lx=='二级菜单'){\\\\n      d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##'+'@rule=js:$.require(\\\\\\\"hiker://page/videoerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }else if(lx=='黑料'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/blackerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }else if(lx=='国内直播'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##'+'@rule=js:$.require(\\\\\\\"hiker://page/zhiboerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }else if((lx=='国外直播')|(lx=='视频')){\\\\n          if(!mc.includes('全网搜')){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/syvideo\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }\\\\n      }else if(lx.includes('女')&lx.includes('优')&(wz!='missav')){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/nvyouerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n          })\\\\n      }else if(lx=='帖子'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/tieerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n          })\\\\n      }else if(lx=='直播'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/zhibojuheerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              wz:mc,\\\\n          }\\\\n      })\\\\n      }else if(lx=='漫画'){\\\\n          if(mc=='猫咪漫画'){\\\\n         d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/maomimanhua\\\\\\\")',\\\\n          col_type:'icon_4_card'\\\\n      })\\\\n          }else{\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/manhuaerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n     }\\\\n      }else if(lx=='小说'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/xiaoshuoerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }else if(lx=='图片'){\\\\n          if(mc=='猫咪美图'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/maomimeitu\\\\\\\")',\\\\n          col_type:'icon_4_card'\\\\n          })\\\\n          }else if(mc!='美图色图'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/picerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n          })\\\\n          }\\\\n      }else if(lx=='有声小说'){\\\\n          if(mc=='猫咪FM'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/maomiFM\\\\\\\")',\\\\n          col_type:'icon_4_card'\\\\n          })\\\\n          }\\\\n      }\\\\n  })\\\\n/*\\\\nvar ziyong=getItem('data').replace('-','').split('分割线')[1].split('换行');\\\\n  ziyong.forEach(data=>{\\\\n      var qd=sp(data, \\\\\\\"qd(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var tp=sp(data, \\\\\\\"tp(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var mc=sp(data, \\\\\\\"mc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var wz=sp(data, \\\\\\\"gjc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var ym=sp(data, \\\\\\\"ym(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var lx=sp(data, \\\\\\\"lx(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\\\n      if(mc.includes('鉴赏')){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/videoerji\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }\\\\n      })\\\\n      */\\\\n}catch(e){\\\\n    log(e.message)\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"视频分类\\\",\\\"path\\\":\\\"videoerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar 视频分类=fetch(host+'?getsort')\\\\nlet data= JSON.parse(视频分类);\\\\n//log(data)\\\\nvar keys=Object.keys(data).slice(2);\\\\n//log(keys)\\\\nvar key_n=keys[0];\\\\nkeys.forEach(key => {\\\\n    d.push({\\\\n            title: getMyVar('视频分类'+wz,key_n)==key?strong(key,'FF6699'):key,\\\\n            url:$(key).lazyRule((key,wz) => {\\\\n               putMyVar('视频分类'+wz, input);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            }, key,wz),\\\\n            col_type:'scroll_button',\\\\n    })\\\\n    })\\\\ndata[getMyVar('视频分类'+wz,key_n)].forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            url: 'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/voderji1\\\\\\\")',\\\\n           col_type:'text_3',\\\\n           extra:{\\\\n              host:`${host}?sort=${data.id}&page=`,\\\\n              wz:wz,\\\\n          }\\\\n    })\\\\n})\\\\n}catch(e){\\\\n    log(e.message)\\\\n    toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"视频二级\\\",\\\"path\\\":\\\"voderji1\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nvar pg=MY_URL.split('##')[1]\\\\nvar host=MY_PARAMS.host+pg;\\\\nvar url=host.split('?')[0];\\\\nvar wz=MY_PARAMS.wz;\\\\ntry{\\\\n    var list= JSON.parse(fetch(host)).videos;\\\\n  //  log(list)\\\\nif((wz=='xbk')|(wz=='md')){\\\\n    list.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image,\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n })\\\\n}else if(wz=='maomi'){\\\\n    list.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image,\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n    })\\\\n })\\\\n}else if(wz=='xcl'){\\\\n    list.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image,\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n    })\\\\n })\\\\n}else if(wz=='qisemao'){\\\\n    list.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:data.duration,\\\\n            img: data.image,\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n    })\\\\n })\\\\n}else if(wz=='91pf'){\\\\n    list.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:parseInt(data.duration/60)+':'+parseInt(data.duration%60),\\\\n            img: data.image+lazy,\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n    })\\\\n })\\\\n}else{\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: (data.date.includes('-')?data.date:data.created_date)+'\\\\\\\\t\\\\\\\\t\\\\\\\\t\\\\\\\\t'+(data.duration==null?'':data.duration),\\\\n            img: data.image+lazy,\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n })\\\\n }\\\\n \\\\n}catch(e){\\\\n    log(e.message)\\\\n     toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"黑料分类\\\",\\\"path\\\":\\\"blackerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar pg=MY_URL.split('##')[1];\\\\nif(MY_PAGE==1){\\\\nvar 黑料分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(黑料分类).categories;\\\\nvar index_n=data[0].id.toString();\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('黑料分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('黑料分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id.toString(),wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('黑料分类'+wz,index_n)+'&page='+pg)).videos;\\\\n//log(list)\\\\nif(wz=='haijiao'){\\\\n    list.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img:  data.image + \\\\\\\"@js=\\\\\\\" + $.toString((rule) => {\\\\n                            const image = $.require(\\\\\\\"hiker://page/aes?rule=\\\\\\\" + rule);\\\\n                            return image.imageDecrypt();\\\\n                        }, MY_RULE.title),\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/blackerji1\\\\\\\")',\\\\n            col_type:'pic_1',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n}else{\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: ((wz=='51cg')|(wz=='hlbdy'))?(data.image+lazy):data.image,\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/blackerji1\\\\\\\")',\\\\n            col_type:'pic_1',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n }\\\\n }catch(e){\\\\n     log(e.message)\\\\n }\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"黑料二级\\\",\\\"path\\\":\\\"blackerji1\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nvar url=MY_PARAMS.host;\\\\nvar wz=MY_PARAMS.wz;\\\\ntry{\\\\nvar data= JSON.parse(fetch(url));\\\\n//log(data)\\\\n        d.push({\\\\n            title:pdfh(data.titleCode,'h1&&Text')==''?pdfh(data.titleCode,'h2&&Text'):pdfh(data.titleCode,'h1&&Text'),\\\\n            col_type:'rich_text'\\\\n        })\\\\n        if(wz=='cgw'){\\\\n            var videos=data.video.replace(/\\\\\\\\$/g,'').split('@');\\\\n        var img=data.imgcode.match(/src\\\\\\\\=\\\\\\\\\\\\\\\".*?\\\\\\\\\\\\\\\".*?alt/)[0].split('\\\\\\\"')[1];\\\\n    videos.forEach((item, index) => {\\\\n        var n=index+1;\\\\n        if(item){\\\\n        d.push({\\\\n            title:'视频'+n,\\\\n            desc:'0',\\\\n            img:img,\\\\n            url:item.replace('分割',''),\\\\n            col_type: 'card_pic_1',\\\\n        });\\\\n        }\\\\n    })\\\\n        d.push({\\\\n            title: data.imgcode,\\\\n            col_type:'rich_text',\\\\n        })\\\\n        }else if(wz=='gtl'){\\\\n        var videos=data.video.replace(/\\\\\\\\$/g,'').split('@');\\\\n        var img=data.picCode.match(/src\\\\\\\\=\\\\\\\\\\\\\\\".*?\\\\\\\\\\\\\\\".*?alt/)[0].split('\\\\\\\"')[1];\\\\n    videos.forEach((item, index) => {\\\\n        var n=index+1;\\\\n        if(item){\\\\n        d.push({\\\\n            title:'视频'+n,\\\\n            desc:'0',\\\\n            img:img,\\\\n            url:item.replace('分割',''),\\\\n            col_type: 'card_pic_1',\\\\n        });\\\\n        }\\\\n    })\\\\n            d.push({\\\\n            title: data.picCode,\\\\n            col_type:'rich_text',\\\\n        })\\\\n        }else if(wz=='tiktok18'){\\\\n        var videos=data.video.replace(/\\\\\\\\$/g,'').split('@');\\\\n        var imgs=data.picCode.replace(/\\\\\\\\$/g,'').split('@分割');\\\\n    videos.forEach((item, index) => {\\\\n        var n=index+1;\\\\n        if(item){\\\\n        d.push({\\\\n            title:'视频'+n,\\\\n            desc:'0',\\\\n            img:imgs[0]+lazy,\\\\n            url:item.replace('分割',''),\\\\n            col_type: 'card_pic_1',\\\\n        });\\\\n        }\\\\n    })\\\\n        var texts=data.imgcode.replace(/\\\\\\\\<p\\\\\\\\>/,'&&&<p>').replace(/\\\\\\\\<\\\\\\\\/p\\\\\\\\>/,'&&&</p>').split('&&&');\\\\n      //  log(texts)\\\\n        texts.forEach((item, index) => {\\\\n    if (pdfh(item, 'p&&Text')) {\\\\n        d.push({\\\\n            title: pdfh(item, 'p&&Text'),\\\\n            col_type: 'rich_text',\\\\n        });\\\\n    }\\\\n    if (pdfh(item, 'h1&&Text')) {\\\\n        d.push({\\\\n            title: pdfh(item, 'p&&Text'),\\\\n            col_type: 'rich_text',\\\\n        });\\\\n    }\\\\n    if (pdfh(item, 'h2&&Text')) {\\\\n        d.push({\\\\n            title: pdfh(item, 'p&&Text'),\\\\n            col_type: 'rich_text',\\\\n        });\\\\n    }\\\\n    })\\\\n    var imgs=data.picCode.replace(/\\\\\\\\$/g,'').split('@分割');\\\\n    imgs.forEach((item, index) => {\\\\n        if(item){\\\\n        d.push({\\\\n            img:item+lazy,\\\\n            url:item+lazy,\\\\n            col_type: 'pic_1_full',\\\\n        });\\\\n        }\\\\n    })\\\\n        }else if(wz=='51cg'){\\\\n        var n=0\\\\n        var texts=data.imgcode.replace(/pstyle/g,'p style').replace(/\\\\\\\\<\\\\\\\\/p.*?\\\\\\\\>\\\\\\\\<p.*?\\\\\\\\>/g,'</p>&&<p>').split('&&');\\\\n       // log(texts)\\\\n       texts.forEach((item, index) => {\\\\n           if(pdfh(item,'.dplayer&&data-config')!=''){\\\\n        let url=JSON.parse(pdfh(item,'.dplayer&&data-config')).video;\\\\n        n++;\\\\n        d.push({\\\\n            title: '““视频””  ' + n,\\\\n            desc:'0',\\\\n            img: url.pic + lazy,\\\\n            url: url.url.replace(/\\\\\\\\/\\\\\\\\/.*play\\\\\\\\./,'//long.'),\\\\n            col_type: 'card_pic_1'\\\\n        });\\\\n       }\\\\n       })\\\\n       texts.forEach((item, index) => {\\\\n    if (pdfh(item, 'p&&Text')) {\\\\n        d.push({\\\\n            title: pdfh(item, 'p&&Text'),\\\\n            col_type: 'rich_text',\\\\n        });\\\\n    }\\\\n    var imgs = pdfa(item, 'p&&img').map(h => pdfh(h, 'img&&data-xkrkllgl'));\\\\n    imgs.forEach(item2 => {\\\\n        d.push({\\\\n            title: '',\\\\n            img: item2 + lazy,\\\\n            url: item2 + lazy,\\\\n            col_type: 'pic_1_full'\\\\n        });\\\\n    });\\\\n    if(pdfh(item,'.dplayer&&data-config')!=''){\\\\n        let url=JSON.parse(pdfh(item,'.dplayer&&data-config')).video;\\\\n        n++;\\\\n        d.push({\\\\n            title: '““视频””  ' + n,\\\\n            desc:'0',\\\\n            img: url.pic + lazy,\\\\n            url: url.url.replace(/\\\\\\\\/\\\\\\\\/.*play\\\\\\\\./,'//long.'),\\\\n            col_type: 'card_pic_1'\\\\n        });\\\\n    }\\\\n    })\\\\n        }else if(wz=='hlbdy'){\\\\n            var n=0\\\\n        var texts=data.picCode.replace(/\\\\\\\\<\\\\\\\\/p\\\\\\\\>\\\\\\\\n\\\\\\\\<p\\\\\\\\>/g,'</p>&&<p>').split('&&');\\\\n       // log(texts)\\\\n         texts.forEach((item, index) => {\\\\n           if(pdfh(item,'.dplayer&&config')!=''){\\\\n        let url=JSON.parse(pdfh(item,'.dplayer&&config')).video;\\\\n        n++;\\\\n        d.push({\\\\n            title: '““视频””  ' + n,\\\\n            desc:'0',\\\\n            img: url.pic + lazy,\\\\n            url: url.url.replace(/\\\\\\\\/\\\\\\\\/.*play\\\\\\\\./,'//long.'),\\\\n            col_type: 'card_pic_1'\\\\n        });\\\\n       }\\\\n       })\\\\n       var n=0;\\\\n       texts.forEach((item, index) => {\\\\n    if (pdfh(item, 'p&&Text')) {\\\\n        d.push({\\\\n            title: pdfh(item, 'p&&Text'),\\\\n            col_type: 'rich_text',\\\\n        });\\\\n    }\\\\n    var imgs = pdfa(item, 'p&&img').map(h => pdfh(h, 'img&&onload'));\\\\n    imgs.forEach(item2 => {\\\\n        d.push({\\\\n            title: '',\\\\n            img: item2.split(\\\\\\\"(this,'\\\\\\\")[1].split(\\\\\\\"')\\\\\\\")[0] + lazy,\\\\n            url: item2.split(\\\\\\\"(this,'\\\\\\\")[1].split(\\\\\\\"')\\\\\\\")[0] + lazy,\\\\n            col_type: 'pic_1_full'\\\\n        });\\\\n    });\\\\n    if(pdfh(item,'.dplayer&&config')!=''){\\\\n        let url=JSON.parse(pdfh(item,'.dplayer&&config')).video;\\\\n        n++;\\\\n        d.push({\\\\n            title: '““视频””  ' + n,\\\\n            desc:'0',\\\\n            img: url.pic + lazy,\\\\n            url: url.url.replace(/\\\\\\\\/\\\\\\\\/.*play\\\\\\\\./,'//long.'),\\\\n            col_type: 'card_pic_1'\\\\n        });\\\\n       }\\\\n    })\\\\n        }else if(wz=='haijiao'){\\\\n            try{\\\\n            var videos=data.video.replace(/\\\\\\\\$/g,'').split('@');\\\\n        var img=data.picCode.match(/xkrkllgl\\\\\\\\=\\\\\\\\\\\\\\\".*?\\\\\\\\\\\\\\\".*?alt/)[0].split('\\\\\\\"')[1];\\\\n    videos.forEach((item, index) => {\\\\n        var n=index+1;\\\\n        if(item){\\\\n        d.push({\\\\n            title:'视频'+n,\\\\n            desc:'0',\\\\n            img:img+ \\\\\\\"@js=\\\\\\\" + $.toString((rule) => {\\\\n                            const image = $.require(\\\\\\\"hiker://page/aes?rule=\\\\\\\" + rule);\\\\n                            return image.imageDecrypt();\\\\n                        }, MY_RULE.title),\\\\n            url:item.replace('分割','')+'#isVideo=true#',\\\\n            col_type: 'card_pic_1',\\\\n        });\\\\n        }\\\\n    })\\\\n        var texts=data.picCode.replace(/pstyle/g,'p style').replace(/\\\\\\\\<\\\\\\\\/p\\\\\\\\>/g,'</p>&&').split('&&');\\\\n        texts.forEach((item, index) => {\\\\n    if (pdfh(item, 'p&&Text')) {\\\\n        d.push({\\\\n            title: pdfh(item, 'p&&Text'),\\\\n            col_type: 'rich_text',\\\\n        });\\\\n    }\\\\n      var img=item.match(/xkrkllgl\\\\\\\\=\\\\\\\\\\\\\\\".*?\\\\\\\\\\\\\\\".*?alt/);\\\\n      if(img){\\\\n     // log(img)\\\\n      d.push({\\\\n          img:img[0].split('\\\\\\\"')[1]+ \\\\\\\"@js=\\\\\\\" + $.toString((rule) => {\\\\n                            const image = $.require(\\\\\\\"hiker://page/aes?rule=\\\\\\\" + rule);\\\\n                            return image.imageDecrypt();\\\\n                        }, MY_RULE.title),\\\\n          url:img[0].split('\\\\\\\"')[1]+ \\\\\\\"@js=\\\\\\\" + $.toString((rule) => {\\\\n                            const image = $.require(\\\\\\\"hiker://page/aes?rule=\\\\\\\" + rule);\\\\n                            return image.imageDecrypt();\\\\n                        }, MY_RULE.title),\\\\n          col_type:'pic_1_full'\\\\n      })\\\\n       }\\\\n    })\\\\n    }catch{}\\\\n        }else if(wz=='kanliao'){\\\\n            var texts=data.picCode.replace(/\\\\\\\\<br\\\\\\\\>/g,'&&').split('&&');\\\\n            var n=0;\\\\n           texts.forEach((item, index) => {\\\\n                if(pdfh(item,'.dplayer&&data-config')!=''){\\\\n        let url=JSON.parse(pdfh(item,'.dplayer&&data-config')).video;\\\\n        n++;\\\\n        d.push({\\\\n            title: '视频 ' + n,\\\\n           // desc:'0',\\\\n            img: url.pic,\\\\n            url: url.url.replace(/\\\\\\\\/\\\\\\\\/.*play\\\\\\\\./,'//long.'),\\\\n            col_type: 'text_1'\\\\n        });\\\\n       }\\\\n       })\\\\n       d.push({\\\\n            title: data.picCode,\\\\n            col_type:'rich_text',\\\\n        })\\\\n        }\\\\n        \\\\n        }catch{}\\\\n        \\\\n        \\\\n        /*\\\\n        try{\\\\n        var video=data.videocode.replace(/\\\\\\\\<\\\\\\\\/video\\\\\\\\>/g,'</video>&&').split('&&');\\\\n        video.forEach((item,index) => {\\\\n           if(pdfh(item, 'video&&src')){\\\\n            var n=index+1;\\\\n        d.push({\\\\n            title: '视频'+n,\\\\n            desc:'0',\\\\n            img: pdfh(item, 'video&&poster'),\\\\n            url: pdfh(item, 'video&&src'),\\\\n            col_type: 'card_pic_1'\\\\n        })\\\\n        }\\\\n        })\\\\n        }catch{}\\\\n        \\\\n        d.push({\\\\n            title:'视频',\\\\n            desc:'0',\\\\n            img:pdfh(data.videocode,'video&&poster'),\\\\n            url:pdfh(data.videocode,'video&&src'),\\\\n            col_type:'card_pic_1'\\\\n            \\\\n        })\\\\n        */\\\\n      \\\\n       \\\\n        \\\\n        /*\\\\n        if(wz=='cgw'){\\\\n        d.push({\\\\n            title: data.imgcode,\\\\n            col_type:'rich_text',\\\\n        })\\\\n        }\\\\n        */\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"国内直播分类\\\",\\\"path\\\":\\\"zhiboerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nif(MY_PAGE==1){\\\\nvar 直播分类=fetch(host+'?getpingtai')\\\\nvar data= JSON.parse(直播分类).pingtai;\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            img:data.image,\\\\n            url:'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/zhiboerji1\\\\\\\")',\\\\n           col_type:'card_pic_3',\\\\n           extra:{\\\\n              host:`${host}?pingtai=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n    })\\\\n})\\\\n}\\\\n}catch(e){\\\\n    log(e.message)\\\\n    toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"国内直播二级\\\",\\\"path\\\":\\\"zhiboerji1\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nlet host=MY_PARAMS.host;\\\\nlet url=host.split('?')[0];\\\\nvar wz=MY_PARAMS.wz;\\\\ntry{\\\\nlet list= JSON.parse(fetch(host)).zhubo;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.image,\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_3'\\\\n        })\\\\n })\\\\n}catch(e){\\\\n    log(e.message)\\\\n     toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"国外直播分类\\\",\\\"path\\\":\\\"guowaierji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_URL.split('##')[1].replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_URL.split('##')[2];\\\\nvar pg=MY_URL.split('##')[3];\\\\nvar 国外直播分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(国外直播分类).categories;\\\\nvar index_n=data[0].id.toString()\\\\nif(MY_PAGE==1){\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('国外直播分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('国外直播分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id.toString(),wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\n\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('国外直播分类'+wz,index_n)+'&page='+pg)).videos;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: ((data.image.includes('upload')|data.image.includes('new.'))&!data.image.includes('toolmm'))?(data.image+lazy):data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n })\\\\n }catch(e){\\\\n     log(e.message)\\\\n     toast('看不了')\\\\n }\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"女 优分类\\\",\\\"path\\\":\\\"nvyouerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar pg=MY_URL.split('##')[1];\\\\nvar item=request(host+'?actress=&page='+pg)\\\\nvar data= JSON.parse(item).actresses;\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:data.number,\\\\n            img:data.image,\\\\n            url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/nvyouerji1\\\\\\\")',\\\\n           col_type:'card_pic_3',\\\\n           extra:{\\\\n              host:`${host}?sort=${data.id}&page=`,\\\\n              wz:wz,\\\\n          }\\\\n    })\\\\n})\\\\n\\\\n}catch(e){\\\\n    log(e.message)\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"女 优二级\\\",\\\"path\\\":\\\"nvyouerji1\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nvar pg=MY_URL.split('##')[1];\\\\nvar host=MY_PARAMS.host+pg;\\\\nvar url=host.split('?')[0];\\\\nvar wz=MY_PARAMS.wz;\\\\ntry{\\\\nlet list= JSON.parse(fetch(host)).videos;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.image,\\\\n            desc:(data.createtime==null?'':data.createtime)+'  '+(data.date==null?'':data.date),\\\\n            url: url+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n })\\\\n}catch(e){\\\\n    log(e.message)\\\\n     toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"帖子分类\\\",\\\"path\\\":\\\"tieerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar pg=MY_URL.split('##')[1];\\\\nif(MY_PAGE==1){\\\\nvar 帖子分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(帖子分类).categories;\\\\nvar index_n=data[0].id.toString();\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('帖子分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('帖子分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id.toString(),wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('帖子分类'+wz,index_n)+'&page='+pg)).videos;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            //img: 'https://images.xoowbs.com/upload_01'+data.image.split('upload_01')[1],\\\\n            img:data.image+lazy,\\\\n            url: 'hiker://empty##'+'@rule=js:$.require(\\\\\\\"hiker://page/blackerji1\\\\\\\")',\\\\n            col_type:'pic_1',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n }catch(e){\\\\n    log(e.message)\\\\n     toast('看不了')\\\\n }\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"直播聚合分类\\\",\\\"path\\\":\\\"zhibojuheerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet wz=MY_PARAMS.wz;\\\\nif(wz=='直播聚合'){\\\\n    host='http://api.vipmisss.com:81/xcdsw/'\\\\n}else{\\\\n    host='http://api.maiyoux.com:81/mf/'\\\\n}\\\\nif(MY_PAGE==1){\\\\nvar 直播聚合=request(host+'json.txt')\\\\nvar data= JSON.parse(直播聚合).pingtai;\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:data.Number,\\\\n            img:data.xinimg,\\\\n            url:'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/zhibojuheerji1\\\\\\\")',\\\\n           col_type:'card_pic_3',\\\\n           extra:{\\\\n              host:`${host}${data.address}`,\\\\n              wz:wz,\\\\n          }\\\\n    })\\\\n})\\\\n}\\\\n}catch(e){\\\\n    log(e.message)\\\\n    toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"直播聚合二级\\\",\\\"path\\\":\\\"zhibojuheerji1\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nlet host=MY_PARAMS.host;\\\\ntry{\\\\nlet list= JSON.parse(fetch(host)).zhubo;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n    if(!data.title.includes('9999')){\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.img,\\\\n            url: data.address,\\\\n            col_type:'movie_2'\\\\n        })\\\\n        }\\\\n })\\\\n}catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"漫画分类\\\",\\\"path\\\":\\\"manhuaerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar pg=MY_URL.split('##')[1];\\\\nif(MY_PAGE==1){\\\\nvar 漫画分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(漫画分类).categories;\\\\nvar index_n=data[0].id.toString()\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('漫画分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('漫画分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id.toString(),wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('漫画分类'+wz,index_n)+'&page='+pg)).videos;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: data.image,\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/manhuaerji1\\\\\\\")',\\\\n            col_type:'movie_3',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n }catch(e){\\\\n     log(e.message)\\\\n     toast('看不了')\\\\n }\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"漫画目录\\\",\\\"path\\\":\\\"manhuaerji1\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nlet host=MY_PARAMS.host;\\\\nlet url=host.split('?')[0];\\\\nvar wz=MY_PARAMS.wz;\\\\ntry{\\\\nlet list= JSON.parse(fetch(host)).chapters;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            url: url+'?id='+data.id+pics,\\\\n            col_type:'text_2'\\\\n        })\\\\n })\\\\n      d.push({\\\\n          title:'第1章预览',\\\\n          col_type:'rich_text',\\\\n      })\\\\n let img= JSON.parse(fetch(host)).content.replace(/\\\\\\\\$/g,'').replace(/分割/g,'').split('@');\\\\n img.forEach(data => {\\\\n        d.push({\\\\n            img:data,\\\\n            url: 'pics://'+img.join('&&'),\\\\n            col_type:'pic_1_full'\\\\n        })\\\\n })\\\\n \\\\n}catch(e){\\\\n    log(e.message)\\\\n     toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"猫咪漫画\\\",\\\"path\\\":\\\"maomimanhua\\\",\\\"rule\\\":\\\" js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\nvar pg=MY_URL.split('##')[1];\\\\ntry{\\\\nvar 猫咪漫画= [{title: '推荐&最新&精华',id: 'recommend&update&popular'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(猫咪漫画,'猫咪漫画',d);\\\\n}\\\\nvar sign=Encrypt('{\\\\\\\"page\\\\\\\":'+pg+'}');\\\\nvar host='http://119.28.52.193:8089/api/comic/'+getMyVar('猫咪漫画','recommend')+'?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\n//log(html2)\\\\nvar list=JSON.parse(html2).data.data;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            img: data.thumb,\\\\n            url: 'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/maomimanhuaerji\\\\\\\")',\\\\n          //url:data.id+maomimanhuajx,\\\\n            col_type:'movie_3',\\\\n            extra:{\\\\n              id:data.id,\\\\n          }\\\\n        })\\\\n })\\\\n}catch(e){\\\\n    log(e.message)\\\\n     toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"小说分类\\\",\\\"path\\\":\\\"xiaoshuoerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar pg=MY_URL.split('##')[1];\\\\nif(MY_PAGE==1){\\\\nvar 小说分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(小说分类).categories;\\\\nvar index_n=data[0].id.toString();\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('小说分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('小说分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id.toString(),wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('小说分类'+wz,index_n)+'&page='+pg)).list;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/xiaoshuoerji1\\\\\\\")',\\\\n            col_type:'text_1',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n }catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"小说二级\\\",\\\"path\\\":\\\"xiaoshuoerji1\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nlet host=MY_PARAMS.host;\\\\nlet url=host.split('?')[0];\\\\nvar wz=MY_PARAMS.wz;\\\\ntry{\\\\n    if((wz=='jinjishuwu')|(wz=='lebo')|(wz=='huanxiang')|(wz=='jkun')){\\\\n        let novel= JSON.parse(fetch(host)).novel;\\\\n        d.push({\\\\n            title:novel,\\\\n            col_type:'rich_text'\\\\n        })\\\\n    }else{\\\\nlet id= JSON.parse(fetch(host)).id;\\\\n loadReadContentPage(id)\\\\n }\\\\n}catch{\\\\n    toast('谁特么看小说啊！')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"猫咪漫画二级\\\",\\\"path\\\":\\\"maomimanhuaerji\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nvar pg=MY_URL.split('##')[1];\\\\nvar id=MY_PARAMS.id;\\\\nvar sign=Encrypt('{\\\\\\\"id\\\\\\\":'+id+',\\\\\\\"page\\\\\\\":'+pg+',\\\\\\\"sort\\\\\\\":0}');\\\\nvar host='http://119.28.52.193:8089/api/comic/lists?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\nvar list=JSON.parse(html2).data.data;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.name,\\\\n            img: data.image,\\\\n            url: data.id+maomimanhuajx,\\\\n            col_type: \\\\\\\"movie_1_left_pic\\\\\\\",\\\\n    })\\\\n    })\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"猫咪美图\\\",\\\"path\\\":\\\"maomimeitu\\\",\\\"rule\\\":\\\" js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\nvar pg=MY_URL.split('##')[1];\\\\ntry{\\\\nvar 猫咪美图= [{title: '热门&闲聊讨论&蕾丝女同&美腿玉足&巨乳美胸&男同&原创自拍&动漫&认证&sm&课堂&我妻&高潮脸&网红大咖&制服诱惑&蜜汁美臀',id: '0&3&7&9&10&22&1&8&26&6&31&23&2&18&4&21'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(猫咪美图,'猫咪美图',d);\\\\n}\\\\nvar sign=Encrypt('{\\\\\\\"page\\\\\\\":'+pg+',\\\\\\\"cate\\\\\\\":'+getMyVar('猫咪美图','0')+',\\\\\\\"type\\\\\\\":1}');\\\\nvar host='http://119.28.52.193:8089/api/v2/post/home?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\nvar list=JSON.parse(html2).data;\\\\nlist.forEach(data => {\\\\n    if(data.images){\\\\n        \\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:data.time,\\\\n            img: data.images[0].image,\\\\n            url: $('').lazyRule(data => {\\\\n          let picArr=[];\\\\n          let img=data.images;\\\\n          let len= img.length-1;\\\\n           for (i = 0; i <= len; i++) {\\\\n                picArr[i] = img[i].image;\\\\n            }\\\\n            return \\\\\\\"pics://\\\\\\\" + picArr.join(\\\\\\\"&&\\\\\\\")\\\\n        },data),\\\\n            col_type:'movie_3'\\\\n        })\\\\n        }\\\\n })\\\\n }catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"猫咪FM\\\",\\\"path\\\":\\\"maomiFM\\\",\\\"rule\\\":\\\" js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\nvar pg=MY_URL.split('##')[1];\\\\nvar 猫咪FM= [{title: '都市激情&家庭乱 伦&另类小说&青春校园&情 色笑话&人 妻乱 伦&性 爱技巧&玄幻奇幻',id: '8&9&10&11&12&13&14&15'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(猫咪FM,'猫咪FM',d);\\\\n}\\\\nvar sign=Encrypt('{\\\\\\\"page\\\\\\\":'+pg+',\\\\\\\"cate_id\\\\\\\":'+getMyVar('猫咪FM','8')+',\\\\\\\"status\\\\\\\":0,\\\\\\\"type\\\\\\\":0,\\\\\\\"new\\\\\\\":0}');\\\\nvar host='http://119.28.52.193:8089/api/book/index?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\nvar list=JSON.parse(html2).data.data;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.name,\\\\n            img: data.thumb,\\\\n            url: data.id+maomifmjx,\\\\n            col_type:'movie_3'\\\\n        })\\\\n })\\\\n\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"01首页视频\\\",\\\"path\\\":\\\"video\\\",\\\"rule\\\":\\\"js:\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\n  var list=getItem('shouye').split('首页数据开始')[1].split('首页数据结束')[0].split('换行');\\\\n  list.forEach(data=>{\\\\n      var qd=sp(data, \\\\\\\"qd(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var tp=sp(data, \\\\\\\"tp(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var mc=sp(data, \\\\\\\"mc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var wz=sp(data, \\\\\\\"gjc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var ym=sp(data, \\\\\\\"ym(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var lx=sp(data, \\\\\\\"lx(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\\\n      if(qd=='麻豆TV'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/madou\\\\\\\")',\\\\n          col_type:'icon_4_card'\\\\n      })\\\\n      }else if(qd=='91TV'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/91tv\\\\\\\")',\\\\n          col_type:'icon_4_card'\\\\n      })\\\\n      }else if(qd=='猫咪'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/maomi\\\\\\\")',\\\\n          col_type:'icon_4_card'\\\\n      })\\\\n      }else if(qd=='猫咪原创'){\\\\n          d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/maomiyuanchuang\\\\\\\")',\\\\n          col_type:'icon_4_card'\\\\n      })\\\\n      }else{\\\\n      d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/syvideo\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }\\\\n  })\\\\n      \\\\n      var list1=getItem('shouye').split('分割线')[1].split('换行');\\\\n  list1.forEach(data=>{\\\\n      var qd=sp(data, \\\\\\\"qd(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var tp=sp(data, \\\\\\\"tp(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var mc=sp(data, \\\\\\\"mc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var wz=sp(data, \\\\\\\"gjc(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var ym=sp(data, \\\\\\\"ym(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var lx=sp(data, \\\\\\\"lx(\\\\\\\", \\\\\\\")\\\\\\\");\\\\n      var qb=qd+'  '+mc+'  '+wz+'  '+ym+'  '+lx;\\\\n      if(tp!=null){\\\\n          if((wz=='xiangjiao')|(wz=='91dsp')|(wz=='tiktok18')|(wz=='ogfap')|(wz=='tiktok18long')|(wz=='xiaohuli')){\\\\n     }else{\\\\n      d.push({\\\\n          title:mc,\\\\n          desc:qb,\\\\n          img:'http://api.xka1.top'+tp,\\\\n          url:'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/syvideo\\\\\\\")',\\\\n          col_type:'icon_4_card',\\\\n          extra:{\\\\n              host:`${ym}/${wz}.php`,\\\\n              wz:wz,\\\\n          }\\\\n      })\\\\n      }\\\\n      }\\\\n      })\\\\n}catch(e){\\\\n    log(e.message)\\\\n    if(getMyVar('a') == ''){\\\\n    var shouye=qzDecrypt(request('http://003.22s.lol/encrypt/api.php?path=qiezi/shouye'))\\\\n    var data=qzDecrypt(request('http://003.22s.lol/encrypt/api.php?path=qiezi/zonghe'))\\\\n    var search=fetch('http://003.22s.lol/searchconfig/vipapi/vipconfig.txt')\\\\n   // var kuozhan=qzDecrypt(request('http://004.22s.lol/encrypt/api.php?path=qiezi/heikeji'))\\\\n   // var yuming=qzDecrypt(request('http://01.xka3a.top/encrypt/api.php?path=yuming/yuming'))\\\\n  //  var gonggao=qzDecrypt(request('http://003.22s.lol/encrypt/api.php?path=qiezi/qz'))\\\\n    putMyVar('a','1')\\\\n    setItem('shouye',shouye)\\\\n    setItem('data',data)\\\\n    setItem('search',search)\\\\n    refreshPage()\\\\n    toast('数据已更新')\\\\n    /*\\\\n    \\\\n    域名替换匹配表达式https?://(api1?\\\\\\\\.)?(changfapiaopiao|yilushunfeng|phpjiekou|apijiekou)\\\\\\\\.top(/api)?《\\\\n线路集合https://api1.yilushunfeng.top|https://api.changfapiaopiao.top|http://api1.yilushunfeng.top|http://api.changfapiaopiao.top|http://api1.apijiekou.top/api|http://api.phpjiekou.top|http://004.22s.lol/api《\\\\n失效域名集合https://api.yilushunfeng.top|http://api.yilushunfeng.top|http://api11.phpjiekou.top《\\\\n最新接口域名https://api1.yilushunfeng.top《\\\\n*/\\\\n  }\\\\n}\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"猫咪AV\\\",\\\"path\\\":\\\"maomiav\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_URL.split('##')[1].replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_URL.split('##')[2];\\\\nvar pg=MY_URL.split('##')[3];\\\\nif(MY_PAGE==1){\\\\nvar 国外直播分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(国外直播分类).categories;\\\\nvar index_n=data[0].id\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('国外直播分类'+wz,index_n)==data.id?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('国外直播分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id,wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('国外直播分类'+wz,index_n)+'&page='+pg)).videos;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n })\\\\n }catch(e){\\\\n     log(e.message)\\\\n     toast('看不了')\\\\n }\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"麻豆TV\\\",\\\"path\\\":\\\"madou\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\n//md5加密\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\nvar t = Math.floor(Date.now()); \\\\nlet pg= MY_URL.split('##')[1];\\\\nvar md= [{title: '首页&频道&标签',id: '1&2&3',img:'https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/111.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/112.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/113.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/114.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/122.svg'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(md,'md',d);\\\\nd.push({\\\\n    col_type: 'line',\\\\n},{\\\\n    col_type: 'big_blank_block',\\\\n}\\\\n,{\\\\n    col_type: 'big_blank_block',\\\\n});\\\\n}\\\\nlet 分类=getMyVar('md', '1');\\\\n\\\\nif(分类==1){\\\\nvar sign = md5('list_row=20&page='+pg+'&timestamp='+t+'&type=2'+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^');\\\\nvar data0={\\\\n       \\\\\\\"encode_sign\\\\\\\":sign,\\\\n       \\\\\\\"list_row\\\\\\\":\\\\\\\"20\\\\\\\",\\\\n       \\\\\\\"page\\\\\\\":pg,\\\\n       \\\\\\\"timestamp\\\\\\\":t,\\\\n       \\\\\\\"type\\\\\\\":\\\\\\\"2\\\\\\\"};\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\nvar body = 'post-data='+data; \\\\nvar url='https://api.nzp1ve.com/video/listcache';\\\\n\\\\n}else{\\\\nvar sign = md5('timestamp='+t+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^');\\\\nvar data0={\\\\n        \\\\\\\"encode_sign\\\\\\\": sign,\\\\n        \\\\\\\"timestamp\\\\\\\": t\\\\n    };\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\nvar body = 'post-data='+data; \\\\nif(分类==2){\\\\nvar url = 'https://api.nzp1ve.com/video/channel';\\\\n}else if(分类==3){\\\\nvar url = 'https://api.nzp1ve.com/video/tags';\\\\n}\\\\n};\\\\nvar html = fetch(url, {\\\\n    headers: {\\\\n    'suffix':'173150',\\\\n    'Content-Type': 'application/x-www-form-urlencoded'\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\n\\\\nlet html1 = JSON.parse(html).data; \\\\nvar iv0= JSON.parse(html).suffix;\\\\nlet html2 = mdDecrypt(html1); \\\\nif(分类==1){\\\\nvar list = JSON.parse(html2).data.data;\\\\nlist.forEach((data) => {\\\\n        var tag=data.tags;\\\\n      var str1='';\\\\n     for(i in tag){\\\\n    var str1 = str1+tag[i].name+'   ';\\\\n}\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.title,\\\\n               desc:str1, pic_url:data.panorama.replace('_sync.webp','.jpg'),\\\\r\\\\n                col_type: \\\\\\\"pic_1\\\\\\\",\\\\n                url :  data.video_url,\\\\n})\\\\n})\\\\n}else if(分类==2){\\\\nvar list = JSON.parse(html2).data;\\\\nlist.forEach((data) => {\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.name,\\\\n                desc:data.total+'个片儿',\\\\n               pic_url:data.image,\\\\r\\\\n                col_type: \\\\\\\"icon_3\\\\\\\",\\\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/madoupindao\\\\\\\")',\\\\n                extra:{\\\\n              id:data.id,\\\\n          }\\\\n})\\\\n})\\\\n}else if(分类==3){\\\\nvar list = JSON.parse(html2).data;\\\\nlist.forEach((data) => {\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.name,\\\\n                //pic_url:data.thumb,\\\\r\\\\n                col_type: \\\\\\\"text_3\\\\\\\",\\\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/madoubiaoqian\\\\\\\")',\\\\n                extra:{\\\\n              id:data.id,\\\\n          }\\\\n})\\\\n})\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"麻豆频道\\\",\\\"path\\\":\\\"madoupindao\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\n\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\n//md5加密\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\nvar t = Math.floor(Date.now());\\\\nvar t0 = Math.floor(Date.now()/1000);\\\\nlet id=MY_PARAMS.id;\\\\nlet p=MY_URL.split('##')[1];\\\\nvar sign = md5('channel='+id+'&list_row=60&page='+p+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); //log(sign)\\\\n\\\\nlet data0={\\\\n        \\\\\\\"channel\\\\\\\": id,\\\\n        \\\\\\\"encode_sign\\\\\\\": sign,\\\\n        \\\\\\\"list_row\\\\\\\": \\\\\\\"60\\\\\\\",\\\\n        \\\\\\\"page\\\\\\\": p,\\\\n        \\\\\\\"timestamp\\\\\\\": t,\\\\n        \\\\\\\"type\\\\\\\": \\\\\\\"2\\\\\\\"\\\\n    }\\\\n//log(data0)\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\n//log(data)\\\\nvar body = 'post-data='+data; \\\\nvar url = 'https://api.nzp1ve.com/video/listcache';\\\\nvar html = fetch(url, {\\\\n    headers: {\\\\n    'suffix':'173150',\\\\n    'Content-Type': 'application/x-www-form-urlencoded'\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\n//log(html)\\\\n\\\\nlet html1 = JSON.parse(html).data; \\\\n//log(html1)\\\\nvar iv0= JSON.parse(html).suffix;\\\\n//log(iv0);\\\\nlet html2 = mdDecrypt(html1); \\\\n//log(html2)\\\\n\\\\nvar list = JSON.parse(html2).data.data;\\\\n//log(list);\\\\nlist.forEach((data) => {\\\\nvar tag=data.tags;\\\\n      var str1='';\\\\n     for(i in tag){\\\\n    var str1 = str1+tag[i].name+'   ';\\\\n}\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.title,\\\\n               desc:str1, pic_url:data.panorama.replace('_sync.webp','.jpg').replace('_longPreview',''),\\\\r\\\\n                col_type: \\\\\\\"pic_1\\\\\\\",\\\\n                url :  data.video_url,\\\\n})\\\\n})\\\\n}catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"麻豆标签\\\",\\\"path\\\":\\\"madoubiaoqian\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\n\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\n//md5加密\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\nvar t = Math.floor(Date.now());\\\\nvar t0 = Math.floor(Date.now()/1000);\\\\nlet id=MY_PARAMS.id;\\\\nlet p=MY_URL.split('##')[1];\\\\nvar sign = md5('list_row=60&page='+p+'&tags='+id+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); //log(sign)\\\\n\\\\nlet data0={\\\\n        \\\\\\\"encode_sign\\\\\\\": sign,\\\\n        \\\\\\\"list_row\\\\\\\": \\\\\\\"60\\\\\\\",\\\\n        \\\\\\\"page\\\\\\\": p,\\\\n        \\\\\\\"tags\\\\\\\": id,\\\\n        \\\\\\\"timestamp\\\\\\\": t,\\\\n        \\\\\\\"type\\\\\\\": \\\\\\\"2\\\\\\\"\\\\n    }\\\\n//log(data0)\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\n//log(data)\\\\nvar body = 'post-data='+data; \\\\nvar url = 'https://api.nzp1ve.com/video/listcache';\\\\nvar html = fetch(url, {\\\\n    headers: {\\\\n    'suffix':'173150',\\\\n    'Content-Type': 'application/x-www-form-urlencoded'\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\n//log(html)\\\\n\\\\nlet html1 = JSON.parse(html).data; \\\\n//log(html1)\\\\nvar iv0= JSON.parse(html).suffix;\\\\n//log(iv0);\\\\nlet html2 = mdDecrypt(html1); \\\\n//log(html2)\\\\n\\\\nvar list = JSON.parse(html2).data.data;\\\\n//log(list);\\\\nlist.forEach((data) => {\\\\nvar tag=data.tags;\\\\n      var str1='';\\\\n     for(i in tag){\\\\n    var str1 = str1+tag[i].name+'   ';\\\\n}\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.title,\\\\n               desc:str1, pic_url:data.panorama.replace('_sync.webp','.jpg').replace('_longPreview',''),\\\\r\\\\n                col_type: \\\\\\\"pic_1\\\\\\\",\\\\n                url :  data.video_url,\\\\n})\\\\n})\\\\n}catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"91TV\\\",\\\"path\\\":\\\"91tv\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\n//md5加密\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\nvar t = Math.floor(Date.now()); \\\\nlet pg= MY_URL.split('##')[1];\\\\nvar tv= [{title: '首页&频道&标签',id: '1&2&3',img:'https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/111.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/112.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/113.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/114.svg&https://ghproxy.net/https://raw.githubusercontent.com/ls125781003/tubiao/main/movie/122.svg'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(tv,'tv',d);\\\\nd.push({\\\\n    col_type: 'line',\\\\n},{\\\\n    col_type: 'big_blank_block',\\\\n}\\\\n,{\\\\n    col_type: 'big_blank_block',\\\\n});\\\\n}\\\\nlet 分类=getMyVar('tv', '1');\\\\n\\\\nif(分类==1){\\\\nvar sign = md5('list_row=20&page='+pg+'&timestamp='+t+'&type=2'+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); \\\\nvar data0={\\\\n       \\\\\\\"encode_sign\\\\\\\":sign,\\\\n       \\\\\\\"list_row\\\\\\\":\\\\\\\"20\\\\\\\",\\\\n       \\\\\\\"page\\\\\\\":pg,\\\\n       \\\\\\\"timestamp\\\\\\\":t,\\\\n       \\\\\\\"type\\\\\\\":\\\\\\\"2\\\\\\\"};\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\nvar body = 'post-data='+data; \\\\nvar url='https://tvv.zjqfart.cn/video/listcache';\\\\n\\\\n}else{\\\\nvar sign = md5('timestamp='+t+'&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); \\\\nvar data0={\\\\n        \\\\\\\"encode_sign\\\\\\\": sign,\\\\n        \\\\\\\"timestamp\\\\\\\": t\\\\n    };\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\nvar body = 'post-data='+data; \\\\nif(分类==2){\\\\nvar url = 'https://tvv.zjqfart.cn/video/channel';\\\\n}else if(分类==3){\\\\nvar url = 'https://tvv.zjqfart.cn/video/tags';\\\\n}\\\\n};\\\\nvar html = fetch(url, {\\\\n    headers: {\\\\n    'suffix':'173150',\\\\n    'Content-Type': 'application/x-www-form-urlencoded'\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nlet html1 = JSON.parse(html).data; \\\\nvar iv0= JSON.parse(html).suffix;\\\\nlet html2 = mdDecrypt(html1); \\\\nif(分类==1){\\\\nvar html3=fetch(JSON.parse(html2).data.file_name);\\\\nvar list = JSON.parse(html3).data;\\\\nlist.forEach((data) => {\\\\n        var tag=data.tags;\\\\n      var str1='';\\\\n     for(i in tag){\\\\n    var str1 = str1+tag[i].name+'   ';\\\\n}\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.title,\\\\n               desc:str1, \\\\n               img:data.thumb+mdlazy,\\\\r\\\\n                col_type: \\\\\\\"pic_1\\\\\\\",\\\\n                url :  data.video_url+tvvod,\\\\n})\\\\n})\\\\n}else if(分类==2){\\\\nvar list = JSON.parse(html2).data;\\\\nlist.forEach((data) => {\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.name,\\\\n                desc:data.total+'个片儿',\\\\n               pic_url:data.image,\\\\r\\\\n                col_type: \\\\\\\"icon_3\\\\\\\",\\\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/91tvpindao\\\\\\\")',\\\\n                extra:{\\\\n              id:data.id,\\\\n          }\\\\n})\\\\n})\\\\n}else if(分类==3){\\\\nvar list = JSON.parse(html2).data;\\\\n//log(list)\\\\nlist.forEach((data) => {\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.name,\\\\n                //img:data.thumb+mdlazy,\\\\r\\\\n                col_type: \\\\\\\"text_3\\\\\\\",\\\\n                url :  'hiker://empty##fypage'+'@rule=js:$.require(\\\\\\\"hiker://page/91tvbiaoqian\\\\\\\")',\\\\n                extra:{\\\\n              id:data.id,\\\\n          }\\\\n})\\\\n})\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"91tv标签\\\",\\\"path\\\":\\\"91tvbiaoqian\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\n\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\n//md5加密\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\nvar t = Math.floor(Date.now());\\\\nvar t0 = Math.floor(Date.now()/1000);\\\\nlet id=MY_PARAMS.id;\\\\nlet p=MY_URL.split('##')[1];\\\\nvar sign = md5('list_row=60&page='+p+'&tags='+id+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); //log(sign)\\\\n\\\\nlet data0={\\\\n        \\\\\\\"encode_sign\\\\\\\": sign,\\\\n        \\\\\\\"list_row\\\\\\\": \\\\\\\"60\\\\\\\",\\\\n        \\\\\\\"page\\\\\\\": p,\\\\n        \\\\\\\"tags\\\\\\\": id,\\\\n        \\\\\\\"timestamp\\\\\\\": t,\\\\n        \\\\\\\"type\\\\\\\": \\\\\\\"2\\\\\\\"\\\\n    }\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\nvar body = 'post-data='+data; \\\\nvar url = 'https://tvv.zjqfart.cn/video/listcache';\\\\nvar html = fetch(url, {\\\\n    headers: {\\\\n    'suffix':'173150',\\\\n    'Content-Type': 'application/x-www-form-urlencoded'\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nlet html1 = JSON.parse(html).data; \\\\nvar iv0= JSON.parse(html).suffix;\\\\nlet html2 = mdDecrypt(html1); \\\\nvar html3=fetch(JSON.parse(html2).data.file_name);\\\\nvar list = JSON.parse(html3).data;\\\\nlist.forEach((data) => {\\\\nvar tag=data.tags;\\\\n      var str1='';\\\\n     for(i in tag){\\\\n    var str1 = str1+tag[i].name+'   ';\\\\n}\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.title,\\\\n               desc:str1, \\\\n               img:data.thumb+mdlazy,\\\\r\\\\n                col_type: \\\\\\\"pic_1\\\\\\\",\\\\n                url :  data.video_url+tvvod,\\\\n})\\\\n})\\\\n}catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"91tv频道\\\",\\\"path\\\":\\\"91tvpindao\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\n\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\n//md5加密\\\\nfunction md5(str) {\\\\n    return CryptoJS.MD5(str).toString();\\\\n}\\\\nvar t = Math.floor(Date.now());\\\\nvar t0 = Math.floor(Date.now()/1000);\\\\nlet id=MY_PARAMS.id;\\\\nlet p=MY_URL.split('##')[1];\\\\nvar sign = md5('channel='+id+'&list_row=60&page='+p+'&timestamp='+t+'&type=2&m}q%ea6:LDcmS?aK)CeF287bPvd99@E,9Up^'); \\\\nlet data0={\\\\n        \\\\\\\"channel\\\\\\\": id,\\\\n        \\\\\\\"encode_sign\\\\\\\": sign,\\\\n        \\\\\\\"list_row\\\\\\\": \\\\\\\"60\\\\\\\",\\\\n        \\\\\\\"page\\\\\\\": p,\\\\n        \\\\\\\"timestamp\\\\\\\": t,\\\\n        \\\\\\\"type\\\\\\\": \\\\\\\"2\\\\\\\"\\\\n    }\\\\nvar data = mdEncrypt(JSON.stringify(data0)); \\\\nvar body = 'post-data='+data; \\\\nvar url = 'https://tvv.zjqfart.cn/video/listcache';\\\\nvar html = fetch(url, {\\\\n    headers: {\\\\n    'suffix':'173150',\\\\n    'Content-Type': 'application/x-www-form-urlencoded'\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nlet html1 = JSON.parse(html).data; \\\\nvar iv0= JSON.parse(html).suffix;\\\\nlet html2 = mdDecrypt(html1); \\\\nvar html3=fetch(JSON.parse(html2).data.file_name);\\\\nvar list = JSON.parse(html3).data;\\\\nlist.forEach((data) => {\\\\nvar tag=data.tags;\\\\n      var str1='';\\\\n     for(i in tag){\\\\n    var str1 = str1+tag[i].name+'   ';\\\\n}\\\\r\\\\n            d.push({\\\\r\\\\n                title: data.title,\\\\n               desc:str1,\\\\n               img:data.thumb+mdlazy,\\\\r\\\\n                col_type: \\\\\\\"pic_1\\\\\\\",\\\\n                url :  data.video_url+tvvod,\\\\n})\\\\n})\\\\n}catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"猫咪\\\",\\\"path\\\":\\\"maomi\\\",\\\"rule\\\":\\\" js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\nvar pg=MY_URL.split('##')[1];\\\\nvar 猫咪= [{title: '猫咪原创&AI制作&不雅视频&亚洲无 码&抖音妹集合&热剧成人版&韩国三级&人气女 优',id: '10&16&5&9&11&12&13&6'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(猫咪,'猫咪',d);\\\\n}\\\\nvar sign=Encrypt('{\\\\\\\"special_id\\\\\\\":'+getMyVar('猫咪','10')+',\\\\\\\"page\\\\\\\":'+pg+'}');\\\\ntry{\\\\nvar host='http://119.28.52.193:8089/api/special/video?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\nvar list=JSON.parse(html2).data.data;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.video_name,\\\\n            desc:data.create_at,\\\\n            img: data.image,\\\\n            url:data.video_id+maomijx,\\\\n            col_type:'movie_2'\\\\n        })\\\\n })\\\\n }catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"猫咪原创\\\",\\\"path\\\":\\\"maomiyuanchuang\\\",\\\"rule\\\":\\\" js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\nvar pg=MY_URL.split('##')[1];\\\\nvar 猫咪原创= [{title: '最新&热门',id: '3&1'}];\\\\nif (MY_PAGE == 1) {\\\\n    $.require(\\\\\\\"Cate\\\\\\\").Cate(猫咪原创,'猫咪原创',d);\\\\n}\\\\nvar sign=Encrypt('{\\\\\\\"user_id\\\\\\\":1790368,\\\\\\\"type\\\\\\\":'+getMyVar('猫咪原创','3')+',\\\\\\\"page\\\\\\\":'+pg+'}');\\\\ntry{\\\\nvar host='http://119.28.52.193:8089/api/original/index?params='+sign;\\\\nvar body='params='+sign;\\\\nvar html = fetch(host, {\\\\n    headers: {\\\\n    'Content-Type': 'application/x-www-form-urlencoded',\\\\n    },\\\\n    body: body,\\\\n    method: 'POST'\\\\n}); \\\\nvar html2=Decrypt(html)\\\\nvar list=JSON.parse(html2).data.data;\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:data.create_at,\\\\n            img: data.video_img,\\\\n            url:data.m3u8,\\\\n            col_type:'movie_3',\\\\n            extra: { \\\\n            longClick: [\\\\n            {title: '下载', js: $.toString((url)=>{ return  'download://'+url},data.down)}\\\\n            ]\\\\n           }\\\\n      })\\\\n })\\\\n }catch{}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"首页视频分类\\\",\\\"path\\\":\\\"syvideo\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar pg=MY_URL.split('##')[1];\\\\nif(wz=='baomads'){\\\\n    var host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top').replace('baomads','baoma/baomads');\\\\n}\\\\nvar 首页视频分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(首页视频分类).categories;\\\\nvar index_n=data[0].id.toString()\\\\nif(MY_PAGE==1){\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('首页视频分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('首页视频分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id.toString(),wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\n\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('首页视频分类'+wz,index_n)+'&page='+pg)).videos;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n    if((wz=='lutube')|(wz=='pali')){\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image+lulazy,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else if(wz.includes('kuaimao')|(wz=='fed')|(wz=='savsp')|(wz=='mmsp')|(wz=='cmav')|(wz=='hsck2')|wz.includes('xiangjiao')){\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.createtime==null?'':data.createtime)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else if(wz=='ins'){\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date),\\\\n            img: data.image+inslazy,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n    }else{\\\\n        if(data.image){\\\\n        var img=data.image;\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc:(data.created_date==null?'':data.created_date)+'  '+(data.date==null?'':data.date)+'  '+(data.duration==null?'':data.duration),\\\\n            img: (img.includes('upload')||img.includes('new.'))?(data.image+lazy):data.image,\\\\n            url: host+'?id='+data.id+vod,\\\\n            col_type:'movie_2'\\\\n        })\\\\n        }\\\\n        }\\\\n })\\\\n }catch(e){\\\\n     log(e.message)\\\\n     toast('看不了')\\\\n }\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"text_4\\\",\\\"name\\\":\\\"图片二级\\\",\\\"path\\\":\\\"tupianerji\\\",\\\"rule\\\":\\\"js:\\\\nvar d=[];\\\\neval(JSON.parse(request('hiker://page/aes')).rule)\\\\nlet host=MY_PARAMS.host;\\\\nlet url=host.split('?')[0];\\\\nvar wz=MY_PARAMS.wz;\\\\ntry{\\\\n let img= JSON.parse(fetch(host)).content.replace(/\\\\\\\\$/g,'').replace(/分割/g,'').split('@');\\\\n img.forEach(data => {\\\\n        d.push({\\\\n            img:data,\\\\n            url: 'pics://'+img.join('&&'),\\\\n            col_type:'pic_1_full'\\\\n        })\\\\n })\\\\n \\\\n}catch(e){\\\\n    log(e.message)\\\\n     toast('看不了')\\\\n}\\\\nsetResult(d)\\\"},{\\\"col_type\\\":\\\"movie_2\\\",\\\"name\\\":\\\"图片分类\\\",\\\"path\\\":\\\"picerji\\\",\\\"rule\\\":\\\"js: \\\\nvar d = [];\\\\neval(JSON.parse(request('hiker://page/aes')).rule);\\\\ntry{\\\\nlet host=MY_PARAMS.host.replace('http://api.phpjiekou.top','https://api1.yilushunfeng.top').replace('comic','picture');\\\\nvar wz=MY_PARAMS.wz;\\\\nvar pg=MY_URL.split('##')[1];\\\\nif(MY_PAGE==1){\\\\nvar 图片分类=fetch(host+'?getsort')\\\\nvar data= JSON.parse(图片分类).categories;\\\\nvar index_n=data[0].id.toString()\\\\ndata.forEach(data => {\\\\n        d.push({\\\\n            title: getMyVar('图片分类'+wz,index_n)==data.id.toString()?strong(data.title,'FF6699'):data.title,\\\\n            url:$('').lazyRule((title,id,wz) => {\\\\n               putMyVar('图片分类'+wz, id);\\\\n                refreshPage();\\\\n                return 'hiker://empty';\\\\n            },data.title,data.id.toString(),wz),\\\\n           col_type:'scroll_button'\\\\n    })\\\\n})\\\\n}\\\\nvar list=JSON.parse(fetch(host+'?sort='+getMyVar('图片分类'+wz,index_n)+'&page='+pg)).videos;\\\\n//log(list)\\\\nlist.forEach(data => {\\\\n        d.push({\\\\n            title: data.title,\\\\n            desc: data.date,\\\\n            img: wz=='tiktok18'?(data.image+lazy):data.image,\\\\n            //url: 'hiker://empty'+'@rule=js:$.require(\\\\\\\"hiker://page/tupianerji\\\\\\\")',\\\\n            url: wz=='tuzac'?data.image:(host+'?id='+data.id+pics),\\\\n            col_type:'movie_3',\\\\n            extra:{\\\\n              host:`${host}?id=${data.id}`,\\\\n              wz:wz,\\\\n          }\\\\n        })\\\\n })\\\\n }catch(e){\\\\n     log(e.message)\\\\n     toast('看不了')\\\\n }\\\\nsetResult(d)\\\"}]\"}","picUrl":"http://api.xka1.top/6img/zhongkoushe.png","title":"重口社"}
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!