API tools faq
paste
xiaomianao666

小程序：茄子

xiaomianao666
Apr 1st, 2025
397
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 118.57 KB | None | 0 0
raw download clone embed print report
  1. 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@茄子@{"last_chapter_rule":"","title":"茄子","author":"流苏","url":"hiker://empty","version":1,"col_type":"movie_2","class_name":"","type":"video","class_url":"","area_name":"","area_url":"","sort_name":"","year_name":"","sort_url":"","year_url":"","find_rule":"js: \nvar d = [];\neval(JSON.parse(request('hiker://page/home')).rule);\nsetResult(d)","search_url":"hiker://empty?page=fypage&kw=**","group":"18+","searchFind":"js:\nvar ky=MY_URL.split('=')[2];\nputMyVar('keyword',ky)\n$.require(\"search\")","detail_col_type":"movie_3","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"*","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)\"}]","icon":"https://img10.360buyimg.com/imgzone/jfs/t1/166535/4/43655/6746/67910900F8a4365a4/f892e9ede37ace38.png","proxy":""}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!