Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 海阔视界规则分享，当前分享的是：小程序￥home_rule_v2￥base64://@91短视频@{"last_chapter_rule":"","title":"91短视频","author":"流苏","url":"hiker://empty##fypage","version":5,"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:\n$.require(\"seach\")","detail_col_type":"movie_3","detail_find_rule":"","sdetail_col_type":"movie_1","sdetail_find_rule":"*","ua":"mobile","preRule":"if(getMyVar('host')==''){\n   var host='https://api3.dspapi3.com/api.php';\n   putMyVar('host',host);\n}","pages":"[{\"col_type\":\"movie_3\",\"name\":\"aes\",\"path\":\"aes\",\"rule\":\"//加载CryptoJS库\\neval(getCryptoJS())\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\n//生成随机uuid\\nfunction generateUUID() {\\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\\n        var r = Math.random() * 16 | 0;\\n        var v = c === 'x' ? r : (r & 0x3 | 0x8);\\n        return v.toString(16);\\n    });\\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}\\nfunction color(txt) {\\n    return  '<b><font color=' + '#FF6699' + '>' + txt + '</font></b>'\\n}\\n\\n// 随机字符串方法\\nfunction generateRandomHex(length) {\\n    var result = '';\\n    var characters = '0123456789abcdef';\\n    for (var i = 0; i < length; i++) {\\n        result += characters.charAt(Math.floor(Math.random() * characters.length));\\n    }\\n    return result;\\n}\\n\\n// 调用方法生成随机字符串\\nvar iv0 = generateRandomHex(32).toUpperCase();\\n\\n// 解密函数\\nfunction Decrypt(word) {\\n    const key = CryptoJS.enc.Hex.parse(\\\"c2fc2c64ee8c48a4324034bedcd768792432257837dd7f95876a6ec20a1828e0\\\");\\n    const iv = CryptoJS.enc.Hex.parse(word.substr(0, 32));  // 获取前32位作为iv\\n  const encryptedHexStr = CryptoJS.enc.Hex.parse(word.substr(32).toUpperCase());\\n    let decrypt = CryptoJS.AES.decrypt({\\n        ciphertext: encryptedHexStr\\n    }, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CFB,\\n        padding: CryptoJS.pad.NoPadding // 注意这里应该是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// 加密函数\\nfunction Encrypt(plaintext) {\\n    const key = CryptoJS.enc.Hex.parse(\\\"c2fc2c64ee8c48a4324034bedcd768792432257837dd7f95876a6ec20a1828e0\\\");\\n    const iv = CryptoJS.enc.Hex.parse(iv0);\\n    var encrypted = CryptoJS.AES.encrypt(plaintext, key, {\\n        iv: iv,\\n        mode: CryptoJS.mode.CFB,\\n        padding: CryptoJS.pad.NoPadding // 注意这里应该是CryptoJS.pad.NoPadding\\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 key = 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, key, {\\n  \\tmode: \\\"AES/CBC/PKCS7Padding\\\",\\n\\t\\tiv: iv\\n\\t});\\n\\treturn encrypted.toInputStream();\\n})\\n\\n\\nfunction post(url,data0){\\nvar data = Encrypt(data0); \\n//log(data)\\nvar sign = md5(sha256('crypt=V2&data='+iv0+data+'&timestamp='+t+'dsaf76cfbb39cjdusihcuekd3b066a6e')); //log(sign)\\nvar body = 'timestamp='+t+'&data='+iv0+data+'&crypt=V2&sign='+sign; \\nvar html = fetch(url, {\\n    headers: {\\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)\\nlet html2 = Decrypt(html1); \\nreturn html2;\\n}\\n\\nvar vod = $('').lazyRule(() => {\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nlet data0='{\\\"app_type\\\":\\\"local\\\",\\\"mod\\\":\\\"anime\\\",\\\"code\\\":\\\"detail\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"id\\\":\\\"'+input+'\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\"}'\\nvar url1 = post(getMyVar('host'),data0);\\nlet url2=JSON.parse(url1).data.chapter[0].play_url.replace(/\\\\/\\\\/.*play\\\\./,'//long.');\\nreturn url2\\n})\"},{\"col_type\":\"movie_3\",\"name\":\"时间戳转换\",\"path\":\"时间戳转换\",\"rule\":\"function timestampToTime(tm, ts) {\\n\\t\\tundefined\\n\\t\\tvar date = new Date(tm * 1000); //时间戳为10位需*1000，时间戳为13位的话不需乘1000\\n\\t\\tvar Y = date.getFullYear() + '-';\\n\\t\\tvar M = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';\\n\\t\\tvar D = date.getDate();\\n\\t\\tvar h = ' | ' + date.getHours() + ':';\\n\\t\\tvar m = date.getMinutes();\\n\\t\\tif(m<10) m = '0'+m;\\n\\t\\tm = m + ':'\\n\\t\\tvar s = date.getSeconds();\\n\\t\\tif(s<10) s = '0'+s;\\n\\t\\tif (ts == 0) return Y + M + D;\\n\\t\\tif (ts == 1) return Y + M + D + h + m + s;\\n\\t}\"},{\"col_type\":\"movie_3\",\"name\":\"分类\",\"path\":\"Category\",\"rule\":\"function strong(d, c) {\\n    return '‘‘’’<strong><font color=#' + (c || '000000') + '>' + d + '</font></strong>';\\n}\\nfunction Category(list,n,col,d) {\\n     var title = list[0].title.split('&');\\n     var key = list[0].key.split('&');\\n      if(list[0].img!=null){\\n     var img=list[0].img.split('&');\\n    }else{\\n    var img=[];\\n    }\\nfor (var i in title) {\\n        d.push({\\n            title:   (getMyVar('color'+n, '0') == i) ? strong(title[i], 'FF6699') : title[i],\\n            img:img[i],\\n            url: $(key[i]).lazyRule((i,n,title,key) => {\\n               putMyVar(n, input);\\n               putMyVar('color'+n, i);\\n                refreshPage();\\n                return 'hiker://empty';\\n            }, i, n,title[i],key[i]),\\n            col_type: col\\n        });\\n    }\\n    d.push({\\n        col_type: 'blank_block',\\n    });\\n    return d;\\n}\\n$.exports.Category = Category;\"},{\"col_type\":\"movie_2\",\"name\":\"搜索\",\"path\":\"seach\",\"rule\":\"js: \\nvar d = [];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar c6= [{title: '短视频&长视频&帖子&动漫',key: '1&7&3&13'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(c6,'c6','scroll_button',d);\\n}\\nlet ky=MY_URL.split('=')[2];\\nlet pg=MY_URL.split('=')[1].replace('&kw','');\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nif(getMyVar('c6', '1')==3){\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"search\\\",\\\"type\\\":\\\"3\\\",\\\"key\\\":\\\"'+ky+'\\\",\\\"mod\\\":\\\"index\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet data= JSON.parse(html2).data;\\ndata.forEach(data => {\\n     if(!data.nickname.includes('91官方')){\\n     //视频和图片\\n      var medias=data.medias;\\n      d.push({\\r\\n                title: data.nickname,\\n                img: data.thumb+lazy,\\n                desc:data.created_at,\\r\\n                col_type: \\\"avatar\\\",\\n                url : 'hiker://empty##fypage##'+data.uuid+'@rule=js:$.require(\\\"hiker://page/detail3\\\")',\\n       },{\\n                title: data.title,\\n                desc:data.content,\\n                url:    'hiker://empty##'+data.id+'@rule=js:$.require(\\\"hiker://page/detail4\\\")',\\r\\n                col_type: 'text_1',\\n                extra: {lineVisible: false}\\n       });\\n       medias.forEach(data => {\\n       if(data.thumb!=null){\\n       d.push({\\n            title: '视频▶️',\\n            img:data.thumb+lazy,\\n            url: data.media_url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'movie_3',\\n        });\\n       }else{\\n       d.push({\\n                img: data.media_url+lazy,\\r\\n                col_type: \\\"pic_3_card\\\",\\n                url : data.media_url,\\n       })\\n       }\\n      })\\n      }\\n})\\n\\n}catch{}\\n}else if(getMyVar('c6', '1')==13){\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"mod\\\":\\\"index\\\",\\\"code\\\":\\\"search_v1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"type\\\":\\\"13\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"token\\\":\\\"\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"page\\\":\\\"'+pg+'\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"key\\\":\\\"'+ky+'\\\"}';\\nlet html2 = post(getMyVar('host'),data0);\\ntry{\\nlet list= JSON.parse(html2).data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: '🔥'+data.view_ct+'     '+ parseInt(data.duration/60)+':'+parseInt(data.duration%60)+'   '+data.tag,\\n            img: data.cover+lazy,\\n            url: data.id+vod,\\n        })\\n })\\n}catch{}\\n\\n}else{\\nif(getMyVar('c6', '1')==1){\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"search\\\",\\\"type\\\":\\\"1\\\",\\\"key\\\":\\\"'+ky+'\\\",\\\"mod\\\":\\\"index\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n}else{\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"search_v1\\\",\\\"type\\\":\\\"'+getMyVar('c6', '1')+'\\\",\\\"key\\\":\\\"'+ky+'\\\",\\\"mod\\\":\\\"index\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n}\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_2\\\",\\n        })\\n })\\n}catch{}\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"首页视频二级\",\"path\":\"erji\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar c3= [{title: '最新&最热',key: 'new&hot'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(c3,'c3','scroll_button',d);\\n}\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"getElementItembyId\\\",\\\"id\\\":\\\"'+id+'\\\",\\\"mod\\\":\\\"element\\\",\\\"page\\\":\\\"'+pg+'\\\",\\\"type\\\":\\\"'+getMyVar('c3', 'new')+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data.list;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.')\\n        })\\n })\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"首页视频\",\"path\":\"video\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar c2= [{title: '推荐&原创&短视频&热点&最新&乱 伦&黑料&自制&网黄&传媒&偷 拍&主题&动漫&日本&同城&欧美&主播&综艺&暗网',key: '1&2&66&6&4&13&7&10&11&3&15&16&22&9&5&21&27&23&25'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(c2,'c2','scroll_button',d);\\n}\\nif(getMyVar('c2', '1')==66){\\n$.require(\\\"mini\\\")\\n}else{\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"getConstructById\\\",\\\"id\\\":\\\"'+getMyVar('c2', '1')+'\\\",\\\"mod\\\":\\\"element\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0);\\nif(getMyVar('c2', '1')==4){\\ntry{\\nlet data= JSON.parse(html2).data;\\ndata.forEach(data => {\\nif((data.content_type!=11)&(data.content_type!=18)&(data.content_type!=21)&(data.content_type!=20)&(!data.title.includes('banner'))){\\nvar list=data.list;\\n//log(list);\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.')\\n        })\\n })\\n}\\n})\\n}catch{}\\n}else{\\ntry{\\nlet data= JSON.parse(html2).data;\\ndata.forEach(data => {\\nif((data.content_type!=11)&(data.content_type!=18)&(data.content_type!=21)&(data.content_type!=20)&(data.content_type!=8)&(!data.title.includes('banner'))){\\n       d.push({\\r\\n                title: color(data.title),\\r\\n                col_type: \\\"text_icon\\\",\\n                img:'hiker://images/icon_right5',\\n                url :  'hiker://empty##fypage##'+data.id+'@rule=js:$.require(\\\"hiker://page/erji\\\")',\\n})\\nvar list=data.list;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n        })\\n })\\n}\\n})\\n}catch{}\\n}\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"首页\",\"path\":\"home\",\"rule\":\"js:\\nif (MY_PAGE == 1) {\\n    d.push({   \\n        title: \\\"搜索\\\",\\n        url: $.toString(() => {\\n        return \\\"hiker://page/seach?page=fypage&kw=\\\" + input\\n    }),\\n           desc: \\\"请输入搜索关键词\\\",\\n           col_type: \\\"input\\\",\\n    })\\n};\\n\\nvar pg= MY_URL.replace('hiker://empty##', '');\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar c1= [{title: '发现&原创&社区&热点&动漫',key: '1&2&3&4&5',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(\\\"Category\\\").Category(c1,'c1','icon_5',d);\\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(\\\"org\\\")\\n}else if(分类==3){\\n$.require(\\\"news\\\")\\n}else if(分类==4){\\n$.require(\\\"hot\\\")\\n}else if(分类==5){\\n$.require(\\\"cartoon\\\")\\n}\"},{\"col_type\":\"movie_3\",\"name\":\"热点\",\"path\":\"hot\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar 热点= [{title: '热点&up',key: '1&2'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(热点,'热点','scroll_button',d);\\n}\\nif(getMyVar('热点','1')==1){\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"index\\\",\\\"mod\\\":\\\"hot\\\",\\\"uuid\\\":\\\"654711a5702067669a83a6cf2b1fdaf9\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet hot= JSON.parse(html2).data.hot;\\nlet list= JSON.parse(html2).data.find;\\n//log(list)\\nhot.forEach(data => {\\n       d.push({\\r\\n                title: data.name,\\n                img: data.img_url+lazy,\\r\\n                col_type: \\\"movie_3\\\",\\n                url :  'hiker://empty##fypage##'+data.type+'@rule=js:$.require(\\\"hiker://page/erji22\\\")',\\n})\\n})\\nlist.forEach(data => {\\n       d.push({\\r\\n                title: data.name,\\n                img: data.img_url+lazy,\\r\\n                col_type: \\\"movie_3\\\",\\n                url :  'hiker://empty##fypage##'+data.name+'@rule=js:$.require(\\\"hiker://page/erji2\\\")',\\n})\\n})\\n}catch{}\\n}else{\\n$.require(\\\"up\\\")\\n}\"},{\"col_type\":\"movie_2\",\"name\":\"详情\",\"path\":\"detail\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"detail\\\",\\\"id\\\":\\\"'+id+'\\\",\\\"mod\\\":\\\"collection\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data.list;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_3\\\",\\n        })\\n })\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"短视频\",\"path\":\"mini\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"home\\\",\\\"mod\\\":\\\"index\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data;\\nlist.forEach(data => {\\n     if(data['is_ads']==false){\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_3\\\",\\n        })\\n}\\n })\\n}catch{}\"},{\"col_type\":\"movie_3\",\"name\":\"原创\",\"path\":\"org\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"collectRecommed\\\",\\\"mod\\\":\\\"author\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet item= JSON.parse(html2).data.item;\\n//log(item)\\nitem.forEach(data => {\\n       var up=data.user;\\n       d.push({\\r\\n                title: up.nickname,\\n                img: up.thumb+lazy,\\r\\n                col_type: \\\"avatar\\\",\\n                url :  'hiker://empty##fypage##'+data.id+'@rule=js:$.require(\\\"hiker://page/detail\\\")',\\n})\\nvar list=data.video_lists;\\n//log(list);\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_3\\\",\\n        })\\n })\\n})\\n}catch{}\"},{\"col_type\":\"movie_2\",\"name\":\"热点二级\",\"path\":\"erji2\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar c4= [{title: '最新&最热',key: 'new&hot'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(c4,'c4','scroll_button',d);\\n}\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"listByTag\\\",\\\"tags\\\":\\\"'+id+'\\\",\\\"mod\\\":\\\"index\\\",\\\"page\\\":\\\"'+pg+'\\\",\\\"type\\\":\\\"'+getMyVar('c4', 'new')+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data.items;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_3\\\",\\n        })\\n })\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"up主\",\"path\":\"up\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar c5= [{title: '推荐&欢迎&最新',key: '0&1&2'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(c5,'c5','scroll_button',d);\\n}\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"getCcreatorList\\\",\\\"mod\\\":\\\"Author\\\",\\\"uuid\\\":\\\"654711a5702067669a83a6cf2b1fdaf9\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data.creator_nav[getMyVar('c5', '0')].list;\\nlist.forEach(data => {\\n       d.push({\\r\\n                title: data.nickname,\\n                img: data.thumb+lazy,\\r\\n                col_type: \\\"icon_round_4\\\",\\n                url :  'hiker://empty##fypage##'+data.uuid+'@rule=js:$.require(\\\"hiker://page/erji3\\\")',\\n       })\\n})\\n}catch{}\"},{\"col_type\":\"movie_2\",\"name\":\"up主二级\",\"path\":\"erji3\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"videos\\\",\\\"uuid\\\":\\\"'+id+'\\\",\\\"mod\\\":\\\"user\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_3\\\",\\n        })\\n })\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"热点二级2\",\"path\":\"erji22\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"mod\\\":\\\"index\\\",\\\"code\\\":\\\"hotLists\\\",\\\"type\\\":\\\"'+id+'\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_3\\\",\\n        })\\n })\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"社区\",\"path\":\"news\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar 社区= [{title: '最新&最热&视频&热门话题',key: 'new&hot&video&topic'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(社区,'社区','scroll_button',d);\\n}\\nif(getMyVar('社区','new')=='topic'){\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"category\\\",\\\"mod\\\":\\\"news\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0);\\ntry{\\nlet list= JSON.parse(html2).data.hot;\\nlist.forEach(data => {\\n       d.push({\\r\\n                title: data.name,\\n                img: data.img_url+lazy,\\r\\n                col_type: \\\"movie_3\\\",\\n                url :  'hiker://empty##fypage##'+data.id+'@rule=js:$.require(\\\"hiker://page/tags\\\")',\\n})\\n})\\n}catch{}\\n}else{\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"mod\\\":\\\"news\\\",\\\"code\\\":\\\"getNewsData_v1\\\",\\\"page\\\":'+pg+',\\\"tag\\\":\\\"'+getMyVar('社区','new')+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet data= JSON.parse(html2).data.list;\\n//log(item)\\ndata.forEach(data => {\\n     if(!data.nickname.includes('91官方')){\\n     //视频和图片\\n      var medias=data.medias;\\n     //标签\\n      var tags=data.tags;\\n      d.push({\\r\\n                title: data.nickname,\\n                img: data.thumb+lazy,\\n                desc:data.created_at,\\r\\n                col_type: \\\"avatar\\\",\\n                url : 'hiker://empty##fypage##'+data.uuid+'@rule=js:$.require(\\\"hiker://page/detail3\\\")',\\n       },{\\n                title: data.title,\\n                desc:data.content,\\n                url:    'hiker://empty##'+data.id+'@rule=js:$.require(\\\"hiker://page/detail4\\\")',\\r\\n                col_type: 'text_1',\\n                extra: {lineVisible: false}\\n       });\\n       medias.forEach(data => {\\n       if(data.thumb!=null){\\n       d.push({\\n            title: '视频▶️',\\n            img:data.thumb+lazy,\\n            url: data.media_url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'movie_3',\\n        });\\n       }else{\\n       d.push({\\n                img: data.media_url+lazy,\\r\\n                col_type: \\\"pic_3_card\\\",\\n                url : data.media_url,\\n       })\\n       }\\n      })\\n      tags.forEach(data => {\\n      d.push({\\n                title:data.tag,\\n                url: 'hiker://empty##fypage##'+data.category_id+'@rule=js:$.require(\\\"hiker://page/tags\\\")',\\n                col_type: 'flex_button'\\n      })\\n      })\\n      }\\n})\\n}catch{}\\n}\"},{\"col_type\":\"movie_2\",\"name\":\"社区二级\",\"path\":\"detail4\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[1];\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"detail_v1\\\",\\\"mod\\\":\\\"news\\\",\\\"news_id\\\":'+id+'}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet data= JSON.parse(html2).data.detail;\\n      var medias=data.medias;\\n      d.push({\\r\\n                title: data.nickname,\\n                img: data.thumb+lazy,\\n                desc:data.created_at,\\r\\n                col_type: \\\"avatar\\\",\\n                url : 'hiker://empty##fypage##'+data.uuid+'@rule=js:$.require(\\\"hiker://page/detail3\\\")',\\n       },{\\n                title: data.content,\\r\\n                col_type: 'long_text',\\n       });\\n       medias.forEach(data => {\\n       if(data.thumb!=null){\\n       d.push({\\n            title: '视频▶️',\\n            img:data.thumb+lazy,\\n            url: data.media_url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'pic_1',\\n        });\\n       }else{\\n       d.push({\\n                img: data.media_url+lazy,\\r\\n                col_type: \\\"pic_1_full\\\",\\n                url : data.media_url,\\n       })\\n       }\\n      })\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_2\",\"name\":\"社区up\",\"path\":\"detail3\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar 作品= [{title: '作品&喜欢&帖子',key: 'videos&likes&target'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(作品,'作品','scroll_button',d);\\n}\\nif(getMyVar('作品','videos')=='target'){\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"mod\\\":\\\"news\\\",\\\"code\\\":\\\"target_news\\\",\\\"page\\\":'+pg+',\\\"target_uuid\\\":\\\"'+id+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet data= JSON.parse(html2).data;\\ndata.forEach(data => {\\n     if(!data.nickname.includes('91官方')){\\n     //视频和图片\\n      var medias=data.medias;\\n     //标签\\n      var tags=data.tags;\\n      d.push({\\r\\n                title: data.nickname,\\n                img: data.thumb+lazy,\\n                desc:data.created_at,\\r\\n                col_type: \\\"avatar\\\",\\n                url : 'hiker://empty##fypage##'+data.uuid+'@rule=js:$.require(\\\"hiker://page/detail3\\\")',\\n       },{\\n                title: data.title,\\n                desc:data.content,\\n                url:    'hiker://empty##'+data.id+'@rule=js:$.require(\\\"hiker://page/detail4\\\")',\\r\\n                col_type: 'text_1',\\n                extra: {lineVisible: false}\\n       });\\n       medias.forEach(data => {\\n       if(data.thumb!=null){\\n       d.push({\\n            title: '视频▶️',\\n            img:data.thumb+lazy,\\n            url: data.media_url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'movie_3',\\n        });\\n       }else{\\n       d.push({\\n                img: data.media_url+lazy,\\r\\n                col_type: \\\"pic_3_card\\\",\\n                url : data.media_url,\\n       })\\n       }\\n      })\\n      tags.forEach(data => {\\n      d.push({\\n                title:data.tag,\\n                url: 'hiker://empty##fypage##'+data.category_id+'@rule=js:$.require(\\\"hiker://page/tags\\\")',\\n                col_type: 'flex_button'\\n      })\\n      })\\n      }\\n})\\n}catch{}\\n}else{\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"'+getMyVar('作品','videos')+'\\\",\\\"uuid\\\":\\\"'+id+'\\\",\\\"mod\\\":\\\"user\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: data.created_at+'\\\\t\\\\t\\\\t\\\\t'+data.durationStr+'  '+data.tags,\\n            img: data.thumbImg+lazy,\\n            url: data.playUrl.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: \\\"movie_2\\\",\\n        })\\n })\\n}catch{}\\n}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"社区标签\",\"path\":\"tags\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar 社区= [{title: '最新&最热&视频',key: 'new&hot&video'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(社区,'社区标签','scroll_button',d);\\n}\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"mod\\\":\\\"news\\\",\\\"code\\\":\\\"getNewsByCategory\\\",\\\"page\\\":'+pg+',\\\"category\\\":\\\"'+id+'\\\",\\\"tag\\\":\\\"'+getMyVar('社区标签','new')+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet data= JSON.parse(html2).data.list;\\n//log(item)\\ndata.forEach(data => {\\n      if(!data.nickname.includes('91官方')){\\n     //视频和图片\\n      var medias=data.medias;\\n     //标签\\n      var tags=data.tags;\\n      d.push({\\r\\n                title: data.nickname,\\n                img: data.thumb+lazy,\\n                desc:data.created_at,\\r\\n                col_type: \\\"avatar\\\",\\n                url : 'hiker://empty##fypage##'+data.uuid+'@rule=js:$.require(\\\"hiker://page/detail3\\\")',\\n       },{\\n                title: data.title,\\n                desc:data.content,\\n                url:    'hiker://empty##'+data.id+'@rule=js:$.require(\\\"hiker://page/detail4\\\")',\\r\\n                col_type: 'text_1',\\n                extra: {lineVisible: false}\\n       });\\n       medias.forEach(data => {\\n       if(data.thumb!=null){\\n       d.push({\\n            title: '视频▶️',\\n            img:data.thumb+lazy,\\n            url: data.media_url.replace(/\\\\/\\\\/.*play\\\\./,'//long.'),\\n            col_type: 'movie_3',\\n        });\\n       }else{\\n       d.push({\\n                img: data.media_url+lazy,\\r\\n                col_type: \\\"pic_3_card\\\",\\n                url : data.media_url,\\n       })\\n       }\\n      })\\n      tags.forEach(data => {\\n      d.push({\\n                title:data.tag,\\n                url: 'hiker://empty##fypage##'+data.category_id+'@rule=js:$.require(\\\"hiker://page/tags\\\")',\\n                col_type: 'flex_button'\\n      })\\n      })\\n      }\\n})\\n}catch{}\\nsetResult(d)\"},{\"col_type\":\"movie_3\",\"name\":\"动漫\",\"path\":\"cartoon\",\"rule\":\"js:\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar 动漫= [{title: '推荐&里番&3D动漫&Cosplay&肉番&H漫&原作&MMD&Motion Anime',key: '30&54&56&58&55&57&62&61&60'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(动漫,'动漫','scroll_button',d);\\n}\\nvar 动漫类= [{title: '最新&正在看&随机&最热',key: 'new&watching&rand&hot'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(动漫类,'动漫类','scroll_button',d);\\n}\\nvar data0 = '{\\\"app_type\\\":\\\"local\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"sort\\\":\\\"'+getMyVar('动漫类', 'new')+'\\\",\\\"app_from\\\":\\\"91lite\\\",\\\"token\\\":\\\"\\\",\\\"code\\\":\\\"getConstructById\\\",\\\"id\\\":\\\"'+getMyVar('动漫', '30')+'\\\",\\\"mod\\\":\\\"resources\\\",\\\"page\\\":\\\"'+pg+'\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0);\\ntry{\\nlet data= JSON.parse(html2).data;\\ndata.forEach(data => {\\nif((data.content_type!=11)&(data.content_type!=18)&(data.content_type!=21)&(data.content_type!=20)&(data.content_type!=8)&(data.content_type!=2)&(!data.title.includes('banner'))){\\n       d.push({\\r\\n                title: color(data.title),\\r\\n                col_type: \\\"text_icon\\\",\\n                img:'hiker://images/icon_right5',\\n                url :  'hiker://empty##fypage##'+data.id+'@rule=js:$.require(\\\"hiker://page/cartoonerji\\\")',\\n})\\nvar list=data.list;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: '🔥'+data.view_ct+'          '+ parseInt(data.duration/60)+':'+parseInt(data.duration%60),\\n            img: data.cover+lazy,\\n            url: data.id+vod,\\n        })\\n })\\n}\\n})\\n}catch{}\"},{\"col_type\":\"movie_2\",\"name\":\"动漫二级\",\"path\":\"cartoonerji\",\"rule\":\"js:\\nvar d=[];\\neval(JSON.parse(request('hiker://page/aes')).rule);\\nvar t = Math.floor(Date.now() / 1000); //log(t)\\nvar t0=Math.floor(Date.now());\\nvar id=MY_URL.split('##')[2];\\nvar pg=MY_URL.split('##')[1];\\nvar 动漫分类= [{title: '最新&正在看&随机&最热',key: 'new&watching&rand&hot'}];\\nif (MY_PAGE == 1) {\\n    $.require(\\\"Category\\\").Category(动漫分类,'动漫分类','scroll_button',d);\\n}\\nvar data0='{\\\"app_type\\\":\\\"local\\\",\\\"mod\\\":\\\"resources\\\",\\\"code\\\":\\\"getElementItembyId\\\",\\\"oauth_type\\\":\\\"android\\\",\\\"sort\\\":\\\"'+getMyVar('动漫分类', 'new')+'\\\",\\\"version\\\":\\\"6.5.0\\\",\\\"token\\\":\\\"\\\",\\\"app_status\\\":\\\"ED0AE2B720A20608E497D3E36E88029337C1C863:1\\\",\\\"oauth_id\\\":\\\"c8a3de61e45edd40cdd1e1e2820e942e\\\",\\\"page\\\":\\\"'+pg+'\\\",\\\"id\\\":\\\"'+id+'\\\",\\\"apiV2\\\":\\\"v2\\\",\\\"app_from\\\":\\\"91lite\\\"}';\\n//var url = 'https://api1.dspapi2.com/api.php';\\n//log(url)\\nlet html2 = post(getMyVar('host'),data0); \\ntry{\\nlet list= JSON.parse(html2).data.list;\\nlist.forEach(data => {\\n        d.push({\\n            title: data.title,\\n            desc: '🔥'+data.view_ct+'     '+ parseInt(data.duration/60)+':'+parseInt(data.duration%60)+'   '+data.tag,\\n            img: data.cover+lazy,\\n            url: data.id+vod,\\n        })\\n })\\n}catch{}\\nsetResult(d)\"}]","icon":"https://mogua.co/download/cc9c895f7971c23b32f642518bb10835-icon.png","proxy":""}
Add Comment
Please, Sign In to add comment
